Checking Consistency in UML Diagrams: Classes and State Machines

Although Unified Modeling Language (UML) state machines constitute a convenient modeling formalism that is widely used in many applications, the lack of formal semantics impedes carrying out automatic processing, such as formal verification. In this article, we aim to achieve a proven translation from a subset of UML state machines to timed automata. A generic abstract syntax is defined for state machines that allows us to specify state machines as a tree-like structure, explicitly illustrating the hierarchical relationships within the model. Based on this syntax, a formal asynchronous semantics for state machines and systems of state machines is established. Additionally, the semantics of timed automata is specified. Then, a translation relation from the considered set of state machines to timed automata is defined and a strong equivalence relation — namely, a timed bisimulation between the source and target models — is formally proven. The proof is carried out inductively while considering continuous (time) and discrete transitions separately. This proof allows us to demonstrate a strong similitude between these models.

This thesis presents research to build and evaluate embedding of a textual form of state machines into high-level programming languages. The work entailed adding state machine syntax and code generation to the Umple model-oriented programming technology. The added concepts include states, transitions, actions, and composite states as found in the Unified Modeling Language (UML). This approach allows software developers to take advantage of the modeling abstractions in their textual environments, without sacrificing the value added of visual modeling. Our efforts in developing state machines in Umple followed a test-driven approach to ensure high quality and usability of the technology. We have also developed a syntax-directed editor for Umple, similar to those available to other high-level programming languages. We conducted a grounded theory study of Umple users and used the findings iteratively to guide our experimental development. Finally, we conducted a controlled experiment to evaluate the effectiveness of our approach. By enhancing the code to be almost as expressive as the model, we further support model-code duality; the notion that both model and code are two faces for the same coin. Systems can be and should be equally-well specified textually and diagrammatically. Such duality will benefit both modelers and coders alike. Our work suggests that code enhanced with state machine modeling abstractions is semantically equivalent to visual state machine models. The flow of the thesis is as follows; the research hypothesis and questions are presented in “Chapter 1: Introduction”. The background is explored in “Chapter 2: Background”. “Chapter 3: Syntax and semantics of simple state machines” and “Chapter 4: Syntax and semantics of composite state machines” investigate simple and composite state machines in Umple, respectively. “Chapter 5: Implementation of composite state machines” presents the approach we adopt for the implementation of composite state machines that avoids explosion of the amount of generated code. From this point on, the thesis presents empirical work. A grounded theory study is presented in “Chapter 6: A Grounded theory study of Umple”, followed by a controlled experiment in “Chapter 7: Experimentation”. These two chapters constitute our validation and evaluation of Umple research. Related and future work is presented in “Chapter 8: Related work”.

Informal and graphical modeling techniques enable developers to construct abstract representations of systems. Object-oriented modeling techniques further facilitate the development process. The Unified Modeling Language (UML), an object-oriented modeling approach, could be broad enough in scope to represent a variety of domains and gain widespread use. Currently, UML comprises several different notations with no formal semantics attached to the individual diagrams. Therefore, it is not possible to apply rigorous automated analysis or to execute a UML model in order to test its behavior, short of writing code and performing exhaustive testing. We introduce a general framework for formalizing a subset of UML diagrams in terms of different formal languages based on a homomorphic mapping between metamodels describing UML and the formal language. This framework enables the construction of a consistent set of rules for transforming UML models into specifications in the formal language. The resulting specifications derived from UML diagrams enable either execution through simulation or analysis through model checking, using existing tools. This paper describes the use of this framework for formalizing UML to model and analyze embedded systems. A prototype system for generating the formal specifications and results from an industrial case study are also described.

Unified Modeling Language (UML) is considered a standard for modeling object-oriented software. It supports several different diagrams that can be used to model behavior and structure of the software. With respect to formal verification, particularly Model Checking, the existing approaches are usually restricted to a single UML diagram. This paper presents a tool to convert UML behavioral diagrams (sequence, activity, and state machine) into Transition Systems to support software Model Checking. A peculiar feature of our tool is that it is developed as part of a larger effort to allow Model Checking of software built in accordance with UML, including several UML behavioral diagrams. We demonstrate the effectiveness of our approach by applying it to a classic case study and also to a real case study (embedded software) in the space domain.KeywordsModel CheckerTransition SystemSequence DiagramActivity DiagramLinear Temporal LogicThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In a wide range of application areas, system behavior is modeled using variations of scenarios and state machines. In telecommunications, ITU standards SDL (Specification and Description Language) and MSC (Message Sequence Charts) are used for formal specifications and descriptions. Also, for behavioral modeling of object-oriented software systems, UML interaction diagrams (sequence or collaboration diagrams) and statechart diagrams are commonly used. Use cases can be conveniently refined using interaction diagrams, which in turn aid in recognizing class operations and associations and in building statechart specifications of object behaviour. The aim of this workshop is to build a shared understanding on the relation between scenarios and state machines and to gain insight on techniques and tools that may leverage from combining these approaches to behaviour modeling. In this workshop, we will discuss the usage of scenario-based approaches in software engineering. An emphasis area is the relation between scenarios and state-machines. Areas of interest of this one-day workshop include, but are not limited to the following three main discussion topics: 1) Models and notations (requirements for different application areas, shortcomings in current notations, new suggestions for models or notations, categorizations); 2) Algorithms (e.g., synthesizing state machines from scenarios, implied scenarios, generating scenarios from state machines, consistency checks); 3) Tools (tool support for the issues above, different application areas). Moreover, we will identify the limitations and shortcomings of current approaches and outline possible directions for future research in the domain. A related workshop (scenario-based roundtrip eng.) was organized at OOPSLA 2000.

