Modeling in the large: model libraries

Jeff Gray, Bernhard Rumpe
2021 Journal of Software and Systems Modeling  
Modeling in the Large is a key concept that is vital toward addressing the growing complexity and organizational requirements that are faced by developers when applying modeling techniques to real-world problems. For the most simple products, it is usually not necessary to define and follow a complicated formal development process. Modeling is particularly beneficial if the product is complex, comes in many different variants, or if the product is for a highly regulated domain (e.g., safety and
more » ... security regulations). In these cases, one model cannot describe the whole product, but many models are needed to define multiple interacting concerns, often requiring several different languages to describe various aspects and viewpoints of the products or parts of the system under development. A modeling approach for software and systems engineering naturally needs to cope with many models that are related to each other. Research at the intersection of programming languages and software engineering has articulated the benefits of a clear and sound modularity concept to contain the complexity of various decompositions that are essential for programming of large systems. A key insight from these findings is that programming modules (e.g., modules, classes, packages) are more reusable if they are selfcontained with clear boundaries (i.e., interfaces). This idea was even promoted in the earliest discussions of software reuse when Doug McIlroy introduced the concept of software components and reuse in the late 1960s. The concept of modular reasoning also facilitates a discussion about the correctness of a module without having to understand every detail specified in other parts of the system. Reusability and effectiveness of interface design have allowed us to design software more quickly and with higher quality. In fact, at the past annual MODELS and AOSD conferences, several SoSyM editors organized over 15 instances of the "Workshop on Aspect-Oriented Modeling" to address these core issues, even though aspects have not proven to be as modular for all modeling approaches. Thus, a good modeling language should also offer techniques to define models in a modular and reusable way. If the reuse of models can be standardized in specific domains, then model-based software and systems engineering will progress with even more breakthroughs. The advent of model libraries will allow us to come up with good, modelbased designs in early phases of development. It cannot be stated more emphatically: Modeling languages need to encourage modularity of their artifacts. Only then can reusable models be organized in model libraries. However, this goal is difficult to achieve. It took a number of years to understand how to design programming languages with a good modularization concept. With the heterogeneity of models and modeling languages, this concept of modularization is even more complicated. Technically, there are advantages in connecting models in the same way as programs: There is usually an explicit "import" or "include" statement that references other dependencies. When expressing such dependencies, the symbols and resources defined in the imported models are available in the importing model. Java has a precise understanding of similar concepts; namely, classes, interfaces, methods, and attributes are exported symbols. As an example comparison, state machines can export and reuse states and triggers as symbols. However, many aspects in the interplay between state machines and other types of models are unclear in current modeling languages, such as UML and SysML. For example, how are the symbols in one model represented and imported as states in a state machine? Or, are the states defined in the state machine and exported to other models (and programmed pieces of code)? Or a third option, are state names defined locally and not exported at
doi:10.1007/s10270-021-00887-w fatcat:avnfxo7zxnfhxm6uri3ud4nkdq