Posts categorized “.NET”.

Radarc 3.0 Released!

The arrival to my new job in Sevilla has coincided with the preparations and launch of a new product. We at Icinetic, are releasing Radarc 3.0. Radarc is a very easy to use code generator highly integrated with Visual Studio and targeting .NET technologies.

Radarc has the ability produce multiple architectures using the same base models and keeping in-sync generated artifacts when model element changes. Architectures and DSLs for defining the models are packaged in so called “Formulas”.

Currently, the following formulas are available for download and it is free for non-commercial usage:

  • ASP.NET Web Forms + Entity Framework
  • ASP.NET MVC 3.0 + Entity Framework
  • ASP.NET MVC 3.0 + Entity Framework + Azure Storage & deployment
  • Windows Phone 7
Radarc creates a complete prototyping application in seconds following the cycle: change the model, touch no line of code, build and run. Prototyping an application is a question of minutes, and obtain a first scaffolding of your application. Moreover, custom code can be inserted in specially designed locations that will be preserved in every regeneration lap.

Radarc 3.0 is available with three licensing models and its free for non-commercial usage.

Other technologies are available on demand, such as:

  • .NET 4.0 Domain Driven Design N-Layered Architecture
  • NHibernate & more to come…
Some cases of usage:
  • If you work in a .NET development shop, feel free to give it a try and give us some feedback.
  • On the other hand, if you want to start learning one of the previous technologies or architectures, you can use also Radarc to generate a reference sample application and start exploring the code.
  • If you are a experienced software architect and needs to evaluate SW architectures to benchmark them before choosing a winner arch for your project, think about the cheap possibility of generate the same application in two technologies and test how well performs for your specfic problem.
These days, I am learning a lot about the state of art here at Icinetic and I hope to start contributing to the bits very, very soon.
Bonus extra: a 20 minutes demo video (in Spanish) generating three architectures is available.
Next week we will be attending Code Generation 2012. If you are interested, join us and see a live demo or download it and give it a try!

Essential on Alt.Net Hispano

The Alt.NET Hispano group has published my VAN about Code generation with Essential. The recording was done in Spanish.

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

 

More… »

Searching for the essential building bricks of MDD

Red Brick Wall. Photo by Cibergabi via Flickr.com

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.

Forward engineering with MDD: A proof of concept

Hello everybody!

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.

NClass 2.0 released!

NClass is a elegant UML class diagram tool oriented to code modeling for the C# & Java languages.

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

More… »

Scaling MDD for production

This was my contribution for the Code Generation 2009 conference.

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 MGrammar 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!

Making the preparatives for CG09

During these days, I am dedicating a lot of my free time to work on my session “Scaling MDD for production: Enabling SoC at model-time” for Code Generation 2009.

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!

Oslo at first glance

Microsoft is making some noise about Oslo: the new MS approach to Model Driven Development (MDD for friends) and Domain Specific Languages (DSL).

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. More… »