9,768 research outputs found
Emerging Topics in Textual Modelling
This is the final version. Available on open access via the link in this recordOCL 2019: Object Constraint Language and Textual Modeling 2019. 19th International Workshop in OCL and Textual Modeling (OCL 2019)
co-located with IEEE/ACM 22nd International Conference on Model Driven Engineering Languages and Systems (MODELS 2019), 16 September 2019, Munich, GermanyThe 19th edition of the OCL workshop featured a lightning talk session where authors were invited to present their recent work and open questions related to textual modeling in general and OCL in particular. These 5 minute presentations triggered fruitful discussions within the OCL community on the usage of textual modeling, model validation, and specific technical points of the OCL specification. This community paper provides an overview of the presented contributions (one per section), as well as a summary of the questions and discussions they have triggered during the session
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
Using an OCL Impact Analysis Algorithm for View-Based Textual Modelling
The Object Constraint Language (OCL) has become a vital part of many frameworks, tools and languages within model-driven engineering. One such application of OCL is the use for describing rules in concrete syntax definitions. Within the textual modeling framework FURCAS, OCL is extensively used for the definition of lookup and attribution rules. Based on these rules the model which is described by such a textual representation is created and updated accordingly. Changes on models over which such an expression is specified require the expression to be re-evaluated to keep the constructed model up-to-date. However, the effort for re-evaluating OCL expressions over a set of model elements grows with the number of elements, the complexity of the expressions, and the number of model changes. Thus, having large models and/or complex expressions places considerable performance costs on OCL evaluation. Techniques to reduce this effort have been presented in previous work but do not cover the full range of OCL expressions, in particular calls to operations defined in OCL, including recursive operations. In this paper, we present an approach that is applicable to the full range of OCL expressions. We validated our approach based on a large set of models and complex expressions to evaluate the performance impact of our newly introduced techniques
Translating between Alloy specifications and UML class diagrams annotated with OCL
Model-driven engineering (MDE) is a software engineering approach based on model transformations at different abstraction levels. It prescribes the development of software by successively transforming the models from abstract (specifications) to more concrete ones (code). Alloy is an increasingly popular lightweight formal specification language that supports automatic verification. Unfortunately, its widespread industrial adoption is hampered by the lack of an ecosystem of MDE tools, namely code generators. This paper presents a model transformation from Alloy to UML class diagrams annotated with OCL (UML+OCL) and shows how an existing transformation from UML+OCL to Alloy can be improved to handle dynamic issues. The proposed bidirectional transformation enables a smooth integration of Alloy in the current MDE contexts, by allowing UML+OCL specifications to be transformed to Alloy for validation and verification, to correct and possibly refine them inside Alloy, and to translate them back to UML+OCL for sharing with stakeholders or to reuse current model-driven architecture tools to refine them toward code.This work was funded by European Regional Development Fund (ERDF) through the COMPETE Programme (operational program for competitiveness) and by national funds through the FCT (Fundaaco para a Ciencia e a Tecnologia-portuguese Foundation for Science and Technology) within project FCOMP-01-0124-FEDER-020532. Part of the work was done while the first author was visiting the Software Design Group at CSAIL, MIT, USA, funded by FCT sabbatical grant SFRH/BSAB/1187/2011. The second author was also partially supported by QREN (the portuguese National Strategy Reference Chart) project 1621, while visiting the High-Assurance Software Laboratory at Universidade do Minho, Portugal. Finally, we would also like to thank all anonymous reviewers for the valuable comments and suggestions
Synthesis of OCL Pre-conditions for Graph Transformation Rules
Proceedings of: Third International Conference on Model Transformation (ICMT 2010): Theory and Practice of Model Transformation. Málaga, Spain, 28 June-02 July, 2010Graph transformation (GT) is being increasingly used in Model Driven Engineering (MDE) to describe in-place transformations like animations and refactorings. For its practical use, rules are often complemented with OCL application conditions. The advancement of rule post-conditions into pre-conditions is a well-known problem in GT, but current techniques do not consider OCL. In this paper we provide an approach to advance post-conditions with arbitrary OCL expressions into pre-conditions. This presents benefits for the practical use of GT in MDE, as it allows: (i) to automatically derive pre-conditions from the meta-model integrity constraints, ensuring rule correctness, (ii) to derive pre-conditions from graph constraints with OCL expressions and (iii) to check applicability of rule sequences with OCL conditions.Work funded by the Spanish Ministry of Science and Innovation through projects “Design and construction of a Conceptual Modeling Assistant” (TIN2008-00444/TIN - Grupo Consolidado), “METEORIC” (TIN2008-02081),mobility grants JC2009-00015 and PR2009-0019, and the R&D program of the Community of Madrid (S2009/TIC-1650, project “e-Madrid”).Publicad
Tool Paper: A Lightweight Formal Encoding of a Constraint Language for DSMLs
International audienceDomain Specific Modeling Languages (dsmls) plays a key role in the development of Safety Critical Systems to model system requirements and implementation. They often need to integrate property and query sub-languages. As a standardized modeling language, ocl can play a key role in their definition as they can rely both on its concepts and textual syntax which are well known in the Model Driven Engineering community. For example, most dsmls are defined using mof for their abstract syntax and ocl for their static semantics as a metamodeling dsml. OCLinEcore in the Eclipse platform is an example of such a metamodeling dsml integrating ocl as a language component in order to benefit from its property and query facilities. dsmls for Safety Critical Systems usually provide formal model verification activities for checking models completeness or consistency, and implementation correctness with respect to requirements. This contribution describes a framework to ease the definition of such formal verification tools by relying on a common translation from a subset of ocl to the Why3 verification toolset. This subset was selected to ease efficient automated verification. This framework is illustrated using a block specification language for data flow languages where a subset of ocl is used as a component language
Practical verification strategy for refinement conditions in UML models
This paper presents an automatic and simple method for creating refinement condition for UML models. Conditions are fully written in OCL, making it unnecessary the application of mathematical languages which are in general hardly accepted to software engineers. Besides, considering that the state space where OCL conditions are evaluated might be too large (or even infinite), the strategy of micromodels is applied in order to reduce the search space. The overall contribution is to propitiate the performing of verification activities during the model-driven development process.1st International Workshop on Advanced Software Engineering: Expanding the Frontiers of Software Technology - Session 2: Software ModelingRed de Universidades con Carreras en Informática (RedUNCI
Practical verification strategy for refinement conditions in UML models
This paper presents an automatic and simple method for creating refinement condition for UML models. Conditions are fully written in OCL, making it unnecessary the application of mathematical languages which are in general hardly accepted to software engineers. Besides, considering that the state space where OCL conditions are evaluated might be too large (or even infinite), the strategy of micromodels is applied in order to reduce the search space. The overall contribution is to propitiate the performing of verification activities during the model-driven development process.1st International Workshop on Advanced Software Engineering: Expanding the Frontiers of Software Technology - Session 2: Software ModelingRed de Universidades con Carreras en Informática (RedUNCI
Translating alloy apecifications to UML class diagrams annotated with OCL
Proceedings of the 9th International Conference on Software Engineering and Formal MethodsModel-Driven Engineering (MDE) is a Software Engineering approach based on model transformations at different abstraction levels. It prescribes the development of software by successively transforming models from abstract (specifications) to more concrete ones (code). Alloy is an increasingly popular lightweight formal specification language that supports automatic verification. Unfortunately, its widespread industrial adoption is hampered by the lack of an ecosystem of MDE tools, namely code generators. This paper presents a model transformation between Alloy and UML Class Diagrams annotated with OCL. The proposed transformation enables current UML-based tools to also be applied to Alloy specifications, thus unleashing its potential for MDE
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
- …