Ana Maria Şutîi

Bio: Ana Maria Şutîi is an academic researcher from Eindhoven University of Technology. The author has contributed to research in topics: Modular design & Modularity (networks). The author has an hindex of 3, co-authored 8 publications receiving 51 citations.

Modularity and reuse of domain-specific languages:an exploration with MetaMod

Abstract: ions, one could argue that there is another kind of abstraction in these higherlevel programming languages. The other kind of abstraction can be best illustrated with object-oriented programming (OOP) [103] in Java. This kind of abstraction lives in the mind of the beholder (user), not in the language itself. When programming in Java, for instance, the user understands certain predefined classes as abstractions and subsequently uses them as such, rather than as features of the programming language. Consider, for instance, class ‘Animal’ with methods ‘eat’ and ‘sleep’. The user can treat the ‘Animal’ class as an abstraction of a real animal, and methods ‘eat’ and ‘sleep’ as an abstraction of the actions the animal can perform. Nonetheless, these abstractions are intertwined with general-purpose abstractions such as overloading, overriding, virtual functions, etc. This intertwining breaks the illusion of programming using concepts from the problem space. A similar argument holds for other mechanisms, such as software libraries. Moreover, these ‘in-language’ abstractions, in languages like Java, do not provide domain-specific optimizations or static error checks that DSLs can provide. Abstractions of the problem space [124] itself would help in closing the aforementioned gap because concepts in programming languages would be concepts from the application domain itself (train, station, etc.). There are new methodologies that advocate the introduction of abstractions of the problem space in the programming languages. Two of these methodologies are model-driven engineering (MDE) and language-oriented programming (LOP). Model-driven engineering advocates to raise the level of abstraction through the use of models (abstract representations of the real world) in software development and it uses, among others, domain-specific languages (DSLs) and code generators to achieve its goal [124]. The goal of MDE and the means to achieve it relate to language-oriented programming. LOP advocates the creation and application of domain-specific languages to express solutions in various domains [39, 51, 162]. In particular, when given a new problem, a DSL engineer1 creates one or more DSLs (if these DSLs do not already exist) that a DSL user2 employs to express the solution. This solution is expressed at a higher level of abstraction, using concepts from the problem domain itself. The solution can be subsequently transformed to executable code as well. In MDE parlance, the central language aspect3 of a DSL is the metamodel. The metamodel describes the kinds of nodes and edges possible in a graph data structure that contains all the relevant information from a program; this graph data structure is called the abstract syntax. The metamodel itself consists of concepts (equivalent to the nodes) and relations (equivalent to the edges) between these concepts. Besides the metamodel, a DSL also involves processing units4, which take models conforming to the metamodel as input and produce something useful from them as output, such as executable code or visualizations. A processing unit can be related to any of the following language aspects: static semantics, interpretation, code generation (more generally, model transformations), editor, etc. Thus, a processing unit implements a language aspect. It is the metamodel and its associated processing units that the DSL engineer needs to provide for a complete definition of a DSL. Traditionally, the creation of a DSL was a time-consuming endeavor. Fortunately, their development has been eased with the introduction of specialized environments called 1The DSL engineer is a software developer responsible for implementing DSLs. 2The DSL user is a person (ideally domain expert) using a DSL. 3A language aspect is a constituent part of the definition of a DSL (e.g., code generation, constraints, editor, etc.). 4Note that the term processing unit is a term that we introduced.

Metamodel-independent modularisation of models with MetaMod

Abstract: In today’s landscape of more and more software-driven functionalities, spanning more and more fields, model-driven engineering (MDE) promises to ease the development of software. To accomplish this goal, MDE employs domain-specific languages (DSLs). The problem is that, on one hand, DSLs are not easy to create, and, on the other hand, as a result of the increased software-driven functionalities, they need to deal with bigger models. In dealing with these big models, modularity mechanisms are employed regularly by DSLs. These mechanisms need to be introduced over and over again into the developed DSLs, adding to the effort of creating them. To ease the development of DSLs, we propose to introduce a modularisation of models that is independent of the DSLs. We do so via two mechanisms, groups and fragment abstractions, that comprise many modularity use cases found in DSLs. These two mechanisms have been implemented in a prototype tool, MetaMod.

