Software Architecture Description Research Articles

Multi-view Metamodeling of Software Architecture Behavior

Component based development is recognized now as a powerful tool to manage actual systems’ technological complexity. The success key factor of this discipline is the high level abstracting of systems’ structural and behavioral constituents. On the other hand, enhancing software architectures simplicity and clarity by separating several concerns is a useful technique to manage complexity. In order to have a complete system specification, a rigorous behavior description is needed. Behavioral concepts and their use in architectural specification are in a fast evolution and have become so numerous, so it becomes difficult to elicit and manage them. For these purposes, we present in this paper, a generalized meta-model of behavioral aspects, that indexes the various architectural behavior concepts in classes, in a generic way. To enable more sophisticated and consistent analysis of architecture behavior we have separated behavioral concepts into packages basing on four functional perspectives: interface, static behavior, dynamic behavior, and interaction protocols. We show that our proposed meta-model allows having a general, a unified and an adaptable view of behavioral concepts required in software architecture description from all functional viewpoints.

A modelling approach to service-oriented architecture

In recent years, with the rapid development of web-based technologies, considerable progress has been witnessed in service-oriented enterprise information systems. Currently a critical issue is to specify service-oriented systems for application design. This paper highlights the description problem of service-oriented architecture (SOA) and puts forward a modelling approach as solution. Different from the current SOA specification methods, we do not exclude the traditional software architecture description techniques and present an architecture description language named SO-ADL. Based on the analysis of the requirements for SOA modelling, some similar concepts are introduced as first-class modelling constructs including that of service component and connector, and some composite notions are defined for the architectural re-use as well. Furthermore, a role-driven dynamic mechanism is specified to support dynamic structure description in SOA since it is typical of the highly dynamic nature. Within the context of a travel reservation system application scenario, we demonstrate the usage and practicability of our approach based on web services.

Vérification formelle d'architectures logicielles à base d'UML

In spite of its expressive capacity, UML does not transport in itsef a a very precise semantics to describe software architectures. We recommend an opening of UML on the formal ADL Wright via our W-UML profile. Moreover, in order to more analyze architectural descriptions as Wright, we propose a systematic approach of translation of Wright towards Ada. This allows the use of the tools for formal verification of the concurrent programs associated Ada such as FLAVERS in order to analyze and reason formally on the architectures described initially in W-UML.

Worldwide collaborative efforts in plasma control software development

This presentation will describe the DIII-D collaborations with various tokamak experiments throughout the world which have adapted custom versions of the DIII-D plasma control system (PCS) software for their own use. Originally developed by General Atomics for use on the DIII-D tokamak, the PCS has been successfully installed and used for the NSTX experiment in Princeton, the MAST experiment in Culham UK, the EAST experiment in China, and the Pegasus experiment in the University of Wisconsin. In addition to these sites, a version of the PCS is currently being developed for use by the KSTAR tokamak in Korea. A well-defined and robust PCS software infrastructure has been developed to provide a common foundation for implementing the real-time data acquisition and feedback control codes. The PCS infrastructure provides a flexible framework that has allowed the PCS to be easily adapted to fulfill the unique needs of each site. The software has also demonstrated great flexibility in allowing for different computing, data acquisition and real-time networking hardware to be used. A description of the current PCS software architecture will be given along with experiences in developing and supporting the various PCS installations throughout the world.

Integrating and deploying a VOEvent service

AbstractThe NOAO VOEvent software components will provide a mechanism for publishing and general distribution of compliant VOEvents produced initially from Type Ia supernova event notifications from the NOAO ESSENCE survey, and eventually from any source of event notifications, to the astronomical community. We present a description of the NOAO VOEvent software architecture and components. We discuss technologies used, and provide a brief description of configuration and installation of the services and dependencies. (© 2008 WILEY‐VCH Verlag GmbH & Co. KGaA, Weinheim)

Engineering manufacturing control systems using PROSA and delegate MAS

