Wow, I just noticed I haven't posted on the blog for 8 months! I guess that is a reflection of the fact that things like Twitter and Google+ really are getting more important ... I'll have to think about what I'll do with the blog.
In any case, here is some news about the book. We are on track for a publication in Feb 2013. The book will be a very cheap PDF book and a Print-on-Demand book at Amazon. I have finished the cover. There is also a new domain: dslbook.org. That page has a complete update of the book status. Check it out.
I started SE Radio six years ago, with the help of a number of great people. We made SE Radio to one of the leading podcasts on software engineering. For me, it was the vehicle for getting into podcasting. I did about 120 episodes there! They were a lot of fun. I learned a lot about software and about podcasting, and I got the change to talk to some fascinating people.
More recently, as you could tell from the number of episodes I was involved in, I ran out of steam. Two reasons: one, I spent a lot of energy on my omega tau science podcast. We have published 87 episodes there already! The other reason is that I simply covered many of the topics I am interested in... sure there is new stuff, but I cannot come up with the same enthusiasm for some of that stuff as I could years ago :-)
Although SE Radio was always a team effort, I was always the one who held it together. As I started retreating a bit, I wanted to make sure SE Radio would continue to prosper. So I had been looking for a somebody (person, organization, group) who would keep it going, with renewed energy. IEEE Software is that organization.
I am extremely happy about this development, and I am sure SE Radio will continue to produce many interesting shows in the future. And I am sure, I will be involved with a few of them :-)
Thanks to all of you listeners for your encouraging feedback over the years :-)
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 :-)
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.
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.
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!
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 :-)
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 :-)
Friday, July 29, 2011
Meine nicht-so-guten Erfahrungen mit FitnessFirst in Cannstatt
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.
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
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
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:
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!
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 :)
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 :-)
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 :-)
Monday, April 18, 2011
What will be coming in Xtext/Xpand/Xtend in June
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 :-)
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.