From requirements negotiation to software architecture decisions

Architecture design and requirements negotiations are conceptually tightly related but often performed separately in real-world software development projects. As our prior case studies have revealed, this separation causes uncertainty in requirements negotiation that hinders progress, limits the success of architecture design, and often leads to wasted effort and substantial re-work later in the development life-cycle. Explicit requirements elicitation and negotiation is needed to be able to appropriately consider and evaluate architecture alternatives and the architecture alternatives need be understood during requirements negotiation. This paper propose the WinCBAM framework, extending an architecture design method, called cost benefit analysis method (CBAM) framework to include an explicit requirements negotiation component based on the WinWin methodology. We then provide a retrospective case study that demonstrates the use of the WinCBAM. We show that the integrated method is substantially more powerful than the WinWin and CBAM methods performed separately. The integrated method can assist stakeholders to elicit, explore, evaluate, negotiate, and agree upon software architecture alternatives based on each of their requirement Win conditions. By understanding the architectural implication of requirements they can be negotiated more successfully: potential requirements conflicts can be discovered or alleviated relatively early in the development life-cycle.     

深空探测器自主健康管理需求及其软件架构

由于深空探测器距离远,要求具有很强的自主健康管理能力.目前大多数深空探测器自主健康管理功能为型号特定、缺乏统一的健康管理方法及软件架构,难以实现星载自主健康管理软件的通用化.针对此问题,本文对深空探测器自主健康管理需求进行了分析,提出了一种基于包应用标准和航天器接口业务标准的自主健康管理方法,设计了分层的通用软件架构.本文对架构中与健康管理相关的在轨监视业务构件、事件报告业务构件、事件动作业务构件等3个核心构件进行了详细设计,并进一步说明了架构在原理样机中的应用验证情况.     

一种软件体系结构可修改性评估方法的研究

计算机软件系统中系统规模不断扩大,软件系统的质量在一定程度上越来越取决于系统的体系结构.体系结构分析评价的目的是为了识别体系结构设计中的潜在风险,帮助开发人员进行设计决策.现在用于软件体系结构可修改性评估的方法却不多,本文就软件体系结构的可修改性方面提出了一种评估方法,该方法是基于场景的软件体系结构分析,其中分析的目标主要集中在可修改性这一质量属性上.该方法通过五个步骤展开对软件体系结构的评估分析,在评估分析的过程中也提出了一些具体的相关技术.     

An evaluation of methods for prioritizing software requirements

This article describes an evaluation of six different methods for prioritizing software requirements. Based on the quality requirements for a telephony system, the authors individually used all six methods on separate occasions to prioritize the requirements. The methods were then characterized according to a number of criteria from a user's perspective. We found the analytic hierarchy process to be the most promising method, although it may be problematic to scale-up. In an industrial follow-up study we used the analytic hierarchy process to further investigate its applicability. We found that the process is demanding but worth the effort because of its ability to provide reliable results, promote knowledge transfer and create consensus among project members.     

An architecture for dynamic and evolving cooperative software agents

This paper presents an architectural model to construct cooperative and evolutionary agent-based software systems. Here, a software system is defined as one consisting of a set of agents which interact by executing actions and by determining system functionality. Because the agents need intercommunication and coordination, we propose a model that allows this communication between agents and preserves system activity. This coordination model uses a blackboard as the means of communication between the system agents. The system architecture presented is dynamic in the sense that the modelled system can evolve and be adapted to its new functions. To do this, we distinguish two levels in the architecture: the system and the meta-system levels. The system level describes the system's structure and its functionality, while the meta-system level allows us to effect changes in the system in such a way as to preserve the system's integrity and restrictions. Modifications at the system level are carried out when the developer interacts at the meta-system level. System users interact only at the system level.     

An architecture for security-oriented perfective maintenance of legacy software

This work presents an implementation strategy which exploits the separation of concerns and reuse in a multi-tier architecture to improve the security (availability, integrity, and confidentiality) level of an existing application. Functional properties are guaranteed via wrapping of the existing software modules. Security mechanisms are handled by the business logic of the middle-tier: availability and integrity are achieved via replication of the functional modules and the confidentiality is obtained via cryptography. The technique is presented with regard to a case study application. We believe that our experience can be used as a guideline for software practitioners to solve similar problems. We thus describe the conceptual model behind the architecture, discuss implementation issues, and present technical solutions.     

Characterizing software architecture changes: A systematic review

With today’s ever increasing demands on software, software developers must produce software that can be changed without the risk of degrading the software architecture. One way to address software changes is to characterize their causes and effects. A software change characterization mechanism allows developers to characterize the effects of a change using different criteria, e.g. the cause of the change, the type of change that needs to be made, and the part of the system where the change must take place. This information then can be used to illustrate the potential impact of the change. This paper presents a systematic literature review of software architecture change characteristics. The results of this systematic review were used to create the Software Architecture Change Characterization Scheme (SACCS). This report addresses key areas involved in making changes to software architecture. SACCS’s purpose is to identify the characteristics of a software change that will have an impact on the high-level software architecture.     

