Statechart Diagrams Research Articles

Aspect Mining Based on Object-Oriented Systems’ Dynamic Behavior Models

Aspect mining is a reverse engineering process that aims at finding crosscutting concerns in existing systems. This paper describes an aspect mining approach making use of the results of reverse engineering, statechart diagram, to aid in the understanding of an object-oriented software system’s behaviors. An aspect based on the recovered statechart diagram is defined as a set of states and an event. These states will transit to the same state after they send the event. Finally, systematic experiment is conducted in the paper in order to verify the correctness and validity of this approach.

PENGEMBANGAN APLIKASI PERMAINAN SCRABBLE DUA BAHASA MENGGUNAKAN JAVA

Game applications are favored by many computer users. The population of Indonesia, especially common people do not like playing games in a foreign language. Yet such games can be a fun learning media for foreign languages , especially English. Hence, we developed a game application using the concept of the game Scrabble. The design of this application uses a waterfall methodology, with application design modeling with UML diagrams (Unified Modelling Language) including Use Case Diagram, Activity Diagram, Statechart Diagram, Class Diagram and Sequence Diagram. In the implementation phase, Blue J software used to build the interface using the Java Development Kit (JDK) version jdk1.6.0_02 as the executor, as well as using the command prompt to call the results of execution. Tests on gaming applications are performed using the Black Box and White Box method. The product of this development is a single player game application, which uses two language options.Keywords: game applications, Scrabble, waterfall software engineering methodologies, UML (Unified Modeling Language), Java Programming.

UML-BASED MODELING AND ANALYSIS OF SECURITY THREATS

Poor design has been a major source of software security problems. Rigorous and designer-friendly methodologies for modeling and analyzing secure software are highly desirable. A formal method for software development, however, often suffers from a gap between the rigidity of the method and the informal nature of system requirements. To narrow this gap, this paper presents a UML-based framework for modeling and analyzing security threats (i.e. potential security attacks) rigorously and visually. We model the intended functions of a software application with UML statechart diagrams and the security threats with sequence diagrams, respectively. Statechart diagrams are automatically converted into a graph transformation system, which has a well-established theoretical foundation. Method invocations in a sequence diagram of a security threat are interpreted as a sequence of paired graph transformations. Therefore, the analysis of a security threat is conducted through simulating the state transitions from an initial state to a final state triggered by method invocations. In our approach, designers directly work with UML diagrams to visually model system behaviors and security threats while threats can still be rigorously analyzed based on graph transformation.

Statechart-based Controllers Synthesis in FPGA Structures with Embedded Array Blocks

Statechart-based Controllers Synthesis in FPGA Structures with Embedded Array BlocksStatechart diagrams, in general, are visual formalism for description of complex systems behaiour. Digital controllers, which act as reactive systems, can be very conveniently modeled with statecharts and efficiently synthesized in modern programmable devices. The paper presents in details syntax and semantics of statecharts and new implementation scheme. The issue of statecharts synthesis is not still ultimately solved. Main feature of the presented approach is the transformation of statechart diagrams into Finite State Machine, and through KISS format, functional decomposition and mapping into Embedded Memory Blocks. Embedded Memory are part of the modern programmable devices.

The impact of structural complexity on the understandability of UML statechart diagrams

The effectiveness of current software development strategies, such as Model-Driven Development (MDD), depends largely on the quality of their primary artefacts, i.e. software models. As the standard modelling language for software systems is the Unified Modelling Language (UML), quality assurance of UML models is a major research field in Computer Science. Understandability, i.e. a model’s ability to be easily understood, is one model quality property that is currently heavily under investigation. In particular, researchers are searching for the factors that determine an UML model’s understandability and are looking for ways to manipulate these factors. This paper presents an empirical study investigating the effect that structural complexity has on the understandability of one particular type of UML model, i.e. the statechart diagram. Based on data collected in a family of three experiments, we have identified three dimensions of structural complexity that affect understandability: (i) the size and control flow complexity of the statechart in terms of features such as the number of states, events, guards and state transitions; (ii) the actions that are performed when entering or leaving a state; (iii) the sequence of actions that is performed while staying within a state. Based on these structural complexity dimensions we have built an understandability prediction model using a regression technique that is specifically recommended for data obtained through a repeated measures design. Our test results show that each of the underlying structural complexity dimensions has a significant impact on the understandability of a statechart diagram.

