Redesign of UML class diagrams: a formal approach

Contracts provide a precise way of specifying object-oriented systems. When a class structure is modified, the corresponding contracts must be modified accordingly. This paper presents a method of transforming contracts, which allows the extension of a mapping defined on a few model elements, to—what we call—an interpretation function, and to use this function to automatically translate OCL-constraints. Interestingly, such functions preserve reasoning using propositional calculi, resolution, equations, and induction. Interpretation functions can be used to trace model elements throughout multiple redesigns of UML class diagrams in both the forward, and the backward direction. The applicability of our approach is demonstrated in several examples, including some of Fowler’s refactoring patterns.     

Automatic generation of basic behavior schemas from UML class diagrams

The specification of a software system must include all relevant static and dynamic aspects of the domain. Dynamic aspects are usually specified by means of a behavioral schema consisting of a set of system operations that the user may execute to update the system state. To be useful, such a set must be complete (i.e. through these operations, users should be able to modify the population of all elements in the class diagram) and executable (i.e. for each operation, there must exist a system state over which the operation can be successfully applied). A manual specification of these operations is an error-prone and time-consuming activity. Therefore, the aim of this paper is to present a strategy for the automatic generation of a basic behavior schema. Operations in the schema are drawn from the static aspects of the domain as defined in the UML class diagram and take into account possible dependencies among them to ensure the completeness and executability of the operations. We believe our approach is especially useful in a Model-Driven Development setting, where the full implementation of the system is derived from its specification. In this context, our approach facilitates the definition of the behavioral specification and ensures its quality obtaining, as a result, an improved code generation phase.     

Generating operation specifications from UML class diagrams: A model transformation approach

One of the more tedious and complex tasks during the specification of conceptual schemas (CSs) is modeling the operations that define the system behavior. This paper aims to simplify this task by providing a method that automatically generates a set of basic operations that complement the static aspects of the CS and suffice to perform all typical life-cycle create/update/delete changes on the population of the elements of the CS. Our method guarantees that the generated operations are executable, i.e. their executions produce a consistent state wrt the most typical structural constraints that can be defined in CSs (e.g. multiplicity constraints). In particular, our method takes as input a CS expressed as a Unified Modeling Language (UML) class diagram (optionally defined using a profile to enrich the specification of associations) and generates an extended version of the CS that includes all necessary operations to start operating the system. If desired, these basic operations can be later used as building blocks for creating more complex ones. We show the formalization and implementation of our method by means of model-to-model transformations. Our approach is particularly relevant in the context of Model Driven Development approaches.     

Automatic test case generation from UML communication diagrams

We present a method to generate cluster level test cases based on UML communication diagrams. In our approach, we first construct a tree representation of communication diagrams. We then carry out a post-order traversal of the constructed tree for selecting conditional predicates from the communication diagram. We transform the conditional predicates on the communication diagram and apply function minimization technique to generate the test data. The generated test cases achieve message paths coverage as well as boundary coverage. We have implemented our technique and tested it on several example problems.     

OWL2Vec*: embedding of OWL ontologies

Machine Learning - Semantic embedding of knowledge graphs has been widely studied and used for prediction and statistical analysis tasks across various domains such as Natural Language Processing...     

Generating Natural Language specifications from UML class diagrams

Early phases of software development are known to be problematic, difficult to manage and errors occurring during these phases are expensive to correct. Many systems have been developed to aid the transition from informal Natural Language requirements to semi-structured or formal specifications. Furthermore, consistency checking is seen by many software engineers as the solution to reduce the number of errors occurring during the software development life cycle and allow early verification and validation of software systems. However, this is confined to the models developed during analysis and design and fails to include the early Natural Language requirements. This excludes proper user involvement and creates a gap between the original requirements and the updated and modified models and implementations of the system. To improve this process, we propose a system that generates Natural Language specifications from UML class diagrams. We first investigate the variation of the input language used in naming the components of a class diagram based on the study of a large number of examples from the literature and then develop rules for removing ambiguities in the subset of Natural Language used within UML. We use WordNet, a linguistic ontology, to disambiguate the lexical structures of the UML string names and generate semantically sound sentences. Our system is developed in Java and is tested on an independent though academic case study.     

Composition inference for UML class diagrams

