Unified Modeling Language Activity Research Articles

A UML Activity Flow Graph-Based Regression Testing Approach

Regression testing is a crucial process that ensures that changes made to a system do not affect existing functionalities. However, there is currently no adequate technique for selecting test cases that consider changes in Unified Modeling Language (UML) activity flow graphs. This paper proposes a novel approach to regression testing of UML diagrams, focusing on healthcare management systems. We provide a formal definition of sequence and activity diagrams and their relationship and construct corresponding activity flow graphs, which are used to develop a regression testing algorithm. The proposed algorithm categorizes test cases into reusable, retestable, obsolete, and newly generated categories by comparing old and new versions of UML activity flow graphs. The methodology is evaluated using a custom-designed hospital management system website as the test case, and the results demonstrate a significant reduction in time and resources required for regression testing. Our study provides valuable insights into the application of UML diagrams and activity flow graphs in regression testing, making it an important contribution to software testing research.

Guidelines and a software tool for quality assessment of BPMN business process models

This paper considers the problem of quality measurement of Business Process Model and Notation business process models. Business process models presented using BPMN and other notations are graphical schemes similar to flowcharts or UML (Unified Modeling Language) activity diagrams utilized in software engineering. Business process modeling strives to capture current enterprise workflows for analysis and improvement using automation through workflow systems deployment. Therefore, designed high-quality business process models have to be understandable and maintainable. It can help efficiently identify and replace all “weak spots” of described organizational workflows with more efficient solutions. Whereas business process models which are not understandable, unstructured and uncertain may cause even more errors than benefits. Therefore, this study proposes guidelines and a software tool for errors detection in business process models.

The 1+5 Architectural Views Model in Designing Blockchain and IT System Integration Solutions

Service fulfillment for clients increasingly involves cooperation between information technology (IT) systems. Designing such solutions requires an architectural approach that ensures symmetry between the communicating parties. For the design of such systems, the author introduces the 1+5 architectural views model. The model contains three new architectural views. For business process modeling, it ensures the integrated processes view. Integration aspects cover two additional views: integrated services, and contracts. Moreover, new stereotypes and tagged values have been added to the unified modeling language (UML). The author has introduced two profiles: UML profile for integration flows, and UML profile for distributed ledger deployment. Communication between systems requires flows that arrange mediation mechanisms. The paper describes an integration flow diagram that extends a UML activity diagram. In the case of blockchain, the author has proposed the smart contract design pattern. The paper describes three case studies that have employed the model to design various solutions. The 1+5 model has proven to be well suited for designing both centralized integration environments with enterprise service bus (ESB) and distributed blockchain solutions with peer-to-peer (P2P) connections.

Characterizing Student Proficiency in Software Modeling in Terms of Functions, Structures, and Behaviors

Software modeling is an integral practice for software engineers, especially as the complexity of software solutions increases. Unified Modeling Language (UML) is the industry standard for software modeling. however, it is often used incorrectly and misunderstood by novice software designers. This study is centered around understanding patterns of student proficiency of abstraction and systems thinking within a software modeling context. The participants of this study (n = 97) belonged to a systems analysis and design course that is primarily taken by second-year university students. The exam solutions to a case study from the course were evaluated for modeling proficiency. As evidence of proficiency in abstract thinking and systems thinking, we evaluated UML activity diagrams, class diagrams, and sequence diagrams and the alignment between these representations in terms of functions, structures, and behaviors. The results suggest students being proficient in modeling the functional aspects of an information system while facing some difficulty in capturing the structural and behavioral aspects of an information system. Clustering analysis revealed two groups within the sample, with one group displaying a significantly higher abstraction and systems thinking ability. Statistically significant correlations were also found between student proficiency of abstraction and their modeling proficiency in terms of functions, structures, and behaviors.

Extending LADM to support workflows and process models

In order to be able to guarantee the overall correctness of data, updating of Land administration system’s data must be executed following a formally and technically clearly defined and controllable procedure (process). In general technical sense, correctness of data primarily depends on its consistency. Databases natively support enforcing consistency of transactions over the data but lack the flexibility needed for modelling business processes and do not natively support operating in heterogeneous IT environments (web services, various external and loosely coupled systems). WorkFlow Management Systems (WFMS) with integrated transactional properties provide a technological platform which supports enforcing consistency within heterogeneous IT environments. Within the scope of our previous work and in order to provide a standardised means for modelling of dynamic component of Land Administration Systems (LASs), we developed an extension to LADM for integrating processes into LADM. We propose to extend the LADM with a new class LA_Process, as a sub-class of the existing LADM class LA_Source. Also, LA_Process is associated to descendants of LA_Source (spatial and administrative source) and versioned object. Associating those classes to LA_Process enables executing processes over instances of LADM classes in a versioning supported manner and linked to underlying formal documents. This extension is proposed to be included in the second edition of the LADM which is under development (Lemmen et al., 2019). Within this work we further revise LA_Process in order to broaden its scope and to consider processes on LADM classes outside of the SpatialUnit package. In addition to this proposed extension of the LADM we give an example of hierarchical modelling of LAS-processes. We define topmost two levels of processes with a basic set of activities which are applicable to any LAS. As the granularity of activities increases, processes may become dependent on a particular LAS but the general concepts from topmost level should be followed. We use UML (Unified Modelling Language) Activity Diagrams to model processes in LAS.

