OCL Tools Report based on the IDE4OCL Feature Model

Previously we have developed the idea of an Integrated Development Environment for OCL (IDE4OCL). Based on the OCL community's feedback we have also designed and published an IDE4OCL feature model. Here we present a report on selected OCL tools developed by the authors and their teams. Each author gives an overview of their OCL tool, provides a top level architecture, and gives an evaluation of the tool features in a web framework. The framework can also be used by other potential OCL users and tool developers. For users it may serve as an aid to choose a suitable tool for their OCL use scenarios. For tool developers it provides a comparative view for further development of the OCL tools. Our plans are to maintain the collected data and extend this web framework by further OCL tools. Additionally, we would like to encourage sharing of OCL development resources

Implementing a Debugger for Dresden OCL

Although originally designed as an extension for the Unifi ed Modeling Language (UML), today, the Object Constraint Language (OCL) has been broadly adopted in the context of both UML and other modeling and domain-specifi c languages. However, appropriate tooling, supporting modelers and software developers on using OCL is still scarce and lacks important features such as debugging support. As OCL constraints are likely to become rather complex for real world examples, it is hard to comprehend the in uence of single OCL expressions and subexpressions on the result of a completely evaluated OCL constraint in the context of speci fic constrained objects. Therefore, debugging is of topmost importance for both constraint comprehension and maintenance. Thus, the major task of this work is to develop a graphical debugger integrated into Dresden OCL and the Eclipse Integrated Development Environment (IDE) to fill this gap.:1 Introduction 2 The Dresden OCL Toolkit 2.1 The Dresden OCL Toolkit 2.2 The Dresden OCL2 Toolkit 2.3 Dresden OCL2 for Eclipse 2.4 Dresden OCL 3 The Eclipse Debugging Framework 3.1 The Debug Model 3.2 Interacting with the Debug Model 3.3 The Execution Control Commands 4 Requirements Analysis and Related Work 4.1 Requirements Analysis 4.2 Related Work 5 Design and Structure 5.1 Architecture 5.1.1 Package Structure 5.1.2 Class Structure 5.2 The OCL Debug Model 5.3 The Mapping from ASM to AST 5.4 The OCL Debugger 5.4.1 The Implementation of the Debugger 5.4.2 Testing the Debugger 6 Graphical User Interface Implementation 6.1 The Dresden OCL Debug Perspective 6.2 Using the Debugger 6.2.1 Selecting a Model 6.2.2 Selecting a Model Instance 6.2.3 Debugging 6.3 Summary 7 Evaluation and Future Work 33 7.1 Evaluation 7.2 Future Work 8 Summary and Conclusio

OCL-based Runtime Monitoring of JVM hosted Applications

In this paper we present an approach that enables users to monitor and verify the behavior of an application running on a virtual machine at the model level. Concrete implementations of object-oriented software usually contain a lot of technical classes. Thus, the central parts of an application, e.g., the business rules, may be hidden among peripheral functionality like user-interface classes or classes managing persistency. Our approach makes use of modern virtual machines and allows the devloper to profile an application in order to achieve an abstract monitoring and verification of central application components. We represent virtual machine bytecode in form of a so-called platform-aligned model (PAM) comprising OCL invariants and pre- and postconditions. In contrast to related work, our approach uses the original source or bytecode of the monitored application as it stands and does not require any changes. We show a prototype implementation as an extension of the UML and OCL tool USE. Also, we investigate the impact of our approach to the execution time of a monitored system

Avoiding OCL specification pitfalls

This paper discusses about teaching software modeling by using OCL specifications, in the context in which the web represents the main source of information. The raise of the interest for models induced a higher need for clear and complete specifications. In case of models specified by means of MOF-based languages, adding OCL constraints proved to be an interesting answer to this need. Several OCL examples posted on web include hasty specifications, that are often dissuasive with respect to complementing models with OCL specification. OCL beginners, and not only, need to know how to avoid potential specification traps.Our proposal is based on a complete and unambiguous description of requirements, that represents the first step towards good OCL specifications. The work highlights several major aspects that need to be understood and complied with to produce meaningful and efficient OCL specifications. This approach was tested while teaching OCL at Babes-Bolyai University of Cluj-Napoca

