Interaction Overview Diagrams Research Articles

Perancangan Sistem Produksi Lampu dengan Metode Perancangan Berorientasi Objek di PT. Cosmo Technology Indonesia Kabupaten Sukabumi

The development of information technology (IT) so rapidly, including for the field of ERP (Enterprice Resources Planning). To design and build an ERP system, it is necessary to first analyze the system to be built, especially for the design of Rekayas Software (RPL). The results of this study are expected to find the results of good and correct analysis so as to be able to implement the system into a program using JAVA.
 
 This research consists of several parts analysis. The core of this research is to review the problems that exist in the company, in determining user requirements or user needs, then generate design in the form of diagrams used as a system design tool. The point explanation that will be done is Business Overview, Organizational Structure, Department Description, User Requirement. While the design of the system using UML consisting of several diagrams are Activity Diagram, Use Case Diagram, Sequence Diagram, Class Diagrams, Entity Diagrams, Communication diagrams, State Machine Diagrams, Component Diagrams, Deployment Diagrams, Composite Structure Diagrams, Interaction Overview Diagrams, Object Diagrams , Package Diagram, Timing Diagram,
 
 The author takes the object case that is PT. COSMO TECHNOLOGY which is located at Jl. Raya Segog Km.14 Batununggal Village Kec. Cibadak, Sukabumi-West Java. Is a company engaged in decorative lights and is developing a business in the field of toys.
 
 Keywords: ERP, UML
 
 

Simulation modeling in the process of loading the machine and tractor fleet

The article describes the use of simulation modeling as a method to increase the efficiency of the formation of the machine and tractor fleet (MTF). The advantages of the use of simulation modeling in combination with traditional approaches to the formation of the MTF are presented. A model of verification of the production plan of an agricultural enterprise has been formed taking into account the use of simulation modeling. The place and role, conceptual requirements, an interaction overview diagram have been determined and basic parameters of the simulation model have been identified which satisfy the process under study. The simulation model can be used both as an independent program module and as part of software systems related to the management of the production resources of agricultural organizations.

Precise use cases in a context-aware model-checking approach

Formal verification exhibits well known benefits but comes at the price of formalising precise and sound requirements, what often remains a challenging task for engineers. We propose a high-level formalism for expressing requirements based on interaction overview diagrams, which orchestrate activity diagrams that we automatically derived from use cases. Informal requirements are transformed into scenarios which fuel a context-aware model-checking approach. The approach assumes the availability of a formal model of the system, such as concurrent and communicating automata and a set of requirements specified in the form of contexts, which point out boundaries between the system and its environment. The requirement specification approach blends elaboration and transformation phases. Thanks to this blending, the semantic gap between informal and formal requirements is reduced, while model-checking is improved by contexts modelling. As a consequence, engineers gain support for moving towards formal verification.

Context-aware approach for formal verification

The Context-aware approach has proven to be an effective technique for software model-checking verification. It focuses on the explicit modelling of environment as one or more contexts. In this area, specifying precise requirement is a challenged task for engineer since often environmental conditions lack of precision. A DSL, called CDL, has been proposed to facilitate the specification of requirement and context. However, such language is still low-level and error prone, difficult to grasp on complex models and assessment about its usability is still mitigated. In this paper, we propose a high level formalism of CDL to facilitate specifying contexts based on interaction overview diagrams that orchestrate activity diagrams automatically transformed from textual use cases. Our approach highlights the boundaries between the system and its environment. It is qualified as model-checking context-aware that aims to reduce the semantic gap between informal and formal requirements, hence the objective is to assist and encourage engineers to put sufficient details to accomplish effectively the specification process.

An Automated Transformation Approach for Requirement Specification

Use cases are often useful in capturing requirements by defining goal-oriented set of interactions between the system and its environment. Formalization of precise requirement is then important for context-aware verification based on use cases scenarios in the form of contexts. In this paper, we propose a high-level formalism for expressing requirements based on interaction overview diagrams that orchestrate activity diagrams automatically transformed from textual use cases. Our approach is qualified as context-aware model-checking; it supposes the availability of the system model as concurrent communicating automata and a specification language for describing requirements. Specification of requirements is performed through transformation phases to generate intermediate artefacts able to reduce the semantic gap between informal and informal requirement. The transformation is based on meta-models implemented in Ecore environment, algorithm and rules are defined using QVT Relational language, and primarily illustrated on an example.

Formalization and Verification of Hierarchical Use of Interaction Overview Diagrams Using Timing Diagrams

