Architecture Description Language Research Articles

Collaborative Solutions to Software Architecture Challenges Faced by IT Professionals

Software architecture serves as a crucial link between problem and solution domains in software systems. However, reliance on graphical artifacts for architecture design has limitations, especially in abstract analysis. To overcome these constraints, Architecture Description Languages (ADLs) offer a more formal approach. Yet, our research reveals that ADLs face numerous challenges, as identified through interviews, surveys, and community interactions. By mining content from various sources, including mailing lists and forums, we comprehensively explore the concerns of software engineers. Employing content mining, topic modeling, and grounded theory, we compile a database of real-world issues and solutions in software architecture. Comparing our findings with existing literature, we identify 17 primary issues faced by practitioners. We also compare our results with language models to ascertain areas of agreement and disagreement. Finally, we propose solutions for each identified issue to aid future analysts.

Requirements for Domain-Specific Language in Enterprise Architecture-based SDGs Orchestration

Coherence is a crucial issue in orchestrating Sustainable Development Goals (SDGs) at the society level. The various parties involved with different language standards further increase the complexity of communication. Enterprise Architecture (EA), which emphasizes consistency and coherence as the pillars of its concept, can be used to address coherence issues in the SDGs orchestration. This study aims to build a Requirements Framework for developing an architecture description language as a domain-specific language used for EA-based SDGs orchestration. To clarify the purpose of the research, a motivating scenario was built in the form of the SDGs Participation Platform (SDGs-PP). SDGs-PP becomes the context in which EA-based SDGs orchestration involves society-level actors (orchestrators) and enterprise-level actors (enterprise architects). This Requirement Framework is built using design science methodology as a part of ongoing research. The requirements consisting of context, concept, and collaboration domains and nine action requirements (elicit, separate, connect, classify, manifest, map, arrange, separate, and set up) were successfully formulated. The Context domain was developed from the ISO/IEC/IEEE 42010 standard. The Concept domain focuses on elaborating the SDGs means of implementation and the business ecosystem concept. The Collaboration domain discusses the separation in the model canvas between the enterprise and society domains. Apart from being used as a requirement framework for the meta-model development of an architecture description language, the results of this study can also be used further as a research framework in the domain of EA-based SDGs orchestration.

An architecture-oriented kansei engineering system for innovative long chi inkstone design

With more and more attention to people's psychological cognition and emotion in design, the concept of kansei engineering has been widely used in all kinds of product design. Based on the concepts and methods of kansei engineering, the research chooses the long chi inkstone as an example to seek a holistic explanation for the proposed architecture-oriented innovative system in obtaining a series of new design schemes. The system architecture integrates the design method of kansei engineering system into the structure-behavior coalescence (SBC) system architecture description language to show the behavior and components of product characteristics. A model of architecture-oriented kansei engineering long chi inkstone system specification was established. The model will clearly explain how the qualitative and quantitative methods are applied to determine the characteristics, process and kansei information of long chi inkstone design. The design specifications of long chi inkstone is described by the architecture-oriented kansei engineering system. The psychological kansei imagery of consumer groups are explored under the mode of qualitative analysis and quantitative research, and the design elements and details of physical properties of products are obtained. The aesthetic attributes of products are raised to a high level of respect for human nature and reflect its new value. The results indicate that the proposed architecture-oriented kansei engineering system in conjunction with a long chi inkstone design can help designers make the design more effectively than traditional design methods.

Verifying contracts among software components: An ontology-based approach

The goal of Component-Based Software Engineering (CBSE) is the development of software systems in terms of an assembly of pre-fabricated software components. One of the main aims of CBSE is to increase software reuse whereby a software component becomes part of different software systems. Verification is an important task that ensures contract conformance among components. However, current techniques for verification of component matching are poorly used in industry due to the fact that the use of these techniques is complex since they require specialized expertise. Also, the use of such techniques can be time-consuming. In this paper, we present Moctezuma, a framework for verifying the matching of software components that does not require the user possessing highly specialized skills and is able to check contract conformance of functional semantics aspects. Our approach relies on a core ontology of software components, which captures the concepts, properties, relationships, requirements, and software component functionality. We make use of architecture description languages (ADLs) to specify configurations of component interconnections. Interface contracts are specified with a customized version of CORBA-IDL. We employ ontology reasoning engines to check conformance among interface contracts. The accuracy evaluation results have shown that our verifier has a high accuracy for detecting semantics errors. The scalability evaluation shows that our framework exhibits almost a linear behavior. It is concluded that our framework is suitable for verifying the conformance of interface contracts, involving semantics aspects, along a configuration of component interconnections.

