voelterblog

Keynoting Code Generation 2012

2012-01-08T11:40:00.002+01:00

I have just been invited to keynote at the Code Generation 2012 conference in late March in Cambridge (the other keynoter is Jan Bosch). I will talk about the DSL Design stuff that I have been working on (with Eelco) for the upcoming DSL book. Looking forward to this very much :-)

mbeddr C: Early Access Preview of Extensible C Published

2011-12-12T09:31:00.002+01:00

Over the weekend we have published the first early access preview version of the mbeddr C extensible C language based on MPS. We've been developing this system as part of the LWES research project (itemis, fortiss, Sick and Lear are the project partners). The download comes with sources, a user guide and a tutorial on how to extend C in mbeddr.

The goal of LWES/mbeddr is to provide a more productive and better integrated way for developing embedded software by using domain-specific extensions to C.

Take a look -- it's cool stuff :-)

Scala, EJB and real language engineering

2011-12-01T09:11:00.001+01:00

Recently there is this battle around Scala going on: sceptical opinions are raised by some people claiming Scala is too complex, hard to learn, tools being suboptimal and generally, not delivering on the advertised productivity improvements. The discussions got started by this article and continues with this one.

Now, I am not the person to judge this stuff. I do think Java needs improvement, I like many of Scala's ideas, but I do realize it is a powerful, complex language.

Scala people typically say that there are two distinct roles of Scala users: library authors and library users. And only the library authors need to deal with Scala's advanced and complex type system (which is the source of many of the reported complexity problems). Critics say that the complexity "shines through" even to library users.

I have been working a lot on language design and implementation, in the context of DSLs. More recently, with the mbeddr.com project, I have dealt a lot with C and extensions to it. We're doing this based on the MPS language workbench. Using a language workbench really distinguishes between language designer/implementor and language user. Instead of implementing interesting new features via meta programming, flexible syntax and type system magic, one can simply implement language extensions, using real language engineering techniques. And the user really doesn't see any of this: the extension feels absolutely like a real language extension.

While I realize that there are issues with this approach as well (actually, there's only one issue: you have to use MPS to write code) I think the approach is much much better in general. Let's face it: many of the things done in Scala libraries are, from a user's perspective, language extensions. But in Scala, the IDE doesn't know about them, and some of the implementation complexity does shine through. I think that, if we do language extension, we should do it with the right tools.

PS: There isn't just MPS. You can do many of these things with SDF/Spoofax or Rascal as well.

Xtext 2.1 and JVM Languages

2011-11-02T08:40:00.002+01:00

Earlier this year, Xtext 2.0 was released. It brought the new Xtend language for transformation and code generation (and to some extent, a replacement for Java). It also included Xbase, an expression language which you could include into your own DSLs by inheriting from Xbase. At the time, I had two complaints about Xbase and the way you would use it. First, Xbase is highly integrated with the JVM. If you wanted to write a DSL that targetted for example C, the provided infrastructure around Xbase wasn't of much help. The other complaint I had was that the integration of Xbase with your own DSL was quite a lot of work to pull off. You had to write all kinds of artifacts to get it done. It was a lot of low-level work.

With Xtext 2.1 things have changed and really become interesting! My first complaint is still true: Xbase is still very much tied to the JVM, so if you wanted to build a DSL that had nothing to do with the JVM, you'd probably be better off building your own grammar and using the Xtext typesystem framework to define typing rules. However, building your own JVM-based language has become impressively simple: you define a grammar (which embeds Xbase in places, e.g. for expressions or operation implementations. The second artifact you build is a little model transformation that maps your new concepts to JVM concepts. This is conceptually similar to generating Java code. However, you don't generate text, but you instantiate JVM objects (classes, methods, fields, etc.). From this mapping information, Xtext then derives everything necessary to derive a generator! This is really pretty neat! The JVM mapping can be expressed very concisely using the new builder-style support in Xtend. Also note that for implementation code (Xbase stuff) there is of course already a generator to Java as part of Xbase, so you don't have to deal with this aspect at all.

So, if we just accept that Xtext and Xbase is mainly targetted to JVM-based languages, then the new Xtext 2.1 stuff is really a big step forward and pretty impressive!

Yet another MPS demo screencast

2011-10-31T21:33:00.001+01:00

Vaclav and I have recorded another screencast on Java language extension with MPS. This time we discuss a decision table expression. This is a particularly interesting example since it nicely demonstrates the advantages of projectional editing: an actual 2-dimensional table is embedded in the C program. The translation is also not trivial, so understanding that is interesting too. Have fun watching it :-)

New MPS Screencast: Extending Base Language

2011-10-26T16:40:00.003+02:00

The JetBrains guys have just started a documentation initiative for MPS (I am helping them a bit with this). The first result is a Screencast on Extending Java with a new Statement. Vaclav Pech and I explain how this works. Stay tuned for more (and increasingly sophisticated) examples.

New Gliding Videos

2011-10-05T20:04:00.002+02:00

I just uploaded a bunch of new (raw, uncut, long) flying videos. The first one (Part 1, Part 2) is a ca. 1 hour autumn flight with the ASH 26E, filmed from the wing. The second one is a spectacular sunrise flight with the ASK 21 (Part 1, Part 2) filmed from the side of the vertical tail. This one is really nice :-)

Meine nicht-so-guten Erfahrungen mit FitnessFirst in Cannstatt

2011-07-29T08:20:00.003+02:00

Ich habe beschlossen, dass ich ein bischen was für meinen älter werdenden Körper tun muss. Daher habe ich mich mal ein bischen mit dem Thema Fitness-Studios auseinandergesetzt. Aufgrund der geographisch günstigen Lage hatte ich mich für FitnessFirst in Cannstatt entschieden. Die Geräte sind so wie ich das einschätzen kann gut, die Einweisung/Trainingsplan machte auch einen guten Eindruck, aber:

Ich wollte eigentlich einen Vertrag von einem Freund übernehmen (günstigere Bedingungen). Der hatte sich da erkundigt, und es hätte gehen müssen. Als wir dann zusammen dort waren war das alles nicht mehr möglich.

Ich habe mit entschieden dann trotzdem zu unterschreiben. Als es dann konkret wurde ist dem Typ eingefallen, dass sich die Preise wohl "kürzlich" erhöht hätten. Er zeigte mir irgendeine neue Preisliste mit höheren Preisen. Es ließ sich leider nicht rausbekommen, ab wann die gelten sollte ("jetzt ist es halt so"). Ich musste also mehr zahlen als mir vorher (schriftlich!) angeboten wurde.

Dann ging es um den Checkup und die Trainingsplanerstellung. Lange Rede, kurzer Sinn: Zwei Minuten nach(!) dem geplanten Termin für das Checkup ruft der Trainer beim Studio an und sagt er könne nicht kommen, er hätte eine Panne. Wer's glaubt! Selbst wenn er eine Panne gehabt hätte, fällt einem das nicht zwei Minuten NACH dem geplanten Termin ein. Als ich den Mensch dann am nächsten Tag bei der Trainingsplanerstellung darauf angesprochen habe, hat er sich nicht mal entschuldigt.

Und heute morgen? Da wollte ich um kurz vor acht da hin zum trainieren (ja, ich bin grade richtig motiviert :-)). Angeblich machen die um sieben auf. Um 10 vor acht war keiner da. Umsonst hingefahren, und 1,80 EUR Parkgebühr verschwendet.

Unter normalen Umständen (also wenn es eine geografisch passende Alternative gäbe) würde ich mir das nicht bieten lassen. Mit dieser Art von "Unverbindlichkeit" kann ich nicht umgehen. Dieser Blog-Eintrag geht auch an die Geschäftsleitung. Mal sehen, was passiert.

Talk about the MPS and Embedded Systems in Stuttgart on Sept. 20

2011-07-24T19:28:00.004+02:00

On Sept. 20 there will be a chance to learn about MPS, Language Workbenches and the LWES Project. I will give a talk at 18:30 at STEP near the university. Find details in this PDF. It would be cool if a couple of you guys would show up :-)

Working with MPS and Git

2011-07-24T17:16:00.002+02:00

Here is a little demo of how to work with MPS and Git. Many people fear that integration of MPS into standard version control systems is a problem. This video is intended to convince you otherwise:

MPS Screencasts: Language Modualrization and Composition

2011-07-13T09:32:00.001+02:00

Last week, I should have been at GTTSE 2011. I was invited to give a short tutorial there on Language and IDE modularization and composition with MPS. However, because of my inflamed, swollen and hurting right foot I wasn't able to travel there. I proposed to present my tutorial remotely via Webex. Thankfully the the organizers agreed to try it, and a number of folks even sat in the room to watch "a remote guy". Thanks to all of you!

The good thing is that as a plan B I had recorded the tutorial ahead of time as screencasts, so you can now watch them even if you haven't been at GTTSE. So here are a eight videos, 90 minutes in total, about the cool things you can do with MPS:

Part 1: MPS Intro (14:18)

Part 2: The Entities Language (14:05)

Part 3: Language Combination with the UI Language (14:51)

Part 4: Language Extension with Expression Blocks (13:14)

Part 5: Language Reuse (Separate Code) with the Persistence Languages (7:44)

Part 6: Language Reuse (Mixed Code) with the RBAC Languages (07:57)

Part 7: Language Embedding with the UI Validations/Expression Languages (12:55)

Part 8: Bonus: MPS Annotations (6:24)

1st Workshop on Game Development and MDSD

2011-07-05T09:15:00.002+02:00

If you are a game developer you may want to consider submitting to the 1st Workshop on Game Development and MDSD. It is held as part of the International Conference on Entertainment Computing. So if you want to have some fun while coding .... it's also in Vancouver, which I guess is an additional argument for submission and attendance :-)

SEACON 2011

2011-06-19T16:24:00.002+02:00

Für spätentschlossene: am 27/28 Juni ist wieder die SEACON in Hamburg, und ich habe mir sagen lassen, es sind noch ein paar Plätze frei! Inbesondere Michael Stal's Architekturtag sieht spannend aus!

