Marie-Pierre Gervais

A canonical scheme for model composition

There is little agreement on terminology in model composition, and even less on key characteristics of a model composition solution. We present three composition frameworks: the Atlas Model Weaver, the Epsilon Merging Language, and the Glue Generator Tool, and from them derive a core set of common definitions. We use this to outline the key requirements of a model composition solution, in terms of language and tool support.

Definition of an Executable SPEM 2.0

One major advantage of executable models is that once constructed, they can be run, checked, validated and improved in short incremental and iterative cycles. In the field of software process modeling, process models have not yet reached the level of precision that would allow their execution. Recently the OMG issued a new revision of its standard for software process modeling, namely SPEM2.0. However, even if executability was defined as a mandatory requirement in the RFP (request for proposal), the adopted specification does not fulfill it. This paper presents a critical analysis on the newly defined standard and addresses its lacks in terms of executability. An approach is proposed in order to extend the standard with a set of concepts and behavioural semantics that would allow SPEM2.0 process models to be checked through a mapping to Petri nets and monitored through a transformation into BPEL.

Model bus: towards the interoperability of modelling tools

MDA software development requires the interoperability of a wide range of modelling services (operations taking models as inputs and outputs), such as model edition, model transformation, and code generation. In particular, software development life cycle requires the interoperability of different modelling services. In particular, this interoperability concerns how to “connect” services (how to send an output model produced by one service as an input to another service). Today, the notion of modelling services is not yet well defined. Moreover, CASE tools, which implements different services, have heterogeneous interfaces. For this reason, the service connection is costly and cannot be automated. Currently, there are few works addressing this problem. Therefore, we propose an architecture and a prototype enabling the services of different tools to be connected.

A Comparison of Six UML-Based Languages for Software Process Modeling

Describing and managing activities, resources, and constraints of software development processes is a challenging goal for many organizations. A first generation of Software Process Modeling Languages (SPMLs) appeared in the 1990s but failed to gain broad industrial support. Recently, however, a second generation of SPMLs has appeared, leveraging the strong industrial interest for modeling languages such as UML. In this paper, we propose a comparison of these UML-based SPMLs. While not exhaustive, this comparison concentrates on SPMLs most representative of the various alternative approaches, ranging from UML-based framework specializations to full-blown executable metamodeling approaches. To support the comparison of these various approaches, we propose a frame gathering a set of requirements for process modeling, such as semantic richness, modularity, executability, conformity to the UML standard, and formality. Beyond discussing the relative merits of these approaches, we also evaluate the overall suitability of these UML-based SPMLs for software process modeling. Finally, we discuss the impact of these approaches on the current state of the practice, and conclude with lessons we have learned in doing this comparison.

UML4SPM: a UML2.0-Based metamodel for software process modelling

In the context of Model Driven Development, models play a central role. Since models can nowadays be executed, they are used not only for description but also for production [32][30][24]. In the field of software process modelling, the current version of the OMG SPEM standard (ver1.1) has not yet reached the level required for the specification of executable models. The purpose of SPEM1.1 was limited at providing process descriptions to be read by humans and to be supported by tools, but not to be executed. Therefore, the OMG issued a new RFP in order to improve SPEM1.1 [35]. Since we intend to participate in the next major revision of SPEM, namely SPEM2.0, in this work, we: 1) compare SPEM1.1 both with primary process model elements (i.e. Activity, Product, Role,...) and with basic requirements that any Process Modelling Language should support (i.e. expressiveness, understandability, executability,...); 2) identify its major limitations and advantages and 3) propose a new UML2.0-based metamodel for software process modelling named: UML4SPM. It extends a subset of UML2.0 concepts – with no impact on the standard – in order to fit software process modelling.

ODAC: An Agent-Oriented Methodology Based on ODP

The ODAC methodology (Open Distributed Applications Construction) aims to provide a designer of agent-based systems with a set of methods and tools to allow him/her to control the construction process complexity of such systems. It enables software engineers to specify agent-based systems that will be implemented within an execution environment, for example a mobile agent platform. Our work is based on the Open Distributed Processing (ODP) standards and the agent paradigm.

UML4SPM: An Executable Software Process Modeling Language Providing High-Level Abstractions

Software processes and software process modeling approaches were and still are in the heart of enterprise preoccupations. This interest is essentially motivated by the increasing need to build reliable and complex software systems in a short time to market. During the three last decades, a variety of Process Modeling Languages were proposed in order to capture the expertise of enterprises. However no one succeeded in gaining the attention of the industry. Main reasons were because that most of them were either imprecise or not suitable to be executed or both. This paper presents UML4SPM, a UML2.0-based Language for software process modelling. Expressiveness, understandability, precision and executability were our main objectives while designing UML4SPM. Our contribution comes inform of MOF-compliant metamodel, a simple yet expressive graphical notation and diagrams and a precise semantics. In order to validate our work, we evaluate UML4SPM with the well-known ISPW-6 process example, a standard benchmark problem for software process modeling

Software Process Modeling and Execution: The UML4SPM to WS-BPEL Approach

Over the two past decades, the software process modeling community is being confronted to the following dilemma: how a software process modeling language (SPML) can be sufficiently abstract to hide the increasing complexity of development processes while being precise enough to be executed? Since no SPML succeeded in satisfying these apparently conflicting requirements, in this paper we propose to combine two languages: UML4SPM, an UML2.0-based software process modeling language and WS-BPEL (web services business process execution language). While UML4SPM brings expressiveness, understandability and abstraction in modeling software development processes, BPEL provides a semantically rich set of concepts for process executions. The mapping between the two languages, how do they complement each other, some issues and the value of the approach are discussed.

Supporting transparent model update in distributed CASE tool integration

Model Driven Architecture (MDA) is a software development approach that focuses on models. In order to support MDA, a lot of CASE tools have emerged; each of them provides a different set of modeling services (operations for automating model manipulation). We have proposed an open environment called ModelBus, which enables the integration of heterogeneous and distributed CASE tools. ModelBus enables tools to invoke the modeling services provided by other tools. In this paper, we focus on supporting a particular kind of modeling services: services that update models (i.e. they have inout parameters). Our contribution is to enable a tool to update models owned by another tool. We propose a parameter passing mechanism that hides the complexity of model update from tools. First, it enables a tool to update models transparently to heterogeneous model representations. Second, it enables a tool to update models located in the memory of another remote tool transparently, as if the models were local. Third, it ensures the integrity between the updated models and the tool that owns the models.

MDA Tool Components: a proposal for packaging know-how in model driven development

As the Model Driven Development (MDD) and Product Line Engineering (PLE) appear as major trends for reducing software development complexity and costs, an important missing stone becomes more visible: there is no standard and reusable assets for packaging the know-how and artifacts required when applying these approaches. To overcome this limit, we introduce in this paper the notion of MDA Tool Component, i.e., a packaging unit for encapsulating business know-how and required resources in order to support specific modeling activities on a certain kind of model. The aim of this work is to provide a standard way for representing this know-how packaging unit. This is done by introducing a two-layer MOF-compliant metamodel. Whilst the first layer focuses on the definition of the structure and contents of the MDA Tool Component, the second layer introduces a language independent way for describing its behavior. An OMG RFP (Request For Proposal) has been issued in order to standardize this approach.