MontiGem - Generating Enterprise Management Systems

Summary of Most Relevant Topic Papers

MontiGem [AMN+20a] is a generator for data-centric applications. To a large extent, it uses standard models from UML/P as sources, namely, Class Diagrams and OCL. While the standard semantics of these modeling languages remains untouched, the generator produces a lot more functionality around these models, because it is well integrated into the target framework and target infrastructure which is used to execute the enterprise management system. The generator thus knows the backend technology stack, with an application core in Java, storage using a relational database and the frontend consisting of Typescript components based on Angular and thus running in the browser.

The generator creates custom data structures based on the input models and domain dependent target code within each layer of the three tier architecture of the target application. The generated source code includes database configurations for the persistence tier, permission checks and APIs for the application tier and user interfaces for the presentation tier. As a highlight, the storage paradigm is based on the command pattern that allows to merge current changes much better and thus allows an optimistic update scheme.

As an extension, a DSL is used to describe the graphical layout of the user interface in a comfortable way. The GUI sub-language is well integrated with the class diagram models allowing to directly describe what to visualize based on the storage structure in the database.

The internal architecture of the MontiGem generator includes the three typical main processes: reading, transformation and generation, while generation produces a lot of resulting Java classes, Typescript and HTML files and related artifacts.

The whole generation is designed in a very extensible way: First, a generator target itself is written in a modular way allowing to reuse parts in a rather independent way. Secondly, templates are used allowing developers to add functionality in the systematic manner. They can, e.g., add additional methods to all generated classes of certain kind. Thirdly, the TOP mechanism created in MontiCore [HKR21] is applied for all kinds of creative classes allowing to efficiently add handwritten code extensions to the generated classes, while fully retaining the ability to intentionally re-generate everything every time. For that purpose, all classes are also equipped with builders, which can be replaced using the TOP mechanism if required.

Thus, handwritten and generated code pieces are well integrated [GHK+15a]. This enables the continuous regeneration of the application with changing models and thus the co-evolution of the models and the handwritten additional functionality during the entire development process.

The input of the generator for such enterprise management systems can be expanded to allow the tagging of existing models [GLRR15], e.g., for the definition of roles and rights, as well as model-based testing [DGH+18].

We have developed an extension for MontiGem called CD2GUI [GMN+20] which can be used before code synthesis: The generation process takes only one class diagram as input and generates data and GUI models which are further processed by the MontiGem generator framework into a running application.

MontiGem builds on earlier versions of generators for information systems. Together with MontiGem, they are already in use for generating various applications, such as a library system and an development artifact overview system. MontiGem is used since several years in a real-world project for financial management [GHK+20], where we apply an agile model-based software engineering approach. We use it in research projects on privacy-preserving information systems [MNRV19], for energy management systems, for creating digital twin cockpits [DMR+20] and process-aware digital twin cockpits [BMR+22], for the parameter management during the engineering process of wind turbines, and goal modeling in assistive systems [MRV20]. Current extensions adapt and extend MontiGem for mobile applications, further graphical representation components as well as the development of information portals in the Internet of Things domain.

We have investigated how to retrofit model-driven methods into brown-field applications, so applications which already exist [DGM+21]. Our 16-step methodology can be applied throughout the 3 phases of the development process: problem analysis, language engineering, and application engineering.

Key Statements

1. We can generate data-centric applications from UML/P class diagrams
2. Such generators are well usable in agile development approaches and for real-world applications
3. Generators for information systems are highly reusable for a large variety of domains

Selected Topic-Specific Publications

Related Topics

• Agile Model-Based Software Engineering
• Generative Software Engineering
• MontiCore - Language Workbench
• UML/P
• Unified Modeling Language (UML)
• Model-Based Assistive Systems
• Models in Enterprise Information System Development
• Digital Twins and Digital Shadows in Engineering, Operation and Production

Further links:

• Publications
• Topic sorted list of most interesting publications
• Books
• Aachener Informatik-Berichte, Software Engineering / Ph.D. Theses
• Website of the SE