Statechart Diagrams Research Articles

A Coalgebraic Semantic Framework for Component-based Development in UML

This paper introduces a generic semantic framework for component-based development, expressed in the unified modelling language UML. The principles of a coalgebraic semantics for class, object and statechart diagrams as well as for use cases, are developed. It is also discussed how to formalize the refinement steps in the development process based upon a suitable notion of behavior refinement. In this way, a formal basis for component-based development in UML is studied, which allows the construction of more complex and specific systems from independent components.

UML Statechart Diagrams on the ADONIS Metamodeling Platform

The metamodeling platform ADONIS has originally been implemented for the use in business process management. Its method independency and extensive customization functionalities also allow for the application in many different other areas such as strategic management, e-learning, object-oriented systems engineering, knowledge management, and numerous others. In computer science the Unified Modeling Language (UML) is the dominating standard for describing systems and behaviours. In this article it is shown how the abstract and concrete syntax of UML statechart diagrams can be described by the use of the metamodeling concepts of ADONIS.

B05: Transition conflicts detection in binary modular statecharts diagrams

Statechart diagrams are graphic formalism for modelling digital controller behaviour. Statecharts employ notion of traditional state transition graph enhanced with concurrency, hierarchy and broadcast communication. One of undesirable problem which arises in specifying behaviour in this way is undeterministic situation, where at given instant of time, two or more transitions can move activity from one state. If this happens, the transitions are said to be in conflict. Conflicts can be both horizontal and, because of hierarchy, vertical. In the paper two methods of searching for conflicting transitions are presented: static based on hierarchy diagram and dynamic using characteristic function of space of global states.

Plug-and-play composition of features and feature interactions with statechart diagrams

This paper presents a new approach for modular design of highly-entangled software components by statechart diagrams. We structure the components into features, which represent reusable, self-contained services. These are modeled individually by statechart diagrams. For composition of components from features, we need to consider the interactions between the features. These feature interactions, well known in the telecommunications area, typically describe special cases or cooperations which only occur when two features are combined. We describe these interactions graphically by refinement relations between statecharts. The main novelty is that full component descriptions are created in a plug-and-play fashion by combining the statecharts for the required features and interactions. Furthermore, we develop different classes of statecharts and show the interactions on a case-by-case basis. For composition, we use semantic refinement concepts for statecharts which preserve the original behavior.

Design/CPN을 이용한 객체지향 소프트웨어 상호작용 테스트 기법

객체지향 시스템은 상호 작용하늘 객체들의 집합으로 구성되었고 시스템의 행위는 객체들의 협력 행위로 표현된다. 객체지향 소프트웨어의 상속성, 다형성 등 특성들은 소프트웨어 테스팅에 어려움을 증가시키고 객체의 병행성, 동적바인딩, 상호작용 등 동적인 면들은 프로그램의 실행 시간에 한 멤버 함수의 호출에 의해 여러 멤버함수로 바인딩될 수 있다. 그러므로 객체지향 소프트웨어의 특성들을 고려하고 동시에 객체들간의 상호착용을 테스트하기 위한 연구가 필요하다 이 논문에서 상속성, 다형성 등 특성을 고려하여 평탄화된(Flattened) 상태차트 다이어그램을 구성하고, 시스템 모델링과 시뮬레이션에 전형적으로 사용되는 CPN(Colored Petri net)으로 모델링 한 후 Design/CPN 툴에 적용하여 객체지향 소프트웨어 객체들간의 상호작용 테스트를 자동화할 수 있는 테스트 레이스 생성 기법을 제안한다. An object-oriented system is organized by a set of interacting objects and the system behavior is represented by the cooperating interaction bet ween objects. The characteristics of object-oriented software. such as inheritance and polymorphism, increase the difficulty of the object-oriented software testing. At running time of a program, one call from a member function can bind to other member functions because of the dynamic characteristics such as concurrence, dynamic binding and interaction. Therefore, there need the research about considering the characteristics of object-oriented software and concurrently testing the interaction between objects. In this paper, we propose the techniques as follows. First, we construct a flattened state chart diagram by considering the inheritance and polymorphism. Next, we model the system with CPN(Colored Petri Net) that usually is applying the system modeling and simulation. Last, we propose a test case generation techniques for testing the interaction between objects in object-oriented software by applying a Design/CPN tool.

From UML activity diagrams to Stochastic Petri nets

Over the last decade, the relevance of performance evaluation in the early stages of the software development life-cycle has been steadily rising. We honestly believe that the integration of formal models in the software engineering process is a must, in order to enable the application of wellknown, powerful analysis techniques to software models. In previous papers the authors have stated a proposal for SPE, dealing with several UML diagram types. The proposal for malizes their semantics, and provides a method to translate them into (analyzable) GSPN models. This paper focuses on activity diagrams, which had not been dealt with so far. They will be incorporated in our SPE method, enhancing its expressivity by refining abstraction levels in the statechart diagrams. Performance requirements will be annotated according to the UML profile for schedulability, performance and time. Last but not least, our CASE tool prototype will be introduced. This tool deals with every model element from activity diagrams and ensures an automatic translation from ADs into GSPNs strictly following the process related in this paper.

