Showing papers by "David Garlan published in 2002"

Documenting Software Architectures: Views and Beyond

Abstract: This lecture maps the concepts and templates explored in this tutorial with well-known architectural prescriptions, including the 4+1 approach of the Rational Unified Process, the Siemens Four Views approach, and the ANSI/IEEE-1471-2000 recommended best practice for documenting architectures for software-intensive systems. The lecture concludes by re-capping the highlights of the tutorial, and asking for feedback.

Project Aura: toward distraction-free pervasive computing

Abstract: The most precious resource in a computer system is no longer its processor, memory, disk, or network, but rather human attention. Aura aims to minimize distractions on a user's attention, creating an environment that adapts to the user's context and needs. Aura is specifically intended for pervasive computing environments involving wireless communication, wearable or handheld computers, and smart spaces. Human attention is an especially scarce resource in such environments, because the user is often preoccupied with walking, driving, or other real-world interactions. In addition, mobile computing poses difficult challenges such as intermittent and variable-bandwidth connectivity, concern for battery life, and the client resource constraints that weight and size considerations impose. To accomplish its ambitious goals, research in Aura spans every system level: from the hardware, through the operating system, to applications and end users. Underlying this diversity of concerns, Aura applies two broad concepts. First, it uses proactivity, which is a system layer's ability to anticipate requests from a higher layer. In today's systems, each layer merely reacts to the layer above it. Second, Aura is self-tuning: layers adapt by observing the demands made on them and adjusting their performance and resource usage characteristics accordingly. Currently, system-layer behavior is relatively static. Both of these techniques will help lower demand for human attention.

Aura: an Architectural Framework for User Mobility in Ubiquitous Computing Environments

Abstract: Ubiquitous computing poses a number of challenges for software architecture. One of the most important is the ability to design software systems that ac- commodate dynamically-changing resources. Resource variability arises natu- rally in a ubiquitous computing setting through user mobility (a user moves from one computing environment to another), and through the need to exploit time-varying resources in a given environment (such as wireless bandwidth). Traditional approaches to handling resource variability in applications attempt to address the problem by imposing uniformity on the environment. We argue that those approaches are inadequate, and describe an alternative architectural framework that is better matched to the needs of ubiquitous computing. A key feature of the architecture is that user tasks become first class entities. User proxies, or Auras, use models of user tasks to set up, monitor and adapt com- puting environments proactively. The architectural framework has been im- plemented and is currently being used as a central component of Project Aura, a campus-wide ubiquitous computing effort.

Model-based adaptation for self-healing systems

Abstract: Traditional mechanisms that allow a system to detect and recover from errors are typically wired into applications at the level of code where they are hard to change, reuse, or analyze. An alternative approach is to use externalized adaptation: one or more models of a system are maintained at run time and external to the application as a basis for identifying problems and resolving them. In this paper we provide an overview of recent research in which we use architectural models as the basis for such problem diagnosis and repair. These models can be specialized to the particular style of the system, the quality of interest, and the dimensions of run time adaptation that are permitted by the running system.

Increasing System Dependability through Architecture-Based Self-Repair.

Abstract: One increasingly important technique for improving system dependability is to provide mechanisms for a system to adapt at run time in order to accommodate varying resources, system errors, and changing requirements For such "self-repairing" systems one of the hard problems is determining when a change is needed, and knowing what kind of adaptation is required In this paper we describe a partial solution in which stylized architectural design models are maintained at run time as a vehicle for automatically monitoring system behavior, for detecting when that behavior falls outside of acceptable ranges, and for deciding on a high-level repair strategy The main innovative feature of the approach is the ability to specialize a generic run time adaptation framework to support particular architectural styles and properties of interest Specifically, a formal description of an architectural style defines for a family of related systems the conditions under which adaptation should be considered, provides an analytic basis for detecting anomalies, and serves as a basis for developing sound repair strategies

Software Architecture-Based Adaptation for Pervasive Systems

Abstract: An important requirement for pervasive computing systems is the ability to adapt at runtime to handle varying resources, user mobility, changing user needs, and system faults. In this paper we describe an approach in which dynamic adaptation is supported by the use of software architectural models to monitor an application and guide dynamic changes to it. The use of externalized models permits one to make reconfiguration decisions based on a global perspective of the running system, apply analytic models to determine correct repair strategies, and gauge the effectiveness of repair through continuous system monitoring. We illustrate the application of this idea to pervasive computing systems, focusing on the need to adapt based on performance-related criteria and models.

