Search

On the basis of the double coupled Duffing oscillator, a differential double coupled Duffing oscillator method, called the proposed method 1, is proposed. The large scale state is judged by the differential timing sequence diagram, and its detection result is more intuitive. To overcome the frequency limitation of differential double coupled Duffing oscillator in detecting unknown frequency periodic signal, according to the proposed method 1, based on the intermittent chaos phenomenon, the differential double coupled Duffing oscillator variable step size detection method, called the proposed method 2, is proposed. This method can be used to detect Gaussian noise background periodic signal and K-distributed noise background periodic signal. Compared with the double Duffing method and the double coupled Duffing method, its average signal-to-noise ratio (SNR) threshold is reduced by 4.94 dB and 1.68 dB respectively, and the detection result is more intuitive to judge through the differential timing sequence diagram. The accuracy and universality of the proposed method 2 are proved by the detection of three measured underwater weak target signals. Experiments show that it has some characteristics such as intuitive detection result, high sensitivity, low SNR threshold, few oscillators, low system complexity and so on.

In model-driven engineering, sequence diagrams are commonly used to describe a system’s expected behavior in different scenarios. Indeed, the information flow described in sequence diagrams should actually take place during a real execution of the system in order to ensure its safety, security and correctness. If it does not, this may lead to serious consequences. In this short paper, we present a novel generic approach for addressing this issue by observing the live execution of a system and checking whether the exhibited information flow correctly follows what has been specified in sequence diagrams.

Software system and conceptual design are highly abstract and functionally based. In recent years, the software system has been developing rapidly whereas the growth of hardware system is slow. However, it is difficult to transfer the knowledge from software to hardware for conceptual design due to the discipline gaps between software and hardware. Axiomatic design theory bridges software and hardware design conceptually; but lacks in further methodologies for transforming the software system structure to the axiomatic design matrix. This paper focuses on developing a methodology to conceptually design firmware which will help bridge the gap between software and hardware conceptual design. A conversion method between the axiomatic design matrix and the widely used UML sequence diagram was developed. This helps the designers identify Functional Requirements (FRs), Design Parameters (DPs) and their dependencies (i.e., Functional Couplings). In this methodology Functional Messages (FMs) are introduced, defined as the messages of UML sequence diagram and they are used for transition to axiomatic design matrix. DPs of design matrix are defined as the objects in the UML sequence diagram, and FRs of design matrix are generated by merging FMs depending on their flow of information in the sequence diagram. A case study was performed on software system of FDM 3D Printer to validate the proposed method. The UML Sequence diagram of the software system of FDM 3D Printer was successfully transformed into the design matrix. Then Design Coupling Sequence approach was applied to find the proper executable sequence to improve the software design concept of the 3D printer and innovation opportunities were suggested. By using this method, the Software system architecture of FDM 3D Printer was improved conceptually by decoupling the highly coupled DPs, which makes the system more efficient by reducing the build time of a 3D printed part.

Software test is an important activity in life cycle of software development. If quality of generated test cases is high, number of detected errors before system dissemination would be significant and costs will be decreased. In recent years, different methods have been presented for test cases generation. One of the methods of test cases generation is using UML (unified modeling language) diagrams. Using UML diagrams for test cases generation and applying them in first stages of software development, leads to decrease in costs and efforts. In this paper, first some methods of test cases generation from Communication diagram, Sequence diagram, Activity diagram, State diagram, Class diagram and combination of some diagrams have been explained. Next, Communication diagram, Sequence diagram, Use Case diagram, Activity diagram, State diagram and Class diagram in test cases generation for different part of a system have been compared. Finally, UML diagrams have been applied for case study on depression on internet addiction estimation.

Destruction of critical nuclear infrastructure would have a debilitating effect on national public health, safety, national economy and security. For this reason, analysts perform safety risk analyses on the performance of the nuclear system to quantify and understand the nature of unwanted events. Since the world has gone through many changes after the terrorist attacks of 9/11, nuclear security risk analysis also became a necessity. To date, the safety and security risk analyses have been done separately without a combined evaluation. Study results are presented for three types of risk analyses for a pure security initiating event, pure safety initiating event, and a combined analysis of safety-security risk for either a security or safety initiating event. The pure security risk analysis uses adversary sequence diagram and pathway analysis to calculate the initiating security event frequency of a successful adversary attack. The pure safety analysis represented a series of natural (random) safety system component failure events for which a safety system failure frequency was calculated using SAPHIRE probabilistic risk analysis code. On the other hand, the combined safety-security analysis considered a security initiating event followed by safety system failure or vice versa. The main outcome of the comparative study of three different types of risk analyses is that pure safety risk evaluation without considering the possibility of a simultaneous security attack would underestimate the risk value. Failure frequency due to a security event should be combined with the safety system failure analysis for a meaningful risk analysis and the Estimate of Adversary Sequence Interruption (EASI) model can be employed for this purpose. The usefulness of a combined safety-security risk analysis is demonstrated through a case study for the spent fuel storage pool facility.

This paper presents a vulnerability learning method for the analysis of adversary paths in Physical Protection System (PPS) named AMC/EASI. AMC/EASI is used absorbing Markov chains (AMC) for the establishment and simulation of state chains and used Estimate of Adversary Sequence Interruption (EASI) method for the calculation of the probability of transitions. Moreover, this paper maps the adversary sequence diagram into the absorbing Markov chain. According to the AMC, the detailed analysis processes for predicting the expected number of the defeated protection elements and the expected value of the intrusion path length are presented. Also, this paper proposed a sensitivity analysis approach for the protection elements by AMC/EASI and the selectivity analysis of multi-targets. Thus, AMC/EASI provides more guidance for the design, reconstruction, and evaluation of PPS.

