
- 5+ Jahre Berater und Trainer fĂŒr Gradle
- 5 Jahre Entwicklung an Gradle (Gradle 3 bis Gradle 7)
- 20+ Jahre Erfahrung in der Softwareentwicklung
Stationen meiner Karriere
VortrÀge
9 Jahre nach Java 9: Was machen wir jetzt mit dem Java-Modulsystem?
Java Forum Nord (2026)
Das Java-Modulsystem (JPMS) wurde vor 9 Jahren mit Java 9 veröffentlicht. Verglichen mit anderen Java-Spracherweiterungen der letzten 9 Jahre (z.B. Records) lĂ€sst sich JPMS schwer punktuell oder inkrementell in existierende Code-Basen einfĂŒhren, weil es eine gewisse modulare Struktur voraussetzt. Generell gibt es HĂŒrden fĂŒr die Verwendung von JPMS durch Frameworks und Libraries, die nicht vollstĂ€ndig JPMS-kompatibel sind (z.B. Spring Boot). Dies sind zwei der HauptgrĂŒnde, warum JPMS in den meisten Projekten nicht in ErwĂ€gung gezogen wird. Der Eindruck, dass JPMS viel KomplexitĂ€t, aber wenig Nutzen bringt, ist weit verbreitet. Die meisten Java-Projekte verwenden es daher nicht. Aber es funktioniert! In diesem Vortrag zeige ich an Beispielen aus drei Projekten, zwei davon OSS (hiero.org / jabref.org), wie JPMS heute effizient eingesetzt wird. Wir schauen uns an konkreten Beispielen an, wie man mit JPMS ein Projektsetup nicht komplexer, sondern einfacher macht. Dabei sehen wir, welche regelmĂ€Ăig auftretenden Probleme durch JPMS adressiert werden, sodass sich ein Investment in die EinfĂŒhrung von JPMS in ein Projekt langfristig rechnen kann. Wir sprechen darĂŒber, welche Probleme es bei der EinfĂŒhrung von JPMS gab und welche Learnings sich daraus ergeben, von denen zukĂŒnftige Projekte profitieren werden.
Unbeschwertes Dependency-Management fĂŒr Java-Projekte
JavaLand (2026)
Wir alle verwenden Open-Source-Bibliotheken in unseren Java-Anwendungen. Solche AbhĂ€ngigkeiten sind schnell hinzugefĂŒgt, da keine direkten Kosten entstehen. Die ProduktivitĂ€t steigt kurzfristig, da fertige FunktionalitĂ€t sofort genutzt werden kann. Doch auf lange Sicht ist dies keineswegs âkostenlosâ. Mit der Weiterentwicklung einer Bibliothek entstehen Folgekosten. In langlebigen Projekten gibt es oft AbhĂ€ngigkeiten, bei denen niemand mehr weiĂ, warum sie existieren. Die Verwaltung der AbhĂ€ngigkeiten ist kostspieliger und mĂŒhevoller als nötig. Ich habe mit mehreren Java-Projekten in diesem Zustand gearbeitet und mir Strategien zur Verbesserung der Situation angeeignet, die ich in diesem Vortrag vorstelle.
Unbeschwertes Dependency-Management fĂŒr Java-Projekte
Java Forum Nord (2025)
Wir alle verwenden Open-Source-Bibliotheken in unseren Java-Anwendungen. Solche AbhĂ€ngigkeiten sind schnell hinzugefĂŒgt, da keine direkten Kosten entstehen. Die ProduktivitĂ€t steigt kurzfristig, da fertige FunktionalitĂ€t sofort genutzt werden kann. Doch auf lange Sicht ist dies keineswegs âkostenlosâ. Mit der Weiterentwicklung einer Bibliothek entstehen Folgekosten. In langlebigen Projekten gibt es oft AbhĂ€ngigkeiten, bei denen niemand mehr weiĂ, warum sie existieren. Das âWarumâ ist nicht dokumentiert, und die Entwickler, die sie eingefĂŒhrt haben, sind lĂ€ngst nicht mehr im Team. Die Verwaltung der AbhĂ€ngigkeiten ist kostspieliger und mĂŒhevoller als sie sein sollte. Ich habe mit mehreren Java-Projekten in diesem Zustand gearbeitet und mir Strategien zur Verbesserung der Situation angeeignet, die ich in diesem Vortrag vorstelle.
Unbeschwertes Dependency-Management fĂŒr Java-Projekte
Java Forum Stuttgart (2025)
Wir alle verwenden Open-Source-Bibliotheken in unseren Java-Anwendungen. Solche AbhĂ€ngigkeiten sind schnell hinzugefĂŒgt, da keine direkten Kosten entstehen. Die ProduktivitĂ€t steigt kurzfristig, da fertige FunktionalitĂ€t sofort genutzt werden kann. Doch auf lange Sicht ist dies keineswegs âkostenlosâ. Mit der Weiterentwicklung einer Bibliothek entstehen Folgekosten. In langlebigen Projekten gibt es oft AbhĂ€ngigkeiten, bei denen niemand mehr weiĂ, warum sie existieren. Das âWarumâ ist nicht dokumentiert, und die Entwickler, die sie eingefĂŒhrt haben, sind lĂ€ngst nicht mehr im Team. Die Verwaltung der AbhĂ€ngigkeiten ist kostspieliger und mĂŒhevoller als sie sein sollte. Ich habe mit mehreren Java-Projekten in diesem Zustand gearbeitet und mir Strategien zur Verbesserung der Situation angeeignet, die ich in diesem Vortrag vorstelle.
Das Java-Modul-System klug mit Gradle kombinieren
DevTalk@TK, Hamburg (2025)
Modularisierung und Dependencymanagement sind fĂŒr viele Java-Entwickler kontroverse Themen. Zwar kommt man kaum an ihnen vorbei, aber sie scheinen oft mehr Probleme zu erzeugen als zu lösen. In typischen Java-Projekten werden Modularisierung und Dependencymanagement heutzutage hauptsĂ€chlich ĂŒber das Build-Tool der Wahl (meist Gradle oder Maven) durchgefĂŒhrt. Seit Java 9 können Module und deren Beziehungen direkt in Java beschrieben werden, wenn man das Java-Modul-System (JPMS) verwenden. Das macht es auf den ersten Blick nicht einfacher: Was nutze ich, wenn ich sowohl Java als auch das Build-Tool zur Beschreibung meiner Module verwenden kann? Bekomme ich, auĂer Redundanz, ĂŒberhaupt einen Mehrwert? In diesem Vortrag stelle ich ein Projekt-Setup vor, das die StĂ€rken vom Java-Modul-System und Gradle vereint. Dies fĂŒhrt zu einer saubereren und wartbareren Java-Projektstruktur. Dieses Setup hat sich in mehreren Projekten in der Praxis bewĂ€hrt.
Boosting Developer Productivity Through Better Modularity
DPE Summit, San Francisco (2024)
Modularization and reuse of modules, through some form of dependency management, are a central part of every larger software project. While most projects have well-defined modularity when they start off, they often end up in a chaotic setup â also referred to as âdependency hellâ â after a few years of development. And all too often, there is no ambition to get out of that again until a project reaches an almost unmaintainable state. Not investing in this area earlier is usually a bad business decision. Issues in the modularity setup of a project have a negative impact on developer productivity in many ways that not only make the daily work of developers inefficient but also worsen the problems over time. In this session, we look at how these problems arise, the influence they have on developer productivity, and why they are so often invisible or ignored. In particular, we identify âaccidental complexitiesâ and separate them from âessential complexitiesâ in this area. We then explore which tooling helps us to avoid the accidental complexities and deal with the essential complexities in a sustainable way. Based on this, we share ideas for future developer productivity tools and features that could be added to existing build and DPE tools like Gradle or Develocity. What we discuss in this session is based on experiences gained through helping multiple large Java projects get back to a maintainable modularity setup. Although we use Java, Gradle, and Develocity in examples, the concepts presented can be transferred to other languages and tools.
Das Java-Modul-System klug mit Gradle kombinieren
Java Forum Stuttgart (2024)
Modularisierung und Dependencymanagement sind fĂŒr viele Java-Entwickler kontroverse Themen. Zwar kommt man kaum an ihnen vorbei, aber sie scheinen oft mehr Probleme zu erzeugen als zu lösen. In typischen Java-Projekten werden Modularisierung und Dependencymanagement heutzutage hauptsĂ€chlich ĂŒber das Build-Tool der Wahl (meist Gradle oder Maven) durchgefĂŒhrt. Seit Java 9 können Module und deren Beziehungen direkt in Java beschrieben werden, wenn man das Java-Modul-System (JPMS) verwenden. Das macht es auf den ersten Blick nicht einfacher: Was nutze ich, wenn ich sowohl Java als auch das Build-Tool zur Beschreibung meiner Module verwenden kann? Bekomme ich, auĂer Redundanz, ĂŒberhaupt einen Mehrwert? In diesem Vortrag stelle ich ein Projekt-Setup vor, das die StĂ€rken vom Java-Modul-System und Gradle vereint. Dies fĂŒhrt zu einer saubereren und wartbareren Java-Projektstruktur. Dieses Setup hat sich in mehreren Projekten in der Praxis bewĂ€hrt.
Combining Java Modules and Gradle for elegant project structures
JavaLand (2024)
Modularization and Dependency Management are controversial topics for many Java developers. You can hardly get past them, but they often seem to create problems rather than solving them. In typical Java projects today, Modularization and Dependency Management are mainly done through the build tool of choice (usually Gradle or Maven). Since Java 9, you can describe Modules and their relationships directly in the Java language by using the Java Module System (JPMS). At first glance, this does not make it any easier: What do I use if Java and build tool both want to be used to describe my Modules? Do I gain anything besides redundancy? In this talk I present a project setup that combines the strengths of the Java Module System and Gradle. This leads to a cleaner and more maintainable Java project structure. This setup has been proven in practice as it was successfully introduced into multiple Java projects over the past two years.
Modularizing with the Java Module System and Gradle
Java User Group Bonn (2023)
Das mit Java 9 eingefĂŒhrte Java-Modulsystem wird inzwischen immer stĂ€rker angenommen. Da dessen Verwendung in Java-Projekten jedoch optional ist, ergeben sich viele Fragen: Was gewinne ich konkret fĂŒr mein Projekt, wenn ich das Modulsystem verwende? Wie vertrĂ€gt sich das Java-Modul-Konzept mit der Modularisierung die bereits in Java-Projekten ĂŒber die Projektstruktur umgesetzt ist? Was mache ich mit Third-Party-Libraries und wie teste ich? In diesem Vortrag werde ich euch diese Fragen aus meiner Erfahrung beantworten. Ich begleite zur Zeit ein Projekt, welches die Umstellung auf das Java-Modulsystem (mit Gradle) erfolgreich durchgefĂŒhrt hat. AuĂerdem war ich an der Implementierung des Java-Modulsystem-Supports in Gradle beteiligt und entwickle Plugins die diesen weiter verbessern (auf gradlex.org).
Modularizing with the Java Module System and Gradle
Java User Group Saxony (2023)
Das mit Java 9 eingefĂŒhrte Java-Modulsystem wird inzwischen immer stĂ€rker angenommen. Da dessen Verwendung in Java-Projekten jedoch optional ist, ergeben sich viele Fragen: Was gewinne ich konkret fĂŒr mein Projekt, wenn ich das Modulsystem verwende? Wie vertrĂ€gt sich das Java-Modul-Konzept mit der Modularisierung die bereits in Java-Projekten ĂŒber die Projektstruktur umgesetzt ist? Was mache ich mit Third-Party-Libraries und wie teste ich? In diesem Vortrag werde ich euch diese Fragen aus meiner Erfahrung beantworten. Ich begleite zur Zeit ein Projekt, welches die Umstellung auf das Java-Modulsystem (mit Gradle) erfolgreich durchgefĂŒhrt hat. AuĂerdem war ich an der Implementierung des Java-Modulsystem-Supports in Gradle beteiligt und entwickle Plugins die diesen weiter verbessern (auf gradlex.org).
Modularizing with the Java Module System and Gradle
Java User Group Hamburg (2023)
Das mit Java 9 eingefĂŒhrte Java-Modulsystem wird inzwischen immer stĂ€rker angenommen. Da dessen Verwendung in Java-Projekten jedoch optional ist, ergeben sich viele Fragen: Was gewinne ich konkret fĂŒr mein Projekt, wenn ich das Modulsystem verwende? Wie vertrĂ€gt sich das Java-Modul-Konzept mit der Modularisierung die bereits in Java-Projekten ĂŒber die Projektstruktur umgesetzt ist? Was mache ich mit Third-Party-Libraries und wie teste ich? In diesem Vortrag werde ich euch diese Fragen aus meiner Erfahrung beantworten. Ich begleite zur Zeit ein Projekt, welches die Umstellung auf das Java-Modulsystem (mit Gradle) erfolgreich durchgefĂŒhrt hat. AuĂerdem war ich an der Implementierung des Java-Modulsystem-Supports in Gradle beteiligt und entwickle Plugins die diesen weiter verbessern (auf gradlex.org).
How to structure a Spring Boot project with Gradle nowadays?
Spring NRW Meetup (2022)
In this talk, I showed how to structure a Spring Boot project with modern Gradle.
Automate everything, but fast! (with Gradle)
techcamp Hamburg (2022)
Das Gradle Build Tool ist in den letzten zehn Jahren zu einer stabilen und effizienten Automatisierungstechnologie herangereift. Vor allem im Umfeld von Java- und Android-Entwicklung bekannt, handelt es sich um ein sprach- und technologieunabhĂ€ngiges Automatisierungstool mit vielfĂ€ltigen Einsatzmöglichkeiten. Der Kern des Open-Source-Tools besteht dabei aus mĂ€chtigen Systemen fĂŒr inkrementelle Verarbeitung, Caching, Parallelisierung, Modularisierung und AbhĂ€ngigkeitenverwaltung. Dank eines flexiblen Plugin-Mechanismus, können diese Systeme fĂŒr beliebige Automatisierungsaufgaben benutzt werden. Im Vergleich zu anderen Lösungen â z.B. einfach Skripte â erhöht sich so die Effizienz wiederkehrender Aufgaben, z.B. durch Parallelisierung und die Wiederverwendung von Zwischenergebnissen. Ein Gradle-Plugin zu schreiben, muss dabei nicht aufwendiger sein als das Schreiben normaler Skripte. In dieser Session erstellen wir gemeinsam, hands-on in der IDE, ein Gradle-Setup fĂŒr einen individuellen Automatisierungs-Anwendungsfall.
Gradle and Kotlin
KKon Warm-up (2021)
Gradle kommt in vielen Softwareprojekten fĂŒr Kotlin, Java, Groovy, Scala oder Android zum Einsatz. Mit dem Build-Tool Gradle lĂ€sst sich jede beliebige Software mit hoher Effizienz bauen, da der Gradle-Kern aus sprachunabhĂ€nigigen Systemen besteht. Inkrementelles Bauen, Build-Caching oder das Verwalten von Dependencies sind nur drei Beispiele, in denen sich eine individuelle Build-Logik wiederverwenden lĂ€sst. Eine solche auf eigene Projekte zugeschnittene Build-Logik kann in jeder JVM-Sprache entwickelt werden â und mit Kotlin gelingt das besonders elegant. Jendrik Johannes zeigt Ihnen in seinem Vortrag, wie Sie Softwareprojekte mit Gradle strukturieren und eine individuelle, effiziente Build-Logik mit Kotlin entwickeln. Besondere Gradle-Vorkenntnisse brauchen Sie zum VerstĂ€ndnis nicht.
Keeping growing software projects under control with Gradle
Joker - Int. Java Conference (2020)
Gradle is a widely used build tool for building Java, Kotlin, Groovy or Scala projects. But, with language-agnostic systems for dependency management and work scheduling at its core, it can be used to automate the build process for any kind of software product. Furthermore, it can do this very effectively by providing various caching mechanisms that also work in a language-agnostic way. This makes Gradle a powerful tool to structure and build growing software projects. And, if used correctly, profit from all the optimisations, like incremental and cached builds, even for custom build logic. The challenge though is to understand which features of Gradle to use when and for what. As Gradle itself evolved, many good things have been added in recent Gradle releases which are not as widely known yet. This talk will show, on a practical example, how Gradle helps you to deal with challenges you typically encounter in growing software projects.
What's New in Gradle 6.0
Official Gradle Inc. Webcast (2019)
Gradle 6.0 is the culmination of several years of innovative improvements in Dependency Management. Embracing the idea that there is more to software composition and reuse than just putting a set of jar files on the classpath, Gradle now offers a new metadata format to richly define software components that are often made up of multiple files, different variants and specific constraints on their dependencies.
Structure your Project with Gradle by using Kotlin Everywhere
Kotlin Everywhere Hamburg (2019)
Gradle is not only the preferred build tool for Kotlin projects, but also offers its own Kotlin DSL to define your project and build structure. In this talk, we will look at the features Gradle offers to structure your project and how you make use of them by writing build scripts with Kotlin.
Dependency Management in Gradle 5 and beyond
Kotlin User Group Hamburg (2019)
The Java ecosystem allows developers to profit from a large pool of reusable libraries. Traditionally, the platform-independence of Java always made it easy to publish and share ready-to-use libraries. As Kotlin and Android developers, we also profit from this existing catalogue of libraries. However, new challenges for dealing with dependencies in the JVM world emerged over the past years, as software systems grew further in complexity and new platforms, such as Kotlin or Android, emerged. Dependency management is one of the major functionalities of the Gradle Build Tool. Gradle 5 offers a number of new stable features to support developers in managing dependencies â and more can be expected soon.
Software-Wiederverwendung in der Praxis - Funktioniert das ĂŒberhaupt?
Software Eng. Day TU Dresden (2018)
...
Behind the Magic of Gradle with Kotlin
Kotlin User Group Hamburg (2018)
If you are a Koltin (Android) developer, Gradle might be your primary (only) choice for a build tool. If you encounter Gradle for the first time and then need to configure your build, you are quickly confronted with a bunch of Groovy scripts. If you reaction is: "Groovy??!! What the %&#\*??!!" ...then you are not alone. Thousands of Android and Java developers had the same feeling once. But fear not! As Kotlin developer, you have another advantage over Java developers now: You can use a powerful build tool that you can configure without being forced to use yet another (scarily dynamic) language. We will explore how Gradle and Kotlin work together on different levels. While we do this, we will look at some basic Gradle features you can leverage to make your builds better and which you can configure using... ...Kotlin!
Komplex und Kompliziert â Ăberleben in der Dauerkrise Softwareentwicklung
Ringvorlesung: Softwareentwicklung in der industriellen Praxis, TU Dresden (2016)
Wer in der Softwareentwicklung tĂ€tig ist, der ist mitten drin in der Um- und Neugestaltung unserer Gesellschaft. Das Informationszeitalter will vorangetrieben werden und Software steht im Zentrum - es ist aufregend und herausfordernd. Eines der befriedigtesten TĂ€tigkeitsfelder der heutigen Zeit. Oder nicht? Wer in der Softwareentwicklung tĂ€tig ist, der stöhnt und jammert: Ăber schlecht gestaltete Arbeitsprozesse, eingefahrenen Unternehmensstrukturen, schlechte Software, langsame Tools und vieles vieles mehr. Jendrik hat sich zehn Jahre Gejammer angehört (und ordentlich mitgejammert). Er war unter anderem schon als Forscher, Berater, FirmengrĂŒnder, Spieleentwickler und Teamleiter tĂ€tig. Und er hat sich dabei immer wieder gefragt: Warum schaffen wir es nicht Software effizienter zu entwickeln und damit am Ende auch mehr Zufriedenheit bei allen Beteiligten zu erreichen? Die Antwort sucht er noch...
What's a Platform to You?
Quo Vadis Game Dev, Berlin (2016)
In game development, we always talk about platforms. Developers talk about platforms, business people talk about platforms⊠everyone talks about platforms. "Platform" became a buzzword with many different meanings. Sometimes it has a positive context expressed by the idea of "a platform we can build on". Yet this isnât the case for mobile development as it often has a negative connotation, with many focusing on the "different platforms we need to address". In this talk, I want to unravel the jungle of platform terminology in mobile game projects. I will do that by analyzing concrete examples from two projects I worked on at InnoGames that used different technologies.
Requirements for Modern Mobile Game Technologies
Pocket Gamer Connects London (2016)
...
EinflĂŒsse des Mobile Gaming auf die Entwicklungskultur
Ringvorlesung: Subkulturen des Spiels, HAW Hamburg (2015)
Neue Plattformen, Neue MĂ€rkte, Neue Spieler - EinflĂŒsse des Mobile Gaming auf die Entwicklungskultur
Why Game Developers should never write Game Code...
Respawn, Cologne (2015)
...but Tool and Engine Code instead. When you are developing software for clients you have a choice: Either you understand the requirements in detail and code the software yourself or you provide tools for the clients to enable them to develop the software on their own (which is called Domain-Specific Modelling in some software development domains). In Game Development, where the "clients" are game designers, producers and product managers, both approaches work: Coding without building specific tools works often better than in other software development domains, because game developers are usually very accustomed with the domain â gaming â themselves. On the other hand, game designers often have a tech background and are thus very open to using a variety of tools. So when a new project starts and a toolset is not already in place, building new tools might seem inefficient compared to just coding down the game, doesn't it? In this talk, I will make a case for building tools as often as possible â because they are an important, often underestimated, factor for efficient development, communication and knowledge transfer in larger teams. I will draw on my own experiences from game development and software development in other industries.
Developing Cross-Platform Mobile MMOs - Architectures/Processes
Quo Vadis Game Dev, Berlin (2015)
We take a closer look at different aspects of cross-platform mobile game development on the example of the MMO Tribal Wars 2. Starting from the technology decisions for the mobile versions, over building up a team and process to develop and maintain different versions of the game in parallel, the launch of the game on different platforms, up to the continuous development on the live game. Based on the experiences gained, we discuss alternative software architectures and processes.
Develop Custom Java Code Analysis and Refactoring Tools
EclipseCon Europe, Ludwigsburg (2012)
Today, Java code makes up a large part of many software systems. To keep these systems maintainable, extendable and flexible in the long run, constant checking of the consistency of code and other artefacts is necessary. Individual coding guidelines need to be followed, anti-patterns need to be avoided and interfaces need to be used correctly. To save costs and to prevent mistakes during theses tasks, a high degree of automation is desirable. JaMoPP - the Java Model Parser and Printer - addresses these challenges. JaMoPP automatically converts your Java code into an EMF-conformant model. This model can be processed by any EMF-based tool. Additionally, the model can be linked to other files and models for which EMF support exists. For example, BPMN or UML models, property or CSV files or data from databases. With JaMoPP, custom tools for Java code analysis and refactoring can be defined. This way, inconsistencies in the code or between code and other artifacts can be recognised instantly and, if required, repaired automatically. JaMoPP is integrated with Eclipse to provide instant feedback to developers but can also be utilised outside of Eclipse to run checks and refactorings in build scripts or on continuous integration systems. In this talk, we demonstrate the capabilities of JaMoPP and its integration with Eclipse and EMF on multiple practical examples.
Boost your build with BuildBoost
XP Days Germany, Hamburg (2012)
To successfully implement Continuous Integration and Delivery, one needs to set up a system that performs automated builds and deployments tailored to the project at hand. This is usually a cumbersome task that involves a lot of scripting and hacking. In other words, a lot of effort and time needs to be invested in advance. Although this effort pays off in the long run, there is enormous potential for improvement in developing and setting up Continuous Integration and Delivery systems. Continuous Integration and Delivery systems are software systems. Similar to the developments of any other software system, established and efficient methods, tools and languages must be used. This includes, to name only some, proper testing and debugging support, reuse of components and libraries, versioning, packaging as well as Continuous Integration and Delivery of the Continuous Integration and Delivery system itself. In this talk we present BuildBoost, a Java/Ant-based open-source framework and meta-build tool to achieve this. BuildBoost rigorously follows the concept of 'convention over configuration' to enable minimal-to-zero build configurations. For this, it is based on the principle that all information needed to build an artefact is delivered with the artifact itself and must not be hidden in build scripts. Furthermore, in BuildBoost the build system itself is considered part of the software and thus BuildBoost includes a bootstrap concept that builds the build system itself with the software. This allows a continuous and agile development of the build system itself together with the software system. BuildBoost is a highly extendable framework. It allows to plug-in and to combine several build steps for arbitrary tasks. It already offers a collection of build steps that can be reused and combined to set up build systems for certain tasks within minutes. Since BuildBoost is a framework and not a new technology, it seamlessly integrates with existing technologies such as Ant, Gradle, Maven, Java or Scala. By this, existing build scripts can be smoothly integrated into BuildBoost. One instantiation of BuildBoost we have developed at DevBoost is a Continuous Integration and Delivery system for Eclipse plugins/OSGi bundles that builds those artefacts from Eclipse projects and delivers them as both p2 and maven repositories. We use this instantiation in the talk to demonstrate BuildBoost and show how you can instantly reuse this instantiation to build your own Eclipse plugins or OSGi bundles. BuildBoost is licensed under the Eclipse Public License and can therefore be used both for non-commericial and commercial puposes without any restrictions.
JaMoPP - Open Source Tool for Analysing und Modernising Software
Eclipse DemoCamp Juno, Kassel (2012)
...
Clean separation of hand-written methods in EMF models with eJava
Eclipse DemoCamp Helios, Dresden (2010)
Jeder Entwickler der das Eclipse Modelling Framework (EMF) nutzt, war sicher schon gezwungen Methoden in dem von EMF generierten Code zu Ă€ndern. Leider wird so der generierte Code mit handgeschriebenem vermischt. Hier bietet eJava eine sauberere Lösung. Einfach gesagt integriert eJava handgeschriebene Methoden in Ecore Modelle. Man legt einfach. eJava Dateien an, die den Code enthalten, den man normalerweise in den generierten EMF Code schreibt. eJava integriert automatisch alle Methoden in die GenModels, so dass die normale EMF Codegenerierung benutzt werden kann, der resultierende Code nicht verĂ€ndert werden muss und trotzdem eigene MethodenrĂŒmpfe möglich sind. So muss man z.b. den generierten Code nicht mehr in die Versionskontrolle einchecken oder darauf achten 'generated NOT' einzufĂŒgen. NatĂŒrlich prĂŒft der eJava Editor schon beim Editieren, ob alle Typen da sind und Ă€hnliches.
Zeitschriftenartikel und Blog-Posts
Unbeschwertes Dependency-Management fĂŒr Java-Projekte
Java aktuell, 01/2026 (2026)
In diesem Artikel werfen wir einen Blick auf das 'Java Recipe for Carefree Dependency Administration'. Es bietet eine Leitlinie aus sechs Punkten, um ein Java-Projekt mit einem AbhĂ€ngigkeitsmanagement ohne unnötige KomplexitĂ€t aufzusetzen. FĂŒr jeden dieser sechs Punkte betrachten wir, welche Rolle er spielt, welches Problem er adressiert und wie sich dieses effektiv lösen lĂ€sst.
Anwendungen mit Java-Modulen und Gradle elegant strukturieren
Java aktuell, 05/2023 (2023)
Die Themen Modularisierung und AbhĂ€ngigkeiten-Verwaltung sind Reizthemen fĂŒr viele Java-Entwickler. In kaum einem Projekt kommt man an ihnen vorbei, doch oft scheinen sie eher Probleme zu erzeugen als sie zu lösen. In Java-Projekten fallen beide Themenbereiche gröĂtenteils in die ZustĂ€ndigkeit eines Build-Tools wie Gradle. Seit Java 9 kann Java Modul-Beschreibungen direkt abbilden und bringt dabei noch zusĂ€tzliche Features wie private Packages mit. Das macht es erst mal nicht einfacher: Was benutze ich denn nun, wenn sowohl Java als auch das Build-Tool zur Beschreibung von Modulen genutzt werden sollen? Gewinne ich dabei auĂer Redundanz ĂŒberhaupt noch was? Dieser Artikel beschreibt, wie man die StĂ€rken des Java-Modulsystems mit dem richtigen Gradle- und Gradle-Plugin-Setup fĂŒr eine ĂŒbersichtlichere und wartbarere Java-Projektstruktur einsetzt.
Komplexe Builds beherrschen (Gradle 7)
Java Magazin, 10.2021 (2021)
Seit seiner Entstehung vor ĂŒber zehn Jahren wurde Gradle stetig erweitert und modernisiert. Es ist damit eines der mĂ€chtigsten Build-Tools ĂŒberhaupt und mit ĂŒber 20 Millionen monatlichen Downloads auch eines der meistgenutzten. Allerdings kann es eine Herausforderung sein, in der FĂŒlle der Funktionen und Möglichkeiten den Ăberblick zu behalten. Dieser Artikel gibt eine Ăbersicht ĂŒber die grundlegenden Konzepte und Funktionen, die man kennen sollte, um die Vorteile von Gradle fĂŒr sein Softwareprojekt zu nutzen und es dabei verstĂ€ndlich und wartbar zu strukturieren.
Gradle 6: Dependency-Management reloaded
Java Magazin, 3.2020 (2020)
Das kĂŒrzlich erschienene Release 6 des modernen Build-Tools bringt eine Menge neuer Features, die es erlauben, Java-, Groovy-, Kotlin- und Scala-Projekte besser zu strukturieren und zu modularisieren. Ein Highlight ist dabei die EinfĂŒhrung des Gradle-Module-Metadata-Formats, um Module mit reichhaltigen Metadaten zu publizieren und wiederzuverwenden.
Why libraries like Guava need more than POMs
Official Gradle Blog (2020)
...
Automatically align Dependencies with Platforms in Gradle
Official Gradle Blog (2019)
...
CommentTemplate: Semantischer Zucker fĂŒr die Template-Erstellung
Eclipse Magazin, 1.2013 (2012)
With Mirko Seifert, and Christian Wender
...
TDD meets Instant Feedback: JUnitLoop & JLoop
Eclipse Magazin, 6.2012 (2012)
With Mirko Seifert, and Christian Wender
Michael C. Feathers prophezeit in seinem Buch âWorking Effectively with Legacy Codeâ, dass es in nicht allzu ferner Zukunft eine IDE geben wird, die bei jedem Tastendruck nicht nur den Compiler startet, um Code statisch auf Korrektheit zu prĂŒfen, sondern auch gleich alle relevanten Unit Tests ausfĂŒhrt und so prĂŒft, ob der Code das erwartete Verhalten zeigt. Das Open-Source-Plug-in JUnitLoop ist angetreten, diese Vision in Eclipse zur RealitĂ€t werden zu lassen.
Codellieren mit Ecore: MinimalEcore und EMFCustomize
Eclipse Magazin, 5.2012 (2012)
With Mirko Seifert, and Christian Wender
...
A DSL for Hibernate
Java Magazin, 8.2012 (2012)
With Mirko Seifert, and Christian Wender
Hibernate ist ein beliebtes Framework fĂŒr die Umsetzung von objektrelationalen Mappings. Es implementiert JPA und wird in unzĂ€hligen Projekten produktiv eingesetzt. HEDL, die Hibernate Entity Definition Language, ist eine DSL, die den Umgang mit Hibernate noch einfacher machen soll. Dieser Artikel stellt die Funktionsweise von HEDL vor.
Hibernate, aber bitte einfach: HEDL â eine DSL fĂŒr Hibernate
Eclipse Magazin, 3.2012 (2012)
With Mirko Seifert, and Christian Wender
Hibernate ist ein beliebtes Framework fĂŒr die Umsetzung von objektrelationalen Mappings. Es implementiert JPA und wird in unzĂ€hligen Projekten produktiv eingesetzt. HEDL, die Hibernate Entity Definition Language, ist eine DSL, die den Umgang mit Hibernate noch einfacher machen soll. Dieser Artikel stellt die Funktionsweise von HEDL vor.
Mit JaMoPP Java-Anwendungen automatisch analysieren und umstrukturiere
Eclipse Magazin, 3.2012 (2012)
With Mirko Seifert, and Christian Wender
Automatisierte Analyse und Umstrukturierung von Code ist ein immer wichtigeres Werkzeug fĂŒr Entwickler: Wer möchte die Error- und Warning-Markierungen in Eclipse, die einen schon vor so mancher Frustration bewahrt haben, noch missen? Genauso unverzichtbar geworden sind automatische Refactorings, die einem stupide Arbeit bei den stĂ€ndig anstehenden Umstrukturierungen abnehmen. Aber was, wenn die Analyse zu speziell wird oder Umstrukturierungen zu sehr auf die eigene Architektur gemĂŒnzt sind? Was ist zu tun, wenn die Analysen zu komplex sind, um sie einem Stylechecker beizubringen? Da wĂŒnscht man sich doch, man könnte die Refactorings in Eclipse erweitern oder anpassen. Hier hilf das Werkzeug JaMoPP, denn es bietet ein API, um diese Dinge schnell und flexibel in der Sprache zu definieren, die Sie ohnehin gerade nutzen: Java.
Modellkomposition mit Reuseware
Eclipse Magazin, 3.2011 (2011)
Die Entwicklung von Softwaresystemen durch Komposition von vorgefertigten Komponenten wird in der Theorie jeher als elegante und effektive Methodik zur Softwareentwicklung angesehen. In der Praxis sieht dies jedoch oft anders aus: Viele Systeme verwenden nur die Frameworks der Basistechnologie wieder und werden ansonsten auf der grĂŒnen Wiese neu entwickelt. Oft ist fehlende Komponententechnologie und ToolunterstĂŒtzung, die den individuellen Anforderungen eines Entwicklungsprozesses gerecht werden, ein Grund dafĂŒr. Insbesondere im Umfeld der modellgetriebenen Entwicklung und der Entwicklung mit domĂ€nenspezifischen Sprachen mangelt es an Komponententechnologien. Das Reuseware Composition Framework, welches in diesem Artikel vorgestellt wird, unterstĂŒtzt die Entwicklung von individueller KomponentenunterstĂŒtzung fĂŒr Entwicklungsprozesse die auf diesen Paradigmen basieren. Es baut dabei, durch die Verwendung von Ecore-Modellen, auf EMF auf, wodurch es leicht mit anderen Tools im EMF-Umfeld kombiniert werden kann.
Textuelle DSLs erstellen mit EMFText
Eclipse Magazin, 5.2009 (2009)
With Florian Heidenreich, Sven Karol, Mirko Seifert, and Christian Wender
DomaÌnenspezifische Sprachen (oder Domain-Specific Languages â DSLs) erlauben es, bestimmte Teilaspekte von Anwendungen zu beschreiben. DSLs besitzen in der Regel eine geringere KomplexitaÌt als herkoÌmmliche Programmiersprachen und koÌnnen so auch von DomaÌnenexperten, die nicht aus dem IT-Bereich stammen, benutzt werden. Je nach Anwendungsfeld koÌnnen DSLs grafischer oder textueller Natur sein. In diesem Artikel wird anhand der BeispieldomaÌne des Formularwesens das Werkzeug EMFText vorgestellt. EMFText schlaÌgt die BruÌcke zwischen textuellen DSLs und Modellen. Es wird Schritt fuÌr Schritt gezeigt, wie sich aufbauend auf einem DomaÌnenmodell eine neue DSL definieren und nutzen laÌsst.
Wissenschaftliche Papers und Doktorarbeit
Component-Based Model-Driven Software Development (PhD Thesis)
PhD thesis, TU Dresden (2010)
Model-driven software development (MDSD) and component-based software development are both paradigms for reducing complexity and for increasing abstraction and reuse in software development. In this thesis, we aim at combining the advantages of each by introducing methods from component-based development into MDSD. In MDSD, all artefacts that describe a software system are regarded as models of the system and are treated as the central development artefacts. To obtain a system implementation from such models, they are transformed and integrated until implementation code can be generated from them. Models in MDSD can have very different forms: they can be documents, diagrams, or textual specifications defined in different modelling languages. Integrating these models of different formats and abstraction in a consistent way is a central challenge in MDSD. We propose to tackle this challenge by explicitly separating the tasks of defining model components and composing model components, which is also known as distinguishing programming-in-the-small and programming-in-the-large. That is, we promote a separation of models into models for modelling-in-the-small (models that are components) and models for modelling-in-the-large (models that describe compositions of model components). To perform such component-based modelling, we introduce two architectural styles for developing systems with component-based MDSD (CB-MDSD).
DropsBox: the Dresden Open Software Toolbox
Software & Systems Modeling, Springer (2012)
With Uwe AĂmann, Andreas Bartho, Christoff BĂŒrger, Sebastian Cech, Birgit Demuth, Florian Heidenreich, Sven Karol, Jan Polowinski, Jan Reimann, Julia Schroeter, Mirko Seifert, Michael Thiele, Christian Wende, and Claas Wilke
The Dresden Open Software Toolbox (DropsBox) is a software modelling toolbox consisting of a set of open source tools developed by the Software Technology Group at TU Dresden. The DropsBox is built on top of the Eclipse Platform and the Eclipse Modeling Framework. The DropsBox contributes to the development and application of domain-specific languages (DSLs) in model-driven software development. It can be customised by tool and language developers to support various activities of a DSLâs life cycle ranging from language design to language application and evolution. In this paper, we provide an overview of the DSL life cycle, the DropsBox tools, and their interaction on a common example. Furthermore, we discuss our experiences in developing and integrating tools for DropsBox in an academic environment.
CommentTemplate: A Lightweight Code Generator for Java
Proc. of Co-located Events at the 8th European Conference on Modelling Foundations and Applications (ECMFAâ12) (2012)
With Mirko Seifert, Christian Wende, Florian Heidenreich, and Uwe AĂmann
In this paper we present CommentTemplate, which realizes code generation features, as known from many model-driven development tools, as a Java language extension. This paper first introduces CommentTemplate and discusses its features and limitations. Second, it discusses CommentTemplate as an example of (a) a tool that makes concepts from model-driven development easily accessible for Java programmers and (b) a powerful and stable tool that was realized in a short time thanks to Eclipse modeling technology.
Integrating OCL and Textual Modelling Languages
Workshops and Symposia at ACM/IEEE 13th International Conference on Model Driven Engineering Languages and Systems, Reports and Revised Selected Papers, LNCS, Springer (2010)
With Florian Heidenreich, Mirko Seifert, Michael Thiele, Christian Wende, and Claas Wilke
In the past years, many OCL tools achieved a transition of OCL from a language meant to constrain UML models to a universal constraint language applied to various modelling and metamodelling languages. However, OCL users still experience a discrepancy between the now highly extensible parsing and evaluation backend of OCL tools and the lack of appropriate frontend tooling like advanced OCL editors that adapt to the different application scenarios. We argue that this has to be addressed both at a technical and methodological level. Therefore, this paper provides an overview of the technical foundations to provide an integrated OCL tooling frontend and backend for arbitrary textual modelling languages and contributes a stepwise process for such an integration. We distinguish two kinds of integration: external definition of OCL constraints and embedded definition of OCL constraints. Due to the textual notation of OCL the second kind provides particularly deep integration with textual modelling languages. We apply our approach in two case studies and discuss the benefits and limitations of the approach in general and both integration kinds in particular.
Concern-based (de)composition of Model-Driven Software Development Processes
Proc. of ACM/IEEE 13th International Conference on Model Driven Engineering Languages and Systems (MoDELSâ10), volume 6395 of LNCS, Springer (2010)
With Uwe AĂmann
An MDSD process is often organised as transformation chain. This can threaten the Separation of Concerns (SoC) principle, because information is replicated in, scattered over, and tangled in different models. Aspect-Oriented Software Development (AOSD) supports SoC to avoid such scatterings and tangling of information. Although there are integrations of MDSD and AOSD, there is no approach that uses concern separation for all artifacts (documents, models, code) involved in an MDSD process as the primary (de)composition method for the complete process. In this paper, we propose such an approach called ModelSoC. It extends the hyperspace model for multi-dimensional SoC to deal with information that is replicated in different models. We present a ModelSoC implementation based on our Reuseware framework that organises all information provided in arbitrary models during development in a concern space and composes integrated views as well as the final system from that. This is shown on the development of a demonstrator system.
Adding Abstraction and Reuse to a Network Modelling Tool using the Reuseware Composition Framework
Proc. of 6th European Conference on Modelling Foundations and Applications (ECMFAâ10), volume 6138 of LNCS, Springer (2010)
With Miguel A. FernĂĄndez
Domain-specific modelling (DSM) environments enable experts in a certain domain to actively participate in model-driven development. Developing DSM environments need to be cost-efficient, since they are only used by a limited group of domain experts. Different model-driven technologies promise to allow this cost-efficient development. [1] presented experiences in developing a DSM environment for telecommunication network modelling. There, challenges were identified that need to be addressed by other new modelling technologies. In this paper, we now present the results of addressing one of theses challengesâ abstraction and reuse supportâwith the Reuseware Composition Framework. We show how we identified the abstraction and reuse features required in the telecommunication DSM environment in a case study and extended the existing environment with these features using Reuseware. We discuss the advantages of using this technology and propose a process for further improving the abstraction and reuse capabilities of the DSM environment in the future.
An Integrated Facet-based Library for Arbitrary Software Components
Proc. of 6th European Conference on Modelling Foundations and Applications (ECMFAâ10), volume 6138 of LNCS, Springer (2010)
With Matthias Schmidt, Jan Polowinski, and Miguel A. FernĂĄndez
Reuse is an important means of reducing costs and effort during the development of complex software systems. A major challenge is to find suitable components in a large library with reasonable effort. This becomes even harder in todayâs development practice where a variety of artefacts such as models and documents play an equally important role as source code. Thus, different types of heterogeneous components exist and require consideration in a component search process. One flexible approach to structure (software component) libraries is _faceted classification_. Faceted classifications and in particular _faceted browsing_ are nowadays widely used in online systems. This paper takes a fresh approach towards using faceted classification in heterogeneous software component libraries by transferring faceted browsing concepts from the web to software component libraries. It presents an architecture and implementation of such a library. This implementation is used to evaluate the applicability of facets in the context of an industry-driven case study.
On Language-Independent Model Modularisation
Transactions on Aspect-Oriented Software Development VI, volume 5560 of LNCS, Springer (2009)
With Florian Heidenreich, Jakob Henriksson, and Steffen Zschaler
As model-driven software development covers additional parts of the development process, the complexity of software models increases as well. At the same time, however, many modelling languages do not provide adequate support for modularising models. For this reason there has been an increasing interest in the topic of model modularisation, often under the heading of aspect-oriented modelling (AOM). The approaches range from techniques that closely mimic concepts from aspect-oriented programming (AOP), such as AspectJ, to very powerful composition techniques for specific types of modelsâfor example, state machines. We believe that AOM is more than just copying the concepts of AOP at the modelling level and should rightly include a large number of other model composition techniques. Developing model composition techniques and tooling is costly, however. To minimise the effort required, this paper presents a generic technique for model composition. The technique is based on invasive software composition and our Reuseware tooling and can be used with arbitrary modelling languages. The basic technique itself is language independent, but it can be adapted to construct language- and purpose-specific composition techniques for specific modelling languages and situations. Hence, it can be used both as a tool for developing specific model-modularisation techniques and as an instrument of research for studying basic properties and concepts of model modularisation. The paper gives a detailed description of our approach and evaluates it using a number of examples.
Abstracting Complex Languages through Transformation and Composition
Proc. of ACM/IEEE 12th International Conference on Model Driven Engineering Languages and Systems (MoDELSâ09), volume 5795 of LNCS, Springer (2009)
With Steffen Zschaler, Miguel A. FernĂĄndez, Antonio Castillo, Dimitrios S. Kolovos, and Richard F. Paige
Domain-specific languages (DSLs) can simplify the development of complex software systems by providing domain-specific abstractions. However, the complexity of some domains has led to a number of DSLs that are themselves complex, limiting the original benefits of using DSLs. We show how to develop DSLs as abstractions of other DSLs by transfering translational approaches for textual DSLs into the domain of modelling languages. We argue that existing model transformation languages are at too low a level of abstraction for succinctly expressing transformations between abstract and concrete DSLs. Patterns identified in such model transformations can be used to raise the level of abstraction. We show how we can allow part of the transformation to be expressed using the concrete syntax of the concrete DSL.
Generating Safe Template Languages
Proc. of ACM 8th International Conference on Generative Programming and Component Engineering (GPCEâ09), ACM Press (2009)
With Florian Heidenreich, Mirko Seifert, Christian Wende, and Marcel Böhme
Template languages are widely used within generative programming, because they provide intuitive means to generate software artefacts expressed in a specific object language. However, most template languages perform template instantiation on the level of string literals, which allows neither syntax checks nor semantics analysis. To make sure that generated artefacts always conform to the object language, we propose to perform static analysis at template design time. In addition, the increasing popularity of domain-specific languages (DSLs) demands an approach that allows to reuse both the concepts of template languages and the corresponding tools. In this paper we address the issues mentioned above by presenting how existing languages can be automatically extended with generic template concepts (e.g., placeholders, loops, conditions) to obtain safe template languages. These languages provide means for syntax checking and static semantic analysis w.r.t. the object language at template design time. We discuss the prerequisites for this extension, analyse the types of correctness properties that can be assured at template design time, and exemplify the key benefits of this approach on a textual DSL and Java.
Closing the Gap between Modelling and Java
Proc. of 2nd International Conference on Software Language Engineering (SLEâ09), LNCS, Springer (2009)
With Proc. of 2nd International Conference on Software Language Engineering (SLEâ09), LNCS, Springer
Model-Driven Software Development is based on standardised models that are refined, transformed and eventually translated into executable code using code generators. However, creating plain text from well-structured models creates a gap that implies several drawbacks: Developers cannot continue to use their model-based tool machinery, relations between model elements and code fragments are hard to track and there is no easy way to rebuild models from their respective code. This paper presents an approach to bridge this gap for the Java programming language. It defines a full metamodel and text syntax specification for Java, from which a parser and a printer are generated. Through this, Java code can be handled like any other model. The implementation is validated with large test sets, example applications are shown, and future directions of research are discussed.
Round-trip Support for Invasive Software Composition Systems
Proc. of 8th International Conference on Software Composition (SCâ09), volume 5634 of LNCS, Springer (2009)
With Roland Samlaus, and Mirko Seifert
The ever increasing complexity of software systems promotes the reuse of software components to a topic of utter importance. By reusing mature parts of software, large systems can be built with high quality. The Reuseware Composition Framework can compose components written in arbitrary software languages. Based on metamodeling these components are merged invasively. But, even though language independent composition is powerful to compose complex systems, one must consider that composition is not the only activity in developing a working systems by reuse. Many tests and validations can only be performed on the composed system. At that point, it is hard to (a) know from which component an error originates and (b) ascertain what the implications of changing something in the composed system are. This paper presents an approach to propagate changes back to the correct source components and discusses the possible implications of changes made to composed systems. Furthermore, the implementation of the approach as an extension to the Reuseware Composition Framework is presented using two example applications.
Derivation and Refinement of Textual Syntax for Models
Proc. of 5th European Conference on Model-Driven Architecture Foundations and Applications (ECMDA-FAâ09), volume 5562 of LNCS, Springer (2009)
With Florian Heidenreich, Sven Karol, Mirko Seifert, and Christian Wende
Textual Syntax (TS) as a form of model representation has made its way to the Model-Driven Software Development community and is considered a viable alternative to graphical representations. To support the design and implementation of text editing facilities many concrete syntax and model mapping tools have emerged. Despite the maturity of these tools, users still spend considerable effort to specify syntaxes and generate editors even for simple metamodels. To reduce this effort, we propose to refine a specification that is automatically derived from a given metamodel. We argue that defaults in a customisable setting enable developers to quickly realise text-based editors for models. In particular in settings where metamodels evolve, such a procedure is beneficial. To evaluate this idea we present EMFText, an EMF/Eclipse integrated tool for agile TS development. We show how default syntax can easily be tailored and refined to obtain a custom text editor for EMF models and demonstrate our approach by two examples.
Developing a Model Composition Framework with Fujaba â An Experience Report
Proc. of 7th International Fujaba Days (2009)
Reuseware is an open-source model composition framework for composing models defined in arbitrary Ecore-based languages. In its four years of development, Reuseware has experienced many extensions and refactorings due to the integration of new research results and requirements. One year ago, a redevelopment of Reusewareâs core was started. Thanks to its EMF code generation, Fujaba was introduced as a new development tool into Reusewareâs development toolchain to replace major parts of Java coding through story driven modelling. With this we solved problems with behavior modelling and code generation we faced in the development so far. This paper summarizes our experiences in developing with Fujaba and suggests improvements for Fujaba and its EMF code generation based on that.
Towards a Generic Layout Composition Framework for Domain Specific Models
Proc. of 9th Workshop on Domain-Specific Modeling (DSMâ09) at OOPSLA (2009)
With Karsten Gaul
Domain Specific Models with graphical syntax play a big role in Model-Driven Software Development, as do model composition tools. Those tools however, often ignore or destroy layout information which is vital for graphical models. We believe that one reason for the insufficient support for layout information in model composition tools is the lack of generic solutions that are easy to adapt for new graphical modelling languages. Therefore, this paper proposes a language-independent framework for layout preservation and composition as an extension to existing model composition frameworks. We describe the single components of the framework and evaluate it in combination with the Reuseware Composition Framework for layout compositions in two different industrial used languages. We discuss the results of this evaluation and the next steps to be taken.
Construct to Reconstruct â Reverse Engineering Java Code with JaMoPP
Proc. of the International Workshop on Reverse Engineering Models from Software Artifacts (R.E.M.â08) (2009)
With Florian Heidenreich, Mirko Seifert, and Christian Wende
Reconstructing models from software artefacts is of utter importance to migrate existing systems to the age of Model-Driven Software Development. To do so, the software artefacts must be analysed and corresponding models need to be created. Many approaches perform this task in a rather direct way. Behavioural or structural models (e.g., UML state machines or class diagrams) are reconstructed from source code. However, this direct model reconstruction implies some major drawbacks. First, parsers and code analysis are reimplemented for different reconstruction tasks. Second, tools developed for forward engineering can not be reused. To resolve these drawbacks, we propose a multi-step procedure, that analyses the structure of artefacts and transforms them to the technological target spaces. The resulting model of the software artefact contains all information present in the artefact. It is therefore independent of specific reconstruction tasks. Then, the model reconstruction itself is performed. We exemplify this approach with our experiences from reverse engineering Java code with JaMoPPâa tool that creates models from Java source code.
Controlling Model-Driven Software Development through Composition Systems
Proc. of 7th Nordic Workshop on Model Driven Software Engineering (NW-MODEâ09) (2009)
In Model-Driven Software Development (MDSD) all artifacts that are created during development can be regarded as parts of the final system. Thus, these artifacts can be seen as components of the system in the sense of Component-Based Software Engineering (CBSE). There, software is split into units such that different concerns are separated. Each functionality of the system can be tracked to the component it is implemented by and therefore fixed, exchanged, extended or individually reused. While in traditional composition systems the components operate independently at run-time, MDSD models are integrated at different points during development time by model transformations. Through this, the advantages mentioned are often lost; and problems occur when one of the components is changed either directly or indirectly during development of a system. This paper proposes an approach that integrates advantages from CBSE into MDSD. In particular the refinements performed during modeldriven development are regarded as compositions supported by composition systems. The approach is based on our Reuseware formalism and exemplified on a concrete MDSD process.
Extending Grammars and Metamodels for Reuse â The Reuseware Approach
Special Issue on Language Engineering, volume 2(3) of IET Software (2008)
With Jakob Henriksson, Florian Heidenreich, Steffen Zschaler, and Uwe AĂmann
The trend toward domain-specific languages leads to an ever-growing plethora of highly specialized languages. Developers of such languages focus on their specific domains rather than on technical challenges of language design. Generic features of languages are rarely included in special-purpose languages. One very important feature is the ability to formulate partial programs in separate encapsulated entities, which can be composed into complete programs in a well-defined manner. This paper presents a language-independent approach for adding useful constructs for defining components. We discuss the underlying concepts and describe a composition environment and tool supporting these ideas â the Reuseware Composition Framework. To evaluate our approach we enrich the (Semantic) Web query language Xcerpt with an additional useful reuse conceptâmodules.
Systematic Usage of Embedded Modelling Languages in Automated Model Transformation Chains
Proc. of 1st International Conference on Software Language Engineering (SLEâ08), volume 5452 of LNCS, Springer (2008)
With Mathias Fritzsche, Uwe AĂmann, Simon Mitschke, Wasif Gilani, Ivor Spence, John Brown, and Peter Kilpatrick
Annotation of programs using embedded Domain-Specific Languages (embedded DSLs), such as the program annotation facility for the Java programming language, is a well-known practice in computer science. In this paper we argue for and propose a specialized approach for the usage of embedded Domain-Specific Modelling Languages (embedded DSMLs) in Model-Driven Engineering (MDE) processes that in particular supports automated many-step model transformation chains. It can happen that information defined at some point, using an embedded DSML, is not required in the next immediate transformation step, but in a later one. We propose a new approach of model annotation enabling flexible many-step transformation chains. The approach utilizes a combination of embedded DSMLs, trace models and a megamodel. We demonstrate our approach based on an example MDE process and an industrial case study.
Putting Performance Engineering into Model Driven Engineering: Model-Driven Performance Engineering
Workshops and Symposia at ACM/IEEE 10th International Conference on Model Driven Engineering Languages and Systems, Reports and Revised Selected Papers, volume 5002 of LNCS, Springer (2008)
With Mathias Fritzsche
Late identification of performance problems can lead to significant additional development costs. Hence, it is necessary to address performance in several development phases by performing a performance engineering process. We show that Model-Driven Engineering (MDE) specifics can be utilised for performance engineering. Therefore, we propose a process combining MDE and performance engineering called ModelDriven Performance Engineering (MDPE).
A Close Look at Composition Languages
Proc. of 2nd Workshop on Assessment of Contemporary Modularization Techniques (ACoMâ08) at OOPSLA (2008)
With Florian Heidenreich, Steffen Zschaler, and Uwe AĂmann
A large number of different composition systems and techniques have been developed over the last years. To compare their relative benefits and drawbacks, we need a common vocabulary for describing elements of composition systems. This paper contributes to the search for such a vocabulary by taking a closer look at the structure of composition languagesâthat is, languages used for describing compositionsâbased on a survey of eight different composition systems.
Letting EMF Tools Talk to Fujaba through Adapters
Proc. of 6th International Fujaba Days (2008)
Many software modelling tools are built on top of the Eclipse Modeling Framework (EMF) through which they can communicate and exchange models. In contrast to that, the Fujaba Toolsuite defines its own modelling framework. Both frameworks are built on the same concepts of software modelling. Therefore, they can be adapted. This paper presents an implementation of a generic adapter layer that adapts Fujabaâs modelling framework to EMF. Through this adapter layer, Fujaba models can be processed by any EMF-based tool without adapting each of those tools individually.
Application of Tracing Techniques in Model-Driven Performance Engineering
Proc. of 4th ECMDA Traceability Workshop (2008)
With Mathias Fritzsche, Steffen Zschaler, Anatoly Zherebtsov, and Alexander Terekhov
In our previous work we proposed Model-Driven Performance Engineering (MDPE) as a methodology to integrate performance engineering into the model-driven engineering process. MDPE enables domain experts, who generally lack performance expertise, to profit from performance engineering by automating the performance analysis process using model transformations. A crucial part of this automated process is to give performance prediction feedback not based on internal models, but on models the domain experts understand. Hence, a mechanism is required to annotate analysis results back into the original models provided by the domain experts. This paper discusses various existing traceability methodologies and describes their application and extension for MDPE by taking its specific needs into account.
Reuseware - Adding Modularity to Your Language of Choice
Proc. of TOOLS EUROPE 2007: Object, Models, Components and Patterns, volume vol. 6, no. 9 of Journal of Object Technology, ETH Swiss Federal Institute of Technology (2007)
With Jakob Henriksson, Steffen Zschaler, and Uwe AĂmann
The trend towards domain-specific languages leads to an ever-growing plethora of highly specialized languages. Developers of such languages focus on their specific domains rather than on technical challenges of language design. Generic features of languages are rarely included in special-purpose languages. One very important feature is modularization, the ability to formulate partial programs in separate entities, composable into a complete program in a defined manner. This paper presents a generic approach for adding modularity to arbitrary languages, discussing the underlying concepts and presenting the Reuseware Composition Framework. We walk through an example based on Xcerpt, a Semantic Web query language.
Harmless Metamodel Extensions with Triple Graph Grammars
Proc. of 5th International Fujaba Days (2007)
With Tobias Haupt
Designing Domain Specific Languages through metamodeling is an emerging engineering technique in software development. Language development, however, is also always tool developmentâwhich can be costly when languages are developed from scratch. Costs can be saved by developing new languages as extensions of existing onesâeffectively by extending metamodels. Here, existing tools, developed for the existing language, can be reused to a certain degree. We argue that a certain group of metamodel extension is harmless: keeping existing tools functional, while integrating new tools to handle additional functionalities. To realize a platform for this, two things are required: 1) a transformation engine for the metamodel extension and 2) a synchronization mechanism for tool integration. In this paper we show how Triple Graph Grammars can be used to define both and introduce an interpreter for these grammars that works in an environment based on the Eclipse Modeling Framework.
Aspect-Orientation for Your Language of Choice
Proc. of 11th International Workshop on Aspect-Oriented Modeling (AOM@MoDELSâ07) (2007)
With Florian Heidenreich and Steffen Zschaler
Modern software development uses lots of so-called domain-specific languages (DSLs), providing domain-specific abstractions as a means to cope with the increasing complexity of modern software systems. While such languages are developed with a strong focus on the domain issues they are to address, more technical considerations of language engineering are typically left out. This can become problematic when the size of descriptions or programs in such a DSL increases, leading eventually to a need for advanced modularisation techniques, such as aspect orientation. To counter the complexities involved in designing modularisation for every new DSL, this paper shows a generic approach for implementing aspect orientation for arbitrary languages. The approach is especially useful for declarative DSLs, but can be used for other languages as well.
Source Code Composition with the Reuseware Composition Framework
Proc. of 7th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAMâ07) (2007)
The Reuseware Composition Framework is a tool-supported framework that aids developers of new composition techniques with integrating them into programming languages. In this tool demo proposal we explain the usage and benefits of the framework by defining an extension of the Java language.
How dark should a component black-box be? The Reuseware Answer
Proc. of 12th International Workshop on Component-Oriented Programming (WCOPâ07) (2007)
With Jakob Henriksson, Florian Heidenreich, Steffen Zschaler, and Uwe AĂmann
Short answer: Jet-black with plenty of holes, some of which are not visible to everyone. Long answer: ...
Modular Web Queries â From Rules to Stores
Proc. of 3rd International Workshop on Scalable Semantic Web Knowledge Base Systems (SSWSâ07) (2007)
With Jakob Henriksson, Florian Heidenreich, Steffen Zschaler, and Uwe AĂmann
Even with all the progress in Semantic technology, accessing Web data remains a challenging issue with new Web query languages and approaches appearing regularly. Yet most of these languages, including W3C approaches such as XQuery and SPARQL, do little to cope with the explosion of the data size and schemata diversity and richness on the Web. In this paper we propose a straightforward step toward the improvement of this situation that is simple to realize and yet effective: Advanced module systems that make partitioning of (a) the evaluation and (b) the conceptual design of complex Web queries possible. They provide the query programmer with a powerful, but easy to use high-level abstraction for packaging, encapsulating, and reusing conceptually related parts (in our case, rules) of a Web query. The proposed module system combines ease of use thanks to a simple core concept, the partitioning of rules and their consequences in flexible âstoresâ, with ease of deployment thanks to a reduction semantics. We focus on extending the rule-based Semantic Web query language Xcerpt with such a module system though the same approach can be applied to other (rule-based) languages as well.
Invasive Software Composition Operators for the Semantic Web
Vdm Verlag Dr. MĂŒller, SaarbrĂŒcken, ISBN 978-3836471053 (2006)
Descriptions of data in the Semantic Web easily grow larger and more complex than the descriptions of traditional web pages and are thus more difficult to handle. In the traditional web, data is enriched with formatting information to be presented to the human reader. The Semantic Web calls for additional machine-readable semantic descriptions to enable computational agents to support a user in acquiring the desired data from the mass of available information. This poses new challenges to data maintainers who have to maintain an overview of complex data descriptions. They should be supported by tools to structure such complex sets of data in the most appropriate way for them and the data at hand...
Invasive Software Composition with EMF
Vdm Verlag Dr. MĂŒller, SaarbrĂŒcken, ISBN 978-3836467131 (2006)
Many of todayâs languages used in software engineering have bad built-in support for software composition. It is important for software engineering to provide languages and tools to define, reuse and compose software components. Still, many languages available today for programming, modeling, markup, scripting and rule writing do not support a proper way of defining components â a _component model_. They do not include concepts about how to compose components â a _composition language_ â and thus there are no tools for these languages to execute compositions â a _composition technique_. A component model, a composition language and a composition technique make up a _composition system_...
Integrating Fujaba and the Eclipse Modeling Framework
Proc. of 4th International Fujaba Days (2006)
With Uwe AĂmann, Sacha Berger, Francois Bry, Tim Fruche and Jakob Henriksson
With Fujaba4Eclipse the Fujaba Tool Suite is intergrated into the Eclipse Platform. Through this integration, Fujaba benefits from the stable and well-documented Eclipse infrastructure and from re-use of some Eclipse tools, such as the Graphical Editing Framework (GEF). Still, there are other powerful Eclipse technologies, which could be enabled in Fujaba. We show, how this can be done by the Eclipse Modeling Framework (EMF). More exactly, we demonstrate, how the EMFâs metamodel Ecore is used to define EMF-complient Fujaba metamodels. The benefit is twofold. First, Fujaba technologies (e.g., pattern recognition) can be applied to EMF models directly in Eclipse. Second, existing EMF-based tools and applications become applicable to Fujaba models.
