• Corpus ID: 14143566

Modeling State Diagrams with And-Cross Transitions

@inproceedings{Adesina2016ModelingSD,
  title={Modeling State Diagrams with And-Cross Transitions},
  author={Opeyemi O. Adesina and St{\'e}phane S. Som{\'e} and Timothy C. Lethbridge},
  booktitle={MoDeVVa@MoDELS},
  year={2016}
}
We propose an approach to encode state diagrams with and-cross transitions. The notion of and-cross transitions is being rejected by researchers and practitioners in model-driven engineering community for reasons that include limited use-inpractice, unmanageable underlying complexity, and availability of alternative modeling solutions. In this paper, we show that and-cross transitions can be useful in practice and its underlying structural complexity can be managed for the purpose of analysis. 

Figures from this paper

Model-Driven Testing in Umple

Umple supports ‘abstract’ classes by allowing the use to declare any Umple class as ’ab abstract’, which is meant to define properties of a particular entity without allowing the user to directly instantiate the entity.

Integrating Formal Methods with Model-Driven Engineering

The goal of this research is to provide an easy-to-use approach for using formal methods for industrial and academic purposes and to demonstrate that the constraints and generated formal methods code represent the patterns faithfully.

References

SHOWING 1-10 OF 27 REFERENCES

Statecharts: A Visual Formalism for Complex Systems

  • D. Harel
  • Computer Science
    Sci. Comput. Program.
  • 1987

A manifestation of model-code duality: facilitating the representation of state machines in the umple model-oriented programming language

This work suggests that code enhanced with state machine modeling abstractions is semantically equivalent to visual state machine models, and enhances the code to be almost as expressive as the model.

Integrating Formal Methods with Model-Driven Engineering

The goal of this research is to provide an easy-to-use approach for using formal methods for industrial and academic purposes and to demonstrate that the constraints and generated formal methods code represent the patterns faithfully.

Symbolic model checking of hierarchical UML state machines

A compact symbolic encoding is described for the transition relation of systems modeled with asynchronously executing, hierarchical UML state machines that communicate through message passing and

Model Driven Engineering

These early languages and platforms provided abstractions of the solution space—that is, the domain of computing technologies themselves—rather than abstraction of the problem space that express designs in terms of concepts in application domains.

Merging Modeling and Programming Using Umple

It is discussed how Umple merges modeling and programming by adding modeling constructs to programming languages and vice-versa, and how key benefits of textual programming languages are found in Umple, as are important features of modeling technology.

Mapping Big-Step Modeling Languages to SMV

We propose an algorithm for creating a semantics-based, parameterized translator from the family of big-step modeling languages (BSMLs) to the input language of the model checker SMV. Our translator

UMLtoCSP: a tool for the formal verification of UML/OCL models using constraint programming

UMLtoCSP is a tool for the formal verification of UML/OCL models that is able to automatically check several correctness properties, such as the strong and weak satisfiability of the model or the lack of redundant constraints.

Model checking large software specifications

The results and experiences of using symbolic model checking to study the specification of an aircraft collision avoidance system and the approach to translating the specification to the SMV language and methods for achieving acceptable performance are reported.

Enhanced code generation from UML composite state machines

This paper presents a new approach that transforms a composite state machine into an equivalent set of simple state machines before code generation, which avoids the combinatorial explosion and leads to more concise and scalable generated code.