Continuous evolution through software architecture evaluation: a case study

Introduced in the early stages of software development, the Charmy framework assists the software architect in making and evaluating architectural choices. Rarely, the software architecture of a system can be established once and forever. Most likely poorly defined and understood architectural constraints and requirements force the software architect to accept ambiguities and move forward to the construction of a suboptimal software architecture. Charmy aims to provide an easy and practical tool for supporting the iterative modeling and evaluation of software architectures. From an UML-based architectural design, an executable prototype is automatically created. Charmy simulation and model checking features help in understanding the functioning of the system and discovering potential inconsistencies of the design. When a satisfactory and stable software architecture is reached, Java code conforming to structural software architecture constraints is automatically generated through suitable transformations. The overall approach is tool supported.

Metric-based Evaluation of Implemented Software Architectures

This research recognizes the limitation and challenges of adapting and applying Process Mining as a powerful tool and technique in the Hypothetical Software Architecture (SA) Evaluation Framework with the features and factors of lightweightness. Process mining deals with the large-scale complexity of security and performance analysis, which are the goals of SA evaluation frameworks. As a result of these conjectures, all Process Mining researches in the realm of SA are thoroughly reviewed, and nine challenges for Process Mining Adaption are recognized. Process mining is embedded in the framework and to boost the quality of the SA model for further analysis, the framework nominates architectural discovery algorithms Flower, Alpha, Integer Linear Programming (ILP), Heuristic, and Inductive and compares them vs. twelve quality criteria. Finally, the framework’s testing on three case studies approves the feasibility of applying process mining to architectural evaluation. The extraction of the SA model is also done by the best model discovery algorithm, which is selected by intensive benchmarking in this research. This research presents case studies of SA in service-oriented, Pipe and Filter, and component-based styles, modeled and simulated by Hierarchical Colored Petri Net techniques based on the cases’ documentation. Process mining within this framework deals with the system’s log files obtained from SA simulation. Applying process mining is challenging, especially for a SA evaluation framework, as it has not been done yet. The research recognizes the problems of process mining adaption to a hypothetical lightweight SA evaluation framework and addresses these problems during the solution development.

: Software architecture is critical to the quality of a software-intensive system. For an acquisition organization, such as the Department of Defense (DoD), the ability to evaluate software architectures early in an acquisition can have a favorable impact on the delivered system. This technical note discusses the role of software architecture evaluations in a system acquisition and describes the contractual elements that are needed to accommodate architecture evaluations in an acquisition. The note then provides an example of contractual language that incorporates the Architecture Tradeoff Analysis Method (ATAM) as a software architecture evaluation method in a system acquisition.

SUMMARYA software architecture evaluation process requires a large number of stakeholders to be collocated for evaluation sessions. Given an increasing trend to using globally distributed software development teams, organizations are likely to be discouraged from introducing disciplined software architecture evaluation practices that require collocated stakeholders. To address this issue, we propose that a software architecture evaluation can be carried out using suitable groupware systems. In this paper, we present a framework for supporting the software architecture evaluation process using a groupware system. The framework highlights the changes that are required in the existing software architecture evaluation methods. We provide an illustrated example of modeling and mapping the activities of the presented process on electronic workspaces provided by a groupware system. We also identify some of the features that a groupware system should provide to successfully support the process. Copyright © 2010 John Wiley & Sons, Ltd.

Agile practices have recently gained popularity among large number of companies as a mechanism for reducing cost and increasing ability to handle change in dynamic market conditions. Based on the principles of the Agile manifesto [1, 2], researchers and practitioners have proposed several software development approaches such as Extreme Programming, Scrum and Feature-Driven Development. These and other agile approaches have had significant impact on industrial software development practices. However, there is also a significant concern and perplexity about the role and importance of the issues related to a system’s software architecture, which is considered one of the most important initial design artefacts. It is argued that software architecture is an effective tool to cut development cost and time and to increase the quality of a system. Many practitioners of Agile approaches appear to view software architecture in the context of the plan-driven development paradigm [3]. For them, upfront design and evaluation of software architecture requires too much work, which may have very little value to the customers of a system. Hence, they perceive architectural work as part of high ceremony processes, which usually require large amount of documentation. We maintain that these two seemingly opposing views to software engineering can be integrated but it requires that experts from both fields work together to overcome evident challenges in bridging these two paradigms together. Indeed, software architecture researchers and practitioners appear to believe that sound architectural practices cannot be followed using Agile approaches. However, these two extreme views of Agile and architecture appear to neglect that many agile experts emphasises the importance of paying attention to good design and architecture early in the development process [4, 5]. Recently, there is growing recognition of the importance of paying more attention to architectural aspects in agile approaches [3, 6, 7]. We argue that there is a vital need for devising a research agenda for identifying and dealing with architecture-centric challenges in agile software development. Such research agenda should make it possible to guide the future research on integrating architecture-centric methods in agile approaches and give advice to the software industry on dealing with architecture related challenges. Some of the questions to stimulate discussion in the workshop are: What is the role of software architecture in Agile software development? What are the key architecture-centric challenges and potential solutions in Agile software development projects? What is the strength of the evidence that attention to architectural issues can be counterproductive in Agile development or vice versa? What are the prerequisites for integrating Architecture-Centric methods in agile development and potential implications of such integration?

