Coordination in a Reflective Architecture Description Language

Software architecture: TC2 first …, 1999

Software Architecture deals with the description, analysis and reuse of the structure of software systems. Several notations and languages for architectural specification have been recently proposed. However, some important aspects of composition, extension, and reuse deserve further research. These include language aspects, such as refinement of components and architectures, and also validation aspects, like analysis of compatibility among system components. These problems are particularly relevant in the context of open systems, where system structure can evolve dynamically, either by incorporating new components, or by replacing existing components with compatible ones. Our approach tries to address some of these open problems by combining the use of formal methods, particularly process algebras, with concepts coming from the object-oriented domain. In this paper we present LEDA, an Architecture Description Language for the specification, validation, prototyping and construction of dynamic software systems. Systems specified in LEDA can be checked for compatibility, ensuring that the behaviour of their components conforms to each other and that the systems can be safely composed. A notion of polymorphism of behaviour is used to extend and refine components while maintaining their compatibility, allowing the parameterisation of architectures, and encouraging reuse of architectural designs.

Electronic Notes in Theoretical Computer Science, 2005

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.

Science of Computer Programming, 2006

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.

Proceedings of the third international workshop on Software architecture - ISAW '98, 1998

This paper explores some issues in the expressiveness of Architecture Description Languages (ADLs) based on our work architecting large, software-intensive systems for command and control and related domains. We briefly outline and motivate several cases where current ADLs lack architecturally useful forms of expression and suggest approaches to addressing some of these cases. 1 Architectural Description Architects don't make architectures, they make representations of architectures. Architectural description-the means to record architectural information in a form such that it may be used (communicated, analyzed, manipulated) and re-used-is central to the emerging practice of software systems architecture. Interest in architectural description has taken various forms. One active area of current research is architecture description languages (ADLs) as witnessed by: • a proliferation of ADLs, such as: Acme, Darwin, LILE-Anna, MetaH, QAD, Rapide, UniCON, and Wright; and investigations into exploiting other notations (e.g., Unified Modeling Language) for architectural use [18];

Proceedings of the 2006 …, 2006

In this paper, we propose a new UML2.0 profile to describe the change of software architectures. The profile introduces a set of stereotypes for modeling the structural and the dynamic aspect as well as architectural constraints. We adapt the component diagrams metamodel on specific purposes by extending existing metaclasses. The adaptations are defined using stereotypes which are grouped in a profile. The profile offers to the architects an intuitive and complete way to specify the software architecture based on visual notations.

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 Architecture Description Languages (ADLs) field has also evolved considerably, providing numerous approaches to the formal specification and representation of architectural designs. However, relatively little work has been done in how architectural representations can be mapped to implementation code. In this paper we present a methodology for mapping the code written in ACME, a state-of-the-art ADL, down to executable code. The mapping process involves the use of the coordination paradigm. 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 assisting significantly the programmer in filling in the rest of the needed code.

2009

Abstract Software architecture plays a prominent role for designing increasingly complex distributed systems. The way an architecture is described is an important aspect of constructing a software architecture. The current state-of-the-art prescribes structuring an architectural description according to multiple models grouped into views, each covering a related set of stakeholder concerns.

ACM SIGSOFT Software Engineering Notes, 1997

Software architectures shift developers' focus from lines-of-code to coarser-grained architectural elements and their interconnection structure. Architecture description languages (ADLs) have been proposed as modeling notations to support architecture-based development. There is, however, little consensus in the research community on what is an ADL, what aspects of an architecture should be modeled in an ADL, and which ADL is best suited for a particular problem. Furthermore, the distinction is rarely made between ADLs on one hand and formal specification, module interconnection, simulation, and programming languages on the other. This paper attempts to provide an answer to these questions. It motivates and presents a definition and a classification framework for ADLs. The utility of the definition is demonstrated by using it to differentiate ADLs from other modcling notations. The framework is used to classify and compare several existing ADLs.

Proceedings of the 21st international conference on Software engineering - ICSE '99, 1999

Software architectures have the potential to substantially improve the development and evolution of large, complex, multilingual , multi-platform, long-running systems. However, in order to achieve this potential, specific techniques for architecture-based modeling, analysis, and evolution must be provided. Furthermore, one cannot fully benefit from such techniques unless support for mapping an architecture to an implementation also exists. This paper motivates and presents one such approach, which is an outgrowth of our experience with systems developed and evolved according to the C2 architectural style. We describe an architecture description language (ADL) specifically designed to support architecturebased evolution and discuss the kinds of evolution the language supports. We then describe a component-based environment that enables modeling, analysis, and evolution of architectures expressed in the ADL, as well as mapping of architectural models to an implementation infrastructure. The architecture of the environment itself can be evolved easily to support multiple ADLs, kinds of analyses, architectural styles, and implementation platforms. Our approach is fully reflexive: the environment can be used to describe, analyze, evolve, and (partially) implement itself, using the very ADL it supports. An existing architecture is used throughout the paper to provide illustrations and examples.

Journal of Systems and Software, 2010

Managing the architectural description (AD) of a complex software system and maintaining consistency among the different models is a demanding task. To understand the underlying problems, we analyze several non-trivial software architectures. The empirical study shows that a substantial amount of information of ADs is repeated, mainly by integrating information of different models in new models. Closer examination reveals that the absence of rigorously specified dependencies among models and the lack of support for automated composition of models are primary causes of management and consistency problems in software architecture. To tackle these problems, we introduce an approach in which compositions of models, together with relations among models, are explicitly supported in the ADL. We introduce these concepts formally and discuss a proof-of-concept instantiation of composition in xADL and its supporting tools. The approach is evaluated by comparing the original and revised ADs in an empirical study. The study indicates that our approach reduces the number of manually specified elements by 29%, and reduces the number of manual changes to elements for several realistic change scenarios by 52%.