Nowadays, there is a great need for solutions capable of flexibly handling the uncertainty of the initial development phases and the constantly changing requirements, but at the same time providing a accurate, reliable, and efficient methodology to produce products. Designing at a high abstraction level can grant the flexibility needed, while classic coding/implementation methods are efficient at covering the small details. In practical cases, however, it is difficult to separate the two. Our mission is to create a new development methodology than can address this challenge. Dynamic modeling allows us to use the most appropriate abstraction level for each component without losing the ability to handle them as a whole unit. In practice this means that it is possible to connect highly detailed, implementation fragments and foggy, sketchy, initial visions of conceptual ideas. Refinement of the levels of abstraction of components can be applied separately. During refinement, the approach automatically enforces validation rules already set both at the level of components and the overall system. An important advantage of the approach is that design decisions are not represented by branches at the source management system, but as living parts of the system. We can always return to a decision point and continue down another path from there. Another advantage of the approach is that is can efficiently cover the communication of two or more systems by providing a common semantic model over them. Specialties of the systems can be modeled as refinement of the common abstract base and thus transformation rules are easy to implement. The approach is ideal for general-purpose frameworks that run and evolve continuously, without restart.
From a technical point of view, the approach consists of a language (D#), an interpreter based on GraalVM and Truffle and a Language Server Protocol (LSP) implementation. The LSP implementation enables to interact models from Visual Studio Code.
From the theoretical point of view, the approach is based on dynamic multi-layer metamodeling, which is able to describe not only the structure of the models, but their behavior and validation as well. Dynamic refers to the fact that behavior, mechanisms, and validation are all modeled. This also allows to create operations capable of changing (e.g. refactor) the implementation of others. DMLA consists of two major parts: The first part (the Core) defines the modeling structure, namely an abstract state machine and a set of connected functions that specify the transition logic between the states. The second part (the Bootstrap) is an initial set of modeling constructs, built-in model elements (e.g. built-in types) that are necessary to adapt the abstract modeling structure to practical applications. The Bootstrap also contains the formal definition of the precise instantiation mechanism via reified validation constructs. The two parts have been intentionally kept separate since the algebraic part is structurally self-contained and isolated from the peculiarities of the different Bootstraps. Hence, any particular Bootstrap genuinely seeds the concrete meta-modeling capabilities derived from the generic DMLA. This may be considered to be one of its most novel aspects when compared to the unlimited and universal modeling capability other approaches, like the potency notion provides at all meta-levels. In effect, the proper selection of Bootstrap entities fully determines the expressibility of DMLA's modeling capabilities available on lower meta-levels.
Contact: dmla (at) aut.bme.hu
MLMP is a validating, modular and general multi-level modeling playground built upon DMLA. Using MLMP, one can specify the underlying structure and semantics of multi-level constructs, like the different variants of the potency notion. This makes it possible to experiment with novel multi-level ideas without having to build the underlying tool chain. Notion specification is governed by our high level, textual domain-specific language, the Multi-Level Specification Language (MLSL). MLMP also supports the creation of domain models on which existing construct specifications can be tested and evaluated in practice.
The specification of several multi-level constructs along with the brief syntax definition of MLSL can be found at: https://github.com/bmeaut/MLMP