Webinar: Domain-Specific Modeling

Domain-Specific Modeling promises to change software development in many companies by changing models from being a bunch of out-of-date rectangles, diamonds and lines to executable representations of solutions in domain-terms. Models no longer depict the soon-to-be-roundtripped, visual representation of the code you need to write later. Instead, the implementation is generated automatically and completely from your high-level models, similar to how compilers generate full assembler from current programming languages.

A free webinar by a true expert in this field on December 14 will give a very concise explanation of domain-specific modeling in an easy to swallow format. So sit back, relax and learn. Learn what?

2 things basically, what it is and whether it makes sense to look into it further. Register here.

Released: MetaEdit+ 4.5

Defining modeling languages graphically in the new MetaEdit+

Today we are releasing the latest version of MetaEdit+. Version 4.5 is stuffed with a lot of significant improvements compared to its predecessor, like to name a few of these:

• Graphical metamodeling (see above)
  
• A whole new generator definition system, that:
• instantly validates generator scripts
• provides a debugger for defined generators
• provides "live code": generated code links back to its original model objects for tracing
• allows you to build more powerful, better generators, faster
  
• Model, and metamodel import/export via XML
• An improved SOAP/WebServices-based API that provides access to models, metamodels and MetaEdit+ functionality
• More powerful metamodeling capabilities
• Symbol import in SVG & Bitmap formats
• A much improved modeling environment

To sum it all up, we clearly focused on allowing developers to obtain tool support for domain-specific languages faster and more conveniently. As an indication: Just for fun, yesterday I "equipped" MetaEdit+ from scratch with Use Case modeling in about 15 minutes. Try that with the visual studio DSL tools or the GMF framework from Eclipse and you'll grow a beard...a big one.

Additionally, our development team put in a big effort in opening MetaEdit+ up, allowing it to work via open-standard SOAP-Web Services, via ANY programming language with ANY tool.

To top it off, we now offer companies, their first license of the new MetaEdit+ Workbench (introductory license) at 150 Euro! Additional licenses carry our normal pricing. There is thus no reason to miss out on experiencing how much value, speed and convenience MetaEdit+ offers.

Free training on creating DSM languages

At the coming OOP 2007 conference in lively Munich, expo and conference attendees have free access to all vendor tracks. MetaCase will provide one that teaches participants "hands-on" how to build a domain-specific modeling language and how to obtain tool support for it. Our aim is to provide participants with something a bit more valuable: Leaving the class room after 90 minutes feeling you've really learned some skills, instead of being made aware of a bunch of product features.

People should bring their own machine, and may opt to bring their own DSM tool. For those that wish to use MetaEdit+ we'll provide them with a copy. From a skills perspective, it's irrelevant what DSM tool you use really. Whether its Eclipse GMF, DOME, GME, Microsoft Visual Studio DSL's, MetaEdit+ or any other tool that can support DSM languages, they're all welcome to the session!

MetaCase offers a free ticket, you can get it here. It also provides entrance to all keynotes, product sessions, special training, vendor tracks and the expo.

New Event: Code Generation 2007

Mark Dalgarno, editor of codegeneration.net pointed me to a new conference, Code Generation 2007 on, well, code generation that his company is organizing in May 2007 in Cambridge UK.
The conference is currently seeking people and companies that are interested in running a session and/or sponsoring the event.

With very few (to my knowledge at least) events on code generation in the UK, this seems like an excellent opportunity for many companies to get exposure.

OMG: "MDA and DSL are the same!"

I came across a webcast by OMG Chairman and CEO Richard Soley in which he claims that MDA and DSL is "the same thing really", since MDA provides DSL's as well via MOF and UML profiles. I agree with Richard that you can get a DSL via MOF and UML Profiles, except that this way we'd have to bin that "little issue" of making sure we get a quality DSL (or DSM language, a term I rather use).

So, what defines the quality of a DSM language? Of course that is debatable but I would suggest "Its ability to define an application correctly, conveniently, concise and completely, with a minimum amount of effort." as that provides the basis for being able to generate 100% of the application's implementation in code. In this light, the lack of quality provided by MOF and UML Profiles leads to incomplete code generation. Richard mentions 70% code generation "which is not bad". Well, it's not good either since it creates the need for keeping models and code synchronized via round-trip engineering, which makes it pretty bad in my book.

