Architecture Description Language Research Articles

Do the informal & formal software modeling notations satisfy practitioners for software architecture modeling?

ContextSoftware architectures can be modeled using semantically informal (i.e., ambiguous) or formal (i.e., mathematically precise) software modeling notations. ObjectiveIn this paper, 115 different practitioners from 28 different countries who work in companies that perform software development have been surveyed. The goal is to understand practitioners’ knowledge and experience about informal and formal modeling notations in specifying software architectures. MethodThe survey consists of 35 different questions, divided into three parts, i.e., the participant profile, the informal modeling, and formal modeling. The results of the survey lead to many interesting findings: Results(1) Informal software modeling notations (especially UML) are practitioners’ top choice in specifying software architectures (94%). (2) Despite many informal languages, some practitioners (40%) insist using informal ad-hoc techniques (i.e., simple boxes/lines and natural languages) to specify complex design decisions (e.g., structure, behaviour, and interaction). (3) Practitioners using informal notations are impressed by their low learning-curve (79%), visuality (62%), and general-purpose scope (66%). (4) Practitioners still criticise informal notations too, essentially for the lack of support for complex design decisions and their exhaustive analysis. (5) While formal modeling notations bridge this gap mentioned in step-4, many practitioners (70%) rarely use formal notations due essentially to the high-learning curve, the lack of knowledge among stakeholders, and the lack of popularity in industry. (6) Among the considered formal notations (i.e., process algebras, high-level formal specification languages, and architecture description languages (ADLs)), process algebras are never used and ADLs are the least used formal languages are ADLs (i.e., 12% frequently use ADLs). (7) Practitioners complain about ADLs’ weak tool support (38%) and their lack of tutorials/guidance/etc (33%). ConclusionThe survey results will let the community realise the advantages and disadvantages of informal and formal modeling notations for software architecture modeling from practitioners’ viewpoint.

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.

Analysis of the consistency of enterprise architecture models using formal verification methods

Э.А. Бабкин - кандидат технических наук, PhD in Computer Science, профессор кафедры информационных систем и технологий, Национальный исследовательский университет «Высшая школа экономики»Адрес: 603155, г. Нижний Новгород, ул. Большая Печерская, д. 25/20E-mail: eababkin@hse.ruН.О. Пономарев - студент магистерской программы «Бизнес-информатика», Национальный исследовательский университет «Высшая школа экономики»; инженер группы разработки программного обеспечения АО «Интел»Адрес: 603155, г. Нижний Новгород, ул. Большая Печерская, д. 25/20E-mail:nik4nikita@gmail.com Разработка архитектуры предприятия является сложным процессом, но в то же время позволяет решить проблему синхронизации возможностей и потребностей бизнеса и информационных технологий (ИТ). Решение данной проблемы достигается за счет уточнения понимания и формализации описания бизнес-процессов и взаимодействия элементов системы путем их формального описания. Наличие большого числа взаимодействующих бизнес-процессов и сущностей архитектуры предприятия объясняет необходимость проверки их корректности. Поэтому необходимо их автоматически верифицировать, на основе формализации требований к архитектуре. В данной работе предлагается метод обнаружения логических противоречий в моделях архитектуры предприятия, на основе частного случая подхода к проверке моделей, примененного в бизнес-моделировании. В качестве языка описания архитектуры предприятия в работе используется современный открытый и независимый язык ArchiMate. Разрабатываемый The Open Group стандарт предоставляет общую спецификацию для описания построения и функционирования бизнес-процессов, организационных структур, информационных потоков, ИТ-систем и технической инфраструктуры предприятия. В качестве верификатора выбран формальный язык реляционной логики и инструментарий системы MITAlloy Analyzer, позволяющий выполнять анализ ограничений модели в терминах реляционной логики путем автоматической генерации структур, которые удовлетворяют требованиям логической модели. В данной работе предлагается упростить и автоматизировать процесс спецификации и верификации моделей предметной области архитектуры предприятия с помощью визуального редактора конструирования моделей на языке ArchiMate - Archi. Разработанный авторами плагин к редактору осуществляет трансляцию моделей архитектуры предприятия на язык системы Alloy Analyzer и в качестве основы для построения конкретных моделей предметной области использует метамодель ключевых элементов спецификации ArchiMate. Предложенный метод и программные решения апробированы на примере пользовательского кейса архитектуры предприятия компании ArciSurance.Исследование выполнено при финансовой поддержке РФФИ в рамках научного проекта № 16-06-00184 А «Разработка и исследование моделей online-дискуссии на материале обсуждения политических новостей»

