Model-driven service engineering in home telecare

Health care systems are highly dynamic not just due to developments and innovations in diagnosis and treatments, but also by virtue of emerging management techniques supported by modern information and communication technology. A multitude of stakeholders such as patients, nurses, general practitioners or social carers can be integrated by modeling complex interactions necessary for managing the provision and consumption of health care services. Furthermore, it is the availability of Service-oriented Architecture (SOA) that supports those integration efforts by enabling the flexible and reusable composition of autonomous, loosely-coupled and web-enabled software components. However, there is still the gap between SOA and predominantly business-oriented perspectives (e.g. business process models). The alignment of both views is crucial not just for the guided development of SOA but also for the sustainable evolution of holistic enterprise architectures. In this paper, we combine the Semantic Object Model (SOM) and the Business Process Modelling Notation (BPMN) towards a model-driven approach to service engineering. By addressing a business system in Home Telecare and deriving a business process model, which can eventually be controlled and executed by machines; in particular by composed web services, the full potential of a process-centric SOA is exploited.

Evolution feature oriented model driven product line engineering approach for synergistic and dynamic service evolution in Clouds: four kinds of schema.

The proposed research will focus on developing a novel approach to solve Software Service Evolution problems in Computing Clouds. The approach will support dynamic evolution of the software service in clouds via a set of discovered evolution patterns. An initial survey informed us that such an approach does not exist yet and is in urgent need. Evolution Requirement can be classified into evolution features; researchers can describe the whole requirement by using evolution feature typology, the typology will define the relation and dependency between each features. After the evolution feature typology has been constructed, evolution model will be created to make the evolution more specific. Aspect oriented approach can be used for enhance evolution feature-model modularity. Aspect template code generation technique will be used for model transformation in the end. Product Line Engineering contains all the essential components for driving the whole evolution process.

Model-Driven requirements engineering process aided by ontologies and natural controlled languages

Researches in Requirements Engineering have been growing in the latest few years. Researchers are concerned with a set of open issues such as: communication between several user profiles involved in software engineering; scope definition; volatility and traceability issues. To cope with these issues a set of works are concentrated in (i) defining processes to collect client s specifications in order to solve scope issues; (ii) defining models to represent requirements to address communication and traceability issues; and (iii) working on mechanisms and processes to be applied to requirements modeling in order to facilitate requirements evolution and maintenance, addressing volatility and traceability issues. We propose an iterative Model-Driven process to solve these issues, based on a double layered CIM to communicate requirements related knowledge to a wider amount of stakeholders. We also present a tool to help requirements engineer through the RE process. Finally we present a case study to illustrate the process and tool s benefits and usage

MDWEnet: a practical approach to achieving interoperability of model-driven web engineering methods

Current model-driven Web Engineering approaches (such as OO-H, UWE or WebML) provide a set of methods and supporting tools for a systematic design and development of Web applications. Each method addresses different concerns using separate models (content, navigation, presentation, business logic, etc.), and provide model compilers that produce most of the logic and Web pages of the application from these models. However, these proposals also have some limitations, especially for exchanging models or representing further modeling concerns, such as architectural styles, technology independence, or distribution. A possible solution to these issues is provided by making model-driven Web Engineering proposals interoperate, being able to complement each other, and to exchange models between the different tools. MDWEnet is a recent initiative started by a small group of researchers working on model-driven Web Engineering (MDWE). Its goal is to improve current practices and tools for the model-driven development of Web applications for better interoperability. The proposal is based on the strengths of current model-driven Web Engineering methods, and the existing experience and knowledge in the field. This paper presents the background, motivation, scope, and objectives of MDWEnet. Furthermore, it reports on the MDWEnet results and achievements so far, and its future plan of actions.

Evolution feature oriented model driven product line engineering approach for synergistic and dynamic service evolution in clouds: A04BPEL3.0 proposal.

Model Driven based approach for Service Evolution in Clouds will mainly focus on the reusable evolution patterns' advantage to solve evolution problems. During the process, evolution pattern will be driven by MDA models to pattern aspects. Weaving the aspects into service based process by using Aspect-Oriented extended BPEL engine at runtime will be the dynamic feature of the evolution.

Towards an understanding of model driven process configuration and its support at large

The common presupposition of Enterprise Systems (ES) is that they lead to significant efficiency gains. However, this is only the case for well-implemented ES that meet organisational requirements. The list of major ES implementation failures is as long as the list of success stories. We argue here that this arises from a more fundamental problem, the functionalist approach to ES development and provision. As long as vendors will continue to develop generic, difficult-to-adapt ES packages, this problem will prevail because organisations have a non-generic character. A solution to this problem can only consist in rethinking the way ES packages are provided. We propose a strict abstraction layer of ES functionalities and their representation as conceptual models. ES vendors must provide sufficient means for configuring these conceptual models. We discuss in this paper what generic situations can occur during process model configuration in order to understand process model configuration in depth.

