Editorial to theme issue on model-driven engineering of component-based software systems

Software and Systems Modeling - This theme issue aims at providing a forum for disseminating latest trends in the use and combination of model-driven engineering (MDE) and component-based software...     

Agile MERODE: a model-driven software engineering method for user-centric and value-based development

Agile is often associated with a lack of architectural thinking causing technical debt but has the advantage of user centricity and a strong focus on value. Model-driven software engineering (MDSE) strongly performs for building a quality architecture and code, but lacks focus on user requirements and tends to consider development as a monolithic whole. The combination of Agile and MDSE has been explored, but a convincing integrated method has not been proposed yet. This paper addresses this gap by exploring the specific combination of MERODE—as an example of a proven MDSE method—with Scrum, a reference agile method offering a concrete (sprint-based) life cycle management on the basis of user stories. The method resulting of this integration is called Agile MERODE; it is driven by user stories, themselves associated with behavior-driven development scenarios. It allows for domain-driven design and permits fast development from domain models by means of code generation. An illustrative example further clarifies the practical application of Agile MERODE, while a case study shows the planning game application in the case’s context. While the approach, in its entirety, allows reducing technical debt by building the architecture in a logical, consistent and complete manner, introducing MDSE involves a trade-off with pure value-driven development. Agile MERODE contributes to the state of the art by showing how to increase user centricity in MDSE, how to align model-driven engineering with the Scrum cycle, and how to reduce the technical debt of agile developments yet remaining value-focused.

     

Domain model-driven software engineering: A method for discovery of dependency links

ContextDependency management often suffers from labor intensity and complexity in creating and maintaining the dependency relations in practice. This is even more critical in a distributed development, in which developers are geographically distributed and a wide variety of tools is used. In those settings, different interpretations of software requirements or usage of different terminologies make it challenging to predict the change impact.Objectiveis (a) to describe a method facilitating change management in geographically distributed software engineering by effective discovery and establishment of dependency links using domain models; (b) to evaluate the effectiveness of the proposed method.MethodA domain model, providing a common reference point, is used to manage development objects and to automatically support dependency discovery. We propose to associate (annotate) development objects with the concepts from the model. These associations are used to compute dependency among development objects, and are stepwise refined to direct dependency links (i.e. enabling product traceability). To evaluate the method, we conducted a laboratory-based randomized experiment on two real cases. Six participants were using an implemented prototype and two comparable tools to perform simulated tasks.ResultsIn the paper we elaborate on the proposed method discussing its functional steps. Results from the experiment show that the method can be effectively used to assist in discovery of dependency links. Users have discovered on average fourteen percent more dependency links than by using the comparable tools.ConclusionsThe proposed method advocates the use of domain models throughout the whole development life-cycle and is apt to facilitate multi-site software engineering. The experimental study and results suggest that the method is effective in the discovery of dependencies among development objects.     

Alliance of model-driven engineering with a proof-based formal approach

Model-driven engineering (MDE) promotes the use of models throughout the software development cycle in order to increase abstraction and reduce software complexity. It favors the definition of domain-specific modeling languages (DSMLs) thanks to frameworks dedicated to meta-modeling and code generation like EMF (Eclipse Modeling Framework). The standard semantics of meta-models allows interoperability between tools such as language analysers (e.g., XText), code generators (e.g., Acceleo), and also model transformation tools (e.g., ATL). However, a major limitation of MDE is the lack of formal reasoning tools allowing to ensure the correctness of models. Indeed, most of the verification activities offered by MDE tools are based on the verification of OCL constraints on instances of meta-models. However, these constraints mainly deal with structural properties of the model and often miss out its behavioral semantics. In this work, we propose to bridge the gap between MDE and the rigorous world of formal methods in order to guarantee the correctness of both structural and behavioral properties of the model. Our approach translates EMF meta-models into an equivalent formal B specification and then injects models into this specification. The equivalence between the resulting B specification and the original EMF model is kept by proven design steps leading to a rigorous MDE technique. The AtelierB prover is used to guarantee the correctness of the model’s behavior with respect to its invariant properties, and the ProB model-checker is used to animate underlying execution scenarios which are translated back to the initial EMF model. Besides the use of these automatic reasoning tools in MDE, proved B refinements are also investigated in this paper in order to gradually translate abstract EMF models to concrete models which can then be automatically compiled into a programming language.

     

Towards UML-based formal specifications of component-based real-time software