Assessing the understandability of UML statechart diagrams with composite states—A family of empirical studies

The main goal of this work is to present a family of empirical studies that we have carried out to investigate whether the use of composite states may improve the understandability of UML statechart diagrams derived from class diagrams. Our hypotheses derive from conventional wisdom, which says that hierarchical modeling mechanisms are helpful in mastering the complexity of a software system. In our research, we have carried out three empirical studies, consisting of five experiments in total. The studies differed somewhat as regards the size of the UML statechart models, though their size and the complexity of the models were chosen so that they could be analyzed by the subjects within a limited time period. The studies also differed with respect to the type of subjects (students vs. professionals), the familiarity of the subjects with the domains of the diagrams, and other factors. To integrate the results obtained from each of the five experiments, we performed a meta-analysis study which allowed us to take into account the differences between studies and to obtain the overall effect that the use of composite states has on the understandability of UML statechart diagrams throughout all the experiments. The results obtained are not completely conclusive. They cast doubts on the usefulness of composite states for a better understanding and memorizing of UML statechart diagrams. Composite states seem only to be helpful for acquiring knowledge from the diagrams. At any rate, it should be noted that these results are affected by the previous experience of the subjects on modeling, as well as by the size and complexity of the UML statechart diagrams we used, so care should be taken when generalizing our results.

Statechart Diagrams Implementation in FPGA Structures with Embedded Memory Blocks

Statechart diagrams, also called state machines, are graphic formalism for behavior description of complex systems. One of many applications of statecharts is description of reactive systems, especially digital controllers. There are many strategies of statecharts-based controller implementations, but there is no universal one. In the paper authors have presented new synthesis algorithms. Statecharts diagrams, through FSM form, are transformed into memory blocks using address register and ROM memory with reduced memory size obtained by the introduction of address modification. Good feature of the new algorithm is usage of dedicated Embedded Memory Blocks, whereas traditional logic cells can be used for other purposes.

Automated UML models merging for web services testing

This paper presents a method for merging Unified Modelling Language (UML) models, which takes place in a quality evaluation framework for Web Services (WSs). This framework, called iTac Tests and Certified Quality of Services (iTac-QoS), is an extended Universal Description Discovery and Integration (UDDI) server using model-based testing to assess quality. Depending on the results of the test execution, a mark is given to the WSs. Until now, our framework was limited to WSs without composition. This was justified by the fact that it is impossible for vendors to create a good model of a foreign product. Our method proposes to automatically merge the models (produced by each vendor) of the WSs involved in the composition. For each type of diagram present in the models (class, instance or statechart diagram), a method is proposed to produce a unique model. In addition to this, a solution is proposed to merge all Object Constraint Language (OCL) codes in the class modelling the WSs under study. Unfortunately, this process introduces inconsistencies in the resulting model that falsify the results of the test generation phase. We thus propose detecting such inconsistencies to distinguish inconsistent and unreachable test targets.

Specifying behavioral semantics of UML diagrams through graph transformations

The Unified Modeling Language (UML) has been widely accepted as a standard for modeling software systems from various perspectives. The intuitive notations of UML diagrams greatly improve the communication among developers. However, the lack of a formal semantics makes it difficult to automate analysis and verification. This paper offers a graphical yet formal approach to specifying the behavioral semantics of statechart diagrams using graph transformation techniques. It supports many advanced features of statecharts, such as composite states, firing priority, history, junction, and choice. In our approach, a graph grammar is derived automatically from a state machine to summarize the hierarchy of states. Based on the graph grammar, the execution of a set of non-conflict state transitions is interpreted by a sequence of graph transformations. This facilitates verifying a design model against system requirements. To demonstrate our approach, we present a case study on a toll-gate system.

Simulation-based analysis of UML statechart diagrams: methods and case studies