Language Workbench Competition 2011 Workshop

2011-05-28T12:34:00.002+02:00

At Code Generation 2011 we had the first of (hopefully a series of) workshops for comparing language workbench tools as part of the Language Workbench Competition. The workshop was a lot of fun and very educational. If you want a summary, take a look at Johan den Haan's summary, or at the very intensive Twitter Live Coverage.

Hopefully to be repeated! Best workshop in a long time!

MPS 2.0 Milestone 5 is out

2011-05-26T14:23:00.002+02:00

MPS 2.0 M5 is out, the New and Noteworthy is available. The highlight certainly is the debugger support for debugging MPS with MPS. This obviously helps you track down problems in your language. M5 also comes with a type system tracer that helps you better understand the unification that's used to calculate types.

One more Milestone, and the final release should be out end of June or beginning of July. Great stuff :)

Video: 500 km mit dem Segelflieger um Nurnberg

2011-05-18T19:51:00.003+02:00

Ich habe mir ja kürzlich eine HD 170 gegönnt, um ein paar Flug-Videos zu machen. Auf dieser Seite habe ich die (Youtube) Videos verlinkt. Am spannendsten ist sicher der (25-teilige) Flug um Nürnberg. Da habe ich so ein bischen erzaehlt wie so ein Überlandflug funtktioniert. Viel Spaß beim ankucken :-)

Xtext Typesystem Framework 2.0

2011-05-16T21:39:00.003+02:00

I have just released a beta version of the Xtext Typesystem Framework, version 2.0. It is compatible with version 2.0 of Xtext. I am thankful to Achim Demelt who did the port to Xtext 2.0. What I did in the meantime was adding a textual DSL to specify the typing rules:

The DSL provides a more concise syntax, as well as static error checking for a bunch of typical errors. Get it :-)

What will be coming in Xtext/Xpand/Xtend in June

2011-04-18T09:30:00.003+02:00

If you are interested in MDD and DSLs on the Eclipse platform, you have of course heard about the upcoming release of Xtext and the accompanying tools. If not, let me give you my view on what will come, and summarize the two most important points. At the core of the new stuff is XBase, an expression language. It can be reused is DSLs, and it is part of Xtend2.

Xtend2 is basically a re-implementation of the old (i.e. current :-)) Xpand and Xtend. It can be used for model-to-model transformation as well as for code generation. A cleaned-up version of Xpand's template syntax is embedded in special Xtend strings. Xtend itself is a "streamlined Java" with higher-order functions, type inference and closures. A really big benefit of Xtend2 compared to the current stuff is that the tooling is implemented with Xtext, and hence is much better quality than the current one. This will be a significant step forward for generator and transformation developers.

XBase is part of Xtend, but it can also be embedded in DSLs. Strictly speaking, you don't *embed* Xbase, rather you make your own grammar inherit from Xbase, so you can reuse the expressions from Xbase in your own DSL. Since basically every (more interesting) DSL has expressions, this simplifies life quite a bit. Xbase is tightly integrated with the JVM and its type system -- it is not yet completely clear to me what this will mean for DSLs whose expressions are not related to JVM types. We'll see.

In addition to these two major steps forward, there are of course any number of bug fixes and improvements. Some small, some a bit bigger, but they are incremental evolutions of what has been possible with the existing Xtext. The improvements
regarding performance and memory consumption are quite significant.

Obviously, I haven't done a lot of real work with this stuff so far, so I am not able to talk from actual experience. But what I have seen so far looks really good and makes me look forward to working with the new release.

Xtext with Xtend, and of course, also MPS with BaseLanguage, clearly shows that language workenches are mature: you can absolutely implement "real" programming languages. These technologies have a great future ahead :-)

MD*/DSL Best Practices - 2011 Update

2011-03-27T12:51:00.003+02:00

In 2008, I wrote a paper covering best practices for model-driven development and DSLs. They cover language design, generation, transformation and interpretation, as well as a couple of best practices regarding organizational issues.

I have now revisited them and update the paper based on my experience over the last two or three years. That experience was influenced by more sophisticated DSLs, and my using MPS - which changes quite a couple of things in the MD* space.

The update uses color to highlight the changes. Read it here..

If you want to comment/discuss/disagree, then I guess the right place is here, a summary posting about my article at InfoQ.

Xtext Interpreter Framework

2011-03-16T09:17:00.003+01:00

I have just published the Xtext interpreter framework. It can be found in the same GoogleCode repository as the Xtext Typesystem Framework.

The framework generates helper classes for interpreters and provides utilities for handling environments as well as logging (including a nice log view for "debugging"). Documentation is available.

MPS export to Eclipse EMF

2011-01-31T09:48:00.001+01:00

Over the last couple of days I have created an EMF export facility for MPS. You can export ecore files from language definitions, as well as XMI files from the instance models.

The export is integrated into the MPS generator facilities. Here is how you use it:

To export an ecore meta model, take any concept declaration in your language of choice and add an ecore export specification annotation (there is an intention for that). In this annotation, you have to specify the name of the to-be-created EPackage, the nsURI as well as the (absolute) path to where the file should be stored. The file's name will correspond to the name of the EPackage. Once you (re-)generate your language, the ecore file will automatically be written as well.

To export an XMI file, select any root element you want to export into an XMI file (currently it's one XMI file per root node). Once again, you create an annotation via an intention. Note that you can only annotate root nodes whose concept has an ecore export specification. In the annotation, you specify path and name, and when you generate the model, the XMI file is written as well.

Notice how nicely one can use the EMF export facility with any language (incl the meta language used for language definition) because of the annotation facility.

Note that the export currently doesn't yet support enumerations (I will work on that...).

You can find the code at https://github.com/markusvoelter/MPSEMFIntegration.

Tutorial and Download for MEL/C MPS project

2011-01-23T16:24:00.003+01:00

The source code for C-based Modular Embedded Language is now available as a download (as opposed to checking it out from SVN). There is also a new Hello World tutorial that shows you how to write your own litte C/state machine/tasks program in MEL. Get it here.

SPLC Industry Track CFP

2011-01-15T10:19:00.002+01:00

In August of 2011 the Software Product Lines Conference 2011 will take place in Munich. SPLC has traditionally been a relatively academic conference; this year, however, they are working to get industry much more involved: here is the Call for Papers.

Let me cite the industry chair Christa Schwanninger: we encourage you to submit industry papers to SPLC. If you are a PLE evangelist or consultant for other companies or within your company, helping your clients to write a joint publication could be a good way to motivate them. The revealed experience would help industry to improve the overall state of the knowledge and experience.

Nothing more to add. Please consider submitting something!

New Book Project

2011-01-09T15:06:00.002+01:00

Eelco Visser and I have decided to write a book - we'll track the progress at dsl-engineering.org.

The book will cover two main aspects: software engineering with DSLs as well as engineering DSLs, i.e., we talk about how DSLs can be used in software engineering and how to engineer good DSLs. The book will assume modern DSL engineering tools (language workbenches). It will not be a tutorial for any specific tool, but of course we will provide examples and some level of detail for the tools you expect from us (SDF/Spoofax, Xtext, MPS, and to a lesser degree, some others).

Although we have just started the book project, we have already written the Introduction as if the book was already finished to give you an impression what we are planning to do. We have not yet decided how open the writing process will be, but of course there will be some degree of openness and community integration. So please check back with this website if you want to stay informed and possibly get involved.

Table support in MPS 2.0 coming along nicely

2011-01-05T12:03:00.005+01:00

MPS 2.0 will feature direct support for tables in editors. I am currently playing around with the code in the MASTER branch in the public git, and I have created a simple example for tables: decision table support for Java.

Here is an example model:

You can now comfortably insert new rows or columns, delete them, and enter expressions. The way you implement it in the editor definition is by subclassing a TableModel class, just as you know it from Swing. A couple of table model base classes exist for the various kinds of tables and matrixes you might want. In the case of this example, I map the table cells onto a linear structure, as defined in the following code (ExprHolders simply wrap/hold an arbitrary expression):

Finally, for generation, I first map it to a new generic switch expression I have added to Java - the intermediate model looks as follows:

In the last step, this is then mapped to a bunch of if statements....

Of course there are still a couple of quirks (it's an arbitrary pull from the repository, not a release!), but table support is coming along nicely.

Also the new build/make system for languages is nice. It now figures out automatically which parts of languages have to be regenerated, reducing average generation times quite a bit.

Interested in an MPS Training?

2010-12-10T18:33:00.004+01:00

We are plannung to run an MPS training at itemis in Zurich in mid-January. We still have a couple of seats available. If you want to participate, please contact me. I am sure we can agree on a pricing model that is interesting :-)

The training will be Jan 18/19/20, and will cost 600 EUR (a bargain!).

RISE 2010 Summer School

2010-11-21T19:43:00.001+01:00

As I write this, I am ready to drive to the airport in Salvador de Bahia, Brasil, to return home from the RiSE 2010 summer school. This was a really cool event. As you can see from the program, I was surrounded by a couple of really interesting people: Krzyzstof Czarnecki, Don Batory and Ira Baxter. All of them have worked for a long time in product lines, DSLs and program transformation. I don't know how much the participants learned from me, but I learnt *a lot* from the other speakers. It is a lot of fun to interact with these folks - too bad, that the opportunities to do this are so rare :-(

So, thanks Eduardo for organizing this and for inviting me, and thanks to Krzyzstof, Don and Ira for a really nice time and many great discussions - and a lot of inspiration for future work :-)

This Developer's Life (Podcast)

2010-11-02T19:58:00.002+01:00

Many of you podcast listeners might have heard about This American Life. It is a very well produced podcast by NPR where each episode covers a specific topic with several mostly true stories, interspersed with music. Many people consider it one of the best radio shows/podcasts ever, and it has won several awares.

Now there is something similar for software developers: This Developer's Life. Same style, same production value, but with stories about software development.

Different than all other software podcasts, but nonetheless (or maybe because of that) very much worth listening to.

