Showing papers on "Database-centric architecture published in 1997"

Software Architecture in Practice

Abstract: From the Book: Our goals for the first edition were threefold. First, we wanted to show through authentic case studies actual examples of software architectures solving real-world problems. Second, we wanted to establish and show the strong connection between an architecture and an organization's business goals. And third, we wanted to explain the importance of software architecture in achieving the quality goals for a system. Our goals for this second edition are the same, but the passage of time since the writing of the first edition has brought new developments in the field and new understanding of the important underpinnings of software architecture. We reflect the new developments with new case studies and the new understanding both through new chapters and through additions to and elaboration of the existing chapters. Architecture analysis, design, reconstruction, and documentation have all had major developments since the first edition. Architecture analysis has developed into a mature field with industrial-strength methods. This is reflected by a new chapter about the architecture tradeoff analysis method (ATAM). The ATAM has been adopted by industrial organizations as a technique for evaluating their software architectures. Architecture design has also had major developments since the first edition. The capturing of quality requirements, the achievement of those requirements through small-scale and large-scale architectural approaches (tactics and patterns, respectively), and a design method that reflects knowledge of how to achieve qualities are all captured in various chapters. Three new chapters treat understanding quality requirements, achieving qualities, and theattribute driven design (ADD) method, respectively. Architecture reconstruction or reverse engineering is an essential activity for capturing undocumented architectures. It can be used as a portion of a design project, an analysis project, or to provide input into a decision process to determine what to use as a basis for reconstructing an existing system. In the first edition, we briefly mentioned a tool set (Dali) and its uses in the re-engineering context; in in this edition the topic merits its own chapter. Documenting software architectures is another topic that has matured considerably in the recent past. When the first edition was published, the Unified Modeling Language (UML) was just arriving on the scene. Now it is firmly entrenched, a reality reflected by all-new diagrams. But more important, an understanding of what kind of information to capture about an architecture, beyond what notation to use, has emerged. A new chapter covers architecture documentation. The understanding of the application of software architecture to enable organizations to efficiently produce a variety of systems based on a single architecture is summarized in a totally rewritten chapter on software product lines. The chapter reinforces the link between architecture and an organization's business goals, as product lines, based around a software architecture, can enable order-of-magnitude improvements in cost, quality, and time to market. In addition to the architectural developments, the technology for constructing distributed and Web-based systems has become prominent in today's economy. We reflect this trend by updating the World Wide Web chapter, by using Web-based examples for the ATAM chapter and the chapter on building systems from components, by replacing the CORBA case study with one on Enterprise JavaBeans (EJB), and by introducing a case study on a wireless EJB system designed to support wearable computers for maintenance technicians. Finally, we have added a chapter that looks more closely at the financial aspects of architectures. There we introduce a method--the CBAM--for basing architectural decisions on economic criteria, in addition to the technical criteria that we had focused on previously. As in the first edition, we use the architecture business cycle as a unifying motif and all of the case studies are described in terms of the quality goals that motivated the system design and how the architecture for the system achieves those quality goals. In this edition, as in the first, we were very aware that our primary audience is practitioners, so we focus on presenting material that has been found useful in many industrial applications, as well as what we expect practice to be in the near future. We hope that you enjoy reading it at least as much as we enjoyed writing it. 0321154959P12162002

Experiences with an architecture for intelligent, reactive agents

Abstract: This paper describes an implementation of the 3T robot architecture which has been under development for the last eight years. The architecture uses three levels of abstraction and description languages which are compatible between levels. The makeup of the architecture helps to coordinate planful activities with real-time behaviours for dealing with dynamic environments. In recent years, other architectures have been created with similar attributes but two features distinguish the 3T architecture: (1) a variety of useful software tools have been created to help implement this architecture on multiple real robots; and (2) this architecture, or parts of it, have been implemented on a variety of very different robot systems using different processors, operating systems, effectors and sensor suites.

An approach for quantitative analysis of application-specific dataflow architectures