This paper presents a systematic description of a reusable software architecture for multiagent systems in the domain of manufacturing control. The architectural description consolidates the authors' expertise in this area. Until now, the research has taken a manufacturing control perspective of multiagent systems. The research team has focused on providing benefits to the manufacturing control domain by designing a novel type of control system. This paper takes a software architectural perspective of multiagent manufacturing control. The systematic description specifies a software product line architecture for manufacturing control. The paper describes the assets of the software product line architecture and how these assets can be combined.

A TRANSLATOR OF SOFTWARE ARCHITECTURE DESIGN FROM SAM TO JAVA

A software architecture design has many benefits including aiding comprehension, supporting early analysis, and providing guidance for subsequent development activities. An additional major benefit is if a partial prototype implementation can be automatically generated from a given software architecture design. However, in the past decade less progress was made on automatically realizing software architecture designs. In this paper, we present a translator for automatically generating an implementation from a software architectural description. The implementation not only captures the functionality of the given architecture description, but also contains additional monitoring code for ensuring desirable behavior properties through runtime verification. Our method takes a software description written in SAM, a software architecture model integrating dual formal methods Petri nets and temporal logic, and generates ArchJava/Java/AspectJ code. More specifically, the structure of a SAM architecture description produces ArchJava code, the behavior models of components/connectors represented in Petri nets lead to plain Java code, and the property specifications defined in temporal logic generate AspectJ code; the above code segments are then integrated into Java code. An experimental result is provided.

A reconfiguration pattern for distributed embedded systems

A reconfiguration pattern for UML-based projects of embedded (real-time) systems is defined. It enables to set up hardware/software configurations, and to specify conditions and methods for dynamic reconfiguration. The reconfiguration pattern was inspired by the reconfiguration management solution of the Specification PEARL methodology, which is based on the standard for Multiprocessor PEARL whose original idea it was to extend the language to enable the programming of distributed real-time applications in PEARL. In Specification PEARL, the possibility for abstract descriptions of hardware and software architectures and for defining mappings from software to hardware components has been enhanced in correspondence with the standard. Here, a UML pattern for reconfiguration management in distributed embedded applications based on concepts from Specification PEARL is presented. Its behavioural, structural and functional aspects are outlined. It addresses stereotype entities from the Specification PEARL language, which were joined in a UML profile, and outlines the related reconfiguration management mechanisms, which were carried over to the mentioned UML pattern. The proposed reconfiguration pattern is to facilitate the development of distributed embedded application in UML with consistent and temporally predictable reconfiguration support. It should also support and enhance the applications’ flexibility and portability.

MDABench: Customized benchmark generation using MDA

This paper describes an approach for generating customized benchmark suites from a software architecture description following a Model Driven Architecture (MDA) approach. The benchmark generation and performance data capture tool implementation (MDABench) is based on widely used open source MDA frameworks. The benchmark application is modeled in UML and generated by taking advantage of the existing community-maintained code generation “cartridges” so that current component technology can be exploited. We have also tailored the UML 2.0 Testing Profile so architects can model the performance testing and data collection architecture in a standards compatible way. We then extended the MDA framework to generate a load testing suite and automatic performance measurement infrastructure. This greatly reduces the effort and expertise needed for benchmarking with complex component and Web service technologies while being fully MDA standard compatible. The approach complements current model-based performance prediction and analysis methods by generating the benchmark application from the same application architecture that the performance models are derived from. We illustrate the approach using two case studies based on Enterprise JavaBean component technology and Web services.

Direct Model Checking Matrix Algorithm

During the last decade, Model Checking has proven its efficacy and power in circuit design, network protocol analysis and bug hunting. Recent research on automatic verification has shown that no single model-checking technique has the edge over all others in all application areas. So, it is very difficult to determine which technique is the most suitable for a given model. It is thus sensible to apply different techniques to the same model. However, this is a very tedious and time-consuming task, for each algorithm uses its own description language. Applying Model Checking in software design and verification has been proved very difficult. Software architectures (SA) are engineering artifacts that provide high-level and abstract descriptions of complex software systems. In this paper a Direct Model Checking (DMC) method based on Kripke Structure and Matrix Algorithm is provided. Combined and integrated with domain specific software architecture description languages (ADLs), DMC can be used for computing consistency and other critical properties.