Visual Specification and Analysis of Contract-Based Software Architectures

XCD is a design-by-contract based architecture description language that supports modular specifications in terms of components and connectors (i.e., interaction protocols). XCD is supported by a translator that produces formal models in SPIN’s ProMeLa formal verification language, which can then be formally analysed using SPIN’s model checker. XCD is extended with a visual notation set called VXCD. VXCD extends UML’s component diagram and adapts it to XCD’s structure, contractual behaviour, and interaction protocol specifications. Visual VXCD specifications can be translated into textual XCD specifications for formal analysis. To illustrate VXCD, the well-known gas station system is used. The gas system is specified contractually using VXCD’s visual notation set and then formally analysed using SPIN’s model checker for a number of properties including deadlock and race-condition.

Safe adaptation of vehicle software systems

The promising advent of Fully Electric Vehicles (FEVs) also means a shift towards fully electrical control of the existing and new vehicle functions. In particular, critical X-by-wire functions require sophisticated redundancy solutions. As a result, the overall Electric/Electronic (E/E) architecture of a vehicle is becoming even more complex and costly. The SafeAdapt project provides an integrated approach for engineering such adaptive, complex and safe systems, ranging from tool chain support, reference architectures, system modeling and networking, up to early validation and verification. In this paper, we give an overview of the SafeAdapt project methodology. We also describe a particular aspect of the project which is the validation of the system adaptive behavior. To validate the adaptive behavior of a vehicle system, an architecture description language for automotive embedded systems (i.e. EAST-ADL) is used for designing the system. The system design model is then used for generating the embedded software. To ensure that the system behaves correctly at runtime, its adaptive behavior is analyzed using fault injection and monitoring techniques on a virtual platform.

Fine-Grained Checkpoint Recovery for Application-Specific Instruction-Set Processors

Checkpoint recovery (CR) is a classic fault-tolerance technique, which enables computing systems to execute correctly even when affected by transient faults. Although a number of software and hardware based approaches for CR does exist, these approaches usually are either too large, too slow, or require extensive modifications to the software and the caching/memory schemes. In this paper, we propose a novel CR approach, which is based on re-engineering the instruction set of a target processor. We take the base instruction set and augment the native micro-operations, i.e., an architectural description language (ADL), with additional micro-operations to perform checkpointing at the granularity of basic blocks. The recovery mechanism is realized by three custom instructions, which can undo the corruptions caused by transient faults during instruction execution, including the values of general-purpose registers, data memory, and special-purpose registers (PC, status registers, etc.), which were incorrectly modified. Our checkpoint storage is sized according to the application program executed. The experimental results show that our approach degrades the system performance by just 0.76 percent when there is no fault, and introduces an area overhead of 44 percent on average and 79 percent in the worst case. During the fault injection test with the benchmark applications, the recovery took just 62 clock cycles (worst case).

Architecture Evolution through Dynamic Reconfiguration in jADL

Abstract In software architecture the dynamic structure of a software system can be described in terms of components and connectors and expressed through the use of Architectural Description Languages (ADLs). We present jADL, a new ADL, designed for the creation and validation of dynamic and mobile architectures. It, also, aims to help towards the process of “unifying” the definition and implementation of an architecture in a way that the final result is consistent with the architecture in terms of both functional requirements and quality attributes. In this paper, we examine into details the definition and expression of jADL’s architectural elements; components, connectors, ports, roles and behaviour describing statements – attach, detach, config, bind. The attributes of synchronicity and multiplicity concerning the connections between architectural elements are presented. A special case of connections is presented – the bind statement and the construction of composite architectural elements. Also, a case study of the client-server dynamic model in jADL is presented and the possibilities of jADL for dynamic reconfiguration are explored.

