UML Sequence Diagrams Research Articles

Occupational health assessment summary designed for semantic interoperability

BackgroundGeopolitical and economic crises force a growing number of people to leave their countries and search better employment opportunities abroad. Meanwhile, the highly competitive labor market provides opportunities for employees to change workplaces and job positions. Health assessment data collected during the occupational history is an essential resource for developing efficient occupational disease prevention strategies as well as for ensuring the physical and psychological well-being of newly appointed workers. The diversity in data representation is source for interoperability problems that are insufficiently explored in the existing literature. ObjectivesThis research aims to design a worker’s occupational health assessment summary (OHAS) dataset that satisfies the requirements of an international standard for semantic interoperability in the use case for exchanging extracts of such data. The focus is on the need for a common OHAS standard at EU level allowing seamless exchange of OHAS at both cross-border and at the worker’s country of origin level. ResultsThis paper proposes a novelty systematic approach ensuring semantic interoperability in the exchange of OHAS. Two use cases are explored in terms of UML sequence diagram. The OHAS dataset reflects common data requirements established in the national legislation of EU countries. Finally, an EN 13606 archetype of OHAS is designed by satisfying the requirements for semantic interoperability in the exchange of clinical data. Semantic interoperability of OHAS is demonstrated with realistic use case data. ConclusionsThe designed static, non-volatile and reusable information model of OHAS developed in this paper allows to create EN 13606 archetype instances that are valid with respect to the Reference model and the datatypes of this standard. Thus, basic activities in the OHAS use case can be implemented in software, for example, by means of a native XML database as well as integrated into existing information systems.

A New Complexity Metric for UML Sequence Diagrams

Object-Oriented Programming (OOP) has been promoted as a way to produce high-quality software while increasing developer productivity through code reuse. Software systems and underlying designs get more extensive and more complicated while maintaining a high degree of quality. One of the widely accepted standards for describing software architectures is the UML Sequence Diagram. A sequence diagram depicts the interaction of two-dimensional chart players by showing messages delivered and received between them. This research aims to develop and validate a metric for complexity evaluation in software design architectures through UML Sequence diagrams. The study included design science, which included metric specification, the creation of a measurement tool, and conceptual and factual verification of the metrics. The metrics use diagram-centric complexity measurements shown to be meaningful when used to determine the difficulty of two example sequence diagrams. Furthermore, conceptual affirmation of the stated metrics was achieved through Weyuker's nine characteristics, which demonstrated that they are computationally efficient. The metric was empirically authenticated, and the findings show that measuring the complexity of sequence diagrams is expedient.

A Graph Transformation Approach for Modeling UML Diagrams

This article proposes an approach for transforming UML Statecharts, Sequence Diagrams and activity Diagrams to Time Petri Nets with Action Duration (DTPN) using graph transformation. By this transformation the author aims to bridge the gap between semi-formal models generated by UML and formal models DTPN. UML is considered to be the standardized language for modelling and describing systems behaviors for analysis. In other hand, DTPN models are tools for the specification and performance analysis of distributed and concurrent systems. However, the proposed approach allows to generate automatically a visual modeling tool for DTPN. The cost of building a visual modeling tool from scratch is prohibitive. Meta-modeling approach is useful to deal with this problem since it allows the modeling of the formalisms themselves, by means of graph grammars. The meta-modeling tool AToM3 is used.

PARMOREL: a framework for customizable model repair

In model-driven software engineering, models are used in all phases of the development process. These models must hold a high quality since the implementation of the systems they represent relies on them. Several existing tools reduce the burden of manually dealing with issues that affect models’ quality, such as syntax errors, model smells, and inadequate structures. However, these tools are often inflexible for customization and hard to extend. This paper presents a customizable and extensible model repair framework, PARMOREL, that enables users to deal with different issues in different types of models. The framework uses reinforcement learning to automatically find the best sequence of actions for repairing a broken model according to user preferences. As proof of concept, we repair syntactic errors in class diagrams taking into account a model distance metric and quality characteristics. In addition, we restore inter-model consistency between UML class and sequence diagrams while improving the coupling qualities of the sequence diagrams. Furthermore, we evaluate the approach on a large publicly available dataset and a set of real-world inspired models to show that PARMOREL can decide and pick the best solution to solve the issues present in the models to satisfy user preferences.

