Collaboration Diagrams Research Articles

Generating Business Process Models from Object Behavior Models

Object-oriented modeling is an established approach to document information systems. In an object model, a system is captured in terms of object types and associations, state machines and collaboration diagrams, among others. Process modeling on the other hand, provides a different approach whereby behavior is captured in terms of activities, flow dependencies, resources, etc. These two approaches have their relative advantages. Also, object models and process models lend themselves to different styles of implementation. In this paper we define a transformation from a meta-model for object behavior modeling to a meta-model for process modeling. The transformation relies on the identification of causal relations in the object model. These relations are encoded in a heuristics net from which a process model is derived and then simplified. Using this transformation, it becomes possible to apply established object-oriented techniques during system analysis and design, and to transform the resulting object models into executable process models that can be deployed in a workflow engine. The proposal has been implemented in an object modeling tool.

Towards an integrated graph-based semantics for UML

This paper shows how a central part of the Unified Modeling Language (UML) can be integrated into a single visual semantic model. It discusses UML models composed of class, object, state, sequence and collaboration diagrams and presents an integrated semantics of these models. As formal basis the theoretically well-founded area of graph transformation is employed which supports a visual and rule-based transformation of UML model states. For the translation of a UML model into a graph transformation system the operations in class diagrams and the transitions in state diagrams are associated with graph transformation rules that are then combined into one system in order to obtain a single coherent semantic description. Operation calls in sequence and collaboration diagrams can be associated with applications of graph transformation rules in the constructed graph transformation system so that valid sequence and collaboration diagrams correspond to derivations, i.e., to sequences of graph transformation rule applications. The main aim of this paper is to provide a formal framework that supports visual simulation of integrated UML specifications in which system states and state changes are modeled in a straightforward way.

Specification of realizable service conversations using collaboration diagrams

Specification, modeling and analysis of interactions among peers that communicate via messages are becoming increasingly important due to the emergence of service oriented computing. Collaboration diagrams provide a convenient visual model for specifying such interactions. An interaction among a set of peers can be characterized as a conversation. A conversation is the global sequence of messages exchanged among the peers, listed in the order they are sent. A collaboration diagram can be used to specify the set of allowable conversations among the peers participating to a composite web service. Specification of interactions from a global perspective leads to the realizability problem: Is it possible to construct a set of peers that generate exactly the specified set of conversations? In this paper, we investigate the realizability of conversations specified by collaboration diagrams. We formalize the realizability problem by modeling peers as concurrently executing finite state machines, and we give sufficient realizability conditions for a class of collaboration diagrams.

Collaborative Learning Through Chat Discussions and Argument Diagrams in Secondary School

This study clarifies whether secondary school students develop their argumentation skills through reading and collaboration. The students first constructed an individual argument diagram on genetically modified organisms, read three articles, and improved their diagrams. Next, they engaged in a chat debate, reflected on their debate by constructing a collaborative argument diagram on it, and finally finished their individual diagrams. The analyses compared the diagrams students finished after the debate and reflection with the diagrams they constructed before the debate. Collaboration not only encouraged students to elaborate their previous arguments but also helped them to recall and create ideas and arguments.

Real-time multispectral imaging system for online poultry fecal inspection using unified modeling language

A prototype real-time multispectral imaging system for fecal and ingesta contaminant detection on broiler carcasses has been developed. The prototype system includes a common aperture camera with three optical trim filters (517, 565 and 802-nm wavelength), which were selected by visible/NIR spectroscopy and validated by a hyperspectral imaging system with decision tree algorithm. The on-line testing results showed that the multispectral imaging technique can be used effectively for detecting feces (from duodenum, ceca, and colon) and ingesta on the surface of poultry carcasses with a processing speed of 140 birds per minute. This paper demonstrated both multispectral imaging hardware and real-time image processing software. For the software development, the Unified Modeling Language (UML) design approach was used for on-line application. The UML models included class, object, activity, sequence, and collaboration diagram. User interface model included 17 inputs and 6 outputs. A window-based real-time image processing software composed of 11 components, which represented class, architecture, and activity. Both hardware and software for a real-time fecal detection were tested at the pilot-scale poultry processing plant. The run-time of the software including online calibration was fast enough to inspect carcasses on-line with an industry requirement. Based on the preliminary test at the pilot-scale processing line, the system was able to acquire poultry images in real-time. According to the test results, the imaging system is reliable for the harsh environments and UML-based image processing software is flexible and easy to be updated when additional parameters are needed for in-plant trials.

A methodological approach to the formal specification of real-time systems by transformation of UML-RT design models

