Why this interview?

This time I sat down with Daniel Stieger, who is the co-founder of a well known consulting company in the Language Engineering field. We met at at Jetbrains MPS meeting in Munich last year and our companies (ours Strumenta and his Modellwerkstatt) offer similar services. So for us it was a great opportunity to compare our vision about Domain Specific Languages with another important player in the area.

Here there are some quotes I found particularly interesting:

Once you get used to the projectional editor, you definitely will not switch back. You really can feel that there is some intelligence in the editor, in the editing component, so every text editor, even with code completion, feels just dumb

We started with an idea of modeling, bringing modeling to business applications by using DSLs and using modern and innovative frameworks

We distinguish from the technical Java, that fachlich Java where we formulate the business logic, where we formulate your domain aspects, and this leads finally to technology independence

Technology is completely abstracted the way, and developers of our stock keeping application can really focus on the domain, on how the stock should keep and what the rules are. That’s really nice, and speeds up development a lot.

But of course there is plenty of more interesting stuff in the interview. Below you find the video and the full transcript. Enjoy!


Federico: Hi Daniel, thank you so much for agreeing for to give this interview. How are you today?

Daniel: Really good, thanks Federico, nice to hear you.

Federico: I think that it would be nice for our readers/listeners if you could start by introducing yourself and explain a little bit what you’re working on.

Daniel: Yeah absolutely. My name is Daniel Stieger and I am a co-partner at Modellwerkstatt. It’s an Austrian based company right between the Alps and we are, I would call it, in the domain of business applications. Our goal is to develop business applications faster and with higher quality and to do that also in a device independent way – we support mobile progressive apps, we support desktop applications, and we support those platforms. And that’s basically the, what Modellwerkstatt works on.

Model-driven and Language Engineering

Federico: All right, nice. One of the reasons why we met is also because you are using Jetbrains MPS. Can you tell us about your experience with MPS?

Daniel: Yes, we use the Jetbrains Meta Programming System as our main development tool for all our solutions. All our developers rely solely on that platform; we do not depend on any other additional tools so all our requirement and all our necessities are basically developed and embedded in MPS.

Federico: Okay, so every part of the process is supported by MPS.

Daniel: True, yes.

Federico: Nice. And have you ever used other similar tools?

Daniel: Yes, in 2009 we started with Xtext in Eclipse, on Eclipse environment and of course Eclipse was not as developed and evolved like it is nowadays. We quickly run into limitations of Xtext in those days: difficulties when developing general code, code generation etc. And that quickly led the path to Jetbrains MPS so we switched after couple of months to MPS completely. Even in that stage MPS managed to fulfill all our demands that came up.

Working with MPS

Federico: If I remember correctly, in 2009 MPS was not as usable as it is now. So maybe in 2009 was bit challenging. It’s interesting though that many people seem to have started using Xtext and then they saw the light to MPS. Can you tell us a bit more about the domain specific languages that you are building with MPS?

Daniel: We are basically relying on three languages for different purposes: user interface modeling, modeling of business logic and controllers, and modeling of database interfaces. Object relational mapping. So quite different purposes but they are all integrated in each other. So that’s also pretty unique for the affordances you have with Jetbrains MPS. All our DSLs are basically built around Java and that is really nice. We follow the Java syntax, we follow the Java philosophy of building things or formulating things – syntax, type system and other technical specs, which is really nice just because we have a guideline on how to formulate and how to develop DSLs that is in accordance with Java. But I think it’s also nice for our users because if your have a bit of familiarity with Java you could easily learn our DSL so it’s not a completely standalone, proprietary, a strangely formulated language. It’s made in the Java style.

Federico: Okay, so for the point of view for the users your DSL seems a little bit like extensions to Java.

Daniel: Extensions to Java, yes, but often times it gives a context because in Java everything is just a class concept and we try to give our users different contexts where they can put in Java code.

Federico: And then, the other thing is that you have different DSLs that are well integrated so you have these families of DSLs that can convert, whole applications.

Daniel: True.

Federico: How did you come up with DSLs: was it different to design them or do you have a process to create a DSL?

Daniel: Initially we picked a use case, a specific business application for one of our customers, we gave some thought on how we could formulate all of the things in Java and then we abstracted it away. We said, okay what could be changed, or what would be changed probably if we developed another application? And so in the iterative process of course we defined our DSLs, we repacked the power the DSLs. So we developed the initial product, initial business application and at the same time we evolved our DSL and evolved application again. Thus, in an iterative process our three DSLs were built.