Software testing is an important and critical activity in software development that deals with software quality. However, the testing process is consuming activities that need to be automated to save a lot of resources. Towards automated testing, automating test cases generation as the first testing process is being highlighted. This research aims to generate test case automatically from UML diagram since model based testing that conducted on early phase of software development process show higher efficiency. UML diagrams used in this research are activity diagram, sequence diagram and SYTG as the combination graph. These three diagrams have been proved as the most compatible diagram to generate test case from previous research. Method proposed in this paper is Depth First Search algorithm that is modified to generate expected test cases. This paper proves that modified DFS algorithm applied to generate test case is provide accurate result, every node presented on the test case, include any condition (alt and opt). Comparison result from three different test cases generated shows that test cases from combined UML may not necessarily result in better test cases, due to the possibility of redundant test cases for some test cases. This paper also presenting an experiment result that proving sequence diagrams can produce better test cases.

This paper introduces a novel method referred to as Enhanced Sequence Diagram (ESD) to support rigorous functional modelling of complex multidisciplinary systems. The ESD concept integrates an exchanges based functional requirements reasoning based on a coherent graphical schema, integrated with the system operational analysis based on a sequence diagram. The effectiveness of the method to support generic function modelling of complex multidisciplinary systems at the early conceptual design stages is discussed in conjunction with an electric vehicle powertrain example, followed by an assessment of potential impact for broader application of the method in the industry.

Context: Software Fuzzy Self-Adaptation (SFSA) is a fuzzy control-based software self-adaptation paradigm proposed to deal with the fuzzy uncertainty existing in self-adaptive software. However, as many software engineers lack fuzzy control knowledge, it is difficult for them to design and model this kind of fuzzy self-adaptive software (F-SAS). Therefore, efficient and effective modeling technologies and tools are needed for the SFSA framework. Objective: This paper aims to identify modeling requirements of F-SAS and to provide a modeling framework to specify, design and model F-SAS systems. Such a framework can simplify modeling process of F-SAS and improve the accessibility of software engineers to the SFSA paradigm. Method: This study proposes a modeling framework called Fuzzy self-Adaptation ModEling (FAME). By extending UML, FAME creates three types of modeling views. An analysis view called Fuzzy Case Diagram is created to specify the fuzzy self-adaptation goal and the realization processes of this goal. A structure view called Fuzzy Class Diagram is created to describe the fuzzy concepts and structural characteristics of F-SAS. A behavior view called Fuzzy Sequence Diagram is created to depict the dynamic behaviors of the F-SAS systems. The framework is implemented as a plug-in of Enterprise Architect. Results: We demonstrate the effectiveness and efficiency of the proposed approach by carrying out a subject-based empirical evaluation. The results show that FAME framework can improve modeling quality of F-SAS systems by 44.38% and shorten modeling time of F-SAS systems by 38.41% in comparison with traditional UML. Thus, FAME can considerably ease the modeling process of F-SAS systems. Conclusion: FAME framework incorporates the SFSA concepts into standard UML. Therefore, it provides a direct support to model SFSA characteristics and improves the accessibility of software engineers to the SFSA paradigm. Furthermore, it behaves a good example and provides good references for modeling domain-specific software systems.

We present a new stochastic computational tool, Multi-path Analysis of Physical Protection Systems (MAPPS) useful for Physical Protection System (PPS) effectiveness analysis. MAPPS tool can perform multi-path (adversary paths) analysis using an Adversary Sequence Diagram (ASD) and can determine the Most Vulnerable Path (MVP). The MVP determination by MAPPS uses the concept of Critical Detection Point (CDP). Suitability of MAPSS for PPS design effectiveness analysis is confirmed through an example. A comparison of MAPPS results with the traditional single path analysis (employing the Estimate of Adversary Sequence Interruption-EASI model) shows the advantages of using MAPPS. MAPPS correctly predicts the MVP and the distribution of probability of interruption (PI) values for various adversary strategies including collusion with facility insiders. MAPPS results show that a focusing only on mean of PI value distribution may not be appropriate instead, a analyzing the low probability tail of the PI distribution is important.

This paper describes a way based on operational semantics of π-calculus and uses TGG tool to formalize sequence diagrams to establish formal verification through model transformations. Our transformation uses basic interactions and combined fragments with the operator Alt , Opt and Par . We argue that TGG rules can be more easily used and they become more understandable. The transformation feasibility is illustrated on a scenario of phone system.

A new risk monitor system is under development which can be applied not only to prevent severe accident in daily operation but also to serve as to mitigate the radiological hazard just after severe accident happens. The system simulates these applied situations, by generating interactions among all actors such as the plant and related people coping with the accident. In this paper, the plant DiD risk monitor is developed utilizing Unified Modeling Language (UML) to model actors' knowledge and express the interactions. Case study to confirm functionality and ability of DiD risk monitor is also introduced by showing examples for Station blackout accident in conventional PWR plant in Japan.