The formal semantics of SDL-2000: Status and perspectives

In November 1999, the current version of specification and description language (SDL), commonly referred to as SDL-2000, passed through ITU-T. In November 2000, the formal semantics of SDL- 2000 was officially approved to become part of the SDL language definition. It covers both the static and the dynamic semantics, and is based on the formalism of abstract state machines (ASMs). To support executability, the formal semantics defines, for each SDL specification, reference ASM code, which enables an SDL-to-ASM-compiler. In this paper, we briefly survey and compare existing approaches to define the semantics of SDL formally. The ITU-T approach is then outlined in more detail, addressing the following steps: (1) mapping of non-basic language constructs to the core language, (2) checking of static semantics conditions, (3) definition of the SDL abstract machine (SAM), and (4) definition of the SDL virtual machine (SVM). The paper concludes with experiences from the SDL-to-ASM-compiler project. It is proposed that the SDL-2000 semantics can be adapted and extended to formally define the meaning of UML 2.0 class, composite structure, and statechart diagrams.

State Machines as Mixins.

Mainstream object modelling techniques use Statechart Diagrams as a means of modelling object behaviour. Research into how statecharts can be used in the context of class generalization hierarchies has focused on applying the Liskov Substitution Principle (LSP) to statecharts. This approach is problematic, and we describe three reservations. We propose an alternative approach based on mixin-style composition of state transition diagrams. This avoids the problems we note in the LSP based approach; and is also a basis for separating descriptions of behaviour inherent to the modelled domain from behaviour that is not inherent, but a requirement of the system.

原子力プラント配管溶接部の熱ぜい化挙動と安全性・信頼性の確率論的評価

Embrittlement behavior of the duplex stainless steel in the intermediate temperature range (275 to 500°C) is one of the very serious problems for applying reliability assessment to practical pipes in a nuclear power plant. In this work, it is shown by formularization of embrittlement behavior with aging time that the increase in hardness due to embrittlement is governed by α contents of the duplex stainless steel. The formula as function of aging time and temperature, which can predict the embrittlement behaviors in the duplex stainless steel of arbitrary chemical compositions, is proposed by using the Scheffler's statechart diagram. For the purpose of estimating the structural reliability of a nuclear power plant, the formula can be used to predict the change of fracture toughness KIC with service term in the field probabilistically.

An Object Oriented Model of a Railway Safety-Related Control System

There is a variety of methods and formalisms usable for writing specifications of railway interlocking and signalling systems or their subsystems. To write a consistent technical specification means to make a model with a required level of precision, clarity and economy of expression that is free of unknown spots and/or conflicts. One of possible formalisms suitable for making such models seems to be the Unified Modeling Language' (trademark of OMG). The paper presents experience and knowledge of authors who have worked over transcription of informal specification of a new railway interlocking and signallingsystem into the UML based object-oriented model. The main attention is paid to analysis and design phases. The former phase results in use case diagrams and sequential diagrams, the latter in class/object diagrams and statechart diagrams. The syntax of the discussed diagrams is in accordance with the UML ver. 1.2 as given by the software tool Rhapsody' ver. 2.2 (a trademark of I-Logix). Experiences and advantages resulting from the presented approach are summarised within conclusions.

Visualizing graphical and textual formalisms

ViSta is a tool suite designed to support the requirements specification of reactive systems. It guides the user through the steps necessary for the visualization of statechart diagrams from an informal document. The user first extracts information from a textual document and stores into a set of interactive templates. The information is used by the tool to automatically generate statechart layouts. In this paper we describe how ViSta is augmented with a tool that automatically translates statecharts into Z specifications. The template, statechart and Z representations are inter-related. This ensures consistency between the different representations, and therefore facilitates the verification and validation effort.

Implementing a component-based tool for interactive synthesis of UML statechart diagrams

The Unified Modeling Language (UML) has an indisputable role in object-oriented software development. It provides several diagram types viewing a system from different perspectives. Currently avail...

On testing and conformance relations for UML statechart diagrams behaviours

In this paper we study the formal relationship between testing preorder/equivalences for a behavioural subset of UML Statechart Diagrams and a conformance relation for implementations with respect to specifications given using such diagrams. We study the impact of stuttering on the above mentioned relationship. In the context of UMLSDs, stuttering occurs when no transition of the UMLSD is enabled by the current event in the current (global) state of the underlying state-machine. We consider both the case in which the semantics underlying the testing relations does not model stuttering explicitly - we call it the non-stuttering semantics - and the case in which it does it - i.e. the stuttering semantics. We show that in the first case the conformance relation is stronger than the reverse of the MUST preorder and, consequently, stronger than the MAY preorder. Much more interesting results can be proven in the second case, possibly under proper conditions on the sets of events under consideration. In fact the conformance relation is shown to coincide with the MAY preorder, and thus be implied by the reverse MUST preorder. Finally, we show important substitutivity properties which hold in the case of stuttering semantics.