Hierarchical Activity-Based Models for Control Flows in Parallel Discrete Event System Specification Simulation Models

Behavior modeling grounded in the Discrete-Event System Specification (DEVS) and Unified Modeling Language (UML) activity specifications is crucial for simulating dynamical systems. The Model-Driven Architecture (MDA) design approach provides flexible yet rigorous layered metamodels for the UML activity diagrams. Our approach for behavior modeling is focused on the action and control concepts in the UML activity metamodels and realizing them as artifacts according to the DEVS formalism. The syntax and semantics for the artifacts conform to the parallel DEVS model specification and execution protocol. We use the system-theoretic state, component, and hierarchy concepts as the foundation for formulating the DEVS Activity models and supported with a prototype graphical tool developed in Sirius. This research also proposes the Parallel DEVS as a formal approach for examining the semantics of the UML Activities. We develop, simulate, and analyze a set of prototypical multi-processor architecture systems demonstrating different synchronization and selection schemes using the DEVS-Suite and MS4 Me simulators.

Orientation-based Ant colony algorithm for synthesizing the test scenarios in UML activity diagram

Abstract Context The model-based analysis is preferred over the code-based analysis as it speeds up the development process and directs the guiding effort. In the software industry, the Unified Modeling Language (UML) is a set standard followed by the developers as well as system analysts to extract all attainable paths of controls, usually known as scenarios under an activity diagram. Objective In this manuscript, a bio-inspired methodology has been applied on concurrent sub-part of a UML activity diagram to fetch various feasible test scenarios. Method The food search pattern of an ant has been taken as a base heuristic. An orientation factor has been introduced in the existing ant colony optimization algorithm. Experiments have been performed using three student projects, five synthetic models and an openly available model repository named LINDHOLMEN data-set at Github. Results The statistical analysis has validated the results obtained through various existing approaches and the proposed approach. Experimentation shows that the orientation-based ant colony algorithm has produced better results as compared to the existing Genetic Algorithm (GA) and Ant Colony Optimization (ACO) on the basis of feasible test scenarios generated.

An integration of uml use case diagram and activity diagram with Z language for formalization of library management system

Unified Modeling Language (UML) is the effective standard for modeling object-oriented software systems. However, the ambiguity of semantics and the absence of consistency among UML diagrams lead to lack of precisely defining the requirements of a system. On the other hand, formal methods are techniques and tools use the mathematical notations, and they involve the precise syntax and semantics of the unambiguous software requirements specification. It applied in early stages of Software Development Life Cycle (SDLC). Therefore, an integrated between UML specification and formal specification is required to reduce the requirements' ambiguity and error, and to improve the quality and security of software systems. This paper proposes an approach involves the combining UML use-case diagram and activity diagrams with Z language for formalization of Library Management System (LMS). The focus of this paper is on consistency between the UML diagrams to Z Schema, and then verified by using the Z / EVEs tool.

Automated Nonintrusive Analysis of Electronic System Level Designs

Due to the ever increasing complexity of hardware systems, designers strive for higher levels of abstractions in the early stages of the design process. Modeling hardware at the electronic system level (ESL) is one way to address this demand, with the C++-based system modeling framework SystemC and its abstract communication library transaction level modeling (TLM) having become de-facto standards for ESL system design. While the C++ compiler is sufficient to compile and simulate a given ESL design, for tasks of design understanding, debugging, or validation (where access to the details of design’s structure and behavior is necessarily required), design needs to be processed by an appropriate tool. This problem is often solved by adding instrumentation code to either the design or the library, usually resulting in incomplete logs, work overhead and/or incompatibilities. This paper introduces an approach that automatically extracts information about both, structure and behavior of SystemC designs and TLM transactions, nonintrusively. The information is retrieved from a given design by running it in debug mode while being connected to a preprogrammed debugger, thus leaving the existing sources and workflows untouched while collecting a vast amount of data without user intervention. Illustrating use cases, value change dump files of the SystemC models’ behavior and unified modeling language activity diagrams of transaction protocols are created automatically from simulation runs.