Thanks to its graphical notation and simplicity, Unified Modeling Language (UML) is a de facto standard and a widespread language used in both industry and academia, despite the fact that its semantics is still informal. The Interaction Overview Diagram (IOD) is introduced in UML2; it allows the specification of the behavior in the hierarchical way. This paper is a contribution towards a formal dynamic semantics of UML2. We start by formalizing the Hierarchical use of IOD. Afterward, we complete the mapping of IOD, Sequence Diagrams and Timing Diagrams into Hierarchical Colored Petri Nets (HCPNs) using the Timed colored Petri Nets (timed CP-net). Our approach helps designers to get benefits from abstraction as well as refinement at more than two levels of hierarchy which reduces verification complexity.

Automatic code generation from unified modelling language sequence diagrams

Unified modelling language (UML) is a visual modelling language, which has gained popularity among software practitioners. In a model-driven software development environment, the existing UML tools mainly support automatic generation of structural code from UML class diagrams. However, the code generation from UML diagrams such as statechart, activity, collaboration and sequence diagrams (SDs) are not supported by most UML tools and also have scarcely been reported in the literatures. This work proposes an approach to automatic generation of code from UML 2.x SDs of use cases. From the XML metadata interchange (XMI) representation of an SD of a use case, the authors construct a graph model called sequence integration graph (SIG). The SIG encapsulates information related to messages, control flow and method scope of interactions. These information are then used to generate code. The proposed approach has been tested using a number of real-life application systems and the results substantiate the efficacy of the approach to synthesise the code for controller classes. The authors observe that approximately 48% of the total lines of code within controller class methods can be generated with the proposed approach. The proposed approach can be easily extended to other behavioural UML models such as interaction-overview diagrams, communication diagrams and activity diagrams.

Risk analysis: a guiding force in the improvement of testing

The authors propose a state-based risk assessment methodology at the analysis and design stage of Software Development Life Cycle. First, a method is proposed to estimate the risk for various states of a component within a scenario and then, the risk for the whole scenario is estimated. The key data needed for risk assessment are complexity and severity. An Inter-Component State-Dependence Graph is introduced to estimate the complexity for a state of a component within a system. The severity for a component within a scenario is decided based on three hazard techniques: Functional Failure Analysis, Software Failure Mode and Effect Analysis and Software Fault Tree Analysis. The risk for a scenario is estimated based on the risk of interacting components in various states within the scenario and State COllaboration TEst Model of the scenario. Finally, the system risk is estimated based on two inputs: scenarios risks and Interaction Overview Diagram of the system. The methodology is applied on a Library Management System case study. An experimental comparative analysis is performed and observed that the testing team guided by our state-based risk assessment approach achieves high test efficiency compared with it with an existing component-based risk assessment approach.

Validation environment of UML2 IOD based on hierarchical coloured Petri nets

A new interaction diagram, called Interaction Overview Diagram or IOD, was introduced in the second generation of UML. It defines interactions through a variant of activity diagrams in a way that promotes overview of the control flow. But its semantics remains unclear thus requiring formalisation tasks. We propose in this paper a validation environment for UML IODs. So we first formalise their semantics by translation to the semantics domain of Hierarchical Coloured Petri Nets, or HCPNs for short. The derived HCPN models are afterwards analysed by means of the model-checker CPNtools. The analysis tackles the simulation, verification and validation aspects. It especially focuses on the validation of system properties written by the UML designer. The properties are expressed in OCL and then automatically translated into ASKCTL temporal logic. A case study of an ATM system illustrates the approach.

A proposal for extending UML-B to support a conceptual model

UML-B is a development process framework for Event-B based on a "UML-like" graphical formal notation that provides support for object-oriented modelling concepts, in particular, for class and state machine diagrams. However, this methodology has a gap for mapping requirements to formal specifications. To overcome this issue, we present a proposal for extending UML-B to support a conceptual model to provide an easier starting point for the actual development process. More precisely, we propose two diagrams to facilitate the passing from requirements to the initial formal model: a first one to represent system behavior based on UML 2 interaction overview diagram (IOD) and a second one for system structure based on boundary-control-entity stereotyped class diagram (BCE). We show how to translate the former into an Event-B specification and explain how to link the latter to the original UML-B using a simple ATM example as proof of concept.

UML interaction model-driven runtime verification of Java programs

The authors use unified modelling language (UML) 2.0 interaction overview diagrams (IODs) and sequence diagrams to construct simple and expressive scenario-based specifications, and present an approach to runtime verification of Java programs for exceptional consistency and mandatory consistency. The exceptional consistency requires that any forbidden scenario described by a given IOD never happens during the execution of a program, and the mandatory consistency requires that if a reference scenario described by a given sequence diagram occurs during the execution of a program, it must immediately adhere to a scenario described by a given IOD. In the approach, the authors first instrument a program under verification so as to gather the program execution traces related to a given scenario-based specification; then they drive the instrumented program to execute for generating the program execution traces; finally they check if the collected program execution traces satisfy the given specification. The approach leads to a supporting tool for testing in which UML interaction models are used as automatic test oracles to detect the wrong temporal ordering of message interaction in programs.