By following a methodological approach, introduced in a previous work, a correct system specification in terms of CSP+T process algebra is systematically obtained from the UML-RT model of a real-time software system. Among other contributions, this article aims at integrating collaboration diagrams into our approach to facilitate the specification of capsules in UML-RT design models. Thus, an improved systematic transformation procedure for deriving a correct and complete formal system specification of real-time systems is established here. Temporal requirements integration in the design and system specification stages of a real-time system is also addressed, so that the approach now opens up the possibility of carrying out scheduling and dependability analysis at the design phase of the system development life cycle for hard real-time systems. The article also discusses a practical application to present a systematic transformation from a UML-RT model of a well known manufacturing-industry paradigmatic case, the “Production Cell”.

A state-based approach to integration testing based on UML models

Correct functioning of object-oriented software depends upon the successful integration of classes. While individual classes may function correctly, several new faults can arise when these classes are integrated together. In this paper, we present a technique to enhance testing of interactions among modal classes. The technique combines UML collaboration diagrams and statecharts to automatically generate an intermediate test model, called SCOTEM (State COllaboration TEst Model). The SCOTEM is then used to generate valid test paths. We also define various coverage criteria to generate test paths from the SCOTEM model. In order to assess our technique, we have developed a tool and applied it to a case study to investigate its fault detection capability. The results show that the proposed technique effectively detects all the seeded integration faults when complying with the most demanding adequacy criterion and still achieves reasonably good results for less expensive adequacy criteria.

Describing Use-Case Relationships with Sequence Diagrams

One of the key tools of the unified modelling language for behaviour modelling is the use-case model. The behaviour of a use case can be described by means of interaction diagrams (sequence and collaboration diagrams), activity charts and state diagrams or by pre-conditions and post-conditions, as well as natural language text, where appropriate. This article explains a technique to describe use cases by means of sequence diagrams. It compares sequence diagrams in order to define sequence-diagram relationships for identifying and defining use-case relationships. This article uses an automatic teller machine system case study to illustrate our proposal.

UB2SQL

UB2SQL is a tool for designing and developing database applications using UML and B formal method. The approach supported by UB2SQL consists of two successive phases. In the first phase, with the design of applications using class, state and collaboration diagrams, B specifications are automatically generated from UML diagrams; the diagrams are then augmented with these B specifications in place. The second phase deals with the refinement of these B specifications into a relational database implementation, for which UML representation is constructed. In both phases, proofs are achieved to ensure correctness of the obtained B specification and correctness of the refinement process. To overcome the lack of rules and tactics in the B prover, UB2SQL defines specific rules and tactics making the proof task seem like a push-button activity. To increase the usability of UB2SQL in both academic and industrial contexts, the tool has been integrated as a plug-in to the Rational Rose CASE tool. Such integration allows users to develop and be able to visualize graphical UML diagrams and formal B notation in a single environment.

A formal approach based on UML and B for the specification and development of database applications

This article describes a formal approach to specify and develop database applications. This approach consists of two complementary phases. In the first phase, B specifications are automatically generated from UML class, state and collaboration diagrams describing the data and the transactions of the system we are developing. In the second phase, these specifications are successively refined until they become close enough to a relational implementation. The tool supporting this approach is implemented as an extension of the Rational Rose tool to develop and visualize graphical (UML) and formal (B) notations in a single environment.

An Implementation Model of Parlay MMCCS API Based on SIP

Parlay Multi Media Call Control Services ( MMCCS) Application Programming Interfaces ( API) based on Session Initiation Protocol ( SIP) is essential for the implementation of Parlay Call Control ( CC) API. This paper first proposes an implementation model of Parlay MMCCS API based on SIP, then presents a mapping between SIP and MMCCS API as far as methods and parameters are concerned, illustrates corresponding relationships between different components of SIP and MMCCS API by means of an application collaboration diagram, and finally presents an application using Java codes as well as some SIP messages. The application shows that a majority of MMCCS API based on SIP can be implemented and therefore verifies our mapping between MMCCS API and SIP.

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.

Object Oriented Software Architecture Design based on UML/Petri Net approach for deadlock prevention of Real Time Systems

The objective of this article is to present an approach based on UML dynamic diagrams and on Petri Net Objects for the deadlock prevention of Real Time Systems. The main idea consists of translating the sequence diagrams which express the initial specifications of the system in a unique Petri Net model which represents the global behaviour of the entire system and which belongs to the special class of Petri Nets called Simple Sequential Process with Resources. After the detection of possible unmarked siphons in the structure of the global model, a deadlock prevention strategy based on the addition of local control places is applied in order to remove structural deadlocks. The augmented Petri Net model is then translated into a set of collaboration and state-transition diagrams which represent the final deadlock free UML specification. Finally, a software architecture free of deadlocks based on an object which contains the global behaviour of the system and which centralises all the interactions between the software objects is presented. The approach is illustrated through an example of Real Time System used at the global coordination level of a Batch System.