We present a comprehensive unified modeling language (UML) statechart diagram analysis framework. This framework allows one to progressively perform different analysis operations to analyze UML statechart diagrams at different levels of model complexity. The analysis operations supported by the framework are based on analyzing Petri net models converted from UML statechart diagrams using a previously proposed transformation approach. After introducing the general framework, the paper emphasizes two simulation-based analysis operations from the framework: direct MSC inspection, which provides a visual representation of system behavior described by statechart diagrams; and a pattern-based trace query technique, which can be used to define and query system properties. Two case-study examples are presented with different emphasis. The gas station example is a simple multi-object system used to demonstrate both the visual and query-based analysis operations. The early warning system example uses only one object, but features composite states and includes analysis specifically aimed at one composite state feature, history states.

Modeling distributed real-time applications with specification PEARL

The methodology of hardware/software co-design of embedded control systems with Specification PEARL is presented. Hardware and software are modeled with the language Specification~PEARL, which has its origins in standard Multiprocessor~PEARL. Its usefulness is enhanced for modeling hierarchical and asymmetrical multiprocessor systems, and by additional parameters for schedulability analysis. Graphical symbols are introduced for its constructs to enable graphical modeling while maintaining the semantical background. It is meant to be a superlayer for programs, based on the PEARL programming model. To model program tasks, Timed State Transition Diagrams have been defined. The model of a co-designed system is verified for feasibility with co-simulation. The resulting information should be used when considering changes in a current design with the goal of producing a temporally feasible model. To support dynamic re-configurations, configuration management is introduced into the models. Since UML is becoming a de facto standard also for designing embedded control systems, and since Timed State Transition Diagrams and State Chart Diagrams share great similarity, an interface of the methodology to UML 2 is defined, using UML's extension mechanisms.

Modelling and model checking suspendible business processes via statechart diagrams and CSP

When modelling object behaviour with UML statechart diagrams, the history mechanism can be useful for modelling the suspension of a “normal” business process upon certain “abnormal” events together with the subsequent resumption, as illustrated by the examples in this paper. However, previous approaches to model checking statechart diagrams often ignore the history mechanism. We enhanced such a previous approach based on Communicating Sequential Processes (CSP) and developed a support tool for it.

5.3.3 SysML‐Based Systems Engineering Using a Model‐Driven Development Approach

AbstractMore and more, systems engineers are turning to the System Modeling Language (SysML) to specify and structure their systems. This has many advantages, including verifiability and ease of passing off information to other engineering disciplines, particularly software. This article describes a SysML‐based process that systems engineers can use to capture requirements and specify architecture. The process uses the SysML exclusively for the representation and specification of system characteristics. Essential SysML artifacts include use case diagrams, sequence diagrams, activity diagrams, statechart diagrams, and structure diagrams. The process is function‐driven and is based heavily on the identification and elaboration of operational contracts, a message‐based interface communication concept. The outlined process has been applied successfully at various customer sites.

A Method for Automatic Generation of OWL-S Service Ontology

We present in this paper the methodology for automatic generation of OWL-S service model ontology along with the results and issues. First, we extract information related to atomic services and their properties such as IOPE from the UML class diagram, and retrieve information related to the composition of services from the UML state-chart diagram. Then, the XSLT applications utilize the acquired information to generate the OWL-S service model ontology through the predefined mappings between OWL-S constructs for composite services and UML state-chart primitives. For the justification of generated service ontology, several validation checks are performed. Our service ontology generation method is general and fully automatic, as well as effective, in that it is achieved in an environment familiar to developers, and information needed to generate service ontology is provided necessarily during service development. It is also noticeable to facilitate representing the condition with GUI rather than a complex language such as OCL.

Metamodel-Based Model Transformation with Aspect-Oriented Constraints

