Model Driven Development (MDD) is certainly not the revolution that will makes software engineering a piece of cake. However, it sounds (IMHO) an interesting approach to face the building of complex software. While some claims that we are not going to program any more in the future, but we are only going to model our application, it can be said that modeling an application (and this model being complete enough to get a running application) is only higher level programming compare to current programming languages (in the same meaning as Python is an higher level programming language than assembly language).
I am mostly experimenting the use of MDD to the building of n-tiers web applications and distributed component based systems. This includes the providing of processes and tools tailored to the target domain requirements and constraints. Using dedicated tools to perform a task is generally more efficient than using general purpose ones (and to do only as best as one can to overcome their limitations). One of the goal is to be able to draft a working application using MDD in front of the end user before going to construction and finalization steps, and to reduce the finalization step as much as we can (reducing hand-written development to the very true specificities of the user application).
The goal is not to reach complete production of a system from a model (which sounds utopia), but first to reduce as much as possible the feedback loop between developers and users and second to generate as much boilerplate code as possible.
These two projects are aimed at supporting domain oriented and user centric software development. To do so, the underlaying approaches are metamodeling, separation of concerns, and automation (through model transformation and code generation).
Codex is an evolution of the work performed during my PhD thesis. It rely on tools that allow separation of concerns in the definition of a metamodel together with two operators for composing these "partial metamodels". The idea is to refine a metamodel according to its expected use and to define library of concern metamodels that could be reused accross software developement processes.
Vortex is aimed at the definition and tooling of modeling micro-processes. The idea of micro-process was introduced by S.Kent in its "Model Driven Engineering" paper: macro-processes define the how to of software processes from models to code while micro-processes define the how to of building a particular model.
A model is built with an intent in mind and building a model for a particular intent is not that easy (especially when you are not expert of the target domain). The motivation of Vortex is to reify the implicit micro-process used by an expert of an application domain into a tool and to allow users to be assisted and controlled in the definition of their models. Then, the knowledge of the expert benefits to other users that need to develop application for this particular domain.
A modeling micro-process is organized as a set of ordered steps (specified as an automata), each step focusing on a particular concerns of the model. Then, the user is not overwhelmed by the amount of operations (s)he can performed on a model, each step providing a limited set of modeling operations. This relies on the definition of structured metamodels and an automata with constraints on the pre- and post-conditions of transitions. On the basis of these definitions, a tools is generated that allow you to use this particular modeling micro-process definition.
Other small experiments of MDD are part of my research activity at the moment. These experiments tackle the use of models and code generation in order to automate the development of n-tiers web applications. From each kind of models (annotated class diagrams, use cases, sequence and activity diagrams) they attempt to identify which parts of an application can be automatically produced.
Relying on the knowledge gained, the first objective is to identify how these models could be composed (with the proper composition operator) in order to get as much of the application implementation using model transformation and code generation. The second objective is is to move towards a web application virtual machine that can be provided with a model and interpret this model in order to provide a running application. (In both objective, we can see models as higher 'programming languages'.)
Mosaiques
Nord Pas de Calais Region (France) research project tackling system adaptability in the scope of ubiquitous systems. I was leading one of the three activities: The definition and tooling of a model driven methodology for the development of ubiquitous applications. The motivation is to help users writing ubiquitous applications and to specify the runtime reconfiguration abilities of these applications using the same models used for their building.