UML-RT is achieving increasing popularity as a modeling language for real-time applications. Unfortunately UML-RT is not formally well defined and it is not well suited for supporting the specification stage: e.g., it does not provide native constructs to represent time and non-determinism. UML+ is an extension of UML that is formally well defined and suitable for expressing the specifications of real-time systems (e.g., the properties of a UML+ model can be formally verified). However, UML+ does not support design and development. This article addresses the translation of UML+ into UML-RT, thus posing the basis for a development framework where UML+ and UML-RT are used together, in order to remove each other’s limitations. Specifications are written using UML+, they are automatically verified by means of formal methods, and are then converted – through a semi-automatic process – in an equivalent UML-RT model that becomes the starting point for the implementation.     

Supporting model-driven development using a process-centered software engineering environment

The adoption of Model-Driven Development (MDD) is increasing and it is widely recognized as an important approach for building software systems. In addition to traditional development process models, an MDD process requires the selection of metamodels and mapping rules for the generation of the transformation chain which produces models and application code. In this context, software process tasks should be performed in a specific sequence, with the correct input artifacts to produce the output ones. However, existing support tools and transformation engines for MDD do not have a process-centered focus that addresses different kinds of software process activities, such as application modeling and testing to guide the developers. Furthermore, they do not enable process modeling nor the (semi) automated execution of activities during process enactment. The MoDErNE (Model Driven Process-Centered Software Engineering Environment) uses process-centered software engineering environment concepts to improve MDD process specification and enactment by using a metamodeling foundation. In MoDErNE, a software process model may be enacted several times in different software projects. This paper details the MoDErNE environment, its approach and architecture and also the case studies through which the tool was evaluated.     

形式化技术应用于软件逆工程的实践研究

形式化技术为软件逆工程提供严格和完备的理论基础,但应用于实践的非常少。介绍了一种将形式化方法应用于逆工程的具体实现方法,应用最强后条件的形式化技术对命令语言进行逆工程的具体初步实践,分三阶段对源程序进行抽象以得到严格保证正确性和一致性的软件结构规格说明,并且给出了具体的实现方法。     

Constructing component-based software engineering environments: issues and experiences

Developing software engineering tools is a difficult task, and the environments in which these tools are deployed continually evolve as software developers’ processes, tools and tool sets evolve. To more effectively develop such evolvable environments, we have been using component-based approaches to build and integrate a range of software development tools, including CASE and workflow tools, file servers and versioning systems, and a variety of reusable software agents. We describe the rationale for a component-based approach to developing such tools, the architecture and support tools we have used some resultant tools and tool facilities we have developed, and summarise the possible future research directions in this area.     

Using formal methods for teaching software engineering: a tool-based approach

In this paper we describe and review the course plan and syllabus we use in a course on formal methods in software engineering currently included in the degree in Informatics of the Faculty of Sciences at the University of Bologna. The course matches the theory of formal methods with their practice based on actual tool usage. In fact, the course is centered upon a project whose main goal is to let students learn some formal specification techniques, all supported by specific tools. The students use well-known notations for both requirements specification and formal design. The formal methods we use are based on the Z notation for requirements specification and on the Larch family of languages for design specifications.     

Integrating a formal method into a software engineering process with UML and Java

We describe how CSP-OZ, a formal method combining the process algebra CSP with the specification language Object-Z, can be integrated into an object-oriented software engineering process employing the UML as a modelling and Java as an implementation language. The benefit of this integration lies in the rigour of the formal method, which improves the precision of the constructed models and opens up the possibility of (1) verifying properties of models in the early design phases, and (2) checking adherence of implementations to models. The envisaged application area of our approach is the design of distributed reactive systems. To this end, we propose a specific UML profile for reactive systems. The profile contains facilities for modelling components, their interfaces and interconnections via synchronous/broadcast communication, and the overall architecture of a system. The integration with the formal method proceeds by generating a significant part of the CSP-OZ specification from the initially developed UML model. The formal specification is on the one hand the starting point for verifying properties of the model, for instance by using the FDR model checker. On the other hand, it is the basis for generating contracts for the final implementation. Contracts are written in the Java Modeling Language (JML) complemented by CSP_jassda, an assertion language for specifying orderings between method invocations. A set of tools for runtime checking can be used to supervise the adherence of the final Java implementation to the generated contracts. This research was partially supported by the DFG project ForMooS (grants OL 98/3-2 and WE 2290/5-1). C. B. Jones     