DataProVe: Fully Automated Conformance Verification Between Data Protection Policies and System Architectures

Abstract Privacy and data protection by design are relevant parts of the General Data Protection Regulation (GDPR), in which businesses and organisations are encouraged to implement measures at an early stage of the system design phase to fulfil data protection requirements. This paper addresses the policy and system architecture design and propose two variants of privacy policy language and architecture description language, respectively, for specifying and verifying data protection and privacy requirements. In addition, we develop a fully automated algorithm based on logic, for verifying three types of conformance relations (privacy, data protection, and functional conformance) between a policy and an architecture specified in our languages’ variants. Compared to related works, this approach supports a more systematic and fine-grained analysis of the privacy, data protection, and functional properties of a system. Our theoretical methods are then implemented as a software tool called DataProVe and its feasibility is demonstrated based on the centralised and decentralised approaches of COVID-19 contact tracing applications.

Designing a methodological framework for modeling and performance forecasting of self‐adaptive cloud systems

AbstractAutonomic computing got an increasing attention during past years in the context of Cloud computing in order to optimize the Cloud systems performance and increase their cost‐effectiveness. In that direction, a broad range of various self‐adaptability strategies have been proposed to overcome uncertainties related to Cloud systems like workload variations, hardware failures and malicious attacks. A special attention in the literature has been paid to resource allocation for cost and performance optimization, and self‐healing for better faut‐tolerance. However, while a lot of progress has been done on these topics, there is still a lack of a standardized methodology, easily reproducible and allowing validation and comparison of a self‐adaptability strategies. This article proposes a methodology allowing to forecast the autonomic Cloud systems performances. The idea is to compare different self‐adaptability approaches at the design stage, and identify the most adequate and optimized configuration. This methodology is based on a new architecture description language and a stochastic Petri nets‐based modeling and simulation approach. We illustrate our methodology in this article through a running example and a set of experiments.

Specifying dynamic software system architectures

The inexorable penetration of software into practically every facet of modern society calls for sophisticated architectural styles, including ones that can support architectures with dynamically shifting structures, which are required to cope with the dynamics of their applications. With the advent of modern Internet-based systems operating in real time, these types of systems are becoming more widespread. Unfortunately, to date there has been insufficient theoretical work on suitable architectural design patterns for such systems. This work describes two such patterns: the dynamic part pattern and the dynamic role pattern, both of which have been proven in earlier-generation dynamic real-time systems. In addition to describing the form and semantics of these design patterns, this work proposes a notational form suitable for specifying them in component-and-connector-style architecture description languages in a clear and unambiguous manner. The practical application of the two patterns is illustrated using a running example.

Architecture Description Languages Taxonomies Review

Self-adaptive distributed embedded systems can automatically adjust their behavior and/or structure at run time to respond to some predictable or unpredictable events. On the other hand, architecture description languages (ADLs) are qualified to be a convenient solution to model systems architecture as a set of components with well-defined interfaces and links. ADLs have been well-studied and applied in many engineering areas beyond the software and hardware engineering. This research work reviews the most relevant ADLs taxonomies and surveys from 2000 till now, selects the most suitable ADLs for self-adaptive embedded systems, and compares between standard and non-standard ADLs based on some key criteria. To do this, a search methodology was followed enabling a systematic review. Results showed that only a few standard ADL have been accepted by the embedded industry favoring domain-specific ADLs with a proved support of adaptivity, real time, energy consumption and security.

Teaching Software Architecture Patterns Using ACME Language

Software Architecture is one of the most important courses, in computer science discipline. It has many branches all of them aimed to prepare students to be architects on the industry. But actually, there is a gap between what the students find on the theoretical courses and what they find on the industry. On other words, the practical experience differs from academic theory. So the question is how to prepare students to join the industry? Abstract nature of the software engineering courses as general and software architecture in a special manner, led to difficulties in understanding, this raises the second question, how to make these courses understandable? All previous studies focusing on these problems either by changing course curricula or by using software tools. This paper extension for the previous study [1] as we survey Architecture Description Languages (ADLs) and conclude that ACME is a general-purpose language and it may be suitable for use as practical part for software architecture curricula. We aimed to design a framework use, ACME language, use it as a practical part of the software architecture course and supporting on teaching, focus on architecture patterns, thus we use most common architecture patterns layer and Pipes-Filters, starting with a simple example and increase the complexity.

Pragmatic reuse for DSML development