Quantitative properties of modern software systems are often defined as a part of a service-level agreement (SLA) that fixes the maximal load to be submitted to a system and guarantees bounds for the response time or delay. The evaluation of software architectures in order to validate SLAs is a challenging task since the systems tend to be complex, highly dynamic and to some extent unpredictable. Thus, there is a need for fast and abstract techniques to evaluate the performance of modern software architectures based on the information available in the SLAs. The paper presents an efficient approach to compute bounds on the delay of composed systems based on available bounds for the load and the response times of components. The technique can be used by a user of a software architecture to validate SLAs of composed services based on SLAs of the components. It can also be used by a provider of a software architecture to validate whether additional users can be accepted or to compute required service capacities to fulfill an SLA.

Software performance based on performance models can be applied at early phases of the software development cycle to characterize the quantitative behavior of software systems. We propose an approach based on queueing networks models for performance prediction of software systems at the software architecture level, specified by UML. Starting from annotated UML Use Case, Activity and Deployment diagrams we derive a performance models based on multichain and multiclass Queueing Networks (QN). The UML model is annotated according to the UML Profile for Schedulability, Performance and Time Specification. The proposed algorithm translates the annotated UML specification into QN performance models, which can then be analyzed using standard solution techniques. Performance results are reported back at the software architecture level in the UML diagrams. As our approach can be fully automated and uses standard UML annotations, it can be integrated with other performance modeling approaches. Specifically, we discuss how this QN-based approach can be integrated with an existing simulation-based performance modeling tool.

<div class="section abstract"><div class="htmlview paragraph">Ensuring software quality is one of the key challenges associated with the development of automotive embedded systems. Software architecture plays a pivotal role in realizing functional and non-functional requirements for automotive embedded systems. Software architecture is a work-product of the early stages of software development. The design errors introduced at the early stages of development will increase cost of rework. Hence, an early evaluation of software architecture is important.</div><div class="htmlview paragraph">PERSIST (Powertrain control architecture Enabling Reusable Software development for Intelligent System Tailoring) is a model-based software product line approach which focuses on cross-project standardization of powertrain software. The product line is characterized by common design guidelines and adherence to industry standards like ISO 25010, AUTOSAR and ISO 26262. This paper shows a systematic approach to ensure objective, early and repeated analysis of software architecture for the PERSIST product line using metrics. The systematic approach for architecture metrics involves the definition, implementation, measurement and, evaluation of the metrics for hybrid control unit software. With a new approach of architecture-driven development, this paper demonstrates how an early evaluation of the software architecture helps to frontload development efforts and improves software quality.</div></div>

Bioinformaticists use the Basic Local Alignment Search Tool (BLAST) to characterize an unknown sequence by comparing it against a database of known sequences, thus detecting evolutionary relationships and biological properties. mpiBLAST is a widely-used, high-performance, open-source parallelization of BLAST that runs on a computer cluster delivering super-linear speedups. However, the Achilles heel of mpiBLAST is its lack of modularity, thus adversely affecting maintainability and extensibility. Alleviating this shortcoming requires an architectural refactoring to improve maintenance and extensibility while preserving high performance. Toward that end, this paper evaluates five different software architectures and details how each satisfies our design objectives. In addition, we introduce a novel approach to using mixin layers to enable mixing-and-matching of modules in constructing sequence-search applications for a variety of high-performance computing systems. Our design, which we call "mixin layers with refined roles", utilizes mixin layers to separate functionality into complementary modules and the refined roles in each layer improve the inherently modular design by precipitating flexible and structured parallel development, a necessity for an open-source application. We believe that this new software architecture for mpiBLAST-2.0 will benefit both the users and developers of the package and that our evaluation of different software architectures will be of value to other software engineers faced with the challenges of creating maintainable and extensible, high-performance, bioinformatics software.

