MPS Workshop at itemis
Last week, we had a workshop about JetBrains MPS
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.
Profiler for XPand and Xtend
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!
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
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
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!