Model-driven process configuration of enterprise systems

The configuration of comprehensive enterprise systems to meet the specific requirements of an organisation up to today is consuming significant resources. The results of failing or delayed enterprise system implementation projects are severe and may even threaten the organisation’s existence. One of the main drivers for implementing comprehensive enterprise systems is to streamline business processes. However, an intuitive conceptual support for business process configuration is insufficiently addressed by enterprise system vendors and inadequately researched in academia. This paper presents a model-driven approach to target this problem and proposes several configuration patterns that describe generic patterns of configuration alternatives, in order to understand what situations can occur during business process configuration. Based on these configuration patterns, a configuration notation is introduced that allows for visually highlighting configuration alternatives. Finally, we will sketch how configurable Event Driven Process Chains and the configuration of business processes can be supported using relational databases.

Towards agent-oriented model-driven architecture

Model Driven Architecture supports the transformation from reusable models to executable software. Business representations, however, cannot be fully and explicitly represented in such models for direct transformation into running systems. Thus, once business needs change, the language abstractions used by MDA (e.g. Object Constraint Language / Action Semantics), being low level, have to be edited directly. We therefore describe an Agent-oriented Model Driven Architecture (AMDA) that uses a set of business models under continuous maintenance by business people, reflecting the current business needs and being associated with adaptive agents that interpret the captured knowledge to behave dynamically. Three contributions of the AMDA approach are identified: 1) to Agent-oriented Software Engineering, a method of building adaptive Multi-Agent Systems; 2) to MDA, a means of abstracting high level business-oriented models to align executable systems with their requirements at runtime; 3) to distributed systems, the interoperability of disparate components and services via the agent abstraction.

Model Driven Architecture (MDA): Integration and Model Reuse for Open Source eLearning Platforms

Open Source (OS) community offers numerous eLearning platforms of both types: Learning Management Systems (LMS) and Learning Content Systems (LCS). General purpose OS intermediaries such as SourceForge, ObjectWeb, Apache or specialized intermediaries like CampusSource reduce the cost to locate such eLearning platforms. Still, it is impossible to directly compare the functionalities of those OS software products without performing detailed testing on each product. Some articles available from eLearning Wikipedia show comparisons between eLearning platforms which can help, but at the end they barely serve as documentation which are becoming out of date quickly [1]. The absence of integration activities between OS eLearning platforms - which are sometimes quite similar in terms of functionalities and implementation technologies - is sometimes critical since most of the OS projects possess small financial and human resources. This paper shows a possible solution for these barriers of OS eLearning platforms. We propose the Model Driven Architecture (MDA) concept to capture functionalities and to identify similarities between available OS eLearning platforms. This contribution evolved from a fruitful discussion at the 2nd CampusSource Developer Conference at the University of Muenster (27th August 2004).

Including functional usability features in a Model-Driven Development Method

The Software Engineering (SE) community has historically focused on working with models to represent functionality and persistence, pushing interaction modelling into the background, which has been covered by the Human Computer Interaction (HCI) community. Recently, adequately modelling interaction, and specifically usability, is being considered as a key factor for success in user acceptance, making the integration of the SE and HCI communities more necessary. If we focus on the Model-Driven Development (MDD) paradigm, we notice that there is a lack of proposals to deal with usability features from the very first steps of software development process. In general, usability features are manually implemented once the code has been generated from models. This contradicts the MDD paradigm, which claims that all the analysts? effort must be focused on building models, and the code generation is relegated to model to code transformations. Moreover, usability features related to functionality may involve important changes in the system architecture if they are not considered from the early steps. We state that these usability features related to functionality can be represented abstractly in a conceptual model, and their implementation can be carried out automatically.

Model-Driven safety evaluation with state-event-based component failure annotations

Over the past years, the paradigm of component-based software engineering has been established in the construction of complex mission-critical systems. Due to this trend, there is a practical need for techniques that evaluate critical properties (such as safety, reliability, availability or performance) of these systems. In this paper, we review several high-level techniques for the evaluation of safety properties for component-based systems and we propose a new evaluation model (State Event Fault Trees) that extends safety analysis towards a lower abstraction level. This model possesses a state-event semantics and strong encapsulation, which is especially useful for the evaluation of component-based software systems. Finally, we compare the techniques and give suggestions for their combined usage