Consulting and Coaching The baseline for my work is consulting and coaching. I will be on site with your team and help architect, design or implement systems. A gig may last a couple of days, or a year or longer. I will either act as a consultant that helps you set up or review your project, architecture or development methodology, or I will play an active role in the development project, as part of your team.
Trainings and Workshops Based on my consulting experience, I will come to your site and deliver trainings or conduct technology workshops with your team.
Evaluation and Prototypes Evaluating whether a given paradigm or technology works for a given context is often a major challenge. As a consultant who sees many different projects and technologies, it is easier for me to evaluate a technology or build a prototype.
The references lists many of the companies I have worked for in various capacities over the years. I am also involved in open source projects, some of them professional grade (mbeddr.com, Eclipse Modeling as well as a number of smaller projects that are more experimental. I also work on a more conceptual/research level. From this work, I extract my publications, publications and talks.
Language engineering refers to the activity of designing and implementing languages and their IDEs. Languages play an important part in software engineering since they determine how effectively we can express ourselves relative to a given topic. Most languages I build for an with customers are domain-specific languages tailored to a specific domain, project, organization or system. More recently, many challenges require sets of integrated languages to be addressed effectively. Language workbenches are the tools to build (sets of) languages efficiently. In the recent years I mostly use the JetBrains MPS language workbench, since, as a consequence of its projectional editor, it can support a wide range of notations including textual, prose-with-code, mathematical, tables and graphics. Notational flexibility is important for DSLs because this allows them to use the notations already expressed in a given domain. To learn more about language engineering and DSLs I suggest you check out my two recent books or this 40 minute video from Craft 2014.
Software architecture is about defining the core abstractions used by a given system. A good architecture reflects the requirements for the system, ensures maintainability testability and evolvability and supports the required quality attributes such as performance, resource consumption or scalability. Architecting a system requires intense collaboration with all stakeholders, but also effective ways of capturing the architecture as it evolves (possibly as the system is being built): best practices for software documentation, communication and writing skills, but also modeling and DSLs can play important parts in this endeavor. To learn more about my perspective on software architecture check out my software architecture patterns, my thoughts on DSLs and architecture as well as these slides on architecture documentation. In the past I have also worked a lot on different middleware architectures, check out my (somewhat outdated) pattern books.
Platforms and Product Lines Product lines and platforms are both examples of planned, systematic reuse. Product lines are used by many device manufacturers (phones, ECUs or industral controllers) to streamline the development of different but similar systems. Platforms are more open; they provide a common infrastructure for systems that may have quite different functionality. Both require a well-defined architecture as well as the systematic management of the differences and/or extension points: modeling, DSLs and frameworks come in very handy. To learn more, check out this paper of DSLs in product lines as well as this paper on integrating feature variability into DSL programs.
Many of the tools I am involved in are available as open source. Below is a list, the most current projects are at the top.
mbeddr mbeddr.com aims at creating a different way of developing embedded software systems. Instead of using archaic modeling tools and manually written C code, we use the open source JetBrains MPS language workbench to create a holistic approach to embedded development, where C programming, modeling, domain specific extensions and product line variability are supported directly.
Xtext Typesystem Framework The Xtext Typesystem Framework provides an efficient way of implementing reasonably sophisticated type systems for Xtext DSLs, and specifically, for the expression part of it. It comes with a framework for performing the type calculations, as well as with a textual DSL for specifying the typing rules.
Xtext Variability Tooling (outdated) Product line engineering and model driven development are two approaches to software development that are becoming more and more important. The combination of the two approaches is promising. There are various ways of how those two approaches can be combined. One way is to use feature modeling to define variants of models created with domain specific languages. The tools in this project are in implementation of this approach. For textual DSLs built with openArchitectureWare 4.3.1 Xtext this project contains tools to define variability. This means, that feature dependencies can be annotated to arbitrary grammar elements. A model processor removes all the elements from the model after it has been loaded whose features are not selected in the current configuration. Tool integration exists with pure::variants. Code completion from the DSL into the feature model is implemented, as well as traceability from the feature back to the models. For completeness this project also contains a text processor that can customize text files according to features selections. The download page contains documentation of how these tools should be used. To understand the background, please refer to my Architecture As Language papers, Part 1 and Part 2.
Meta Model Semantic Annotations (outdated) Many languages defined with Xtext have aspects in common. One way of exploiting this is to modularize language definitions and then composing specific languages from these modules. However, because of shortcomings of the current (4.3.1) version of Xtext, this is not necessarily a very viable approach. This semantic annotation toolkit provides support for another approach. Languages are generated from scratch (i.e. there is no reuse between grammar fragments), but the semantics of various language building blocks are still reusable. By annotating grammar elements with semantic annotations, the necessary Xtext infrastructure can be generated to make those grammar elements behave in a given way. Technically, this is implemented by generating extensions and checks as well as by model transformations and extensions of the meta model.
Model Visualization (outdated) This project contains a number of utilities to visualize EMF models. Visualizations are read-only, automatically layouted, and created via a model-to-model transformation. The visualization is based on the Eclipse ZEST project. The visualization toolkit is used in the following way: developers write a model to model transformation for a given language. The transformation maps language abstractions to a generic graph meta model consisting of nodes and edges with various decorations. The current state of the project is still very much a prototype. We are actively looking for additional contributors.
openArchitectureWare (outdated) oAW is one of the most used MDSD tools worldwide. It is based on Eclipse. The most well-known parts of oAW are the Xpand template engine as well as the Xtext tool for building textual DSLs and the associated editors. As of 2010, all of oAW’s ingredients have moved to Eclipse into their own projects or components.
In the past I have always tried to use innovative ways of solving customer problems. This page lists some of the more interesting ones. (No, I don’t claim that I invented any of these! I just want to illustrate my involvement at the leading edge.)
Eclipse Rich Clients Long before Eclipse RCP became a buzzword and a reality, I have been building a non-trivial Eclipse-based business application for ESG/DaimlerChrysler.
Generative Component Infrastructures For a long time I have been working on generative component infrastructures for embedded systems. Among other things, I have produced the Small Components paper. Once day, BMW Car IT called and asked whether I could help implementing a proof-of-concept for the AUTOSAR standard. As it turns out, AUTOSAR uses exactly the same approach - generative component infrastructures - to realize in-vehicle component middleware.
Technology-Agnostic Component Infrastructures I have long had the opinion that business logic implemented in components should not depend on specific technologies (use their specific interfaces, extend certain base classes, etc.) to simplify development, testing and technology migration (see also Architecture Patterns). I have build several component-based systems for customers using this metaphor. Essentially, the idea is to support the programming model from the technical infrastructure. I use model-driven, generative techniques to generate the necesssary glue code to map the “pure business logic components” onto the respective infrastructure. These approach has become mainstream in Java development with the Spring Framework. Currently, these things also become mainstream on larger scales, namely enterprise-wide Service-Oriented, Component-Based systems - the Service Component Architecture (SCA) standard implements this approach.
Generating Graphical Editors As part of the AUTOSAR proof-of-concept development project we have built an integrated IDE for AUTOSAR development based on Eclipse. A part of this IDE was a set of graphical, GEF based editors. After initial hand-making of these editors, we started generating these editors from the domain metamodel plus specific editor description models. This is exactly the same approach that is now taken on by the Eclipse GMF project.
Textual DSLs Textual DSLs are becoming more and more mainstream now; a major reason for this are tools like Xtext. Although I was not directly involved in the implementation of Xtext (as part of oAW, or now as part of Eclipse modeling), I have used it in real projects since the early days, and spent a lot of “conference talk time” explaining why textual DSLs are a good idea. In that sense, I did play a small part in making textual DSLs more mainstream, I think :-) Today in 2010 Xtext is my bread-and-butter tool, I am involved in coaching and consulting with several customer projects. My research focus today is mostly with projectional language workbenches, which provide a quite different approach to (textual) DSLs, simplifying language modularization and composition significantly. Intentional Software and JetBrains MPS are the two leading implementations of this idea.
Product Lines and DSLs As part of the AMPLE Project I have been working on integrating product line engineering with model-driven development and DSLs. Based on the openArchitectureWare platform, I have built facilities to integrate models with feature management tools (such as pure::variants) to be able to express variants of models. I’ve also built several model weavers, in order to support variability implementation via aspect weaving on models.
Architecture DSLs As part of my passion for the conceptual aspects of software architecture, I have been working on expressing architecture formally, using DSLs, and integrating variability management into it (e.g. see here and here. I am currently employing this approach in various customer projects.
Projectional Editing, Mixed GPL/DSL mbeddr.com aims at creating a different way of developing embedded software systems. Instead of using archaic modeling tools and manually written C code, we use the open source JetBrains MPS language workbench to create a holistic approach to embedded development, where C programming, modeling, domain specific extensions and product line variability are supported directly. Take a look at this video to learn details.
This is a (not necessarily complete) list of the companies and organizations I have worked for in the past. You can find out details about my involvement with these companies by contacting me.