MetaMod: a modeling formalism with modularity at its core

Abstract: Because modern engineering products require more and more functionality, the models used in the design of these products get larger and more complex. A way to handle this complexity would be a suitable mechanism to modularize models. However, current approaches in the Model Driven Engineering field have limited support for modularity. This is the gap that our research addresses. We want to tackle the gap by designing and creating a modeling formalism with modularity at its core - MetaMod. We are including the modeling formalism into a prototype such that we can experiment with it. Our evaluation plan includes bootstrapping MetaMod (defining MetaMod in MetaMod) and creating an industrial DSL in MetaMod.

Modular multilevel metamodeling with MetaMod

Abstract: The increase of software driven functionalities in products leads to more complex software. Helping with the construction of this complex software, models in model-driven engineering have become larger and more complex. As a consequence, the models are harder to understand and the need to reuse models is augmented. Given these two goals: increasing understandability and reuse of models, and inspired by modular programming in the realm of general software development and its role in fulfilling these goals (among others), we set to explore modularity mechanisms for models. Although work has been done to address the issue of modularity in models, there is no commonly agreed method for doing it. Ours is an attempt to discover the basic modularity elements for models. We have done this in the context of a simple multilevel metamodeling language that we designed, MetaMod, where we introduced a few modularity mechanisms: groups, fragment abstractions and applications. To test the feasibility of our ideas, we created a prototype of this language and a few exploratory examples in the language.

Model Driven Engineering

Abstract: The Object Management Group's (OMG) Model Driven Architecture (MDA) strategy envisages a world where models play a more direct role in software production, being amenable to manipulation and transformation by machine. Model Driven Engineering (MDE) is wider in scope than MDA. MDE combines process and analysis with architecture. This article sets out a framework for model driven engineering, which can be used as a point of reference for activity in this area. It proposes an organisation of the modelling 'space' and how to locate models in that space. It discusses different kinds of mappings between models. It explains why process and architecture are tightly connected. It discusses the importance and nature of tools. It identifies the need for defining families of languages and transformations, and for developing techniques for generating/configuring tools from such definitions. It concludes with a call to align metamodelling with formal language engineering techniques.

Structured Design Fundamentals Of A Discipline Of Computer Program And Systems Design

Abstract: Thank you for reading structured design fundamentals of a discipline of computer program and systems design. As you may know, people have search hundreds times for their favorite novels like this structured design fundamentals of a discipline of computer program and systems design, but end up in harmful downloads. Rather than enjoying a good book with a cup of coffee in the afternoon, instead they juggled with some infectious bugs inside their computer.

Nominal Techniques and Black Box Testing for Automata Learning

Abstract: Using an adaptation of state-of-the-art algorithms for black-box automata learning, as implemented in the LearnLib tool, we succeeded to learn a model of the Engine Status Manager (ESM), a software component that is used in printers and copiers of Océ. The main challenge that we encountered was that LearnLib, although effective in constructing hypothesis models, was unable to find counterexamples for some hypotheses. In fact, none of the existing FSM-based conformance testing methods that we tried worked for this case study. We therefore implemented an extension of the algorithm of Lee & Yannakakis for computing an adaptive distinguishing sequence. Even when an adaptive distinguishing sequence does not exist, Lee & Yannakakis’ algorithm produces an adaptive sequence that “almost” identifies states. In combination with a standard algorithm for computing separating sequences for pairs of states, we managed to verify states with on average 3 test queries. Altogether, we needed around 60 million queries to learn a model of the ESM with 77 inputs and 3.410 states. We also constructed a model directly from the ESM software and established equivalence with the learned model. To the best of our knowledge, this is the first paper in which active automata learning has been applied to industrial control software. This chapter is based on the following publication: Smeenk, W., Moerman, J., Vaandrager, F. W., & Jansen, D. N. (2015). Applying Automata Learning to Embedded Control Software. In Formal Methods and Software Engineering 17th International Conference on Formal Engineering Methods, ICFEM, Proceedings. Springer. doi:10.1007/978-3-319-25423-4_5