And hats off to Rob Conery and Scott Hanselman for producing this. Being a podcaster myself, I know how much work goes into producing something like this! I hope they have the time and energy to keep it going :-)

A thought on (Scientific) Conferences

2010-10-22T03:54:00.002+02:00

Over the last couple of weeks I have been visiting a couple of conferences: MODELS, SLE, GPCE and OOPSLA (now: SPLASH). Particularly with OOPSLA, I noticed it was only a shadow of its former self: way fewer people, reduced programme, non-convincing location. Why is that? Clearly, it is all a consequence of the attendee numbers dropping. So why don't people go to OOPSLA anymore?

There are of course many reasons, and I am not the one to analyse all of this completely. For one, there is simply more competition: the Agile folks, who have been at OOPSLA before, now have their own conference. Conferences like JAOO - although different in style - pull many of the industry attendees away.

However, there is also another problem I'd like to call "conference fragmentation". People don't go to these "big software conferences" anymore, they go to more specialized ones. Let me give you a small overview of the major conferences in the modeling space: MODELS, GPCE, SLE, ICMT, ECMFA, Code Generation, ... and more. The problem here is this: each of these conferences has their own time and location, requiring travel. Because there are more and more conferences, you see fewer and fewer interesting people at each of them. All in all, it makes conferences much less attractive!

There may be reasons why more conferences are better (possibly, I don't know). But can we please colocate them? Can't we have a European Modeling thing go on in the spring (with 3 conferences colocated) and maybe another one in the US in fall? This would make organization simpler, would allow participants to network better, make everything cheaper (economies of scale) and, best of all, require less (annoying) travel.

Don't know if anyone of the decision makers is reading this, but if so, please give it a thought.

MPS 2.0 M1

2010-10-06T22:12:00.001+02:00

The folks at JetBrains have just released Milestone 1 of MPS 2.0. It's probably not a good idea to switch to it immediately, but you should at least take a look at What's New in it.

Xtext Typesystem Framework - 1.3

2010-10-03T17:56:00.002+02:00

I've just released the 1.3 version of the Xtext typesystem framework. It contains a couple of fixes, but most importantly. it supports type coercion. I have also updated the docs, they now include an example of how to use the typesystem in scopes.

A story about working with MPS

2010-09-06T09:04:00.005+02:00

I am currently working on a DSL for scientific calculations (integrated with Java) in MPS. As part of this DSL I need an expression interpreter. For various reasons, I cannot add the typical evaluate methods to the expression classes themselves, so I have to write a separate interpreter.

Basically what I need to do is this: depending on the concrete expression, I need to recusively call the evaluate function, doing something (e.g. multiply or divide or add) with the result. Here is an example of the typical code you would write in Java:

Now, this code is rather ugly because it has all these if-then-else statements (Java cannot do a switch/case with an instanceof) and also all this casting stuff going on. However, since I am working with MPS I am not forced to stick with existing Java. So I have spent an hour or so to enable a nicer notation:

As you can see, I have created a new dispatch expression that basically enumerates the different cases and the result of the method. The $ sign refers to the already downcasted expression over which we dispatch, so no manual cast is necessary.

This new notation is obviously much more concise, and also much more readable. The fact that the arrows are aligned also helps.

It really is nice if you can enhance the programming language yo work with on the fly :-)

Xtext Typesystem Framework

2010-08-24T17:34:00.001+02:00

Starting with version 1.0, it has become absolutely feasible to build complex languages of Xtext. One aspect of a complex language is usually support for expressions. Expressions require recursive grammar definitions, for which assignment actions in Xtext provide reasonable support.

However, once you have expressions, it typically also need a type system. While it can be argued that type system checks are nothing more than constraints, building a reasonable type system is a lot of work that can use additional support over plain constraint checks.

The code in this Google Code project provides this kind of support. Read the documentation on the download page to learn more.

MPS 1.5 available

2010-08-17T15:59:00.002+02:00

JetBrains have just released the 1.5 version of MPS. It comes with a bunch of new features, among them a debugger, improved version control integration, some generator language features, some ew editor features and much more.

If you want to play with it, you get get it from here. JetBrains have also made the source repository available, so you can keep track as the system evolves.

Check it out!

Erstes Deutschsprachiges MPS Training

2010-08-04T19:17:00.002+02:00

Zusammen mit Software und Support haben wir ein zweitägiges Hands-On Seminar zu MPS organisiert. Je nach Zahl der Teilnehmer werden wir bis zu drei Trainer sein, sodass wir jedem Teilnehmer sinnvoll helfen können.

Der Preis für das ganze ist recht vernünftig.... wer kommt??

New MPS Tutorial available

2010-07-28T16:57:00.002+02:00

A new, very detailed MPS Tutorial is available. It is based on the MPS entry for the Language Workbenches Competition 2011 and explain some basic, but also some non-trivial aspects of MPS.

Give it a try, and let me know what we can improve. We're going to evolve it over time.

Language Workbench Competition 2011

2010-07-25T11:27:00.003+02:00

Over the past few years, and actually the past year, a lot of new initiatives have surfaced in the area of creating so called language workbenches - aiming at facilitating the definition and use of DSLs and code generation.

We believe each of these has its own strengths and weaknesses, and none is 'the best' for every purpose. Still, a lot of people keep asking for the best workbench. Based on that, we have started a Language Workbench Competition, in which we will be able to compare the strengths and weaknesses of these workbenches based on solutions for a predefined set of cases.

If you want to participate (implement the case) or just understand how the different workbenches work, take a look at the site. Currently, of course, there are no submissions yet.

The idea for LWC11 originates from a group of people who met in the preparations for, and during CodeGeneration 2010: Markus Völter, Eelco Visser, Steven Kelly, Angelo Hulshout, Jos Warmer, Pedro J. Molina, Bernhard Merkle and Karsten Thoms.

mbeddr.com

2010-06-11T16:25:00.002+02:00

I have created a new website that covers the MPS/C/Mindstorms stuff I am working on with Bernhard Merkle (and hopefully a larger group of people soon): mbeddr.com. Among other things it contains a couple of new videos about the C implementation in MPS:

Xtext Helios Screencast

2010-06-10T12:04:00.002+02:00

In case you haven't seen it so yet: the Xtext team recently did a screencast on the Helios Xtext. At about 35 minutes into the video, the new features in Helios are explained. These are most impressive. Congratulations to the team!

Papyrus team integrates Xtext

2010-06-05T08:34:00.001+02:00

Adding to my recent blog post about notational flexibility on Eclipse: the Papyrus team has integrated Xtext with Papyrus. Andreas Graf has blogged about it, incl. a video.

Notational Flexibility - making progress

2010-06-03T10:42:00.002+02:00

In a recent blog post I talked about how MPS can render the same model in different ways, in the same editor. The examples was a statemachine rendered as text and a table. Over in the Eclipse Modeling world, progress is being made in a similar way. Here are some examples.

Jan Koehnlein has worked on, and blogged about editing the same model with a graphical and a textual editor at the same time. Essentially this means that the GMF editor uses Xtext for serializing the model to a file. The typical usage is this: A meta model contains high level structures as well as fine grained details. As you define the GMF editor, you only create editor concepts for the coarse grained stuff. In the Xtext editor, you create a grammar for everything. What this means is this: you can for example edit a model completely textually. You can then open it in the graphical editor, which of course only shows (and lets you edit) the coarse grained elements. However, as you save the model back, the fine grained stuff you had added in the textual editor before is still there - it has been loaded by EMF, *not* modified by the graphical editor, and serialized back. So you can use this setup to "fill in the finer points" into a graphical model - making sure the graphical model is not polluted by all the details.

Nirmal Sasidharan showed me two other interesting things yesterday. One was a demo actually created by Jan where an Xtext editor is embedded into a GMF editor. Imagine you have a UML modeler and you want to edit the (say) set of attributes. You an click on the attribute compartment, and an in-place Xtext editor opens to let you edit the "textual content of a box". Very very nice.

The final thing Nirmal showed me is something he created recently, where he embedded an Xtext editor into an Eclipse Forms application. Imagine a forms-based business app, which some embedded DSL snippets. Very nice!

Notational flexibility, with appropriate tool support, is important. This is what the users of DSLs see and interact with. If you want to make domain experts use DSLs, you have to use *their* syntax.

Glad we're making progress!

MPS/C/Lego Video

2010-05-14T17:57:00.003+02:00

Just to let you know: I have recently updated the MPS/C/Lego project home page with a short demo video. If you want to watch it be sure to set it to HD mode so you can read the code...

MPS/C/Lego News

2010-05-07T08:30:00.002+02:00

Wow, long time no posts :-) This week at JAX I had a chance to do some MPS hacking together with Konstantin from JetBrains. We played around a bit with the upcoming version of MPS. He showed me the debugger and other cool things. For example, they have extended BaseLanguage/Java with Closures, native syntax for the Builder pattern (for assembling hierarchical data structures). They've also recently added 1:n:n:n... expressions (aStatemachine.states.transitins.event) and they have implemented extensions methods (a way to add additional members to existing classes) Very impressive :-)

We used some of this to build a table notation for the state machines. The text and table notation can be switched at will while editing. Very nice :-)

Software Experts Summit in Munich

2010-04-07T20:45:00.002+02:00

On June 9 there will be a nice little 1 day conference on software engineering in Munich. The speakers are all part of the IEEE Software industry advisory board. Since the board meeting will take place the two days before in Munich, the chair of the board, Frances Paulisch, has taken the chance to do a littel conference "on the side".

The conference, although branded "SIEMENS", is accessible to non-SIEMENS folks. So if you're interested, take a look at the agenda, it does look interesting.

Dringende Buchempfehlung: Gunter Dueck's "Aufbrechen"

2010-02-14T13:42:00.002+01:00

Ich bin ja nicht unbedingt ein Fan der früheren Dueck-Bücher. Ich finde sie teils etwas zu philosophisch und langatmig. Aber das neue, "Aufbrehen - Warum wir eine Exzellenzgesellschaft werden müssen" ist absolute Pflichlektüre für jeden der Deutsch versteht.

