A Framework for Developing and Analyzing Software Architecture Specifications in SAM

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.

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

: Architecture Description Languages provide significant opportunity for the incorporation of formal methods and engineering models into the analysis of software and system architectures. A standard is being developed for embedded real-time safety critical systems which will support the use of various formal approaches to analyze the impact of the composition of systems from hardware and software and which will allow the generation of system glue code with the performance qualities predicted. The standard the Avionics Architecture Description Language (AADL), is based on the MetaH language developed under DARPA and US Army funding and on the model driven architectural based approach demonstrated with this technology over the last 12 years. The AADL standard will include a UML profile useful for avionics, space, automotive, robotics and other real-time concurrent processing domains including safety critical applications.

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.

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.

Software architecture analysis plays an important role in software development lifecycle. However, from the view of separation of concerns, there is an absence of both structural description and behavioural analysis of software architecture. This paper proposes an aspect-oriented software architecture (AOSA) to reduce the complexity of software model and improve the reliability of software system. Aspect-oriented architecture description language based on XML is defined for structural description of software architecture, while aspect-oriented statechart and temporal logic are used for its behavioural analysis. A carousel case illustrates that the formal method is effective.

Software architecture has become an important area of research and practice since the late 1980s (Shaw and Clements 2006). The term “software architecture” started gaining acceptance by the software engineering community in early 1990s but the foundations of this field were laid by the seminal work of Edsger Dijkstra, David Parnas, and others between 1960s and 1980s (Clements 2000). The increasing size and complexity of software systems and demand for high quality are some of the most important factors that have driven the increased interest in this sub-discipline of software engineering. It has generally been realized that a high-level design description can play an important role in successfully understanding and managing large and complex software systems (Clements et al. 2002; Lung and Kalaichelvan 2000). The high-level design decisions regarding the software architecture of a system are not only the hardest and most expensive to change but also play a fundamental role in setting the boundaries for the required quality attributes such as maintainability, reliability, usability, performance, and flexibility of a system (Bass et al. 2003; Clement and Northorp 1996). As a result of increasing realization of the important role of software architecture in large-scale software development and evolution projects, the software architecture community has developed several methods, techniques, and tools to support the software Empir Software Eng (2011) 16:539–543 DOI 10.1007/s10664-011-9168-6

Software architecture is the foundation for the development of software systems. Its correctness is important to the quality of the software systems that have been developed based on it. Formally modeling and analyzing software architecture is an effective way to ensure the correctness of software architecture. However, how to effectively verify software architecture and use the results from formal modeling and analysis is important to the application of the approach. In this paper, software architecture is modelled using high level Petri nets, and the model is then checked with a model based testing tool called MISTA, and bounded model checking tool Alloy to ensure the correctness of the model. The approach is designed as a two-phase process consisting of model-based testing and bounded model checking to ensure it is both practical and rigorous for analyzing software architecture. We illustrated the idea and procedure via modeling and analyzing the Publish- Subscribe architecture. The result has shown that combining bounded model checking with model based testing is an effective extension to ensure the development quality.

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.

Agile practices have recently gained popularity among large number of companies as a mechanism for reducing cost and increasing ability to handle change in dynamic market conditions. Based on the principles of the Agile manifesto [1, 2], researchers and practitioners have proposed several software development approaches such as Extreme Programming, Scrum and Feature-Driven Development. These and other agile approaches have had significant impact on industrial software development practices. However, there is also a significant concern and perplexity about the role and importance of the issues related to a system’s software architecture, which is considered one of the most important initial design artefacts. It is argued that software architecture is an effective tool to cut development cost and time and to increase the quality of a system. Many practitioners of Agile approaches appear to view software architecture in the context of the plan-driven development paradigm [3]. For them, upfront design and evaluation of software architecture requires too much work, which may have very little value to the customers of a system. Hence, they perceive architectural work as part of high ceremony processes, which usually require large amount of documentation. We maintain that these two seemingly opposing views to software engineering can be integrated but it requires that experts from both fields work together to overcome evident challenges in bridging these two paradigms together. Indeed, software architecture researchers and practitioners appear to believe that sound architectural practices cannot be followed using Agile approaches. However, these two extreme views of Agile and architecture appear to neglect that many agile experts emphasises the importance of paying attention to good design and architecture early in the development process [4, 5]. Recently, there is growing recognition of the importance of paying more attention to architectural aspects in agile approaches [3, 6, 7]. We argue that there is a vital need for devising a research agenda for identifying and dealing with architecture-centric challenges in agile software development. Such research agenda should make it possible to guide the future research on integrating architecture-centric methods in agile approaches and give advice to the software industry on dealing with architecture related challenges. Some of the questions to stimulate discussion in the workshop are: What is the role of software architecture in Agile software development? What are the key architecture-centric challenges and potential solutions in Agile software development projects? What is the strength of the evidence that attention to architectural issues can be counterproductive in Agile development or vice versa? What are the prerequisites for integrating Architecture-Centric methods in agile development and potential implications of such integration?

Chapter 1 - Relating System Quality and Software Architecture: Foundations and Approaches

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

Regression testing can be systematically applied at the software architecture level in order to reduce the cost of retesting modified systems, and also to assess the regression testability of the evolved system. With the advent of model-based specification and analysis of software architectures, regression testing at the architectural level can be handled by analyzing how the architectural model evolves when moving from an initial to a subsequent version. This paper analyzes how model differencing, a recent research topic in the model-based community, can be employed for implementing model-based architecture-level regression testing.

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.