Unified Modelling Language (UML) has a graphical notation for 13 different types of diagrams and can be used as a general modelling tool. Well-known examples of diagram types are class diagrams for modelling classes that can be instanced into objects, state machine diagrams for modelling states in systems and activity diagrams for modelling process flows. A literature survey shows that UML has been used to model concepts and methodologies of risk assessment and risk management. One example is the Coras Framework. The international standard CEI IEC 61882 Hazard and operability (HAZOP) studies describes concepts for investigating and detecting possible hazards in systems. In CEI IEC 6882, guide words like ‘More’ and ‘Less’ are applied to system parameters to invoke deviations in the system and assess possible hazards due to the deviation from the design intent. In this paper, we have used UML to model concepts of CEI IEC 61882 Hazards and operability studies. Diagrams of UML were used to show dependencies and relations between parts of the target system and concepts of CEI IEC 61882. Extensions of UML are suggested to better capture and display the concepts of CEI IEC 61882, the results of a HAZOP study and emerging risk. These extensions are referred to as UML for emerging risks (UML-ER).

Unified Modeling Language (UML) is the most famous modeling language use for software design in software development industries with the class diagram being the most use diagram by UML practitioners. As software development progress, the UML model became complicated. Thus, difficult for human being to trace back previously known relationship(s) between classes of the previous class diagram(s) in the present complex class diagram. Tracing back previous relationship(s) is accomplished by abstracting relationships among three related classes to semantic equivalent relationship between two of the classes. Abstracting class diagram aid in checking consistency, reverse engineering and facilitate model understanding. This article presented abstraction rules of a class diagram using a logical approach. The result was evaluated using a case study of hotel management system, and the rules were found to be reliable and useful.

In manufacturing, a good workshop tool management system (WTMS) plays an important role for enterprise production planning system & the use of equipment capacity. By using Unified Modeling Language (UML), based on Use Case Diagram, Static Structure Diagrams, and Dynamic Behavior Diagram, the functional demands of workshop tool management system are analyzed. Thus the workshop tool management system model is established, and the Sub-function systems are designed in detail. Farther more, technical instrument of WTMS & key technology are systematically studied. And an example of WTMS prototype system has been put forward in the end.

A Simultaneous Localization and Mapping(SLAM) system is a complex program consisting of several interconnected components with different functionalities such as optimization, tracking or loop detection. Whereas the literature addresses in detail how enhancing the algorithmic aspects ofthe individual components improves SLAM performance, the modal aspects, such as when to localize, relocalize or close a loop, are usually left aside. In this paper, we address the modal aspects of a SLAM system and show that the design of the modal controller has a strong impact on SLAM performance in particular in terms of robustness against unforeseen events such as sensor failures, perceptual aliasing or kidnapping. We preset a novel taxonomy for the components of a modern SLAM system, investigate their interplay and propose a highly modular architecture of a generic SLAM system using the Unified Modeling LanguageTM(UML) state machine formalism. The result, called SLAM state machine, is compared to the modal controller of several state-of-the-art SLAM systems and evaluated in two experiments. We demonstrate that our state machine handles unforeseen events much more robustly than the state-of-the-art systems.

A model is a simplification of a reality, an abstraction, which neglects all of the irrelevant aspects of a software and focuses on the ones which define the software. Through modeling, we can visualize the software in a way which is understandable from both computers and people. Unified Modeling Language (UML) is a language, which stands in a higher level of abstraction than any programming language and through it, we can build software models from the simplest to the most complicated ones. However, even though through UML we are able to design software’s and to generate a considerable amount of code, still we need to write tons of lines of code in a certain object – oriented language. In order to be totally independent from the execution environment and to focus entirely in business logic as what really defines a software we need to go further. To achieve this goal, the executable UML and state machines concept is introduced. “An executable UML model is one with a behavioral specification detailed enough that it can effectively be run as a program” (Seidewitz, 2011). Through executable model a higher programmer productivity could be achieved and the system is not affected by the year after year change in development technologies, which require that the system to be upgraded each time there are changes in run-time environments. On the other hand, through state machines we are able to simulate the execution of a program through the model. Thus we can develop information systems using techniques which stand in a higher level of abstraction and platform independence that can be translated in whichever specific platform of implementation.

