618088
Specifying and Analyzing Dynamic Software Architectures
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 reconfiguration and non-reconfiguration 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 reconfiguration 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 of possible architectural snapshots, each with its own steady-state behavior. Transitions between these snapshots are accounted for by special reconfiguration-triggering events.
9208543
Formalizing Architectural Connection
As software systems become more complex the overall system structure { or software architecture { becomes a central design problem. An important step towards an engineering discipline of software is a formal basis for describing and analyzing these designs. In this paper we present a theory for one aspect of architectural description: the interactions between components. The key idea is to de ne architectural connectors as explicit semantic entities. These are specied 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 de ne a variety of common architectural connectors. We provide a formal semantics and show how this leads to a sound deductive system in which architectural compatibility can be checked in a way analogous to type checking in programming languages.
14188317
Beyond Definition/Use: Architectural Interconnection
Large software systems require decompositional mechanisms in order to make them tractable. Traditionally, MILs and IDLs have played this role by providing notations based on definition/use bindings. In this paper we argue that current MIL/IDLs based on definition/use have some serious drawbacks. A significant problem is that they fail to distinguish between "implementation" and "interaction" relationships between modules. We propose an alternative model in which components interact along welldefined lines of communication -- or connectors. Connectors are defined as protocols that capture the expected patterns of communication between modules. We show how this leads to a scheme that is much more expressive for architectural relationships, that allows the formal definition of module interaction, and that supports its own form of automated checks and formal reasoning.
1741470
Architectural Mismatch or Why it's hard to build systems out of existing parts
Many would argue that future breakthroughs in software productivity will depend on our ability to combine existing pieces of software to produce new applications. An important step towards this goal is the development of new techniques to detect and cope with mismatches in the assembled parts. Some problems of composition are due to low-level issues of interoperability, such as mismatches in programming languages or database schemas. However, in this paper we highlight a different, and in many ways more pervasive, class of problem: architectural mismatch. Specifically, we use our experience in building a family of software design environments from existing parts to illustrate a variety of types of mismatch that center around the assumptions a reusable part makes about the structure of the application in which is to appear. Based on this experience we show how an architectural view of the mismatch problem exposes some fundamental, thorny problems for software composition and suggests possible research avenues needed to solve them.
15996696
Formal Connectors
As software systems become more complex the overall system structure --- or software architecture --- becomes a central design problem. An important step towards an engineering discipline of software is a formal basis for describing and analyzing these designs. In this paper we present a theory for one aspect of architectural description: the interactions between 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.
12180900
Towards Formalized Software Architectures
An important goal in software engineering is to describe complex software systems at an architectural level of abstraction. While there are many useful architectural paradigms (pipes, blackboards, etc.) they are typically understood only idiomatically and applied in an ad hoc fashion. We show how a formal model allows us to say precisely what we mean by a software architecture, explore its properties, and systematically describe instances of the architecture. We illustrate the approach using the well-known example of pipe-filter architectures.
17318100
Using an architecture description language for quantitative analysis of real-time systems
An architecture description language (ADL) specifies the structure of an overall system as an assembly of interacting components. ADLs can serve as input to a variety of development tools. We outline the Avionics Architecture Description Language, an emerging SAE standard for describing the architectures of hard real-time, safety-critical embedded computer systems. We describe a suite of tools that perform a set of verification, modeling and analysis, and implementation activities given an AADL specification. We summarize a study that applied these technologies using data about a complex avionics system, identifying and discussing some of the issues raised by this exercise.
33532247
Running an NSF REU program: observations, comments and suggestions
The Department of Computer Science at the University of Alabama, in conjunction with the National Science Foundation (NSF), offered a Research Experiences for Undergraduates (REU) program during the summer of 1991. This paper discusses the administration, structure, organization, and research efforts associated with this program.
19591181
RAVE: Real-Time Services for the Web
Abstract RAVE provides Web clients with real-time data services. Thus, RAVE supports live and stored video and audio as well as less typical real-time services such as MIDI and information services (e.g., news or stock market feeds). The system is extensible so that new real-time services can easily be added. RAVE has a flexible distribution architecture: it supports unicast and multicast, as well as both real-time data sources and sinks. RAVE integrates well into the Web so that many multimedia applications may be written using simple HTML extensions. We describe the RAVE architecture, the Web-client facilities that are required to support it, and three applications we have built using RAVE: a video library, a video mail system, and a video-conferencing tool.
44457281
An improved algorithm for relational distance graph matching
One of the problems in computer vision is to give a computer a representation of a scene and recognize the objects in the scene and their spatial relationships. This involves low-level vision (image processing), mid-level vision (feature extraction and measurement) and high-level vision (interpretation). One important part of high-level vision is relational matching, the process of matching two relational descriptions of objects, often for the purpose of object identification. This paper presents an improvement of the original method by Shapiro and Haralick for solving the relational distance graph matching problem for unlabeled graphs on a parallel computer.
11904917
Neuro-fuzzy closed-loop control of depth of anaesthesia
The utility of the auditory evoked potential (AEP) is under investigation as a feedback signal for the automatic closed-loop control of general anaesthesia using neural networks and fuzzy logic. The AEP is a signal derived from the electroencephalogram (EEG) in response to auditory stimulation, which may be useful as an index of the 'depth' of anaesthesia. A simple back-propagation neural network can learn the AEP and provides a satisfactory input to a fuzzy logic infusion controller for the administration of anaesthetic drugs, but the problem remains that of reliable signal acquisition.