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.     

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...     

A model-driven engineering framework for embedded systems design

This work presents a Model-Driven Engineering (MDE) framework to improve embedded system design. The framework adopts concepts from MDE for the automatic generation of a control and data flow internal representation, starting from the functional specification of an embedded application described using UML class and sequence diagrams. By means of transformations rules applied on the UML model of the embedded system, an MOF-based (Meta Object Facility is a standard representation for meta-models and models proposed by OMG) internal representation is automatically obtained, which is iteratively mapped into a hardware/software implementation by means of model transformations. This mapping is optimized by a design space exploration (DSE) method based on a categorical graph product. The model transformations have also as input a platform model, which specifies the available hardware, software and interface resources, and produce an implementation model, on which software synthesis, communication synthesis and high-level synthesis algorithms are applied to generate the final implementation. A case study is described to illustrate the application of the framework.     

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.     

rCOS: a formal model-driven engineering method for component-based software

Model-driven architecture (MDA) has become a main stream technology for software-intensive system design. The main engineering principle behind it is that the inherent complexity of software development can only be mastered by building, analyzing and manipulating system models. MDA also deals with system complexity by providing component-based design techniques, allowing independent component design, implementation and deployment, and then system integration and reconfiguration based on component interfaces. The model of a system in any stage is an integration of models of different viewpoints. Therefore, for a model-driven method to be applied effectively, it must provide a body of techniques and an integrated suite of tools for model construction, validation, and transformation. This requires a number of modeling notations for the specification of different concerns and viewpoints of the system. These notations should have formally defined syntaxes and a unified theory of semantics. The underlying theory of the method is needed to underpin the development of tools and correct use of tools in software development, as well as to formally verify and reason about properties of systems in mission-critical applications. The modeling notations, techniques, and tools must be designed so that they can be used seamlessly in supporting development activities and documentation of artifacts in software design processes. This article presents such a method, called the rCOS, focusing on the models of a system at different stages in a software development process, their semantic integration, and how they are constructed, analyzed, transformed, validated, and verified.     

A model-driven workflow fragmentation framework for collaborative workflow architectures and systems

This paper focuses on a workflow distribution methodology for rationally deploying workflow models onto a distributed workflow system running on cloud computing environments, and we particularly lay a stress upon that those workflow systems operable on cloud computing environments are dubbed collaborative workflow systems, which are not only built upon the collaborative workflow architectures proposed in the paper, but pursuing the so-called collaborative computing paradigm characterized by focusing collaboration over cloud computing environments. The essential idea of the workflow distribution methodology is about how to fragment a workflow model and how to allocate its fragments to each of the architectural components configuring the underlying collaborative workflow architecture and system. As a reasonable solution to realize the essential idea, the paper proposes a model-driven workflow fragmentation framework, which provides a series of fragmentation algorithms that semantically fragmentate a workflow model by considering the semantic factors - performer, role, control-flow, data-flow, etc. - of the ICN-based workflow model as fragmentation criteria. The algorithms are classified into the vertical fragmentation approach, the horizontal fragmentation approach, and the hybrid approach of both. Conclusively, this paper conceives a possible set of collaborative workflow architectures embedding the collaborative computing paradigm, and describes the detailed formalism of the framework and about how the framework works on those collaborative workflow architectures and systems.     

The chamois component-based knowledge engineering framework

A prototype software framework and research testbed exploits recent findings in knowledge engineering to power an electronic commerce application. Chamois combines two main components. The infrastructure component consists of software products and prototype modules that provide key knowledge engineering technologies. The application component uses the infrastructure as a data and knowledge resource. We chose the primary application, an electronic commerce system, as our validation candidate because it includes various functional components that use the underlying knowledge engineering technology. These components include personalization, security, quality-of-service transmission of multimedia data, querying, and XML document management     

A model-driven framework for enterprise service management

With a steady pace of adoption of service-oriented architecture, enterprises have made significant progresses in implementing various kinds of Web services and converting existing applications to service-oriented architecture. As a significant number of services have been put into actual use, many service-oriented enterprises are faced with the problem of how to manage these services efficiently. In this paper, we propose a model-driven framework for a more efficient management of these services. In this framework, the creation and maintenance of enterprise integration solutions are modeled by flows, finite state machines (FSMs), role-based access control (RBAC) among other formal systems models as well as appropriate decision models. For instance, each enterprise integration solution would be modeled as composite services that can be described by respective flow, FSM and RBAC models. These solution models can then be stored, and later retrieved for the execution of these composite services. Furthermore, formal systems and decision models are also used to maintain and update these service-oriented solutions to improve the efficiency and quality of service management by taking advantage of the underlying service-oriented architecture.     