Exploiting architectural design knowledge to support self-repairing systems

Abstract: In an increasing number of domains software is now required to be self-adapting and self-healing. While in the past such abilities were incorporated into software on a per system basis, proliferation of such systems calls for more generalized mechanisms to manage dynamic adaptation. General mechanisms have the advantage that they can be reused in numerous systems, analyzed separately from the system being adapted, and easily changed to incorporate new adaptations. Moreover, they provide a natural home for encoding the expertise of system designers and implementers about adaptation strategies and policies. In this paper, we show how current software architecture tools can be extended to provide such generalized dynamic adaptation mechanisms.

A programming system for children that is designed for usability

Abstract: A programming system is the user interface between the programmer and the computer. Programming is a notoriously difficult activity, and some of this difficulty can be attributed to the user interface as opposed to other factors. Historically, the designs of programming languages and tools have not emphasized usability. This thesis describes a new process for designing programming systems where HCI knowledge, principles and methods play an important role in all design decisions. The process began with an exhaustive review of three decades of research and observations about the difficulties encountered by beginner programmers. This material was catalogued and organized for this project as well as for the benefit of other future language designers. Where questions remained unanswered, new studies were designed and conducted, to examine how beginners naturally think about and express problem solutions. These studies revealed ways that current popular programming languages fail to support the natural abilities of beginners. All of this information was then used to design HANDS, a new programming system for children. HANDS is an event-based system featuring a concrete model for computation based on concepts that are familiar to non-programmers. HANDS provides queries and aggregate operations to match the way non-programmers express problem solutions, and includes domain-specific features to facilitate the creation of interactive animations and simulations. In user tests, children using the HANDS system performed significantly better than children using a version of the system that lacked several of these features. This is evidence that the process described here had a positive impact on the design of HANDS, and could have a similar impact on other new programming language designs. The contributions of this thesis include a survey of the knowledge about beginner programmers that is organized for programming system designers, empirical evidence about how non-programmers express problem solutions, the HANDS programming system for children, a new model of computation that is concrete and based on familiar concepts, an evaluation of the effectiveness of key features of HANDS, and a case study of a new user-centered design process for creating programming systems.

Using Architectural Style as a Basis for System Self-repair

Abstract: An increasingly important requirement for software systems is the capability to adapt at run time in order to accommodate varying resources, system errors, and changing requirements For such self-repairing systems, one of the hard problems is determining when a change is needed, and knowing what kind of adaptation is required Recently several researchers have explored the possibility of using architectural models as a basis for run time monitoring, error detection, and repair Each of these efforts, however, has demonstrated the feasibility of using architectural models in the context of a specific style In this paper we show how to generalize these solutions by making architectural style a parameter in the monitoring/repair framework and its supporting infrastructure The value of this generalization is that it allows one to tailor monitoring/repair mechanisms to match both the properties of interest (such as performance or security), and the available operators for run time adaptation

Software architecture-based adaptation for Grid computing

Abstract: Grid applications must increasingly self-adapt dynamically to changing environments. In most cases, adaptation has been implemented in an ad hoc fashion, on a per-application basis. This paper describes work which generalizes adaptation so that it can be used across applications by providing an adaptation framework. This framework uses a software architectural model of the system to analyze whether the application requires adaptation, and allows repairs to be written in the context of the architectural model and propagated to the running system. In this paper, we exemplify our framework by applying it to the domain of load-balancing a client-server system. We report on an experiment conducted using our framework, which illustrates that this approach maintains architectural requirements.

Lightweight structure in text

