Archele, a web based acquisition, search and retrieval system

The problem of filing and storing paper and electronic documents is of great concern for public administration as well as private companies. We introduce a system that allows acquisition of images by means of one or more computer equipped with scanners, and associated with metadata for the subsequent search for and storage of data in a Document Repository protected by a system of access control lists (ACL).The system we describe here allows filing, search and retrieval of millions of documents by means of web interfaces. The architecture is fully compliant with web standards and with its design principles. The system we describe is called ArchEle (in Italian, Archiviazione Elettronica)

Usenetfs: A Stackable File System for Large Article Directories

The Internet has grown much in popularity in the past few years. Numerous users read USENET newsgroups daily for entertainment, work, study, and more. USENET News servers have seen a gradual increase in the traffic exchanged between them, to a point where the hardware and software supporting the servers is no longer capable of meeting demand, at which point the servers begin 'dropping' articles they could not process. The rate of this increase has been faster than software or hardware improvements were able to keep up,resulting in much time and effort spent by administrators upgrading their news systems. One of the primary reasons for the slowness of news servers has been the need to process many articles in very large flat directories representing newsgroups such as control. cancel and misc.jobs.offered. A large portion of the resources is spent on processing articles in these few newsgroups. Most Unix directories are organized as a linear unsorted sequence of entries. Large news groups can have hundreds of thousands of articles in one directory, resulting in significant delays processing any single article. Usenetfs is a file system that rearranges the directory structure from being flat to one with small directories containing fewer articles. By breaking the structure into smaller directories, it improves the performance of looking for, creating, or deleting files, since these operations occur on smaller directories. Usenetfs takes advantage of article numbers; knowing that file names representing articles are composed of digits helps to bound the size of the smaller directories. Usenetfs improves overall performance by at least 22\%for average news servers; common news server operations such as looking up, adding, and deleting articles are sped up by as much as several orders of magnitude. Usenetfs was designed and implemented as a stackable Vnode layer loadable kernel module. It operates by 'encapsulating' a client file system with a layer of directory management. To the process performing directory operations through a mounted Usenetfs, all directories appear flat; but when inspecting the underlying storage that it manages, small directories are visible. Usenetfs is small and is transparent to the user. It requires no change to News software, to other file systems, or to the rest of the operating system. Usenetfs is more portable than other native kernel-based file systems because it interacts with the Vnode interface which is similar on many different platforms

A Novel, Tag-Based File-System

For decades, computer use has largely focused on managing and manipulating files-- creating and consuming media, browsing the web, software development, and even, with such systems as UNIX and Plan$9$, direct device access can largely be reduced to locating, creating, reading, and writing files. To facilitate these operations, developers have created a vast assortment of file-systems, each presenting a unique framework underlying nearly everything people do with a computer. For various reasons, these file-systems have historically represented only incremental improvements and alterations from their predecessors, leaving the basic design and interaction models relatively unchanged. Because of this, most common file-systems share a similar set of weaknesses and limitations, intrinsic to those models. As an attempt to break with these traditional shortcomings, the author has created STUFFS, a Semantically-Tagged Unstructured Future File-System. It is intended largely as a research platform for investigating fundamentally new ideas in storing, locating, managing, and otherwise manipulating files, their data, and their associated meta-data. As such, STUFFS does not claim to perfectly solve all of these problems -- rather, it serves as a proof-of-concept and testbed for a number of promising new approaches. Of these new features, users are likely most impacted by STUFFS\u27s titular tag-based structure, which spurns the traditional folder hierarchy in favor of a folksonomy inspired, tag-centric approach to file organization. While this change retains backwards compatibility, and is therefore fully usable as a traditional FS, it has profound impact on potential user interaction. In order to support this high level transition, STUFFS is implemented using a relational database for storage and tag-resolution, and, as an exciting side effect, it has gained proper transaction support and full ACID compliance

The Design of a High-Integrity Disk Management Subsystem

This dissertation describes and experimentally evaluates the design of the Logical Disk, a disk management subsystem that guarantees the integrity of data stored on disk even after system failures, while still providing performance competitive to other storage systems. Current storage systems that use the hard disk as storage medium, such as file systems, often do not provide sufficient protection against loss of data after a system failure. The designers of such systems are afraid that the amount of effort necessary for data protection would also result in too much loss of performance. The Logical Disk uses many different techniques to guarantee data integrity, including the support to execute multiple commands as one atomic action and avoiding `in-place updates' at all times. The techniques used to provide competitive performance include the technique of combining many, small write commands into one large, sequential, and thus efficient, write to disk, and clustering the data on disk continuously and automatically.Tanenbaum, A.S. [Promotor]Jonge, W. de [Copromotor

Abstract Porting the SGI XFS File System to Linux

In late 1994, SGI released an advanced, journaled file system called XFS on IRIX, their System-V-derived version of UNIX. Since that time, XFS has proven itself in production as a fast, highly scalable file system suitable for computer systems ranging from the desktop to supercomputers. In early 1999, SGI announced that XFS would be released under an open source license and integrated into the Linux kernel. In this paper, we outline the history of XFS, its current architecture and implementation, our porting strategy for migrating XFS to Linux, and future plans, including coordinating our work with the Linux hacker community. 1 Introduction to XFS In the early 1990’s, SGI realized its existing EFS (Extent File System) would be inadequate to support the new applicatio

Open Source Software Evolution and Its Dynamics

This thesis undertakes an empirical study of software evolution by analyzing open source software (OSS) systems. The main purpose is to aid in understanding OSS evolution. The work centers on collecting large quantities of structural data cost-effectively and analyzing such data to understand software evolution dynamics (the mechanisms and causes of change or growth). We propose a multipurpose systematic approach to extracting program facts (e. g. , function calls). This approach is supported by a suite of C and C++ program extractors, which cover different steps in the program build process and handle both source and binary code. We present several heuristics to link facts extracted from individual files into a combined system model of reasonable accuracy. We extract historical sequences of system models to aid software evolution analysis. We propose that software evolution can be viewed as Punctuated Equilibrium (i. e. , long periods of small changes interrupted occasionally by large avalanche changes). We develop two approaches to study such dynamical behavior. One approach uses the evolution spectrograph to visualize file level changes to the implemented system structure. The other approach relies on automated software clustering techniques to recover system design changes. We discuss lessons learned from using these approaches. We present a new perspective on software evolution dynamics. From this perspective, an evolving software system responds to external events (e. g. , new functional requirements) according to Self-Organized Criticality (SOC). The SOC dynamics is characterized by the following: (1) the probability distribution of change sizes is a power law; and (2) the time series of change exhibits long range correlations with power law behavior. We present empirical evidence that SOC occurs in open source software systems