Structure-Behavior Coalescence Method for Formal Specification of UML 2.0 Sequence Diagrams

This paper presents the structure-behavior coalescence (SBC) method for the formal specification of UML sequence diagrams. The SBC method, also named SBC sequence diagrams (SBC-SqD), includes syntax and semantics. The syntax allows the hierarchy of a sequence diagram to be represented as a parse tree. The semantic meaning of that sequence diagram is then represented by its message sending-and-receiving event transition graph (MSRETG). In order to create this MSRETG, the semantic meaning of sequence diagram (SD) modules is presented, including the meaning of these modules when they are used in a hierarchy that defines another module. Such hierarchical decomposition is formally provided for all sequence diagram modules, including all types of loops. In UML, all SD modules are also called combined fragments (CF). The obtained MSRETG has advantages over previous formal specifications, because it is a fully-complete specification and is compact and readable.

The Specification of Air-to-Air Combat Tactics Using UML Sequence Diagram

Air force air-to-air combat tactics are occurring at a high speed in three-dimensional space. The specification of the tactics requires dealing with a quite amount of information, which makes it a challenge to accurately describe the maneuvering procedure of the tactics. The specification of air-to-air tactics using natural languages is not suitable because of the intrinsic ambiguity of natural languages. Therefore, this paper proposes an approach of using UML Sequence Diagram to describe air-to-air combat tactics. Since the current Sequence Diagram notation is not sufficient to express all aspects of the tactics, we extend the syntax of the Sequence Diagram to accommodate the required features of air-to-air combat tactics. We evaluate the applicability of the extended Sequence Diagram to air-to-air combat tactics using a case example, that is the manned-unmanned teaming combat tactic. The result shows that Sequence Diagram specification is more advantageous than natural language specification in terms of readability, conciseness, and accuracy. However, the expressiveness of the Sequence Diagram is evaluated to be less powerful than natural language, requiring further study to address this issue.

Bridging the model-to-code abstraction gap with fuzzy logic in model-based regression test selection

Regression test selection (RTS) approaches reduce the cost of regression testing of evolving software systems. Existing RTS approaches based on UML models use behavioral diagrams or a combination of structural and behavioral diagrams. However, in practice, behavioral diagrams are incomplete or not used. In previous work, we proposed a fuzzy logic based RTS approach called FLiRTS that uses UML sequence and activity diagrams. In this work, we introduce FLiRTS 2, which drops the need for behavioral diagrams and relies on system models that only use UML class diagrams, which are the most widely used UML diagrams in practice. FLiRTS 2 addresses the unavailability of behavioral diagrams by classifying test cases using fuzzy logic after analyzing the information commonly provided in class diagrams. We evaluated FLiRTS 2 on UML class diagrams extracted from 3331 revisions of 13 open-source software systems, and compared the results with those of code-based dynamic (Ekstazi) and static (STARTS) RTS approaches. The average test suite reduction using FLiRTS 2 was 82.06%. The average safety violations of FLiRTS 2 with respect to Ekstazi and STARTS were 18.88% and 16.53%, respectively. FLiRTS 2 selected on average about 82% of the test cases that were selected by Ekstazi and STARTS. The average precision violations of FLiRTS 2 with respect to Ekstazi and STARTS were 13.27% and 9.01%, respectively. The average mutation score of the full test suites was 18.90%; the standard deviation of the reduced test suites from the average deviation of the mutation score for each subject was 1.78% for FLiRTS 2, 1.11% for Ekstazi, and 1.43% for STARTS. Our experiment demonstrated that the performance of FLiRTS 2 is close to the state-of-art tools for code-based RTS but requires less information and performs the selection in less time.

