Christian Percebois

Bad smells in design and design patterns.

To give a consistent and more valuable property on models, model-driven processes should be able to reuse the expert knowledge generally expressed in terms of patterns. We focus our work on the design stage and on the systematically use of design patterns. Choose a good design pattern and ensure the correct integration of the chosen pattern are non trivial for a designer who wants to use them. To help designers, we propose design inspection in order to detect “bad smells in design” and models reworking through use of design patterns. The automatic detection and the explanation of the misconceptions are performed thanks to spoiled patterns. A “spoiled pattern” is a pattern which allows to instantiate inadequate solutions for a given problem: requirements are respected, but architecture is improvable.

Rule-Level Verification of Graph Transformations for Invariants Based on Edges' Transitive Closure

This paper develops methods to reason about graph transformation rules for proving the preservation of structural properties, especially global properties on reachability. We characterize a graph transformation rule with an applicability condition specifying the matching conditions of the rule on a host graph as well as the properties to be preserved during the transformation. Our previous work has demonstrated the possibility to reason about a graph transformation at rulelevel with applicability conditions restricted to Boolean combinations of edge expressions. We now extend the approach to handle the applicability conditions containing transitive closure of edges, which implicitly refer to an unbounded number of nodes. We show how these can be internalized into a finite pattern graph in order to enable verification of global properties on paths instead of local properties on edges only.

A methodology for integration of patterns with validation purpose

Design patterns are now widely used as a meaning to store and retrieve valuable expert information in order to solve a given problem or provide a selected property. During the software development life cycle, software engineers choose and integrate patterns depending on the specifications. We are proposing a methodology for pattern integration with validation activities. The proposed solution highlights a set of artifacts and practices, based on widely accepted standards such as OCL and UML, a pattern modeling language and using SPEM for the process definition. While ensuring the correctness of the integration, our process is flexible enough to let the designer adapts the solution to his/her particular needs. To illustrate our process, we will apply it to the GoF Mediator pattern and an UML class diagram representing the application of an air traffic controller.

A Modeling and Formal Approach for the Precise Specification of Security Patterns

Non-functional requirements such as Security and Dependability (S &D) become more important as well as more difficult to achieve. In fact, the integration of security features requires the availability of both application domain specific knowledge and security expertise at the same time. Hence, capturing and providing this expertise by the way of security patterns can support the integration of S&D features by design to foster reuse during the process of software system development. n nThe solution envisaged here is based on combining metamodeling techniques and formal methods to represent security pattern at two levels of abstraction fostering reuse during the process of pattern development and during the process of pattern-based development. The contribution of this work is twofold: (1) An improvement of our previous pattern modeling language for representing security pattern in the form of a subsystem providing appropriate interfaces and targeting security properties, (2) Formal specification and validation of pattern properties, using the interactive Isabelle/HOL proof assistant. The resulting validation artifacts may mainly complete the definitions, and provide semantics for the interfaces and the properties in the context of S&D. As a result, validated patterns will be used as bricks to build applications through a Model-Driven engineering approach.

Towards a Rule-Level Verification Framework for Property-Preserving Graph Transformations

We report in this paper a method for proving that a graph transformation is property-preserving. Our approach uses a relational representation for graph grammar and a logical representation for graph properties with first-order logic formulas. The presented work consists in identifying the general conditions for a graph grammar to preserve graph properties, in particular structural properties. We aim to implement all the relevant notions of graph grammar in the Isabelle/HOL proof assistant in order to allow a (semi) automatic verification of graph transformation with a reasonable complexity. Given an input graph and a set of graph transformation rules, we can use mathematical induction strategies to verify statically if the transformation preserves a particular property of the initial graph. The main highlight of our approach is that such a verification is done without calculating the resulting graph and thus without using a transformation engine.

SynchSPEM: A synchronization metamodel between activities and products within a SPEM-based Software Development Process

The Software Process Engineering Metamodel (SPEM) is used to define and describe software development processes and their components. This metamodel contains three main entities: roles, activities and products. Our goal is to ensure synchronization between activities and products of a software development process in order that one of the two entities will be notified and adapted in accordance with the changes of the other. This paper presents an overview of SPEM, and reviews its implementations. A metamodel based on SPEM 2.0 is then proposed to synchronize activities and products within a software development process.

Dealing with variability within a family of domain-specific languages: comparative analysis of different techniques

Almost a decade has passed since the OMG has issued the Model Driven Architecture (MDA) initiative. It soon became obvious that raising the level of abstraction in development and reasoning at the model level would help in asking the right questions at the right time. Based on a concrete problem, we discuss four alternative solutions to a multi-language system design problem. These solutions use a traditional approach, a technique based on modeling, a domain-specific approach, and a mix of modeling and domain-specific techniques, respectively. The solutions depend on the problem, but they are representative for the situations we encounter in practice, therefore giving us a good basis for a larger discussion on the appropriateness of using modeling techniques and on the place of MDA in current software engineering practice and design.

Spoiled patterns: how to extend the GoF

Design patterns were popularized by the GoF catalog in 1995. This catalog contains 23 design patterns which concern 23 design problems. Each pattern is detailed with its structure, its intent, and some information including applicability conditions and some possible variations which enable it to be re-used. In 1995, they were the cutting edge thought processes. We consider that design patterns have two major features. First, they are the result of emergent conceptions validated by a community through a well-defined acceptance process. They are a field of expert knowledge. Secondly, they must be as abstract as needed to be able to maximize their reusability. They constitute a compilation of best practices concerning object codes and designs. We propose to extend the GoF with a new concept that we have named “spoiled patterns”. They are midway between bad smells in design necessary to go ahead with a refactoring and a necessary learned lesson in order to explain anti-patterns. Each design pattern corresponds to some spoiled patterns. In this paper, we present how we have compiled the first spoiled patterns catalog, by carrying out several experiments with a lot of young inexperienced designers.

Towards a rigorous framework for dealing with domain specific language families

In this paper we present our approach to rigorously handle variation within a family of languages. Our starting point is a case study that we developed with industrial partners, where a major difficulty arised from the need to work with a set of domain specific languages (DSLs). Our solution is based on using the category theory. We consider the category of algebraic specifications implementing the semantics of the DSLs and we calculate the unifying language of the family.

Towards a change-aware process environment for system and software process

Managing changes for knowledge-intensive processes like System and Software Engineering is a critical issue but far from being mastered due to the lack of supporting methods and practical tools. To manage changes systematically, a process environment is needed to control processes and to handle changes at run-time. However, such an effective environment satisfying these requirements is still missing. The reason is two-folds: first, operational process environments for system and software engineering is scarce; second, there is a lack of efficient change management mechanism integrated in such process environments. In order to address these concerns, we aimed at developing a change-aware process environment for system and software engineering. To this aim, we proposed a change management mechanism based on (1) the Process Dependency Graph (PDG) representing the dependencies among running process instances managed by a process environment ; (2) a Change Observer process to catch change events and update the PDG with run-time information; (3) a Change Analyzer component to extract the impacts of change by reasoning the PDG. In terms of implementation, to gain the benefits from the Business Process Community, where many mature Business Process Management Systems have been developed, we chose jBPM to enact and monitor processes. The key strengths of this study are: first, the PDG makes hidden dependencies among process instances emerge at run-time; second, the process observer inside the BPMS allows to handle the change events in a timely manner. Finally, the Neo4j graph database, used to store the PDG, enables efficient traversal and queries.