Multiview modeling languages like UML are a very powerful tool to deal with the ever increasing complexity of modern software systems. By splitting the description of a system into different views-the diagrams in the case of UML-system properties relevant for a certain development activity are highlighted while other properties are hidden. This multiview approach has many advantages for the human modeler, but at the same time it is very susceptible to various kinds of defects that may be introduced during the development process. Besides defects which relate only to one view, it can also happen that two different views, which are correct if considered independently, contain inconsistent information when combined. Such inconsistencies between different views usually indicate a defect in the model and can be critical if they propagate up to the executable system.In this paper, we present an approach to formally verify the reachability of a global state of a set of communicating UML state machines, i.e., we present a solution for an intradiagram consistency checking problem. We then extend this approach to solve an interdiagram consistency checking problem. In particular, we verify whether the message exchange modeled in a UML sequence diagram conforms to a set of communicating state machines.For solving both kinds of problems, we proceed as follows. As a first step, we formalize the semantics of UML state machines and of UML sequence diagrams. In the second step, we build upon this formal semantics and encode both verification tasks as decision problems of propositional logic (SAT) allowing the use of efficient SAT technology. We integrate both approaches in a graphical modeling environment, enabling modelers to use formal verification techniques without any special background knowledge. We experimentally evaluate the scalability of our approach. HighlightsFormalization of the semantics of a modeling language similar to UML.Consistency checking via SAT encodings.Direct integration of verification in modeling environment.

This paper develops directed graph representations for a class of archaeological sequence diagrams, such as the Harris Matrix, that do not include information on duration. These “stratigraphic directed graphs” differ from previous software implementations of the Harris Matrix, which employ a mix of directed graph and other data structures and algorithms. A “chronological directed graph” to represent the relationships in a Bayesian chronological model that correspond to the possibilities inherent in a sequence diagram, and an algorithm to map a stratigraphic directed graph to a chronological directed graph are proposed and illustrated with an example. These results are intended to be a proof of concept for the design of a front-end for Bayesian calibration software that is based directly on the archaeological stratigrapher's identification of contexts, observations of stratigraphic relationships, inferences concerning parts of once-whole contexts, and selection of materials for radiocarbon dating.

This research investigates the model based approach to detect infeasible paths.Investigated two patterns and their effects on path infeasibility.Proposed an elegant model-based approach to all infeaspaths for two patterns.Our approach is more effective compared to the traditional code-based approach.With our approach it is possible to significantly minimize testing effort. UML model-based analysis is gaining wide acceptance for its cost effectiveness and lower overhead for processing compared to code-based analysis. A possible way to enhance the precision of the results of UML based analysis is by detecting infeasible paths in UML models. Our investigation reveals that two interaction patterns called Null Reference Check (NLC) and Mutually Exclusive (MUX) can cause a large number of infeasible paths in UML sequence diagrams. To detect such infeasible paths, we construct a graph model (called SIG), generate MM paths from the graph model, where an MM path refers to an execution sequence of model elements from the start to end of a method scope. Subsequently, we determine infeasibility of the MM paths with respect to MUX and NLC patterns. Our proposed model-based approach is useful to help exclude generation of test cases and test data for prior-detected infeasible paths, refine test effort estimation, and facilitate better test planning in the early stages of software development life cycle.

Objective: The main objective is to investigate whether the comprehension of object-oriented source-code increases when it is added with UML class and sequence diagrams produced in the software design phase.Methods: We conducted a controlled experiment and a differentiated replication with young software maintainers. In particular, groups of Bachelor and Master students were involved.Results: The results show that more experienced participants better comprehend source-code when added with UML design models. An average improvement (or benefit) of circa 12% was achieved when the participants accomplished the comprehension task with UML class and sequence diagrams. The results of an analysis on the time to accomplish comprehension tasks showed that less experienced participants significantly spent more time when comprehending source-code with UML design models. This kind of participants spent on average 44.8% of the time to accomplish the same task with source-code alone.Implications: It is useless to give UML design models to comprehend source-code in case maintainers are not adequately experienced with the UML. Furthermore, the less the experience of participants, the more the time to accomplish a comprehension task with UML diagram is. HighlightsUsing UML design models to support young software maintainers.We analyze the effect of the experience and ability.We present the results of a controlled experiment and a differentiated replication.More experienced maintainers significantly better comprehend source code using UML models.To benefit from the use of UML design models, a given experience and ability is needed.

ContextThe COSMIC functional size measurement method on UML diagrams has been investigated as a means to estimate the software effort early in the software development life cycle. Like other functional size measurement methods, the COSMIC method takes into account the data movements in the UML sequence diagrams for example, but does not consider the data manipulations in the control structure. This paper explores software sizing at a finer level of granularity by taking into account the structural aspect of a sequence diagram in order to quantify its structural size. These functional and structural sizes can then be used as distinct independent variables to improve effort estimation models. ObjectiveThe objective is to design an improved measurement of the size of the UML sequence diagrams by taking into account the data manipulations represented by the structure of the sequence diagram, which will be referred to as their structural size. MethodWhile the design of COSMIC defines the functional size of a functional process at a high level of granularity (i.e. the data movements), the structural size of a sequence diagram is defined at a finer level of granularity: the size of the flow graph of their control structure described through the alt, opt and loop constructs. This new measurement method was designed by following the process recommended in Software Metrics and Software Metrology (Abran, 2010). ResultsThe size of sequence diagrams can now be measured from two perspectives, both functional and structural, and at different levels of granularity with distinct measurement units. ConclusionIt is now feasible to measure the size of functional requirements at two levels of granularity: at an abstract level, the software functional size can be measured in terms of COSMIC Function Point (CFP) units; and at a detailed level, the software structural size can be measured in terms of Control Structure Manipulation (CSM) units. These measures represent complementary aspects of software size and can be used as distinct independent variables to improve effort estimation models.