The Web Services Choreography Description Language (WS-CDL) is a specification developed by the W3C and can be viewed as a blueprint for the development of end-point services. Consequently, it is worth providing a systematic approach for its modeling, analysis and verification. The Unified Modeling Language (UML) is an industry standard for modeling. Applying UML to model WS-CDL is obviously a promising solution to bring together academics and practitioners through a unique standard language. In this paper, we propose to use different UML diagrams to model WS-CDL. UML Component Diagram is used to model the underlying structure of WS-CDL. UML Sequence Diagram is utilized to model the activities in WS-CDL. UML State Machine Diagram is utilized to model the behaviors of each role participating in a WS-CDL specification. We then enrich the UML State Machine Diagram with data by the use of UML Class Diagram. Given the UML specification of WS-CDL, we then provide a systematic way of formally analyzing and verifying WS-CDL against desired properties. Some experiments show that our approach can verify structural, behavioral and data properties in a middle-scale data-enriched WS-CDL specification.

To solve the problem that UML (Unified Modeling Language) design model cannot be model-checked for its rough semantics, an extension of UML, called xUML4MC, is defined by extending the activity diagram with accurate syntax and semantics to model the activities of an object. Besides, the technique for automatical transformation of xUML4MC model into MSVL (Modeling, Simulation and Verification Language) model is also presented, which in turn can be verified with model checking tool MSV. The formalism arms the classical visual specification language UML with the power of model checking, and helps to promote the quality of software system.

This article presents a formalization approach for the requirements of object-oriented programs with state machines, using a spacecraft control system as a case study. It proposes a state pattern implementation, where each state is represented as a class with clearly defined responsibilities, and the transitions between states are controlled by the state objects themselves. Additionally, the application of model checking, theorem proving, and code generation techniques are discussed. The effectiveness of the proposed approach in ensuring compliance with the specified requirements is demonstrated, while also identifying potential drawbacks and limitations of the approach. The implementation is validated using a range of formal verification techniques, including model checking and theorem proving. The article also discusses how the approach can be extended and applied to other complex systems. Overall, the valuable insights into the formalization of requirements for object-oriented programs with state machines are provided, offering a practical and effective approach for verifying the correctness and completeness of such implementations. The results of this work have important implications for the development of safety-critical systems and can potentially improve the quality and reliability of software systems in various domains. By using mathematical models and rigorous formal methods, it is possible to detect and eliminate errors early in the development process, leading to higher confidence in the correctness of the final product. Future research in this area could explore the use of more advanced techniques, such as model-driven development and automatic code synthesis, to further streamline the software development process. Additionally, the development of more efficient and user-friendly tools could make these techniques more accessible to a wider range of developers and organizations. Altogether, the combination of formal methods and software engineering has the potential to revolutionize the way software systems are designed, developed, and verified, leading to safer and more reliable software for critical applications.

The quality of a computer system can be enhanced by modelling its design and verifying the correctness of the design before implementation is done. Abstract State Machines (ASMs) provide a mathematical framework for system modelling, while Model Checking is a technology for verification of system properties. Together, they form a powerful tool for checking systems. Bounded Model Checking (BMC) based on Answer Set Programming (ASP) is a competitive model checking approach due to its ability to compactly encode BMC problems. In this paper, we present a method of applying ASP to BMC of ASMs. Given an ASM and a temporal property, we show how to efficiently translate the BMC problem for the ASM into a problem of answer set computation. Experimental results for our method using the answer set solvers SMODELS and CMODELS are also given.

In this work, novel symbolic step encodings of the transition relation for object based communicating state machines are presented. This class of systems is tailored to capture the essential data manipulation features of UML state machines when enriched with a Java-like object oriented action language. The main contribution of the work is the generalization of the \(\exists\)-step semantics approach, which Rintanen has used for improving the efficiency of SAT based AI planning, to a much more complex class of systems. Furthermore, the approach is extended to employ a dynamic notion of independence. To evaluate the encodings, UML state machine models are automatically translated into NuSMV models and then symbolically model checked with NuSMV. Especially in bounded model checking (BMC), the \(\exists\)-step semantics often significantly outperforms the traditional interleaving semantics without any substantial blowup in the BMC encoding as a SAT formula.KeywordsState MachineModel CheckTransition RelationSymbolic Model CheckBound Model CheckThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.