La comunidad Alt.NET Hispano ha publicado la VAN (desconferencia) sobre Generación de código con Essential que tuvimos el pasado dia 11 de junio. Si estás interesado en MDD, generación de código y como aplicarlo con Essential, este video grabado para la comunidad en español es un buen punto de partida.

Mi agradecimiento a Alt.NET Hispano por el interés en la materia y la invitación a divulgarlo.

Descarga directa del video (562 Mb).

A title like this could sound utopian and probably it is in the extreme, but at the same time provides two advantages:

1. a suggestive title brings more blogs readers , and
2. these kind of Quests keep me active developing and testing my ideas about MDD.

Sorry for 1, the joke. But Let me explain 2 a little further if you are interested:

Some months ago, I started to develop a new tool for doing Model Driven Development. I always start new developments with contained expectatives. I consider most of them throw away propotypes just to test a new way of doing the same thing, but luckily, with less effort and better productivity. But when you found the way, you follow it again whenever you need it, isn’t it?

So, this time is one of those moments: I am quite happy with the results, and I will continue building on the top of it to make it grow.

Today (almost?) everyone agrees on code generation can make your life notably easier as long as you have:

1. a stable domain,
2. a clear knowledge of your domain (domain expert) and,
3. tools: modelling editors, model checkers, and code generator adapted to your domain and your chosen target architecture and language.

The trickiest one to get is, not surprisingly, the third one. And this issue: the quality and the applicability of the MDD tools is the main stopper when considering applying MDD for a software development project.

So, my motivation during years is not only to create code generators one more time, but do it in a way that it will be cheaper to obtain results in next projects. Therefore, reducing the requirements for the entry level will help the MDD adoption to gain speed.

Ok, wait a minute, are you reinventing the wheel again? Building another meta-code-generator?

Yes I know, there are very good and mature tools for doing MDD: such as EMF/GMF, XText, ATL, TextUml, Metacase, MS DSL Tools, etc.

However, guided by my intuition and the experiences in the domains I have worked in, I have a strong opinion on of how some things should be done and for the moment I didn’t found the perfect tool to satisfy my needs.

But, instead of complain, I decided to take to the action and add my two cents implementing my view about MDD tool support: taking the good ideas of the standards available and reinventing the parts that don’t fit.

The tool

After this introduction, the name of the tool is not going to surprise you. It is named Essential.

The goals of the project are following ones:

• to declaratively describe metamodels, models, templates, and transformations using textual DSLs
• to provide a comfortable editor for each of these four pillars,
• to provide model checkers to assure the integrity of the four, and
• to build code generators and transformation interpreters to achieve the output we are looking for.

In the next posts I will depict the DSLs used in Essential and some architectural choices. This will help us to discuss the essence of the problems found in MDD.

I want to thanks Javier Hernandez for his constant help, good discussions and counterpoints about choosing design alternatives for Essential. And also to Nicolas Cornaglia and Ángel Marín for their active beta testing as early adopters and providing good test fields.

I want to share with you a set of videos to show what I understand when talking about Forward Engineering applied to MDD.

First of all, a legal disclaimer: my apologies for the quality of the videos and for my rusty English: I am starting to play with video editing tools and recording software so I expect to improve my recording and editing skills on the way. Anyway, I found (I hope) they have enough quality to explain the main ideas. So seeing it is totally up to you! You have been warned! 

Also note: see the videos in High Quality mode (HQ) in Youtube. Otherwise, details of the samples probably will not be visible.

In a previous post I introduced a sample of the code that can be generated from a very basic conceptual model. I have created three videos to show you the main steps involved.

1. Modeling (Video 1/3). The first video uses a minimalistic class model created inside Visual Studio 2005 with Microsoft DSL Tools. The sample creates a basic blog structure in less than 5 minutes. Note that in the specification there are no technological choices (neither the types are bind to a concrete language representation).
2. Code Generation (Video 2/3). A quick step: Selecting a code generation (selecting a target architecture), fixing the design choices offered by the code generation and pressing the red button: Generate! A full .NET Solution is generated in less than 5 seconds ready to compile.
3. A quick code review of the generated code (Video 3/3). Finally, I am sure you have curiosity to take a look to the output code, don’t you? This third video shows a walkthrough to show:
   • DB Scripts (table creation, foreign keys, drop scripts)
   • Database creation
   • Logic layer: POCOs (Plain Old CLR objects), NHibernate mappings and a Business Service Layer with fully functional CRUD operations.

So this is it. It is a proof of concept of how fast and direct MDD tools can be starting from a minimalistic model.

When talking about using or buying modeling & code generation products my advice is:

• Don’t use models just for documentation. They will be outdated soon or later. On the contrary, a living (generating) model is always in sync with its target application.
• Don’t resign yourself to just using code generation of skeletons. As you just have seen the current technology allows you to generate much more.
• Don’t be content if anyone try to sell you a model too close or tied in any way to a given target language. Today we have just generated C#, but tomorrow may be we prefer Ruby? Python?
• Don’t resign yourself to use a tool married with a specific database. You know, technology changes faster that we usually expect.

• It is specially well suited to create your O-O design class model (and think and visualize the full set in terms of Design Patterns) and generate a skeleton for you in C# or Java.
• On the other hand, if you need to document a-posteriori (I hope you don’t do it frequently, by the way), NClass also incorporates a plug-in developed by Malte Ried to reverse engineering a .NET assembly using reflection to extract the classes and draw the corresponding design class model.

