oAW at EclipseCon and QCon

Markus Voelter and Bernd Kolb will present oAW (and Eclipse Modeling) at EclipseCon. There are several talks regarding Eclipse Modeling. Strange thing that some of them take place at the same time in different rooms... ???
Anyway, if you're there make sure to visit their talks, because they will present some cool new features :-)
In addition Markus will talk about Xtext at this year's QCon. You have to go there if you 're at all interested in DSLs!
Markus and Bernd: Thank you for traveling around the world and presenting it. :-)

itemis labs kiel - Team blog

There's a rumor about Itemis AG in Kiel working on great ;-) open-source software hosted at eclipse.org as well as openarchitectureware.org.

If you want to keep yourself informed about their latest activities go here:

http://apps.itemis.de/roller/itemislabkiel/

TMF- Successful Creation Review

Yesterday, I presented the new TMF (Textual Modeling Framework) to the Eclipse Foundation together with my co-lead Frédéric Jouault from INRIA, France. There were just a view questions regarding the relationship to IMP and Antlr. One of the attendees already had experience with Xtext and was very excited to hear about Xtext becoming an Eclipse project. Nice to hear :-)

The next step is to do some paper work, rename packages, etc. and get the AntLR generator IP-approved.

Stay tuned.

Can Dynamic Languages Scale?

Currently, there is one of these "dynamic vs. statically typed languages"-discussion going on at theserverside.
I found especially the discussion regarding "IDE support" funny, because both sides seem not to have an idea of how it "feels" to work in the other environment. I don't have "real project" experience using dynamically typed languages either, but have tried many of them to do smaller tasks.

For me the "type safety" of statically typed languages isn't important. What is important is the IDE's knowledge of the static type information and what can be done with that. There is much more than just 'refactoring' or 'compiler checks', which are both very useful of course. Btw. refactoring in Eclipse's JDT or IntelliJ's IDE is far more sophisticated than what the old smalltalk 'Refactoring Browser' can do. And this has to do with the availability of static type information.
What about all the cool Navigation features, type hierarchy view, call hierarchy, etc. ? With static information in place one can view the source base from different angles using different levels of abstraction. Of course some of these things can be done without static type information as well, but not near to what you'll find in the IDEs I mentioned above.

Most of the hype about dynamically typed languages like ruby, python or groovy are because the existing statically typed mainstream languages are just very verbose and lack a number of important features (e.g. closures). Have a look at languages like Scala or even C# 3.0, they are statically typed AND expressive at the same type. Unfortunately Scala doesn't have tooling comparable to JDT so far.

One important thing left to dynamically typed languages is meta-programming, i.e. introducing new types and features at runtime. This is indeed very useful sometimes.
In statically typed languages this is most often solved using code generation, but IMHO there is also a need for using reflection in a briefer way.
Ultimately one could introduce some kind of compiler-escape syntax into a statically typed language so we can write:

myObject..unknownFeature

instead of the usual reflection code :

myObject.getClass().findFeature("unkownFeature").get()

Of course the language must not use static type information (like casts) at runtime any more. For me static typing should just be an IDE (and compiler) thing. The runtime shouldn't use any static type information.

Textual Modeling Framework (TMF)

We've submitted a project proposal called "Textual Modeling Framework" (TMF) at Eclipse which focuses on textual DSLs and Eclipse IDE integration. Xtext will become one of two initial contributions.
Would be nice to hear what you think about it.
Please, use the newsgroup (the password can be retrieved via this form).

Definition of the term "Language Workbench"

I just had another look at Martin Fowler's article about language workbenches. I read it when it first came out, but didn't remember what the definition of the term "Language Workbench" was like.

Here is what the article states:

• Users can freely define new languages which are fully integrated with each other.
• The primary source of information is a persistent abstract representation.
• Language designers define a DSL in three main parts: schema, editor(s), and generator(s).
• Language users manipulate a DSL through a projectional editor.
• A language workbench can persist incomplete or contradictory information in its abstract representation.

I think this point is an implementation detail:

• The primary source of information is a persistent abstract representation.

Why should the source be the AST? What is the benefit from a user's perspective. Shouldn't this be transparent anyway?
I don't want to "feel" like editing the AST, because that's why there are concrete syntaxes, they are closer to what I am thinking about.
It's possible to store the information in a concrete syntax (e.g. a Java File) but view and edit it using other representations (e.g. outline views, call hierarchies,refactoring actions etc.).
Eclipse JDT for example has the complete AST in memory to help the user while editing and exploring the code. They don't need to store the Java files in an XML or a database. So if you know how to define a projection on an AST (like Intentional does), you could do this against a temporary, in-memory AST as well.

IMHO storing programs using the abstract form is a bad idea.
UML-Tool users know why:
You can't use existing text editing tools (diff, editors, etc.). You are always bound to the "Language Workbench". And you have to come up with your own version control system.
People who've used graphical DSL-frameworks like GMF know that in addition it is much harder to migrate your code/model to newer versions of your DSL, because you've to do that using the syntax of the stored AST (ugly XML at it's best). (Of course, Intentional may have developed a special "migration tool" for this as well ;-))

So I 'ld like to change the requirements like so:

• Users can freely define new languages which are fully integrated with each other.
• Language designers define a DSL in the following parts: abstract syntax, concrete syntax(s), tooling (editor(s), view(s), wizard(s)), and generator(s) or interpreter(s).
• Language users can manipulate a DSL using the defined tooling, which can be different editors, actions or wizards.
• A language workbench can persist incomplete or contradictory information.
  

Joining itemis

From the beginning of next year, I'll be working for itemis AG (www.itemis.de), a software consultancy which focuses on model-driven software development (MDSD).

Why's that? There are several reasons.

First of all itemis is an excellent employer. Not only have I always had a very good relationship to the management, but they value their employees very highly and they have a very flat hierarchy, which creates a great working atmosphere. As a result they have a lot of talented young software architects which I'm also looking forward to working with.
However the best thing about itemis is that they are very much involved in MDSD and they understand how open-source software development works.

In addition I've come to the conclusion that it is time for me to work within a team in order to provide greater reliability to my customers and the users of oAW (or Eclipse Modeling) in general. At itemis, I'll form a professional team which will focus on open-source development at Eclipse.org as well as international high-level consultancy in the field of code generators, domain-specific languages and the corresponding tooling.

If you are interested in joining such a team, please contact me.
And of course, if you are interested in being assisted by such a team, please contact me as well. :-)