By bridging the semantic gap, domain-specific language (DSLs) serve an important role in the conquest to allow domain experts to model their systems themselves. In this publication we present a case study of the development of the Continuous REactive SysTems language (CREST), a DSL for hybrid systems modeling. The language focuses on the representation of continuous resource flows such as water, electricity, light or heat. Our methodology follows a very pragmatic approach, combining the syntactic and semantic principles of well-known modeling means such as hybrid automata, data-flow languages and architecture description languages into a coherent language. The borrowed aspects have been carefully combined and formalised in a well-defined operational semantics. The DSL provides two concrete syntaxes: CREST diagrams, a graphical language that is easily understandable and serves as a model basis, and crestdsl, an internal DSL implementation that supports rapid prototyping—both are geared towards usability and clarity. We present the DSL’s semantics, which thoroughly connect the various language concerns into an executable formalism that enables sound simulation and formal verification in crestdsl, and discuss the lessons learned throughout the project.

OpenFPGA: An Open-Source Framework for Agile Prototyping Customizable FPGAs

Demanded by ever-evolving data processing algorithms, field-programmable gate arrays (FPGAs) have become essential components of modern computing systems, thanks to their reconfigurable and distributed computing capabilities. However, FPGAs are among the very few integrated chips that still require long development cycles and high human efforts, even for industrial vendors. In this article, we introduce OpenFPGA, an open-source framework that can automate and significantly accelerate the development cycle of customizable FPGA architectures. OpenFPGA allows users to customize their FPGA architectures down to circuit-level details using a high-level architecture description language and autogenerate associated Verilog netlists which can be used in a backend flow to generate production-ready layouts. A generic Verilog-to-Bitstream generator is also provided, allowing end-users to implement practical applications on any FPGAs that OpenFPGA can support. Using OpenFPGA, we demonstrate less than 24-h layout generation of two FPGA fabrics, which are based on a Stratix-like architecture built with a commercial 12-nm standard cell library and 40-nm custom cells, respectively.

Using directed graphs to define viewpoints to keep a metamodel, an architecture framework and views using different modeling languages consistent

AbstractKeeping an architecture description of a complex system consistent is difficult. View content is specified by viewpoints which draw upon an underlying metamodel. Viewpoints need to define consistency rules. This becomes increasingly hard as the metamodel size and the number of viewpoints increase. Use of an architecture description language (ADL) such as the Unified Modeling Language (UML) complicates this further because its metamodel may not be able to implement the triples in the AD metamodel and therefore one or more views requiring use of an additional ADL. Even for an architecture framework with a small footprint, such as TRAK, it is a time‐consuming and error‐prone process to keep the metamodel, viewpoint definitions, and implementation consistent. To tackle these TRAK has been modeled by creating views against five viewpoints. These viewpoints can be used to define a metamodel, define the viewpoints for an architecture framework, assess the implementation using one or more ADLs, and record model changes over time. The viewpoint definitions and views are wholly graph‐based and provide a mechanism to define allowed and minimum view content. Views and viewpoints can be read as simple assertions requiring no technical knowledge and support query and analysis. The viewpoint definitions have been validated against a model of TRAK held in a Neo4J graph database. This showed that the TRAK metamodel contains c 750 triples not 500 as had been previously thought. It also identified metamodel elements missing from one of the UML profiles. Example views are provided together with CYPHER queries.

Software portability based on retargetable runtime environment

Subject of Research. The paper presents research of approaches to portable software development at the level of binary and source code. We study such factors affecting portability as compatibility of target platforms at the level of software and binary application interfaces, standardization of programming languages, software architecture, the functionality of software target platforms and software tools. Modern approaches for software portability based on virtual runtimes for Java and the .NET platform are considered. Method. A method is proposed for software portability based on two- stage compilation and an architecture description language application for translator configuration. The method gives the possibility to solve the software portability problem at the level of program execution environment. We also present a new approach to self-tuning runtime implementation with such configuration parameters as architecture-dependent metadata — descriptions of target platforms. To generate a binary image of the runtime environment for a target platform, its source code is not required. Image generation is performed based on metadata that is part of an existing image used as a builder utility. Main Results. Implementation requirements for the program execution environment and its architecture at the level of functional components are determined. The novel approach for the runtime implementation is proposed which ensures portability without recompilation from the source code of both user applications and the runtime environment. A script for the runtime environment application has been developed to generate its binary image aimed at a target platform. Practical Relevance. Binary portability of the program execution environment allows reducing labor costs for cross-platform applications.

Designing an architecture description language for nontechnical actors and purposes (NOTE-ADL)