When it comes to convenience, Richard "rubishes" the concern so many developers have with UML being too complex, by saying that he - as a man - "likes to have a big tool box", because he "wants to use a tool that is best suited to the problem at hand." To me it seems that Richard's big tool box contains just one very big and complex tool that you can use for whatever it is you wish to develop, therefore not making it very well suited for any specific problem at hand. It's "OK, nothing more", which already may be overstated. Don't give me that crap about it being great for everything.

Providing a developer or company with a great tool for modeling and generating the software he/it wants to build, means providing the ability to conveniently build an own tool that precisely matches the domain-specific requirements, in the shortest time possible. Not by providing a one-size-fits-all big man's box of tools that are "pretty OK" for doing almost anything.

MDA and DSM (using DSL's for generating code) are NOT the same. The OMG would do good to stick to its own MDA vision, abandon it or make an attempt to define it more concisely, instead of positioning it as the greatest thing for all of mankind while trying to jump multiple bandwagons and please everyone's agenda in order to justify its own existense.

Rants, Strikes, Planes and Wheels

It seems OOPSLA has its way in causing many to rant about reinventing wheels, not buying the latest book, airlines, stupid business decisions, blatant tool marketing and what have you. I suppose it's the "lovely" autumn weather and returning darkness that triggers our emotional outbursts.

The good side of it all: the DSM Workshop (6th time) at OOPSLA keeps on growing in size, a clear indicator that we're making progress in our market creation activities. Also the media are now clearly picking-up on the issue on a larger scale, so are the analysts..... so are businesses, and good for it!

With the new MetaEdit+ on its way to being officially released soon, MetaCase is making it significantly easier and definitely more convenient for businesses of any size to start developing software more effectively (faster, less complex, better quality, less cost, less testing, less development time) than with all-purpose UML.

Despite the ugly weather and everybody's rants, I am delighted to see this happening.

MDD & Product Lines Conference review

Markus Völter, one of Germany's most respected consultants in the area of software engineering and software technology, also founder of Software Engineering Radio posted some comments about the recently held Model-Driven Development and Product Lines Conference in Leipzig, that I blogged about earlier.

He comments about using MetaEdit+ being a great tool for building modeling languages and his wish to use MetaEdit+ as a front-end to Open Architecture Ware (oAW) generators. This is something that one of our contacts is actually working on right now, his comments were that "currently the process of assembling a working and useful editor with GMF is quite painful and time consuming. It's just not feasible for larger models." and that “Modeling with MetaEdit+ was indeed quite convenient and a lot easier to accomplish than trying to achieve the same results with Eclipse GMF.”

MetaEdit+ already provides the ability to plug oAW into it, via the model and meta-model import/export facility in XML format, which oAW accepts. Alternatively, there is also the SOAP/Web Services-based API that MetaEdit+ provides. There should thus be nothing stopping Markus from using MetaEdit+ more intensively :)

DSM @ DevWeek 2007 in the UK

Juha-Pekka has been invited to speak about defining domain-specific modeling languages and generators at DevWeek 2007, the UK's biggest conference for developers. On Thursday, March 1, JP will "demystify DSM, open the lid on OMG's MDA and shine a light on Microsoft's Software Factories".

Besides showing why UML-based MDA is generally a bad idea (do notice that not a single session in the whole conference deals with UML-based MDA anymore....hmmm maybe JP should just leave the lid where it is and focus on stuff that works), he will discuss the steps developers can take toward defining their own modeling languages - those that suit the work to be done better and therefore making them more effective - and generators, making sure that whatever it is the generator spits out, is what they want it to spit out.

From a guy with over 15 years of experience in this field, you can expect the session to be enlightning, well worth a visit.

The problem with language templates

When the idea behind DSM and MetaEdit+ has just settled in the minds of many people I talk to - these usually include developers, their bosses, magazine editors and analysts - I regularly get the question about language and generator templates: "Do you offer any ready-made templates?"

Although this would seemingly make adopting DSM faster by offering a "more-ready" solution that users would only need to tweak a little, it actually falls into the "one-size fits all" trap that UML offers. Ready-made templates try to do what ready-made templates try to do: offer one solution to many, which is what DSM tries to avoid for productivity reasons. A solution that needs to work for many, even if they are all active in the same horizontal or vertical, has to make compromises in the design of the modeling language and therefore the code generators, which negatively affects the productivity boost that DSM seeks to offer.