Coherently Explaining UML Statechart and Collaboration Diagrams by Graph Transformations

In this paper we continue our work on the formalization and validation of UML models by means of graph transformation systems. We here concentrate on statechart and collaboration diagrams albeit our approach covers use case, class, object, and sequence diagrams as well. The statechart and collaboration diagrams describe the operations of the underlying class diagram and include OCL expressions as guards and parts of message expressions. We illustrate in detail the generation of graph transformation rules for the statechart and collaboration diagrams.

Quality and comprehension of UML interaction diagrams-an experimental comparison

UML (Unified Modeling Language) is a collection of somewhat overlapping modeling techniques, thus creating a difficulty in establishing practical guidelines for selecting the most suitable techniques for modeling OO artifacts. This is true mainly with respect to two types of interaction diagrams: Sequence and collaboration. Attempts have been made to evaluate the comprehensibility of these diagram types for various types of applications, but they did not address the issue of quality of diagrams created by analysts. This article reports the findings from a controlled experiment where both the comprehensibility and quality of the interaction diagrams were investigated in two application domains: management information systems (MIS) and real-time (RT) systems. Our results indicate that collaboration diagrams are easier to comprehend than sequence diagrams in RT systems, but there is no difference in comprehension of the two diagram types in MIS. Irrespective of the diagram type, it is easier to comprehend interaction diagrams of MIS than of RT systems. With respect to diagram quality, in the case of MIS, analysts create collaboration diagrams of better quality than sequence diagrams, but there is no significant difference in quality of diagrams created in RT systems. Irrespective of the diagram type, more correct diagrams are created in MIS applications than in RT applications.

Software performance models from system scenarios

The earliest definition of a software system may be in the form of Use Cases, which may be elaborated as scenarios. In this work, performance models are created from scenarios, to permit the earliest possible analysis of potential performance issues. Suitable forms of scenario models include Unified Modeling Language (UML) Activity or Sequence Diagrams (SD), and Use Case Maps (UCM) from the User Requirements Notation (URN) standard. They capture the causal flow of intended execution, and the operations, activities or responsibilities which may be allocated to components, with their expected resource demands. The Scenario to Performance (S2P) algorithm described here automatically transforms scenario models into performance models, and the LQNGenerator tool implements S2P to convert UCM scenario models into layered queueing performance models. S2P can, in principle, also be applied to other scenario models, including Message Sequence Charts, UML Activity Graphs (or Collaboration Diagrams, or Sequence Diagrams).

Graphic Language for Describing Constraints on Diagrams of UML Classes

A visual notation for specifying constraints on diagrams of UML classes by means of the UML collaboration diagrams is suggested. A formal semantics of the suggested notation is presented.

7.6.1 Applying the Object Oriented Systems Engineering Method to A Simple Hardware System

AbstractThe application of Object‐Oriented Systems Engineering Method (OOSEM) to hardware systems has been controversial since it was initiated. This paper will explore its applicability and its effectiveness relative to traditional systems engineering approach. A simple Mouse Trap hardware system was used for the case study. The System Requirements can be derived from the System Diagram. The Activity Diagram can be used to visualize the workflow scenario. The Sequence Diagram can provide earlier interface identification between subsystems. The Collaboration Diagram shows the functional and physical data between subsystems. The Logical Architecture and allocation can generate logical components and develop the Class Diagram for subsystems. The design of this simple hardware system can be accomplished using the OOSEM. A definitive conclusion cannot be made as to which approach, between the traditional systems engineering and OOSEM, is better in assisting a simple hardware system design.

A GXL Schema for Story Diagrams

This paper briefly outlines the process of generating story diagrams, and describes a GXL schema to represent them. These diagrams result from a static, heuristic reverse engineering analysis and combine the data and behavioral information of UML activity and collaboration diagrams. This paper also summarizes potential issues in representing and visualizing story diagrams.

Nonfunctional requirements: from elicitation to conceptual models

Nonfunctional requirements (NFRs) have been frequently neglected or forgotten in software design. They have been presented as a second or even third class type of requirement, frequently hidden inside notes. We tackle this problem by treating NFRs as first class requirements. We present a process to elicit NFRs, analyze their interdependencies, and trace them to functional conceptual models. We focus our attention on conceptual models expressed using UML (Unified Modeling Language). Extensions to UML are proposed to allow NFRs to be expressed. We show how to integrate NFRs into the class, sequence, and collaboration diagrams. We also show how use cases and scenarios can be adapted to deal with NFRs. This work was used in three case studies and their results suggest that by using our proposal we can improve the quality of the resulting conceptual models.