Yanchun Sun

Supporting runtime software architecture: A bidirectional-transformation-based approach

Runtime software architectures (RSA) are architecture-level, dynamic representations of running software systems, which help monitor and adapt the systems at a high abstraction level. The key issue to support RSA is to maintain the causal connection between the architecture and the system, ensuring that the architecture represents the current system, and the modifications on the architecture cause proper system changes. The main challenge here is the abstraction gap between the architecture and the system. In this paper, we investigate the synchronization mechanism between architecture configurations and system states for maintaining the causal connections. We identify four required properties for such synchronization, and provide a generic solution satisfying these properties. Specifically, we utilize bidirectional transformation to bridge the abstraction gap between architecture and system, and design an algorithm based on it, which addresses issues such as conflicts between architecture and system changes, and exceptions of system manipulations. We provide a generative tool-set that helps developers implement this approach on a wide class of systems. We have successfully applied our approach on JOnAS JEE system to support it with C2-styled runtime software architecture, as well as some other cases between practical systems and typical architecture models.

Towards a unified formal model for supporting mechanisms of dynamic component update

The continuous requirements of evolving a delivered software system and the rising cost of shutting down a running software system are forcing researchers and practitioners to find ways of updating software as it runs. Dynamic update is a kind of software evolution that updates a running program without interruption. This paper covers the fundamental issues of the mechanisms of dynamic update theoretically. Based on a similarity analysis of many typical approaches to dynamic update during the past decades, we propose a unified formal model (namely, Dynamic Update Connector) to specify mechanisms of updating an architectural component, and reason about its properties. The model borrows the concept of connectors from software architecture community and is specified using process algebra CSP. We also demonstrate the applications of our DUC model.

Towards Automated Solution Synthesis and Rationale Capture in Decision-Centric Architecture Design

Software architectures are considered crucial because they are the earliest blueprints for target products and at the right level for achieving system-wide qualities. Existing methods of architecture design still face the challenge of bridging the gap between software requirements and architectures in practice. The emerging methods that focus on design decisions and rationale provide little support for deriving target architectures. In this paper we propose a decision- centric architecture design approach, which models issues, solutions, decisions, and rationale as the core elements of architecture design and the key notions to direct the derivation of target architectures. The approach transits from requirements to architectures through a process including issue eliciting, solution exploiting, solution synthesizing, and architecture deciding. We implement the automated synthesis of candidate architecture solutions from various issue solutions, and provide a way to capture comprehensive design decisions and rationale during this design process. We finally illustrate the applicability of this approach with a case study.

Instant and incremental QVT transformation for runtime models

As a dynamic representation of the running system, a runtime model provides a model-based interface to monitor and control the system. A key issue for runtime models is to maintain their causal connections with the running system. That means when the systems change, the models should change accordingly, and vice versa. However, for the abstract runtime models that are heterogeneous to their target systems, it is challenging to maintain such causal connections. This paper presents a model-transformation-based approach to maintaining causal connections for abstract runtime models. We define a new instant and incremental transformation semantics for the QVT-Relational language, according to the requirements of runtime models, and develop the transformation algorithm following this semantics. We implement this approach on the mediniQVT transformation engine, and apply it to provide the runtime model for an intelligent office system named SmartLab.

Inferring meta-models for runtime system data from the clients of management APIs

A new trend in runtime system monitoring is to utilize MOF-based techniques in analyzing the runtime system data. Approaches and tools have been proposed to automatically reflect the system data as MOF compliant models, but they all require users to manually build the meta-models that define the types and relations of the system data. To do this, users have to understand the different management APIs provided by different systems, and find out what kinds of data can be obtained from them. In this paper, we present an automated approach to inferring such meta-models by analyzing client code that accesses management APIs. A set of experiments show that the approach is useful for realizing runtime models and applicable to a wide range of systems, and the inferred meta-models are close to the reference ones.

Architecture Design for the Large-Scale Software-Intensive Systems: A Decision-Oriented Approach and the Experience

Software architectures are considered the key means to manage the complexity of large-scale systems from the high abstraction levels and system-wide perspectives. The traditional software design methodologies and the emerging architecture design methods still fall short of coping with the architectural complexity and difficulty in practice. The recent research on the architecture design decisions mostly focuses on its representation, providing little support for the architecture design task itself. In this paper we propose a decision-oriented architecture design approach ABC/DD, based on the decision-abstraction and issue-decomposition principles specific to the architecture level design of software. The approach models software architecture from the perspective of design decisions, and accomplishes the architecture design from eliciting architecturally significant design issues to exploiting and making decisions on the solutions for these issues. We illustrate the application of the approach with two real-life large-scale software-intensive projects, showing that the decision-oriented approach accommodates the characteristics and demands of the architecture level, and facilitates the design of architecture and the capture of the essential decisions for large complex systems.

SM@RT: representing run-time system data as MOF-compliant models

Runtime models represent the dynamic data of running systems, and enable developers to manipulate the data in an abstract, model-based way. This paper presents SM@RT, a tool that help realize runtime models on a wide class of systems. Receiving a meta-model specifying the target systems data type and an API description specifying how to manipulate the data, SM@RT automatically generates the synchronizer to maintain the runtime model for this system.

An Approach for Generation of J2EE Access Control Configurations from Requirements Specification

Access control of sensitive resources is a widely used means to achieve information security. When building large-scale systems based on popular commercial component middleware, such as J2EE, a usual way to enforce access control is to define access control configurations for components in a declarative manner. These configurations can be interpreted by the J2EE security service to grant or deny access requests to components. However, it is difficult for the developers to define correct access control configurations according to complex and sometimes ambiguous real-world access control requirements. The difficulties come from mainly the complexity of configuring voluminous component methods in large-scale component based systems and some quality constraints on the configurations, for example, the completeness, consistency and performance overhead of configurations. In this paper, we propose a requirements model driven approach for automatic generation of J2EE access control configurations and demonstrate the approach in a J2EE blueprint application.

The challenge and practice of creating Software Engineering curriculum

Software Engineering is important for the students majored in computer science and technology. This curriculum is intended to provide students with an overall view over Software Engineering as an engineering discipline and with insight into the processes of software development. Creating software Engineering curriculum faces several challenges: (1) Software Engineering has wide coverage, but teaching time is limited. So it is difficult to make in-depth education. (2) Some introductory Software Engineering courses present the principles in isolation from practice. Teaching the lectures seems to focus on philosophy and methodology level, which leads to difficulty for students having no practical experience to understand. (3) Due to the lack of software project practice, students can hardly apply appropriate software engineering methods and technologies to solve problems. (4) How can Software Engineering curriculum satisfy the various needs of different levels? This paper focuses on the challenges above, and introduces how to try to solve them by a case study on the construction of Software Engineering curriculum at Peking University. Finally, this paper gives the future direction for the construction of Software Engineering curriculum.

Automated assembly of Internet-scale software systems involving autonomous agents

On the Internet, there is a great amount of distributed software entities deployed independently and behaving autonomously. This paper describes an automated approach to constructing Internet-scale software systems based on autonomous software agents. In the approach, the systems are modeled by interconnected divisions and cooperative roles. The approach adopts a dynamic trial-and-evaluation strategy to select high quality autonomous agents to undertake the responsibilities of roles, and implements a special mobile agent, called delegate, carrying the interaction information specified for responsibilities of roles to facilitate the interoperations among autonomous agents. The experiments show that the approach is highly scalable and improves the overall qualities of systems remarkably.