Moving architectural description from under the technology lamppost

In 2000, we published an extensive study of existing software architecture description languages (ADLs), which has served as a useful reference to software architecture researchers and practitioners. Since then, circumstances have changed. The Unified Modeling Language (UML) has gained popularity and wide adoption, and many of the ADLs we studied have been pushed into obscurity. We argue that this progression can be attributed to early ADLs’ nearly exclusive focus on technological aspects of architecture, ignoring application domain and business contexts within which software systems and development organizations exist. These three concerns – technology, domain, and business – constitute three “lampposts” needed to appropriately “illuminate” software architecture and architectural description.

The NBI control system for the TJ-II

A description of the control system software and hardware architecture for the TJ-II Neutral Beam Injectors is given. The platform chosen is VMEbus, with controller boards running OS9 (Microware) real-time operating system. Three VME crates house several boards for performing analogue signal acquisition, signal conditioning, analogue voltage generation, digital input detection and digital output generation. A specific timing system for the injectors has been developed. At present, a user interface for monitoring and programming purposes is provided by html pages, using a web server running under the OS9 operating system. A few subsystems are now using a graphical user interface built using the Java programming language.

Computer-aided dispatch system family architecture and verification: an integrated formal approach

Software architecture is an important level of description for software systems. Formal modelling techniques can be used to define and verify software architectures precisely. An integrated formal approach to the architecture modelling and verification of a computer-aided dispatch (CAD) system family, is presented. An incremental three-layer model, that is, architecture style layer, generic system layer and customised system layer, is presented to capture the design of the CAD system family. Critical CAD system properties in the architecture models are formally verified by using the state and event-based proof techniques of the underlying specification language. In summary, it is demonstrated that integrated formal techniques could be a good candidate for modelling and verifying various levels of descriptions of software architectures.

Formally modelling software architectures with the UML 2.0 profile for π-ADL

A key aspect of the design of any software system is its architecture. An architecture description, from a runtime perspective, should provide a formal model of the architecture in terms of components and connectors, their ports and behaviours, and how they are composed together. The Unified Modelling Language (UML) is widely used in the design of software systems and has recently been extended to better support software architecture description. This paper presents the UML 2.0 Profile for π-ADL, a novel ADL that has been designed in the ArchWare European Project. It briefly presents π-ADL and its UML 2.0 Profile, then it illustrates through a case study how the UML 2.0 Profile for π-ADL can be used for formally modelling software architectures. The toolset for supporting the UML 2.0 Profile for π-ADL is outlined: it supports architecture modelling, architectural behaviour animation, and model checking of architectural properties.

A Distributed Software Architecture Description Language Based on Attributed Grammar

A Distributed Software Architecture Description Language Based on Attributed Grammar

An implementation framework for Software Architectures based on the coordination paradigm

Software Architectures have evolved considerably over the last decade and, partly also due to the significant progress made in component-based development, have become a major subfield of Software Engineering. The associated field of Architecture Description Languages (ADLs) has also evolved considerably, providing numerous approaches to the formal specification and representation of architectural designs. In this field, one of its most interesting (and rather recent) aspects has been the exploration of different ways to map architectural specifications down to executable representations. In this paper, we present a methodology for mapping the generic features of any typical ADL to executable code. The mapping process involves the use of ACME, a generic language for describing software architectures, and the coordination paradigm. More to the point, we show how the core concepts of ACME can be mapped to equivalent executable code written in the coordination language Manifold. The result is the generation of skeletal code which captures and implements the most important system implementation properties of the translated architectural design, thus significantly assisting the programmer in filling in the rest of the needed code.

A Rewriting Semantics for a Software Architecture Description Language

