Hierarchical State Machines as Modular Horn Clauses

Separation of Concerns (SoC) is an important issue to reduce the complexity of software. Recent advances in programming language research show that Aspect-Oriented Programming (AOP) may be helpful for enhancing the SoC in software systems: AOP provides a means for describing concerns which are normally spread throughout the whole program at one location. The arguments for introducing aspects into programming languages also hold for modeling languages. In particular, modeling state-crosscutting behavior is insufficiently supported by UML state machines. This often leads to model elements addressing the same concern scattered all over the state machine. We present an approach to aspect-oriented state machines, which show considerably better modularity in modeling state-crosscutting behavior than standard UML state machines.

Verification of scope-dependent hierarchical state machines

Mutual exclusion is a very common requirement in parallel systems. Yet its modeling is a tedious task in UML state machines, one of the most popular languages for behavior modeling. We present HiLA, an aspect-oriented extension of UML state machines, to address this problem. In HiLA, mutual exclusion can be modeled in a highly modular and declarative way. That is, the logic of mutual exclusion is modeled at a dedicated place rather than by model elements scattered all over the state machine, and the modeler only needs to specify which states to mutually exclude rather than how to exclude them.KeywordsState MachineGraph TransformationMutual ExclusionComposite StateConcrete SyntaxThese 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.

Use cases are commonly used to structure and document requirements while UML state machine diagrams often describe the behavior of a system and serve as a basis to automate test case generation in many model-based testing (MBT) tools. Therefore, automated support for the transition from use cases to state machines would provide significant, practical help for testing system requirements. Additionally, traceability could be established through automated transformations, which could then be used for instance to link requirements to design decisions and test cases, and assess the impact of requirements changes. In this paper, we propose an approach to automatically generate state machine diagrams from use cases while establishing traceability links. Our approach is implemented in a tool, which we used to perform three case studies, including an industrial case study. The results show that high quality state machine diagrams can be generated, which can be manually refined at reasonable cost to support MBT. Automatically generated state machines showed to largely conform to the actual system behavior as evaluated by a domain expert.

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.

With increasing need on underwater applications, the research on underwater acoustic networks (UANs) becomes more and more important. In addition to proposals for many protocols at each layer, the underwater network architecture is also in need of well-suited solutions. In recent years, several platforms have been proposed that can test a variety of protocols in both simulation and field test cases. Because most of them are extended from network simulators (e.g., NS-2 and NS-3), they require the user to be familiar with these simulator platforms to implement protocols, which is difficult and would waste time during the initial research phase. In fact, the state machine is a common way to describe a network protocol. As far as we know, however, current platforms do not include a state machine-based protocol design method. In this paper, we propose a framework for protocol design in UANs based on a hierarchical state machine (HSM). We have completed fundamental code implementation of this framework successfully in both pool environment and simulation channel. The proposed framework will be a great convenience to the study of UAN protocols.

The authors examine a class of discrete event systems (DESs) modeled as asynchronous hierarchical state machines (AHSMs). For this class of DESs, they provide an efficient method for testing reachability, which is an essential step in many control synthesis procedures. This method utilizes the asynchronous nature and hierarchical structure of AHSMs, thereby illustrating the advantage of the AHSM representation as compared with its equivalent (flat) state machine representation. An application of the method is presented where an online minimally restrictive solution is proposed for the problem of maintaining a controlled AHSM within prescribed legal bounds.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Path mapping is a very essential part of a mobile robot navigation system. In this work, a novel technique to map and plan path for a mobile service robot without any vision aids in indoor environment using hierarchical state machine with partially known paths is proposed. The known paths are taught to a robot using Learning by Demonstration technique (LfD). The first phase of the algorithm is to map the paths as a hierarchical state machine using the partially known paths. Second phase is to plan the path given the source and destination. The algorithm is implemented and tested using a 2D simulation environment platform, Player/Stage.

