Semi-automated architectural abstraction specifications for supporting software evolution

In this paper we present an approach for supporting the semi-automated architectural abstraction of architectural models throughout the software life-cycle. It addresses the problem that the design and implementation of a software system often drift apart as software systems evolve, leading to architectural knowledge evaporation. Our approach provides concepts and tool support for the semi-automatic abstraction of architecture component and connector views from implemented systems and keeping the abstracted architecture models up-to-date during software evolution. In particular, we propose architecture abstraction concepts that are supported through a domain-specific language (DSL). Our main focus is on providing architectural abstraction specifications in the DSL that only need to be changed, if the architecture changes, but can tolerate non-architectural changes in the underlying source code. Once the software architect has defined an architectural abstraction in the DSL, we can automatically generate architectural component views from the source code using model-driven development (MDD) techniques and check whether architectural design constraints are fulfilled by these models. Our approach supports the automatic generation of traceability links between source code elements and architectural abstractions using MDD techniques to enable software architects to easily link between components and the source code elements that realize them. It enables software architects to compare different versions of the generated architectural component view with each other. We evaluate our research results by studying the evolution of architectural abstractions in different consecutive versions of five open source systems and by analyzing the performance of our approach in these cases.     

Towards an Integrated View on Architecture and its Evolution

Information about the evolution of a software architecture can be found in the source basis of a project and in the release history data such as modification and problem reports. Existing approaches deal with these two data sources separately and do not exploit the integration of their analyses. In this paper, we present an architecture analysis approach that provides an integration of both kinds of evolution data. The analysis applies fact extraction and generates specific directed attributed graphs; nodes represent source code entities and edges represent relationships such as accesses, includes, inherits, invokes, and coupling between certain architectural elements. The integration of data is then performed on a meta-model level to enable the generation of architectural views using binary relational algebra. These integrated architectural views show intended and unintended couplings between architectural elements, hence pointing software engineers to locations in the system that may be critical for on-going and future maintenance activities. We demonstrate our analysis approach using a large open source software system.     

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.     

Using software evolution to focus architectural recovery

Ideally, a software project commences with requirements gathering and specification, reaches its major milestone with system implementation and delivery, and then continues, possibly indefinitely, into an operation and maintenance phase. The software system's architecture is in many ways the linchpin of this process: it is supposed to be an effective reification of the system's technical requirements and to be faithfully reflected in the system's implementation. Furthermore, the architecture is meant to guide system evolution, while also being updated in the process. However, in reality developers frequently deviate from the architecture, causing architectural erosion, a phenomenon in which the initial, “as documented' architecture of an application is (arbitrarily) modified to the point where its key properties no longer hold. Architectural recovery is a process frequently used to cope with architectural erosion whereby the current, “as implemented” architecture of a software system is extracted from the system's implementation. In this paper we propose a light-weight approach to architectural recovery, called Focus, which has three unique facets. First, Focus uses a system's evolution requirements to isolate and incrementally recover only the fragment of the system's architecture affected by the evolution. In this manner, Focus allows engineers to direct their primary attention to the part of the system that is immediately impacted by the desired change; subsequent changes will incrementally uncover additional parts of the system's architecture. Secondly, in addition to software components, which are the usual target of existing recovery approaches, Focus also recovers the key architectural notions of software connector and architectural style. Finally, Focus does not only recover a system's architecture, but may in fact rearchitect the system. We have applied and evaluated Focus in the context of several off-the-shelf applications and architectural styles to date. We discuss its key strengths and point out several open issues that will frame our future work.     

Deriving software architectural models from requirements models for adaptive systems: the STREAM-A approach

Some quality attributes are known to have an impact on the overall architecture of a system, so that they are required to be properly handled from the early beginning of the software development. For example, adaptability is a key concern for autonomic and adaptive systems, which brings to them the capability to alter their behavior in response to changes on their surrounding environments. In this paper, we propose a Strategy for Transition between Requirements and Architectural Models for Adaptive systems (STREAM-A). In particular, we use goal models based on the i* (i-Star) framework to support the design and evolution of systems that require adaptability. To obtain software architectures for such systems, the STREAM-A approach uses model transformations from i* models to architectural models expressed in Acme. Both the requirements and the architectural model are refined to accomplish the adaptability requirement.     

Interactive Inconsistency Fixing in Feature Modeling