PurposeThe paper proposes the development of a graphical architecture description language (ADL) that allows a better understanding of software architectures for nontechnical actors and purposes and, beyond, can serve as a communication tool between domain experts and IT experts, for instance, in a software development process.Design/methodology/approachThe paper follows the methods and guidelines of design science research. By deriving characteristics and general requirements for ADLs from a research literature review and from industry standards, the paper provides a conceptual modeling approach for an ADL. The model design is based on typical requirements and suggestions derived from literature and related work. The application possibilities and advantages are then demonstrated with a usage scenario.FindingsThe paper elaborates a user-oriented ADL that makes software architecture comprehensible for stakeholders and end users. It provides a high level of abstraction and, thus, is not restricted to a particular domain. The paper also provides a corresponding modeling editor as well as an underlying catalogue with symbols and rules for the ADL.Research limitations/implicationsAs this is a conceptual study, the ADL has not been practically evaluated yet. Thus, the usefulness of this academic approach for the industry remains to be validated.Originality/valueThe elaborated ADL can serve as a language to visualize software architectures, particularly in the business domain, in a comprehensible manner. Still, it retains the structured character of ADLs to facilitate communication on an IT-near level. In including nontechnical actors, the approach broadens the overall application capabilities of ADLs.

Model Testing of Complex Embedded Systems Using EAST-ADL and Energy-Aware Mutations

Nowadays, embedded systems are increasingly complex, meaning that traditional testing methods are costly to use and infeasible to directly apply due to the complex interactions between hardware and software. Modern embedded systems are also demanded to function based on low-energy computing. Hence, testing the energy usage is increasingly important. Artifacts produced during the development of embedded systems, such as architectural descriptions, are beneficial abstractions of the system’s complex structure and behavior. Electronic Architecture and Software Tools Architecture Description Language (EAST-ADL) is one such example of a domain-specific architectural language targeting the automotive industry. In this paper, we propose a method for testing design models using EAST-ADL architecture mutations. We show how fault-based testing can be used to generate, execute and select tests using energy-aware mutants—syntactic changes in the architectural description, used to mimic naturally occurring energy faults. Our goal is to improve testing of complex embedded systems by moving the testing bulk from the actual systems to models of their behaviors and non-functional requirements. We combine statistical model-checking, increasingly used in quality assurance of embedded systems, with EAST-ADL architectural models and mutation testing to drive the search for faults. We show the results of applying this method on an industrial-sized system developed by Volvo GTT. The results indicate that model testing of EAST-ADL architectural models can reduce testing complexity by bringing early and cost-effective automation.

On the verification of mission-related properties in software-intensive systems-of-systems architectural design

• Architectural Verification Method for Systems-of-systems. • Simulation-based Verification through Statistical Model Checking. • Tool support extensible for other Architectural Description Languages • Mission-oriented Formal Verification One of the prominent domains of nowadays software engineering concerns on building and maintaining the so-called system-of-systems (SoS) . The activity of integrating independent, potentially heterogeneous, and distributed systems has become remarkable. Designing SoS that consists on integrating independent and behaviorally unknown systems involves several difficulties, specially due to the inner dynamism that hovers SoS. Aiming to support the development of such kind of systems, mission models allows stakeholders to set objectives and resources for SoS, complementing the traditional requirements approach. In a mission model, designers specify the missions of the system and what the system is capable of doing to achieve them. On the other hand, one of the most desired feature of any modeling language is the possibility of formally verifying described properties. Enabling the stakeholders to check the degree of compliance of a model to a given set of properties fosters quality and simplifies the development process by shifting the problem resolution to the design level. The difficulties of SoS modeling also reflect on the verification processes: traditional verification methods were shown noneffective. In this context, this work proposes a method to verify SoS models based on mission-related properties, using the mission modeling language mKAOS and the DynBLTL formalism. Our proposal can be applied to any modeling language, although we exemplify using SosADL, an architectural description language for the SoS context.

Formal specification and verification of reusable communication models for distributed systems architecture

The development of distributed computing systems involves complex concerns related to integrating numerous communication styles, technologies (Internet of Things, cloud, big data, etc.), stakeholders (architects, developers, integrators, etc.) and addressing a multitude of application domains (smart cities, health, mobility, etc.). Existing architectural description languages fail to rigorously bridge the gap between the abstract representation of communication styles and those supported by existing execution infrastructures. In this paper, we propose an approach combining semi-formal and formal languages which considers modeling and formalization from both the structural and communication behavior perspectives. As a prerequisite, we build reusable model libraries to specify and verify communication styles for modeling software architectures of distributed systems. First, we propose a metamodel to describe high-level concepts of architecture in a component–port–connector fashion focusing on different communication styles. Then, we formalize those concepts and their semantics following some properties (specifications) to check architectural conformance. To validate our work, we provide a set of reusable connector libraries within a set of properties to define architectures for systems with explicit communication models that are common to most distributed systems including message passing, remote procedure calls, and distributed shared memory. Through reuse of these specified and verified connectors, we demonstrate how concrete software architectures for a given application domain can be developed.