We describe a comprehensive approach for conformance testing of reactive systems. Based on a formal specification, namely UML state machines, we automatically generate test cases and use them to test the input-output conformance of a system under test. The test cases include not only the stimuli to trigger the system under test, they also include the test oracles to automatically evaluate the test execution. In contrast to Harel Statecharts, state machines behave asynchronously, which makes automatic test case generation a particular challenge. As a prerequisite we have completely formalized a substantial subset of UML state machines that includes complex structured data. The Teager tool suite implements our test approach and proves its applicability.KeywordsState MachineInput SequenceSystem Under TestEvent StoreTest ExecutionThese 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.

UML is widely accepted and practiced in industries for modeling and design of software systems. Software requirements and design are very important parts of software development, which must be validated and verified before implementation. UML State Machine diagram is an important formalism to model the dynamics of the system. In this paper, a comparative study of the test case generation techniques from UML State Machine diagram has been done. This study is an attempt to find out the work that has already been done in this field and various aspects of UML state machines that have been considered for generating test cases. Finally, this paper presents a scope to generate test data for complex state machine involving concurrent states and events.

A software architecture for smart watches supporting and securing the everyday life for the elderly is presented. The approach starts from the insight that the usage of smart watches for care-giving and handling personal health hazards is a best practice driven, empirical discipline, requiring a declarative, easy to maintain software description for the smart watch devices. The second rationale for the approach presented is the decomposition of the complex interrelations of "health hazards" into definable modules of manageable size, each addressing the handling an individual health hazard. The proposed, hierarchical architecture builds on the automatic detection of the activities and events of daily life (ADLs, EDLs) by the sensors of the smart watch. Handling of health hazards will be modeled by UML state machines, which utilize the detected ADL/EDLs for their state transitions. The architecture has to take account for a plenitude of relevant hazards, managed by a multitude of simultaneously operating state machines, via a central synchronizing control mechanism.

To reduce the verification costs and to be more confident on software, static program analysis offers ways to prove properties on source code. Unfortunately, these techniques are difficult to apprehend and to use for non-specialists. Modelling allows users to specify some aspects of software in an easy way. More precisely, in embedded software, state machine models are frequently used for behavioural design. The aim of this paper is to bridge the gap between model and code by offering automatic generation of annotations from model to source code. These annotations are then verified by static analysis in order to ensure that the code behaviour conforms to the model-based design. The models we consider are UML state machines with a formal non-ambiguous semantics, the annotation generation and verification is implemented in a tool and applied to a case study.

UML state machines are quite popular and useful to specify dynamic components of software systems. They have a formal static semantics but their execution semantics is described only informally. Graph transformation, on the other hand, constitutes a well-studied area with many theoretical results and practical application domains. In this paper, an operational semantics for a subset of UML state machines is proposed which is based on graph transformation. In more detail, a UML state machine is described as a structured graph transformation system in such a way that the wellformedness rules of UML state machines are satisfied and the firing of a (maximum) set of enabled non-conflicting transitions corresponds to the application of a graph transformation rule. The presented approach uses the concept of transformation units, a recently developed modularization concept for graph transformation systems.

One of the barriers to widespread adoption of behavior modeling languages lies in the complexity of the models. We show in the context of UML state machines how non-locality, i.e., the information for the current behavior of a model being spread over several model elements instead of being locally available, may make seemingly intuitive and simple models rather complex and error-prone. We present a set of metrics to measure the complexity of UML state machines arising from different kinds of non-locality. Our metrics give a better understanding of the complexity of UML state machines, and may alert the modeler to pay more attention to pitfalls in apparently simple UML state machines.

We propose an hierarchical state machine (HSM) model for specifying behavioral interfaces of peers participating in a composite Web service. We integrate the HSM model to a design pattern which is supported by a modular verification technique that can 1) statically analyze the properties about global interactions of a composite Web service and 2) check the conformance of the Java implementations of the participant peers to their interfaces. We extend the synchronizability analysis to HSMs to efficiently identify composite Web services whose global interactions can be analyzed with respect to unbounded queues using finite state model checkers. We also discuss automated translation of behavioral interfaces specified as HSMs to BPEL specifications to be published and used by other services.