For further details take a look to the slides and Conceptual User Interface Patterns.

During the video you can see a pair of demos:

•  Essential on action doing full UI inference and code generation
• and IO, the codename for a new proof of concept UI specification and WYSIWYG prototyping tool.

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).

The Code Generation 2011 conference and the Language Workbenches Competition 2011 Workshop are quite close in the calendar.

I want to celebrate it with the MDD community sharing my work on Essential (a tool designed for acquiring speed with Model Driven Development). On 11th may 2011, version 0.4.44 has been released as the first public beta.

Essential is a meta-modeling and code generation tool providing specific DSLs to define and consume:

• Metamodels
• Models
• Templates (using StringTemplate) &
• Transformations (Model2Text and Model2Model)

Try it also with the sample projects created for the LWC 2011 challenge.

Code Generation 2011 is the leading European conference on modeling and code generation. It’s a great opportunity to meet with the experts in the field and share the latest research in the area.

The invited speakers this year are very, very interesting:

• Terrence Parr, well known by its work on teaching compiler construction and the great tools ANTLR and StringTemplate, and
• Ed Merks, the leader of the Eclipse Modeling Framework

As a novelty, previous to the conference itself the first edition of the Language Workbenches Competition will take place on May 24^th in the same venue.

In this edition, I will be there again, more active if ever, taking part with some activities:

• On May 24^th, presenting Essential in the scope of the Language Workbenches Competition
• On 25^th, presenting on Introducing Model Driven Software Development
• And, later on, taking part in the panel Build or Buy – who should develop and own your DSLs and generators? organized by Juha-Pekka Tolvanen from Metacase
• Finally, on 26^th, discussing about Modelling the User Interface

As always, I’m looking forward to meet again the code generation community.

Take a look to the full programme and don’t miss the chance.

See you in Cambridge!

I submitted a proposal with Essential for participation in LWC11. It’s going to be a great forum for comparing language workbenches capabilities and the state of the art in the area. If interested, track the progress here LCW11.

During the last weeks I’ve been working a little, replacing the old Microsoft Oslo dependencies to MGrammar inside Essential to an alternative parsing solution. The MS Oslo and later SQL Server Modeling never passed from the CTP stage and finally were discontinued. Therefore, I couldn’t ship a product in such conditions and finally decided to change it.

The Hello World sample is a nice starting point to show the syntax and capabilities of every new language. This test is also useful for code generators and Domain Specific Languages (DSLs) also as a proof of concept.

Following this honorable tradition, I have created a video showing the capabilities of Essential: the tool I am working on for doing agile Model Driven Development.

In this 10 minutes video you will get a general idea of the DSL the language provides to create:

• metamodels
• models
• templates
• and control transformations

In order to see the details, jump to Vimeo, activate the High Definition mode (HD) and set full screen (sorry embebed version is not good enough).

Essential IDE – Hello World sample from Pedro J. Molina on Vimeo.

More info about it and 12 usage scenarios in the last Code Generation 2010 presentation about Tailored Code Generators.

Share your impressions!

It also was the public presentation of Essential: the tooling supporting my approach for applying MDD. I got a very good feedback from the audience and receive many request to test the tool.

People interested in beta testing it can still enroll here.

Essential

To celebrate this milestone and give the chance to have more people trying it, an early version is going to be released for the people interested in.

If this is your case, please enroll yourself using the evaluation request form.

After presenting the metamodel DSL, today is the turn for the modelling DSL.

As commented previously, Martin Thiede has a nice prototype called Concrete of a Web editor for model and metamodels. Such work and video also helps to understand the modelling and metamodelling duality.

Coming back to Essential, our tool is also providing a DSL to instantiate a metamodel. But a sample will probably be more illustrative:

Suppose the following simple metamodel:

namespace Core.Class
{
    class ClassModel
    {
        composition List<Class> Classes opposite Model;
    }
    class  Class
    {
        string Name;
        composition List<Attribute> Attributes;
    }
    class Attribute
    {
         string name;
         string Type;
    }
}

You could consider it as a very basic OO model. Intentionally I haven’t added too many details to keep it simple.

If you continue building it; adding operations, arguments, association support and more… at the end, you can have a metamodel comprising a full class diagram of UML, for example. The complexity of the metamodel you want to use is up to you. Having the control of the concepts inside the metamodel you can always add or remove features.

Modelling tools focused in UML, for example, provides this metamodel closed. You can’t change it, it’s a hard-wired standard and you are not allowed to change the core directly (only by extensions points like stereotypes and profiles).

Modelling Language

Now, let’s see how we can create a model using the previous metamodel:

using Core.Class;
namespace MyModel
{
    ClassModel  myClassModel
    {
        Classes = [Customer, Invoice];
    }
    Class Customer
    {
        Name = "Customer";
        Attributes = [Name, Surname];
    }
    Attribute Name
    {
        Name= "Name";
        Type= "string";
    }
    Attribute Surname
    {
        Name= "Name";
        Type= "string";
    }
    Class Invoice
    {
        Name = "Invoice";
        Attributes = [
            Attribute Amount
            {
                Name= "Amount";
                Type= "decimal";
            },
            Attribute InvoiceDate
            {
                Name= "InvoiceDate";
                Type= "date";
            }
        ];
     }
}

In the sample, a basic declaration of two classes (Customer and Invoice) has been instantiated using the concept Class defined in the metamodel. Each metamodel concept is instantiated using it as you would be using a class in Java, C# or C++. Properties are assigned in the natural way one would expect in such languages.

As expected, the using operator imports the metamodel to be employed.

In the lines 26-37 you can see how properties can be also defined inline for list contexts.

Under the curtains, the tool is providing code completion, syntax colorization, error management and real-time parsing as you could expect from a modern IDE.

Essential uses DSL text for serialization but also XML can be derived. This XML document is conformant with an XSD derived from the corresponding metamodel.

Intended usage

Consider now, a basic DB metamodel:

namespace Meta.Database
{
    class Schema
    {
		string Name;
		composition List<Table> Tables;
    }
    class Table
    {
		string Name;
		composition List<Column> Columns;
    }
    class Column
    {
		string Name;
		string SqlType;
    }
}

With this base in mind, you can define a business model containing (Customers, Invoices, etc.) based on a class metamodel and then, look for ways to transform your class model in, for example, a DB model representation. This is called, a M2M transformation (Model to Model). Essential will provide specialized languages to do that.

After that, your derived DB model can again be generated to final code, for example SQL DDL scripts in a given certain dialect. This is generally called a M2T transformation (Model to Text) and again Essential provides tools to describe the transformations.

Basically, to complete all this stuff, we need to introduce two more specialized languages: one for applying transformations, and another one for templates to be converted to final text.

I will focus on templates side on the next post.

The first one is related to Enterprise Architecture. The second one is a tool for applying MDD. Both projects are not related in any way. But it’s curious how we collide choosing the same name.

I don’t want to confuse people and fortunately the name is not the key part of our work. So, probably, a rename for our side (as the newcomers) would be gentle an a good choice. I’m open to suggestions for a new name.