Software testing plays an important role in software development because it can minimize the development cost. Software testing approaches are divided into three parts i.e. code based testing, specification based testing and model based testing. In model based testing, the testing begins at design phase. So, early detection of faults can be achieved by using this approach further reducing time, cost and efforts of the developer to a large extent. In this paper we propose a technique for generating test cases using both UML sequence diagram and state chart diagram. Our approach is to convert Sequence Diagram into Sequence Graph and then to convert State Chart Diagram into State chart Graph. Finally System Testing Graph (SYTG) is formed by combining the two Graphs. From the graphs different control flow sequences also called test cases are identified and then optimized using evolutionary Algorithm, called Genetic Algorithm. Although State chart did better at revealing unit level faults and sequence diagram is better at removing integration level faults, but after integrating the two graphs, generated test cases are appropriate for system testing and to identify Error handling, correctness, pre-post condition faults, interaction, message sequence faults and scenario faults.

Smart product-service system (PSS) has been transcending scope of traditional PSS and can be characterized as value co-creation business strategy. This article aims to propose a framework with hybrid approach to capture and evaluate conceptual factors of smart PSS in fuzzy front end. According to service logic that is one of value co-creation paradigms, conceptual factors can be divided into customer needs (CNs) as customer problems to be solved, co-creative value propositions (CVPs) as mutual benefits and system requirements (SRs) as abstract solutions, which just match with three spheres of customer, joint and provider in service logic, respectively. Particularly, CVPs on smart PSS are captured from various interactions in its sequence diagram. As means-end chain theory, three types of conceptual factors for smart PSS are formed into multi-hierarchy network structure, and they are evaluated through a hybrid approach integrating fuzzy DEMATEL, modified-ANP and fuzzy TOPSIS. As a result, SRs prioritization is derived to give support to conceptual design of smart PSS. Sensitivity analysis also is conducted to test reliability of SRs prioritization. Finally, an illustrative case study of smart fridge-service system (SFSS) is demonstrated along this proposed methodological framework.

Automation essentially enables drivers to become “hands and feet free” but not necessarily “mind-free” during vehicle operation and on these grounds, increased vehicle automation may contribute to safety concerns rather than overcome them. Although automated systems were originally designed to improve driver safety by reducing driver fatigue, stress and ultimately error, there is growing concern within the Ergonomics and Human Factors community that automation may introduce additional complexity into the driving task placing increased pressure on drivers to monitor both the environment and behaviour of vehicle sub-systems. This paper considers how increasing the level of automation within the sub-tasks of driving may affect the traditional role of the driver. Using the Distributed Cognition approach and Operator Sequence Diagrams as a representational aid, this paper indicates that the level at which automation is set significantly affects the dynamism of the system network.

This paper suggests a systematic approach to establish design requirements for the human–system interface (HSI) between operators and automatic systems. The role of automation in the control of a nuclear power plant (NPP) operation is to support the human operator and act as an efficient team player to help reduce the human operator’s workload. Some of the problems related to the interaction between the human operator and automation are out-of-the-loop performance, mode errors, role change to supervisory role and final authority issues. Therefore, the design of HSI is critical to avoiding breakdowns in communication between the human operator and the system. In this paper, the design requirements for human–system interface of automatic systems are constructed with the help of a tool called Itemized Sequence Diagram (ISD). Eight levels of automation (LOA) are initially defined in the function allocation and an ISD is drawn for each of the LOA for task allocation. The ISD is a modified version of sequence diagram, which is widely used in systems engineering as well as software engineering. The ISD elements of arrows, messages, actors and alternative boxes collectively show the interactions between the control agents, which are decomposed into four different roles: information acquiring, plant diagnosing, response selecting and response implementing. Eleven design requirements to optimize the human–automation interaction are suggested by using this method. The design requirements produced from the identified interaction points in the ISD are rationalized and how each requirement addresses the issues related to automation is discussed. We also identify which requirements address which of the stated automation issues and at which operational process stage each requirement applies to. Finally, the strengths of the proposed methodology and its implication on the HSI design are discussed in comparison with the methodology used to produce the existing guidelines or guidance.

Model checking is one of the most accurate analysis techniques which are used to verify software and hardware systems. However, the analysis of large and complex systems tends to become infeasible since their state spaces easily become too big. Besides well-known abstraction techniques, which may hamper the accuracy of results, in this paper we propose the use of scenario-driven model checking to address and mitigate the state explosion problem. The proposal starts from systems specified through a Graph Transformation (GT) system and it is focused on the analysis of the most significant scenarios. We exploit the modularity of GT systems to reduce the state space by eliminating all the nodes and rules that are not involved in the scenario. Focused analysis also helps concentrate on the most critical behaviors of the system and smooth the risks associated with them. The paper introduces the analysis approach and explains how scenarios (specified in terms of sequence diagrams) can help to reduce the state space. All main concepts are illustrated through a simple application for a travel agency specified as if it were a service-oriented application.