‘Toward a Global Social Contract for Trade’ - a Rawlsian approach to Blockchain Systems Design and Responsible Trade Facilitation in the New Bretton Woods era

Imminent changes to the international monetary system alongside a shift toward more egalitarian principles of justice in commercial contracts for trade are now taking place. Such changes however do not sufficiently account for circumstances of hardship, or black-swan events such as COVID-19, whereby the relative losers of trading arrangements should continue to receive outcomes which are not only efficient, but also fair and resilient. We argue that the ‘Society-in-the-Loop’ (SITL) social contract paradigm, in conjunction with the use of Strategic Responsible Innovation Management (StRIM), can together provide a solution for improving distributive justice in trade. Through collaboration with a locally based trade facilitation company, we describe the innovation-planning phase of a blockchain smart contract solution based on Derek Leben's idea of a ‘Rawlsian Algorithm’ (2017). It is demonstrated how this can be used to strengthen the algorithmic fairness of commercial contract implementation in accordance with existing ISO 20022 standards. Since currently no formal design framework exists for modeling blockchain oriented software (BOS), an agile development approach is adopted which takes account of the substantial difference between traditional software development and smart contracts. This method involves the construction of UML Use Case, Sequence, and Class diagrams, with a view to blockchain specificities. Evaluation and feedback from the company is also considered.

Leveraging SPARQL Queries for UML Consistency Checking

Context and motivation: Multiple-viewed requirements modeling method describes the system to-be from different perspectives. Some requirements models are then specified in various UML diagrams. Question/problem: Managing those models can be tedious and error-prone, since a lot of CASE tools provide poor support for reasoning and consistency checking. Principal ideas/results: Ontology is a formal notation for describing concepts and their relations in a domain. Since software requirements are a kind of knowledge, we propose to adopt a knowledge engineering approach for managing the consistency of requirements models. In this paper, an ontology for three most commonly used UML diagrams is developed in Web Ontology Language (OWL). The transformation of UML class, sequence and state diagrams to OWL knowledge base is presented. Owing to the underlying logical reasoning capability of OWL, a semantic query language, SPARQL (SPARQL Protocol and RDF Query Language), is used to query the knowledge base for consistency checking. Contribution: This paper introduces a semantic web-based knowledge engineering approach to represent and manage software requirements knowledge in OWL. By experimenting with a concrete software system, we demonstrate the feasibility and applicability of this knowledge approach.

Optimization of Favourable Test Path Sequences Using Bio-Inspired Natural River System Algorithm

Testing of software requires a great amount of time and effort. The tester's main aim is to design optimized test sequences with a minimum amount of time, effort, and with less redundancy. Testers have used artificial intelligence meta-heuristic algorithms for optimization of test sequences. The model-driven approach is helpful in the generation of test sequences at early designing phase only. The model-driven approach uses UML diagram to represent the system's behavior and design test cases for the system at design stage of software development life cycle. The proposed approach uses natural river system for optimizing favourable non-redundant test path sequences using UML activity diagrams and sequence diagrams. The implementation of proposed approach has been done using python and results show that the proposed approach provides full coverage of test paths with less redundant test nodes compared to other meta heuristic algorithms.

UML sequence diagram to axiomatic design matrix conversion: a method for concept improvement for software in integrated systems

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.

UML Sequence Diagram: An Alternative Model

