Coexistence of Graphical and Textual DSLs

A major part of my research/work at the university and in some of my personal projects is about integrating business experts into the development process. You can read more about it in my dissertation. We reincarnated a very ambitious project, which now focuses on modeling complete web applications. We defined different interconnected graphical DSLs (Domain-Specific Languages) with Cinco and allow to one-click generate and deploy it on an application server. I am very excited about this great project and some of my posts are (and will be) inspired by it.

As of recently, we use XText as an alternative serialization format to XMI for our graphical DSLs. XText languages have some nice properties over XMI, like syntax highlighting, scoping, validation, just not being XML, compatibility with VCS, etc.. But most important it is much easier to “repair” XText models after a format/meta model change, than with a graphical editor (which just ignores friendly inquiries to open an incompatible file), or with XMI (trust me it is a 😵).

This brings me near to a dream I already have for quite some time: Bringing together textual and graphical DSLs to describe the same model. This is so great because all these integration efforts of business experts (i.e. non-programmers) into the development process is up-to-now a one-way approach. But with a textual representation both the technical and the business experts are likely to use (different views on) the same modeling artifact. Since December 2015 XText (2.9.x) supports IntelliJ IDEA, some web editors as well as standalone usage besides Eclipse. This is great news again (although I have some problems to get it up and running the way I would like to. But more on that later)!

So stay tuned, to news regarding this great new project called DIME (Dynamic web application Integrated Modeling Environment).

Exciting 😉.

Splitting up “Streams” using jOOλ, Kotlin, and ReactiveX

The Java 8 Stream API is pretty cool as you can see in my last post BFS with Streams. But there is a catch. You cannot reuse Streams. Consider the following code Java-Code:

final List<String> helloList =
    Arrays.asList("H", "e", "l", "l", "o", ", ", "W", "o", "r", "l", "d", "!");

final Stream<String> helloStream =;
final Predicate<String> checkUpper = s -> !s.isEmpty()
    && !s.substring(0,1).toUpperCase().equals(s.substring(0, 1));
helloStream.filter(s -> !checkUpper.test(s));

This results in IllegalStateException: stream has already been operated upon or closed.
The problem with Java 8’s Stream API is that they are designed for parallel execution. This decision introduced some constraints. Unfortunately, there is no sequential only-switch. What you can do is collect the results with groupBy into a map and then create two new streams from that. But collecting is a terminal operation, not lazy, and therefore inefficient (especially in combination, with early-exit operations like limit). You can also try to do the first filter, chain it with a peek, and finally do the second filter. But since only elements matching the first filter will reach the second filter (i.e. a && !a which is equal to false), you won’t get any elements past the second filter. If you have a so called cold source (i.e. like a collection), you can just use two different streams which results in two iterations. But for hot sources (like a network or file i/o stream), this is not that easy. A possible solution is to cache the input in a collection, i.e., cool it down. But this comes with a space and performance penalty. So let us see, what our options are…
Read More

Breadth-First Search with Java 8 Stream API

I recently had the problem to walk through some data and collect elements on the go. I thought it would be nice to use the (relatively) new Stream API in Java 8. After a short search in “the internet” I found a solution in this blog post for tree structures and in this one for recursing through a file system (which is a tree structure again). So, story told? No way! I needed to walk through graph structures (i.e., there might be cycles in it). In contrary, the solutions above will run forever, or more precisely they will terminate relatively fast with a StackOverflowException.
Read More

Lazy Recursive Drill-Down of Tree Structures in Swift 2.1

I really do like the Swift programming language, because of features like multiple return types, nice support for optionals, value types (i.e., structs), enums with associated values, method overloading just with the return type, operator overloading, and many more.

But there are some language decision that are quite alien to me and I want to write them down (and my workarounds to them, which might help you), starting with this post. Perhaps you (yes I mean you 🙂 ) have a better answer for me, then please comment.
Read More

LaTeX: replacing “-quotation marks with \glqq{} and \grqq{} in vim

If you ever had the problem that your LaTeX document contains wrongly formatted quotation marks (either in a german or english text), you most likely went all the way through your document searching for quotation marks and replacing them accordingly. Here are easy vim commands using the substitution feature (similar to the unix sed command) to replace all occurrences of quotation marks with the correct replacement for english texts:


And this one for german texts:



Apple Swift: Emulate Partial Fully Applied Functions

This article is only a short one, that tells an obvious fact, but I love it; hence, I will let you participate. Currently, I am doing a project with the new language Swift from Apple. Swift is a object-functional language like e.g. Scala.

Both languages have the nice functionality partial application of functions. This means you can set some of the parameters which returns a function that has the remaining parameters, only. So, it is not yet executed, but the already passed parameters are stored into the partial applied function and used if it is called with the rest of the parameters. Just for the seek of completeness, currying is then, when a function with multiple parameters is decomposed into a chain of functions that each has exactly one parameter (this is not the same).

But hey, this should be a short one. Here comes the punch line: You can partially apply functions, so that they have only one parameter, but what if I would like to preset all the parameters? It is very simple: Use a closure to create a new anonymous function, that simply executes the function of interest with all its parameters.
Read More

VirtualBox v4.2.18 with Native Hard Drive Partition in Mac OSX Lion

Most of the time you use desktop virtualization, you simply add a virtual hard drive and install a guest operating system (like (K)Ubuntu Linux) in it. But some times – as in my case – you already have another operation system on a partition on your native hard drive. For a mac it’s either via Bootcamp or via something like rEfit enabling you to install a BIOS boot manager like Grub. Since it is kind of uncommon using such an existing partition for desktop virtualization, it is not supported (and documented) so good in the different virtualization solutions.
Read More