UML activity diagram transformation into BPEL integration flow

The growing interest of companies in integration and interoperability between information systems has caused increase in significance of Service-Oriented Architecture which provides tools for Enterprise Application Integration. In that architecture, Enterprise Service Bus provides technical possibilities of communication between IT systems. A key element in the communication are integration flows. Objective: The aim of this article is to present a new transformation Integration2BPEL, which automates the development of executable integration flow expressed in the Web Services Business Process Execution Language (WS-BPEL) based on the model of the integration flow presented in the Unified Modelling Language (UML) activity diagram. Method: The author proposes a transformation of the type of model-to-code type which generates integration flow expressed in WS-BPEL, which can be executed in any BPEL-compliant process engine. The integration flow is modelled using UML activity diagram with stereotypes from ‘UML Profile for Integration Flows’ profile in an IBM Rational Software Architect (RSA). Using Integration2BPEL transformation a complete, executable integration flow is generated, which is composed of many mediation mechanisms. Generated integration flows have been executed on OpenESB. Results: The ability to generate a complete integration flow in BPEL, which without any additions can be run on enterprise service bus. Implementation phase of an integration flow construction was automated. Each of integration flows is implemented according to the same rules. In addition, it allows to avoid mistakes made by designers and programmers. Conclusions: Model-Driven Development is an approach that leads to the automation of the design and programming phases. Integration2BPEL transformation is a uniform mechanism to design integration flow. Potentially, it also allows to avoid implementation errors. Keywords: Web Services Business Process Execution Language (BPEL), Enterprise Service Bus (ESB), Unified Modelling Language (UML), UML activity diagram, Model-Driven Development (MDD), Transformation. null

Object constraint language for code generation from activity models

ContextAchieving hundred percent automation in code generation process from Unified Modeling Language (UML) models will make a drastic advancement in software industry. UML does not use a fully formalized semantics. So it leads to ambiguity during automatic implementation of UML models. These ambiguities can be avoided to a large extent using Object Constraint Language (OCL). OCL is formal and user friendly which is also familiar to industry people. ObjectiveThis paper examines how to improve the code generation from UML models, with the help of Object Constraint Language. It also explores the possibilities to incorporate OCL in UML activity models and generate code from the OCL enhanced activity diagrams. MethodMeta models for the association of OCL expressions with the UML activity diagram is proposed in the paper. OCL expressions are added as part of the UML activity models to improve the code generation and to specify assertions and behavior. Moreover a tool, called ActivityOCLKode, is implemented which follows the algorithm for code generation. The algorithm is depicted in the text. ResultsThe tool which is implemented based on the proposed method gives a promising result. More than 80% of source code is generated using the tool. In addition, the average execution time for our approach is only 11.46 ms. ConclusionThe meta model proposed in the paper gives the strong theoretical back ground to attach OCL statements with each element in the UML activity diagrams. The proposed method of code generation will improve the productivity of the software industries, since it reduces the software development effort and time. Since UML and OCL are commonly used in software industry, our method is easily adaptable by software programmers in industry.

Synthesizing test scenarios in UML activity diagram using a bio-inspired approach

The model-based analysis is receiving a wide acceptance as compare to code-based analysis in the context of prioritizing and guiding the testing effort and speeding up the development process. Ordinarily, system analysts as well as developers follow Unified Modeling Language (UML) activity diagrams to render all realizable flows of controls commonly recognized as scenarios of use cases. This paper applies a bio-inspired algorithm to produce test scenarios for the concurrent section in UML activity diagram. Here, the heuristic draws its inspiration from the internal mechanism of the slime mould Physarum Polycephalum, a large single-celled amoeboid organism. Simulations are performed using eight subject systems taken from the LINDHOLMEN data-set, two models taken from real life student projects and five synthetic models. The results obtained through different approaches are validated through the statistical analysis which demonstrates that our proposed approach is better than the existing Ant Colony Optimization (ACO) and Genetic Algorithm (GA) by a number of feasible test scenarios generated.

Automatic code generation using unified modeling language activity and sequence models