Current production plants are highly customizable and flexible in their processes. This flexibility is mainly realized by software. It causes an increasing complexity of control software components and the need of new methods for comprehensive and automated testing approaches to ensure a requested level of quality at high efficiency. A survey among mechanical engineering companies of the industries aerospace, automotive and machine/plant automation was conducted. Aspects of requirements engineering, testing, simulation, processes, tools, etc. were addressed to reveal research demands of PLC (Programmable Logic Controller) control software development in machine/plant automation. A system architecture embedding UML sequence diagrams for testing is proposed. We further contribute transformation rules of semantically adapted UML sequence diagrams to the cyclic execution logic of PLCs for reactive systems. The approach can be applied to any IEC 61131-3 programming language of the automation control software. A prototypical realization shows proof of concept and reveals the potential for future work.

The need for adaptability in software is growing, driven in part by the emergence of pervasive and autonomic computing. In many cases, it is desirable to enhance existing programs with adaptive behaviour, enabling them to execute effectively in dynamic environments. Increasingly, software systems should self-adapt to satisfy new requirements and environmental conditions that may arise after deployment. Due to their high complexity, adaptive programs are difficult to specify, design, verify, and validate. In this paper we propose a new approach for Genetic Algorithm based multi objective evolution in autonomic system using Design Patterns. Proposed system satisfies properties of autonomic system. Proposed system distributes the population of Genetic Algorithm to different clients to execute the population and store population results into database. We use different Design Patterns for this autonomic system those are Case Based Reasoning, Database Access Design Pattern and Master Slave. Main objective of the system is to reduce the load of the system to distribute the population. The pattern is described using a java-like notation for the classes and interfaces. A simple UML class and Sequence diagrams are depicted

In our approach, we use condition slicing and generate test cases from UML interaction diagrams. A novel testing methodology, to test object oriented software based on UML interaction diagrams is presented here. In our method, we identify the message guards on interaction diagrams and create condition slices with respect to each conditional predicates. We have proposed conditioned slicing as a general slicing framework for test case generation from interaction diagrams. To generate test cases, our approach, first builds a message flow dependence graph from an ordinary UML sequence diagram and then applies conditioned slicing on a predicate node of the graph. By this it minimizes the number of test cases generated while deriving all practically useful test cases. The effectiveness of a test case is based on how well the test modeled behaviors are covered and exercised. Test cases that we generate satisfy slice test coverage as well message path coverage. Our proposed method satisfies high path coverage criterion. Our technique also describes how condition slicing is used in testing and it achieves adequate test coverage without increasing the number of test cases.

The growing complexity in the systems due to growing size need a new mechanism to enable the system to self-manage, releasing administrators of low-level task management while delivering an optimized system. The Autonomic systems are: self-configuring, self-healing, self-optimizing, self-protecting. They sense the environment in which they are operating and automatically take action to change their own behaviour or the environment. There are no well established methodologies that a designer of an autonomic system can exploit to drive their work. So, the Current autonomic systems are ad hoc solutions in which each system is designed and implemented from scratch. This paper proposes adaptive reconfiguration compliance pattern for autonomic computing systems that can propose the reconfiguration rules and can learn new rules at runtime. The pattern is described using a java-like notation for the classes and interfaces. A simple UML class and Sequence diagrams are depicted

It is difficult to construct correct models for distributed large-scale service-oriented applications. Typically, the behavior of such an application emerges from the interaction and collaboration of multiple components/services. On the other hand, each component, in general, takes part in multiple scenarios. Consequently, not only components, but also their interaction protocols are important in the development process for distributed systems. Coordination models and languages, like Reo, offer powerful “glue-code” to encode interaction protocols. In this paper we propose a novel synthesis technique, which can be used to generate Reo circuits directly from scenario specifications. Inspired by the way UML2.0 sequence diagrams can be algebraically composed, we define an algebraic framework for merging connectors generated from partial specifications by exploiting the algebraic structure of UML sequence diagrams.

Context: The implied scenarios are unexpected behaviors in the scenario specifications. Detecting and handling them is essential for the correctness of the scenario specifications. To handle such implied scenarios, identifying the causes of implied scenarios is also essential. Most recent researches focus on detecting those implied scenarios, themselves or limited causes of implied scenarios. Objective: The purpose of this research is to provide an approach to detecting the causes of implied scenarios. Method: The scenario specification is a set of events and a set of relative orders between the events, and enforces them for its implementation. Among the orders, a set of orders that cannot be inherently enforced is the unenforceable orders. Obviously, existence of unenforceable orders leads the implied scenarios. To obtain the unenforceable orders, we first provide a method to represent each of the specification and its implementation as a set of orders between events, called the causal order graph. Then, the differences between them are the unenforceable orders. Results: Because the unenforceable orders consist of events and their order relation that are specified in the scenario specification, they can point out which part of the scenario specification should be considered to handle the implied scenarios. In addition, our approach supports the synchronous, asynchronous, and FIFO communication styles without the state explosion or heavy computational overhead. To validate our approach, we provide two case studies. Conclusions: This approach helps a designer to effectively correct the scenario specification by identifying where to be fixed, especially in large cases and under the various communication styles.