Model transformation means converting an input model available at the beginning of the transformation process to an output model. A widely used approach to model transformation uses graph rewriting as the underlying transformation technique. In case of diagrammatic languages, such as the Unified Modeling Language (UML), the exclusive topological matching is found to be not enough. To define precisely the transformation steps beyond the topology of the visual models, additional constraints must be specified which ensures the correctness of the attributes, or other properties to be enforced. Dealing with OCL constraints provides a solution for these unsolved issues, because topological and attribute transformation methods cannot perform and express the problems which can be addressed by constraint validation. The use of OCL as a constraint and query language in modeling is essential. We have shown that it can be applied to model transformations as well. Often, the same constraint is repetitiously applied in many different places in a transformation. It would be beneficial to describe a common constraint in a modular manner, and to designate the places where it is to be applied. This paper presents the problem of crosscutting constraints in transformation rules, and provides an aspect-oriented solution for it. Our approach makes it possible to define constraints separately from the transformation steps, and facilitates specifying their propagation assignment to graph transformation rules. To illustrate the conceptual results, a case study is also provided, which introduces (i) how our approach generates user interface handler source code for mobile platform from a resource model and a statechart diagram, and (ii) how it validates specific properties during the transformation steps using aspect-oriented constraints.

FROM STATECHARTS TO FSM-DESCRIPTION - TRANSFORMATION BY MEANS OF SYMBOLIC METHODS

Statechart diagrams are very convenient way in specifying behavior of reactive systems and controllers in particular. The system modelled as a statechart can be directly implemented in reprogrammable devices. Mathematical model of statechars gives an opportunity to verify symbolically some properties and to transform into FSM-description. Having statechart in FSM-description allow to implement controllers in embedded array blocks.

Automated Prototyping of User Interfaces Based on UML Scenarios

User interface (UI) prototyping and scenario engineering have become popular techniques. Yet, the transition from scenario to formal specifications and the generation of UI code is still ill-defined and essentially a manual task, and the two techniques lack integration in the overall requirements engineering process. In this paper, we suggest an approach for requirements engineering that generates a user interface prototype from scenarios and yields a formal specification of the application. Scenarios are acquired in the form of collaboration diagrams as defined by the Unified Modeling Language (UML), and are enriched with user interface (UI) information. These diagrams are automatically transformed into UML Statechart specifications of the UI objects involved. From the set of obtained specifications, a UI prototype is generated that is embedded in a UI builder environment for further refinement. Based on end user feedback, the collaboration diagrams and the UI prototype may be iteratively refined, and the result of the overall process is a specification consisting of the Statechart diagrams of all the objects involved, together with the generated and refined prototype of the UI. The algorithms underlying this process have been implemented and exercised on a number of examples.

Toward an Automated Attack Model for Red Teams

To better understand system vulnerabilities, proactive security services use red teams that simulate malicious attacks. The authors contend that an attack model with UML-based use cases, sequence and state chart diagrams, and XML would best help red teams achieve attack automation.

Web services composition using software agents and conversations

This paper discusses the process of integrating software agents and conversations into the composition of web services. A web service is a component that an organization provides in order to be assembled and re-used in a distributed, Internet-based environment. Acting on behalf of users, software agents are responsible for various operations such as discovering the web services that satisfy user needs, gathering the appropriate web services into composite services, and monitoring the execution of the composite services. While carrying out these operations, the software agents engage in conversations with their peers in order for example to agree on the web services that will take part in a composition. These conversations are specified with state chart diagrams, which are enhanced with awareness mechanisms for assessing the execution contexts of web services.

QoS modelling and analysis with UML-statecharts

The UML is an influential and widespread notation for high-level modelling of information processing systems. UML statechart diagrams are a graphical language to describe system behaviour. They consitute one of the most intensively-used formalisms comprised by the UML. However, statechart diagrams are lacking concepts for describing real-time, performance, dependability and quality of service (QoS) characteristics at a behavioural level.This note describes a QoS-oriented extension of UML statechart diagrams, called StoCharts. StoCharts enhance the basic statechart formalism with two distinguished features, both simple and easy to understand, yet powerful enough to model a sufficiently rich class of stochastic processes. This is illustrated by a selection of case studies performed using StoCharts. We review the main ingredients of StoCharts and survey tool support and case studies performed with the language, and place StoCharts in the context of other extensions of statechart diagrams.