Step 0: An Idea for Automatic OCL Benchmark Generation

Model Driven Engineering (MDE) is an important software development paradigm. Within this paradigm, models and constraints are essential components for expressing specifications of a software artefact. Object Constraint Language (OCL), a specification language that allows users to freely express constraints over different model features. However, one major issue is that the lack of OCL benchmarks makes difficult to evaluate existing and newly created OCL tools. In this paper, we present our initial idea about automatic OCL benchmark generation. The purpose of this paper is to show a developing idea rather than presenting a more formal and complete approach. Our idea is to use an OCL metamodel to sketch abstract syntax trees for OCL expressions, and solve generated typing constraints to produce the concrete OCL expressions. We illustrate this idea by using an example, discuss our work-in-progress and outline challenges to be tackled in the future

On Formalizing UML and OCL Features and Their Employment to Runtime Verification

Model-driven development (MDD) has been identified as a promising approach for developing software. By using abstract models of a system and by generating parts of the system out of these models, one tries to improve the efficiency of the overall development process and the quality of the resulting software. In the context of MDD the Unified Modeling Language (UML) and its related textual Object Constraint Language (OCL) have gained a high recognition. To be able to generate systems of high quality and to allow for interoperability between modeling tools, a well-defined semantics for these languages is required. This thesis summarizes published work in this context that employs an endogenous metamodeling approach to define the semantics of newer elements of the UML. While the covered elements are exhaustively used to define relations between elements of the metamodel of the UML, the UML specification leaves out a precise definition of their semantics. Our proposed approach uses models, not only to define the abstract syntax, but also to define the semantics of UML. By using UML and OCL for this, existing modeling tools can be used to validate the definition. The second part of this thesis covers work on the usage of UML and OCL models for runtime verification. It is shown how models can still be used at the end of a software development process, i. e., after an implementation has manually been added to generated parts, even though they are not used as central parts of the development process. This work also influenced the integration of protocol state machines into a modeling tool, which lead to publications about the runtime semantics of state machines and the capabilities to declaratively specify behavior using state machines

Model Transformation Testing and Debugging: A Survey