Context: Specification matching techniques are crucial for effective retrieval processes. Despite the prevalence for object-oriented methodologies, little attention has been given to Unified Modeling Language (UML) for matching. Objective: This paper presents a two-stage framework for matching two UML specifications and quantifying the results based on the systematic integration of their structural and behavioral similarities in order to identify the candidate component set for reuse. Method: The first stage in the framework is an evaluation of the similarities between UML class diagrams using the Structure-Mapping Engine (SME), a simulation of the analogical reasoning approach known as the structure-mapping theory. The second stage, performed on the components identified in the first stage, is based on a graph-similarity scoring algorithm in which UML class diagrams and sequence diagrams are transformed into an SME representation and a Message-Object-Order Graph (MOOG). The effectiveness of the proposed framework was evaluated using a case study. Results: The experimental results showed a reduction in potential mismatches and an overall high precision and recall. Conclusion: It is concluded that the two-stage framework is capable of performing more precise matching compared to those of other single-stage matching frameworks. Moreover, the two-stage framework could be utilized within a reuse process, bypassing the need for extra information for retrieval of the components described by UML.

In this paper we propose a generic simulation model, named XSM, with which researchers can construct standard platforms and evaluate their proposed concurrency control protocols for native XDBMSs. The system environment, the performance metrics, and the protocol rules of various types of XML protocols are all considered by the model. To facilitate the implementation of XSM, the state diagrams, the sequence diagrams, the component diagram, and the class diagram of XSM are depicted using UML 2.0 notations. We also show a simulation platform constructed from XSM to fairly and comprehensively evaluate the performance of various XML protocols.

This paper proposes a new fracture mechanics based OOP tool for damage tolerant evaluation of cracked structural components including tubular joints subjected to constant and variable amplitude loading. To meet requirements of damage tolerant evaluation of structural components, interactive and user-friendly software, has been developed by using OOP concepts. Application of OOP concepts with class and sequence diagrams generated using unified modified language (UML) design tool has been explained with reference to the software. Graphical user interface (GUI) has been developed using VC++, which acts as a client at the front end, while the database developed using MS-ACCESS-XP acts as the server at the back-end. Database design for typical structural components with different crack configurations has been shown in the form of tables. The details of various program modules and structure of GUI have been outlined. Number of benchmark problems has been solved through GUI for verification and validation. The efficacy of the software has been illustrated through an example problem.

Developing RFID based applications is a painstakingly difficult endeavor. The difficulties include non-standard software and hardware peripherals from vendors, interoperability problems between different operating systems as well as lack of expertise in terms of low-level programming for RFID (i.e. steep learning curve). In order to address these difficulties, a reusable RFIDTM API (RFID Tracking & Monitoring Application Programmable Interface) for heterogeneous RFID system has been designed and implemented. The API has been successfully employed in a number of application prototypes including tracking of inventories as well as human/object tracking and tagging. Here, the module has been tested on a number of different types and configuration of active and passive readers including that LF and UHF Readers.

The formal specification of design patterns is widely recognized as being vital to their effective and correct use in software development. It can clarify the concepts underlying patterns, eliminate ambiguity and thereby lay a solid foundation for tool support. This paper further advances a formal meta-modeling approach that uses first-order predicate logic to specify design patterns. In particular, it specifies both structural and behavioural features of design patterns and systematically captures the variants in a well-structured format. The paper reports a case study involving the formal specification of all 23 patterns in the Gang of Four catalog. It demonstrates that the approach improves the accuracy of pattern specifications by covering variations and clarifying the ambiguous parts of informal descriptions.

Implementation of a traceability system in the bulk grain supply chain is a complex task. Grain lots are often commingled to meet buyer specifications and the lot-identity is not maintained. In this paper, a systems approach is used to develop methods for implementing bulk grain supply chain traceability in the United States, that includes both internal and chain traceability. First, the usage requirements of a traceability system are defined for all the actors in the supply chain. Second, a model is developed for implementing internal traceability system for a grain elevator that handles specialty grain. Then, we develop a model for information exchange between the supply chain actors. The model shows what grain lot information must be recorded and then passed on to the next actor. A sequence diagram is developed to show the information exchange in the grain supply chain when a user requests additional information about a suspect product. Finally, we discuss some suitable technologies to enable this information exchange. A few sample XML documents are shown for the transfer and sharing of information in the grain supply chain.

Collaborative manufacturing requires efficient and cost effective communications among the partners. To provide efficient and reliable communications, this research modularizes the design of communication protocols for order management in collaborative manufacturing. Ten protocol modules have been defined and designed in this research. With the 10 protocol modules, companies can easily construct the protocols to regulate the interactions between partner companies. This research designs five protocols associated with order management in collaborative manufacturing. The protocols are also implemented in a distributed computing environment. The results indicate that the modularized protocols ensure the reliability and efficiency of communications, and reduce the complexity in protocol design.

A vulnerability assessment is essential for the efficient operation of a physical protection system (PPS). Previous assessment codes have used a simple model called an adversary sequence diagram. In this study, the use of a twodimensional (2D) map of a facility as a model for a PPS is suggested as an alternative approach. The analysis of a 2D model, however, consumes a lot of time. Accordingly, a generalized heuristic algorithm has been applied to address this issue. The proposed assessment method was implemented to a computer code; Systematic Analysis of physical Protection Effectiveness (SAPE). This code was applied to a variety of facilities and evaluated for feasibility by applying it to various facilities. To help upgrade a PPS, a sensitivity analysis of all protection elements along a chosen path is proposed. SAPE will help to accurately and intuitively assess a PPS.