基于改进随机森林算法的Android恶意软件检测

Android系统的开放性和第三方应用市场的多样性,使其在取得高市场占有率的同时也带来了巨大的风险,导致Android恶意应用层出不穷并广泛传播,严重威胁了用户的隐私和经济安全. 如何有效检测Android恶意应用受到了研究人员的广泛关注. 根据是否运行应用程序,将现有的恶意应用检测方法分为静态检测和动态检测. 其中,静态检测的效率和代码覆盖率均优于动态检测,Drebin等静态检测工具取得了广泛应用. 为此,系统调研了Android恶意应用静态检测领域的研究进展,并进行了分析和总结. 首先,介绍了Android应用静态特征;然后,根据静态特征的不同,分别对基于权限、应用程序编程接口（application programming interface,API）和操作码等不同静态特征的Android恶意应用检测方法进行了分析,并总结了常用的Android应用数据集和评价Android恶意应用检测性能的常用指标;最后,对Android恶意应用静态检测技术的发展进行了总结和展望,以期为该领域的研究人员提供参考.

     

A graph-based framework for model-driven optimization facilitating impact analysis of mutation operator properties

Optimization problems in software engineering typically deal with structures as they occur in the design and maintenance of software systems. In model-driven optimization (MDO), domain-specific models are used to represent these structures while evolutionary algorithms are often used to solve optimization problems. However, designing appropriate models and evolutionary algorithms to represent and evolve structures is not always straightforward. Domain experts often need deep knowledge of how to configure an evolutionary algorithm. This makes the use of model-driven meta-heuristic search difficult and expensive. We present a graph-based framework for MDO that identifies and clarifies core concepts and relies on mutation operators to specify evolutionary change. This framework is intended to help domain experts develop and study evolutionary algorithms based on domain-specific models and operators. In addition, it can help in clarifying the critical factors for conducting reproducible experiments in MDO. Based on the framework, we are able to take a first step toward identifying and studying important properties of evolutionary operators in the context of MDO. As a showcase, we investigate the impact of soundness and completeness at the level of mutation operator sets on the effectiveness and efficiency of evolutionary algorithms.

     

A component-based simulation environment for statistical process control systems analysis

This paper describes a simulation environment, called Prosim, which permits a user to define components, subsystems, and their interconnections to analyse a statistical process control (SPC) system. The components and systems are defined and analysed interactively. A library of standard SPC objects containing models for the Xbar, range, exponential weighted moving average, p-chart and other SPC techniques have been created which help define the control application. The PC-based tool is tested on theoretical, and real data, and is useful for the design and trouble shooting of a manufacturing system. It is also an effective teaching and research tool.     

Maintaining component-based systems

As we continue to move toward component-based software engineering, software development will become more like traditional manufacturing: developers will code less and design and integrate more. The author argues that to reap the benefits of component-based development: reduced time to market, more user choice, and lower costs, we must rethink our software maintenance strategies. He gives a wide-ranging overview of the maintenance challenges raised by component-based development     

A model-driven development framework for enterprise Web services

The growing scale and complexity of the enterprise computing systems under distributed and heterogeneous environments present new challenges to system development, integration, and maintenance. In this paper, we present a model driven Web service development framework to combat these challenges. The framework capitalizes on the unified modeling language (UML) profile for enterprise distributed object computing (EDOC), MDA (model-driven architecture) and Web services. Within the framework, firstly, a general PIM (platform independent models) is created using the EDOC CCA structural specification and CCA choreography specification which defines the general functions of a system. Secondly, the general PIM is broken down into sub-PIMs according to functional decomposition, each of which can provide service independently and will be implemented in a Web service. Thirdly, all of the PIMs are transformed to Web service interface models for publication and invoking. Afterward, transform each PIM to a BPEL specified Web service orchestration model. Finally, supported by model transform techniques, the sub EDOC PIMs are implemented into Web services on specific platforms. Automatic model transformation is the key to this framework, therefore, the transformation from EDOC CCA models to WSDL specified Web service interface models and the transformation from EDOC CCA models to BPEL specified Web service orchestration models are deeply discussed, and the detailed transformation rules are proposed. A case study is also provided to demonstrate the effectiveness of these rules and the merits of this framework.

A model-driven traceability framework for software product lines