Federico: When you said that you wrote the application, you started thinking where the variability could be in an another project. I think that to be able to understand when things could vary is a skill that requires a lot of experience. So maybe it’s one of the differences between people with good experience and younger developers.

Daniel: Absolutely.

Federico: And so in a way you start, you developed the language bottom-up, in the sense that you start with a real application, let’s say in Java. And then you see abstractions in the code and you build these abstractions improving the application. So moving from Java to something on a slightly higher level, is that right?

Daniel: Yes that’s how we structured the process of developing and DSL so, but we also got some theoretical input by literature from Domain-driven design, from enterprise patterns, from Domain Specific Languages by Martin Fowler. So there are a lot of folks we also used in order to get an idea of how to abstract things.

Federico: Good, so maybe later in the article we will put links to these books so that someone can take a look at those and read them. Okay, I would like to ask a few more questions about MPS. You already said that you started in 2009 so it was a while ago. Was it difficult to get started? Did you find resources to learn MPS?

Daniel: I think in those days it was a bit difficult because there were no books available on MPS and there were also no screen-casts available. Unlike today: I really like them and I think they are really cool now. Jetbrains put some effort into all the explanations and that was very nice because, we had a reference manual for MPS and a small tiny tutorial from some guy, I can’t remember his name. It was a bit hard to get into MPS but Jetbrains helped out a lot. I had a contact there to whom I could ask questions and I also used the community forum a lot, and Vaclav Pech gave me a lot of support. Personal support from him, it was really amazing and there were conferences in the United Kingdom. They were called Code Generation. There was also some great input on how to formulate things, but also on MPS specific problems, I could get help there. So it was a nice resource for learning.

Federico: I never attended Code Generation but since everyone speaks very fondly of it, I regret not visiting it. About MPS, do you think that some companies are a bit resistant to MPS or do you have an opinion for that? Do you think is difficult to convince a company to consider MPS?

Note: people who attended Code Generation compared it to the LangDev meeting that was started last year and it will be helf next year in March. You can find a summary of that here: LangDev ’18 Summary.

Daniel: I think it is not easy because everyone is used to text editors and everyone is used to version control systems, which are text based like Git or SVN, and interestingly not being text based is a strength of MPS. Understanding that it does not make any sense to formulate things in text, parse, and compile this text, basically transforming it forwards and backwards. Basically, the strength of MPS is not being text based, but being a projectional editor. Of course, it’s always hard to accept new things…

Note: Projectional editing is something that sounds new to many readers. You can find a definition of projectional editing on Martin Fowler’s website.

Federico: It’s a bit scary.

Daniel: It’s always a bit scary, that’s right.

Federico: It’s true that one of the main complaints that I hear over and over is versioning. I think now in MPS there are these tools designed to do the merging, to do the comparison between two versions, but it’s true that if you used to do a merge from the command line, it can be …

Daniel: Jetbrains did a stunning job on the version integration in MPS. It works like a charm.

Federico: It does. It’s just a matter to understand that you have to use that integration and not doing from the command line, otherwise you are comparing two XML files, and yeah, you don’t understand.

Daniel: It sounds a bit strange, because once you get used to the projectional editor, you definitely will not switch back. You really can feel that there is some intelligence in the editor, in the editing component, so every text editor, even with code completion, feels just dumb. Just a stupid tool, basically. It’s absolutely convincing once you’ve got the idea of having an intelligent editor.

Federico: I think that, as you have already mentioned, many people, many language designers start with Xtext, and maybe they hear about MPS, but are not so convinced because it has not been tested, and then they go on and try it. If they use it for a while, they will never consider going back to Xtext, it just seems crazy to limit yourself. Sorry for everyone loving Xtext!


Federico: Your company, I will try to pronounce it correctly: Modellwerkstatt?

Daniel: Yes, you pronounced it correctly.

Federico: It’s now 10 years old, right?

Daniel: Correct.

Federico: How things changed over time? Can you tell a little bit about the history of the company?

Daniel: Yes, of course. We started with an idea of modeling, bringing modeling to business applications by using DSLs and using modern and innovative frameworks. As already stated, we started with Xtext, and then we got to MPS. Things evolved over time. We started by those DSLs, and then we applied them with one customer, and now we generalize those DSLs over time, we built a rapid application development framework, we call it MoWare. We really pushed that framework to let it become product based on three DSLs in itself. Nowadays it’s basically just three services: we implement applications and use our own tools to implement a product for customers. We also give support to MoWare in the form of teaching and consulting of course. We are also the sole maintainer of MoWare, although it’s open source. The third service we do is DSL, and then the Jetbrains MPS consulting.