An approach to modelling and analysing reliability of Breeze/ADL-based software architecture

Breeze/architecture description language (ADL), is an eXtensible markup language (XML) based architecture description language which is used to model software systems at the architecture level. Though Breeze/ADL provides an appropriate basis for architecture modelling, it can neither analyse nor evaluate the architecture reliability. In this paper, we propose a Breeze/ADL based strategy which, by combining generalized stochastic Petri net (GSPN) and tools for reliability analysis, supports architecture reliability modelling and evaluation. This work expands the idea in three directions: Firstly, we give a Breeze/ADL reliability model in which we add error attributes to Breeze/ADL error model for capturing architecture error information, and at the same time perform the system error state transition through the Breeze/ADL production. Secondly, we present how to map a Breeze/ADL reliability model to a GSPN model, which in turn can be used for reliability analysis. The other task is to develop a Breeze/ADL reliability analysis modelling tool---EXGSPN (Breeze/ADL reliability analysis modelling tool), and combine it with platform independent petri net editor 2 (PIPE2) to carry out a reliability assessment.

Compiling, verifying and simulating dynamic software architectures using ANTLR and coloured-ADL

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.

Compiling, verifying and simulating dynamic software architectures using ANTLR and coloured-ADL

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.

A smart mobile cloud environment for modelling and simulation of mobile cloud applications

Mobile cloud computing (MCC) has been introduced as an optimal solution to the constrained mobile devices. MCC takes mobile devices to a wholly new level where the latter rely on the cloud to store and process data. Since mobile cloud applications (MC-Apps) encompass more complicated features, they are considered as the next generation of mobile applications. Thereby new challenges arise in their development phase, such as exploiting the concept of mobility and contextual information. This new kind of applications requires new methods, of development, modelling and simulation. Addressing this lack in MCC, we propose in this paper a context-aware-based framework that allows: the description of MC-Apps' architecture with Mobile Cloud Architecture Description Language (MC-ADL); the simulation of MC-Apps' behaviour using mobile cloud simulation toolkit (MC-SIM); and the provision of a context-aware middleware: smart cloud gate (SCG) to ensure contextual configuration of the MC-Apps, and contextual evolution of its architecture.

XBreeze/ADL: A language for software architecture specification and analysis

Architecture description languages play an important role in modelling software architectures. However, many architecture description languages (ADLs) are either unable to deal with the verification and dynamic changes directly or too formal to be understood and manipulated. This paper presents xBreeze/ADL, a novel extensible markup language (XML)-based verification and evolution supported architecture description language, which is specifically designed for modelling the software architecture of large, complex systems. Five principle design goals are 1) to separate template from instance to define a loose coupling structure, 2) to present virtual and concrete link to identify service execution flow, 3) to clearly represent component behaviour to specify architecture semantics, 4) to introduce multi-dimension restrictions to define the architecture constraints, and 5) to use the graph transformation theory to implement the architecture configuration management (i.e., reconfiguration and verification). Various advanced features of xBreeze/ADL are illustrated by using an example on online movie ticket booking system.

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.

EAST-ADL

EAST-ADL is an Architecture Description Language (ADL) initially defined in several European-funded research projects and aligned with AUTOSAR and ISO26262. It provides a comprehensive approach for defining automotive electronic systems through an information model that captures engineering information in a standardized form. Aspects covered include vehicle features, requirements, analysis functions, software and hardware components and communication. The representation of the system's implementation is not defined in EAST-ADL itself but by AUTOSAR. However, traceability is supported from EAST-ADL's lower abstraction levels to the implementation level elements in AUTOSAR. In this article the authors describe EAST-ADL in detail, show how it relates to AUTOSAR as well as other significant automotive standards and present recent research work on using and advancing EAST-ADL, the functional safety standard ISO 26262, heterogeneous multi / many core architectures, security and for multi-objective optimization.

Using agent-based model to simulate stakeholder balance model of tourism intangible cultural heritage