What we at MetaCase see, is that there are huge differences between problem domains, even between companies in the same vertical that make the same product. They benefit from DSM just because they can design the modeling language to fit exactly the way they wish to design their products/systems: Not surprisingly, the desing languages they use differ completely from one another in terms of the concepts they use, the rules that apply to them....the abstraction level they work on.
Providing them with a ready-made language template would:

• Get them started on the wrong path: They would not think carefully about their problem domain and attempt to create a language that would fit it. Instead, they would take the ready-template and try to fit it to their problem domain via all kinds of complex adaptations (similar to the UML profiles approach): Let's do it quick and ugly.
• Because of this, limit the possibilities and flexibility to generate the code they need, leading to a need to reverse engineer and round-trip: A road to nowhere...

The problem with language templates is that they exclude the much better solutions that exist for an individual problem domain. Although the idea seems a good one at first thought, once the idea of DSM matures however, providing or using ready-made templates seems a lot less attractive.

DSL: How to start creating your own language

This is becoming a more important issue for many, since modeling with DSL's or DSM languages is clearly picking up steam. Some stuff has been written about it but I feel it's definitely something that deserves more focus since it is such an important aspect of DSM. Sure, many experts, evangelists and even MDA-guru's speak about meta-models and, if you're living life on the OMG matrass, the good and bad of MOF. This is mostly the "WHY". I've seen only few give advise on the "HOW".

It seems that once you get into a serious session of DSM language creation, the tendency is to push it as far as you can....which often is the wrong thing to do: You're re-inventing UML.