We describe a translation of scenarios given in UML 2.0 sequence diagrams into a tuples-based behavioural model that considers multiple access points for a participating instance and exhibits true-concurrency. This is important in a component setting since different access points are connected to different instances, which have no knowledge of each other. Interactions specified in a scenario are modelled using tuples of sequences, one sequence for each access point. The proposed unfolding of the sequence diagram involves mapping each location (graphical position) onto the so-called component vectors. The various modes of interaction (sequential, alternative, concurrent) manifest themselves in the order structure of the resulting set of component vectors, which captures the dependencies between participating instances. In previous work, we have described how (sets of) vectors generate concurrent automata. The extension to our model with sequence diagrams in this paper provides a way to verify the diagram against the state-based model.

16 pages, 10 figures.-- Issue title: "Best papers from the 2007 Australian Software Engineering Conference (ASWEC 2007), Melbourne, Australia, April 10-13, 2007, Australian Software Engineering Conference 2007". Transforming integrity constraints into active rules or triggers for verifying database consistency produces a serious and complex problem related to real time behaviour that must be considered for any implementation. Our main contribution to this work is to provide a complete approach for deriving the active mechanisms for Relational Databases from the specification of the integrity constraints by using OCL. This approach is designed in accordance with the MDA approach which consists of transforming the specified OCL clauses into a class diagram into SQL:2003 standard triggers, then transforming the standard triggers into target DBMS triggers. We believe that developing triggers and plugging them into a given model is insufficient because the behaviour of such triggers is invisible to the developers, and therefore not controllable. For this reason, a DBMS trigger verification model is used in our approach, in order to ensure the termination of trigger execution. Our approach is implemented as an add-in tool in Rational Rose called OCL2Trigger. This work is part of the "Software Process Management Platform: Modelling, reuse and measurement" TIN2004/07083 project. Publicado

This paper presents an approach to model, design and verify scenarios of real-time systems used in the scheduling and global coordination of batch systems. The initial requirements of a system specified with sequence diagrams are translated into a single p-time Petri net model representing the global behavior of the system. For the Petri net fragments involved in conflicts, symbolic production and consumption dates assigned to tokens are calculated based on the sequent calculus of linear logic. These dates are then used for off-line conflict resolution within a token player algorithm used for scenario verification of real-time specifications and which can be seen as a simulation tool for UML interaction diagrams.

In recent years, Web services have been developed as a fundamental technique for the new generation of B2B or EAI applications. As they have matured and a new vision of service-oriented computing has emerged, the software industry has shifted its attention from developing required software to delivering desired services. In order to benefit from such a service-oriented model of software, several critical issues must be addressed in a service-oriented environment such as differentiation of services by various attributes, dynamic selection and provision of services in a supply chain style, and commitment of services with prescribed rules. From the managerial perspective, these issues are concerned with a process of negotiating desired services in a service-oriented environment. In this paper, we propose an object-oriented model that specifies such a negotiation process by architectural constructs where these critical issues are adequately addressed. The model contains a use case diagram that depicts requirements for the negotiation process, an architecture diagram that describes collaborative components for satisfying these requirements, and a class/sequence diagram that specifies class objects in these components to perform all behaviors occurring within the negotiation process. For illustration, the model is applied to an exemplified negotiation process for book publishing.

This paper deals with the development of a generalized model for version control systems application as a support in a range of project-based learning methods. The model is given as UML sequence diagram and described in detail. The proposed model encompasses a wide range of different project-based learning approaches by assigning a supervisory role either to instructor or students in different project stages. Different strategies for supervisor role assignment are given. Project duration, project milestones, as well as a number of team members are discussed in respect to project-based learning method that the proposed model supports. Possible implementations of different project-based learning approaches on the proposed model are demonstrated by setting the model parameters. Version control server security issues are discussed in the manner of implementation aspects of the proposed model. One of possible model implementations is evaluated in respect of cooperation on the test group of 21 students. Implementation details are presented and compared with other approaches. Mentoring and monitoring students efforts during the development by implementing proposed model with specific model settings introduces controlled cooperation with high clarity in evaluation of individual students work. Using open source version control software on Linux platform, with web interface package, we implemented a low-cost support for project-based learning.

Informal and abstract user requirement specifications are usually complemented by formal and detailed system requirement specifications. While user requirements provide a high level description of what services the system is expected to provide, system requirements provide a more technical specification of how that services should be provided by the system. One of the relevant problems that arise during the Requirement Engineering process is the result of failing to make a clear transition between different levels of requirements description.Goal of this paper is to introduce a graphical tool for requirements refinement which guides software architects while moving from user requirements to (architec-tural-level) system requirements. The tool makes use of a previous work that gives a simple but expressive graphical formalism, based on UML2.0 Sequence Diagrams, for specifying temporal properties.

This paper presents a model-driven, stress test methodology aimed at increasing chances of discovering faults related to network traffic in distributed real-time systems (DRTS). The technique uses the UML 2.0 model of the distributed system under test, augmented with timing information, and is based on an analysis of the control flow in sequence diagrams. It yields stress test requirements that are made of specific control flow paths along with time values indicating when to trigger them. The technique considers different types of arrival patterns (e.g., periodic) for real-time events (common to DRTSs), and generates test requirements which comply with such timing constraints. Though different variants of our stress testing technique already exist (that stress different aspects of a distributed system), they share a large amount of common concepts and we therefore focus here on one variant that is designed to stress test the system at a time instant when data traffic on a network is maximal. Our technique uses genetic algorithms to find test requirements which lead to maximum possible traffic-aware stress in a system under test. Using a real-world DRTS specification, we design and implement a prototype DRTS and describe, for that particular system, how the stress test cases are derived and executed using our methodology. The stress test results indicate that the technique is significantly more effective at detecting network traffic-related faults when compared to test cases based on an operational profile.