Dueck beschreibt wie sich die klassische Dienstleistungsgesellschaft aufgrund zunehmender Automatisierung dem Ende nähert. Der einzige Weg für ein Land (und die darin lebenden Menschen) relevant zu bleiben ist Exzellenz: also richtig gut sein bei dem was man tut. Mit anderen Worten: wir sollten dringend in Bildung und zukunfsfähige Infrastrukturen investieren. Ich will aber gar nicht mehr erzaehlen. Für jeden der sich schon mal die Frage gestellt hat wie das mit diesem Land eigentlich so weiter gehen soll, ist das Buch dringend lesenswert.

Übrigens hat Dueck auf der OOP 2010 über dieses Thema geredet und ich habe ihn im Vorlauf im Rahmen des OOP Podcasts dazu interviewt. Nach dem Interview war mir klar, dass ich das Buch lesen werden müsste. Vielleicht geht's Euch beim Hören des Interviews ja auch so :-)

MPS/C/Lego Showcase at Embedded World 2010!

2010-02-09T08:54:00.004+01:00

I am glad to report that I will have the chance to show the MPS/C/Lego showcase at this year's Embedded World conference. itemis have a booth there, and I will be at the booth Wednesday and Thursday to help communicate itemis' story about model-driven development, DSLs and embedded systems - including Eclipse Modeling and Xtext, Yakindu and also the MPS/C/Lego showcase.

So if you're at Embedded World, be sure to drop by :-)

There's nothing more motivating than cool technology, Part 2

2010-02-08T21:11:00.003+01:00

Of course I had to show the MPS/C/Mindstorms thing to my girlfriend. She works with embedded software for BOSCH. So in some very real sense, she would be a user of what we are building here. Together we built a simple "dancing robot" example. With a statemachine and a task. She said she really liked what she saw! Very encouraging! (Typically she is rather sceptical about the "magic" stuff I work on) We added some product line variability to create two versions of the "dance". Just a matter of minutes.

The cool thing was: except for a little bug in the statemachine generator, the new program (built with my own language) worked out of the box!!

This stuff is really A LOT of fun!

There's nothing more motivating than cool technology!

2010-02-08T17:27:00.001+01:00

I spent the last couple of days and the weekend working on the Lego Mindstorms MPS showcase together with Bernhard Merkle. I extended my C implementation on MPS with state machines, tasks, bit patterns and other neat stuff useful for embedded programming and the Lego Mindstorms showcase.

It's hard to overstate how much fun it was! It is literally a matter of hours to extend a programming language (C) with new, domain-specific concepts that integrate completely into the programming experience - including the IDE and the type system.

MPS is really an unbelievably powerful tool, and it is surprisingly mature. Very little "strange behaviour". The only thing missing for a complete experience is an extendible debugger - and that will come with the next release (1.2).

There's only one problem: Using MPS effectively requires quite a bit of learning. The learning curve is significant. It's hard for most people to cough up the time and effort to work through the learning curve - I could not have done it without the wonderful support from Jetbrains' Konstantin Solomatov. The only thing I can say is: it's really worth it. It's a perfect environment for language development and integration, and clearly plays in the same league as Xtext and Intentional's Domain Workbench, with each of the tools having their own strong points and weaknesses.

Go, take a couple of weeks, and dig into it! It's really cool!

PS: I will blog about hte actual showcase later.

Helios Xtext coming along nicely

2010-02-05T16:56:00.003+01:00

If you're an Xtext user you should take a look at the New and Noteworthy for Helios M5. The itemis team in Kiel is making good progress and the feature set for Helios is shaping up nicely.

I guess there's no point in repeating what the New and Noteworthy says, but I want to point out one feature specifically: the Builder infrastructure results in a "global model space". In other words you don't have to explicitly import resources (files) to be able to refernece an element. You can do it like Java and work with logical namespaces or packages or something. In the M5 release the guys added a feature which makes this facility perfect: Ctrl-Shift-Z opens a dialog where you can enter a the name of a model element and you can directly jump to that element. This completes the "Java IDE feeling" for your own DSLs. Very nice :-)

If you want to try it out get the M5 distro. It contains a bunch of examples that showcase the new features.

DSL Best Practices Video

2010-02-05T15:37:00.003+01:00

The folks from the JAX conference have published the video of one of my talks at last year's JAX: DSL/MDSD Best Practices. It's german and I have a cold, but I guess it's still worth watching if you're into these topics.

(you can also read most of what I said in English in this article)

New Product Lines Book

2010-01-24T14:20:00.002+01:00

A new book on software product lines has been published. It is called Applied Software Product Line Engineering , edited by Kyo C. Kang, Vijayan Sugumaran, and Sooyong Park and contains contributions (papers) by various authors. Among them are Iris Groher and myself.

So if you're interested in PLE stuff, you might want to consider this book!

DSL Unconference - Einladung

2009-12-30T12:58:00.002+01:00

Am 18./19. Februar findet in einem schönen Hotel in der Mitte Deutschlands (Details folgen :-)) eine zweitätige kleine Unconference (Open Space) rund um DSLs statt. Die Idee ist: miteinander reden, philosophieren, diskutieren, demonstrieren, coden, voneinander lernen - rund um DSLs, intern und extern. Also Dinge wie: Scala, Groovy, Ruby, Eclipse, MPS, Parser, etc.

Das ganze ist keine Schulung, jeder Teilnehmer muss etwas beitragen! Wir versuchen die Kosten so niedrig wie möglich zu halten, aber Seminargebühr und Hotel werden wohl trotzdem so zwischen 200 und 250 EUR werden, denke ich.

Ich organisiere das ganze zusammen mit Stefan Tilkov. Wer Lust hat, mitzumachen, melde sich bitte ASAP bei mir. Dabei bitte angeben, was ihr vorstellen/diskutieren wollt.

Java Language Days auf der JAX

2009-12-03T19:46:00.002+01:00

At next year's JAX conference there will be a two-day special track on new and interesting languages on the JVM (see here). The days are organized by Dierk König and myself. We still have free slots, as well as a budget to invite people. So please let me know who you want to hear speak at this event.

Software Engineering Method and Theory

2009-12-01T18:48:00.003+01:00

SEMAT is an initiative that wants to

support a process to refound software engineering based on a solid theory and best practices.

This certainly sounds interesting. If they can keep it relevant for practitioners, this is certainly interesting to follow.

SEACON 2010 - Call for Speakers

2009-12-01T18:40:00.003+01:00

The 2010 edition of the SEACON is in the process of being prepared (I am on the PC, this is why I blog about it :-)). The conference, taking place on June 28 and 29 in Hamburg, focusses on Interaction Design, Communication, Domain-Oriented Software Development and Test Automation. So, I encourage you to take a look at the CfP and submit something!

PLE Track at OOP 2010

2009-11-29T13:02:00.002+01:00

At this year's OOP conference there will be a two day track on product line engineering, organized by Christa Schwanninger of SIEMENS. The two days are packad with a number of really interesting and relevant talks, going beyond only the technical aspects (such as variant management). So if you're interested in PLE, take a look at the talks and consider joining :-)

The Role of Domain Experts in designing DSLs

2009-11-26T21:58:00.001+01:00

One of the advantages of using DSLs is - so people say - that the communication between domain experts and software developers is improved. However, a good "business" DSL is one where the business or domain folks can do the coding themselves and then they run the generator to build the executable software. Where in this picture is the communication between the domain expert and the developer that the DSL should improve? In an ideal scenario, business people, after creating the models, press a button. No need to communicate to a developer.

However, there's of course another take at this problem: before domain users can use the DSL to write down their domain specific programs or models, the DSL needs to be created! This DSL creation, and the development of the generators, etc. is of course something a developer does! So the communication between domain experts and developers happens during language creation and evolution!

So, where does this leave us? We need to improve the domain expert/developer collaboration during DSL creation! How can DSL tools help with that? After all, they are designed for developers, right? Are we back to the same old "domain experts write it down in Word, throw it over the fence, and then the devs build the DSL"-kind of scenario? Something that DSLs aim at avoiding in the first place?

Here are some ideas and examples of how domain experts can play a role in language development.

When building a DSL with Xtext, language definition is so quick and straight forward that the domain expert can provide input, the developer builds the grammar, and then the domain expert can use the resulting language/editor to try out whether the language can represent his ideas. Because Xtext is so lightweight, such a round-trip can happen in a couple of minutes. Consequently, it is absolutely feasible to put a domain expert and a developer in front of a machine to develop a language together. There's no real need to write a "language specification".

Intentional has emphasized this idea for a while now. They encourage language developers to start new domains/languages by first just writing down domain concepts (essentially, words at this time) and their relationships. At this point, without defining sophisticated custom projections, models can be edited using a default projection. After an hour or two of pair-language-development the dev can spend the rest of the day alone implementing the fancy custom projections. But at least a first rough cut at defining models based on the new language is available immediately.

With MetaEdit+, the graphical shapes representing the concepts in a diagram can be defined with a nice graphical editor. Again, this shape definition is something that can involve domain experts.

So what do we take from this? Quick turn-around during DSL development is essential to be able to include the domain expert in this crucial phase. When selecting a DSL tool, you should take into account this concern - it hasn't been discussed much AFAIK, and most DSL tools don't make this a priority. Maybe this should change.

Learn about DSLs and Schwäbisch at the same time: MID Insight 09 Keynote

2009-11-26T08:13:00.002+01:00

Two weeks ago I gave a keynote at the MID Insight 09 conference. I talked about "Programming and Modeling - Two worlds?" The folks at MID filmed the keynote and I uploaded it to vimeo. So here is the video and the slides are here.

By the way: While the slides are in English, the talk and the video are in German (Schwäbisch).

Tutorial @ SE 2010: Software Engineering mit Domänenspezifischen Sprachen und Language Workbenches

2009-11-25T17:51:00.002+01:00

