Multi-level Architectural Evolution Management

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 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.

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).

Self-adaptive systems evolve during system's execution against changes in operating environment. Such evolution and reconfiguration can be specified at architecture level using a syntactical expressive language such as Architecture Description Languages (ADLs). Variability modeling is an excellent instrument to model variations of software artifacts and their behavior within a self-adaptive system. However, existing ADLs that support dynamic reconfiguration do not explicitly model variation points on which the reconfiguration is based. This constitutes a barrier for a flexible management of reconfiguration at architecture level as well as traceability issues between a dynamic description given at architectural level and its counterpart at other abstraction levels. In this paper, we propose a variant-rich service-oriented ADL that enables system to reconfigure itself at runtime in response to a context change. To this end, our modular ADL, called Dynamic Service-Oriented Product Lines Architecture Description Language (DSOPL-ADL), specifies dynamic reconfigurations at architecture level besides specifying structural, variability and context information. Among several specified variable configurations at architecture level, one concrete configuration is generated at runtime triggered by a context value. Furthermore, an implementation code can be automatically generated from the architectural description.

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.

One of the main issue of software systems engineering is determining the overall system quality attributes at an early stage. This has several advantages such as early detection of problems, cost benefits and assuring that the chosen architecture will meet both functional and non-functional quality attributes. One emerging approach for dealing with such early analysis is to evaluate the system quality attributes at the architectural level. However, there is a notable lack of support for representing and reasoning about non functional attributes in existing Architectural Description Languages(ADLs). In this paper, we propose Acme+ as an extension of Acme ADL and discuss its abilities to represent and evaluate non functional attributes such as response time, throughput, failure probability, etc. We also describe a tool that reads a text file containing an architecture described in ACME+ and outputs the quality attributes of all the system and detects the component or the connector bottleneck.

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.

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 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.

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.

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.

Software architecture is widely recognized as one of the most fundamental concepts in software engineering, because of the fact, that today’s software systems are assembled from components with different characteristics: for example heterogenous, legacy or distributed systems. At the software architecture level, designers combine subsystems into complete systems using different techniques, e.g. “Architecture Description Languages” (ADLs). There exists a number of ADLs, each of which is specialized for one or more architectural styles. They are designed by different research groups with different goals in mind corresponding to their mental model on how software architecture can be expressed in the most efficient and elegant way. As a result, ADLs are not compatible with each other, so that it is difficult to present a homogeneous view of the software architecture of a system assembled from different components. This paper presents an approach how architectural styles can be combined using a concept of ADL-interchange.KeywordsSoftware ArchitectureDescription LanguageArchitectural StyleService LayerAbstract State MachineThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

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.

With increasing demands and changing environment on software systems, a major challenge for those systems is to evolve themselves to adapt to these variations, especially during their running, where dynamic evolution of software architectures has been a key issue of software dynamic evolution research. Most current research in this direction focuses on describing dynamic evolution process of software architectures, and lack consistency analysis of dynamic evolution of software architectures. In this paper, we propose to represent software architectures with constraint hypergraphs, model dynamic evolution of software architectures with constraint hypergraph grammars, and discuss the consistency condition and corresponding consistency decision method of dynamic evolution of software architectures. Our approach provides a formal theoretical basis and a user-friendly graphical representation for consistency analysis of dynamic evolution of software architectures.