Some time ago, Juha-Pekka wrote a great article on DSM language definition (for Software Factory aficionado's and Gareth J: This is the more correct acronym for a graphical DSL) and he's got another one coming soon in Methods and Tools.

Business before Pleasure

With Model-based development based on domain-specific modeling languages getting more interest from businesses, I have noticed several times now that teams blindly decide to build their own DSM tool using freely available frameworks, like the one offered by Eclipse, only to realize a few weeks (or months) later that the effort this requires is more than they initially hoped for.

There are many facets involved with building your own MDD tool like providing the ability to define your own modeling languages and generators, defining and associating the visual representation to the defined language, defining tool behavior, providing the means to immediatley test your languages and generators while defining them simultaneously, sharing your languages, generators and models with others, possibly even on hetrogeneous platforms, providing integration with other development tools, supporting different DSM languages at the same time etc. Building your own DSM tool does not end with your first version of it.

It's highly unlikely for one that developers will get their first DSM language right the first time, or that this will be a good DSM language. Furthermore, it is very likely that even a good DSM language will need to change over time, which will have its effects on the models that have been created with it. Normally, defining a DSM mechanism requires developers to concentrate on both language definition and generator definition simultaneously. If those developers also need to concentrate on making sure there is reliable tool support for their continuously changing definitions, the effort becomes very complex, very time consuming and very costly.

In order to make DSM a success, developers need to put the goals of business before the pleasure and challenge of building their own DSM tool from scratch....which is what it comes down to, really, when using free frameworks.

At MetaCase, our vision is that developers should be allowed to focus on building good DSM languages and generators, where the environment helps them in doing so by making the effort convenient and transparent. Developers should not be bothered with the intricacies of creating tool support for their own languages and generators, a good environment automatically provides the tool support for them. Not just for the "using them" part, but also for the "defining them", "sharing them", "maintaining them" and "integrating them" parts.

You don't want to spend man-years in developing a tool that in the end will make you a lot faster just until it inevitably becomes obvious that you need to make a change to the language, generator or tool...........and you can start all over again. This may be nice for people that like to build stuff, just for the fun of building stuff, it completely offsets the benefits the DSM approach has for the business goals.

Thankfully, some people have realized this in time, before having wasted precious time on building from scratch:

“Modeling with MetaEdit+ was indeed quite convenient and a lot easier to accomplish than trying to achieve the same results with Eclipse GMF,”
Ulf Hesselbarth, SIEMENS Communications.

"MetaEdit+ provides convenient tool support for domain (meta-)modeling as well as for the definition of concrete instance data, which is simplified by a domain-specific graphical user interface. Easy to learn — easy to use!"
Cord Giese, Research Analyst, Delta Software Technology.

"MetaEdit+ is the most sophisticated DSM tool,"
Scott Ambler, Ambysoft

"Even as a beginner with MetaEdit+, I could define a domain-specific activity language in about six hours - design, testing and one failed trial included,"
Laurent Safa from Matsushita Electric Works, Ltd., Japan.

"MetaEdit+ was the most flexible tool, allowed us to define our own design syntax quickly, and make fast experiments while developing the method,"
David Narraway from Nokia.

Struggling with Microsoft's wording

GarethJ is wondering if MS's "DSL" tools might make people think MS is targeting textual languages. Remarkable.....especially when knowing that DSL's have for decades been textual languages. It remains a mystery to me why MS have not opted for the more correct "DSM languages", with the "M" representing Modeling. I suppose some marketing buff up in Redmond decided "DSL" to "sound" better and of course......it would save some ink.

UML vs. DSM - The analysts take on it

Nice to see more and more analyst firms agreeing on DSM making MDD work, where UML fails to do so. My guess is that we'll likely see more and more UML tool vendors claiming support for DSM with suddenly-popular buzzwords like "abstraction", "full code generation", "MOF" en "profiles". In the end, MOF en profiles do not raise abstraction, make things more complex than UML already is while vendor-defined generators don't generate company platform-specific implementations.

Congratulations to Microsoft DSL Team

Jack, Steve, Gareth, Stuart, George, Jochen, Pedro, Alan, congratulations for the great work in bringing the Microsoft DSL tools this far! Your work means a lot to the category of model-driven development tools based on domain-specific modeling languages.

That the DSL tools have a lot of mindshare is shown for example by the article published yesterday on DevX that introduces the Software Factories approach by Edward Bakker and Christian Weyer. It puts the current (still immature) state of the Microsoft DSL tools in good perspective - don't get me wrong - I really think the DSL team has done an excellent job but there is still a long way to go, just like we at MetaCase had after releasing version 1.0 of MetaEdit+ back in 1993.

One of the problems described in the article deals with keeping generated artifacts and models in synch. It's inherent really to the horizontal focus the DSL's have in Microsofts view, this - in my humble opinion - will often (if not always) lead to an inability to generate full code from models, thus always leading to a chicken-and-egg situation: which one comes first. The article suggests ( I think correctly) that models to get the no.1 spot and proposes round-tripping as a solution. The problem it subsequently does not deal with is the difference in abstraction levels between the two. Steven gave an excellent explanation of this problem in his article on Codegeneration.net. Having to keep stuff in synch with each other always is a recipe for trouble, which is why code generation should aim at being complete.

Still, a big hats off for the DSL tools team at Microsoft, as the article shows, already some very cool things can be done with the current version.

Conference: MDD and Product Lines

The end of the year usually sees a lot of top-quality conferences, like SD Best Practices, OOPSLA, Elektronik and many more. I would like to point also to one, which really gets to the point when it comes to model-driven development. It's got a long name:

Model-Driven Development and Product Lines: Synergies and Experiences

It will be held in Germany, the city of Leipzig on October 19 and 20 and hosts some big names like Markus Völter, Steve Cook (will he demo MS's new DSL tools?) and our own Juha-Pekka Tolvanen (will he demo the all new MetaEdit+ 4.5?)

Furthermore I see that Carsten Bock from Porsche will discuss how making automotive software in fast cars is done even faster with DSM.

With a conference fee of 150 euros for two days of model-driven fun, including food, it's definitely worth the effort.

UML or DSL for Embedded (Continued)

It seems Jack Ganssle picked a boiling subject with his "UML Use" article, seen the number of reactions from the embedded world to how suitable UML really is for embedded development. The OMG and several (OMG) tool vendors would like us to believe it's excellent.

I remember an interesting discussion with someone from I-Logix at a conference on automotive software a few years ago. After "getting" the idea behind domain-specific modeling his reaction was that it maybe was 10 times faster than Rational...but "only" 5 times faster than Rhapsody. He never replied to the question if we could quote him on that though.... :)

An interesting reaction to Jacks article: "In my opinion it would not have been possible to do these projects given the code complexity and the safety level (RTCA DO-178B Level A) without a tool like this that both understands controls and can enforce the rules". Essentially, the tool he mentions is a domain-specific model-driven development tool. I haven't heard about that specific one but clearly it differs from MetaEdit+ in that it is aimed at one domain only, while MetaEdit+ can be made to aim at one domain only.

Another comment: "Sure if you give incompetent carpenter a better hammer and saw your not guaranteed a better house. However, if you give a great carpenter the same tools you may just get a house of your dreams". Well....what about giving a great carpenter a set of great tools? Your dream house would be ready when normally you would have just finished the blueprint!

How about this one: " For smaller companies UML's a good booster stage, but it isn't going to get us into orbit. At some point it becomes extra weight and costs more to use, in time and productivity, than dropping it and continuing on unimpeded."

Or some "juicy" ones ;)
"I dont think that anyone here believes that we will ultimately use the UML models as anything more than blueprints for hand-coding"