Feature models have been widely adopted to reuse the requirements of a set of similar products in a domain. In feature models’ construction, one basic task is to ensure the consistency of feature models, which often involves detecting and fixing of inconsistencies in feature models. While many approaches have been proposed, most of them focus on detecting inconsistencies rather than fixing inconsistencies. In this paper, we propose a novel dynamic-priority based approach to interactively fixing inconsistencies in feature models, and report an implementation of a system that not only automatically recommends a solution to fixing inconsistencies but also supports domain analysts to gradually reach the desirable solution by dynamically adjusting priorities of constraints. The key technical contribution is, as far as we are aware, the first application of the constraint hierarchy theory to feature modeling, where the degree of domain analysts’ confidence on constraints is expressed by using priority and inconsistencies are resolved by deleting one or more lower-priority constraints. Two case studies demonstrate the usability and scalability (efficiency) of our new approach.     

Developing and evolving a DSL-based approach for runtime monitoring of systems of systems

Complex software-intensive systems are often described as systems of systems (SoS) due to their heterogeneous architectural elements. As SoS behavior is often only understandable during operation, runtime monitoring is needed to detect deviations from requirements. Today, while diverse monitoring approaches exist, most do not provide what is needed to monitor SoS, e.g., support for dynamically defining and deploying diverse checks across multiple systems. In this paper we report on our experiences of developing, applying, and evolving an approach for monitoring an SoS in the domain of industrial automation software, that is based on a domain-specific language (DSL). We first describe our initial approach to dynamically define and check constraints in SoS at runtime and then motivate and describe its evolution based on requirements elicited in an industry collaboration project. We furthermore describe solutions we have developed to support the evolution of our approach, i.e., a code generation approach and a framework to automate testing the DSL after changes. We evaluate the expressiveness and scalability of our new DSL-based approach using an industrial SoS. We also discuss lessons we learned. Our results show that while developing a DSL-based approach is a good solution to support industrial users, one must prepare the approach for evolution, by making it extensible and adaptable to future scenarios. Particularly, support for automated (re-)generation of tools and code after changes and automated testing are essential.     

Optimized implementation of synchronous models on industrial LTTA systems

Synchronous models are used to specify embedded systems functions in a clear and unambiguous way and allow verification of properties using formal methods. The implementation of a synchronous specification on a distributed architecture must preserve the model semantics to retain the verification results. Globally synchronized time-triggered architectures offer the simplest implementation path, but can be inefficient or simply unavailable. In past work, we defined a mapping of synchronous models on a general class of distributed asynchronous architectures, for which the only requirement is a lower bound on the rate of activation of tasks. In this paper, we set tighter requirements on task execution rates, and we include a realistic modeling of communication delays, task scheduling delays and schedulability conditions, discussing the timing characteristics of an implementation on a system with a Controller Area Network (CAN). Next, the semantics preservation conditions are formulated as constraints in an architecture optimization problem that defines a feasible task model with respect to timing constraints. An automotive case study shows the applicability of the approach and provides insight on the software design elements that are critical for a feasible implementation.     

Data model for extensible support of explicit relationships in design databases

We describe the conceptual model of SORAC, a data modeling system developed at the University of Rhode Island. SORAC supports both semantic objects and relationships, and provides a tool for modeling databases needed for complex design domains. SORAC's set of built-in semantic relationships permits the schema designer to specify enforcement rules that maintain constraints on the object and relationship types. SORAC then automatically generates C++ code to maintain the specified enforcement rules, producing a schema that is compatible with Ontos. This facilitates the task of the schema designer, who no longer has to ensure that all methods on object classes correctly maintain necessary constraints. In addition, explicit specification of enforcement rules permits automated analysis of enforcement propagations. We compare the interpretations of relationships within the semantic and object-oriented models as an introduction to the mixed model that SORAC supports. Next, the set of built-in SORAC relationship types is presented in terms of the enforcement rules permitted on each relationship type. We then use the modeling requirements of an architectural design support system, called Arch Objects, to demonstrate the capabilities of SORAC. The implementation of the current SORAC prototype is also briefly discussed.     

On study of design and implementation of virtual fixtures

Virtual fixtures (VFs) can be defined as guiding constraints designed to enhance or assist human performance in a computer-controlled system by providing cues of haptic or audiovisual nature. In this paper we present a new characterization of VFs based on mechanics, and provide a set practical guidelines for the designers of such fixtures from a software architecture point of view. We propose an event-driven approach that facilitates the integration of these guiding constraints in a scene graphed-based environment. In this context some novel implementation of VFs are presented, where users may interact with a single or an assembled set of fixtures. We present two types of force attributes for VF and present their implications in a trajectory-following problem.     

Quality-driven architecture development using architectural tactics