Automated compression of state machines using UML statechart diagram notation

In object-oriented design, behavioral modeling aims at describing the behavior of objects using state machines. State machines can also be used in dynamic reverse engineering to capture the overall run-time behavior of the objects of interest. The unified modeling language (UML) statechart diagram notation provides powerful means to structure state machines, thus avoiding the plague of combinatorial explosion. Tool support for constructing statechart diagrams automatically from example scenarios is currently available. These tools are applicable in both forward and reverse engineering. For complicated objects, the statechart diagrams tend to be large, which makes them difficult to visualize and understand. In this paper, we discuss information preserving means to transform flat statechart diagrams into a more compact form. These algorithms can be applied to both manually constructed and automatically generated diagrams. The proposed technique is integrated with a UML-based software design environment TED.

Modular semantics for a UML statechart diagrams kernel and its extension to multicharts and branching time model-checking

Statechart diagrams provide a graphical notation to model dynamic aspects of system behaviour within the unified modelling language (UML). In this paper, we present a formal operational semantics for a behavioural subset of UML statechart diagrams (UMLSDs) including a formal proof of their correctness with respect to major UML semantics requirements concerning behavioural issues. We show how the modularity of our semantics definition can be exploited to define extensions, in particular we show an extension to models composed of collections of communicating statechart diagrams, which we call multicharts. Finally we present all the conceptual issues related to building a tool for action based branching time model-checking, for the automatic verification of formal correctness of UML multicharts. The approach we propose preserves all the information necessary to report the results of model-checking in terms of the original UMLSD specification. The reference verification environment used for this model-checking approach is JACK, where automata are represented in a standard format which facilitates the use of a collection of tools for automatic verification.

Quantitative Analysis of UML Statechart Models of Dependable Systems

The paper introduces a method which allows quantitative dependability analysis of systems modeled by using the Unified Modeling Language (UML) statechart diagrams. The analysis is performed by transforming the UML model to stochastic reward nets (SRNs). A large subset of statechart model elements is supported including event processing, state hierarchy and transition priorities. The transformation is presented by a set of SRN patterns. Performance-related measures can be directly derived using SRN tools, while dependability analysis requires explicit modeling of erroneous states and faulty behavior.

Minimally adequate teacher synthesizes statechart diagrams

We consider the problem of synthesizing UML statechart diagrams from sequence diagrams as a language inference problem, and we solve it in Angluin's framework of minimally adequate teacher. The designer has the role of the teacher who answers membership and equivalence queries made by the algorithm. It turns out that there are several natural methods to decrease the number of membership queries needed, and thus, to make the algorithm practically applicable.

Exploiting object-oriented methodologies to model MAS on organizations

Researchers have recognized multi-agent systems (MAS) as being a promising means to cope with distributed and complex problems. However, how to analyze and design an agent-based system in practical environments is still difficult. Based on the inherent consistency between objects and agents, MAS and human social organizations, we propose an approach using comparatively mature object-oriented (OO) methodologies and tools (mostly UML) to model MAS from the point of view of organization depiction. This paper uses a distributed logistics management system (DLMS) as an example and describes a method to model MAS based on extended UML from the following three aspects:•extracting roles for agent organizations based on the theory of use cases,•depicting the static organizational structures of MAS based on the semantics and syntax of class diagrams, and•extending collaboration diagrams, sequence diagrams and state chart diagrams to portray the interactive behaviors among agent roles and the reasoning behaviors within agent roles themselves.

A Framework for the Static and Interactive Visualization of Statecharts

We present a framework for the automatic generation of layouts of statechart diagrams. Statecharts [16] are widely used for the requirements specication of reactive systems. Our framework is based on several techniques that include hierarchical drawing, labeling, and floorplanning, designed to work in a cooperative environment. Therefore, the resulting drawings enjoy several important properties: they emphasize the natural hierarchical decomposition of states into substates; they have a low number of edge crossings; they have good aspect ratio; and require a small area. We also present techniques for interactive operations. We have implemented our framework and obtained drawings for several statechart examples.

FORMALIZATION OF OBJECT BEHAVIOR AND INTERACTIONS FROM UML MODELS

UML, being the industry standard as a common OO modeling language, needs a well-defined semantic base for its notation. Formalization of the graphical notation enables automated processing and analysis tasks. This paper describes a methodology for synthesis of a Petri net model from UML diagrams. The approach is based on deriving Object Net Models from UML statechart diagrams and connecting these object models based on UML collaboration diagram information. The resulting system-level Petri net model can be used as a foundation for formal Petri net analysis and simulation techniques. The methodology is illustrated on some small examples and a larger case study. The case study reveals some unexpected invalid system-state situations.