Showing papers by "David Garlan published in 1997"

A formal basis for architectural connection

Abstract: As software systems become more complex, the overall system structure—or software architecture—becomes a central design problem. An important step toward an engineering discipline of software is a formal basis for describing and analyzing these designs. In the article we present a formal approach to one aspect of architectural design: the interactions among components. The key idea is to define architectural connectors as explicit semantic entities. These are specified as a collection of protocols that characterize each of the participant roles in an interaction and how these roles interact. We illustrate how this scheme can be used to define a variety of common architectural connectors. We further provide a formal semantics and show how this leads to a system in which architectural compatibility can be checked in a way analogous to type-checking in programming languages.

Architectural styles, design patterns, and objects

Abstract: Architectural styles, object-oriented design and design patterns all hold promise as approaches that simplify software design and reuse by capturing and exploiting system design knowledge. This article explores the capabilities and roles of the various approaches, their strengths and their limitations.

Specifying Dynamism in Software Architectures

Abstract: A critical issue for complex component-based systems design is the modeling and analysis of architecture. One of the complicating factors in developing architectural models is accounting for systems whose architecture changes dynamically (during run time). This is because dynamic changes to architectural structure may interact in subtle ways with on-going computations of the system. In this paper we argue that it is possible and valuable to provide a modeling approach that accounts for the interactions between architectural recon guration and non-recon guration system functionality, while maintaining a separation of concerns between these two aspects of a system. The key to the approach is to use a uniform notation and semantic base for both recon guration and steady-state behavior, while at the same time providing syntactic separation between the two. As we will show, this permits us to view the architecture in terms of a set possible architectural snapshots, each with its own steady-state behavior. Transitions between these snapshots are accounted for by special recon guration-triggering events.

Agents of change: educating software engineering leaders

Abstract: Most professional degree programs for software engineering focus on solving today's problems with today's technologies. Carnegie Mellon's Master of Software Engineering program takes a different approach, preparing engineers to work with new science and technology throughout their careers and helping them become agents of change in the industry. The approach aims to cultivate future leaders in software engineering. It combines a long-term, mentored software development project with an unusual core curriculum that stresses broad-based models and problem-solving skills.

Towards a Formal Treatment of Implicit Invocation

Abstract: : Implicit invocation SN92,GN91 has become an important architectural style for large-scale system design and evolution. This paper addresses the lack of specification and verification formalisms for such systems. A formal computational model for implicit invocation is presented. We develop a verification framework for implicit invocation that is based on Jones' rely/guarantee reasoning for concurrent systems Jon83,St(phi)91. The application of the framework is illustrated with several examples. The merits and limitations of the rely/guarantee paradigm in the context of implicit invocation systems are also discussed.

Modeling and simulating a software architecture design space

Abstract: Frequently, a similar type of software system is used in the implementation of many different software applications. Databases are an example. Two software development approaches are common to fill the need for instances from a class of similar systems: (1) repeated custom development of similar instances, one for each different application, or (2) development of one or more general purpose off-the-shelf systems that are used many times in the different applications. Each approach has advantages and disadvantages. Custom development can closely match the requirements of an application, but has an associated high development cost. General purpose systems may have a lower cost when amortized across multiple applications, but may not closely match the requirements of all the different applications. It can be difficult for application developers to determine which approach is best for their application. Do any of the existing off-the-shelf systems sufficiently satisfy the application requirements? If so, which ones provide the best match? Would a custom implementation be sufficiently better to justify the cost difference between an off-the-shelf solution? These difficult buy-versus-build decisions are extremely important in today's fast-paced, competitive, unforgiving software application market. In this thesis we propose and study a software engineering approach for evaluating how well off-the-shelf and custom software architectures within the design space of a class of OODB systems satisfy the requirements for different applications. The approach is based on the ability to explicitly enumerate and represent the key dimensions of commonality and variability in the space of OODB designs. We demonstrate that modeling and simulation of OODB software architectures can be used to help software developers rapidly converge on OODB requirements for an application and identify OODB software architectures that satisfy those requirements. The technical focus of this work is on the circular relationships between requirements, software architectures, and system properties such as OODB functionality, size, and performance. We capture these relationships in a parametrized OODB architectural model, together with an OODB simulation and modeling tool that allows software developers to refine application requirements on an OODB, identify corresponding custom and off-the-shelf OODB software architectures, evaluate how well the software architecture properties satisfy the application requirements, and identify potential refinements to requirements.

Formal Modeling and Analysis of the HLA RTI

Abstract: The HLA RTI is a complex artifact, supporting several classes of interaction (e.g., federation management, object management, time management). A critical challenge in producing an RTI architectural framework (and its associated simulation interface speci cations) is to develop con dence that its speci cation is well-formed and complete. In this paper we describe on-going work in formally modelling the HLA both to document the standard more precisely, as well as to analyze it for anomalies, omissions, inconsistencies, and ambiguities. The technical basis for this work is the use of a formal architectural description language, called Wright, and its accompanying toolset.

Architectural unification

Abstract: Many software designs are produced by combining and elaborating existing architectural design fragments. These fragments may be design patterns, partially thought-out ideas, or portions of some previously-developed system design. To provide mechanized support for this activity it is necessary to have a precise characterization of when and how two or more architectural fragments can be combined. In this paper we describe extensions to notations for software architecture to represent incomplete design fragments, and algorithms for combining fragments in a process analogous to unification in logic.

Coordination languages and models : Second International Conference COORDINATION '97, Berlin, Germany, September 1-3 1997 : proceedings

Abstract: From weaving threads to untangling the web: A view of coordination from Linda's perspective.- Exposing the skeleton in the coordination closet.- Design for open systems in Java.- Checking assumptions in component dynamics at the architectural level.- Security benefits from software architecture.- Regulated coordination in open distributed systems.- Debugging distributed applications using a coordination architecture.- Coordinating durative actions.- Communication-passing style for coordination languages.- Software architecture for large control systems: A case study description.- Evaluation of software architectures for a control system: A case study.- Modeling railway control systems using graph grammars: A case study.- On what Linda is: Formal description of Linda as a reactive system.- Three semantics of the output operation for generative communication.- Coordinating mobile agents via blackboards and access rights.- Modeling coordination via asynchronous communication.- Partial order and SOS semantics for linear constraint programs.- Programmable coordination media.- Safer tuple spaces.- Coordinating action systems.- Approximating unity.- Mobile UNITY coordination constructs applied to packet forwarding for mobile hosts.- From layer to layer - object-oriented protocol refinement in kannel.- An asynchronous model of locality, failure, and process mobility.- A component calculus for modeling the Olan configuration language.- A coordination model for distributed object systems.- Coordination patterns for parallel computing.- Concurrent Metatem as a coordination language.- Control-based coordination of human and other activities in cooperative information systems.- Using asynchronous tuple-space access primitives (Bonita primitives) for process co-ordination.- Berlinda: An object-oriented platform for implementing coordination languages in Java.