Federico: Okay. If I understand correctly, your clients see these DSLs as secret weapons to develop applications faster, right?

Daniel: Yes, that’s true. It’s s a rapid application development tool, which lets you model business applications to develop faster and with higher quality, but also device-independent. That is, you use the same code to execute it in a mobile progressive environment, progressive apps, you use the same code, the same model to let it run on a desktop computer. You use the same DSLs, the same models and solutions to develop that platform product.

Federico: That’s also a good point. I mean, portability, if you want to develop an application that you plan to be using in 10 years, and we probably don’t know which platforms we will have in 10 years. If you can be independent from the device, I think it’s the only way to protect your investment.

Daniel: That’s true. That’s why we came up with the idea of, we call it technical, and we call it fachlich. I don’t know how to translate fachlich.

Federico: I think Markus Völter is promoting this word fachlichkeit as a sort of synonym for business logic.

Daniel: Yes or just, like a domain aspect. We differentiate between technical Java, that is framework related, that is database connection related, the specific user interface technology, like JavaFX or Vaadin or other products. We distinguish from the technical Java, that fachlich Java where we formulate the business logic, where we formulate your domain aspects, and this leads finally to technology independence. You can of course execute that fachlich Java code with business logic in any environment. You won’t find any technical Java coding or Jetbrains MPS environment, because that is exactly why we abstract it away, and that delivers technology independence to our customers.

Federico: Okay, good. In normal development, we have a mix of business logic and technical aspects and you cannot distinguish between them. With your solution, you can separate them, so that if the need arises, you can preserve the fachlich aspect of the application and just change the small part that has to do with the platform specific aspects. Is that right?

Daniel: Yes. That’s a nice formulation. Also, I would say that even if you have the goal of separating those things, typically at some point, you are, due to legacy, or just because your developers are not disciplined …

Federico: Right.

Daniel: Basically, some technical code is flowing into your business logic. Just using those DSLs and using Jetbrains MPS really separates things nicely, so there is really a strong distinction. And also, technology- you cannot access technical stuff, the infrastructure-related stuff. That really pushes developers to just formulate things correctly and nicely.

Federico: Okay, good. I think we have described on a high level what activities your company does. Do you think is there any specific project that you can tell us about that is maybe on a high level? I know that some stuff is confidential, but just to give an idea to the listeners of what can be achieved.

Daniel: Right now the biggest project is developing a stock keeping application for a major client of ours. This stock keeping application uses a standard Oracle database in the background. All the code that is used, all the business logic and user interfaces and database access, things are modeled within our domain-specific languages. That leads to the advantage that the stock keeping can be used from a back office, a desktop application, with a lot of data displayed, and a lot of tables and forms, and also as a full mobile solution for point-of-sale mobile devices with scanners. Technology is completely abstracted the way, and developers of our stock keeping application can really focus on the domain, on how the stock should keep and what the rules are. That’s really nice, and speeds up development a lot.

Federico: It would be nice to have a comparison of the effort that you spent building the logic once instead of maybe the alternative of building an application for mobile phones, to run on the server, and to integrate them. Maybe this could be an idea for a white paper, to show to people the advantages of DSLs.


Federico: Another thing that is also interesting that you mentioned is the fact that you have an open-source library, MoWare, right?

Daniel: Yes, true.

Federico: Why have you decided to make this library open source?

Daniel: There are a lot of products like rapid application development tools around nowadays, such as Microsoft PowerApps or Mendix or OutSystems, and even in part there is the Borland builder tools, are very well known. But they are all proprietary so once you invest and use those platforms, you cannot get out of them and that is one major pain point by relying solely on those projects. I think one key aspect of MoWare is using a rapid application development tool which is still on a platform you could change, extend if absolutely needed. Jetbrains MPS is free and MoWare is free and then even it allows you to get the models out of this environment, if you want to. You have a lot of freedom, but you could also use the advantages of rapid application development and generating code. So basically being open, being extensible, being changeable, and being independen, not proprietary that is a key feature of MoWare.

Federico: Ok, so now that we have explained the goal of MoWare. I am curious about how it is used. Do you and your company use it for clients in projects, or do you sometimes teach other developers how to use it so that they use it on their own?

Daniel: Yes, that’s exactly right. We typically start together with on-premise developers, with developers from the client, and kick0off a project together, implement things but of course over time when a project involves the developers at the client side, they take over the complete project and the complete solution so then our role is more of consulting and moderating these kinds of things, options similar to pair programming. However, we  also implement complete solutions at the clients’ side.