I was just notified that my (and Peter Friese's) tutorial for SE 2010 has been accepted: Software Engineering with DSLs and Language Workbenches. This is a German conference and a German tutorial, so here's the German abstract:

Als Softwareentwickler sind wir daran gewöhnt, uns mithilfe existierender Programmiersprachen auszudrücken, also die Fachlichkeit des zu erstellenden Systems mittels objektorientierter, funktionaler, oder andere Ausdrucksmittel der Implementierungssprache zu beschreiben. In den letzten Jahren haben sich allerdings Werkzeuge entwickelt, mit denen es möglich ist, eigene Sprachen zu bauen beziehungsweise existierende Sprachen zu erweitern. In diesem Tutorium gehen wir darauf ein, wie sich Softwareentwicklung ändert wenn man die Möglichkeit hat die Sprache an die Domäne anzupassen, und nicht gezwungen ist, sich im Rahmen existierender Programmiersprache zu bewegen. Im ersten Teil des Tutoriums erläutern wir Grundlagen zu domänenspezifischen Sprachen und Spracherweiterungen und erläutere einige wichtige Anwendungsfälle für diese Technologien. Im zweiten Teil werden wir zwei Werkzeuge zeigen mit denen Sprachbau mit vertretbarem Aufwand möglich ist (Eclipse Xtext, JetBrains MPS). Der zweite Teil besteht zum Großteil aus praktischen Übungen.

By the way: it does not overlap with the PIK 2010 workshop, so you can actually come and join us for both :-)

Thoughts on Migrating Model-Driven Solutions between Tools

2009-11-21T09:24:00.002+01:00

This week I was at a customer who started MDD a couple of years ago. They started with oAW 3.x and at some point migrated to oAW 4.x, using the Classic mode. This means that the meta model was implemented as Java classes. Because the decided to generate from UML, the meta classes were subclasses of the UML 1.x meta model implemented in Java that shipped with oAW classic.

The model defines the core data structures of a large scientific instrument, and it serve as a data exchange layer between systems implemented in several programming languages. Consequently, they have code generators for seven different target languages, i.e. they have put quite a bit of effort into the generators. The meta model structure is reasonably simple, but the behaviour, or derived attributes if you will, implemented in Java is quite non trivial.

Now they decided to migrate to the most current oAW, i.e. using EMF for the meta model and models, and Xtend for the derived behaviour. Consequently, all the meta classes implemented as subclasses of UML 1.x classes don't work anymore. Generally, the behaviour implemented in Java is obsolete and cannot be directly reused. A manual migration of the behaviour from Java to Xtend (or to whatever other platform) is required. This is a lot of work - almost prohibitive!

So what can we do to avoid situations like these?

There is no simple solution. Dependencies on tools, no matter which kinds of tools, are always a problem. If you wanted to migrate your system from one database/middleware/UI framework to another, this is also a lot of work. What can we do specifically in MDD tools to tackel this problem? I think there are a couple of things that are a good starting point:

Instead of writing the code generators directly against the UML meta model, you should introduce an intermediate domain specific layer. Code generators are written against this domain specific meta model, and a model-to-model transformation transforms the profiled UML model to the domain specific meta model. This has several benefits: generators become simpler because the are written against a simpler meta model. Simpler generators are easier to migrate. The complexity of handling UML (they used a couple of non-trivial conventions) is encapsulated in the one M2M transformation instead of being repeated into seven code generators. Also, a migration from UML 1 to 2 (or to a real DSL, throwing away UML) would be simpler, because the differences would all be handled in one single place. No change to the code generstors required.

As a second point, you should use declarative approaches wherever possible. Things like validations, scopes, type systems etc. should not be implemented in "procedural" code. Turing complete, procedural code is hard to "understand" with a tool (other than a compiler) and hence is complex to transform into another representation when you want to migrate the code. The more declarative, restricted and structured such descriptions are, the easier it is to work with them. This is of course the whole point about models in the first place! So maybe I should say it differntly: make sure that as many aspects of meta models, validations, scopes, generators and transformations are themselves described as a model! In oAW 3.x/Classic this is clearly not the case - it is the case to a larger degree (not enough!) with more current versions of Eclipse Modeling and oAW.

Finally, assuming you use models for all these things, make sure it is models based on the same tools/formalisms as your application models. This makes them "just another model" which you can (relatively) easily process in a migration with the tools you are working with anyway. In tools like MPS and Intentional, all aspects of DSLs are defined with models expressed in other MPS/Intentional DSLs. It is turtles all the way down :-)

So what do I take away from this: First, migrations are always hard, also in case of MDD tools. They are especially hard if the effort is put into the generators (for multiple platforms) and not so much into the models (note that we actually added an intermediate domain-specific meta model now; introducing this is just two or three days of work). The second takeaway is that we need to enhance tools such as Xtext
(or EMF in general) to describe more aspects of DSLs as models. Validations, scopes and type systems, as well as model navigation and queries ("give me all types of all public attributes of all classes in this file") are important candidates. There will of course always remain some aspects that need to be described with turing-complete implementation code. But by keeping this to a minimum, the tool lock-in and migration effort is minimized.

Eclipse Demo Camp Stuttgart Location Change

2009-11-18T22:31:00.001+01:00

If you are planning to join, please take a look at this page to see the new updated location at the airport.

Oslo becomes SQL Server Modeling - my 2 cents

2009-11-16T07:47:00.001+01:00

Here are my two cents why I am disappointed by Microsoft's decision to change Oslo to SQL Server Modeling. In this eWeek article Doug Purdy is being quoted as follows:

"The great irony to all these (negativ, ed.) comments is that all we did was change the name from 'Oslo' to ... SQL Server Modeling and now we get the #fail tag. If we had called it Windows Modeling or .NET Modeling would it have been #success?"

When I saw Oslo and M, I was always disturbed by the focus on SQL Server integration. I always wondered, why, during talks and demos, the SQL Server aspect was emphasized. Sure, a scalable repository is good and useful. But I always considered it only one option of storing models, basically a "persistence backend" of the nice and cool DSL facilities. I hoped MS would keep the DSL infrastructure indepedent of SQL Server.

This most recent move changes the picture. Now Oslo is basically an API for SQL Server. SQL Server is not merely one of many persistence backends but rather the reason why M & Co exist. And consequently, future decisions in M & Co will be driven by the data community and not by the needs of the DSL community.

So yes, I am somewhat disappointed. Oslo will probably still be a cool and useful tool for data modeling and programming on the SQL server. But it has lost its appeal to me as a general purpuse DSL tooling (at least until I get convinced otherwise :-))

PIK 2010: Produktlinien im Kontext

2009-11-14T15:43:00.002+01:00

Here some information about an interesting workshop at the SE 2010 conference in Paderborn.

Produktlinien sind heute in vielen Bereichen der Software-Industrie vertreten, von Embedded Systems bis zu betrieblichen Informationssystemen. Sie ermöglichen höhere Produktivität, steigern die Qualität und verbessern die strategischen Positionen der Unternehmen. Zugleich sind Produktlinien noch eine relativ junge Technologie, die für viele Unternehmen noch bedeutende Herausforderungen und Risiken birgt.

Der Workshop PIK 2010 beleuchtet aktuelle Erfahrungen mit Software-Produktlinien und fördert den Dialog zwischen Praxis und anwendungsorientierter Forschung. Im Mittelpunkt steht das Wechselspiel zwischen technischen Fragestellungen und den geschäftlichen, organisatorischen und Prozessaspekten. Daneben werden auch neue technologische Entwicklungen vorgestellt und diskutiert.

If you consider joining, please read the Call for Papers.

Eclipse Modeling: Models Getting Bigger

2009-11-11T14:37:00.002+01:00

If you take a look at the more recent activities at Eclipse Modeling you can clearly see a focus on scalability, teamwork, and big or many models.

CDO, the database-based persistence and collaboration layer for EMF models has been extremely popular at this year's Eclipse Summit. I heard about several projects that consider using CDO as the backend for an enterprise wide modeling infrastructure.

What's currently is still missing in EMF (and to some extent also in CDO) is a flexible and scalable query facility. A query language is needed and EMF resources need to provide an API against which queries can be executed. The model query project, spearheaded by SAP, aims at providing this.

In the file/text based environment scalability is also an issue. Modern IDE is, for example, build an index of symbols and the resources in which they're defined to support efficient linking and lookup. The EMF index project, led by the itemis folks in Kiel provides this capability specifically for use by Xtext.

Finally, the ARTOP project has created a number of facilities to work with EMF/XMI models that are several hundred megabytes in size (the tools are not publicly available right now).

All of these projects and developments are a clear signal that Eclipse modeling is picking up momentum in "real" environments. It is a good sign if a technology leaves behind the "it works" phase and addresses "how to use it large scale".

Programming, Modeling, DSLs and Language Workbenches

2009-11-07T19:49:00.002+01:00

More and more I am getting to the point where I think that there should be no difference between modeling and programing. What we really want is to program ... at different levels of abstaction ... from different viewpoints ... all viewpoints integrated ... … with different degrees of domain-specificity ... with suitable notations ... with suitable level of expressiveness ... and always precise and tool processable.

I am talking about this idea quite a bit. Some slides towards this point are at slideshare and as PDFs on my website.

I will blog about some of the thoughts from these slides in the next couple of weeks.

William Cook on Industry and Academia

2009-10-23T19:08:00.003+02:00

You should really read William Cook's ECOOP 2009 Banquet Speech on Industry and Academia. Very good! Here's an excerpt:

The way I see it is that industry generally has more problems than they do solutions, but academia often has more solutions than problems. As an academic, I think everyone here will realize the value of a good problem. So if nothing else, we should revise the technology transfer story to include flows in both directions. Industry could transfer problems to academia, and academia could provide solutions to industry. I want to emphasize that both these flows are of high value.

Exactly how I see it, too!

A few thoughts on code generation with MPS

2009-10-23T09:58:00.003+02:00

Here is a typical scenario that I use when working with classical external DSLs: I describe certain structures in the model. From the model I generate all kinds of code, infrastructure, glue code, and also an API (e.g. superclasses) against which I then implement the manually-written business logic.