Knowing which associations are compositions is important in a tool for the reverse engineering of UML class diagrams. Firstly, recovery of composition relationships bridges the gap between design and code. Secondly, since composition relationships explicitly state a requirement that certain representations cannot be exposed, it is important to determine if this requirement is met by component code. Verifying that compositions are implemented properly may prevent serious program flaws due to representation exposure. We propose an implementation-level composition model based on ownership and a novel approach for identifying compositions in Java software. Our approach is based on static ownership inference; it is parameterized by class analysis and is designed to work on incomplete programs. We present empirical results from two instantiation of our approach. For one of these instantiations, on average 40% of the examined fields account for relationships that are identified as compositions. In addition, we present a precision evaluation which shows that the analysis achieves almost perfect precision—that is, it almost never misses composition relationships. The results indicate that precise identification of interclass relationships can be done with a simple and inexpensive analysis, and thus can be easily incorporated in reverse engineering tools that support iterative model-driven development.     

Refactoring OCL annotated UML class diagrams

Refactoring of UML class diagrams is an emerging research topic and heavily inspired by refactoring of program code written in object-oriented implementation languages. Current class diagram refactoring techniques concentrate on the diagrammatic part but neglect OCL constraints that might become syntactically incorrect by changing the underlying class diagram. This paper formalizes the most important refactoring rules for class diagrams and classifies them with respect to their impact on attached OCL constraints. For refactoring rules that have an impact on OCL constraints, we formalize the necessary changes of the attached constraints. Our refactoring rules are specified in a graph-grammar inspired formalism. They have been implemented as QVT transformation rules. We finally discuss for our refactoring rules the problem of syntax preservation and show, by using the KeY-system, how this can be resolved.     

从关系数据库学习OWL本体的方法

提出了一种从关系数据库半自动学习OWL本体的方法.该方法在形式化表示关系数据库模式和OWL本体的基础上,遵循从关系数据库模式到OWL本体的一组通用映射方法和规则,并基于Java 2平台实现了原型工具OntoLeamer.利用OntoLeamer进行的典型案例研究表明了该方法的有效性.     

由序列图合成状态图

序列图和状态图对于描述和理解面向对象软件系统有着极其重要的作用。符合UML标准的序列图和状态图存在信息重叠，根据序列图提供的信息可以合成状态图。给出了在Rational Rose中由序列图合成状态图工具的实现。     

Extracting a justification for OWL ontologies by critical axioms

Extracting justifications for web ontology language (OWL) ontologies is an important mission in ontology engineering. In this paper, we focus on black-box techniques which are based on ontology reasoners. Through creating a recursive expansion procedure, all elements which are called critical axioms in the justification are explored one by one. In this detection procedure, an axiom selection function is used to avoid testing irrelevant axioms. In addition, an incremental reasoning procedure has been proposed in order to substitute series of standard reasoning tests w.r.t. satisfiability. It is implemented by employing a pseudo model to detect “obvious” satisfiability directly. The experimental results show that our proposed strategy for extracting justifications for OWL ontologies by adopting incremental expansion is superior to traditional Black-box methods in terms of efficiency and performance.     

Guidelines on the aesthetic quality of UML class diagrams

In the past, formatting guidelines have proved to be a successful method to improve the readability of source code. With the increasing success of visual specification languages such as UML for model-driven software engineering visual guidelines are needed to standardize the presentation and the exchange of modeling diagrams with respect to human communication, understandability and readability. In this article, we introduce a new and encompassing taxonomy of visual guidelines capturing the aesthetic quality of UML class diagrams. We propose these guidelines as a framework to improve the aesthetic quality and thus the understandability of UML class diagrams. To validate this claim, we describe in detail a controlled experiment carried out as a pilot study to gather preliminary insights on the effects of some of the guideline rules on the understandability of UML class diagrams.     

Combining OWL ontologies using -Connections

The standardization of the Web Ontology Language (OWL) leaves (at least) two crucial issues for Web-based ontologies unsatisfactorily resolved, namely how to represent and reason with multiple distinct, but linked ontologies, and how to enable effective knowledge reuse and sharing on the Semantic Web.In this paper, we present a solution for these fundamental problems based on -Connections. We aim to use -Connections to provide modelers with suitable means for developing Web ontologies in a modular way and to provide an alternative to the owl:imports construct.With such motivation, we present in this paper a syntactic and semantic extension of the Web Ontology language that covers -Connections of OWL-DL ontologies. We show how to use such an extension as an alternative to the owl:imports construct in many modeling situations. We investigate different combinations of the logics , and for which it is possible to design and implement reasoning algorithms, well-suited for optimization.Finally, we provide support for -Connections in both an ontology editor, SWOOP, and an OWL reasoner, Pellet.     