网构软件体系结构代数模型

由于网络化软件的规模和复杂程度的不断增加,设计可伸缩的软件体系结构,开发可演化的软件系统遇到了挑战.挑战之一是很难把软件模型与原系统说明区分开来,使得软件系统的可演化性受到限制.一个有效的途径是建立可范用软件体系结构的抽象模型,指导网构软件设计,从而提高软件模型的概括能力和可伸缩能力.本文提出一种网构软件体系结构代数模型,其中一个创新思想是把网构连接子解释成网构变量的运算.结合代数学方法和软件实现技术,定义了6种网构连接运算,所有运算是对连接子的代数抽象,因此软件体系结构的抽象表达能力得到了加强.为了展示提出代数模型的建模与分析辅助作用,介绍了一个基于代数模型的网构软件设计与演化的案例研究.     

An innovative software architecture to improve information flow from CAM to CNC

Over the years, machine tool evolution has allowed faster equipment, using new configurations, to manufacture parts that were almost impossible to machine in the past. Despite this tremendous evolution in machine and control technologies, the metalworking industry is still using the old ISO 6983 G-Codes programming interface to control the motion of these machines. This programming interface is not the most flexible or most appropriate for use by new open-architecture machine controllers and object-oriented high-level machining interfaces such as ISO 14649 (STEP-NC). This work proposes an innovative language, the ‘Base Numerical Control Language (BNCL),’ which is based on a low-level simple instruction set-like approach. The architecture is designed around two concepts: the BNCL virtual machine, which acts as a virtual microprocessor, and the BNCL virtual hardware, which is an abstraction of the machine tool. The language is characterised by its simplicity and flexibility, two qualities that are critical in a market in which the capabilities and performance of machines are constantly improving. The proposed architectural concepts are validated through various computer simulation and physical tests, including performance throughput, trajectory driving, and CNC controller extension capabilities.     

An exploratory study on ontology engineering for software architecture documentation

The usefulness of Software Architecture (SA) documentation depends on how well its Architectural Knowledge (AK) can be retrieved by the stakeholders in a software project. Recent findings show that the use of ontology-based SA documentation is promising. However, different roles in software development have different needs for AK, and building an ontology to suit these needs is challenging. In this paper we describe an approach to build an ontology for SA documentation. This approach involves the use of typical questions for eliciting and constructing an ontology. We outline eight contextual factors, which influence the successful construction of an ontology, especially in complex software projects with diverse AK users. We tested our ‘typical question’ approach in a case study and report how it can be used for acquiring and modeling AK needs.     

An aspect‐oriented software architecture for code mobility

Mobile agents have come forward as a technique for tackling the complexity of open distributed applications. However, the pervasive nature of code mobility implies that it cannot be modularized using only object‐oriented (OO) concepts. In fact, developers frequently evidence the presence of mobility scattering in their system's modules. Despite these problems, they usually rely on OO application programming interfaces (APIs) offered by the mobility platforms. Such classical API‐oriented designs suffer a number of architectural restrictions, and there is a pressing need for empowering developers with an architectural framework supporting a flexible incorporation of code mobility in the agent applications. This work presents an aspect‐oriented software architecture, called ArchM, ensuring that code mobility has an enhanced modularization and variability in agent systems, and is straightforwardly introduced in otherwise stationary agents. It addresses OO APIs' restrictions and is independent of specific platforms and applications. An ArchM implementation also overcomes fine‐grained problems related to mobility tangling and scattering at the implementation level. The usefulness and usability of ArchM are assessed within the context of two case studies and through its composition with two mobility platforms. Copyright © 2008 John Wiley & Sons, Ltd.     

一种软件体系结构复杂性的评价方法

为了满足软件体系结构复杂性的预测和评价需求,通过抽取构件之间的连接,提出了基于复合关系的分层式软件体系结构,从而能够清晰、准确地表达构件之间的关系。在该结构基础上,提出了基于加权图的复杂性评价模型,并结合实例分析了模型的使用效果。模型能够准确地刻画系统结构及构件关系,而且能够较为客观地定量评估系统结构复杂性。它具有实现过程简单、通用性强等特点。     

An integration experience of a software architecture and a monitoring infrastructure to deploy applications with non‐functional requirements in computing grids

Resource management is an important aspect to consider regarding applications that might have different non‐functional or operational requirements, when running in distributed and heterogeneous environments. In this context, it is necessary to provide the means to specify the required resource constraints and an infrastructure that can adapt the applications in light of the changes in resource availability. We adopted a contract‐based approach to describe and maintain parallel applications that have non‐functional requirements in a Computing Grid context, called ZeliGrid. To form the supporting infrastructure we have designed a software architecture that integrates some of the Globus services, the LDAP and the NWS monitoring services. Some modules that map the contract approach into software artifacts were also integrated to this architecture. This paper addresses the architecture and integration issues of our approach, as well as how we put the pieces together highlighting deployment and implementation details, which have to consider diverse aspects such as monitoring, security and dynamic reconfiguration. Copyright © 2010 John Wiley & Sons, Ltd.     