航空机载嵌入式控制软件需求建模的形式化工程方法

嵌入式控制软件是现代航空飞行器的核心部件之一。构建软件需求的形式化规约精确地刻画人们对软件期望的功能和运行场景,是确保此类安全攸关软件质量的根本途径。在工业界,形式化需求建模的大规模应用尽管有成功的案例,但仍面临众多的困难。其根本性难点在于缺少一种系统化的工程方法来引导工业界软件实践者,从原始需求开始最终完成形式化需求规约,并能确认该规约真实、充分地反映了人们对软件期望的功能。针对上述挑战,提出了一种面向机载控制软件需求建模的形式化工程方法ACSDL-MV,以形式化方法为理论基础,结合软件需求工程的基本原理,引导工程人员从原始需求出发以演化式的过程逐步完成需求规约的构建;定制了航空控制软件的形式化描述语言ACSDL,用以构建形式化规约;为了确认软件需求规约准确、充分地描述了人们对软件期望的功能,该方法给出了基于图形的静态审查和基于模型的动态模拟技术。在航空发动机公司中的实验结果表明,该方法相比传统方法探测到了更多的潜在错误。     

Building ubiquitous QoC-aware applications through model-driven software engineering

As every-day mobile devices can easily be equipped with multiple sensing capabilities, ubiquitous applications are expected to exploit the richness of the context information that can be collected by these devices in order to provide the service that is the most appropriate to the situation of the user. However, the design and implementation of such context-aware ubiquitous appplications remain challenging as there exist very few models and tools to guide application designers and developers in mastering the complexity of context information. This becomes even more crucial as context is by nature imperfect. One way to address this issue is to associate to context information meta-data representing its quality. We propose a generic and extensible design process for context-aware applications taking into account the quality of context (QoC). We demonstrate its use on a prototype application for sending flash sale offers to mobile users. We present extensive performance results in terms of memory and processing time of both elementary context management operations and the whole context policy implementing the Flash sale application. The cost of adding QoC management is also measured and appears to be limited to a few milliseconds. We show that a context policy with 120 QoC-aware nodes can be processed in less than 100 ms on a mobile phone. Moreover, a policy of almost 3000 nodes can be instantiated before exhausting the resources of the phone. This enables very rich application scenarios enhancing the user experience and will favor the development of new ubiquitous applications.     

A model-driven software engineering workflow and tool architecture for servitised manufacturing

Modern manufacturing businesses increasingly engage in servitisation, by offering advanced services along with physical products, and creating “product–service systems”. Information Technology infrastructures, and especially software, are a critical part of modern service provision. However, software development in this context has not been investigated and there are no development methods or tools specifically adapted to the task of creating software for servitised businesses in general, or manufacturing in particular. In this paper, we define the requirements for software engineering in servitised manufacturing. Based on these, we describe a model-driven software engineering workflow for servitised manufacturing, supporting both structural and behavioural modelling of the service system. Furthermore, we elaborate on the architecture of an appropriate model-driven Integrated Development Environment (IDE). The proposed workflow and a prototype implementation of the IDE were evaluated in a set of industrial pilots, demonstrating improved communication and collaboration between participants in the software engineering process.     

A pattern-based model-driven approach for situational method engineering

ContextConstructing bespoke software development methodologies for specific project situations has become a crucial need, giving rise to Situational Method Engineering (SME). Compared with Software Engineering, SME has a long way to go yet; SME approaches are especially deficient as to support for modeling, portability, and automation. Model-Driven Development (MDD) has been effectively used for addressing these issues in Software Engineering, and is also considered a promising approach for resolving them in SME.ObjectiveThis paper aims to address the shortcomings of existing SME approaches by introducing a novel MDD approach, specifically intended for SME purposes, that uses a pattern-based approach for model transformation.MethodDeveloping a MDD approach for SME requires that a modeling framework, consisting of modeling levels, be defined for modeling software development methodologies. Transformation patterns should also be specified for converting the models from one level to the next. A process should then be defined for applying the framework and transformations patterns to real SME projects. The resulting MDD approach requires proper evaluation to demonstrate its applicability.ResultsA framework and a semi-automated process have been proposed that adapt pattern-based model transformation techniques for application to the methodology models used in SME. The transformation patterns have been implemented in the Medini-QVT model transformation tool, along with two supplementary method bases: one for mapping the situational factors of SME projects to requirements, and the other for mapping the requirements to method fragments. The method engineer can produce the methodology models by using the method bases and executing the transformation patterns via the tool.ConclusionThe validity of the proposed approach has been assessed based on special evaluation criteria, and also through application to a real-world project. Evaluation results indicate that the proposed approach addresses the deficiencies of existing approaches, and satisfies the practicality requirements of SME approaches.     

