Structured Component and Connector Communication

Software architecture is high-level software design, dealing with the structure and organization of software systems. A software architecture is defined in terms of computational components and interactions among those components. Architecture description languages (ADLs) represent architecture-level software designs. Different ADLs often have different intents; e.g., Rapide supports architecture simulation and Acme is intended to be both an ADL and an ADL interchange format. Experimental applications of two ADLs were conducted to determine the effectiveness of ADLs for architecture-level analysis of simulation systems; one of them is reported. Acme was used to model the architecture of ModSAF and to analyze its run-time performance. The model was used to analyze execution time at the component and federate levels and to estimate the maximum number of internal and external simulation entities that could be supported by the ModSAF architecture. The experiment showed that ADLs could model important features of simulation system architectures.

In this article we contribute to the issue of the recent research work, in which software architecture is oriented more toward the OMG group. Thus, we try to map any ADL (Architecture Description Language) into MDA (Model Driven Architecture) platform. Our strategy is based on constructing a meta ontology that next can be used as a facade meta-model for semantic mapping of ADLs into MDA platforms. We show how this strategy can be used by mapping COSA architectural description concepts into CORBA. The goal of our work is to increase the high level of systems' concepts abstracting for wrapping and integrating heterogeneous software concepts into MDA platforms via a top-level ontology.

Software architecture is an important key that guarantees services and an effective analysis tool that ensures efficient verification properties of software systems. This is confirmed by using architecture description languages (ADL). The precise semantics of B method and its powerful data abstraction allow software architects to specify architectural elements behavior explicitly, to verify their semantics using powerful tools that are designed for the B method. In this paper, we define the behavioral aspects of software architecture using the B method. We use this formal method to define the behavioral aspects of COSA, which is a metamodel for software architecture. We also provide a B formal specification of the proposed aspects.

We present a novel architecture description language - OPNADL. The domain specific software architecture based on OPNADL is employed to guide the large-scale software development. OPNADL (object-oriented Petri nets architecture description language) is a graphical and mathematical modeling language, which can be used to describe static and dynamic semantics, and analyze the dynamic behavior of software system. The overall and individual characteristics of a system can be visually and intuitively depicted with the proposed OPNADL. Software architecture is conveniently constructed, refined and verified by OPNADL.

Research and experimentation in software architectures over the past decade (1992-2002) have yielded a plethora of software architecture description languages (ADLs). Continuing innovation indicates that it is reasonable to expect more new ADLs, or at least ADL features. This research process is impeded by the difficulty and cost associated with developing new notations. An architect in need of a unique set of modeling features must either develop a new architecture description language from scratch or undertake the daunting task of modifying an existing language. In either case, it is unavoidable that a significant effort will be expended in building or adapting tools to support the language. To remedy this situation, we have developed an infrastructure for the rapid development of new architecture description languages. Key aspects of the infrastructure are its XML-based modular extension mechanism, its base set of reusable and customizable architectural modeling constructs, and its equally important set of flexible support tools. The paper introduces the infrastructure and demonstrates its value in the context of several real-world applications.

Architecture description languages (ADLs) play an important role in specifying the software architectures. While most of these ADLs are unable to deal with the change directly, especially for dynamic evolution of software systems. This paper proposes an XML-based ADL, named Breeze/ADL, which is supported by Breeze Graph Grammar (BGG) - a graph grammar we defined, to describe software architecture and capture the change in the architecture definition. Our approach is explained in two directions. First, we give the basic definitions of Breeze/ADL, and then show how to map the BGG to Breeze/ADL to specify the structural model, style constraints and dynamic evolution. The other direction is that we use a Client/Server application as a running example to demonstrate our approach throughout this paper. In this approach, the software architecture description has both a textual and a graph representations, and the unplanned change can be captured and defined.

Software architecture research focuses on models of software architectures as specified in architecture description languages (ADLs). As research progresses in specific areas of software architectures, more and more architectural information is created. Ideally, this information can be stored in the model. An extensible modeling language is crucial to experimenting with and building tools for novel modeling constructs that arise from evolving research. Traditional ADLs typically support a small set of modeling constructs very well, but adapt to others poorly. XML provides an ideal platform upon which to develop an extensible modeling language for software architectures. Previous XML-based ADLs successfully leveraged XML's large base of off-the-shelf tool support, but did not take advantage of its extensibility. To give software architecture researchers more freedom to explore new possibilities and modeling techniques, while maximizing reuse of tools and modeling constructs, we have developed xADL 2.0, a highly extensible XML-based ADL. xADL 2.0 supports run-time and design time modeling, architecture configuration management and model-based system instantiation. Additionally, xADL 2.0 has a set of extensible infrastructure tools that support the creation, manipulation, and sharing of xADL 2.0 documents.