Here is an important thing: if I want to enforce certain constraints, for example visiblities or dependencies, then it is not enough to enforce these constraints on model level. I must make sure, through generation of suitable code structures, that in the manually written parts I cannot violate these constraints. For example, I need to prevent the creation of depenencies that have been prevented on DSL level. Consequently, I have to put a lot of thought into the structure of the generated code and sometimes I need to use "tricks" to enforce these constraints on code level. Or I need to use static analysis tools.

Contrast this with the approach in MPS: here you code *everything* in the model, because you can use Java (or other languages we're working on) directly on the model level. You don't implement code against some kind of generated API. So you can enforce the constraints mentioned above only in the model! The generated code is really not important here (sure, it should be readable and debuggable, but it's not something against you program). This simplifies the design of the generated code, and hence the code generator, quite a bit.

Training on DSLs, Product Lines and Language Workbenches

2009-10-22T21:52:00.002+02:00

On February 3 and 4 2010 I will run a course on Domain Specific Languages (for Product Lines) at Sioux Embedded Systems in Eindhoven, The Netherlands. In addition to concepts, I will cover Xtext as well as MPS.

I invite you to join, even if you already know one of the tools - maybe especially if you already one of the tools, so you can learn another approach. This will certainly deepen your understanding about DSL and the technologies used to implement them.

If we get a nice group, this could be a very interesting, productive and fun training.

Practical Product Lines 2009

2009-10-22T08:07:00.002+02:00

I just returned from the PPL 2009 conference in Amsterdam. Although small, the conference was very good: nice program, competent participants, nice venue, good food. I will definitely go back next year. It is also better value for money than SPLC if you're interested mainly in practical aspects of PLE.

To get an impression of what the conference was like, take a look at the Twitter #ppl2009 stream.

Slides uploaded to slideshare.net

2009-10-18T12:39:00.002+02:00

I have just uploaded a couple of my currently relevant presentations to http://slideshare.net. All of them had been online at my website, too, but I decided I wanted to participate in the slideshare community.

Type Systems for Xtext DSLs

2009-10-11T18:17:00.002+02:00

I recently implemented a type system for an Xtext DSL. I wanted to give you a couple of pointers of how to do it, if you have to.

What is a type system? A type system is essentially a set of sophisticated constraints. I.e. it is a way of determining whether a model is correct beyond its structure. We all know type systems from programming languages. If you try to add an int and a String, you'll get a type error.

So, in principle, you could simply implement a type system as a set of Check constraints. This is true, but for non trivial type systems and languages, this can grow complex. A more principled approach is recommended, and it consists of three ingredients.

The type meta model: the structure of types and their relationship often warrants its own meta model. For example, an array type isn't trivial: It has to express that it is an Array, it has to contain the size, and it has to point to the type of the elements in the array. The array type itself is structured. Hence, it is a good idea to create a meta model, or language, to capture the types. In the context of Xtext, you can either do this as a separate EMF meta model that you reference from the Xtext DSL, or you simply add additional rules to the language that represent the types once they are transformed to Ecore. Make sure that the grammar structure does not allow you to actually "write down" the types in models - you want to work with them behind the scenes.

So how do you associate the type of an element with the element itself? A good way is simply to create a bunch of Xtend functions. I usually call it typeof(...) and define it polymorphically for all the language elements for which I want to have a type. These functions typically do one of two things: for atomic elements (e.g. an integer literal or an array declaration) the typeof(...) extension simply returns the type object, i.e. instances of the type meta model (or language) defined above. For non-atomic elements (let's say, a comparison operation that compares the result of a constant and a plus expression) the typeof function contains a type derivation rule. For example, for a plus expression, it returns the type of one of the operands (the types of the two operands have to be the same, see below). For a comparison
operation, it simply returns boolean.

Finally, once you have these two ingredients in place, you can now implement the actual type constraints. For example, it a type constraint might say that for a plus expression, the typeof(...) the left operand and the typeof(...) the right operand need to be the same. Note that by calling the typeof(...) function for both operands, the resulting type is calculated correctly even if the two operands are, for example, multiplication operations themselves.

One last comment: usually, types don't have to be the same for a constraint to be correct, but they have to be "compatible", whereas compatible is defined specficially for each type. To incorporate this problem, simply create an isCompatible(t1, t2) Xtend function, which you polymorphically override for all relevant type combinations.

That's it! Using this approach gives you a scalable, and maintainable type system implementation.

PS: MPS uses the same approach. It even comes with a separate DSL for defining type systems, including a set of operators for type inference and type compatibility. Very nice!

MPS Workshop at itemis

2009-09-28T10:05:00.002+02:00

Last week, we had a workshop about JetBrains MPS at itemis in Pforzheim. Konstantin Solomatov, MPS' lead developer, was kind enough to spend a whole week with the team in Pforzheim to teach us MPS to a level of detail where I feel comfortable to start using the tool in real projects (thank you very much, Konstantin!).

We have built a couple of example languages, all of them extensions of Java. Remember that one of the benefits of MPS is the ability to extend existing languages, in particular, the version of Java (called BaseLanguage) they ship with MPS: we have extended Java classes with state machines, we've added pre- and postconditions to Java interfaces, we implemented a new type to represent money and we've built a way to express product line variability for arbitrary languages.

Once we got used to some of the particularities of MPS, working with the tool was actually very productive and comfortable. In the time we had, we got further along than I had expected. JetBrains have done a really good job with making the projecting editor "feel" as much as text as possible. Within a week or two, you can easily get used to working with this approach.

Because MPS is a projectional editor, you can be extremely flexible regarding modularization and combination of languages. The four example languages we have built can be combined arbitrarily in a single program. Of course the drawback is, that programs are not stored as plain text, but rather as an abstract representation (XML). This means, that you can edit MPS programs only with MPS. However, the projectional approach does give you a significant amount of additional flexibility over storing the concrete syntax. In other words: there are many environments where storing the textual syntax is preferable, in which case tools like Xtext are the better choice. But there are also a number of scenarios where you don't care as much about how programs are stored, and you want to exploit the benefits regarding flexibility that projectional editors deliver. In those scenarios MPS is a very interesting candidate and certainly worth considering (remember, that it is also open source).

In the next weeks, I will continue my evaluation of the Intentional Domain Workbench to complete my picture about the three most interesting DSL tools out there: Eclipse Xtext, JetBrains MPS and the Intentional Domain Workbench. These tools are different enough to warrant familiarity with each of them. They all have a particular sweet spot regarding where and how they should be used.

Stay Tuned!

The future of openArchitectureWare

2009-09-28T09:58:00.003+02:00

Over the last couple of months, many people have asked me about the status of openArchitectureWare. I have blogged about this before. Here is some update. Heiko and Peter have created a succinct summary at openarchitectureware.org.

Profiler for XPand and Xtend

2009-09-27T18:31:00.002+02:00

Heiko Behrens has blogged about the Xpand/Xtend Profiler that will be part of the next 0.8 M2 release. Using the profiler, you can substantially improve the performance of Xpand-based code generation and/or Xtend based model transformations. If you have issues with oAW performance, take a look!

Website down

2009-09-17T21:47:00.001+02:00

It seems my website http://www.voelter.de is currently down. My provider says they're working on it... they said this 5 hours ago. Let's see if it's up again by tomorrow morning.

Using Scala for Xtext scope definitions

2009-09-09T16:16:00.002+02:00

Over the last couple of days I have experimented with using Scala for a XText scope definitions. In my opinion, the current API for defining reference scopes in Xtext has two problems: first, because it is based on naming conventions, there is no compiler error if you change the name of the referencing feature; your scope definition simply isn't invoked anymore. The second problem is that Java is not necessarily the ideal language to write more or less complex model navigation and query code.

My Scala implementation addresses both of these problems. Scala, through its functional programming flavor, is much better suited for model navigation and query. Also, I've decided to generate a base class with empty scope definition methods and you provide the customized implementation in a subclass. Since Scala requires the use of the override modifier if you want to override a method in a subclass, you get a compiler error if you change the name of the referencing feature (and hence, the name of the generated method in the base class).

In the rest of this post I explain how I built this, and also discuss my experiences, and whether I recommend using this approach or not.

The first you have to do is to install the Scala IDE for Eclipse. Then you have to Scala-enable your language project, since you want to put scala code into it. I have described here how you do this.

Then you need to make sure that the base class with the generated scope methods is generated as part of the language generation process. To do this, I have written a plug-in that contains an additional Xtext generator fragment that generates this code. Generator fragments are plug-ins into the Xtext generator. You get the language grammar as an EMF model, and then you can generate whatever you want from it.

Based on this infrastructure, you can then implement your own scope in Scala.

Should you use this approach? In principle, yes. Scala really is much nicer than Java, particularly for the task at hand. And the fact that you get compiler errors if you rename properties is really useful.

However, in practice there are two problems that really make me recommend do not use this approach at this time: the first one is that the EMF data structures don't play well with Scala's collection API. You have to write a lot of conversion functions. While this is in principle possible (and actually, quite nice to do due to Scala's implicit methods) you do pay a performance penalty. However, I think this issue can be solved.

The second problem is the Scala IDE for Eclipse. At least in this scenario, where you mix Java and Scala code, and where you use it for plug-in development, the IDE really is not good enough. For example, code completion doesn't work (at least on my machine), you have to do a full rebuild constantly to make sure changes in the Scala code make it to the class files, a compiler error in the Scala file "destroys" the classpath, preventing Xtext from generating the language, there is no "organize imports" for Scala, etc. etc.

Now, my goal here is not at all to bash the Scala IDE. I got good support from Miles Sabin who is the main person behind it. He said that by the end of the year the Scala IDE should be roughly comparable to the Java IDE in Eclipse (and he's looking for help in reaching this goal!). So I guess, I will check back later, when the 2.8 release of the IDE is available. I really think, once the Scala tooling in Eclipse has matured, using Scala for scopes is a good idea.

MDE Diploma in Nantes

2009-09-06T19:55:00.002+02:00

The folks at Nantes (Ecole de Mines and INRIA) have started something interesting: an MDE Diploma. They describe it as

The MDE International post-graduate specialization Diploma in Model Driven Engineering (MDE) for Software Management is offered by Ecole des Mines de Nantes. Its objective is to train engineers to manage complex projects in various IT fields with the latest cutting-edge modeling technologies.

Sounds good! So if you're interested in enhancing your academic education, and want to do it in the context of model-driven stuff, you should take a look!

Xtext Helios Roadmap

2009-08-27T17:36:00.001+02:00

... on Sven's Blog. Let him know if you have comments, suggestions or input!

Java programmers: you must read these two books

2009-08-24T13:32:00.003+02:00

Recently, there has been a lot of hype around the idea of using different languages for programming the JVM. Many languages are available, as you probably know. However, I think two of these languages are specifically worth taking a look at because they approach the problem quite differently. These languages are Scala and Clojure.

So, what is the problem? The problem is, in my opinion, that the Java language (not the JVM) has stagnated. When Java was created, one of the primary goals was a significant simplification compared to C++. And I would argue, that this goal was reached. Java has deserved it's success. However, the landscape has changed over the last couple of years and Java did not evolve. Example areas include concurrency, functional programming, metaprogramming (internal) DSLs and type systems. As a consequence, alternatives languages flourished.

It is interesting to see how Clojure and Scala address this challenge very (although not completely) differently. I'd say the only thing they have in common is their emphasis on functional programming.

So let us look at some of the differences:

Typing: Scala is strongly typed, even more strongly than Java, but it comes with a sophisticated type inferencer to make sure the type system does not get in your way. Clojure on the other hand uses dynamic typing (duck typing, specifically), like so many of the "newer" languages. Consequently, Scala has a very sophisticated compiler, whereas Clojure emphasizes much more the runtime system.

Concurrency: Scala uses the actor model. Actors are lightweight threads that communicate by message passing. Clojure mainly relies on immutable data structures and pure functions, but it also comes with a software transactional memory facility for managing shared state without requiring developers to manually manage locks.

Syntax: Scala's syntax is in the tradition of Java. Although it reduces noise significantly (thanks to type inference and many other useful conventions) it is still driven by keywords and different special symbols. Clojure on the other hand, in the tradition of Lisp, basically treats everything as a list. I have not yet made up my mind as to which syntactic style I prefer. My stomach tells me I prefer Scala style. However, I do recognize that the simplicity orthogonality of Lisp like syntax provides for some very powerful facilities (macros)

Extensibility and Metaprogramming: Both languages emphasize extensibility in the sense that you should be able to use libraries to provide powerful functionality, which ideally looks like as if it would be built into the language. As usual in Lisps, closure provides a macro system that supports the definition of almost arbitrary special forms (as long as they still look like a list, syntactically - that's the catch, of course). In Scala, by being able to avoid the dot operator, parentheses and semicolons and through clever use of functions, you can achieve some of the same goals (there is also a compiler plug-in framework).

So, why am I talking about this, and why thus the title of this post talk about books?

I would suggest that every self-respecting Java programmer has to inform themselves about these two languages. Even if you will never use them, you should take a look to understand how the same problem can be solved in different ways, and how languages on the JVM can evolve (both provide extremely good interoperability with Java the language, by the way). It's a matter of looking beyond your own nose.

To do so, I suggest you read the following two books. Both are reasonably short, very well written, and emphasize the important issues:

Programming Scala by Venkat Subramaniam and Programming Clojure by Stuart Halloway

News about OSLO

2009-08-18T12:20:00.002+02:00

Some news about OSLO. I am not sure I like the merging of the Data Programmability team and the "Oslo" team ("Quadrant", Repository, "M"). I was always confused by some of the talks I heard where the SQL-ishness of everything was put into the foreground.

Hardware for Podcast Editing

2009-08-13T21:17:00.002+02:00

As you may know, I do quite a lot of audio editing these days for the various podcasts I am involved in. The time I spend editing the audio is worth optimizing....

So I was looking into buying affordable external controllers (aka control surfaces) for Adobe Audition. There are two ways how Audition can be controlled from an external device: the MIDI interface as well as "something that simulates a keyboard".

I have been looking into the following devices: Frontier Design Tranzport, the Numark Total Control, the Miditech MTB Command as well as the Contour Shuttle Pro V2.

The first three are MIDI devices and cost ca. 200 EUR. The last one is a "keyboard simulator" and costs EUR 99. I decided to try the cheapest one.

It arrived today. It has 13 buttons and two wheels, I use one for transport and one for zooming. I've assigned the most commonly used editing operations to the 13 buttons.

After editing a bit today I have to say it works really well! I now use the mouse with the right hand and the Shuttle with the left hand, hardly touching the keyboard. The editing experience is a quite a bit more efficient, and much more pleasant.

It's a little bit like HOTAS from military aviation: it takes a little bit of time to learn to "play it", but once you have practice, you're much faster and you can operate the device blindly.

Recommended.

DSL Variant Management for TMF Xtext Released

2009-08-13T11:24:00.007+02:00

Over the last couple of weeks Andreas Rytina and I have been working on porting the DSL Variant Management Tools to Eclipse 3.5 and TMF Xtext. We have finally finished these efforts and the plug-ins are available as a download.

The DSL Variant Management tools allow you to access pure::variants feature models from within your own textual DSLs. Static checking of feature names is the supported. There is also an integration with pure::variants relations view, which means that if you select a feature in the feature model the relations you will tell you, which off your DSL files refer to that feature.

In addition, you can also specify feature dependent regions in manually written code (in fact, any text file) and you can query selection status of features from within model transformations and templates.

We have also updated the documentation. The code used in the documentation is available for download, too.

On a related note: we are currently preparing an eclipse project to implement simple feature model tools based on EMF and other Eclipse Modeling technologies. Over time, we will and able the DSL variant management tools to also work with this open source feature modeling environment, and not just with the commercial pure::variants.

Results of my Layouting experiments

2009-08-09T11:40:00.003+02:00

Over the last couple of months, together with a couple of other people, I have been working on model visualization tooling, based on GraphViz and ZEST. However, the layout algorithms that come with these tools aren't as good as I'd like them to be; specifically, the algorithms in ZEST don't avoid node overlaps and aren't robust with regard to adding a few new nodes (i.e. the layout can change completely if you add new nodes).

A while ago I had the idea of using numerical simulations for layouting. Each node is assigned a negative charge (i.e. nodes repel each other) and the connections act as springs (i.e. they create a pull force between them). Doing an interative numerical simulation of the forces between them should result in a nice layout. That was the idea.

Since I couldn't convince somebody else to try this out, I had to do it myself :-) Here are the preliminary results.

I built this thing "from scratch" using Scala and Java2D. I think the results are convincing. The next steps would be to either integrate a layout along these lines into ZEST or to enhance my prototype to become a complete Eclipse-based model visualization solution.

I'd prefer the first alternative. Anybody interesting in integrating this approach into ZEST?

Back to the Roots

2009-08-02T20:24:00.002+02:00

Yesterday evening, and also most of today, I spent coding in Scala. I was prototyping a layout algorithm. I implemented the prototype in Scala, nicely test-driven (ScalaTest), and using IntelliJ as the IDE. I've used Scala before, but ScalaTest and IntelliJ was new for me.

The coding was/is a lot of fun! As you probably know, these days I spend most of my time doing meta stuff: languages, meta models, code generators. Or, if I code, it's either C (in customer projects) or it's Java based on huge frameworks (usually Eclipse or JEE stuff). Programming against these frameworks is not so much about creatively programming, it's more about understanding and mastering existing frameworks, which can be very frustrating.

Over the last two days, the only framework I had to work with was Java2D. Everything else is very much self-contained, really nice OO design. Scala is really refreshing, and I have to say, I start understanding people who say that IntelliJ is the better IDE for Java development... Eclipse is of course very useful because of it's plugin architecture and the huge amount of existing plugins, but for pure coding... IntelliJ really is nice.

So, in summary: this was a lot of fun. I should do more coding like this :-)

MPS 1.0 is now available

2009-07-23T20:14:00.002+02:00

Jetbrains have just released MPS 1.0. You can get it from here, and there's also a lot of docs and videos available.

From my perspective, tools like Xtext, Intentional's Domain Workbench and - of course - MPS have the potential for a revolution in programming. Being able to define your own languages, including IDE support, or extending existing languages, also with IDE support, is really a powerful concept. If think about it, this really blurs the line between modeling and programming - very very nice.

Try out those tools! And even if you judge them as not ready for primetime yet, think ahead one or two more years, or even three, and imagine what they'll be able to do.

Congratulations Jetbrains!

And thanks for making it Open Source ;-)

Graphviz Integration Ported to Eclipse 3.5/TMF

2009-07-17T15:50:00.000+02:00

I have ported the oAW visualization tooling for Graphviz to TMF Xtext and Eclipse 3.5. You can get the distribution and the docs from the Google code download page.

First MPS-Based Open Source Activities

2009-07-14T17:42:00.002+02:00

Some people want to add C# to MPS.

I'd like to see C in MPS, too. Anybody interested?

MPS 1.0 Release Candidate

2009-07-10T17:27:00.002+02:00

... has been released today. Go here to get it.

Eclipse, Galileo and oAW

2009-06-25T08:10:00.002+02:00

Yesterday was the big day: Eclipse 3.5 Galileo was just released.

I thought I'd use this occasion to give you an update about oAW in this context.

The Galileo release contains what has been known as oAW 5. Over the last year, oAW has been broken down into its constituent components, and the components have been contributed to Eclipse. oAW 5 can thus be considered a distribution, or packaging, of these components.

However, currently there's no real oAW 5 release, specifically the openArchitectureWare.org website does not yet reflect the newest release.

If you want to get the new code, you should simply download the available distributions. You can get the Everything-in-Modeling distribution from here the Eclipse download page or you can get the oAW distribution from itemis' oAW site.

So what's new in the current release?

First of all, Xtext has been completely rewritten, as part of the TMF project. This is why we now call it TMF Xtext. The new version is much more scalable, supports cross-language references well, supports (single) language inheritance and is generally much more flexible. Go to the official TMF Xtext project page to find (the really nice!) documentation and access to newsgroups and mailing lists.

oAW 5 also contains - as you would expect - Xpand, Xtend and Check. These are all wrapped under the M2T Xpand project. Compared to 4.3.1, no major changes have been made; a couple of bugs were fixed and a number of minor adaptations have been made to work better as an Eclipse citizen. There's also a wiki page as well as newsgroups and mailing lists.

Finally, the release also contains the tried and trusted workflow engine. It is now its own EMFT project, with the goal of encouraging other transformation tool developers to write a workflow component to integrate with workflows. Imaging you could simply use an ATL transformation or MOFScript generator as part of your workflow...!?

So you might wonder: what has happened to openArchitectureWare as a whole, now that all its "real stuff" has become Eclipse projects and the downloads are available as part of distros? There is now an oAW Working Group. It has its own mailing list and website, and this is the place where we want to gather oAW users, discuss the tool and coordinate further development in the context of the Eclipse development process. The openArchitectureWare.org website will be adapted soon to act as a redirect to the working group page.

Thanks to all the oAW comitters, specifically the itemis guys in Kiel, for doing a great job with the new release, specifically with TMF Xtext. I am not completely happy with all the decisions they've made, but it is an important and very good step forward!

Synchronized editors with TMF/Xtext and GMF

2009-06-21T19:54:00.002+02:00

Jan Koehnlein, in his blog talks about creating a system where TMF Xtext and GMF work on the same model. He has a screencast that shows it. Well worth watching.

Visio, EMF and oAW

2009-06-19T10:23:00.004+02:00

A long time ago I built an integration of Visio with openArchitectureWare 3. As version three of oAW went out of use, I didn't have the time and resources to update the tooling for oAW 4 and EMF. Recently some people have asked me about Visio/EMF integration and I had to disappoint them...

However there's good news! Heiko Kern from Leipzig University has built a Visio/EMF bridge that looks really nice! I have not yet used it, but it looks really good.

So, whoever asked me about the Visio/EMF integration recently (I have to admit, I forgot who it was :-( ): why don't you try this out and let me and others know if it works for you?

CodeGeneration 2009 - a great conference

2009-06-19T09:43:00.001+02:00

I spent the last three days at the CodeGeneration2009 conference. I knew it would be good, since it was good the last two years, but this year it was really great.

The good thing is that it really serves as a (european) community meeting for many folks involved in DSLs, MDD and code generation. The best part of the conference, hence, is meeting all the colleagues and friens in this space.

Also, this was the first conference in a long time where I spend almost every slot in a session: I was in Eelco Visser's Stratego/XT tutorial, in a panel or two, and in two goldfishbowls (I love the format!) about the relationship between DSLs and programming languages, and modeling vs. programming in general.

I had the pleasure of keynoting the event this year, together with Metacase's Steve Kelly. We never did a talk together, but I think our two co-presented keynotes on best and worst practices in DSLs and MDD went really well - at least that's what the audience feedback sounded like.

The talk on MPS with Konstantin Solomatov was also a great success. I started out by presenting a bunch of slides about the idea of programming == modeling and projectional editing, and then Konstanting gave an impressive demo of MPS. You could see a bunch of open mouths in the audience while he was showing off the tool (people told me that mine was also open :-)). After he finished his demo with the words "I think that's all I wanted to show" the audience spontaneously applauded.

I think tools like MPS and Intentional's Domain Workbench have a great future - even if currently they still have a couple of rough edges. Who cares if you have to wait another year for a revolution :-) ?

So, I guess, you should really consider going to Code Gen 2010 next year if you're into DSLs. Not the usual introductory stuff - really interesting content!

Thanks Mark Dalgarno!

Flying with the Cambridge Gliding Club

2009-06-17T08:41:00.000+02:00

Bernd Kolb and I spent yesterday evening with the Cambridge Gliding Centre. We are currently both at the Code Generation 2009 conference. Andrew Watson, also at the conference, and gliding instructor at Cambridge, invited us to join him for the Tuesday evening flying - thank you very much for this, Andrew!

Gliding really is the same everywhere, so once you are on an airfield, you can give everybody a hand and help out. And pilots are also a very nice bunch of folks, so it was easy to feel comfortable there. Bernd and I also both got a ride in one of their ASK-21's, a training plane both Bernd and I have a lot of exprience in. We did a winch take-off, and because it was evening already, it was only a five minute hop. I hadn't done a winch take-off for a long time, so it was also good exercise!

Thanks to the evening crew for their hospitality, and to Andrew to taking us along!

GMF is still awful

2009-06-12T11:00:00.002+02:00

Today we had a GMF workshop at a customer (I was a participant, not the presenter). And I have to say I am still seriously underwhelmed by GMF ... I hadn't looked at it for a year or so. It is still basically unusable: awful editors, bad diagnostics and a lot of duplication.

Obviously, having a tool for defining graphical editors is a good thing. However, I think GMF really fails at delivering. It is too low level, and too brittle.

I wonder when somebody will build a decent (textual) language that supports simple creation of (GMF-based) graphical editors. York's Epsilon Eugenia is a step in the right direction.

I hate travelling, continued

2009-06-11T21:56:00.002+02:00

I am currently in Norway for a customer. Last night I was in the Ambassador Hotel in Drammen. I sucked - stay away! First I was in a room that was extremely loud, the trucks practically drove through the room. I asked for another room a minute after I arrived and they said they had no other room. Two hours later, after I tried in vain to sleep, I called the reception: "I want another room or I will leave the hotel". Then they had one....! I changed.

Of course I forgot my notebook power cord in the room, which meant I had to go back to the room the next morning. I asked at the reception to have them go into the room and grab the cable - they refused: "there's somebody else in there". I knocked at the room door 10 times, no reaction. They still said "somebody in there" and refused to let me in, "the person must be at breakfast". I asked everybody at breakfast. Nobody was in the room. After a long while I convinced a cleaning lady to let me in. It was empty. I got my cable. Of course I missed the train to the customer....

Next day, better hotel, Scandic Hotel in Asker. Nice room. Quiter. Of course at 21:40 a group of guests started dancing and singing outside the hotel in front of my room. No sleep, again.

I HATE TRAVELLING!!! I guess I really have to make sure that I have to travel less. The plan was to travel <= 50% as part of my work for itemis. However, as a consequence of the current economic situation I guess I have to travel more (again...).

Next year will be different! I promise (to myself)!

Keynote at Practical Product Lines 2009

2009-06-09T10:27:00.002+02:00

I am happy to report that I will be giving a keynote at this year's Practical Product Lines conference. This is a new conference on PLE organized by Mark Dalgarno, who is also the person behind the very successful Code Generation conference series.

Now I just have to come up with a good topic/talk :-)

MPS Beta 3

2009-06-04T11:55:00.002+02:00

MPS Beta 3 is available for download. Important new features include a new, more text-flow-like editor layout as well as a facility to build custom MPS distributions/packages that only include your own languages.

SoftwareArchitekTOUR Podcast

2009-05-20T21:20:00.003+02:00

I just wanted to let you know about a new (german language) podcast on software architecture called SoftwareArchitekTOUR. It is hosted at heise.developer, supported by Microsoft, IBM, itemis, innoQ and Siemens.

The shows are hosted by Stefan Tilkov, Michael Stal, Christian Weyer and myself.

In contrast to SE Radio, we won't do many interviews, but we'll try to build a real community by encouraging feedback and audience interaction.

Go, give it a try and let me know what you think!

Microsoft Axum: "Erlang for .NET"

2009-05-19T07:48:00.001+02:00

Microsoft has just started talking about a new .NET language called Axum. People have described it as "Erlang for .NET". To stick with this classification, one could also call it "Erlang with a more mainstream syntax".

It is an agent based language, which means that communication is asynchronous and message-based, and agents (cf, the Actors model) are considered active, i.e. they have their own thread or process. Data in messages is typed and can be (deeply) serialized to make remote message sending (i.e. agent distribution) possible and more or less transparent. Axum comes with integration into WCF.

Communication between agents happens via Channels. A channel is a kind of "asynchronous interface", i.e. channels define which messages can be sent into it and received from it. Agents "implement" Channels as a way of defining the kinds of messages it can handle.

Since the timing and sequencing in asynchronous applications can be hard to understand, Axum supports the definition of protocol state machines (yeah!!) for channels. So if you send something in the wrong order, you don't get a strange crash or a deadlock, but rather a meaningful error message. I *love* that part!

Axum comes with powerful operators to define dataflow networks. You can say things like: "wait until a message arrives in this channel and in that other channel, then combine the two messages in an array, forward them to the agent xyz and forward the result to these other two channels, in an alternating way". You can define things like that with concise expressions. Very cool!

Axum has a controlled way of handling side effects. Specifically, the "units of functionality" can be declared as functions, which means they have no way of accessing state (this is checked by the compiler). The point of this is, of course, to be able to run parts of dataflow networks in parallel. This is where the big benefit of agent-based/dataflow-oriented systems comes in.

I have to say, this stuff looks *really* interesting! Because it is based on the .NET platform you get interop with other .NET stuff more or less for free. There's also an integration with VisualStudio. It is really interesting to see how Microsoft, after "renovating" and "mainstreaming" Haskell to F# they now adress Erlang and pimp it up to Axum. Very cool!

Afrikanische Ostern

2009-05-10T20:42:00.002+02:00

(sorry for the German language...) An Ostern 2009 war segelfliegerisch das absolute Hammerwetter. Das kam so unerwartet und hat mich derart begeistert, dass is beschlossen habe, mal ein paar Eindrücke zu Papier zu bringen. Das 9 Megabyte PDF ist jetzt fertig. Viel Spass beim Lesen :-)