UML‐based regression testing for OO software

AbstractIn software maintenance, a system has to be regression tested after modifying it. The goal of regression testing is to ensure that modifications have not adversely affected the system. Regression test selection determines a subset of test cases, from the initial test suite, which concentrates on the parts of the system affected by the modification. Previous techniques have been mainly code‐based and several of them have addressed procedural programs. When working with large and complex object‐oriented systems, source code‐based regression testing is usually costly. This paper proposes a programming‐language‐independent technique for regression test selection for object‐oriented software based on Unified Modeling Language (UML 2.0) design diagrams. These diagrams are: the newly introduced interaction overview diagram, class diagrams, and sequence diagrams. We assume a test suite that contains both unit and system test cases. Based on the software changes reflected in the class and the interaction overview diagrams, our proposed technique selects test cases in phases. In the first phase, we select both unit and system test cases that directly traverse the changed methods and their calling methods. For the second phase, we present algorithms for detecting system level changes in the interaction overview diagram. If the change is at the action level, which is represented by a sequence diagram, only the test cases that execute changed methods will be selected. We apply our proposed technique to a few object‐oriented subject applications and evaluate its precision and inclusiveness in addition to the number of selected tests; the results demonstrate the advantages of the technique. Copyright © 2010 John Wiley & Sons, Ltd.

Synthesizing hierarchical state machines from expressive scenario descriptions

There are many examples in the literature of algorithms for synthesizing state machines from scenario-based models. The motivation for these is to automate the transition from scenario-based requirements to early behavioral design models. To date, however, these synthesis algorithms have tended to generate flat state machines which can be difficult to understand or adapt for practical systems. One of the reasons for this is that relationships between scenarios are often not taken into account during synthesis—either because the relationships are not explicitly defined or because the synthesis algorithms are not sophisticated enough to cope with them. If relationships are not considered, it is impossible for a synthesis algorithm to know, for example, where one scenario stops and another continues. Furthermore, the lack of relationships makes it difficult to introduce structure into the generated state machines. With the introduction of interaction overview diagrams (IODs) in UML2.0, relationships such as continuation and concurrency can now be specified between scenarios in a way that conforms to the UML standard. But synthesis algorithms do not currently exist that take into account all of these relationships. This article presents a novel synthesis algorithm for an extended version of interaction overview diagram. This algorithm takes into account not only continuation and concurrency, but also preemption, suspension and the notion of a negative scenario. Furthermore, the synthesis algorithm generates well-structured state machines. These state machines are executable and can therefore be used to validate the scenarios. The hierarchy generated aids readability and so the state machines are more amenable to subsequent design steps. Our IOD extensions have a formal semantics and are supported by a synthesis and execution tool, UCSIM, which is currently provided as a plug-in to IBM Rational Software Modeler.

Extending interaction overview diagrams with activity diagram constructs

UML2.0 introduced interaction overview diagrams (IODs) as a way of specifying relationships between UML interactions. IODs are a variant of activity diagrams that show control flow between a set of interactions. The nodes in an IOD are either inline interactions or references to an interaction. A number of recent papers have defined a formal semantics for IODs. These are restricted, however, to interactions that can be specified using basic sequence diagrams. This excludes the many rich modeling constructs available in activity diagrams such as interruptible regions, activity groups, concurrent node executions, and flow final nodes. It is non-trivial to allow such constructs in IODs because their meaning has to be interpreted in the context of interaction sequences rather than activities. In this paper, we consider how some of these activity diagram constructs can be used practically in IODs. We motivate the integration of these constructs into IODs using a NASA air traffic control subsystem and define a formal semantics for these constructs that builds on an existing semantics definition for IODs.

Modeling of login procedure for wireless application with interaction overview diagrams

In this paper we describe in details UML modeling of login procedure, which is a part of UserBarCodeReader application, developed for large stores and intended for use as a customer support during the shopping session. Login procedure is realized within access control system, in this case over a wireless network. Paper gives the whole modeling and implementation cycle of login procedure, from Use Case diagrams to the Java source code. Login procedure is modeled using interaction overview diagram, new in UML 2.0 which gives concise representation and divides complex sequence diagram into several smaller. The link between these diagrams is modeled with OCL postcondition and precondition expressions.

Refining UML interactions with underspecification and nondeterminism

STAIRS is an approach to the compositional development of UML interactions, such as sequence diagrams and interaction overview diagrams. An important aspect of STAIRS is the ability to distinguish between underspecification and inherent nondeterminism through the use of potential and mandatory alternatives. This paper investigates this distinction in more detail. Refinement notions explain when (and how) both kinds of nondeterminism may be reduced during the development process. In particular, in this paper we extend STAIRS with guards, which may be used to specify the choice between alternatives. Finally, we introduce the notion of an implementation and define what it means for an implementation to be correct with respect to a specification.