Formal Architecture Description Languages Research Articles

A modeling approach for Systems-of-Systems by adapting ISO/IEC/IEEE 42010 Standard evaluated by Goal-Question-Metric

Context. Systems-of-Systems (SoS) constitute a new category of complex software systems resulting from the integration of independent heterogeneous systems. Each constituent system has its own purpose and could interact with other systems to achieve a common goal. SoS have specific characteristics, namely operational and managerial independence of constituent systems, geographic distribution, evolutionary development and emergent behaviors. Due to the complexity of SoS, their development demands special attention to their software architecture description. Objective. In this work, we aim to elaborate an approach for modeling SoS using an Architecture Description Languages (ADL) adequate with SoS' characteristics. In fact, many researches have addressed the problem of describing the software architecture of SoS. However, there is still a lack of ADL having the expressive power to describe SoS software architectures. Method. To address this problem, we proposed an approach based on the standard “ISO/IEC/IEEE 42010: Systems and software engineering- Architecture Description” to describe the software architectures of SoS. Then, we proposed improvements for this standard to be adequate with SoS characteristics. Finally, we conducted a qualitative study based on Goal-Question-Metric (GQM) with a focus group to evaluate the effectiveness of this work. Results. While applying our approach in an illustrative case study which is an SoS entitled Smart City, we modeled three viewpoints for our SoS, expressing its specific characteristics; structural viewpoint, behavioral viewpoint and requirement viewpoint. Each one of these viewpoints is illustrated via an architecture model modeled by multi-labeled graphs which represent an intuitive and formal ADL. The use of multi-labeled graphs allowed as to check the conformity of the obtained architecture models with design rules via the Graph Matching and Transformation Engine (GMTE). Conclusions. It is concluded that the proposed improvements for the standard are important to express specific characteristics of SoS. Moreover, our proposed formal ADL, entitled multi-labeled graphs, allows us to elaborate different models considering different viewpoints to describe the SoS' architecture. Finally, it is important to investigate larger SoS and to conduct a quantitative study to further evaluate the effectiveness of our approach. • Modeling System of Systems based on the standard ISO/IEC/IEEE 42010. • Improving the ISO/IEC/IEEE 42010 standard for System of Systems modeling. • System of Systems case study entitled “Smart City”. • Qualitative study based on Goal-Question-Metric (GQM).

Stimuli-SoS: a model-based approach to derive stimuli generators for simulations of systems-of-systems software architectures

BackgroundSystems-of-systems (SoS) are alliances of independent and interoperable software-intensive systems. SoS often support critical domains, being required to exhibit a reliable operation, specially because people’s safety relies on their services. In this direction, simulations enable the validation of different operational scenarios in a controlled environment, allowing a benchmarking of its response as well as revealing possible breaches that could lead to failures. However, simulations are traditionally manual, demanding a high level of human intervention, being costly and error-prone. A stimuli generator could aid in by continuously providing data to trigger a SoS simulation and maintaining its operation.MethodsWe established a model-based approach termed Stimuli-SoS to support the creation of stimuli generators to be used in SoS simulations. Stimuli-SoS uses software architecture descriptions for automating the creation of such generators. Specifically, this approach transforms SoSADL, a formal architectural description language for SoS, into dynamic models expressed in DEVS, a simulation formalism. We carried out a case study in which Stimuli-SoS was used to automatically produce stimuli generators for a simulation of a flood monitoring SoS.ResultsWe run simulations of a SoS architectural configuration with 69 constituent systems, i.e., 42 sensors, 9 crowdsourcing systems, and 18 drones. Stimuli generators were automatically generated for each type of constituent. These stimuli generators were capable of receiving the input data from the database and generating the expected stimuli for the constituents, allowing to simulate constituent systems interoperations into the flood monitoring SoS. Using Stimuli-SoS, we simulated 38 days of flood monitoring in little more than 6 h. Stimuli generators correctly forwarded data to the simulation, which was able to reproduce 29 flood alerts triggered by the SoS during a flooding event. In particular, Stimuli-SoS is almost 65 times more productive than a manual approach to producing data for the same type of simulation.ConclusionsOur approach succeeded in automatically deriving a functional stimuli generator that can reproduce environmental conditions for simulating a SoS. In particular, we presented new contributions regarding productivity and automation for the use of a model-based approach in SoS engineering.

RAMSES: A new reference architecture for self-adaptive middleware in Wireless Sensor Networks

