Louis Féraud

An Approach of Model Transformation Based on Attribute Grammars

Attribute grammars have been developed by Knuth [9] for the specification and implementation of static semantic aspects of programming languages. Since then, they have matured into a recognized field of study with many applications [17]. In this paper, we propose a system for transformation of information system models based on this formalism. First, the problem will be defined followed by the necessity for model transformation. Next, some model transformations approaches are presented, with special attention to XSLT. This brief survey gives the characteristics of the problem of model transformation and situates our approach. The semantics offered by attribute grammars brings the rigor of formal semantics while providing good performance at the implementation by a specific software called an evaluator. Thus, our system architecture consists essentially in defining a textual abstract syntax of the source meta-models and in building an attribute grammar to express the transformation. The input of the automatically generated evaluator is some text describing the source model, the syntax of which is defined by an abstract syntax. The output of the evaluator is another text corresponding to the target model in accordance with its grammar. In the last section, the characteristics and the benefits of our approach are discussed.

Towards Interoperability in Component Based Development with a Family of DSLs

In this paper we address interoperability between components specified using various languages within a same family of DSLs. Our approach consists in applying results of the category theory in order to merge the languages into a unification one, automatically obtained. For this, we use the category of formal specifications of each DSL in the family. Using colimits on the category of algebraic specifications that implements the semantics of the DSLs in the family, we construct a language that unifies the family. Additionally we obtain translation morphisms from individual DSLs to the resulting unified one. By application of the translation morphisms, one can translate each component specifications into a specification written in the unification language. Moreover, properties established in the context of a DSL are transferred to the unifying language. In this paper, we illustrate the unification and the preservation of a property on an example.

Typed lambda-terms in categorical attributed graph transformation

This paper deals with model transformation based on attributed graph rewriting. Our contribution investigates a single pushout approach for applying the rewrite rules. The computation of graph attributes is obtained through the use of typed λ -calculus with inductive types. In this paper we present solutions to cope with single pushout construction for the graph structure and the computations functions. As this rewrite system uses inductive types, the expr essiveness of attribute computations is facilitated and appears more efficient than the one based on Σ-algebras. Some examples showing the interest of our computation approach are described in this paper.

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.

A Model to Design Reusable Parallel Software Components

The definition of objects in a parallel environment can be viewed as that of classes, devoted to the construction of objects, which are composed of two kind of ancestors. A first kind contains the basic elements necessary for the definition of an abstract data type. A second is devoted to handling constraints resulting from the parallel execution of methods. These constraints are called “concurrency constraints”. Each component of ancestor can be viewed as a reusable software component. In this paper, we focus on class extension which deals with interference problems which are provoked by the above class composition. In this proposal, we aim to implement synchronization and inheritance without decreasing the expressive power of “concurrency constraints”.

A 'two degrees of freedom' approach for parallel programming

The concept of a priority controlled module (PCM), which is intended to implement shared objects in a parallelism environment is presented. Semantics of a PCM are given using a temporal logic. Experiences adapting the inheritance mechanisms to the synchronization domain using the concept of a PCM are also described. Because PCM mainly relies on the separation between data abstraction and synchronization, either of these can be thought as a degree of freedom. Each degree of freedom appears as a reusable programming entity, and can be implemented using the concept of a class occurring in the object-oriented languages.<<ETX>>

Computations in graph rewriting: inductive types and pullbacks in DPO approach

In this paper, we give a new formalism for attributed graph rewrites resting on category theory and type theory. Our main goal is to offer a single theoretical foundation that embeds the rewrite of structural parts of graphs and attribute computations which has more expressive power for attribute computations as well.

How could object-oriented concepts and parallelism cohabit?

A lot of new languages and new concepts have been conceived in order to promote parallelism in the object-oriented framework. These proposals could be investigated using different concepts related to parallelism and object orientation. Among these concepts, we can find shared variables/message passing, inheritance/delegation, reflection. The degrees of a good cohabitation may be appreciated by combining the above concepts. In order to have significant criteria we have to determine how languages fit some requirements. These requirements should cover the different phases of programs development i.e. specification, design and implementation. To structure the discussion, we may focus on some formalisms and languages, in order to specify and to implement concurrent objects. The benefits of the different classes of these formalisms and languages should be discussed from a methodological point of view. The issues to be addressed in this context could include the following questions: what are the main characteristic design principles and methodologies of concurrent object-oriented programming? How could the current object-oriented methodologies handle concurrent and distributed objects?.<<ETX>>

Attribute Computations in the DPoPb Graph Transformation Engine

One of the challenges of attributed graph rewriting systems concerns the implementation of attribute computations. Most of the existing systems adopt the standard algebraic approach where graphs are attributed using sigma-algebras. However, for the sake of efficiency considerations and convenient uses, these systems do not generally implement the whole attribute computations but rely on programs written in a host language. In previous works we introduced the Double Pushout Pullback (DPoPb) framework which integrates attributed graph rewriting and computation on attributes in a unified categorical approach. This paper discusses the DPoPb’s theoretical and practical advantages when using inductive types and lambda-calculus. We also present an implementation of the DPoPb system in the Haskell language which thoroughly covers the semantics of this graph rewriting system.