Distributed and concurrent application invariably have coordination requirements. The design of those applications, composed by several (possibly distributed) components, has to consider coordination requirements comprising inter-component interaction styles, and intra-component concurrency and synchronization aspects. In our approach coordination aspects are treated in the software architecture level and can be specified in high-level contracts in CBabel ADL. A rewriting logic semantics for the software architecture description language CBabel is given, revisiting and extending previous work by some of the authors, which now includes a revision of the previous semantics and the addition of new features covering all the language. The CBabel tool is also presented. The CBabel tool is a prototype executable environment for CBabel, that implements the given CBabel's rewriting logic semantics and allows the execution and verification of CBabel descriptions in the Maude system, an implementation of rewriting logic. In this way, software architectures describing complex applications can be formally verified regarding properties such as deadlock and synchronization consistency in the software architecture design phase of its life cycle.

A comprehensive approach for the development of modular software architecture description languages

Research over the past decade has revealed that modeling software architecture at the level of components and connectors is useful in a growing variety of contexts. This has led to the development of a plethora of notations for representing software architectures, each focusing on different aspects of the systems being modeled. In general, these notations have been developed without regard to reuse or extension. This makes the effort in adapting an existing notation to a new purpose commensurate with developing a new notation from scratch. To address this problem, we have developed an approach that allows for the rapid construction of new architecture description languages (ADLs). Our approach is unique because it encapsulates ADL features in modules that are composed to form ADLs. We achieve this by leveraging the extension mechanisms provided by XML and XML schemas. We have defined a set of generic, reusable ADL modules called xADL 2.0, useful as an ADL by itself, but also extensible to support new applications and domains. To support this extensibility, we have developed a set of reflective syntax-based tools that adapt to language changes automatically, as well as several semantically-aware tools that provide support for advanced features of xADL 2.0. We demonstrate the effectiveness, scalability, and flexibility of our approach through a diverse set of experiences. First, our approach has been applied in industrial contexts, modeling software architectures for aircraft software and spacecraft systems. Second, we show how xADL 2.0 can be extended to support the modeling features found in two different representations for modeling product-line architectures. Finally, we show how our infrastructure has been used to support its own development. The technical contribution of our infrastructure is augmented by several research contributions: the first decomposition of an architecture description language into modules, insights about how to develop new language modules and a process for integrating them, and insights about the roles of different kinds of tools in a modular ADL-based infrastructure.

SoftArch/MTE: Generating Distributed System Test-Beds from High-Level Software Architecture Descriptions

Most distributed system specifications have performance benchmark requirements, for example the number of particular kinds of transactions per second required to be supported by the system. However, determining the likely eventual performance of complex distributed system architectures during their development is very challenging. We describe SoftArch/MTE, a software tool that allows software architects to sketch an outline of their proposed system architecture at a high level of abstraction. These descriptions include client requests, servers, server objects and object services, database servers and tables, and particular choices of middleware and database technologies. A fully-working implementation of this system is then automatically generated from this high-level architectural description. This implementation is deployed on multiple client and server machines and performance tests are then automatically run for this generated code. Performance test results are recorded, sent back to the SoftArch/MTE environment and are then displayed to the architect using graphs or by annotating the original high-level architectural diagrams. Architects may change performance parameters and architecture characteristics, comparing multiple test run results to determine the most suitable abstractions to refine to detailed designs for actual system implementation. Further tests may be run on refined architecture descriptions at any stage during system development. We demonstrate the utility of our approach and prototype tool, and the accuracy of our generated performance test-beds, for validating architectural choices during early system development.

Usefulness of Software Architecture Description Languages for Modeling and Analysis of Federates and Federation Architectures

Software architecture is high-level software design dealing with the structure and organization of large software systems. Architecture description languages (ADLs) are languages designed to represent software designs at the architecture level. ADLs are not widely used in the development of simulation systems. This research investigates the utility and effectiveness of ADLs for architecture-level design and analysis of simulation systems. Experimental applications of two ADLs to the specification and analysis of simulation architectures were conducted. Rapide was used to model the EnviroFed federation architecture and analyze data volume with and without interest management. Acme was used to model the ModSAF federate architecture and to analyze execution time at the component and federate levels in ModSAF. The experiments showed that ADLs could be used to discover important features of simulation system architectures.