Intangible cultural heritage, as one of the important cultural resources, is currently one of the most popular points for social scientific researchers. However, the intrinsic relationships between stakeholders related to tourism intangible cultural heritage including government, inheritors, enterprises, experts and tourists is hard to determine through social scientific approaches, especially, when we need to understand dynamic behavior. In this paper, we firstly use Breeze/ADL (Architecture Description Language) to model the intrinsic relationship between the stakeholders referring to tourism intangible cultural heritage. Secondly, we use ABM (Agent-Based Model) to simulate the interactions between stakeholders, in which path coefficient obtained from case studies is considered as an external objective. The results show that the environment revenue and enterprise revenue achieve optimum status when path coefficient and environment benefit are both set as external objectives. The results also imply that the construct stakeholder balance model of tourism intangible cultural heritage is reasonable and effective.

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.

UML-Based Development of Embedded Real-Time Software on Multi-Core in Practice: Lessons Learned and Future Perspectives

Model-driven engineering has got a foothold in industry as an effective way to tame the complexity of modern software, which is meant to run on embedded systems with real-time constraints by promoting abstraction, in terms of prescriptive models, and automation, in terms of model manipulations. In the plethora of modeling languages, the unified modeling language (UML) has emerged and established itself as a de facto standard in industry, the most widely used architectural description language and an ISO/IEC standard. In the SMARTCore project, we have provided solutions for the UML-based development of software to run on multicore embedded real-time systems with the specific focus of automating the generation of executable code and the optimization of task allocation based on a unique combination of model-based and execution-based mechanisms. In this paper, we describe the lessons learned in the research work carried out within SMARTCore and provide a set of perspectives that we consider to be highly relevant for the forthcoming future of this research area to enable a wider adoption of UML-based development in industry in general, and in the multicore embedded real-time domain in particular.

Formal Verification of Contractual Software Architectures using SPIN

Software architectures have become one of the most crucial aspects of software engineering. Software architectures let designers specify systems in terms of components and their relations (i.e., connectors). These components along with their relations can then be verified to check whether their behaviours meet designers’ expectations. XCD is a novel architecture description language, which promotes contractual specification of software architectures and their automated formal verifications in SPIN. XCD allows designers to formally verify their system specifications for a number of properties, i.e., (i) incomplete functional behaviour of components, (ii) wrong use of services operated by system components, (iii) deadlock, (iv) race-conditions, and (v) buffer overflows in the case of asynchronous (i.e., event-based) communications. In addition to these properties, designers can specify their own properties in linear temporal logic and check their correctness. In this paper, I discuss XCD and its support for formal verification of software architectures through a simple shared-data access case study.

An automatic process for weaving functional quality attributes using a software product line approach

Some quality attributes can be modelled using software components, and are normally known as Functional Quality Attributes (FQAs). Applications may require different FQAs, and each FQA (e.g., security) can be composed of many concerns (e.g., access control or authentication). They normally have dependencies between them and crosscut the system architecture. The goal of the work presented here is to provide the means for software architects to focus only on application functionality, without having to worry about FQAs. The idea is to model FQAs separately from application functionality following a Software Product Line (SPL) approach. By combining SPL and aspect-oriented mechanisms, we will define a generic process to model and automatically inject FQAs into the application without breaking the base architecture. We will provide and compare two implementations of our generic approach using different variability and architecture description languages: (i) feature models and an aspect-oriented architecture description language; and (ii) the Common Variability Language (CVL) and a MOF-compliant language (e.g., UML). We also discuss the benefits and limitations of our approach. Modelling FQAs separately from the base application has many advantages (e.g., reusability, less coupled components, high cohesive architectures).

Composing code generators for C&C ADLs with Application-specific behavior languages (tool demonstration)

Modeling software systems as component & connector architectures with application-specific behavior modeling languages enables domain experts to describe each component behavior with the most appropriate language. Generating executable systems for such language aggregates requires composing appropriate code generators for the participating languages. Previous work on code generator composition either focuses on white-box integration based on code generator internals or requires extensive handcrafting of integration code. We demonstrate an approach to black-box generator composition for architecture description languages that relies on explicit interfaces and exploits the encapsulation of components. This approach is implemented for the architecture modeling framework MontiArcAutomaton and has been evaluated in various contexts. Ultimately, black-box code generator composition facilitates development of code generators for architecture description languages with embedded behavior languages and increases code generator reuse.