A semantic file system is an information storage system that provides flexible associative access to the system's contents by automatically extracting attributes from files with file type specific transducers. Associative access is provided by a conservative extension to existing tree-structured file system protocols, and by protocols that are designed specifically for content based access. Compatibility with existing file system protocols is provided by introducing the concept of a virtual directory. Virtual directory names are interpreted as queries, and thus provide flexible associative access to files and directories in a manner compatible with existing software. Rapid attribute-based access to file system contents is implemented by automatic extraction and indexing of key properties of file system objects. The automatic indexing of files and directories is called "semantic" because user programmable transducers use information about the semantics of updated file system objects to extract the properties for indexing. Experimental results from a semantic file system implementation support the thesis that semantic file systems present a more effective storage abstraction than do traditional tree structured file systems for information sharing and command level programming.

. Teaching introductory computing courses with Scheme elevates the intellectual level of the course and thus makes the subject more appealing to students with scientific interests. Unfortunately, the poor quality of the available programming environments negates many of the pedagogic advantages. To overcome this problem, we have developed DrScheme, a comprehensive programming environment for Scheme. It fully integrates a graphics-enriched editor, a multi-lingual parser that can process a hierarchy of syntactically restrictive variants of Scheme, a functional read-eval-print loop, and an algebraically sensible printer. The environment catches the typical syntactic mistakes of beginners and pinpoints the exact source location of run-time exceptions. DrScheme also provides an algebraic stepper, a syntax checker and a static debugger. The first reduces Scheme programs, including programs with assignment and control effects, to values (and effects). The tool is useful for explaining the sem...

Program slicing is a technique for visualizing dependences and restricting attention to just the components of a program relevant to evaluation of certain expressions. Backward slicing reveals which other parts of the program the expressions' meaning depends on, while forward slicing determines which parts of the program depend on their meaning. Slicing helps programmers understand program structure, which aids program understanding, maintenance, testing, and debugging; slicing can also assist parallelization, integration and comparison of program versions, and other tasks. This paper improves previous techniques for static slicing. Our algorithm is expression-oriented rather than based on statements and variables, resulting in smaller slices. A user can slice on any value computed by the program---including ones that are not, or cannot be, assigned to variables. The slicer accounts for function calls, pointers, and aggregate structures. It takes advantage of compiler analyses and tran...

Proteus: An Adaptable Presentation System for a Software Development and Multimedia Document Environment by Ethan Vincent Munson Doctor of Philosophy in Computer Science University of California at Berkeley Professor Michael A. Harrison, Chair The many different documents produced by a large software project are typically created and maintained by a variety of incompatible software tools, such as programming environments, document processing systems, and specialized editors for non-textual media. The incompatibility of these tools hinders communication within the project by making it difficult to share the documents that record the project's plans, design history, implementations, and experiences. An important factor underlying this incompatibility is the diversity of presentation models that have been adopted. Each system's presentation model is well-suited to the document types and media it supports, but is difficult to adapt to other types and media. This dissertation describes a ne...

This thesis presents a new architecture for information discovery based on a hierarchy of content routers that provide both browsing and search services to end users. Content routers catalog information servers, which may in turn be other content routers. The resulting hierarchy of content routers and leaf servers provides a rich set of services to end users for locating information, including query refinement and query routing. Query refinement helps a user improve a query fragment to describe the user's interests more precisely. Once a query has been refined and describes a manageable result set, query routing automatically forwards the query to relevant servers. These services make use of succinct descriptions of server contents called content labels. A unique contribution of this research is the demonstration of a scalable discovery architecture based on a hierarchical approach to routing.

Every interactive system requires a presentation mechanism, to show the user the data it handles. Often, the relationship between the data and its presentation is complex; further, it is often mediated by astyle mechanism, allowing the user or a designer to describe how the data should be displayed. It is a standing engineering challenge to develop a presentation model that is exible, handling many kinds of data and layout; powerful, giving the user extensive control over appearance; and e cient enough for interactive work. In this dissertation, we propose a model of presentation by tree transformation. Because information often has a hierarchical logical structure, trees are widely used to represent documents and other data. The layout or presentation of a document is also often modeled as a computation over a tree. But these trees are not generally identical. In other words, presentation can be seen as a mapping between trees. Casting it as a formal tree transformation o ers both expressive, compact style speci cations and e cient implementation. We present a general framework for presentation by tree transformation. It has been implemented as part of Ensemble, a software development environment and multimedia document system

As digital video is manipulated by increasingly powerful computers, many new applications are becoming viable. This report investigates the programming language aspects of controlling such video applications. It presents the design, implementation, and use of PAVES, a direct manipulation system that combines aspects of visualization and multimedia systems to form an interactive video programming environment. PAVES is novel in the degree to which it emphasizes liveness and in its approach to extensibility. It extends the VuSystem media processing toolkit through flow graph and textual programming windows. Flow graph windows are used to control the media processing component of applications. Textual programming windows are used to issue interpreted commands and view source code. They work together to allow the user to combine methods as needed. While developing PAVES, I confronted a number of programming language issues related to the support of multiple program representations. I defined a cooperative model for translating across these representations and implemented the model by leveraging a presentation-style synchronization approach and Object Tcl, an object-oriented extension to the Tcl language.

As software projects continue to grow in scale and scope, it becomes important to reuse software. An important kind of reuse is extensibility, i.e., the extension of software without accessing existing code to edit or copy it. In this paper, we propose a rigorous, semantics-based definition of software extensibility. Then we illustrate the utility of our definitions by applying them to several programs. The examination shows how programming style affects extensibility and also drives the creation of a variant of an existing design pattern. We consider programs in both object-oriented and functional languages to prove the robustness of our definitions. 1 Introduction As software projects have continued to grow in scale and scope, it has become increasingly important to reuse program components. Reuse lowers software development costs by reducing development time, decreasing the number of errors, and increasing the consistency of software systems. In short, there are compelling reasons...

Abstract not found

The software development process generates a wide variety of artifacts. Supporting the management and editing of these artifacts in a single, tightly-integrated development environment is a widely shared goal. To support a software object means not only managing its evolution, representation and storage, but also its display and user interaction. To integrate support for the representation, display, and editing of all the objects in the development process, we regard objects as documents - structured compositions of primitive types. We present a document model for software development that accommodates textual documents in natural and formal languages, multimedia documents, and the results of programmatic analysis. We also present an architecture that supports presentation and editing of these documents, in such a way that the services for each primitive type are reusable in all classes of documents. This document architecture is implemented in a working prototype system, Ensemble. Our experiences with Ensemble provide solutions to some of the key architectural problems in integrated environments.