Incremental Consistency Checking in Delta-oriented UML-Models for Automation Systems

Automation systems exist in many variants and may evolve over time in order to deal with different environment contexts or to fulfill changing customer requirements. This induces an increased complexity during design-time as well as tedious maintenance efforts. We already proposed a multi-perspective modeling approach to improve the development of such systems. It operates on different levels of abstraction by using well-known UML-models with activity, composite structure and state chart models. Each perspective was enriched with delta modeling to manage variability and evolution. As an extension, we now focus on the development of an efficient consistency checking method at several levels to ensure valid variants of the automation system. Consistency checking must be provided for each perspective in isolation, in-between the perspectives as well as after the application of a delta.Comment: In Proceedings FMSPLE 2016, arXiv:1603.0857

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 semistructured 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

Logical Approach : Consistency Rules Between Activity Diagram And Class Diagram

Requirements validation especially models validation has gained quite an interest from a lot of researchers. The research regarding the consistency checking is proliferating from time to time. Several of techniques, approaches and methods have been proposed to cater the issues of requirements inconsistency especially in models validation. UML modelling has been used widely in software development industry. The varied of UML models that representing the system in different viewpoints but somehow relate to each other make them inextricable from one model to another. Hence, the inconsistency becomes inevitable. The models will be inconsistent if there are overlapping elements of diverse models that depicts the parts of the system are failed to cooperative. In this paper, we focused on the consistency rules between two models, activity and class diagrams by converting the rules into logical predicates and the logical predicates will be evaluated using a sample of case study that consists of the two models

Generic Methodology for Formal Verification of UML Models

This paper discusses a Unified Modelling Language (UML) based formal verification methodology for early error detection in the model-based software development cycle. Our approach proposes a UML-based formal verification process utilising functional and behavioural modelling artifacts of UML. It reinforces these artifacts with formal model transition and property verification. The main contribution is a UML to Labelled Transition System (LTS) Translator application that automatically converts UML Statecharts to formal models. Property specifications are derived from system requirements and corresponding Computational Tree Logic (CTL)/Linear Temporal Logic (LTL) model checking procedure verifies property entailment in LTS. With its ability to verify CTL and LTL specifications, the methodology becomes generic for verifying all types of embedded system behaviours. The steep learning curve associated with formal methods is avoided through the automatic formal model generation and thus reduces the reluctance of using formal methods in software development projects. A case study of an embedded controller used in military applications validates the methodology. It establishes how the methodology finds its use in verifying the correctness and consistency of UML models before implementation

Consistency check between XML schema and class diagram for document versioning

A consistency check between design and implementation is usually done in order to check the correctness of the system’ requirements. However, if the requirements are changed over time, then the document versioning occurred within the requirements. For XML Schema, document versioning exists when there is a change in the XML Schema from its previous Schema. In order to detect the versioning of both XML Schemas, consistency rules check need to be performed to both class diagrams produced by both Schemas. The consistency between two XML Schemas are checked based on transformation rules and versioning rules. Transformation rules are used for translating the XML Schema into class diagram and versioning rules are used for checking the existing of document changes between two XML Schemas. Once two XML Schemas are different the consistency rules will be used for the consistency check. This paper presents an approach based on transformation rules and versioning rules to check consistency between XML Schema and UML class diagram when document versioning exist. The approach is then used for the case study to show how the consistency is checked in order to detect the versioning of two different XML Schemas. Based on the case study, the approach shows that two XML Schemas can be checked for their consistency when document versioning exist

Consistency Check between XML Schema and Class Diagram for Document Versioning

A consistency check between design and implementation is usually done in order to check the correctness of the system’ requirements. However, if the requirements are changed over time, then the document versioning occurred within the requirements. For XML Schema, document versioning exists when there is a change in the XML Schema from its previous Schema. In order to detect the versioning of both XML Schemas, consistency rules check need to be performed to both class diagrams produced by both Schemas. The consistency between two XML Schemas is checked based on transformation rules and versioning rules. Transformation rules are used for translating the XML Schema into the class diagram, and versioning rules are used for checking the existing of document changes between two XML Schemas. Once two XML Schemas are different the consistency rules will be used for the consistency check. This paper presents an approach based on transformation rules and versioning rules to check consistency between XML Schema and UML class diagram when document versioning exist. The approach is then used for the case study to show how the consistency is checked in order to detect the versioning of two different XML Schemas. Based on the case study, the approach shows that two XML Schemas can be checked for their consistency when document versioning exist.

Automated Mapping of UML Activity Diagrams to Formal Specifications for Supporting Containment Checking

Business analysts and domain experts are often sketching the behaviors of a software system using high-level models that are technology- and platform-independent. The developers will refine and enrich these high-level models with technical details. As a consequence, the refined models can deviate from the original models over time, especially when the two kinds of models evolve independently. In this context, we focus on behavior models; that is, we aim to ensure that the refined, low-level behavior models conform to the corresponding high-level behavior models. Based on existing formal verification techniques, we propose containment checking as a means to assess whether the system's behaviors described by the low-level models satisfy what has been specified in the high-level counterparts. One of the major obstacles is how to lessen the burden of creating formal specifications of the behavior models as well as consistency constraints, which is a tedious and error-prone task when done manually. Our approach presented in this paper aims at alleviating the aforementioned challenges by considering the behavior models as verification inputs and devising automated mappings of behavior models onto formal properties and descriptions that can be directly used by model checkers. We discuss various challenges in our approach and show the applicability of our approach in illustrative scenarios.Comment: In Proceedings FESCA 2014, arXiv:1404.043

Analyzing Consistency of Behavioral REST Web Service Interfaces

REST web services can offer complex operations that do more than just simply creating, retrieving, updating and deleting information from a database. We have proposed an approach to design the interfaces of behavioral REST web services by defining a resource and a behavioral model using UML. In this paper we discuss the consistency between the resource and behavioral models that represent service states using state invariants. The state invariants are defined as predicates over resources and describe what are the valid state configurations of a behavioral model. If a state invariant is unsatisfiable then there is no valid state configuration containing the state and there is no service that can implement the service interface. We also show how we can use reasoning tools to determine the consistency between these design models.Comment: In Proceedings WWV 2012, arXiv:1210.578