A fully automatic translation of unified modeling language (UML) models to complete source code is not reported so far because some implementation details will not be there in the model, or a single UML model is not enough for complete code generation, or some model elements may not be directly convertible to source code. These issues are addressed in this study. The authors take workflow modelling and automation as the focus of their research. Hence, UML activity diagram is considered. Activity diagram alone cannot give the implementation details like object interactions. A formal association is found between activity and sequence diagrams to add object interaction details to the work flow. Moreover, the authors formulate an algorithm, Am_To_Prototype , which is composed of two subroutines named Method_Body & Excecution_Logic , to generate code from the combined model of activity and sequence diagrams consisting of concurrent activities. The authors compare the proposed method with other research outcomes with respect to workflow automation, support for concurrency, etc. The proposed algorithms are able to generate class definition, method definition and control flow. A case study is presented that demonstrates the algorithm, to generate Java code for the ATM operation.

Accessible Modelling of Complexity in Health (AMoCH) and associated data flows: asthma as an exemplar.

Background Modelling is an important part of information science. Models are abstractions of reality. We use models in the following contexts: (1) to describe the data and information flows in clinical practice to information scientists, (2) to compare health systems and care pathways, (3) to understand how clinical cases are recorded in record systems and (4) to model health care business models.Asthma is an important condition associated with a substantial mortality and morbidity. However, there are difficulties in determining who has the condition, making both its incidence and prevalence uncertain.Objective To demonstrate an approach for modelling complexity in health using asthma prevalence and incidence as an exemplar.Method The four steps in our process are:1. Drawing a rich picture, following Checkland's soft systems methodology;2. Constructing data flow diagrams (DFDs);3. Creating Unified Modelling Language (UML) use case diagrams to describe the interaction of the key actors with the system;4. Activity diagrams, either UML activity diagram or business process modelling notation diagram.Results Our rich picture flagged the complexity of factors that might impact on asthma diagnosis. There was consensus that the principle issue was that there were undiagnosed and misdiagnosed cases as well as correctly diagnosed. Genetic predisposition to atopy; exposure to environmental triggers; impact of respiratory health on earnings or ability to attend education or participate in sport, charities, pressure groups and the pharmaceutical industry all increased the likelihood of a diagnosis of asthma. Stigma and some factors within the health system diminished the likelihood of a diagnosis. The DFDs and other elements focused on better case finding.Conclusions This approach flagged the factors that might impact on the reported prevalence or incidence of asthma. The models suggested that applying selection criteria may improve the specificity of new or confirmed diagnosis.

RFID temperature sensors for monitoring soil solarization with biodegradable films

Soil-borne pathogen and weed control can be achieved by soil solarization even if estimation of time treatment is difficult to assess. Thus, due to dependence to environmental conditions and the need to minimize the time of treatments, the implementation of monitoring tools may help in solarization managements, especially when biodegradable films were applied or weather condition are subjected to significant variation. Digitalization of data relative to plants thanks to RFID applications has been used for health or treatment monitoring, sample collecting and retrieving sanitary information: this paper presents the testing of RFID sensor application for soil solarization purposes. Different matrices were selected to assess RFID temperature sensors performances. Sandy, loam and clay soils with different moisture-holding capacity were selected for sensor burial. Sensors were covered by 5 or 10cm of fresh matrix and read immediately. Reliability was found to be more than 90% in all tested conditions, while higher failure in tag reading was recorded in clay soil at 90% of moisture-holding capacity (−7% of tag reliability). Soil solarization treatment was carried out as case of study during a period characterized by changeable weather using a biodegradable film. Data, expressed as thermal addition and temperature classes, collected continuously by sensors permitted to design real-time graphs that help the farmer to understand the thermal effect caused by treatment. Throughout the second and third week of treatments, Tmax at 5cm depth is increased by 9–13°C or 11–14°C compared to environment, respectively. Otherwise, Tmax at 10cm depth is increased by 7–9°C compared to environment throughout the second and third week, showing as sensors are able to collect temperature during solarization. The soil microbial community of soils treated with solarization exhibited a slight reduction of cumulative carbon metabolic activity compared to control (8.8% of reduction), while among 31 preselected carbon sources, the soil microbial communities were capable of utilizing up to 23 carbon source without difference between treatments. Unified Modeling Language activity diagrams for solarization management via digital sensors were designed and effects of biodegradable film on microbial population were observed. The integration of information technology solutions with new-generation biodegradable films may offer an interesting revaluation of soil solarization in actual farm organization.

Aspect-oriented modeling framework for security hardening

Aspect-oriented modeling (AOM) emerged as a promising paradigm for handling crosscutting concerns, such as security, at the software modeling level. Most existing AOM contributions are presented from a practical perspective and lack formal syntax and semantics. In this paper, we present a practical and formal AOM framework for software security hardening. Our contributions are threefold. First, we define an AOM approach for the specification of security aspects at the unified modeling language (UML) design level. Second, we design and implement the matching and the weaving processes into UML design models. Third, we elaborate formal specifications for aspect matching and weaving in UML activity diagrams. Finally, we demonstrate the viability and the relevance of our propositions using a case study. The proposed framework is supported by a tool built on top of IBM-Rational Software Modeler.