Abstract: In this paper we present an approach for quantitative analysis of application-specific dataflow architectures. The approach allows the designer to rate design alternatives in a quantitative way and therefore supports him in the design process to find better performing architectures. The context of our work is video signal processing algorithms which are mapped onto weakly-programmable, coarse-grain dataflow architectures. The algorithms are represented as Kahn graphs with the functionality of the nodes being coarse-grain functions. We have implemented an architecture simulation environment that permits the definition of dataflow architectures as a composition of architecture elements, such as functional units, buffer elements and communication structures. The abstract, clock-cycle accurate simulator has been built using a multi-threading package and employs object oriented principles. This results in a configurable and efficient simulator. Algorithms can subsequently be executed on the architecture model producing quantitative information for selected performance metrics. Results are presented for the simulation of a realistic application on several dataflow architecture alternatives, showing that many different architectures can be simulated in modest time on a modern workstation.

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.

An approach to software architecture analysis for evolution and reusability

Abstract: Software evolution and reuse is more likely to receive higher payoff if high-level artifacts--such as architectures and designs--can be reused and can guide low-level component reuse. In practice, however, high-level artifacts are often not appropriately captured. This paper presents an approach to capturing and assessing software architectures for evolution and reuse. The approach consists of a framework for modeling various types of relevant information and a set of architectural views for reengineering, analyzing, and comparing software architectures. We have applied this approach to large-scale telecommunications systems, where the approach is useful to reveal areas for improvement and the potential for reuse.

Domains of concern in software architectures and architecture description languages

Abstract: Software architectures shift the focus of developers from lines-of-code to coarser-grained elements and their interconnection structure. Architecture description languages (ADLs) have been proposed as domain-specific languages for the domain of software architecture. There is still little consensus in the research community on what problems are most important to address in a study of software architecture, what aspects of an architecture should be modeled in an ADL, or even what an ADL is. To shed light on these issues, we provide a framework of architectural domains, or areas of concern in the study of software architectures. We evaluate existing ADLs with respect to the framework and study the relationship between architectural and application domains. One conclusion is that, while the architectural domains perspective enables one to approach architectures and ADLs in a new, more structured manner, further understanding of architectural domains, their tie to application domains, and their specific influence on ADLs is needed.

Analysing the behaviour of distributed software architectures: a case study

Abstract: A software architecture is the overall structure of a system in terms of its constituent components and their interconnections. We describe work to associate behavioural specifications with the components of a distributed software architecture and an approach to analysing the behaviour of systems composed from these components. The approach is based on the use of labelled transition systems to specify behaviour and compositional reachability analysis to check composite system models. The architecture description of a system is used directly to generate the model used for analysis. Analysis allows a designer to check whether an architecture satisfies the properties required of it. The approach is illustrated using a case study of an active badge system.

Issues in the Runtime Modification of Software Architectures

Abstract: Existing software architecture research has focused on static architectures, where the system architecture is not expected to change during system execution. We argue that the architectures of many systems, especially long running or mission critical systems, evolve during execution, and thus cannot be accurately modeled and analyzed using static architectures. To overcome these problems, we propose the use of dynamic architectures, where the system architecture may change during execution. In this paper, we identify the issues involved in supporting dynamic architectures. Although some of these issues may be addressed by augmenting current models (i.e., adding constructs that support dynamism to existing architectural description languages), many are new to dynamic architectures (i.e., runtime support for modifying architectures). We describe an initial implementation of our tool, ArchShell, that supports the runtime modification of C2-style software architectures.

The role of cognitive architecture in modeling the user: Soar's learning mechanism

Abstract: What is the role of a cognitive architecture in shaping a model built within it? Compared with a model written in a programming language, the cognitive architecture offers theoretical constraints. These constraints can be "soft," in that some ways of constructing a model are facilitated and others made more difficult, or they can be "hard," in that certain aspects of a model are enforced and others ruled out. We illustrate a variety of these possibilities. In the case of Soar, its learning mechanism is sufficiently constraining that it imposes hard constraints on models constructed within it. We describe how one of these hard constraints deriving from Soar's learning mechanism ensures that models constructed within Soar must learn a display-based skill and, other things being equal, must find display-based devices easier to learn than keyboard-based devices. We discuss the relation between architecture and model in terms of the degree to which a model is "compliant" with the constraints set by the architecture. Although doubts are sometimes expressed as to whether cognitive architectures have any empirical consequences for user modeling, our analysis shows that they do. Architectures play their part by imposing theoretical constraints on the models constructed within them, and the extent to which the influence of the architecture shows through in the model's behavior depends on the compliancy of the model.