This paper presents a quality-driven approach to embodying non-functional requirements (NFRs) into software architecture using architectural tactics. Architectural tactics are reusable architectural building blocks, providing general architectural solutions for common issues pertaining to quality attributes. In this approach, architectural tactics are represented as feature models, and their semantics is defined using the Role-Based Metamodeling Language (RBML) which is a UML-based pattern specification notation. Given a set of NFRs, architectural tactics are selected and composed, and the composed tactic is used to instantiate an initial architecture for the application. The proposed approach addresses both the structural and behavioral aspects of architecture. We describe the approach using tactics for performance, availability and security to develop an architecture for a stock trading system. We demonstrate tool support for instantiating a composed tactic to generate an initial architecture of the stock trading system.     

建筑平面图纸理解中关于符号识别的新方法

实现计算机图纸理解的关键在于对图纸中符号的识别,该文提出了一种建筑平面CAD图纸中符号识别的新方法,该方法首先由建筑符号中的几何图元构造出一种矩形网格结构,并用图元与网格之间的约束替换几何图元之间的约束来建立符号的几何特征描述。基于这种描述提出了一个统一的识别方法,最后给出了应用实例,取得了满意的识别效果。     

基于细粒度结构演化的软件转变

如何对既有的软件系统进行软件结构变化，指导软件转变，达到优化质量属性的目的，是目前软件结构研究的一个重要课题．本文从宏观的角度，提出一种细粒度软件结构演化方法(Fine—Grained Software Architectural Evolution，FGSAE)，给出它的具体步骤(依FGSAE原则，重新设计软件结构；依结构对应关系，进行因子调整)，指导软件转变．     

Ontological emergence scheme in self-organized and emerging systems

This paper presents the concept of “Ontological Emergence”, a process that seeks to adapt an ontology to the changes and new components in a self-organized and emergent system, through the application of a set of rules that allows the emergence of a new conceptualization (emerging concepts). The Ontological Emergence provides the structuration of the information and knowledge that could be generated in the system, creating conceptual models that can adequately represent the new behavior that is emerging. It arises from the need to represent ontologically a conceptualization of a reality that is dynamic, which cannot be pre-defined or pre-determined, in order to generate emerging knowledge models that follows the scalability and the evolution of it. In that sense, in this paper is proposed an “Ontological Emergence Scheme” based on a set of processes of registration, monitoring, analysis and adaptation of the various conceptual models that interact in the system, as well as on some processing rules in regard to requirements and information of the context, in order to allow the ontological emergence. In this proposal scheme, the Meta-ontologies guide the ontological emergence process through the definition of general categories, to facilitate the integration of concepts from different ontologies or data sources. Finally, the paper presents some case studies, showing its utility in self-organized and emergent systems.     

Synthesizing Service Composition Models on the Basis of Temporal Business Rules

Transformational approaches to generating design and implementation models from requirements can bring effectiveness and quality to software development. In this paper we present a framework and associated techniques to generate the process model of a service composition from a set of temporal business rules. Dedicated techniques including path-finding,branching structure identification and parallel structure identification are used for semi-automatically synthesizing the process model from the semantics-equivalent Finite State Automata of the rules. These process models naturally satisfy the prescribed behavioral constraints of the rules. With the domain knowledge encoded in the temporal business rules,an executable service composition program,e.g.,a BPEL program,can be further generated from the process models. A running example in the e-business domain is used for illustrating our approach throughout this paper.     

An Empirical Methodology for Exploring Reconfigurable Architectures

Recent research in reduced instruction set computer architectures has emphasized the importance of the empirical approach to designing computer architectures: architectural features are analyzed for utility and cost with respect to the system software that uses them. This approach has resulted in architectural simulators that allow computer designers to vary the features of the architecture being simulated and to analyze how the addition or removal of these features affects the cost and performance of the architecture. In this paper we apply this technique to a new area: reconfigurable architectures. Our approach is to use an empirical methodology that emphasizes the interaction between the target software and the reconfigurability features of parallel architectures. We have developed a set of tools, the reconfigurable architecture workbench, that assists in this methodology by allowing parallel programs to be simulated on a target architecture in order to study the performance implications of various reconfigurability features. The workbench is based on a framework, the PCI model, which describes the range of parallel programs, parallel architectures, and reconfiguration features. We present details of the design and implementation of a prototype workbench, GT-RAW. GT-RAW is being used to study the utility of one dimension of reconfiguration for image processing and image understanding applications. We present an example of the experiments that are being conducted with GT-RAW as a demonstration of our empirical methodology.