Software Architecture Research Research Articles

Report on the Blended Modeling for Software Architectures Tutorial at ICSA 2023

In this note, we report on a half-day tutorial designed to introduce software architecture practitioners and researchers to the concepts and open-source implementations of blended modeling for software architectures. The tutorial covered blended modeling motivation and principles, generation of editors, generation of the synchronization infrastructure, and collaborative modeling techniques. Through presentations, examples, and demonstrations, participants explored the practical implementation of blended modeling environments that can be tailored to their specific needs. The note provides a detailed account of the tutorial sessions, including the main implications of a focus group discussion held in the final session of the tutorial. In the follow-up to the tutorial, we conducted a survey to assess participants' perceptions of blended modeling's usefulness within their contexts. Post-tutorial actions and survey results are discussed as well, providing valuable insight into the benefits and potential challenges associated with the adoption of blended modeling.

Empirical research in software architecture — Perceptions of the community

Context:Previous research highlighted concerns about empirical research in software engineering (e.g., reproducibility, applicability of findings). It is unclear how these concerns reflect views of those who conduct and evaluate research. Objective:Focusing on software architecture, one subfield of software engineering, we study perceptions of the research community on (1) how empirical research is applied, (2) human participants, (3) internal and external validity, and (4) replications. Method:We collected responses from 105 key players in architecture research via a survey; we analyzed data quantitatively and qualitatively. Results:Although respondents do generally not prefer either quantitative or qualitative research, around 40% express a preference for various reasons. Professionals are the preferred participants; there is no consensus on the value of student participants. Also, there is no consensus on when to focus on internal or external validity. Most respondents value replications, but acknowledge difficulties. A comparison with published research shows differences between how the community thinks research should be done. Conclusions:We provide evidence that consensus about empirical research is limited. Findings have implications for conducting and reviewing empirical research (e.g., training researchers and reviewers), and call for reflection on empirical research (e.g., to resolve conflicts). We outline actions for the future.

A functional safety assessment method for cooperative automotive architecture

The scope of automotive functions has grown from a single vehicle as an entity to multiple vehicles working together as an entity, referred to as cooperative driving. The current automotive safety standard, ISO 26262, is designed for single vehicles. With the increasing number of cooperative driving capable vehicles on the road, it is now imperative to systematically assess the functional safety of architectures of these vehicles. Many methods are proposed to assess architectures with respect to different quality attributes in the software architecture domain, but to the best of our knowledge, functional safety assessment of automotive architectures is not explored in the literature. We present a method, that leverages existing research in software architecture and safety engineering domains, to check whether the functional safety requirements for a cooperative driving scenario are fulfilled in the technical architecture of a vehicle. We apply our method on a real-life academic prototype for a cooperative driving scenario, platooning, and discuss our insights.

Automatic Generation of Basis Component Path Coverage for Software Architecture Testing

Architecture-centric development is one of the most promising methods for improving software quality, reducing software cost and raising software productivity. Software architecture research not only focuses on the design phase, but also covers every phase of software life cycle. Software architecture has characteristics different from traditional software, conventional testing methods do not apply directly to software architecture. Basis path testing is a very simple and efficient white-box testing method. Traditional methods generate basis path according to the control flow graph, they are not suitable for generating component path when we detect more software architecture errors. This paper presents a new concept - Basis Component Path (BCP) for C2-style architecture, and proposes a method to generate the BCPs. C2-style architecture is represented by components, connectors, and interfaces, and uses an architecture component interaction graph (CIG) to describe interface connection relationship. We also provide an algorithm to generate BCP set. Experiments apply the proposed method in a typical C2-style architecture and the result shows that the proposed method can generate BCP set which contains as many BCPs as possible efficiently, and it meets the requirements of the basis component path testing.

Software architectural principles in contemporary mobile software: from conception to practice

The meteoric rise of mobile software that we have witnessed in the past decade parallels a paradigm shift in its design, construction, and deployment. In particular, we argue that today’s mobile software, with its rich ecosystem of apps, would have not been possible without the pioneering advances in software architecture research in the decade that preceded it. We describe the drivers that elevated software architecture to the centerpiece of contemporary mobile software. We distill the architectural principles found in Android, the predominant mobile platform with the largest market share, and trace those principles to their conception at the turn of century in software architecture literature. Finally, to better understand the extent to which Android’s ecosystem of apps employs architectural concepts, we mine the reverse-engineered architecture of hundreds of Android apps in several app markets and report on those results.

Software Architecture Patterns: Reflection and Advances