In this second mayor version the key new features are:

• Project-model hierarchy for multiple diagrams
• Name, role and multiplicity labels on relationships
• Navigation facilities (Model Explorer, Diagram Navigator)
• Inline class editor
• Visual enhancements (gradient modes,  ClearType, etc.)
• Generation of solution files and NotImplementedException as default implementation

NClass is coded in C# by my colleague Balázs Tihanyi (based on Budapest) and it’s released under the GNU Licence.

In version 2.0, NClass supports different languages like Hungarian, English, Russian, Brazilian Portuguese, German, Chinese & Spanish. If you find a bug in the Spanish translation do not complaint  to Balázs. In this case do it directly to me. }:)

Try it & enjoy!

NClass User Interface

The central idea of my speech was devoted to achieve scalability in MDD tools & methods for industrial application of the MDD technology.

I was so glad to see that Markus Völter and Steven Kelly also just 30 minutes before my talk, were addressing the same key issues in their inspiring keynote: scalability, partitioning, modularization of DSL. This fact reinforce me in the idea that we are really growing as a community (CG) with common problems and aligned in the solutions improving the tools & techniques more and more every year.

Scaling MDD for production: enabling SoC at model time

There was also time for an small but complete live demo of a small tool socDriven running and demonstrating the concepts explained. The tool was implementing a compiler and merger for a small textual DSL. The DSL was parsed using the OSLO M_Grammar to create the AST. A merged engine in a second phase glued the partial specifications producing as output:

• the same specs merged in a unique file,
• the same spec ready to be open with a graphical editor with DSL Tools,
• a full code generation solution on VS2008 containing:
  • scripts for SQL Server
  • a logic layers with POCOs & full NHibernate mappings
  • a default CRUD service definition,
  • a default Web Service definition,
  • and a Windows Form UI ready to query and execute CRUD operations.

After the generation of the solution, it can be opened with VS, create the DB launching the scripts provided and pressing just F5 for building and running it all! == (a.k.a the utopia of 0 custom code) };-)

Please, feel free to add your comments!

This year my focus will be directed to stress the importance of prepare your code generator for scalability and discuss some techniques in order to achieve it. Separation of Concerns (SoC) is one of the powerful principles you ever can apply in Computer Science, and I will discuss about how to use it as the basis to split concerns and improve the scalability of the approach.

A custom MDD tool named “socDriven” has also been implemented to demonstrate the ideas. This tool has been developed using .NET, the Microsoft OSLO MGrammar & StringTemplate.

See you there to discuss about it!

As a practitioner and enthusiast of MDD and .NET I was looking forward to try it and see if there are nuts enough to justify the noise.

At Models Remixed you can find some nice marketing introductory videos about Model Driven & Oslo. By the way, if you take a look to the funny video about Modeling through the ages just remember that the second scene about humans and T-Rex is purely fiction: humans & T-Rex were never concurrent in time. Fortunately T-Rex disappeared a long time before humans get off the trees.

Much more technical & serious videos can be found at the Oslo homepage in MSDN.

Oslo is the Microsoft codenamed project to embrace MDD as a second wave initiative annunciated by Bill Gates before retiring. The first wave was initiated by Microsoft DSL Tools some years ago to support a modeling environment following the steps of Java counterparts EMF/GMF.

The project Oslo is still under development but some bits are available in form of CTP. As seen, Oslo provides the following main components:

• A Repository. A relational, SQL Server based, repository to store models as schemas and models instances as data.
• A language called M. Or better said, a meta-language used to create languages (textual DSLs) and schemas or models.
• A functional language to create grammars MGrammar.
• A graphical editor called Quadrant able to represent models in a graphical way. I’ve seen some videos but seems it is not released yet in the CTP.

More utilities comes with it to assist in the modeling tasks:

• Intellipad is lightweight text editor with keyword highlighting capabilities able to help in the editing of a myriad of languages, also custom ones defined in MGrammar.
• Some commands tools like mx to compile & deploy models to DB Schemas.

I was wondering to know if Quadrant (the visual editor) has a common-ground on DSL Tools. But for them moment it seems to be no common roots here or reuse. The editor seems to be (re-)created totally from scratch.

As a first rough simplification we could say that M allows to define modules (or namespaces). Modules contains types, types contains properties, properties can have any type you have already define or can be a primitive type.

The mx tool is able to compile models and generate tables, views as stored procs. in Transact-SQL.

Types are compiled into tables. Properties are compiled into columns.

Models will be available at the database ready to be consumed by any application able to connect to the database using raw SQL, ADO, Datasets, LINQ, objects models (M models), etc. Of course, other Microsoft tools will be prepared to take profit of the MDD tools: Biztalk, Visual Studio 10, .NET 4.0

I am still playing & learning the ropes with Oslo, but is it difficult not to compare it with other previous experiences like:

• Antlr for grammar creation,
• MS DSL Tools & GMF for graphical representation,
• EMF for the modeling core &
• Hibernate for the ORM mapping.

I will continue commenting about Oslo as CTPs appears and my knowledge on it increases.

My general impression is that there is a good stuff behing Oslo, but we will have to wait a bit before seeing it in his full glory.

To get started with Oslo and take your own impressions you can download the CTP and take a look here.

More info at wikipedia.

Updated: a nice video about how to start with MGrammar from Channel 9.