Software product line (SPL) engineering is a recent approach to software development where a set of software products are derived for a well defined target application domain, from a common set of core assets using analogous means of production (for instance, through Model Driven Engineering). Therefore, such family of products are built from reuse, instead of developed individually from scratch. SPL promise to lower the costs of development, increase the quality of software, give clients more flexibility and reduce time to market. These benefits come with a set of new problems and turn some older problems possibly more complex. One of these problems is traceability management. In the European AMPLE project we are creating a common traceability framework across the various activities of the SPL development. We identified four orthogonal traceability dimensions in SPL development, one of which is an extension of what is often considered as “traceability of variability”. This constitutes one of the two contributions of this paper. The second contribution is the specification of a metamodel for a repository of traceability links in the context of SPL and the implementation of a respective traceability framework. This framework enables fundamental traceability management operations, such as trace import and export, modification, query and visualization. The power of our framework is highlighted with an example scenario.     

基于构件技术的快速样机原型的软件框架

以自主研发的HLRESP（honeycomb-like rapid embedded system platform）快速样机系统为基础,提出一种基于构件技术地快速样机原型的软件框架。该软件系统以Eclipse开放平台为基础,并采纳了角色的概念,使之能够支持一定程度上的多人协作开发任务。提出了板级IP（BLIP）的概念,使其在软件系统中的管理方式与FPGA内的IP管理方式一致,简化了软件设计工作。对于IP库的管理,使用了XML（extensible markup language）表示IP（intellectual property）,结合CVS版本控制系统,使得用户能够方便地从IP构件库中获得、配置并集成IP。     

A framework for automated distributed implementation of component-based models

Although distributed systems are widely used nowadays, their implementation and deployment are still time-consuming, error-prone, and hardly predictable tasks. In this paper, we propose a method for producing automatically efficient and correct-by-construction distributed implementations from a model of the application software in Behavior, Interaction, Priority (BIP). BIP is a well-founded component-based framework encompassing high-level multi-party interactions for synchronizing components (e.g., rendezvous and broadcast) and dynamic priorities for scheduling between interactions. Our method transforms an arbitrary BIP model into a Send/Receive BIP model that is directly implementable on distributed execution platforms. The transformation consists in (1) breaking the atomicity of actions in components by replacing synchronous multiparty interactions with asynchronous Send/Receive interactions; (2) inserting distributed controllers that coordinate the execution of interactions according to a user-defined partition of interactions, and (3) adding a distributed algorithm for handling conflicts between controllers. The obtained Send/Receive BIP model is proven observationally equivalent to its corresponding initial model. Hence, all functional properties of the initial BIP model are preserved by construction in the implementation. Moreover, the obtained Send/Receive BIP model can be used to automatically derive distributed executable code. The proposed method is fully implemented. Currently, it is possible to generate C++ implementations for (1) TCP sockets for conventional distributed communication, (2) MPI for multi-processor platforms, and (3) POSIX threads for deployment on multi-core platforms. We present four case studies and report experimental results for different design choices including partition of interactions and choice of algorithm for distributed conflict resolution.     

The reliability estimation, prediction and measuring of component-based software

Reliability is a key driver of safety-critical systems such as health-care systems and traffic controllers. It is also one of the most important quality attributes of the systems embedded into our surroundings, e.g. sensor networks that produce information for business processes. Therefore, the design decisions that have a great impact on the reliability of a software system, i.e. architecture and components, need to be thoroughly evaluated. This paper addresses software reliability evaluation during the design and implementation phases; it provides a coherent approach by combining both predicted and measured reliability values with heuristic estimates in order to facilitate a smooth reliability evaluation process. The approach contributes by integrating the component-level reliability evaluation activities (i.e. the heuristic reliability estimation, model-based reliability prediction and model-based reliability measuring of components) and the system-level reliability prediction activity to support the incremental and iterative development of reliable component-based software systems. The use of the developed reliability evaluation approach with the supporting tool chain is illustrated by a case study. The paper concludes with a summary of lessons learnt from the case studies.     

基于组件的软件可靠性计算方法

提出了一种基于组件的软件可靠性的计算方法。该方法首先利用各现成商用组件的说明信息,对组件的输入域进行划分,然后构建马尔可夫链,最终根据各组件之间的关系求出整个系统的软件可靠性。这种方法对基于组件的软件的可靠性进行了定量计算,是一种可行的方法。     

Computational framework for long-term reliability analysis of RC structures

In many engineering fields, durability aspects with damage-oriented structural assessments recently have gained increasing interest. Thus new demands both for theoretical developments and analysis concepts are required. Because of their complexity, previous published researches hereby often have followed some aspects very accurately, while others were oversimplified. The present contribution proposes a rational computational concept for long-term reliability of RC structures. It is based on a novel combination of nonlinear damage analysis with efficient probabilistic reliability estimations, balancing mechanical modelling, analysis and stochastic aspects with acceptable computing time. Thereby, new 3D models for short-time behavior and for fatigue of concrete are applied. A time-variant reliability study of a RC bridge column with respect to stability failure under fatigue conditions demonstrates the general applicability of the derived strategy.