Coming attractions in software architecture

Abstract: Software architecture has emerged as an important topic in software engineering. This paper examines what is new about the subject, and what is not, and what research trends we may expect in the future. We discuss the promise that work in the field holds, and organize the work into five predominant themes: selection, representation, evaluation, development, and recovery. Technology for the formal representation of architectures is examined in detail, along with notions of architectural styles and patterns. The paper begins by examining the range of meanings associated with the term in order to provide a context for its treatment.

Dynamic control architecture for metamorphic control of advanced manufacturing systems

Abstract: While current research into decentralized control architectures for advanced manufacturing systems has proven the concept of architectures ranging from hierarchical to heterarchical control, neither extreme of the control architecture spectrum has proven to be the most appropriate choice for given manufacturing systems. This paper reports on research into a control architecture that does show promise in this area: a hybrid control architecture consisting of elements of both hierarchical and heterarchical control architectures. First control architectural issues are considered. Next, the concepts of virtual control organizations and partial dynamic hierarchies are presented. The paper then concludes with a discussion of recent work on implementing partial dynamic hierarchies within real-time control constraints, using an agent-based architecture.

A Graphical Description Technique for Communication in Software Architectures

Abstract: A crucial aspect of the architecture of a software system is its decomposition into components and the specification of component interactions. In this paper we use an enhanced variant of Extended Event Traces [SHB96] as a graphical technique for the description of such component interactions. It allows us to define interaction patterns that occur frequently within an architecture, in the form of diagrams. The diagrams may be instantiated in various contexts, thus allowing reuse of interaction patterns. We present several examples to show the applicability of our notation. In addition, we provide a formal semantics for our graphical notation, based on sets of traces. Furthermore, we compare our approach to connector specifications in WRIGHT [AG94], another description language for component interaction in software architectures.

Declarative specification of software architectures

Abstract: Scaling formal methods to large, complex systems requires methods of modeling systems at high levels of abstraction. In this paper, we describe such a method for specifying system requirements at the software architecture level. An architecture represents a way breaking down a system into a set of interconnected components. We use architecture theories to specify the behavior of a system in terms of the behavior of its components via a collection of axioms. The axioms describe the effects and limits of component variation and the assumptions a component can make about the environment provided by the architecture. As a result of the method the verification of the basic architecture can be separated from the verification of the individual component instantiations. We present an example of using architecture theories to model the task coordination architecture of a multi-threaded plan execution system.

SHA: a design for parallel architectures?

Abstract: To enhance system performance computer architectures tend to incorporate an increasing number of parallel execution units. This paper shows that the new generation of MD4-based customized hash functions (RIPEMD-128, RIPEMD-160, SHA-1) contains much more software parallelism than any of these computer architectures is currently able to provide. It is conjectured that the parallelism found in SHA-1 is a design principle. The critical path of SHA-1 is twice as short as that of its closest contender RIPEMD-160, but realizing it would require a 7-way multiple-issue architecture. It will also be shown that, due to the organization of RIPEMD-160 in two independent lines, it will probably be easier for future architectures to exploit its software parallelism.

An Architecture for Complex Systems

Abstract: We demonstrate that both a logical and a mathematical approach is required to design an architecture which describes precisely the construction of complex systems. The key advantage of our architecture is that it not only describes the construction of hierarchical systems in a precise way, but that it also expresses the operations that carry out the structuring of system components in a precise way. The concept of a module is expressed within our architecture, so that we can provide reusability for the hierarchically structured system components.

A generic model for software architectures

