Software Architecture Analysis Research Articles

From Software Architecture Analysis to Service Engineering: An Empirical Study of Methodology Development for Enterprise SOA Implementation

This paper presents an integrated service-oriented enterprise system development framework (called the BITAM-SOA Framework) as well as an instantiated design process model (called the Service Engineering Schematic) that was a result from a three-year action research case study with a Fortune 50 company in the financial services industry. The BITAM-SOA Framework and Schematic advance are both business-IT alignment and software architecture analysis techniques supporting the engineering of enterprise-wide service-oriented systems-that is, service engineering.

Quantitative Analysis of System Based on Extended UML State Diagrams and Probabilistic Model Checking

If probabilistic model checking is applied in software architecture, function validation and quantitative analysis for Markov process based real-time model can be automatically performed in model refinement, which will improve software quality. In this paper, the exact definitions and mapping rules between UML state diagrams and probabilistic Kripke structure semantics are proposed, as well as the general translation algorithm of formal semantics. An asynchronous parallel composited DTMC system is illustrated, the key non-function properties of system are described by PCTL, which is automatically validated and analyzed by PRISM model checker. The key system properties are also manually deduced and proved, and compared with the experiment results. The mapping rules we proposed are bi-direction, so it can be used in both forward and reverse software engineering.

A Tile Logic Based Approach for Software Architecture Description Analysis

A main advantage of Architecture Description Languages (ADL) is their aptitude to facilitate formal analysis and verification of complex software architectures. Since some researchers try to extend them by new techniques, we show in this paper how the use of tile logic as extension of rewriting logic can enforce the ability of existing ADL formalisms to cope with hierarchy and composition features which are more and more present in such software architectures. In order to cover ADL key and generic concepts, our approach is explained through LfP (Language for rapid Prototyping) as ADL offering the possibility to specify the hierarchical behaviour of software components. Then, our contribution goal is to exploit a suitable logic that allows reasoning naturally about software system behaviour, possibly hierarchical and modular, in terms of its basic components and their interactions.

Towards Analyzing the Architectural Support Level of Usability

The user acceptance of a software product especially depends on its usability. Therefore, it is a matter that needs to be addressed early on in the software development process. In existing scenario-based software architecture analysis methods that focus on usability, the usage context is not employed to select scenarios used for analysis, although it is known that understanding a specific usage context is important to carefully design for usability. In order to address this, we propose the method Software ArchitecTural analysis of Usability Requirements realizatioN'' SATURN in this paper. It is set in the requirements context, incorporates a usage context analysis, and a simple walkthrough of a user interface prototype. The method furthermore provides a knowledge base of standardized analysis scenarios and analysis templates that are derived from general usability requirements and design patterns. By arriving at an Architectural Support Level (ASL) based on the architectural impact of analyzed scenarios, the proposed procedure model shall guide evaluators to accomplish a repeated analysis of the current architectural design for usability in a traceable way.

The Personal Hearing System—A Software Hearing Aid for a Personal Communication System

A concept and architecture of a personal communication system (PCS) is introduced that integrates audio communication and hearing support for the elderly and hearing-impaired through a personal hearing system (PHS). The concept envisions a central processor connected to audio headsets via a wireless body area network (WBAN). To demonstrate the concept, a prototype PCS is presented that is implemented on a netbook computer with a dedicated audio interface in combination with a mobile phone. The prototype can be used for field-testing possible applications and to reveal possibilities and limitations of the concept of integrating hearing support in consumer audio communication devices. It is shown that the prototype PCS can integrate hearing aid functionality, telephony, public announcement systems, and home entertainment. An exemplary binaural speech enhancement scheme that represents a large class of possible PHS processing schemes is shown to be compatible with the general concept. However, an analysis of hardware and software architectures shows that the implementation of a PCS on future advanced cell phone-like devices is challenging. Because of limitations in processing power, recoding of prototype implementations into fixed point arithmetic will be required and WBAN performance is still a limiting factor in terms of data rate and delay.

Performance analysis of real-time component architectures: An enhanced model interchange approach