The function and significance of mission-critical software-intensive systems have got substantial recognition. Software architecture has become a new field since system software is all the time more intricate. Agile software development counters the advancement in requirement, besides to attend to the fixed plan. In this paper, the effort has been made to find parameters for software architecture evaluation and then evaluate software architecture under agile environment based on the determined parameters.

The paper examined the problem of modeling and design of software computer systems. The article briefly describes the content aspects of the various stages of the implementation of software complexes and systems. The methodology of research and analysis of systems, which uses the method of computer simulation modeling, is given. The aim of the work is to create a new universal approach to the design and implementation of software systems of various levels of complexity. During the study, the following general scientific methods were used: system analysis, synthesis, formalization, modeling, decomposition, structuring, description, comparison. The materials used in the study were: computers and software development tools. As a result of the study proposed a universal agent-module approach to the design and implementation of software systems based on simulation agent-based modeling. The study presents the processes of modeling and designing software systems, their stages, and the possibility of their integration within the described approach. Examples of formal model and structure of the software system under design based on the agent-module approach are presented. The proposed approach can be used in the process of software development at the initial stages related to modeling and designing of software systems. Integration of modeling and design stages in the proposed approach will significantly reduce software development time and simplify the design process by making it clearer and more formalized. Materials of the article are of scientific and practical value for a wide range of specialists interested in system analysis, modeling, design and implementation of software systems.

Architectural evaluation to determine a software architecture's fitness with respect to its desired quality attributes is one of the most important issues in architecture-based software development. However, existing techniques have too many limitations for widespread application, such as the inappropriate representation of architecture and ambiguities in the evaluation process. Therefore, this paper presents an approach to evaluate software architecture with a 4+1 view model in UML. Our approach is divided into three main areas of activity: the work involved in preparation, execution, and completion of the evaluation. By performing these activities, architecture evaluation can be explicitly described and its result can be systematically organized based on the 4+1 view model. In addition, we show the practical applicability and features of our approach via an ATM example.

The analysis of multi-unit extracellular recordings of brain activity has led to the development of numerous tools, ranging from signal processing algorithms to electronic devices and applications. Currently, the evaluation and optimisation of these tools are hampered by the lack of ground-truth databases of neural signals. These databases must be parameterisable, easy to generate and bio-inspired, i.e. containing features encountered in real electrophysiological recording sessions. Towards that end, this article introduces an original computational approach to create fully annotated and parameterised benchmark datasets, generated from the summation of three components: neural signals from compartmental models and recorded extracellular spikes, non-stationary slow oscillations, and a variety of different types of artefacts. We present three application examples. (1) We reproduced in-vivo extracellular hippocampal multi-unit recordings from either tetrode or polytrode designs. (2) We simulated recordings in two different experimental conditions: anaesthetised and awake subjects. (3) Last, we also conducted a series of simulations to study the impact of different level of artefacts on extracellular recordings and their influence in the frequency domain. Beyond the results presented here, such a benchmark dataset generator has many applications such as calibration, evaluation and development of both hardware and software architectures.

Current implementation methodologies for platform-based development strategies presume that product variants are made clear and explicit prior to application. However, this might not be the case in many engineer-to-order companies where product variants typically emerge from individual developments over time, commonly without a predefined product strategy. Also, information related to different product variants is usually spread across multiple sources. This makes it difficult to identify the information on which a future configure-to-order strategy can be built. In this article, a systematic, visual approach to identify, analyze, and structure product variant information has been developed. A real-world, proof-of-concept demonstrator case has been defined to verify the proposed modeling approach applied to the unstructured product portfolio of a small- and medium-sized enterprise company that manufactures road signpost masts and gantries. The outcome is a product portfolio map that visualizes the product variants in the product family side by side, and a variant map that provides a closer overview of functional structure and related physical variants. Hence, these two maps combined provide a systemized overview of the product variants at different abstraction levels as a knowledge source. It is concluded that this study has demonstrated the potential of a step-by-step methodology for preparing a dispersed product portfolio as a basis for the implementation of a configure-to-order strategy.