Abstract: In other industries, the idea of build corporate culture by establishing a common level of "best practice" is widely known and used. The architecture concept directly supports this goal for our industry and can help us improve problem areas dominated by organizational and social issues, such as health care organizations, educational systems, and so on. Our proposed reference model for architecture specification and development is organized around a set of aspects that structure concepts and rules; these, in turn, specify a conceptual architecture. We have added principles and guidelines to the concepts and rules to give a more complete picture of the architecture and to provide a place to store and communicate successfully applied design patterns and other knowledge related to the architecture. Adding architectural elements is a step toward a more constructive type of architecture representation. Our current research is focused on further refining these concepts and developing a formal specification of the architecture reference model. We are continuing to test our ideas in case studies, such as applying our model to the OSCA architecture and the application machine concept. We are also developing a prototype architecture editor, and we are testing different tools to learn more about integrating them into a real infrastructure and to learn what typical services an infrastructure must provide.

Software Architectures and Design Patterns in Business Applications

Abstract: This report is a collection of papers that present the results of the research project ENTSTAND (development of a standard architecture for business information systems), which was sponsored by the "Bundesministerium fuer Bildung, Wissenschaft, Forschung und Technologie" (BMBF). This project was a joint effort of the Technical University of Munich and sd&m GmbH & Co. KG to capture the essentials of good business information systems design. One goal of this project was to extract and to document the design knowledge of sd&m in building large business information systems. The latter can be roughly characterized by: database oriented (mostly relational), mission critical, on-line transaction as well as batch processing systems. Part I gives an overview of several theoretical and pragmatic approaches at dealing with software architecture and discusses the latter's role within the software development process. Part II contains presentations of design patterns (in shortened versions) that have been derived from sd&m projects. The introductory three-layer-architecture serves as a kind of roadmap. The layers within this architecture are described as black-box components, which are then refined by pattern languages. These pattern languages cover the main technical aspects in the design of the individual layers: user interface design, decoupling of components, distribution, relational database access, and error handling. The work of Part III complements the pattern view on architecture by more formal ways of dealing with software architectures. The contributions address various approaches at defining description languages for (certain aspects of) software architecture, and aim at clarifying and formalizing important terms of software architecture as well as at providing a formal treatment of the latter. The complete technical report is available under http://www4.informatik.tu-muenchen.de/proj/arcus/TUM-I9746.html

Distributed Software Architectures

Abstract: We motivate the need for architectural description languages in general, concentrating on Darwin, an architectural description language specifically designed for the specification and construction of distributed software systems.

Creating reusable architectures: initial experience report

Abstract: Achieving systematic reuse of software designs requires the creation of a reusable software architecture. This paper describes initial experience of creating reusable architectures in the avionics domain. A case-study is presented which illustrates the RACE (Reusable Architecture Creation and Employment) process. In RACE, a variability analysis is used to identify possible variations in a family of systems, which then guides the creation of a generic architecture and a set of architectural "plug-ins." The paper concludes with a set of RACE guidelines which summarises our initial experience.

Conception and design of a RISC CPU for the use as embedded controller within a parallel multimedia architecture

Abstract: In this paper, the problem of defining a high performance control structure for a parallel motion estimation architecture for MPEG2 coding is addressed. Various design and architecture choices are discussed and the final architecture is described. It represents a combined MIMD-SIMD approach which is based on a small but efficient ASIP with subword parallelism.

A multi-agent architecture for situation awareness

Abstract: The paper describes an architecture of a system for assisting an aircraft crew in enhancing its situation awareness by creating a complete surveillance picture of the environment in real time. The architecture is based on the framework of the multi agent technology where tasks are solved cooperatively among heterogeneous intelligent agents; each performs one defined function. This architecture offers a number of advantages such as synergy, scalability, reusability, reliability.

Class-graph inference for adaptive programs