Architecture Description Language – Systematic Literature Review

increase numbers and complexity of software development requires that learners of software engineering and software architecture or software architects who do not have sufficient practical experience must have the skills and abilities to perform their jobs. But there is a gap between academia and practical so the question why does not use one of the architecture description languages in teaching and learn software engineering and software architecture to fill this gap? The objective of this study to classification ADLs according to their domain, domain specific or general purpose languages, doing these systematic literature review flowing the steps from Ketchenham. As the result we find that most ADLs are Domain Specific ADLs (Aviation Systems, Distribution Systems, Mobile Systems, Product Lines …etc. ) none of these ADLs is used in the field of software architecture education, but most intended to deal with experts in the field, except general purpose ADLs, like ACME, which we make as start point to design Arabic ADL, so as to enrich Arabic content, also to be as helping language in teaching Software Architecture course, because most of ADLs need experience and high level of understanding to use, moreover, when student think and design with same language subject more understandable. So using software architecture description languages in educating purpose, help on understanding high level of abstraction of software architecture and software engineering courses, there are some studies that aimed to reduce the complexity of these courses using different methodologies and approaches, but none of them using architecture description languages as helping tool. So the use of architecture description languages is helpful in teaching software architecture and software engineering courses.

An Approach to Generate the Traceability Between Restricted Natural Language Requirements and AADL Models

Requirements traceability is broadly recognized as a critical element of any rigorous software development process, especially for building safety-critical software (SCS) systems. Model-driven development (MDD) is increasingly used to develop SCS in many domains, such as automotive and aerospace. MDD provides new opportunities for establishing traceability links through modeling and model transformations. Architecture Analysis and Design Language (AADL) is a standardized architecture description language for embedded systems, which is widely used in avionics and aerospace industries to model safety-critical applications. However, there is a big challenge to automatically establish the traceability links between requirements and AADL models in the context of MDD, because requirements are mostly written as free natural language texts, which are often ambiguous and difficult to be processed automatically. To bridge the gap between natural language requirements (NLRs) and AADL models, we propose an approach to generate the traceability links between NLRs and AADL models. First, we propose a requirement modeling method based on the restricted natural language, which is named as RM-RNL. The RM-RNL can eliminate the ambiguity of NLRs and barely change engineers’ habits of requirement specification. Second, we present a method to automatically generate the initial AADL models from the RM-RNLs and to automatically establish traceability links between the elements of the RM-RNL and the generated AADL models. Third, we refine the initial AADL models through patterns to achieve the change of requirements and traceability links. Finally, we demonstrate the effectiveness of our approach with industrial case studies and evaluation experiments.

A Model-Checking-Based Framework for Analyzing Ambient Assisted Living Solutions.

Since modern ambient assisted living solutions integrate a multitude of assisted-living functionalities, out of which some are safety critical, it is desirable that these systems are analyzed at their design stage to detect possible errors. To achieve this, one needs suitable architectures that support the seamless design of the integrated assisted-living functions, as well as capabilities for the formal modeling and analysis of the architecture. In this paper, we attempt to address this need, by proposing a generic integrated ambient assisted living system architecture, consisting of sensors, data collection, local and cloud processing schemes, and an intelligent decision support system, which can be easily extended to suit specific architecture categories. Our solution is customizable, therefore, we show three instantiations of the generic model, as simple, intermediate, and complex configurations, respectively, and show how to analyze the first and third categories by model checking. Our approach starts by specifying the architecture, using an architecture description language, in our case, the Architecture Analysis and Design Language, which can also account for the probabilistic behavior of such systems, and captures the possibility of component failure. To enable formal analysis, we describe the semantics of the simple and complex architectures within the framework of timed automata. We show that the simple architecture is amenable to exhaustive model checking by employing the UPPAAL tool, whereas for the complex architecture we resort to statistical model checking for scalability reasons. In this case, we apply the statistical extension of UPPAAL, namely UPPAAL SMC. Our work paves the way for the development of formally assured future ambient assisted living solutions.