Architectural software patterns capture successful designs for recurring problems in software architecture. For the first time, a workshop in the tradition of the software-pattern conference series (e.g. PLoP, EuroPLoP) was held jointly with the European Conference on Software Architecture (ECSA 2014) in Vienna, Austria. The main objective of this workshop called MiniPLoP was to bring software architecture researchers closer to the pattern community and to introduce the writers' workshop format to them. Writers' workshop at PLoP conferences provide authors of pattern papers with high-density feedback given by peers within a limited timeframe. In addition, our workshop provided a forum to reect on the state of software architecture patterns and to discuss advances pattern research. This report contains an extended keynote abstract and summaries of the papers discussed during the workshop.

A Study on User-Interface Architectures

This paper is a outcome of a detailed examination of tools, systems and notation used in software architectures. Modeling software architecture for a system is not as easy as one can understand tools, applying the appropriate tool essentially varies its efficiency and demands. In the background of Software Architecture analysis, design there is a profound influence of design and specification tools that tend to develop models for even challenging systems is a more systematic and predictable manner. This survey reveals various directions of research in software architectures.

Deadlock Detection and Avoidance in Static Step Topology under Distributed Environment

During the past years, the distributed computing approach has become very popular due to various advantages over centralized approach. In the distributed approach, the execution of a process has reduced and also it requires low cost for installation. Many of the researchers are using the modeling approach for solution of the software and hardware architecture research problems. The most popular approach of modeling is known as Unified Modeling Language based on the object-oriented technology. In the present work, a method of deadlock detection is explained for the newly proposed static step topology for the distributed network. In the step topology, the processes are taken as a task, sub task, macro, subroutine, etc which are executed in reflexive and symmetric manners when the systems are interconnected to each other under distributed environment and avoidance technique is also presented for the same. The deadlock detection technique is presented through a UML class model.

Empirical research in software architecture: opportunities, challenges, and approaches

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

An Architectural Framework for the Development of Secure Mobile Payment System

The Research in software architecture is an emerging field which emphasis on development methodologies, building theory, models of architecture, quality requirements, architectural description languages, and verification of architectural properties. Researchers put on efforts to elicit the state-of-the art technology framework in software architecture models in diversified fields. The high market penetrations of mobile personal devices including mobile phones, PDAs have paved a way for the development of new models in Mobile Commerce. Mobile phones are well suited with mobile commerce to reach the customers anywhere and at any time. Mobile Payments are a natural evolution of e-payment schemes that facilitate mobile commerce. A study reveals that there are wide ranges of mobile payment solutions and models available with the aid of various services. This paper provides a panoramic view of research in Software Architecture framework. A framework is to perform secure mobile payment system with the aim of achieving end-to-end security using asymmetric-key operations to provide convenient payment solutions. The development of secured mobile payment system for macro payments is a hot research topic for the research community and telecommunication industry. This paper proposes an effective framework to carry out the financial transactions from the customer to the merchant. It helps the application designers, developers and researchers to develop and manage the future payment applications and technologies.

Applying empirical software engineering to software architecture: challenges and lessons learned

In the last 15 years, software architecture has emerged as an important software engineering field for managing the development and maintenance of large, software- intensive systems. Software architecture community has developed numerous methods, techniques, and tools to support the architecture process (analysis, design, and review). Historically, most advances in software architecture have been driven by talented people and industrial experience, but there is now a growing need to systematically gather empirical evidence about the advantages or otherwise of tools and methods rather than just rely on promotional anecdotes or rhetoric. The aim of this paper is to promote and facilitate the application of the empirical paradigm to software architecture. To this end, we describe the challenges and lessons learned when assessing software architecture research that used controlled experiments, replications, expert opinion, systematic literature reviews, obser- vational studies, and surveys. Our research will support the emergence of a body of knowledge consisting of the more widely-accepted and well-formed software architecture theories.

Moving architectural description from under the technology lamppost

In 2000, we published an extensive study of existing software architecture description languages (ADLs), which has served as a useful reference to software architecture researchers and practitioners. Since then, circumstances have changed. The Unified Modeling Language (UML) has gained popularity and wide adoption, and many of the ADLs we studied have been pushed into obscurity. We argue that this progression can be attributed to early ADLs’ nearly exclusive focus on technological aspects of architecture, ignoring application domain and business contexts within which software systems and development organizations exist. These three concerns – technology, domain, and business – constitute three “lampposts” needed to appropriately “illuminate” software architecture and architectural description.

Progress of Research on Software Architecture

As an important means to control the complexity of software systems, to improve software quality and to support software development and software reuse, software architecture has become a mainstream research field in the software engineering community. Now, software architecture research not only focuses on the design phase, but also covers every phase of software lifecycle. This paper surveys the update-to-date research and practice of software architecture from a software lifecycle’s perspective, and discusses the potential research directions of software architecture.

