Configuration Knowledge Representation Using UML/OCL (original) (raw)
Related papers
Consistency-Preserving Model Evolution through Transformations
Lecture Notes in Computer Science, 2002
With model-based development being on the verge of becoming an industrial standard, the topic of research of statically checking the consistency of a model made up of several submodels has already received increasing attention. The evolution of models within software engineering requires support for incremental consistency analysis techniques of a new version of the model after evolution, thereby avoiding a complete reiteration of all consistency tests. In this paper, we discuss the problem of preserving consistency within model-based evolution focusing on UML-RT models. We introduce the concept of a model transformation rule that captures an evolution step. Composition of several evolution steps leads to a complex evolution of a model. For each evolution step, we study the effects on the consistency of the overall model and provide localized consistency checks for those parts of the model that have changed. For a complex evolution of a model, consistency can then be established by incrementally performing those localized consistency checks associated to the transformation rules applied within the evolution.
A Framework for Managing Consistency of Evolving UML Models
2005
Abstract As the standard for object-oriented analysis and design, the UML (Unified Modeling Language) metamodel, as well as contemporary CASE (Computer-Aided Software Engineering) tools, must provide adequate and integrated support for all essential aspects of software evolution. This includes version control, traceability, impact analysis, change propagation, inconsistency management, and model refactorings. This chapter focuses on the latter two aspects, and shows how tool support for these aspects can be provided.
Research Journal of Applied Sciences, Engineering and Technology, 2015
Software Configuration Management (SCM) aims to provide a controlling mechanism for software artifacts created during the software development lifecycle. Traditional SCM systems are file-centric and consider software systems as a set of text files. Today software development is model-centric. New challenges such as model diff, merge and evolution control arise while using models as central artifact, traditional systems are unable to resolve these challenges adequately. In its essence these challenges are mainly due to the inappropriate representation of models at fine-granular level by traditional systems. In this study we present a generic data model to represent model at fine-grain level. We use graph structures to represent models at fine-granular level, which is an intermediate representation based on graph theory. By transforming models into the graph structures we get several advantages. Firstly, we avoid several problems associated with textual representation of models. Secondly, we can handle different types of UML diagrams. Thirdly, it can be used to develop a generic model-based SCM framework, which provides model configuration management services for any UML model.
Maintaining Consistency between UML Models Using Description Logic
A software design is often modelled as a collection of UML diagrams. There is an inherent need to preserve their consistency, since these diagrams are subject to continuous changes due to successive refinements or evolutions. Contemporary UML tools provide unsat- isfactory support for maintaining the consistency between different versions of UML diagrams. To solve this problem, an extension of the UML metamodel is developed, and a classification of inconsistency problems is proposed. Detection and resolution of consistency conflicts is expressed by means of rules in description logic. By carrying out a number of concrete experi- ments, we show the feasibility of the description logic formalism for the purpose of maintaining consistency between evolving UML models.
Odyssey-SCM: An integrated software configuration management infrastructure for UML models
Science of Computer Programming, 2007
Model-driven development is becoming a reality. Different CASE tool vendors support this paradigm, allowing developers to define high-level models and helping to transform them into refined models or source code. However, current software configuration management tools use a file-based data model that is barely sufficient to manipulate source code. This file-based data model is not adequate to provide versioning capabilities for software modeling environments, which are strongly focused on analysis and architectural design artifacts. The existence of a versioned repository of high-level artifacts integrated with a customized change control process could help in the development and maintenance of such model-based systems. In this work, we introduce Odyssey-SCM, an integrated software configuration management infrastructure for UML models. This infrastructure is composed of a flexible version control system for fine-grained UML model elements, named Odyssey-VCS, and two complementary components: a customizable change control system tightly integrated with the version control system, and a traceability link detection tool that uses data mining to discover change traces among versioned UML model elements and provides the rationale of change traces, automatically collected from the integrated software configuration management infrastructure.
UML models consistency management: Guidelines for software quality manager
International Journal of Information Management, 2016
Unified Modeling Language (UML) has become the de-facto standard to design today's large-size object-oriented systems. However, focusing on multiple UML diagrams is a main cause of breaching the consistency problem, which ultimately reduces the overall software model's quality. Consistency management techniques are widely used to ensure the model consistency by correct model-to-model and model-to-code transformation. Consistency management becomes a promising area of research especially for model-driven architecture. In this paper, we extensively review UML consistency management techniques. The proposed techniques have been classified based on the parameters identified from the research literature. Moreover, we performed a qualitative comparison of consistency management techniques in order to identify current research trends, challenges and research gaps in this field of study. Based on the results, we concluded that researchers have not provided more attention on exploring inter-model and semantic consistency problems. Furthermore, state-of-the-art consistency management techniques mostly focus only on three UML diagrams (i.e., class, sequence and state chart) and the remaining UML diagrams have been overlooked. Consequently, due to this incomplete body of knowledge, researchers are unable to take full advantage of overlooked UML diagrams, which may be otherwise useful to handle the consistency management challenge in an efficient manner.
Using Description Logic to Maintain Consistency between UML Models
Lecture Notes in Computer Science, 2003
A software design is often modelled as a collection of UML diagrams. There is an inherent need to preserve consistency between these diagrams. Moreover, through evolution those diagrams get modified leading to possible inconsistency between different versions of the diagrams. State-of-the-art UML CASE tools provide poor support for consistency maintenance. To solve this problem, an extension of the UML metamodel enabling support for consistency maintenance and a classification of inconsistency problems is proposed. To achieve the detection and resolution of consistency conflicts, the use of description logic (DL) is presented. DL has the important property of being a decidable fragment of first-order predicate logic. By means of a number of concrete experiments in Loom, we show the feasibility of using this formalism for the purpose of maintaining consistency between (evolving) UML models.
Using a Formal Language Constructs for Software Model Evolution
IEEE Internet Computing, 2009
In this paper we present an automated support for software model evolution using a formal language constructs. For this, we extended Object Constraint Language (OCL) with actions to define a new language - CAL (Constraint with Action Language), which gives users the ability to evaluate objects change a-priori. We have added a data type, directed acyclic graph (DAG) to CAL to automate model evolution. DAG has been annotated (ADAG) with dependency weights based on an improved graph labeling scheme. Rules are designed to translate a UML model into CAL data structure (ADAG). CAL contains a small set of constructs, but is powerful enough to be used efficiently for typical software evolution management operations like impact analysis, correction, improvement and enhancement of models. A prototype tool VCAL (visual CAL), for dependency analysis of UML Class Diagrams is presented.
Description Logics for consistency checking of architectural features in UML 2.0 models
2005
UML has become the de facto standard language for software modeling. Although it was first created as a language for documenting detailed object-oriented designs, its newest version -UML 2.0-introduced new features for documenting software architectures as part of the standard. Models in UML include a series of diagrams that describe different views of the system, and even though the standard does not enforce consistency, good software engineering practices do. MCC is a tool based on description logics for UML model checking. In this paper we present how MCC can be used for reasoning about the consistency of UML models and how it can be extended so that it can also deal with UML 2.0 new architectural features following the same strategy.
Ensuring UML Models Consistency Using the OCL Environment
Electronic Notes in Theoretical Computer Science, 2004
The topic of UML model consistency is becoming increasingly important. Having a tool that checks the consistency of UML models is very useful. Using the XMI standard, the consistent models can be transferred from the checker tool to any other UML tool. By means of practical examples, this paper shows that using a framework based on OCL is a valuable approach when checking UML models. The results obtained in the examples highlight some shortcomings in the UML definition and prove that OCL offers the support needed in managing tool peculiarities.