Wireless Sensor Networks (WSNs) consist of networks composed of tiny devices equipped with sensing, processing, storage, and wireless communication capabilities. WSN nodes have limited computing resources and are usually powered by batteries. First generations of WSNs were designed to attend requirements of a unique target application usually with a single user, who was also the infrastructure owner. However, the rapid evolution in this area and the increasing of the complexity of the sensors and applications pose new challenges to WSN solutions, which can be addressed by specific middleware platforms for these networks. Existing middleware systems provide suitable mechanisms to define the high-level application logic and to deal with heterogeneity and distribution issues of WSN, but most of them do not provide explicit mechanisms to define the underlying autonomic behavior of the system, an essential feature of this kind of network. In this perspective, Autonomic Computing (AC) appears as a promising option to meet autonomic requirements in WSN middleware design. This paper presents the consolidated specification of RAMSES, a reference architecture of a self-adaptive middleware for WSNs. RAMSES was conceived in light of a well-stablished Reference Architecture Model, the RAModel. It follows the autonomic computing model MAPE-K, and presents a mapping of AC conceptual model to a set of software components. We claim that, with the aid of a middleware that supports the autonomic computing principles, a WSN becomes an autonomous WSN by design. RAMSES realizes our vision by providing: (i) an architectural template with core aspects of the self-adaptive systems from which is possible to build concrete middleware instances for self-adaptive WSNs, and (ii) a specification of the reference architecture using a formal architecture description language (Pi-ADL), which enables the representation of dynamic software architectures as required by WSNs. A scenario-based qualitative analysis and a checklist survey conducted with experts demonstrate the effectiveness of RAMSES. Moreover, a concrete WSN middleware instance derived from RAMSES was implemented as a proof of concept.

A Formal Architectural Description Language based on Symbolic Transition Systems and Modal Logic

Component Based Software Engineering has now emerged as a discipline for system development. After years of battle between component platforms, the need for means to abstract away from specific implementation details is now recognized. This paves the way for model driven approaches (such as MDE) but also for the more older Architectural Description Language (ADL) paradigm. In this paper we present KADL, an ADL based on the Korrigan formal language which supports the following features: integration of fully formal behaviours and data types, expressive component composition mechanisms through the use of modal logic, specification readability through graphical notations, and dedicated architectural analysis techniques. Key Words: Architectural Description Language, Component Based Software Engineering, Mixed Formal Specifications, Symbolic Transition Systems, Abstract Data Types, Modal Logic Glue, Graphical Notations, Verification.

Modeling and performance analysis for security aspects

The problem of effectively designing and analyzing software to realize non-functional requirements is an important research topic. The significant benefits of such work include detecting and removing defects earlier, reducing development time and cost while improving the system’s quality. The Formal Design Analysis Framework (FDAF) is an aspect-oriented approach that supports the design and analysis of multiple non-functional properties for distributed, real-time systems. In this paper, a security attribute, data origin authentication, is defined as a reusable aspect based on its security pattern definition. The FDAF provides a UML extension to weave the security aspect into a UML architecture design. This is accomplished by abstracting Aspect-Oriented Programming concepts join point and advice up to the design level. The FDAF supports the automated translation of a UML architecture design into Rapide [D.C. Luckham, J.J. Kenney, L.M. Augustin, J. Vera, D. Bryan, W. Mann, Specification and analysis of system architecture using Rapide, IEEE Transactions on Software Engineering 21 (4) (1995) 336–354], a formal architecture description language, allowing the simulation of a system’s response time. Thus, the response time of a design with and without the security aspect can be respectively analyzed, and the performance cost of this aspect can be predicted. One of the translation algorithms, which have been implemented in the FDAF tool support, and its proof are presented. The FDAF approach is illustrated using a Domain Name System example.

Formal modeling of the Enterprise JavaBeans™ component integration framework

An emerging trend in the engineering of complex systems is the use of component integration frameworks. Such a framework prescribes an architectural design that permits flexible composition of third-party components into applications. A good example is Sun Microsystems' Enterprise JavaBeans™ (EJB) framework, which supports object-oriented, distributed, enterprise-level applications, such as account management systems. One problem with frameworks like EJB is that they are documented informally, making it difficult to understand precisely what is provided by the framework, and what is required to use it. We believe formal specification can help, and in this paper show how a formal architectural description language can be used to describe and provide insight into such frameworks.

Robots

This paper presents an architectural style for real-time systems, and an associated formal architectural description language, called Robots. A basic specification in Robots consists of a synchronous control task that is responsible for the dynamic reconfiguration of the system controller as a set of asynchronous observer and process tasks. The controller architecture evolves by hierarchical refinement of observers and processes into lower level control tasks each dominating a new set of observers and processes. Robots is given operational semantics by statecharts. Also, the architectural style is embedded in Robots by semantic rules that allow formal checking of the consistency and completeness of architectural specifications.