The UML sequence diagram is the second most common UML diagram that represents how objects interact and exchange messages over time. Sequence diagrams show how events or activities in a use case are mapped into operations of object classes in the class diagram. The general acceptance of sequence diagrams can be attributed to their relatively intuitive nature and ability to describe partial behaviors (as opposed to such diagrams as state charts). However, studies have shown that over 80% of graduating students were unable to create a software design or even a partial design, and many students had no idea how sequence diagrams were constrained by other models. Many students exhibited difficulties in identifying valid interacting objects and constructing messages with appropriate arguments. Additionally, according to authorities, even though many different semantics have been proposed for sequence diagrams (e.g., translations to state machines), there exists no suitable semantic basis refinement of required sequence diagram behavior because direct style semantics do not precisely capture required sequence diagram behaviors; translations to other formalisms disregard essential features of sequence diagrams such as guard conditions and critical regions. This paper proposes an alternative to sequence diagrams, a generalized model that provides further understanding of sequence diagrams to assimilate them into a new modeling language called thinging machine (TM). The sequence diagram is extended horizontally by removing the superficial vertical-only dimensional limitation of expansion to preserve the logical chronology of events. TM diagramming is spread nonlinearly in terms of actions. Events and their chronology are constructed on a second plane of description that is superimposed on the initial static description. The result is a more refined representation that would simplify the modeling process. This is demonstrated through remodeling sequence diagram cases from the literature.

Extension of the Function to Ensure Real-time Traceability between UML Sequence Diagram and Java Source Code on RETUSS

Extension of the Function to Ensure Real-time Traceability between UML Sequence Diagram and Java Source Code on RETUSS

Ameliorated Methodology To Meta Model UML Sequence Diagram In The Table Format

Ameliorated Methodology To Meta Model UML Sequence Diagram In The Table Format

ABCDE—agile block chain DApp engineering

Blockchain software development is becoming more and more important for any modern software developer and IT startup. Nonetheless, blockchain software production still lacks a disciplined, organized and mature development process, as demonstrated by the many and (in)famous failures and frauds occurred in recent years. In this paper we present ABCDE, a complete method addressing blockchain software development. The method considers the software integration among the blockchain components—smart contracts, libraries, data structures—and the out-of-chain components, such as web or mobile applications, which all together constitute a complete DApp system. We advocate for ABCDE the use of agile practices, because these are suited to develop systems whose requirements are not completely understood since the beginning, or tend to change, as it is the case of most blockchain-based applications. ABCDE is based on Scrum, and is therefore iterative and incremental. From Scrum, we kept the requirement gathering with user stories, the iterative-incremental approach, the key roles, and the meetings. The main difference with Scrum is the separation of development activities in two flows—one for smart contracts and the other for out-of-chain software interacting with the blockchain—each performed iteratively, with integration activities every 2–3 iterations. ABCDE makes explicit the activities that must be performed to design, develop, test and integrate smart contracts and out-of-chain software, and documents the smart contracts using formal diagrams to help development, security assessment, and maintenance. A diagram derived from UML class diagram helps to effectively model the data structure of smart contracts, whereas the exchange of messages between the entities of the system is modeled using a modified UML sequence diagram. The proposed method has also specific activities for security assessment and gas optimization, through systematic use of patterns and checklists. ABCDE focuses on Ethereum blockchain and its Solidity language, but preserves generality and with proper modifications might be applied to any blockchain software project. ABCDE method is described in detail, and an example is given to show how to concretely implement the various development steps.

An UML Based Performance Evaluation of Real-Time Systems Using Timed Petri Net

Performance is a critical non-functional parameter for real-time systems and performance analysis is an important task making it more challenging for complex real-time systems. Mostly performance analysis is performed after the system development but an early stage analysis and validation of performance using system models can improve the system quality. In this paper, we present an early stage automated performance evaluation methodology to analyse system performance using the UML sequence diagram model annotated with modeling and analysis of real-time and embedded systems (MARTE) profile. MARTE offers a performance domain sub-profile that is used for representing real-time system properties essential for performance evaluation. In this paper, a transformation technique and transformation rules are proposed to map the UML sequence diagram model into a Generalized Stochastic Timed Petri net model. All the transformation rules are implemented using a metamodel based approach and Atlas Transformation Language (ATL). A case study from the manufacturing domain a Kanban system is used for validating the proposed technique.

Verification of the Instantiation and Integration of Security Patterns