An optimization framework for “build-or-buy” decisions in software architecture

Building a software architecture that meets functional requirements is a quite consolidated activity, whereas keeping high quality attributes is still an open challenge. In this paper we introduce an optimization framework that supports the decision whether to buy software components or to build them in-house upon designing a software architecture. We devise a non-linear cost/quality optimization model based on decision variables indicating the set of architectural components to buy and to build in order to minimize the software cost while keeping satisfactory values of quality attributes. From this point of view, our tool can be ideally embedded into a Cost Benefit Analysis Method to provide decision support to software architects. The novelty of our approach consists in building costs and quality attributes on a common set of decision variables related to software development. We start from a special case of the framework where the quality constraints are related to the delivery time and the product reliability, and the model solution also devises the amount of unit testing to be performed on built components. We generalize the framework formulation to represent a broader class of architectural cost-minimization problems under quality constraints, and discuss advantages and limitations of such approach.     

From safety analysis to software requirements

Software for safety critical systems must deal with the hazards identified by safety analysis. This paper investigates, how the results of one safety analysis technique, fault trees, are interpreted as software safety requirements to be used in the program design process. We propose that fault tree analysis and program development use the same system model. This model is formalized in a real-time, interval logic, based on a conventional dynamic systems model with state evolving over time. Fault trees are interpreted as temporal formulas, and it is shown how such formulas can be used for deriving safety requirements for software components     

An extended software defined optical networks slicing architecture

Optical Networks are composed of multiple devices, from multiple vendors. Normally these networks have a huge transmission capacity. The Slicing of Optical Networks is not a new concept, but continues to be very important, since the capacity of Optical Networks keeps evolving. Most of the time the slicing is manually configured by system operators. Besides being laborious and error-prone, such configuration limits the clients’ ability to customize and configure the network according to their own needs. One way out of this problem is to separate from these devices the control of and the data from the planes. The Software Defined Networks (SDNs) propose the separation of planes while also offering network operators the flexibility to create and manage applications, enabling them to reduce the network costs by globally optimizing the network’s resources, reducing the staff needed to configure it, and contributing for less violation of the service level agreement (SLA). SDN can also help operators to maximize their profit by generating more revenue through mechanisms that increase availability and failure resiliency, maximize throughput, allow for fast dynamic reprovisioning and enable network virtualization. The goal of this paper is to propose a Software Defined Optical Networks Slicing Architecture (SONA) extension (eSONA). that permits defining components such as topology manager, inventory manager, slice manager and path provisioner, and thus enable Optical Networks slicing. It has proved to be capable of managing different slices and provisioning a path on a given slice over the same physical optical network. It has showed an excellent performance, taking little time to provision paths, even with a large number of nodes, which are crucial for optical environments.     

Arcade: early dynamic property evaluation of requirements using partitioned software architecture models

A fundamental goal of software engineering research is to develop evaluation techniques that enable analysis early in the software development process, when correcting errors is less costly. The Systems Engineering Process Activities (SEPA) Arcade tool employs a number of techniques to evaluate dynamic properties of requirements including correctness, performance, and reliability. To mitigate a number of practical issues associated with dynamic property evaluation, Arcade leverages the SEPA 3D Architecture, a formal requirements representation that partitions requirements types amongst a set of interrelated architecture models. This paper presents a case study illustrating how Arcade uses the SEPA 3D Architecture to help manage complexity associated with dynamic property evaluation, to reduce the level of evaluation technique expertise required to perform dynamic property evaluations, and to support an iterative, incremental approach that allows early evaluation using partial requirements models.     

An object based algebra for specifying a fault tolerant software architecture

In this paper we present an algebra of actors extended with mechanisms to model crash failures and their detection. We show how this extended algebra of actors can be successfully used to specify distributed software architectures. The main components of a software architecture can be specified following an object-oriented style and then they can be composed using asynchronous message passing or more complex interaction patterns. This formal specification can be used to show that several requirements of a software system are satisfied at the architectural level despite failures. We illustrate this process by means of a case study: the specification of a software architecture for intelligent agents which supports a fault tolerant anonymous interaction protocol.     

Abstractions for software architecture and tools to support them

Architectures for software use rich abstractions and idioms to describe system components, the nature of interactions among the components, and the patterns that guide the composition of components into systems. These abstractions are higher level than the elements usually supported by programming languages and tools. They capture packaging and interaction issues as well as computational functionality. Well-established (if informal) patterns guide the architectural design of systems. We sketch a model for defining architectures and present an implementation of the basic level of that model. Our purpose is to support the abstractions used in practice by software designers. The implementation provides a testbed for experiments with a variety of system construction mechanisms. It distinguishes among different types of components and different ways these components can interact. It supports abstract interactions such as data flow and scheduling on the same footing as simple procedure call. It can express and check appropriate compatibility restrictions and configuration constraints. It accepts existing code as components, incurring no runtime overhead after initialization. It allows easy incorporation of specifications and associated analysis tools developed elsewhere. The implementation provides a base for extending the notation and validating the model