International audience; Automatic test generating system in distributed computing context is one of the most important links in on-line evaluation system. Although the issue has been argued long since, there is not a perfect solution to it so far. This paper proposed an innovative approach to successfully addressing such issue by the seamless integration of genetic algorithm (GA) and multi-agent system. In the design phase, a test ontology was firstly defined for smoothing the communication among agents. For the implementation of GA, The fitness function and the structure of chromosome were identified on the basis of the analysis of constraint conditions associated with a test. To demonstrate the task execution flow and messages passing among agents, the activity diagram and sequence diagram were also shown on the AUML basis. In the phase of implementation, the JADE based agent behavior model was described in detail and the implementation platform was also demonstrated. The final simulation results validated the feasibility of the proposed approach.

Nowadays, UML is the de-facto standard for object-oriented analysis and design. Unfortunately, the deficiency of its dynamic semantics limits the possibility of early specification analysis. UML 2.0 comes to precise and complete this semantics but it remains informal and still lacks tools for automatic validation. The main purpose of this study is to automate the formal validation, according a value-oriented approach, of the behavior of systems expressed in UML. The marriage of Petri nets with temporal logics seems a suitable formalism for translating and then validating UML state-based models. The contributions of the paper are threefold. We first, consider how UML 2.0 activity partitions can be transformed into Object Petri Nets to formalize the object dynamics, in an object-oriented context. Second, we develop an approach based on the object and sequence diagram information to initialize the derived Petri nets in terms of objects and events. Finally, to thoroughly verify if the UML model meets the system required properties, we suggest to use the OCL invariants exploiting their association end constructs. The verification is performed on a predicate/transition net explored by model checking. A case study is given to illustrate this methodology throughout the paper.

These days, many systems are developed applying various UML notations to represent the structure and behavior of (technical) systems. In addition, for safety critical systems like Railway Interlocking Systems (RIS) the fulfillment of safety requirements is demanded. UML-based Railway Interlocking (UML-based RI) is proposed as a methodology in designing and developing RIS. It consists of infrastructure objects and UML is used to model the system behavior. This design is validated and demonstrated by using simulation with Rhapsody. Automated verification techniques like model checking have become a standard for proving the correctness of state-based systems. Unfortunately, one major problem of model checking is the state space explosion if too many objects have to be taken into account. Multi-object checking circumvents the state space explosion by checking one object at a time. We present an approach to enhance multi-object checking by generating counterexamples in a sequence diagram fashion providing scenarios for model-based testing.

Summary Objectives Electronic Health Records (EHRs) provided as a lifelong patient record advance towards core applications of distributed and co-operating health information systems and health networks. For meeting the challenge of scalable, flexible, portable, secure EHR systems, the underlying EHR architecture must be based on the component paradigm and model driven, separating platform-independent and platform-specific models. Methods Allowing manageable models, real systems must be decomposed and simplified. The resulting modelling approach has to follow the ISO Reference Model – Open Distributing Processing (RM-ODP). The ISO RM-ODP describes any system component from different perspectives. Platform-independent perspectives contain the enterprise view (business process, policies, scenarios, use cases), the information view (classes and associations) and the computational view (composition and decomposition), whereas platform-specific perspectives concern the engineering view (physical distribution and realisation) and the technology view (implementation details from protocols up to education and training) on system components. Those views have to be established for components reflecting aspects of all domains involved in healthcare environments including administrative, legal, medical, technical, etc. Thus, security-related component models reflecting all view mentioned have to be established for enabling both application and communication security services as integral part of the system's architecture. Beside decomposition and simplification of system regarding the different viewpoint on their components, different levels of systems’ granularity can be defined hiding internals or focusing on properties of basic components to form a more complex structure. The resulting models describe both structure and behaviour of component-based systems. Results The described approach has been deployed in different projects defining EHR systems and their underlying architectural principles. In that context, the Australian GEHR project, the openEHR initiative, the revision of CEN ENV 13606 “Electronic Health Record communication”, all based on Archetypes, but also the HL7 version 3 activities are discussed in some detail. The latter include the HL7 RIM, the HL7 Development Framework, the HL7's clinical document architecture (CDA) as well as the set of models from use cases, activity diagrams, sequence diagrams up to Domain Information Models (DMIMs) and their building blocks Common Message Element Types (CMET) Constraining Models to their underlying concepts. Conclusion The future-proof EHR architecture as open, user-centric, user-friendly, flexible, scalable, portable core application in health information systems and health networks has to follow advanced architectural paradigms.

In UML 2.0 sequence diagrams have been considerably extended but their expressiveness and semantics remains problematic in several ways. In other work we have shown how sequence diagrams combined with an OCL liveness template gives us a much richer language for inter-object behaviour specification. In this paper, we give a semantics of these enriched diagrams using labelled event structures. Further, we show how sequence diagrams can be embedded into a true-concurrent two-level logic interpreted over labelled event structures. The top level logic, called communication logic, is used to describe inter-object specification, whereas the lower level logic, called home logic, describes intra-object behaviour. An interesting consequence of using this logic relates to how state-based behaviour can be synthesised from inter-object specifications. Plans of extending the Edinburgh Concurrency Workbench in this context are discussed.

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.

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).