Model interchange approaches support the analysis of software architecture and design by enabling a variety of tools to exchange performance models using a common schema. This paper builds on the Software Performance Model Interchange Format (S-PMIF), extending it to support the analysis of real-time systems and adapting it to be suitable for implementation with modeling frameworks such as MOF or EMF. This enhances the model interchange process by making it possible to define model-to-model transformations from design models into software performance models. The paper addresses real-time system designs expressed in CCL and their transformation into the S-PMIF for additional performance analyses.

Hierarchical Design Rewriting with Maude

Architectural Design Rewriting (ADR) is a rule-based approach for the design of dynamic software architectures. The key features that make ADR a suitable and expressive framework are the algebraic presentation and the use of conditional rewrite rules. These features enable, e.g. hierarchical (top-down, bottom-up or composition-based) design and inductively-defined reconfigurations. The contribution of this paper is twofold: we define Hierarchical Design Rewriting (HDR) and present our prototypical tool support. HDR is a flavour of ADR that exploits the concept of hierarchical graph to deal with system specifications combining both symbolic and interpreted parts. Our prototypical implementation is based on Maude and its presentation serves several purposes. First, we show that HDR is not only a well-founded formal approach but also a tool-supported framework for the design and analysis of software architectures. Second, our illustration tailored to a particular algebra of designs and a particular scenario traces a general methodology for the reuse and exploitation of ADR concepts in other scenarios.

Experiences with Software Architecture Analysis of Usability

Software engineers and human computer interaction engineers have come to the understanding that usability is not something that can be “added” to a software product during late stage, since to a certain extent it is determined and restricted by architecture design. Cost effectively developing a usable system must include developing an architecture, which supports usability. Because software engineers in industry lacked support for the early evaluation of usability, we defined a generalized four-step method for software architecture level usability analysis called SALUTA. In this article, we report on a number of experiences and problems we observed when performing architecture analysis of usability at three industrial case studies performed in the domain of Web-based enterprise systems. Suggestions or solutions are provided for solving or avoiding these problems so organizations facing similar problems may learn from our experiences.

Software architecture reliability analysis using failure scenarios

With the increasing size and complexity of software in embedded systems, software has now become a primary threat for the reliability. Several mature conventional reliability engineering techniques exist in literature but traditionally these have primarily addressed failures in hardware components and usually assume the availability of a running system. Software architecture analysis methods aim to analyze the quality of software-intensive system early at the software architecture design level and before a system is implemented. We propose a Software Architecture Reliability Analysis Approach (SARAH) that benefits from mature reliability engineering techniques and scenario-based software architecture analysis to provide an early software reliability analysis at the architecture design level. SARAH defines the notion of failure scenario model that is based on the Failure Modes and Effects Analysis method (FMEA) in the reliability engineering domain. The failure scenario model is applied to represent so-called failure scenarios that are utilized to derive fault tree sets (FTS). Fault tree sets are utilized to provide a severity analysis for the overall software architecture and the individual architectural elements. Despite conventional reliability analysis techniques which prioritize failures based on criteria such as safety concerns, in SARAH failure scenarios are prioritized based on severity from the end-user perspective. SARAH results in a failure analysis report that can be utilized to identify architectural tactics for improving the reliability of the software architecture. The approach is illustrated using an industrial case for analyzing reliability of the software architecture of the next release of a Digital TV.

Evaluation of accuracy of drug interaction alerts triggered by two electronic medical record systems in primary healthcare

This article presents a study to evaluate the accuracy of drug interaction (DI) alerts triggered by two electronic medical record (EMR) systems in primary healthcare. A scenario-based software architecture analysis methodology (SAAM) was used with drug-drug interaction (DDI) pairs in hypothetical patient scenarios. A literature search identified common drugs used in the management of conditions in the elderly population. Three reference programs determined the level of severity of drug interactions, and a common severity rating scale was adapted. The EMR systems showed a limited potential to identify 'severe' clinically significant DDIs and considerable probability for triggering spurious alerts. This may explain the overriding of DI alerts and the interruption of the workflow of users of EMR systems. Reasons for EMR system deficiency included unavailable updates or programming, database functioning discrepancies, and controversies in the clinical evidence.