Software architectures may be described using text-based architecture description language(ADL). The key goals of an ADL are to communicate alternate designs between different stakeholders, to detect reusable structures, and to record design decisions. This paper provided a solution to the representation problem by creating a tool for three-dimensional representation of architectural viewpoints. The tool consisted of an architecture description language(VTADL) to first describe the software architectures and viewpoints on the architectures; and a VTADL-to-VRML translator to translate each viewpoint into a separate virtual reality world The goal of the paper was to devise algorithms for translating an ADL into effective VRML representations based on the desired viewpoint. The VRML representations were intended to enhance comprehension on the overall design and to improve communications between diverse stakeholders.

During this last decade, several architecture description languages (ADLs) have been proposed. These ADLs provide an adequate framework for the specification of software systems in terms of components and connectors. In this paper, we deal with an advanced facet of software architecture description. Our aim is to describe at the architectural level the separation of concerns. This is done in a formal way. Thus, we propose a model for architecture description based on the view concept.

Welcome you to the Fifth Edition of the track Software Architecture: Theory, Technology, and Applications (SA-TTA 2017) as part of the 32th ACM/SIGAPP Symposium on Applied Computing (SAC).

The concept of reconfigurable and dynamic software architecture (DSA) occupies today an important place in the field of software engineering. As result, several architecture description languages (ADLs) and approaches have been proposed for describing DSA in the highest level of abstraction. However, most of these works present theoretical solutions without giving an idea on the execution of final systems at run time. In this paper, we propose a new DSA called coloured software architecture (CSA) based on two concepts coloured operation and coloured connector. Then, we propose a new ADL called coloured-ADL and implement a compiling, verification and simulation tool dedicated to CSA. The simulation of system instances, derived from a CSA, is mainly used to explain coloured-ADL and evaluate the reliability of the simulated system. On the other hand, the verification is focused on checking a new defined safety property called architectural stack overflow (ASO). A safe CSA should be free of ASO violation property. To check a CSA, the verification uses also finite state processes (FSP) and labelled transition state (LTS) to expect this kind of property. We illustrate our propositions through two case studies from the literature.

Research in software architecture (SA) can be seen in two perspectives: a traditional and modern one. Software architecture is represented using graphical diagrams (Models, Frameworks) of the system, Architecture Description Languages, Ontology. The main focus of this paper is to know about the software architecture and to find out the strength of evidence in empirical work reported within literature. The outcome of this systematic literature review will be useful for researchers and practitioners and this SLR also includes widely used tools, models, and techniques used in SA; software architecture challenges/Issues widely reported; the SA areas which are under major consideration; the SA areas that require sufficient attention. In the end we also provide information model regarding requirements and architecture, which handles portability and contextual issues regarding platform dependency. Main purpose of information model is to facilitate practitioners for achieving traceability between requirements and architecture.

Software architecture involves a series of decisions based on many factors in a wide range of software development. Architects face recurring issues in different software architecture design, and to reduce huge cost and risks, software architecture decisions can rely on a set of idiomatic patterns commonly named architectural styles or patterns. Architectural pattern determines the vocabulary of components and connectors that are used in instances of the pattern together with a set of constraints to combine the two. Little contemporary data exists to document actual practices used by software professionals when selecting and incorporating architectural patterns for their projects in industry. Therefore, a comprehensive survey of software professionals was conducted to attempt to discover these practices. This exploratory survey and its quantitative results offer opportunities for further interpretation and comparison. Data from this survey are presented in this paper and include characteristics of projects, practices, organizations, and practitioners related to the usage of architectural patterns. Some of the notable findings include that architectural patterns are widely used in software projects with the Model–View–Controller being the most common. Despite reported difficulties in incorporating architectural patterns, the majority of the software professionals revealed that patterns were the most essential for completing the projects. The most difficult pattern to implement and the most expensive to adopt was the peer-to-peer, while the easiest was the client–server.

This paper presents a framework for generating assembler and disassembler from ADL (architecture description language), which enables processor architecture designers to explore a large design space by quickly modifying the architecture description written in high abstraction level ADL. We present our ADL: GADL(GNU tool chain based ADL) and propose the binary utilities generation algorithms for GADL. Some issues are discussed and resolved which have not been covered by related research. We have implemented the binary utilities generator with the proposed algorithms and used it to generate the binary utilities for a DSP we are designing, which shows the efficiency of the algorithms.

Software applications are continuing to grow at a rapid pace and became more and more complex. Thus, the use of software architectures in the development process is the ideal solution to deal with this issue. In this context, many Architecture Description Languages (ADLs) have been introduced to define the software architecture and its elements. Most of these ADLs do not address the dynamic behavior of the software architecture. This dynamic behavior is most commonly known as architectural reconfiguration. In our work, we use the Architecture Analysis and Design Language (AADL) due to its capacity to represent the architectural reconfiguration. However, AADL suffers from the absence of a concrete model to define its formal semantics. This paper presents a formal approach based on Bigraphical Reactive Systems (BRS) to model the dynamic architectural reconfiguration of embedded real-time systems expressed in AADL.