Software architectures and embedded systems: a match made in heaven?

One area from which we might gain leverage in the ubiquitous- and embedded-systems domain is software architecture, which has emerged over the past decade as an area of intense interest among researchers and practitioners. Such interest has resulted in many approaches to dealing with architectural description and analysis, architectural styles, domain-specific and application family architectures, and architecture-based dynamic system adaptation. By and large, however, these approaches share assumptions that make them suited specifically to the domain of traditional, desktop-based development platforms. Those comparatively few architecture-based solutions that have focused on software systems for embedded devices have faced some traditional development challenges (such as applying solutions across an application family) but have also had different priorities (for example, ensuring efficient, architecture-compliant system implementations). In this article, the author draw general distinctions between "traditional" software architectures and those targeted at embedded systems. The author focuses on several areas that traditional software architecture research has studied and discusses their applicability and potential shortcomings in the embedded-systems context.

On relating functional specifications to architectural specifications: A case study

Software architecture specifications are predominantly concerned with describing the component structure of systems and how the components interact behaviorally. They are increasingly part of standardized software development processes because they represent a system abstraction in which design choices relevant to the correctness of the final system are taken. Therefore, much of software architecture research has concentrated on specification and analysis, whereas little attention has been paid to formally relating architectural specifications to higher levels of specification, such as the system requirements. In this paper we present our progress toward addressing an instance of this problem, namely relating state-based software architecture specifications to high-level functional specifications. Our approach is to use an intermediate specification given in terms of a set of temporal logic properties to bridge the gap between the two levels of specifications. We describe our approach in the context of a particular case study, the AEGIS GeoServer Simulation Testbed system, showing how a compact functional specification of a critical behavioral property of the system can be used to validate three alternative architectural specifications of that system.

Bridging the gap between IEEE 1471, an architecture description language, and UML

A lot of attention has been paid to software architecture issues in academia, industrial research and standardization organizations working in the software area. The software architecture research community has focused on the creation and improvement of special-purpose languages: architecture description languages (ADLs). However, ADLs lack adequate support for separating various kinds of stakeholders’ concerns along different viewpoints. But also, they do not address the difference between the architecture of a software system and its representations. In contrast, ANSI/IEEE-Std-1471 makes a clear distinction between the architecture and the architectural description of a software system. In this paper, we propose ConcernBASE, a UML-based approach to software architecture, which instantiates the conceptual framework defined in ANSI/IEEE-Std-1471 and complements the abstractions and mechanisms found in current ADLs. ConcernBASE provides a viewpoint for structural descriptions of software architectures that supports key concepts of ADLs and defines a UML profile as a viewpoint language. We validate this profile through a mapping between a representative ADL, called Structural ADL (SADL), and the new profile and by providing a UML-based tool prototype, called ConcernBASE Modeler, which integrates with SADL tools.

A Framework for Developing and Analyzing Software Architecture Specifications in SAM

In the past decade, software architecture research has mainly focused on the concept formulation and the development of various architecture description languages. This field has now matured enough and thus requires more emphasis on techniques for developing and analyzing software architecture specifications. SAM is a general software architecture model for developing and analyzing software architectures. In this paper, we show how to integrate high-level Petri nets and first-order temporal logic as the foundation of SAM to establish a unified framework for specifying and analyzing all aspects of a software architecture. We provide a set of heuristics, which are supported by well-defined existing methods and techniques developed by other researchers as well as our own, for software architecture development and analysis. We demonstrate the application of this framework and the heuristics with an example.

SPECIFYING SOFTWARE ARCHITECTURAL CONNECTORS IN SAM

Software architecture has become one of the most active research topics in software engineering in recent years. One of the distinct features of software architecture research is to explicitly study the interconnections (connectors) among system components. In this paper, we show how to formally specify several well-known general connectors in a software architecture methodology called SAM. Related work is discussed and compared. Our results establish the basis for reusing these defined connectors and for building more sophisticated connectors from them.

AN APPROACH TO QUANTITATIVE SOFTWARE ARCHITECTURE SENSITIVITY ANALYSIS

Software architectures are often claimed to be robust. However, there is no explicit and concrete definition of software architecture robustness. This paper gives a definition of software architecture robustness and presents a set of architecture metrics that were applied to real-time telecommunications software for the evaluation of robustness. The purpose of this study is to provide a structured method to support software architecture evaluations and downstream software implementations. The study also expands the software architecture research to quantitative and measurable evaluations as opposed to qualitative assessments. In addition, this paper presents an empirical case study of applying the metrics. The approach and the metrics data provide insights into software architecture sensitivity analysis on system qualities and trade-off analysis among a set of design alternatives to support product evolution.