Refinement and verification in component-based model-driven design

Modern software development is complex as it has to deal with many different and yet related aspects of applications. In practical software engineering this is now handled by a UML-like modelling approach in which different aspects are modelled by different notations. Component-based and object-oriented design techniques are found effective in the support of separation of correctness concerns of different aspects. These techniques are practised in a model-driven development process in which models are constructed in each phase of the development. To ensure the correctness of the software system developed, all models constructed in each phase are verifiable. This requires that the modelling notations are formally defined and related in order to have tool support developed for the integration of sophisticated checkers, generators and transformations. This paper summarises our research on the method of Refinement of Component and Object Systems (rCOS) and illustrates it with experiences from the work on the Common Component Modelling Example (CoCoME). This gives evidence that the formal techniques developed in rCOS can be integrated into a model-driven development process and shows where it may be integrated in computer-aided software engineering (CASE) tools for adding formally supported checking, transformation and generation facilities.     

A model-driven process for the modernization of component-based systems

Software modernization is critical for organizations that need cost-effective solutions to deal with the rapid obsolescence of software and the increasing demand for new functionality. This paper presents the XIRUP modernization methodology, which proposes a highly iterative process, structured into four phases: preliminary evaluation, understanding, building and migration. This modernization process is feature-driven, component-based, focused on the early elicitation of key information, and relies on a model-driven approach with extensive use of experience from the previous projects. XIRUP has been defined in the European IST project MOMOCS, which has also built a suite of support tools. This paper introduces the process using a case study that illustrates its activities, related tools and results. The discussion highlights the specific characteristics of modernization projects and how a customized methodology can take advantage of them.     

A validation of the component-based method for software sizeestimation

Estimation of software size is a crucial activity among the tasks of software management. Work planning and subsequent estimations of the effort required are made based on the estimate of the size of the software product. Software size can be measured in several ways: lines of code (LOC) is a common measure and is usually one of the independent variables in equations for estimating several methods for estimating the final LOC count of a software system in the early stages. We report the results of the validation of the component-based method (initially proposed by Verner and Tate, 1988) for software sizing. This was done through the analysis of 46 projects involving more than 100,000 LOC of a fourth-generation language. We present several conclusions concerning the predictive capabilities of the method. We observed that the component-based method behaves reasonably, although not as well as expected for “global” methods such as Mark II function points for software size prediction. The main factor observed that affects the performance is the type of component     

An efficient method for developing requirement specifications for plant control software using a component-based software prototype

This paper proposes an efficient method to develop requirement specifications for Plant Control Software (PCSW) using software-component-based prototypes. Prior to this proposal, domain analyses were conducted on existing PCSWs, and their functions were classified into “similar functions” and “individual functions”. Then PCSW Software Components (PSC: PCSW Software Component, PSCs: PCSW Software Components) were developed to correspond to these functions. PSCs as parameter-style components were developed in order to satisfy the clients’ (we define clients as owners, managers and operators of plants) requirements. A support environment for developing requirement specifications was developed. The environment consists of the Prototype Development Tool (PDT), the Behavior Check Simulator (BCS) and the Requirement Specification Development Tool (RSDT). The method consists of four steps. In the first step, PDT is used to define the parameters to customize PSCs and to compose a PCSW prototype by setting these parameters to PSCs. In the second step, BCS is used to execute the composed PCSW prototype and check its behavior and relevancy against the clients’ expectations. In the third step, steps 1 and 2 are repeated until the behavior of the PCSW prototype satisfies the clients’ requirements. Finally, a requirement specification is developed from the PCSW prototype which fully reflects the clients’ requirements. In order to evaluate the proposed method, it has been applied in five development cases. A Requirement Coverage of 91%, a Requirement Revision Rate of 6%, a PSC Reuse Rate of 92% and a LOC Reuse Rate of 83% have been achieved. In addition, a reduction of 55% in the amount of time required to develop requirement specifications has been achieved. These results indicate that the proposed method has sufficient capability to develop an exhaustive and an adequate PCSW requirement specification. And the developed PSCs have sufficient functions and capability to compose PCSW prototypes, and the support environment is capable of shortening the time taken to develop requirement specifications.