Frédéric Fondement

Model-Driven analysis and synthesis of concrete syntax

Metamodeling is raising more and more interest in the field of language engineering. While this approach is now well understood for defining abstract syntaxes, formally defining concrete syntaxes with metamodels is still a challenge. Concrete syntaxes are traditionally expressed with rules, conforming to EBNF-like grammars, which can be processed by compiler compilers to generate parsers. Unfortunately, these generated parsers produce concrete syntax trees, leaving a gap with the abstract syntax defined by metamodels, and further ad-hoc hand-coding is required. In this paper we propose a new kind of specification for concrete syntaxes, which takes advantage of metamodels to generate fully operational tools (such as parsers or text generators). The principle is to map abstract syntaxes to concrete syntaxes via bidirectional mapping-models with support for both model-to-text, and text-to-model transformations.

Platform independent Web application modeling and development with Netsilon

This paper discusses platform independent Web application modeling and development in the context of model-driven engineering. A specific metamodel (and associated notation) is introduced and motivated for the modeling of dynamic Web specific concerns. Web applications are represented via three independent but related models (business, hypertext and presentation). A kind of action language (based on OCL and Java) is used all over these models to write methods and actions, specify constraints and express conditions. The concepts described in the paper have been implemented in the Netsilon tool and operational model-driven Web information systems have been successfully deployed by translation from abstract models to platform specific models.

Making metamodels aware of concrete syntax

Language-centric methodologies, triggered by the success of Domain Specific Languages, rely on precise specifications of modeling languages. While the definition of the abstract syntax is standardized by the 4-layer metamodel architecture of the OMG, most language specifications are held informally for the description of the semantics and the (graphical) concrete syntax. This paper is tackling the problem of specifying the concrete syntax of a language in a formal and non-ambiguous way. We propose to define the concrete syntax by an extension of the already existing metamodel of the abstract syntax, which describes the concepts of the language, with a second layer describing the graphical representation of concepts by visual elements. In addition, an intermediate layer defines how elements of both layers are related to each other. Unlike similar approaches that became the basis of some CASE tools, the intermediate layer is not a pure mapping from abstract to concrete syntax but connects both layers in a flexible, declarative way. We illustrate our approach with a simplified form of statecharts.

Modeling modeling modeling

Model-driven engineering and model-based approaches have permeated all branches of software engineering to the point that it seems that we are using models, as Molière’s Monsieur Jourdain was using prose, without knowing it. At the heart of modeling, there is a relation that we establish to represent something by something else. In this paper we review various definitions of models and relations between them. Then, we define a canonical set of relations that can be used to express various kinds of representation relations and we propose a graphical concrete syntax to represent these relations. We also define a structural definition for this language in the form of a metamodel and a formal interpretation using Prolog. Hence, this paper is a contribution towards a theory of modeling.

Modeling Modeling

Model-driven engineering and model-based approaches have permeated all branches of software engineering; to the point that it seems that we are using models, as Molieres Monsieur Jourdain was using prose, without knowing it. At the heart of modeling, there is a relation that we establish to represent something by something else. In this paper we review various definitions of models and relations between them. Then, we define a canonical set of relations that can be used to express various kinds of representation relations and we propose a graphical concrete syntax to represent these relations. Hence, this paper is a contribution towards a theory of modeling.

Model Driven analysis and synthesis of textual concrete syntax

Meta-modeling is raising more and more interest in the field of language engineering. While this approach is now well understood for defining abstract syntaxes, formally defining textual concrete syntaxes with meta-models is still a challenge. Textual concrete syntaxes are traditionally expressed with rules, conforming to EBNF-like grammars, which can be processed by compiler compilers to generate parsers. Unfortunately, these generated parsers produce concrete syntax trees, leaving a gap with the abstract syntax defined by meta-models, and further ad hoc hand-coding is required. In this paper we propose a new kind of specification for concrete syntaxes, which takes advantage of meta-models to generate fully operational tools (such as parsers or text generators). The principle is to map abstract syntaxes to textual concrete syntaxes via bidirectional mapping-models with support for both model-to-text, and text-to-model transformations.

Big Metamodels Are Evil

While reuse is typically considered a good practice, it may also lead to keeping irrelevant concerns in derived elements. For instance, new metamodels are usually built upon existing metamodels using additive techniques such as profiling and package merge. With such additive techniques, new metamodels tend to become bigger and bigger, which leads to harmful overheads of complexity for both tool builders and users. In this paper, we introduce i¾? package unmergei¾? - a proposal for a subtractive relation between packages - which complements existing metamodel-extension techniques.

Definition and correct refinement of operation specifications

Modern incremental and iterative software engineering processes advocate to build software systems by first creating a highly simplified and abstract model of the system which is then moved by applying a series of model improvements toward implementation. Models of software systems at any level of abstraction should contain, besides structural information, a precise description of the expected system behavior. This paper formalizes relations between models of the same system at different levels of abstraction, classifies approaches for describing behavior of system operations, and investigates how these system operation descriptions can be kept synchronized with frequent changes of the systems structure.

“Weaving” MTL model transformations

Model transformations are the core of the MDA approach to software development. As specified by the OMG, model transformations should act on any kind of model of any kind of metamodel, which implies the possible “reflective” use of model transformations, i.e., model transformations acting on model trans formations. However, this requires transformation developers to be familiar with the metamodel of the transformation language itself, which is not always the case. In order to overcome such a frustrating impediment for the MTL language, and inspired by AOP approaches, we have designed and implemented an MTL weaver that modifies MTL transformations according to some weaving behavior, which is specified as special MTL transformations, called MTL-aspects, using an AOP-like extension to the MTL language. Both the weaver and the language extension are presented in this paper, and an example is used to show how transformation developers can take advantage of the proposed language extension constructs in order to write “reflective” model transformations in MTL without requiring any previous knowledge of the MTL metamodel itself.

Web Site Audience Segmentation Using Hybrid Alignment Techniques

We are working on behavioral marketing in the Internet. On one hand we observe the behavior of visitors, and on the other hand we trigger in real-time stimulations intended to alter this behavior. Real-time and mass-customization are the two challenges that we have to address. In this paper, we present a hybrid approach for clustering visitor sessions, based on a combination of global and local sequence alignments, such as Needleman-Wunsch and Smith-Waterman. Our goal is to define very simple approaches able to address about 80i¾?% of visitor sessions to be segmented, and which can be easily turned into small pieces of program, to be run in parallel in thousands of web browsers.