MPS released

JetBrains just released version 1.0 of its Meta Programming System.

The screencasts provided by Markus Völter are very nice. They show how the Java base language can be extended by a lock abstraction, which is translated to some best practice lock code by the generator component afterwards. This seems to be a good example of growing a language as motivated by Guy L. Steele Jr.

I wonder whether multiparadigm programming could be supported that way more straightforwardly. So, one could not only generate imperative code from imperative abstractions, but one also could generate imperative code from an embedded functional program, right? Also it seems to be promising to integrate visual languages. That way, one could specify a method's body not only by Java code, but alternatively with, say, activity diagrams. However, currently only the creation of editors for textual and tabular representations seems to be supported.

All in all, MPS is a promising system, but regarding performance there seems to be plenty of potential for improvements (it took really long to load the simplest possible language for the first time, which raises the question how long it would take to load something real - on the other hand the system seems to be bootstrapped, which usually is an indicator of maturity). The language oriented programming approach as a whole of course is also heavily disputed, cf. this discussion.

Alligator Eggs (for the last time)

Now I have also constructed an editor for alligator eggs. This editor is different from Torsten's editor with the nice animation discussed some days ago. My editor provides syntax-based user assistance instead, i.e. the user gets help in creating syntactically correct alligator eggs expressions. Whereas Torsten's editor has been created with DiaMeta (syntax defined by a class diagram), my approach relies on the DiaGen framework (syntax defined by a graph grammar).

Here is a screencast:


And here is the executable jar.

The underlying hyperedge replacement grammar is very straightforward and close to the textual lambda grammar:

Alligator Eggs revisited (again)

The video about the animated editor for Alligator Eggs has raised some questions on where the editor is available for download. Therefore, Torsten has provided an executable jar. Feel free to try it out yourself!

Actually, the success of this video on youtube (more than 3.000 views already) really motivates me to implement syntax-based assistance for the language of alligator eggs. The language is tree-based, i.e., context-free, so that the developed approach is applicable. I hope to find some time in the near future to this end.

Business Process Models

In the last weeks I have developed an editor for business process models with syntax-based user assistance as described in previous blog posts. A screencast of this editor is shown below:



The editor is provided for download as an executable jar.

Concepts and realization are described in S. Mazanek, M. Minas. Business Process Models as a Showcase for Syntax-based Assistance in Diagram Editors. Appears in Proc. of the ACM/IEEE 12th International Conference on Model Driven Engineering Languages and Systems (MODELS 2009), 2009. The original publication will be available at www.springerlink.com.

Alligator Eggs revisited

At the moment I spend a lot of time on polishing my PhD thesis. Therefore, not so many new posts appear on this blog in these days. However, today I would like to follow up on my last post, which was about the visual language of alligator eggs. A colleague of mine, Torsten Strobl, has created a very nice editor for alligator eggs expressions. It even animates the evaluation of such expressions, i.e. alligators eat other alligators (but don't worry, there is no blood).

Here is the video:

Alligator Eggs!

Some time ago I had already written about a nice visualization of lambda calculus called VEX (visual expressions). In VEX the variable bindings are made explicit by using connecting lines. In contrast, in conventional lambda calculus bindings are implicitly given by the names of the variables. From my experience this is difficult to understand for students, in particular if alpha conversion comes into play. Today I have seen an even nicer visualization for the representation and execution of lambda expressions called Alligator Eggs!.

For motivation, here is an example expression from the Alligator Eggs! website:



Very briefly: A hungry alligator is an abstraction, an old (=uncolored and non-hungry) alligator can be used for bracketing, and eggs represent variables. There is an eating rule, which corresponds to beta-reduction, and a color rule for over-cautious alpha-conversion. Finally, for clean-up, there is an old age rule, which says that if a pair of parentheses contains a single term, the parentheses can be removed.

I really look forward to empirical results whether this approach helps in teaching lambda calculus.

Graph Transformation Day Bremen

Directly after the World Usability Day in Dresden I attended the Graph Transformation Day in Bremen. Here, I gave a talk about the generation of correctness-preserving editing operations for diagram editors. More on this later...

The other talks have been given by my supervisor Prof. Mark Minas (about using triple graph grammars for analysis in diagram editors), Dr. Rubino Geiß, the architect of the GrGen graph transformation engine (and indeed his talk was about the implementation and application of GrGen), and finally Edgar Jakumeit, who described the realization of recursive matching rules for GrGen. I have found these recursive "star" rules particularly interesting, because they actually allow to write parsers with GrGen in a declarative style. In a sense, this is quite similar to my approach to graph parsing via combinators.

It was a nice workshop. I learned a lot about the GrGen system. In particular I now have an idea how they managed to build the fastest (at least in quite some cases) graph transformation tool in the wild. Thank you Berthold for organizing this...