8,756 research outputs found
Requirements Analysis for an Integrated OCL Development Environment
An Integrated OCL Development Environment (IDE4OCL) can significantly improve the pragmatics and praxis of OCL. We present the domain concepts, toolâlevel interactions with OCL and the use cases we identified in a systematic analysis of requirements for an IDE4OCL. The domain concepts is an important contribution of our work as it attempts to clarify inconsistencies in the relevant specifications. Because OCL is not a standâalone language, the OCL landscape includes several interacting tools including an IDE4OCL. The use cases describe our vision of the desired functionality unique to an IDE4OCL. The results of our analysis and the long term vision of our work should be relevant to developers of OCL tools as well as to the OMG Request for Information regarding the UML Futures1. Our work is relevant to the UML Futures Roadmap because providing OCL for the constraints in the UML specification has been a longstanding problem at the OMG
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
An Institutional Framework for Heterogeneous Formal Development in UML
We present a framework for formal software development with UML. In contrast
to previous approaches that equip UML with a formal semantics, we follow an
institution based heterogeneous approach. This can express suitable formal
semantics of the different UML diagram types directly, without the need to map
everything to one specific formalism (let it be first-order logic or graph
grammars). We show how different aspects of the formal development process can
be coherently formalised, ranging from requirements over design and Hoare-style
conditions on code to the implementation itself. The framework can be used to
verify consistency of different UML diagrams both horizontally (e.g.,
consistency among various requirements) as well as vertically (e.g.,
correctness of design or implementation w.r.t. the requirements)
Model-driven design, simulation and implementation of service compositions in COSMO
The success of software development projects to a large extent depends on the quality of the models that are produced in the development process, which in turn depends on the conceptual and practical support that is available for modelling, design and analysis. This paper focuses on model-driven support for service-oriented software development. In particular, it addresses how services and compositions of services can be designed, simulated and implemented. The support presented is part of a larger framework, called COSMO (COnceptual Service MOdelling). Whereas in previous work we reported on the conceptual support provided by COSMO, in this paper we proceed with a discussion of the practical support that has been developed. We show how reference models (model types) and guidelines (design steps) can be iteratively applied to design service compositions at a platform independent level and discuss what tool support is available for the design and analysis during this phase. Next, we present some techniques to transform a platform independent service composition model to an implementation in terms of BPEL and WSDL. We use the mediation scenario of the SWS challenge (concerning the establishment of a purchase order between two companies) to illustrate our application of the COSMO framework
Model-driven description and validation of composite learning content
Authoring of learning content for courseware systems is a complex activity requiring the combination of a range of design and validation techniques. We introduce the CAVIAr courseware models allowing for learning content description and validation. Model-based representation and analysis of different concerns such as the subject domain, learning context, resources and instructional design used are key contributors to this integrated solution. Personalised learning is particularly difficult to design as dynamic configurations cannot easily be predicted and tested. A tool-supported technique based on CAVIAr can alleviate this complexity through the validation of a set of pedagogical and non-pedagogical requirements. Courseware validation checks intra- and inter-content relationships and the compliance with requirements and educational theories
Clafer: Lightweight Modeling of Structure, Behaviour, and Variability
Embedded software is growing fast in size and complexity, leading to intimate
mixture of complex architectures and complex control. Consequently, software
specification requires modeling both structures and behaviour of systems.
Unfortunately, existing languages do not integrate these aspects well, usually
prioritizing one of them. It is common to develop a separate language for each
of these facets. In this paper, we contribute Clafer: a small language that
attempts to tackle this challenge. It combines rich structural modeling with
state of the art behavioural formalisms. We are not aware of any other modeling
language that seamlessly combines these facets common to system and software
modeling. We show how Clafer, in a single unified syntax and semantics, allows
capturing feature models (variability), component models, discrete control
models (automata) and variability encompassing all these aspects. The language
is built on top of first order logic with quantifiers over basic entities (for
modeling structures) combined with linear temporal logic (for modeling
behaviour). On top of this semantic foundation we build a simple but expressive
syntax, enriched with carefully selected syntactic expansions that cover
hierarchical modeling, associations, automata, scenarios, and Dwyer's property
patterns. We evaluate Clafer using a power window case study, and comparing it
against other notations that substantially overlap with its scope (SysML, AADL,
Temporal OCL and Live Sequence Charts), discussing benefits and perils of using
a single notation for the purpose
- âŚ