Federico: But if the client wants to take control of development, you have the possibility to train developers who do not have previous experience with language engineering how to use MoWare and be independent from you if they want to – is that right?

Daniel: I think it’s one of the goals that the clients ultimately become capable of developing their own solutions, using MoWare just as a tool and use the DSLs to speed up their development, get a better standardization of products and higher quality of solutions.

Daniel Stieger presenting MoWare


Federico: This is also an aspect to consider, especially if the company invest some time and money and builds the application and can at some point take control of it themselves. Okay, so we talked about MoWare and your experience with open source. I would like to ask a few final questions and hear your opinion about language engineering and model driven. So do you think that DSLs in particular are European thing, maybe something that is particular strong in German-speaking countries? Or do you think  it’s used on the same level all over the world?

Daniel: I think model driven development and DSLs are more advanced in Europe because two major projects that are Xtext and Jetbrains MPS come from our continent and so there is naturally a big community around in Europe. Germany, I mean it is Markus Völter who is contributing a lot to the DSL community. Therefore I would assume that the community is also growing faster in nearby countries, so I would say that Europe is definitely a bit ahead from the rest of the world when it comes to Domain Specific Languages.

Federico: I also have this feeling. I have never before realized why this is the case, but your point is interesting and it might very well be because Xtext and MPS had an effect on the community. And have you recently found anything new or something that would be particularly interesting in language engineering?

Daniel: Well, lately I have been really interested in machine learning and artificial intelligence, which are some buzz-words but I think you can apply that technology to a lot of problems, especially in environments where a lot of data is available. But personally for me, domain specific language is a bit of the contrary direction where you don’t have any data around but you want to solve things. You want to solve complex matters and then, of course there is a need to express yourself in a way that you can focus on and work on complex problems. So, Domain Specific Languages, as well as machine learning are for me two paths to tackle problems now and in future.

Federico: Okay good. Yeah let’s see if we can find a way to combine them. Is there something that you are working on in particular, or that you are planning to work on in the future such as a new release of MoWare or something else?

Daniel: Of course yes, we’re constantly working on MoWare and I’m putting a lot of time into making MoWare easier and easier to use. I’m also currently working on better mobile integrations – they get more and more important and we are trying to abstract away the technology that is used in the mobile environment. Because they change very frequently, there are a lot of technology changes, such as using iOS or using Android or using some operating environment you even haven’t even heard of yet. Also the speed, life cycles: taking Android from version to version is really fast.Things are no longer like in the past days of Unix when you could change your environment every ten years. Now the life cycle of a mobile stuff is half a year, so we are really putting a lot of effort in there to stabilize and development environments, formulate things in logical ways to mitigate any dependency on underlying technology.

Federico: Maybe in a way by using DSLs you can protect a little bit the application from these continuous changes in the underlying technologies: they keep releasing new versions of Android or iOS but in your code generators or interpreters you can deal with this new version without having to change the application, the code written by the user. Is that true?

Daniel: Absolutely, and it’s just causing trouble and a lot of efforts on the clients’ side to keep pace with all the development whereas they should not have to put any efforts in there because if it doesn’t speed up or help solving their problems, they should be able to focus all their efforts into solving business problems, domain problems they have and not keeping track with technology.

Federico: Okay good. Okay now, my final question is, is there anything else that you would like to add, maybe something I should’ve asked you or something that didn’t come up in the interview and you would like to tell our audience?

Daniel: I think we covered a lot of things. Finally, about our clients being resistant to MPS that you asked think it’s important for the future not to have any fears and to take a closer look into projectional editing and the options we have there. And clearly have advantages in mind when we’re comparing such a technology with traditional environments like text editors. So be open and push forward a bit.

Federico: I would like to thank you – this for me has been particularly interesting also because I think what we both work with MPS and I have seen some presentations of yours and would like to thank you for what you’re doing in the MPS community. And also for your open source work that helps moving forward the MPS community. I would also like to thank you for taking this time to talk to us and answer all these questions.

Daniel: Thank you also for the interview and if you have any further questions on MoWare, ottechnology, like MPS, I’d be glad to help out your readers.

Federico: Thank you, good to know. Thank you once again and see you soon. Bye.

Daniel: Okay, thank you bye.

The complete guide to (external) Domain Specific Languages

Receive the guide by email and get more tips on DSLs

Powered by ConvertKit