Abstract: Pattern matching is heavily used for searching, filtering, and transforming text, but existing pattern languages offer few opportunities for reuse. Lightweight structure is a new approach that solves the reuse problem. Lightweight structure has three parts: a model of text structure as contiguous segments of text, or regions; an extensible library of structure abstractions (e.g., HTML elements, Java expressions, or English sentences) that can be implemented by any kind of pattern or parser; and a region algebra for composing and reusing structure abstractions. Lightweight structure does for text pattern matching what procedure abstraction does for programming, enabling construction of a reusable library. Lightweight structure has been implemented in LAPIS, a web browser/text editor that demonstrates several novel techniques: (1) Text constraints is a new pattern language for composing structure abstractions, based on the region algebra. Text constraint patterns are simple and high-level, and user studies have shown that users can generate and comprehend them. (2) Simultaneous editing uses multiple selections for repetitive text editing. Multiple selections are inferred from examples given by the user, drawing on the lightweight structure library to make fast, accurate, domain-specific inferences from very few examples. In user studies, simultaneous editing required only 1.26 examples per selection, approaching the 1-example ideal. (3) Outlier finding draws the user's attention to inconsistent selections or pattern matches—both possible false positives and possible false negatives. When integrated into simultaneous editing and tested in a user study, outlier finding reduced user errors. (4) Unix tools for structured text extend tools like grep and sort with lightweight structure, and the browser shell integrates a Unix command prompt into a web browser, offering new ways to build pipelines and automate web browsing. Theoretical contributions include a formal definition of the region algebra, data structures and algorithms for efficient implementation, and a characterization of the classes of languages recognized by algebra expressions. Lightweight structure enables efficient composition and reuse of structure abstractions defined by various kinds of patterns and parsers, bringing improvements to pattern matching, text processing, web automation, repetitive text editing, inference of patterns from examples, and error detection.

Documenting Software Architecture: Documenting Behavior

Abstract: : This report represents another milestone of a work in progress: a comprehensive handbook on how to produce high-quality documentation for software architectures. The handbook, tentatively titled Documenting Software Architectures, will be published in early 2002 by Addison-Wesley as part of the Software Engineering Institute (SEI) Series on Software Engineering. The book is intended to address a lack of language-independent guidance about how to capture an architecture in a written form that can provide a unified design vision to all of the stakeholders on a development project. A central precept of the book is that documenting an architecture entails two essential steps: 1) documenting the set of relevant views of that architecture and then completing the picture by 2) documenting information that transcends any single view. The book's audience is the community of practicing architects, apprentice architects, and developers who receive architectural documentation. This technical note describes ways to document an important but often overlooked aspect of software architecture: the behavior of systems, subsystems, and components.

Bridging the HLA: problems and solutions

Abstract: The High-Level Architecture (HLA) provides a common architecture for distributed modeling and simulation. In its original form, HLA allows a number of simulations to be joined together into a federation using a single run time infrastructure. Recently there has been interest in joining multiple federations together using a mediating unit, called an HLA "bridge." This paper presents the results of an in-depth study of the feasibility of an HLA bridge in the context of the current HLA interface specification. Problems and solutions are discussed and illustrated using particular HLA services.

A Practical Method for Documenting Software Architectures

Abstract: A practical approach for documenting software architectures is presented. The approach is based on the well-known architectural concept of views, and holds that documentation consists of documenting the relevant views and then documenting the information that applies to more than one view. Views can be usefully grouped into viewtypes, corresponding to the three broad ways an architect must think about a system: as a set of implementation units, as a set of runtime elements interacting to carry out the system’s work, and as a set of elements existing in and relating to external structures in its environment. A simple three-step procedure for choosing the relevant views to document is given, and applied to the problem of documentation for a large, complex NASA system.

Documenting Software Architecture: Documenting Interfaces

Abstract: : This is the fourth in a series of SEI reports on documenting software architectures. This report details guidance for documenting the interfaces to software elements. It prescribes a standard organization (template) for recording semantic as well as syntactic information about an interface. Stakeholders of interface documentation are enumerated, available notations for specifying interfaces are described, and three examples are provided.

Software Selection and Configuration in Mobile Environments: A Utility-Based Approach

Abstract: Users of low-power mobile computing platforms make ad hoc decisions when choosing software components among alternatives and configuring those components. We propose applying utility-theoretic models, which can help determine optimal allocation of scarce resources to applications given the user’s utility and application resource usage. We believe that taking into consideration resource consumption and applying microeconomic models has the potential of improving the user’s satisfaction with the system. In this paper, we formula te the problem, demonstrate the use of a microeconomics-based model on a simple version of the problem, and list possible solutions. Further, we identify issues typical of mobile environments that are not addressed by existing research, and propose ways of tackling these issues.