Survey of reliability and availability prediction methods from the viewpoint of software architecture

Many future software systems will be distributed across a network, extensively providing different kinds of services for their users. These systems must be highly reliable and provide services when required. Reliability and availability must be engineered into software from the onset of its development, and potential problems must be detected in the early stages, when it is easier and less expensive to implement modifications. The software architecture design phase is the first stage of software development in which it is possible to evaluate how well the quality requirements are being met. For this reason, a method is needed for analyzing software architecture with respect to reliability and availability. In this paper, we define a framework for comparing reliability and availability analysis methods from the viewpoint of software architecture. Our contribution is the comparison of the existing analysis methods and techniques that can be used for reliability and availability prediction at the architectural level. The objective is to discover which methods are suitable for the reliability and availability prediction of today’s complex systems, what are the shortcomings of the methods, and which research activities need to be conducted in order to overcome these identified shortcomings. The comparison reveals that none of the existing methods entirely fulfill the requirements that are defined in the framework. The comparison framework also defines the characteristics required of new reliability and availability analysis methods. Additionally, the framework is a valuable tool for selecting the best suitable method for architecture analysis. Furthermore, the framework can be extended and used for other evaluation methods as well.

The essential components of software architecture design and analysis

Architecture analysis and design methods such as ATAM, QAW, ADD and CBAM have enjoyed modest success and are being adopted by many companies as part of their standard software development processes. They are used in the lifecycle, as a means of understanding business goals and stakeholders concerns, mapping these onto an architectural representation, and assessing the risks associated with this mapping. These methods have evolved a set of shared component techniques. In this paper we show how these techniques can be combined in countless ways to create needs-specific methods in an agile way. We demonstrate the generality of these techniques by describing a new architecture improvement method called APTIA (Analytic Principles and Tools for the Improvement of Architectures). APTIA almost entirely reuses pre-existing techniques but in a new combination, with new goals and results. We exemplify APTIA’s use in improving the architecture of a commercial information system.

AVDL: A highly adaptable architecture view description language

Architectural views are rapidly gaining a momentum as a vehicle to document and analyze software architectures. Despite their popularity, there is no dedicated language flexible enough to support the specifications of an unbound variety of views including those preexisting and needing to be newly created on demand. In this paper, we propose a novel view description language intended for specifying any arbitrary views, using a uniform set of conventions for constructing views and how to use them. The highly adaptable nature of the new language results from its built-in mechanisms to define different types of views in a systematic and repeatable manner.

π-AAL

A key aspect of the design of any software system is its architecture. An architecture description, from a runtime perspective, provides a formal representation of the architecture in terms of its components and connectors, their ports and behaviours, and how they are composed together. In the past decade, several Architecture Description Languages (ADLs) have been defined for representing the structure and behaviour of software architectures. However, describing the structure and behaviour of an architecture in terms of a configuration of components and connectors is needed, but it is not enough. Indeed, in addition to representing software architectures, we need to rigorously specify their required and desired architectural properties, in particular related to completeness, consistency and correctness. This article presents π-AAL, a novel Architecture Analysis Language (AAL) that has been designed in the ArchWare European Project to address formal analysis of software architectures. It is a formal, well-founded theoretically language based on the modal μ-calculus designed to enable the specification of structural and behavioural properties and their verification using an analytical toolset based on theorem proving and model checking techniques.

Investigating the impact of usability on software architecture through scenarios: A case study on Web systems

Usability has primarily been served by separating the user interface from the remainder of the application. However, several researchers have recently determined that there is a direct relationship between architectural decisions and usability requirements. This leads us to conclude that more attention should be devoted to usability-driven architectural analysis methods. We present a case study, which involves adapting an existing software architecture analysis method (SAAM) for the purpose of deriving the interdependencies between architectural characteristics and usability requirements. More specifically, we investigate the impact on the architecture of implementing usability requirement changes. Potential design solutions that accommodate the corresponding usability mechanisms into the Web software architecture are presented, along with the rationale for applying them and the process by which they are obtained. We conclude by recommending how usability issues can be dealt with proactively during the design of the architecture, and explain the need to integrate those usability requirements into a software engineering process.