Model transformations are the key technique in Model-Driven Engineering (MDE) to manipulate and construct models. As a consequence, the correctness of software systems built with MDE approaches relies mainly on the correctness of model transformations, and thus, detecting and locating bugs in model transformations have been popular research topics in recent years. This surge of work has led to a vast literature on model transformation testing and debugging, which makes it challenging to gain a comprehensive view of the current state of the art. This is an obstacle for newcomers to this topic and MDE practitioners to apply these approaches. This paper presents a survey on testing and debugging model transformations based on the analysis of \nPapers~papers on the topics. We explore the trends, advances, and evolution over the years, bringing together previously disparate streams of work and providing a comprehensive view of these thriving areas. In addition, we present a conceptual framework to understand and categorise the different proposals. Finally, we identify several open research challenges and propose specific action points for the model transformation community.This work is partially supported by the European Commission (FEDER) and Junta de Andalucia under projects APOLO (US-1264651) and EKIPMENT-PLUS (P18-FR-2895), by the Spanish Government (FEDER/Ministerio de Ciencia e Innovación – Agencia Estatal de Investigación) under projects HORATIO (RTI2018-101204-B-C21), COSCA (PGC2018-094905-B-I00) and LOCOSS (PID2020-114615RB-I00), by the Austrian Science Fund (P 28519-N31, P 30525-N31), and by the Austrian Federal Ministry for Digital and Economic Affairs and the National Foundation for Research, Technology and Development (CDG

A Catalog of Reusable Design Decisions for Developing UML/MOF-based Domain-specific Modeling Languages

In model-driven development (MDD), domain-specific modeling languages (DSMLs) act as a communication vehicle for aligning the requirements of domain experts with the needs of software engineers. With the rise of the UML as a de facto standard, UML/MOF-based DSMLs are now widely used for MDD. This paper documents design decisions collected from 90 UML/MOF-based DSML projects. These recurring design decisions were gained, on the one hand, by performing a systematic literature review (SLR) on the development of UML/MOF-based DSMLs. Via the SLR, we retrieved 80 related DSML projects for review. On the other hand, we collected decisions from developing ten DSML projects by ourselves. The design decisions are presented in the form of reusable decision records, with each decision record corresponding to a decision point in DSML development processes. Furthermore, we also report on frequently observed (combinations of) decision options as well as on associations between options which may occur within a single decision point or between two decision points. This collection of decision-record documents targets decision makers in DSML development (e.g., DSML engineers, software architects, domain experts).Series: Technical Reports / Institute for Information Systems and New Medi

Highlighting model elements to improve OCL comprehension

Models, metamodels, and model transformations play a central role in Model-Driven Development (MDD). Object Constraint Language (OCL) was initially proposed as part of the Unified Modeling Language (UML) standard to add the precision and validation capabilities lacking in its diagrams, and to express well-formedness rules in its metamodel. OCL has several other applications, such as defining design metrics, code-generation templates, or validation rules for model transformations, required in MDD. Learning OCL as part of a UML course at the university would seem natural but is still the exception rather than the rule. We believe that this is mainly due to a widespread perception that OCL is hard to learn, as gleaned from claims made in the literature. Based on data gathered over the past school years from numerous undergraduate students of di↵erent Software Engineering courses, we analyzed how learning design by contract clauses with UML+OCL compares with several other Software Engineering Body Of Knowledge (SWEBOK) topics. The outcome of the learning process was collected in a rigorous setup, supported by an e-learning platform. We performed inferential statistics on that data to support our conclusions and identify the relevant explanatory variables for students’ success/failure. The obtained findings lead us to extend an existing OCL tool with two novel features: one is aimed at OCL apprentices and goes straight to the heart of the matter by allowing to visualize how OCL expressions traverse UML class diagrams; the other is intended for researchers and allows to compute OCL complexity metrics, making it possible to replicate a research study like the one we are presenting.Modelos, metamodelos e transformações de modelo desempenham um papel central em MDD. OCL foi inicialmente proposta como parte da UML para adicionar os recursos de precisão e validação que faltavam nestes diagramas, e também para expressar regras de boa formação no metamodelo. OCL possui outras aplicações, tais como definir métricas de desenho, modelos de geração de código ou regras de validação para transformações de modelo, exigidas em MDD. Aprender OCL como parte de um curso de UML na universidade parecia portanto natural, não sendo no entanto o que se verifica. Acreditamos que isso se deva a uma percepção generalizada de que OCL é difícil de aprender, tendo em conta afirmações feitas na literatura. Com base em dados recolhidos em anos letivos anteriores de vários alunos de licenciatura de diferentes cursos de Engenharia de Software, analisámos como a aprendizagem por cláusulas contratuais de UML + OCL se compara a outros tópicos do SWEBOK. O resultado do processo de aprendizagem foi recolhido de forma rigorosa, apoiado por uma plataforma de e-learning. Realizámos estatísticas inferenciais sobre os dados para apoiar as nossas conclusões, de forma a identificar as variáveis explicativas relevantes para o sucesso / fracasso dos alunos. As conclusões obtidas levaram-nos a estender uma ferramenta OCL com duas novas funcionalidades: a primeira é voltada para os estudantes de OCL e permite visualizar como as expressões percorrem um diagrama de classes UML; a segunda é voltada para investigadores e permite calcular métricas de complexidade OCL, habilitando a réplica de um estudo semelhante ao apresentado