Mario Fuksa

Abstract

Many enterprise software systems provide complex Graphical User Interfaces (GUIs) that need robust architectural patterns for well-structured software design. However, popular GUI architectural patterns like Model-View-ViewModel (MVVM) often lack detailed implementation guidance, leading GUI developers to inappropriately use the pattern without a comprehensive overview of design variants and often-mentioned trade-offs. Therefore, this paper presents an extensive review of MVVM design aspects and trade-offs, extending beyond the standard MVVM definition. We conducted a multivocal literature review (MLR), including white and gray literature, to cover essential knowledge from blogs, published papers, and other unpublished formats like books. Using the standard MVVM definition as a baseline, our study identifies (1) 76 additional design constructs grouped into 29 design aspects and (2) 16 additional benefits and 15 additional drawbacks. These insights can guide enterprise application developers in implementing practical MVVM solutions and enable informed design decisions.

Abstract

Domain-specific Languages (DSLs) assist in building complex software systems across various domains by creating models that are interpreted or transformed into executable code. Language developers face a tedious and error-prone process when transforming such models directly into multiple target General-Purpose Programming Languages (GPLs) like Java and C++, requiring them to write DSL-specific transformations redundantly multiple times. Using intermediate languages can reduce this redundancy by enabling language developers to write DSL-specific transformation logic only once. Despite its potential, no approach currently uses the Action Language for Foundational UML (ALF) as an intermediate language to transform tailored DSLs within an industry-strength workbench for designing projectional languages. To address this, we develop ALFI as a prototypical implementation of ALF in Jet-Brains MPS and implement MPS transformations from ALFI to Java and C++. We develop two exemplary DSLs to demonstrate the transformation chains that transform tailored DSLs into ALFI and then into executable Java and C++ code. The prototypical ALFI implementation successfully demonstrates the use of ALF as an intermediate language, enabling the model transformation of DSLs into multiple target GPLs.

Abstract

Automated GUI testing is widely used in practice to ensure high software quality. While current tools and methods support automatic GUI testing, open challenges exist, like specification efforts, fragility problems, and maintainability difficulties. To tackle those challenges, we have proposed the complementary approach ViMoTest as a preliminary concept. The ViMoTest approach aims to automate GUI tests with behavior-oriented test specifications based on ViewModel-abstractions and projectional DSLs to address those open challenges. However, no empirical ev-idence shows the applicability of automated GUI testing with the combination of ViewModels and projectional DSLs. Therefore, we develop a prototypical implementation using JetBrains MPS, extending our preliminary ViMoTest concept as proof of concept. Through a field study for which we applied our prototype to five real-world subject applications, we could show the applicability of our approach with 17 exemplary ViewModels. We successfully modeled 11 standard GUI widgets as first-class constructs and used them in 38 test scenarios in our projectional DSLs. Our field study indicates that the ViMoTest approach is applicable to support test developers in testing the view logic independent of specific GUI frameworks and rendering aspects.

Abstract

Automated testing for software is a fundamental part of achieving high-quality software systems. In particular, the user interface (UI) is one suitable abstraction layer for automated tests. However, software test developers usually spend considerable effort writing automated UI tests in a maintainable way. Therefore, this work proposes a concept to design a low code approach using the ViewModel architectural pattern as an abstraction layer to develop automated UI tests. We use the Design Science Research method to design a projectional DSL as an artifact to refine our approach. As planned results, we aim to (1) develop a projectional DSL to specify ViewModel-based tests, (2) apply this novel approach in an industrial and an open-source project, and (3) perform empirical studies to get feedback for improving this approach w.r.t. creation, maintenance, and understandability of test suites. We conclude that a low code approach using a projectional DSL to specify automated tests based on ViewModels could have several benefits compared to similar approaches.

Abstract

Model-driven software development (MDSD) aims at the total or partial generation of software systems from instances of Domain-specific Languages (DSLs). However, teaching MDSD often suffers from small, comprehensible systems which can be understood easily but are not entirely artificial. In teaching programming, so-called mini programming worlds (MPWs) play the role of small, easy-to-comprehend but still realistic systems. In teaching MDSD, on the contrary, toy examples are often used based on well-known examples like UML2RDBMS. In this paper, we present our approach to transferring the idea of using MPWs to teach MDSD. We have developed a full-fledged MDSD project to model new MPWs and generate code for them in the two supported programming languages C++ and Java. We will use both simulators in our introductory programming courses.

Abstract

Teaching programming can be performed in many different ways, such as focusing on object-oriented concepts in first place combined with mini-worlds like the hamster simulator. At the University of Stuttgart, such a solution is provided with the focus on teaching Java. But now the need to teach C++ in a similar way is also intended. To solve this necessity, a model-driven solution is proposed to model mini-worlds and generate code into multiple programming languages like Java or C++. The proposed solution covers requirements based on the existing approaches relevant for teaching programming at the University of Stuttgart at the Institute of Software Engineering. Based on these requirements, a modeling environment is designed which provides a framework part and a concrete mini-world simulator part. Technically, the modeling environment is based on the Eclipse platform and makes use of research related tooling for input modeling, model-to-model transformations and code generation. Generated simulators are based on a modular architecture, which enables high automation for tests and independence of concrete third-party frameworks. Further, the interface provided for students is based on object-oriented principles and contract-based design, including formalized pre- and postconditions defined for commands. By providing a metamodel to define mini-worlds in a generic way, the proposed solution can be adapted for modeling of different mini-worlds. In addition, a code generator is developed to transform adjusted intermediary models to concrete source code. By achieving that most complexity is handled by model-to-model transformations, this allows also to adapt the solution for further programming languages. Finally, different aspects for the proposed solution are evaluated. On the one hand, the combination of object-oriented teaching concepts with model-driven software development is evaluated. On the other hand, the use of existing ideas such as the generation of graph transformations at Fujaba or technologies such as Henshin is discussed. The functionality of the solution is shown by adapting it to the Java and C++ programming languages. Furthermore, another mini-world is adapted in addition to the hamster simulator with Kara the ladybug.