Statecharts Research Papers - Academia.edu (original) (raw)

The purpose of this paper is to map the works in the Agent Oriented Software Engineering and Engineering Multi-Agent Systems fields that use the Statecharts paradigm to aid the software development process. We did not only focus on finding out the methods that employ statecharts, but also on identifying the application domains suitable for this kind of modeling. To achieve this goal we researched the available literature. We found out that statecharts are used by numerous methods that target diverse application domains such as robotics, internet agents, simulation, health and safety. Moreover, statecharts have been employed for modeling different things, such as the behaviour of agents, agent plans, agent interaction protocols. We also found reports of real-world systems and applications that were developed using these methods in the last 20 years and we identified trends and common characteristics that they have. Concluding, we have mapped the area where statecharts meet agent oriented methodologies both in theory and practice. Moreover, we provide some exciting directions for future works.

This work aims to bring forward the intersection between the world of statecharts and that of agent technology. We begin by disambiguating the different terms related to statecharts, i.e. state machines and finite state automata / machines. Subsequently we review their impact to agent technology, mainly in the area of Agent-Oriented Software Engineering. Our findings are that multi-agent systems modeling has used and, some times, extended the language of statecharts, mainly for modeling agent interaction protocols and for coordinating the different modules of an agent. We conclude with some future directions related to the use of statecharts by the Multi-agent Systems community in the coming years.

Modern model-driven engineering and Agent-Oriented Software Engineering (AOSE) methods are rarely utilized in developing robotic software. In this paper, we show how a Model-Driven AOSE methodology can be used for specifying the behavior of multi-robot teams. Specifically, the Agent Systems Engineering Methodology (ASEME) was used for developing the software that realizes the behavior of a physical robot team competing in the Standard Platform League of the RoboCup competition (the robot soccer world cup). The team consists of four humanoid robots, which play soccer autonomously in real time utilizing the on-board sensing, processing, and actuating capabilities, while communicating and coordinating with each other in order to achieve their common goal of winning the game. Our work focuses on the challenges of coordinating the base functionalities (object recognition, localization, motion skills) within each robot (intra-agent control) and coordinating the activities of the robots towards a desired team behavior (inter-agent control). We discuss the difficulties we faced and present the solutions we gave to a number of practical issues, which, in our view, are inherent in applying any AOSE methodology to robotics. We demonstrate the added value of using an AOSE methodology in the development of robotic systems, as ASEME allowed for a platform-independent team behavior specification, automated a large part of the code generation process, and reduced the total development time.

- by Nikolaos Spanoudakis and +2
- •
- Robotics, Model-Driven Development, Model-Driven Engineering, Agent Oriented Software Engineering

The development of high-level behavior for autonomous robots is a time-consuming task even for experts. This paper presents a Computer-Aided Software Engineering (CASE) tool, named Kouretes Statechart Editor (KSE), which enables the developer to easily specify a desired robot behavior as a statechart model utilizing a variety of base robot functionalities (vision, localization, locomotion, motion skills, communication). A statechart is a compact platform-independent formal model used widely in software engineering for designing software systems. KSE adopts the Agent Systems Engineering Methodology (ASEME) model-driven approach. Thus, KSE guides the developer through a series of design steps within a graphical environment that leads to automatic source code generation. We use KSE for developing the behavior of the Nao humanoid robots of our team Kouretes competing in the Standard Platform League of the RoboCup competition.

- by Nikolaos Spanoudakis
- •
- Robotics, Software Engineering, Model-Driven Development, CASE Tools
- by Steve Reeves
- •
- Statecharts

Developing intuitive interactive applications that are easy to maintain by developers is quite challenging, due to the complexity and the many technical aspects involved in such applications. In this article, we tackle the problem in two complementary ways. First, we propose a gestural interface to improve the user experience when interacting with applications that require the manipulation of 3D graphical scenes. Second, we reduce the complexity of developing such applications by modeling their executable behaviour using statecharts. We validate our approach by creating a modular and extensible Java framework for the development of interactive gesture-based applications. We developed a proof-of-concept application using this framework, that allows the user to construct and manipulate 3D scenes in OpenGL by using hand gestures only. These hand gestures are captured by the Kinect sensor, and translated into events and actions that are interpreted and executed by communicating statecharts that model the main behaviour of the interactive application.

- by Tom Mens and +1
- •
- Human Computer Interaction, Natural User Interfaces, Gesture Recognition, Tangible User Interfaces
- by Steve Reeves
- •
- Statecharts

In the area of model based testing, major improvements have been made in the generation of conformance tests using a model checker. Unfortunately, the execution of the generated test suites tend to be rather time-consuming. In [1] we presented a method to generate the test suites with the shortest execution time providing the required coverage, but this method can only be applied to small models due to memory-consumption. Here we show how to generate test suites for a number of different test quality criteria like coverage criteria, UIOs, mutant testing. Moreover, we present heuristics to significantly reduce test execution time that are as efficient as a naive testsuite generation. Our optimization combines min-set-cover-algorithms and search strategies, which we use to enlengthen generated test cases by promising additional coverages. We compare several heuristics and present a case study where we could achieve a reduction of the test execution time to less than 10%.

- by Michaela Huhn
- •
- Statecharts
- by shyamasundar R.K.
- •
- Distributed System, Statecharts, Asynchronous Communication, Signal
- by SD Dewasurendra
- •
- Computer Science, Control, Controllability, Statecharts

Abstract: Simplified statecharts are derived by excluding all redundant constructs of the UML (Unified Modeling Language) metamodel on statecharts. In previous papers we introduced this basic concept and pointed out some interesting applications. We transformed and compacted state machines into serializable objects that clearly highlight their basic constructs and showed how a lot of sparse edges were created during this transformation. Sparse edges contain little or no information (e.g. empty transitions). From this compaction we derived a theory in which state machines are reduced to two distinct partial orderings on states. For the sake of convenience to read this paper, we briefly recapture part of this theory and show the exponentially growing complexity of calculating all possible values of variables that appear on state machine edges. In order to arrive at feasible algorithms leading to practical applications of the implicity complex partial ordering relations we need to redu...

- by Bert Hoogewijs
- •
- Model Checking, UML, Statecharts, Key words

Demonstrating support for state diagrams security issue. New documentation set that broadens UML state diagram documentation. Semantics required in state based security. Model driven security has turned into a dynamic range of exploration amid the previous decade. While numerous examination works have contributed fundamentally to this goal by stretching out famous demonstrating documentations to model security angles, there has been small displaying support for state-based perspectives of security issues. This framework attempts an investigative way to deal with propose another notational set that augments the UML (Unified Modeling Language) statecharts documentation. An online mechanical review was led to gauge the view of the new documentation as for its semantic straightforwardness and also its scope of demonstrating state based security viewpoints. The overview results show that the new documentation incorporates the arrangement of semantics required in a state based security displaying dialect and were to a great extent instinctive to utilize and comprehend gave next to no preparation. A subject-based observational assessment utilizing programming building experts was additionally directed to assess the psychological adequacy of the proposed documentation. The fundamental finding was that the new documentation is psychologically more powerful than the first notational set of UML statecharts as it permitted the subjects to peruse models made utilizing the new documentation much snappier.

- by IAEME Publication
- •
- Statecharts, Industrial survey, Iaeme Ijcet, Security modeling
- by Ravindra Naik
- •
- Program Analysis, Statecharts, Embedded C programming, Reverse Engineering Software