"The tool stinks. Sorry I-Logix, but for what we paid, I expect better." "important functions that are just too difficult to use and poor support for multiple developers working on the same model. And please don't tell me that these problems can all be solved by purchasing more training!" Put that one in your pocket I-Logix!

"I've been using modeling diagrams for 10 years on embedded 8-bit projects (first Shlaer-Mellor, now UML). I've never used the generated code in a final product and I doubt I will until the tools come up with a better way to specify and debug the models at the algorithm level."

"UML is an extremely powerful anaylsis tool. What it lacks is a graphical langauge that lets you quickly and easilly define code execution at the algorithmic level." Yes, UML was developed for just that: analysis and design, never for code generation, the UML tool vendors came up with that, figured out it didn't work, added a lot of stuff to it to make it stink less and called it an excellent solution.

"I think there could be an interesting connection between LabView and executable UML. They both have the same concept: draw a picture and execute it. Generally LabView works at a lower level and UML at a higher level. If UML adopts a graphical execution language like LabView, then you might truly have an executable model from top to bottom." Well, your vision is a reality, it's called MetaEdit+

"May be the next generation of CASE tools will cross UML and Visual logic programming (like Simulink) + Concurrency in one tool and it would address architects, designers and programmers all." Surprising that also this guy has more or less the same vision: Graphical design that captures behavior. Well add to that the ability to define yourself exactly how code is generated and you have a DSM environment.

It's good to see that modeling is gaining in acceptance in the embedded world, although possibly more by crisis than by liking. It looks like the embedded area is moving toward a situation where, as Geoffrey Moore describes in his book "Crossing the Chasm", it is "bleeding by the neck". I see it very unlikely that UML is going to stop the blood from flowing.

UML or DSL for Embedded?

In his article "UML use" on Dr. Dobb's portal, Jack Ganssle wonders how much UML is really used in the embedded arena. Casually he remarks that when visiting the soon to be held Embedded Systems Conference in Boston, you see UML plastered on every expo booth. I am not surprised Jack, especially with a conference program so narrow-minded with 6 classes on just UML and SysML from 3 speakers, 2 of which are OMG members.

In my view, conferences like ESC should provide the platform for demonstrating new ideas and methods – once proven in industry, not for methods and notations (MDA, SysML) that are hyped by tool vendors and standardization organizations who, after modest success in the desktop and IT market now put their hopes on conquering the embedded market with some simple modifications to their standard and tools.

Modeling with UML is happening more in the embedded area, to me that is a sign that clearly the software is becoming more complex, not that embedded developers have - suddenly - started to love or even accept UML. The reactions at the bottom of the article are clear indications of the problem with a one-size-fits all language that a) never was designed for generating code from it and b) never was designed for developing non-object-oriented software or some form of hybrid: The large majority of all embedded development.

One comment describes the UML tool generating object-oriented languages like C++ while actual development is done in C :) as a problem. Actually the perceived problem is not such a problem here: Assuming the UML tool would generate C, you'd still have to throw the code away, trust me.

Another comment claims that non-UML-savvy developers can create diagrams that are "non UML-compliant". Aside from the fact that the "UML tool" here probably is a pen and a paper or some free tool that's the binary version of a pen and a paper, even if the diagrams were "UML compliant" then that really means zilch. UML compliant is not in any way related to quality-compliant, performance-compliant or just.....compliant! UML says nothing about any product, platform, framework or architecture, UML-compliant can actually be a lot worse than non-UML-compliant.