Performance modeling and analysis of software architectures: An aspect-oriented UML based approach

Much attention has recently been focused on the problem of effectively developing software systems that meet their non-functional requirements (NFRs). Architectural frameworks have been proposed as a solution to support the design and analysis of NFRs such as performance, security, adaptability, etc. The significant benefits of such work include detecting and removing defects earlier, reducing development time, cost and improving the quality. The Formal Design Analysis Framework (FDAF) is an aspect-oriented approach that supports the automated translation of extended Unified Modeling Language designs for distributed real-time systems into existing formal notations, including Architecture Description Languages Rapide and Armani. The analysis of the formalized design is achieved using existing tool support for the formal methods, which leverages a large body of work in the research community. Currently, FDAF supports the design and analysis of response time and resource utilization performance sub-aspects. This paper presents the algorithms for translating extended UML diagrams into Armani, the proofs of correctness of the algorithms, and an illustration of the FDAF approach by using the Domain Name System. The Armani performance analysis results can provide architects with information indicating whether or not overloaded components exist in the design. If such a component exists, then the architect iteratively refines the UML architecture to meet the clients’ requirements.

A Framework for the Integration of Functional and Non-functional Analysis of Software Architectures

The separation of functional and non-functional analysis of software systems often prevents from considering design solutions that would be evident if an integrated analysis would be possible. Lack of analysis integration is in fact leading software developers to loose precious feedback that would improve the quality of the software product or, even better, would avoid late software inconsistencies with respect to functional or non-functional requirements. In this paper we introduce a framework for software analysis integration. The framework core is XML-based and consists of software models and formal relations among models. The relations help to automatically propagate the analysis feedback among software models. We specify how different analysis methodologies can be integrated in our framework. We also show how the Eclipse platform represents a natural implementation environment for such a framework.

Review of Software Architecture Analysis and Evaluation Methods

Review of Software Architecture Analysis and Evaluation Methods

Architecture-level modifiability analysis (ALMA)

Several studies have shown that 50–70% of the total lifecycle cost for a software system is spent on evolving the system. Organizations aim to reduce the cost of these adaptations, by addressing modifiability during the system’s development. The software architecture plays an important role in achieving this, but few methods for architecture-level modifiability analysis exist. Independently, the authors have been working on scenario-based software architecture analysis methods that focus exclusively on modifiability. Combining these methods led to architecture-level modifiability analysis (ALMA), a unified architecture-level analysis method that focuses on modifiability, distinguishes multiple analysis goals, has explicit assumptions and provides repeatable techniques for performing the steps. ALMA consists of five main steps, i.e. goal selection, software architecture description, change scenario elicitation, change scenario evaluation and interpretation. The method has been validated through its application in several cases, including software architectures at Ericsson Software Technology, DFDS Fraktarna, Althin Medical, the Dutch Department of Defense and the Dutch Tax and Customs Administration.

Derivation of markov models for effectiveness analysis of adaptable software architectures for mobile computing

Adaptable software architectures (SA) have been suggested as a viable solution for the design of distributed applications that operate in a mobile computing environment to cope with the high heterogeneity and variability of this environment. Mobile code techniques can be used to implement this kind of SA since they allow us to dynamically modify the load of the hosting nodes and the internode traffic to adapt to the resources available in the nodes and to the condition of the (often wireless) network link. However, moving code among nodes has a cost (e.g., in terms of network traffic and consumed energy for mobile nodes), so designing an adaptable SA based on mobile code techniques requires a careful analysis to determine its effectiveness from the early design stages. In this respect, our main contribution consists of a methodology, called ASAP (adaptable software architectures performance), to automatically derive, starting from a design model of a mobility-based SA, a Markov model whose solution provides insights about the most effective adaptation strategy based on code mobility in a given execution environment. We assume that the SA model is expressed using the Unified Modeling Language (UML) because of its widespread use in software design, also suggesting some extension to this formalism to better express the "mobility structure" of the application, i.e., which are the mobile components, and the possible targets of their movement.