As software applications suffer from increasing malicious attacks, security becomes a critically important issue for software development. To avoid security problems and increase efficiency, a large software system design may reuse good security solutions for existing security patterns. While security patterns document expert solutions to common security problems and capture well-examined practices on secure software design, implementing them in a particular context (pattern instantiation) and composing them with other related patterns (pattern integration) are prone to flaws and may break expected security properties. In this paper, we present an approach to verify security patterns instantiation and integration automatically. We offer formal definitions for security pattern instantiation and integration, and establish rules to transform sequence diagrams (representing the behaviors of security patterns) to expressions in Milner’s Calculus of Communicating Systems (CCS). We prove the correctness of the proposed transformation, and propose an algorithm to carry out this transformation automatically. In particular, we formally specify the alternative flows of UML sequence diagrams guarded by constraint conditions, which allows us to model choice making behaviors of security patterns precisely. The properties of the instantiation and integration can be verified by model checking against their CCS expressions. Flaws of instantiation and integration can, therefore, be discovered early in the design stage. We use two case studies to illustrate our approach and show the capability to prove security in integration and detect design errors in instantiation respectively.

Smart Test Case Quantifier Based on Mc/Dc Coverage Criterion with Uml Sequence Diagram

Software testing is an inevitable phase in the Software Development Life Cycle (SDLC). It plays a vital role in ensuring the quality of the product. Testing can be performed on requirement, design and code. Traditional test case generation approaches majorly focuses on designing and implementation models, as a huge percentage of errors in the software are caused due to the lack of understanding in the early phases. So, it’s advisory to follow testing in the initial phase in SDLC as most of the errors/faults can be eliminated and can be prevented without disseminating to the next phase. So, testing must not be secluded to a single phase alone in SDLC. In software testing, test case generation is the fundamental and challenging part. The major purpose to design test case is to create set of tests that are valuable in validation. Due to the increase in software size, it’s not quite advisable to have the choice as manual testing to test the code as its error prone, complex and time consuming. Automation of testing would help the tester to test effectively and timely. Applications of new techniques improve the test process and cut down the tester’s effort. The proposed work presents a sandwich of black box and white box testing. Design-based testing, a black box approach is implemented, that aids in fixing the errors at initial phase. Unified Modeling Language (UML) Use case diagram, Activity diagram and Sequence Diagram are considered for designing. The code-based generation of test cases, is a white box testing approach, test coverage criteria Modified Condition/Decision Condition (MC/DC) has been used to ensure the maximum coverage of the code during testing phase for generating the test cases. The objective of this paper is to automate the generation of minimal number of test cases required to test a system with maximum coverage by removing the redundant test cases using MC/DC criterion. This present an idea to the beginners of the testing about minimal test cases they necessitate for testing their system.

Regression testing of object-oriented systems using UML state machine diagram and sequence diagram

The software requirements are modelled using UML state machine diagram and UML sequence diagram. The different features of both the diagrams are combined and an intermediate graph, i.e., state sequence graph (SSG) is generated. The affected nodes, due to different changes in the past versions of the applications are stored for further analysis. Whenever, a new version of the software is developed, and it is under regression testing, test scenario prioritisation is carried out by finding the frequent pattern from the stored modification history. Different other factors like number of message passing, number of state changes etc. also contribute in prioritising the test cases. The proposed approach is applied on different case studies and the results are recorded. This approach is found to be very efficient when evaluated using prioritisation metric and compared with other related work.

Regression testing of object-oriented systems using UML state machine diagram and sequence diagram

The software requirements are modelled using UML state machine diagram and UML sequence diagram. The different features of both the diagrams are combined and an intermediate graph, i.e., state sequence graph (SSG) is generated. The affected nodes, due to different changes in the past versions of the applications are stored for further analysis. Whenever, a new version of the software is developed, and it is under regression testing, test scenario prioritisation is carried out by finding the frequent pattern from the stored modification history. Different other factors like number of message passing, number of state changes etc. also contribute in prioritising the test cases. The proposed approach is applied on different case studies and the results are recorded. This approach is found to be very efficient when evaluated using prioritisation metric and compared with other related work.