Of course there's the comment about understanding UML being hard. "it seems that engineers understand block diagrams and pretty pictures, with a bit of descriptive text....much better than a full blown UML diagram complete with interaction diagrams". Yes, code visualization (UML) is not exactly reducing complexity, it just presents complexity in another format. UML fails to raise abstraction is why.

And then the nicest, one that sums it all up to me:

"After having used UML based CASE tools for the past 6 years, I must say they are great for prototyping. Other than that, I'll never use them again. Merging changes from multiple developers into one graphical model? It never worked. Code generation? Only the framework and how much time will that save you."

Thank you Jos Dijkstra. UML-based CASE tools simply do not fit embedded development. The problem is not CASE......... the problem is UML.

I hope the highly esteemed program committee of the Embedded Systems Conference - claiming to offer "high-caliber, solutions-oriented technical sessions" and a "a fundamental educational tool offering practical, how-to classes designed to meet the needs of engineers developing embedded systems" - will aim to proivide something in next years' program that actually works.

SD Wild West Panel

Well, it's been a while but after a long holiday, during the dryest summer of the century here in Finland, I'm back behind my keyboard.

Currently at MetaCase we're working hard toward the release of the new MetaEdit+, which will be awesome. I had some time to go through old emails, stumbled on the panel script of SD West 2006 and my wooden shoe broke (old Dutch saying). In the annoucement to the panel I am sure the SD events group had announced "some heat" that could be expected. However, the script I read does not give any indication of "heat". Instead, it seems like the panelists were given ear plugs and asked to react to issues that were barely related to each other.

The best advice to attendees clearly came from Compuware's John Kern who wanted to point out that it matters who you hire for a software development project. I bet it does John, but don't you think that "Just hire the smart ones and you don't have to worry about getting them there" is simplifying it just a little too much? Comments like that should get you barred from any future panel if you ask me.

Jack Greenfield mentions that he does not believe in big red buttons that generate code he has to live with from high-level models. Well Jack, first, in MetaEdit+ that button is not big and not red, it's actually quite small and blue/whitish and people have been using it for over 13 years to generate full code that they can live with, and yes, from high-level models.

Scott Ambler reacts (according to the script) out of the blue that not everyone gets modeling. Correct Scott. Could it be that this is because UML, the most used modeling language - hyped since its inception by the OMG in every magazine, website and conference - is actually very complex? Would modeling not be simpler if developers can design with the concepts and rules that they are most familiar with - those from their problem domain - while the language makes sure that they follow the architecture and design rules that are valid in their problem domain?

Hopefully the next panel on MDD provides some real fireworks, cause there is enough reason to. A good moderator might help, one who doesn't let panelists get away with half answers or John-Kernisms.

Steven's problem with MDA

Steven has been writing a nice article on code generators on the code generation network. In it he explains his idea of what constitutes a good code generator and some best practices of how to create one. He also elaborates on why he sees that the modeltomodel-MDA (elaborationalist) will be fraught with obstacles and mayhem.

Doug Schmidt on DSM

Software Engineering Radio recently interviewed Doug Schmidt, a professor of computing at Vanderbilt University. The interview became interesting for me from minute 33:30 onwards, where Doug explains DSM, as he also did in his article on Model-Driven Engineering last year.

Doug clearly is an expert in this area and I enjoyed hearing how much his thoughts are similar to the ones I have about Model-Driven Development.

What my experiences with the media and many developers on conferences are, is that further introductions of the idea however, are no longer really necessary. I do not think anyone is anxiously awaiting another book or another article that introduces Domain-Specific Modeling or modeling with DSLs. Instead, we need the minds, expertise and experience of people like the Schmidts, Tolvanens, Kelly's, Dimitrievs, Greenfields, Cooks, Fowlers and so on to focus on:

HOW

Mainly:
How do I best create a DSM language?
How do I make sure I can easily update it later?

But definitely as important are:
How does the DSM tool best support updating the language?
How does it best update and distribute changes?
How does it best integrate generators with metamodels?
How do we best exchange metamodels?

Juha-Pekka has made a significant contribution here in his recent articles on DevX and he will no doubt touch the subjects during his classes on Architecture and Design World. Many of his ideas are naturally part of MetaEdit+ of which the 4.5 version is scheduled for later this year.