Transformation process of RTS scheduling analysis requirements from UML/MARTE to dynamic priority time Petri Nets

The real-time system (RTS) design is a major challenge due to the complexity of the considered application and the appearance of multiprocessor architectures. Most of the research in this area is interested in high abstraction level methods to decrease the design convolution. In particular, the Unified Modeling Language (UML) profiles and the Model Driven Engineering (MDE) aim at being an adequate solution to support the whole life cycle of RTS design with its real-time constraints and performance issues. Based on MDE and the Modeling and Analysis of Real-Time and Embedded systems (MARTE) profile, the present manuscript proposes an interactive partitioning scheduling of RTS running on multiprocessor architecture. A special attention is paid to the scheduling analysis step to accelerate the exploration of HW/SW space solution. Starting from a candidate solution modeled with UML activity and annotated with MARTE stereotypes, a mapping process to dynamic priority time Petri Nets (dPTPN) was defined. The considered dPTPN is able to prove the schedulability or provide a counterexample to determine the partitions causes of temporal fault. This counterexample presents a useful feedback to the HW/SW space solution explorer in the aim to exclude all solution containing the described partitions.

Presentation of an executable model for evaluation of software architecture using blackboard technique and formal models

Considering the promotion and complexities of software systems and need to services for repair and updating, success of this system is extremely dependent to its architecture and design. Architectural techniques due to being used by the architectures frequently have specified effect on qualitative characteristics. If this effect is quantitative and measurable for each technique will enable the architect to have more care and convenience for evaluation of design and architectural designs. In this study, at first to show the structure and behavior of software architecture using blackboard technique, component diagram and unified modeling language activity diagram together with required data in relation to nonfunctional needs as stereotypes and labels were used. Later, upon converting the actual model to the formal model, requirements for system performance evaluation on the formal model is provided. Upon analyzing the results, it is observed that the offered method can evaluate the performance of software architecture based on blackboard technique at the design age.

On Collaboration in Software: Annotation vs. Flow-Based Diagrams

Programming may involve a fair amount of complexity. Accordingly, development of a description is needed to facilitate understanding and to serve more than documentation and initial planning requirements of a program. This paper focuses on the programming level at the point where stakeholders (e.g., designers, algorithm specialists) have concerns about the implementation method (coding) to be used, a concern that stems from the collective accountability of the software project team. The paper claims that current methodologies of producing high-level description to represent structural units and control streams in software programs fall short of providing a foundation for an easily understandable, high-level overview of what the code actually does. The paper contributes to the solution of such a problem by proposing an alternative approach to diagramming of programs. Without loss of generality, the focus on a very recent tool that generates flowcharts from annotated C++ source code to a set of interconnected high-level UML (Unified Modeling Language) activity diagrams. For comparison purposes, the diagrams produced by the methodologies are put side by side for the same source programs. The proposed diagrammatic representation seems to offer a viable alternative in the examined context to activity diagrams.

Modelling biological behaviours with the unified modelling language: an immunological case study and critique.

We present a framework to assist the diagrammatic modelling of complex biological systems using the unified modelling language (UML). The framework comprises three levels of modelling, ranging in scope from the dynamics of individual model entities to system-level emergent properties. By way of an immunological case study of the mouse disease experimental autoimmune encephalomyelitis, we show how the framework can be used to produce models that capture and communicate the biological system, detailing how biological entities, interactions and behaviours lead to higher-level emergent properties observed in the real world. We demonstrate how the UML can be successfully applied within our framework, and provide a critique of UML's ability to capture concepts fundamental to immunology and biology more generally. We show how specialized, well-explained diagrams with less formal semantics can be used where no suitable UML formalism exists. We highlight UML's lack of expressive ability concerning cyclic feedbacks in cellular networks, and the compounding concurrency arising from huge numbers of stochastic, interacting agents. To compensate for this, we propose several additional relationships for expressing these concepts in UML's activity diagram. We also demonstrate the ambiguous nature of class diagrams when applied to complex biology, and question their utility in modelling such dynamic systems. Models created through our framework are non-executable, and expressly free of simulation implementation concerns. They are a valuable complement and precursor to simulation specifications and implementations, focusing purely on thoroughly exploring the biology, recording hypotheses and assumptions, and serve as a communication medium detailing exactly how a simulation relates to the real biology.