Logo des Repositoriums

Auflistung nach Schlagwort "model-driven engineering"

1 - 6 von 6
  • Konferenzbeitrag
    Assessing the Usefulness of a Visual Programming IDE for Large-Scale Automation Software
    (Software Engineering 2022, 2022) Wiesmayr, Bianca; Zoitl, Alois; Rabiser, Rick
    This is a summary of a paper (with the same title) that we published at the ACM/IEEE 24th International Conference on Model-Driven Engineering Languages and Systems (MODELS 2021) describing a study centered on a visual programming IDE for large-scale automation software development and maintenance.
  • Konferenzbeitrag
    Efficiency of Projectional Editing
    (Software Engineering und Software Management 2018, 2018) Berger, Thorsten; Voelter, Markus; Jensen, Hans Peter; Dangprasert, Taweesap; Siegmund, Janet
    Published at International Symposium on the Foundations of Software Engineering (FSE) 2016. Projectional editors are editors where a user's editing actions directly change the abstract syntax tree without using a parser. They promise essentially unrestricted language composition as well as flexible notations, which supports aligning languages with their respective domain and constitutes an essential ingredient of model-driven development. Such editors have existed since the 1980s and gained widespread attention with the Intentional Programming paradigm, which used projectional editing at its core. However, despite the benefits, programming still mainly relies on editing textual code, where projectional editors imply a very different --typically perceived as worse --editing experience, often seen as the main challenge prohibiting their widespread adoption. We present an experiment of code-editing activities in a projectional editor, conducted with 19 graduate computer-science students and industrial developers. We investigate the effects of projectional editing on editing efficiency, editing strategies, and error rates --each of which we also compare to conventional, parser-based editing. We observe that editing is efficient for basic-editing tasks, but that editing strategies and typical errors differ. More complex tasks require substantial experience and a better understanding of the abstract-syntax-tree structure—then, projectional editing is also efficient. We also witness a tradeoff between fewer typing mistakes and an increased complexity of code editing.
  • Konferenzbeitrag
    Experiences on Traceability and Consistency Checking across Engineering Tools in an Automation Solution Company
    (Software Engineering und Software Management 2018, 2018) Demuth, Andreas; Kretschmer, Roland; Tröls, Michael; Kanakis, Georgios; Maes, Davy; Egyed, Alexander
    The engineering of systems is unimaginable without software tools. Engineers use them to capture and analyze engineering problems; specify, implement, test, and maintain engineering solutions, and manage engineering processes. Yet, there is a gap between the capabilities of independently working engineers and the needs of a collaborative engineering team. The existing tool landscape emphasizes the former. Most engineering tools are single-user applications – often of excellent quality but limited in that they support the works of individual engineers and not that of a group of engineers. And herein lies one of the most fundamental problems of software and systems engineering. Engineers know well the engineering knowledge they capture but they often lack awareness of the many implications their work has on other engineers and/or other engineering domains. This is a problem because in today’s engineering projects, companies continuously have to adapt their systems to changing customer or market requirements. This requires a flexible, iterative development process in which different parts of the system under construction are built and updated concurrently. However, concurrent engineering is quite problematic in domains where different engineering domains and different engineering tools come together. In this paper, we discuss experiences with Van Hoecke Automation, a leading company in the areas of production automation and product processing, in maintaining the consistency between electrical models and the corresponding software controller when both are subject to continuous change. The paper discusses how we let engineers describe the relationships between electrical model and software code in form of links and consistency rules; and how through continuous consistency checking our approach then notified those engineers of the erroneous impact of changes in either electrical model or code.
  • Konferenzbeitrag
    Model-driven Engineering for Dynamic Data Structures
    (Softwaretechnik-Trends Band 42, Heft 4, 2022) Boockmann,Jan H.; Jacob, Kerstin; Lüttgen,Gerald
    Model-driven engineering (MDE) has become a key technology in such diverse fields as signal processing, control engineering and software engineering. Our research has adopted the MDE paradigm for the analysis of complex software involving dynamic data structures, e.g., of device driver managers that employ custom list structures. Here, the central model studied by us is logic predicates that describe data structure shapes. This paper highlights aspects of our research on how shape predicates can support a range of activities: automated code generation for defensive programming, visualization for program comprehension and test case generation and formal verification for quality assurance. We discuss the commonalities and differences to the MDE of control-intensive systems and outline how our test case generation approach may be adapted to complex object-oriented software.
  • Textdokument
    Towards Model-Driven Engineering for Quantum AI
    (INFORMATIK 2022, 2022) Moin,Armin; Challenger,Moharram; Badii,Atta; Günnemann,Stephan
    Over the past decade, Artificial Intelligence (AI) has provided enormous new possibilities and opportunities, but also new demands and requirements for software systems. In particular, Machine Learning (ML) has proven useful in almost every vertical application domain. In the decade ahead, an unprecedented paradigm shift from classical computing towards Quantum Computing (QC), with perhaps a quantum-classical hybrid model, is expected. We argue that the Model-Driven Engineering (MDE) paradigm can be an enabler and a facilitator, when it comes to the quantum and the quantum-classical hybrid applications. This includes not only automated code generation, but also automated model checking and verification, as well as model analysis in the early design phases, and model-to-model transformations both at the design-time and at the runtime. In this paper, the vision is focused on MDE for Quantum AI, particularly Quantum ML for the Internet of Things (IoT) and smart Cyber-Physical Systems (CPS) applications.
  • ConferencePaper
    Variability Representations in Class Models: An Empirical Assessment (Summary)
    (Software Engineering 2021, 2021) Strüber, Daniel; Anjorin, Anthony; Berger, Thorsten
    We present our paper originally published in the proceedings of the ACM/IEEE International Conference on Model Driven Engineering Languages and Systems 2020 (MODELS). Owing to the ever-growing need for customization, software systems often exist in many different variants. To avoid the need to maintain many different copies of the same model, developers of modeling languages and tools have recently started to provide representations for such variant-rich systems, notably variability mechanisms that support the implementation of differences between model variants. Available mechanisms either follow the annotative or the compositional paradigm, each of them having unique benefits and drawbacks. Language and tool designers select the used variability mechanism often solely based on intuition. A better empirical understanding of the comprehension of variability mechanisms would help them in improving support for effective modeling. In this paper, we present an empirical assessment of annotative and compositional variability mechanisms for class models. We report and discuss findings from an experiment with 73 participants, in which we studied the impact of the chosen variability mechanisms during model comprehension tasks. We find that, compared to the baseline of listing all model variants separately, the annotative technique did not affect developer performance. Use of the compositional mechanism correlated with impaired performance. For a subset of our tasks the annotative mechanism is preferred to the compositional one and the baseline. We present actionable recommendations concerning support of flexible, tasks-specific solutions, and the transfer of best established best practices from the code domain to models.