Using OWL-VisMod through a decision-making process for reusing OWL ontologies

Knowledge representation (KR) can be defined as a set of ontological commitments, provided with the capabilities of performing inference. The knowledge can be represented using an ontology, which provides a shared insight into a certain domain. The use of ontologies to represent knowledge also allows interoperation among knowledge-based systems. The process of building ontologies can be tedious and sometimes exhaustive. A possible solution in order to avoid this problem would be to reuse the ontologies previously created by others. This paper describes a case study of reusability using OWL-VisMod, a tool designed for developing ontological engineering based on visual conceptual modelling for OWL ontologies. A workflow performed with OWL-VisMod is described; including a decision-making process in order to decide whether or not it could be desirable to reuse an ontology, according to the requirements of a certain project.     

GrOWL: A tool for visualization and editing of OWL ontologies

In an effort to optimize visualization and editing of OWL ontologies we have developed GrOWL—a browser and visual editor for OWL that accurately visualizes the underlying DL semantics of OWL ontologies while avoiding the difficulties of the verbose OWL syntax. In this paper, we discuss GrOWL visualization model and the essential visualization techniques implemented in GrOWL.     

A feedback technique for unsatisfiable UML/OCL class diagrams

In Model‐Driven Development (MDD), detection of model defects is necessary for correct model transformations. Formal verification tools and techniques can to some extent verify models. However, scalability is a serious issue in relation to verification of complex UML/OCL class diagrams. We have proposed a model slicing technique that slices the original model into submodels to address the scalability issue. A submodel can be detected as unsatisfiable if there are no valid values for one or more attributes of an object in the diagram or if the submodel provides inconsistent conditions on the number of objects of a given type. In this paper, we propose a novel feedback technique through model slicing that detects unsatisfiable submodels and their integrity constraints among the complex hierarchy of an entire UML/OCL class diagram. The software developers can therefore focus their revision efforts on the incorrect submodels while ignoring the rest of the model. Copyright © 2013 John Wiley & Sons, Ltd.     

Structural similarity measure between UML class diagrams based on UCG

Requirements Engineering - In software reuse, the reuse of UML class diagram produced in design phase has received more attention due to the important influence on the following developing process....     

Source code size estimation approaches for object-oriented systems from UML class diagrams: A comparative study

BackgroundSource code size in terms of SLOC (source lines of code) is the input of many parametric software effort estimation models. However, it is unavailable at the early phase of software development.ObjectiveWe investigate the accuracy of early SLOC estimation approaches for an object-oriented system using the information collected from its UML class diagram available at the early software development phase.MethodWe use different modeling techniques to build the prediction models for investigating the accuracy of six types of metrics to estimate SLOC. The used techniques include linear models, non-linear models, rule/tree-based models, and instance-based models. The investigated metrics are class diagram metrics, predictive object points, object-oriented project size metric, fast&&serious class points, objective class points, and object-oriented function points.ResultsBased on 100 open-source Java systems, we find that the prediction model built using object-oriented project size metric and ordinary least square regression with a logarithmic transformation achieves the highest accuracy (mean MMRE = 0.19 and mean Pred(25) = 0.74).ConclusionWe should use object-oriented project size metric and ordinary least square regression with a logarithmic transformation to build a simple, accurate, and comprehensible SLOC estimation model.     

On the complexities of consistency checking for restricted UML class diagrams

Automatic debugging of UML class diagrams helps in the visual specification of software systems because users cannot detect errors in logical consistency easily. This study focuses on the tractable consistency checking of UML class diagrams. We accurately identify inconsistencies in these diagrams by translating them into first-order predicate logic that is generalized by counting quantifiers and classify their expressivities by eliminating certain components. We introduce optimized algorithms that compute the respective consistencies of class diagrams of different expressive powers in P, NP, PSPACE, or EXPTIME with respect to the size of the class diagrams. In particular, owing to the restrictions imposed on attribute value types, the complexities of consistency checking of class diagrams decrease from EXPTIME to P and PSPACE in two cases: (i) when the class diagrams contain disjointness constraints and overwriting/multiple inheritances and (ii) when the class diagrams contain both these components along with completeness constraints. Additionally, we confirm the existence of a restriction of class diagrams that prevents any logical inconsistency.