Abstract: Software generators can adapt components to changes in the architectures in which the components operate. The idea is to keep the architecture description separate and let the software generator mix it with specications of each component. Adaptation is done by regeneration: when the architecture changes, the components are regenerated. A software component will usually be written with a particular architecture in mind. This raises the question: how much has it committed to the particular structure of that architecture? To put it in a nutshell: How exible is a given software component? In this paper we study this question in the setting of Lieberherr’s adaptive programming. Lieberherr uses class graphs as the architecture and so-called adaptive programs as the software components. We present a polynomial-time class-graph inference algorithm for adaptive programs. The algorithm builds a representation of the set of class graphs with which a given adaptive program can work. It also decides if the set is non-empty, and if so it computes a particularly simple graph in the solution set. Several toy programs have been processed by a prototype implementation of the algorithm.

A quality-based analysis of architecture recovery environments

Abstract: Architecture recovery is a recent research area which aims at providing reverse engineering technologies to extract high-level architectural information from the source code of legacy systems. The authors review the main (only?) architecture recovery environments proposed thus far. The environments are analysed with respect to different quality attributes, and their features and limitations are discussed. This allows one to highlight problems yet to be addressed in the area and, for some of them, suggest possible alternatives. They believe that this analysis is useful for the design of more effective architecture recovery tools.

The integration of dissimilar control architectures for mobile robot applications

Abstract: This article discusses a dual architecture for autonomous mobile robots. The implementation application is an autonomous visual inspection system for waste stored in drums. We discuss the three main architectures commonly implemented on mobile robots. The various modules needed for the successful operation of a mobile robot are analyzed, and software and hardware requirements for each modules are noted. We make arguments as to which architecture is best suited for each component. From the results of this analysis, we propose a new dual architecture for autonomous mobile robots. Rather than developing a single hybrid architecture that has qualities of both behavioral and functional architectures, we have taken an approach that involves the integration of two distinct architectures. Next, we detail the implementation of the architecture of the robot, and the advantages of our architecture as it pertains to the integration of system components. System performance in the testing environment is discussed. © 1997 John Wiley & Sons, Inc.

NSA's MISSI Reference Architecture - Moving from Prose to Precise Specification

Abstract: We discuss the definition and modeling of reference of architectures, and the notion of conformance. NSA’s MISSI (Multilevel Information System Security Initiative) security reference architecture is used as an illustrative example.

Multi-neural Networks Hardware and Software Architecture: Application of the Divide To Simplify Paradigm DTS

Abstract: We present in this paper the implementation of the data driven method we called DTS (Divide to Simplify), that builds dynamically a Multi-Neural Network Architecture. The Multi-Neural Network architecture, we propose, solves a complex problem by splitting it into several easier problems. We have previously present a software version of the DTS multi-neural network architecture. The main idea of the DTS approach is to use a set of small and specialized mapping neural networks, or Slave Neural Networks (SNN), that are guided by a prototype based neural network, or Master Neural Network (MNN). In this paper, the MNN manages a set of hardware digital neural networks. Learning is performed in few milliseconds. We get a very good rate of classification when using the two spirals problem as a benchmark.

Defining a Security Reference Architecture

Abstract: This report discusses the definition and modeling of reference architectures that specify the security aspects of distributed systems. NSA''s MISSI (Multilevel Information System Security Initiative) security reference architecture is used as an illustrative example. We show how one would define such a reference architecture, and how one could use such a definition to model as well as check implementations for compliance with the reference. We demonstrate that an ADL should have not only the capability to specify interfaces, connections and operational constraints, but also to specify how it is related to other architectures or to implementations. A reference architecture such as MISSI is defined in Rapide [10] as a set of hierarchical interface connection architectures [9]. Each Rapide interface connection architecture is a reference architecture - an abstract architecture that allows a number of different implementations, but which enforces common structure and communication rules. The hierarchical reference architecture defines the MISSI policies at different levels - at the level of enclaves communicating through a network, at the level of each enclave being a local area network with firewalls and workstations and at the level of the individual workstations. The reference architecture defines standard components, communication patterns and policies common to MISSI compliant networks of computer systems. A network of computers may be checked for conformance against the reference architecture. The report also shows how one can generate architecture scenarios of networks of communicating computers. The scenarios are constructed as Rapide executable models, and the behaviors of the models can be checked for conformance with the reference architecture in these scenarios. The executable models demonstrate how the structure and security policies in the reference architecture may apply to networks of computers.