Search

UML diagrams describe different views of one software. These diagrams strongly depend on each other and must therefore be consistent with one another, since inconsistencies between diagrams may be a source of faults during software development activities that rely on these diagrams. It is therefore paramount that consistency rules be defined and that inconsistencies be detected, analyzed and fixed. The relevant literature shows that authors typically define their own consistency rules, sometimes defining the same rules and sometimes defining rules that are already in the UML standard. The reason might be that no consolidated set of rules that are relevant by authors can be found to date. The aim of our research is to provide an up to date, consolidated set of UML consistency rules and obtain a detailed overview of the current research in this area. We therefore followed a systematic procedure in order to collect from literature up to March 2017 and analyze UML consistency rules. We then consolidated a set of 119 UML consistency rules (avoiding redundant definitions or definitions already in the UML standard), which can be used as an important reference for UML-based software development activities, for teaching UML-based software development, and for further research.

In the paper we consider a method for mining so-called “hybrid” UML models, that refers to software process mining. Models are built from execution traces of information systems with service-oriented architecture (SOA), given in the form of event logs. While common reverse engineering techniques usually require the source code, which is often unavailable, our approach deals with event logs which are produced by a lot of information systems, and some heuristic parameters. Since an individual type of UML diagrams shows only one perspective of a system’s model, we propose to mine a combination of various types of UML diagrams (namely, sequence and activity ), which are considered together with communication diagrams. This allows us to increase the expressive power of the individual diagram. Each type of diagram correlates with one of three levels of abstraction (workflow, interaction and operation), which are commonly used while considering web-service interaction. The proposed algorithm consists of four tasks. They include splitting an event log into several parts and building UML sequence, activity and communication diagrams. We also propose to encapsulate some insignificant or low-level implementation details (such as internal service operations) into activity diagrams and connect them with a more general sequence diagram by using interaction use semantics. To cope with a problem of immense size of synthesized UML sequence diagrams, we propose an abstraction technique based on regular expressions. The approach is evaluated by using a developed software tool as a Windows-application in C#. It produces UML models in the form of XML-files. The latter are compatible with well-known Sparx Enterprise Architect and can be further visualized and utilized by that tool.

The majority of flaws found in software originates in the system requirements specification stage. The use of domain-specific languages has shown to be a valuable resource in this part of the process, since they help to establish communication standards, enable automation and bring productivity and quality gains, in spite of their limited vocabulary. This study proposes the implementation of language of use case to automate models (LUCAM), a domain-specific language that allows specification of textual use cases and semi-automated generation of use case diagrams, class diagrams and sequence diagrams through LUCAMTool. To verify the feasibility of the proposed solution, tests were performed in both simulated and real environments so as to comprise a variety of scenarios observed in systems development. The approach assists in the requirement analysis and modelling, minimising existing problems in natural language specification, such as the dependence on the knowledge of specialists, uncertainty, ambiguity and complexity.

Context: In recent years, UML-based domain-specific model languages (DSMLs) have become a popular option in model-driven development projects. However, making informed design decisions for such DSMLs involves a large number of non-trivial and inter-related options. These options concern the language-model specification, UML extension techniques, concrete-syntax language design, and modeling-tool support. Objective: In order to make the corresponding knowledge on design decisions reusable, proven design rationale from existing DSML projects must be collected, systematized, and documented using an agreed upon documentation format. Method: We applied a sequential multi-method approach to identify and to document reusable design decisions for UML-based DSMLs. The approach included a Web-based survey with 80 participants. Moreover, 80 DSML projects1, which have been identified through a prior systematic literature review, were analyzed in detail in order to identify reusable design decisions for such DSMLs. Results: We present insights on the current state of practice in documenting UML-based DSMLs (e.g., perceived barriers, documentation techniques, reuse potential) and a publicly available collection of reusable design decisions, including 35 decision options on different DSML development concerns (especially concerning the language model, concrete-syntax language design, and modeling tools). The reusable design decisions are documented using a structured documentation format (decision record). Conclusion: Our results are both, scientifically relevant (e.g. for design-space analyses or for creating classification schemas for further research on UML-based DSML development) and important for actual software engineering projects (e.g. by providing best-practice guidelines and pointers to common pitfalls).

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.

Software refactoring is the process of changing a software system in a manner that does not alter its external behavior and yet improving its internal structure. Model-driven architecture and the popularity of the UML enabled the application of refactoring at model level, which was earlier applied to software code. In this paper, we propose a multi-view integrated approach to model-driven refactoring using UML models. We selected a single model from each UML view at metamodel level to construct an integrated metamodel. We selected class diagram to represent the structural view, sequence diagram to represent the behavioral view and use case diagram to represent the functional view. We validated the proposed approach by comparing integrated refactoring approach with refactoring applied to models individually in terms of quality improvement through UML model metrics. Our results indicate that more bad smell instances can be detected using the integrated approach rather than the individual refactoring approach.

Nowadays, the Unified Modeling Language (UML) is the most successful notation for the design of object-oriented applications. However, plain UML is not enough to characterize the web presentation tier of enterprise applications, including the navigational, structural and role-based access control (RBAC) features present in these applications. In this paper, we present Enterprise Web Application Extension (E-WAE), a lightweight UML extension for the modeling of these elements, which permits the inclusion of multitier, Service-Oriented Architecture (SOA) and security design-level patterns in the models. Our approach follows a Model-Driven Development (MDD) approach, which enables the automatic generation of intermediate platform-specific models and automatic code generation for JavaServer Faces (JSF) and Active Server Pages.NET Model-View-Controller (ASP.NET MVC) frameworks. In addition, this generated code can be used as a low-cost mockup for early client validation of the navigational, structural and RBAC features of enterprise applications. E-WAE has been used with different applications. In this paper, we refer to the checkout process in the Amazon website, the delete resources use case in OdAJ2EE, an educational application developed by us, and the US Library of Congress Online Catalog search facility as examples of its applicability.

Purpose The development of context-aware applications in ubiquitous environments depends not only on the user interactions but also on several context parameters. The handling of these parameters is a fundamental problem in these systems. The key purpose of this work is to enrich the unified modeling language (UML) class diagram with new constructs to provide a universal model capable of coping with the context-awareness concerns. Design/methodology/approach The authors provide a review of existing context handling approaches. Afterward, they relied on the UML extensibility mechanisms to propose a heavyweight extension for the UML class diagram. This generic approach allows describing the different context parameters since the modeling phase. Findings Existing solutions for context handling apply the contextual constraints on finished applications or tend to be dependent on a specific development process. This paper presents a solution based on UML, which allows dealing with context since the modeling phase, and independently of development processes. This proposal is implemented as an eclipse editor and illustrated through a case study in the healthcare field. Originality/value This paper addresses the problem of context handling, and it presents a review of the foremost existing solutions. The paper also presents a heavyweight extension for the UML class diagram, which consists in enriching it with additional constructs, capable of monitoring how applications are linked to context parameters and how the values of these parameters may affect the application behavior.

It is important that a Cyber-Physical System (CPS) with uncertainty in its behavior caused by its unpredictable operating environment, to ensure its reliable operation. One method to ensure that the CPS will handle such uncertainty during its operation is by testing the CPS with model-based testing (MBT) techniques. However, existing MBT techniques do not explicitly capture uncertainty in test ready models, i.e., capturing the uncertain expected behavior of a CPS in the presence of environment uncertainty. To fill this gap, we present an Uncertainty-Wise test-modeling framework, named as UncerTum, to create test ready models to support MBT of CPSs facing uncertainty. UncerTum relies on the definition of a UML profile [the UML Uncertainty Profile (UUP)] and a set of UML Model Libraries extending the UML profile for Modeling and Analysis of Real-Time and Embedded Systems (MARTE). UncerTum also benefits from the UML Testing Profile V.2 to support standard-based MBT. UncerTum was evaluated with two industrial CPS case studies, one real-world case study, and one open-source CPS case study from the following four perspectives: (1) Completeness and Coverage of the profiles and Model Libraries in terms of concepts defined in their underlying uncertainty conceptual model for CPSs, i.e., U-Model and MARTE, (2) Effort required to model uncertainty with UncerTum, and (3) Correctness of the developed test ready models, which was assessed via model execution. Based on the evaluation, we can conclude that we were successful in modeling all the uncertainties identified in the four case studies, which gives us an indication that UncerTum is sufficiently complete. In terms of modeling effort, we concluded that on average UncerTum requires 18.5% more time to apply stereotypes from UUP on test ready models.

A model of the information-seeking process of computer scientists is proposed.The model derives from two qualitative studies with computer scientists.The model is described textually and is visually illustrated using UML.The model contains the main concepts and relationships intervening in the process. The information-seeking process carried out by researchers is complex and full of different variables. We have represented this complexity for computer science researchers in the form of a conceptual model. The model is presented in a visual form using the UML modeling language, since it allows conveying all the complexity present in such a process with greater clarity. It has been obtained after carrying out two qualitative studies a focus group and semi-structured interviews with computer science researchers. The proposed overall model is composed of 4 sub-models: of the documents used in the process, of the tasks undertaken, of the user, and of the information-seeking process context. The conceptual model proposed can serve for the purpose of better understanding the information-seeking process, for example for librarians or for software designers wanting to provide a support to such task. It can also be useful as a framework to characterize different software solutions aimed to information-seeking in research activities, and to compare them.

One of the ways to specify dynamic behavior in UML is to model interactions between objects with sequence diagrams, and model the behavior of each object with state machines. In this context, the problem of ensuring consistency between the sequence diagrams and state machines may arise. To verify consistency, the authors propose an approach based on compositions of Büchi automata which allow us to capture the evolution of each object among the lifeline. This paper focuses on UML modeling and verification methods and bridges the gap between theoretical studies on formal semantics and practical studies to implement languages through model transformations. The transformations include basic interactions, state invariants, strict and weak sequencing, and alternative interaction fragments. Ultimately, the results of the transformations are integrated into the Spin model checker as a never claim property. The authors use the Automatic Gate Controller Railway (AGCR) as an example to illustrate their approach.

Software usage model can be used as a guide when generate reliability test cases and it helps to evaluate the reliability of the software. Recent researches of deriving Markov Chain usage model from UML Model are mostly based on the UML sequence diagram and UML component diagram. But there are some problems with the existing methods: for some large software systems, there are many kinds of users who use the software in different ways, while a general usage model is not targeted and not suitable for all users. For this reason,this paper puts forward a new method to construct user-based software usage model. The method constructs usage model according to the UML activity diagram and UML use-case diagram, the model constructed by this method is user-based: the model describes, for every kind of users, the specific interacting process between the user and the system. What’s more, the model can be used to guide test cases generation.

This research mainly is focused on automation of Unified Modeling Language (UML) diagrams from the analyzed requirement text using Natural Language Processing (NLP). The looks and styles of software engineering have been completely changed in the recent times. Presently, software engineering follows the rules of Object Oriented design patterns. All phases of software engineering are deviating from the conventions and new paradigms are more popular these days. Same is the case with Software analysis process which uses Unified Modeling Language to map and model the user requirements. Analysis is the key process of building modern information system applications and base for the robust and vigorous software application’s design and development. Nowadays everybody needs a quick and reliable service. It was necessary to have some sort of quick, accurate and intelligent software for generating UML based documentations to save time and budget of both the user and system analyst

1 SOA MODELINGAccording to [1] the Service Oriented Architecture (SOA) concept is based on the principle of developing reusable business service and building applications instead of building monolithic applications in silos.SOA has the potential to bridge the gap between business and technology, improve reuse of existing applications and interoperability with new ones. Some authors [2] consider that software services are the building blocks for SOA, and they can be composed to provide a more coarse grained functionality and to automate business processes.A modeling language is an artificial language that can be used to define system, information in the structure defined by the rules of the system. Rules are used to interpret the association of components in the system. There are two types of modeling languages - Graphical Modeling: it used a diagrammatic approach to represent the system. There are symbols and lines that connect the symbols which is used to display the relationship between the systems. Notations are used to define the constraints in the system.- Textual Modeling: it uses the keywords or special characters with parameters to represent certain information in natural language which can be used by computers for processing [3]. Expressions are used to link the relationship among the text.Service Oriented Modeling (SOM) is the first step to model services of SOA. According to the specialists [3], the approach for modeling SOA with the viewpoint from services is required. Various methods for serviceoriented modeling have been proposed to apply SOA in industrial and business environments by many researchers [4]. They can be seen in Table 1 below:Starting from this table we decided, based on the reviewed literature, to pay attention only to specific modeling approaches, which are more common and used today.1.1.SOAMLUML is used for general purpose modeling of SOA and create visual models. The services were modeled as objects and general purpose of the design was made by it. But when the degree of complexity increased it was not that efficient. This is how SoaML (Service oriented architecture Modeling Language) emerged: as a UML profile and meta-model for the modeling and design of services within a service-oriented architecture [3].SoaML was created to support the following features:* Indentifying services and their requirements.* Defining service consumers and providers as well as the service itself.* Specifying message pattern and protocols for the services.* Different Service classification schemes.* Integration and extension with OMG meta-models and BPMN.The Object Management Group (OMG) proposed SoaML in 2009 for representing SOA artifacts using Unified Modeling Language (UML) as a core-modeling standard. Moreover, a meta-model and a UML profile are provided in SoaML for the specification and design of service to SOA (meta-model for modeling the requirement for a service and UML for specifying services) [4].1.2.SOMFService Oriented Modeling Framework (SOMF) is a model driven engineering methodology which focuses on business process, and the IT is part of the lifecycle. It can also be used at standalone designing platform with other modeling languages such as UML, BPMN, or SoaML to enrich the language syntax. It can also set software development priorities during life cycle stages, and enhance the overall implementation view of the system [3].The SOMF offers specialized modeling notation to help model, analysis and identification services that is proposed by Bell. It provides a formal method of service identification at different levels of abstraction including meta-model concept and specific notation [4].1.3.SOMASOMA is a modeling technique for developing and building SOA-based systems proposed by IBM in 2004. SOMA activities focuses include: service identification (discovering candidate service and interaction between them), service specification (making decision for exposing services), and service realization (capturing service realization). …

Real-time embedded systems (RTESs) operating in safety-critical domains have to satisfy strict performance requirements in terms of task deadlines, response time, and CPU usage. Two of the main factors affecting the satisfaction of these requirements are the configuration parameters regulating how the system interacts with hardware devices, and the external events triggering the system tasks. In particular, it is necessary to carefully tune the parameters in order to ensure a satisfactory trade-off between responsiveness and usage of computational resources, and also to stress test the system with worst-case inputs likely to violate the requirements. Performance tuning and stress testing are usually manual, time-consuming, and error-prone processes, because the system parameters and input values range in a large domain, and their impact over performance is hard to predict without executing the system. In this paper, we provide an approach, based on UML/MARTE, to support the generation of system configurations predicted to achieve a satisfactory trade-off between response time and CPU usage, and stress test cases that push the system tasks to violate their deadlines. First, we devise a conceptual model that specifies the abstractions required for analyzing task deadlines, response time, and CPU usage, and provide a mapping between these abstractions and UML/MARTE. Then, we prune the UML/MARTE metamodel to only contain a purpose-specific subset of entities needed to support performance tuning and stress testing. The pruned version is a supertype of UML/MARTE, which ensures that all instances of the pruned metamodel are also instances of UML/MARTE. Finally, we cast the generation of configurations and stress test cases as two constrained optimization problems (COPs) over our conceptual model. The input data for these COPs in automatically generated via a model-to-text (M2T) transformation from models specified in the pruned UML/MARTE metamodel to the Optimization Programming Language. We validate our approach in a safety-critical RTES from the maritime and energy domain, showing that (1) our conceptual model can be applied in an industrial setting with reasonable effort, and (2) the optimization problems effectively identify configurations predicted to minimize response time and CPU usage, and stress test cases that maximize deadline misses. Based on our experience, we highlight challenges and potential issues to be aware of when using UML/MARTE to support performance tuning and stress testing in an industrial context.

OPC Unified Architecture (UA) is a platform-independent standard for message-based communication between clients and servers on various types of network to facilitate information exchange. OPC UA has been adopted in various domains such as power grids, building automation, and smart devices to support interoperability of involved systems. These domains also use Unified Modeling Language (UML) as the standard notation for data modeling or system modeling. Use of two different notations in the same domain causes compatibility issues. To address this, we present an approach for transforming OPC UA to UML to improve their compatibility and integration. In the approach, we rigorously analyze the semantics of OPC UA elements and establish a mapping between OPC UA elements and UML elements based on the analysis. Based on the mapping, we define transformation algorithms using Query/View/Transformation (QVT) which is a standard model transformation language by OMG. We demonstrate the approach using case examples in the power grid, building automation, and smart device domains. HighlightsOPC UA and UML are analyzed for correspondence.Mappings are established between OPC UA elements and UML elements.Based on the mappings, transformation rules are defined in QVT.Three case examples are presented demonstrating transformation.

Context: UML diagrams are the de facto standard for analysing, communicating and designing software systems, as well as automated code generation. However there is a certain degree of difficulty in understanding a system represented by means of UML diagrams. Object: Our previous research demonstrates a significant improvement in understanding the structural aspects of a system represented as a UML class diagram when using a feedback-inclusive prototype of a model. This paper extends our previous work with an empirical validation study for the effectiveness of the feedback-inclusive rapid prototyping (FIRP) method, on the comprehension of system dynamics represented as multiple interacting UML statecharts. Because models often combine structural and behavioural views that are highly intertwined, we additionally evaluate the effectiveness of the proposed method with respect to comprehension of the between-view consistency. Method: The FIRP environment was built following the principles of Design Science Research in Information Systems. This study targets the empirical validation of the effectiveness of the proposed technique using an experimental study method. Two experiments were conducted with the participation of 65 final-year master students in the context of different modelling courses from different study programs at KU Leuven using a two-group factorial experimental design. The effectiveness of the FIRP method was measured by comparing students’ performance between the cycles with and without the use of the method, using the understandability (comprehension test results) as the dependent variable and the use of FIRP as the independent variable. Effects from unknown variables were neutralized by means of randomized group compositions. The effectiveness of FIRP was additionally assessed with respect to personal characteristics (age, gender, self-efficacy) and user acceptance (perceived ease of use, perceived utility, preference, satisfaction). Results: The findings reveal a significant positive impact of the use of the prototyping technique on students’ comprehension of system dynamics represented as multiple interacting statecharts. Conclusions: The findings provide empirical support for the advantage of the use of FIRP over manual inspection of interacting statecharts. The findings also suggest that the method is suitable for training system's analysis and modelling skills when UML statecharts are involved. publisher: Elsevier articletitle: Assessing the influence of feedback-inclusive rapid prototyping on understanding the semantics of parallel UML statecharts by novice modellers journaltitle: Information and Software Technology articlelink: http://dx.doi.org/10.1016/j.infsof.2016.11.001 content_type: article copyright: © 2016 Elsevier B.V. All rights reserved. ispartof: Information and Software Technology vol:82 pages:159-172 status: published

In this paper, we present a unified modelling language (UML) framework to model timed Web services with distributed resources. We provide a graphical model of timed Web services that integrates the publish/subscribe paradigm in the context of distributed resources, with the goal that users have a formal framework to design this kind of systems. A formalization is then provided by using UML sequence diagrams with Combined Fragments (CFs) to represent the interactions between the roles involved and Web Services Resource Framework as a standard for the management of distributed resources. The formalization is based on a two-level process algebra. At the top level we have the CF description, and at the bottom the interactions inside them. An operational semantics is then defined for this model, and two case studies are presented to illustrate the applicability of this formalism.

We propose a multi-scale methodology for complex software systems using the model transformation techniques. The methodol- ogy provides a correct by design approach for the description of multi-scale architectures. It is founded on a rule-oriented iterative modeling process ensuring transition from a coarse-grained description to a fine-grained description. The rules manage the re- finement between scales and are applied with respect to the system constraints. Multi-scale architectures are modeled graphically using UML notations. The design process supports model transformation and validation of UML models with the OCL constraints defined on UML models. We illustrate our approach with a case study dedicated to the smart cities.

This paper describes the formal representation approach used in the scope of a large-scale research project aiming at the holistic, completely digital representation and automated computability of the product life-cycle (PLC). The distinctive approach consists in the novel methodology of visual, graph-based design languages expressed in UML (Unified Modeling Language), which allow both the creation of new engineering models as well as the reuse of pre-existing engineering models and know-how. The tool-independent representation of the engineering design knowledge via the abstraction level in UML was originally developed by one of the project partners in prior work. The paper explains the methodology, modeling method and computational means as well as their integration along the product life-cycle including requirements, design, simulation as well as cost and energy analysis. The explanation is illustrated through a design language implementation for the automated design of novel light-weight multicopters.

[EN] Today, robotics manipulator is a crucial discipline in modern production industrial facilities and in a near future; it will also be decisive in the human quotidian society. Consequently, currently there is a growing demand of applications with arm-based robots with requirements such as: reutilization, flexibility and adaptability. Unfortunately, there is a lack of standardization of hardware and software platforms, so the satisfaction of these requirements is too difficult. In this sense, there is a necessity of a methodology that guides along application design, implementation as well as the execution of the software systems. This work, explores the advantages of Model Driven Engineering (MDE) for the design and development of applications performed by manipulator robots. In fact, an UML based approach is proposed that supports the design of robotic tasks and an automatic code generation for the most spread robotic communication Middlewares has been also developed. More specifically, the target code generation for OROCOS and ROS communication Middlewares has been detailed. Finally, two case studies have been presented one for industrial field and the other for service sector. The former runs on OROCOS and the latter on ROS., [ES] Hoy en día, los robots manipuladores están presentes en todas las instalaciones de producción moderna industriales. Por ello, a la robótica manipuladora se la considera una disciplina decisiva en el sector industrial. Además, en un futuro no muy lejano los robots manipuladores pasarán a ser también esenciales en la vida cotidiana de la sociedad. Así, existe una demanda creciente de aplicaciones con robots manipuladores con requisitos software como son la reutilización, flexibilidad y adaptabilidad. Lamentablemente, en la actualidad hay una falta de estandarización de plataformas hardware y software, por lo que es extremadamente complicado satisfacer estos requisitos. Así, se contempla, por lo tanto, una necesidad de definir una metodología que proporcione unas pautas y guíe en el diseño, implementación y en la ejecución de sistemas software para este tipo de aplicaciones. Este trabajo explora las ventajas proporcionadas por la Ingeniería Dirigida por Modelos (MDE- Model Driven Engineering) en el diseño y desarrollo de tareas realizadas por robots manipuladores. En concreto se propone una aproximación basada en un sub-conjunto de diagramas UML (diagrama de componentes y diagrama de despliegue) para el diseño de este tipo de aplicaciones. Además, se identifican y definen los pasos a realizar para la generación automática de código que se ejecutará sobre los middlewares (MW) de comunicación más utilizados en esta disciplina. Para ello, se hará uso de las técnicas Model-To-Model y Model-To-Text nuevamente de MDE. Este trabajo, detalla la generación del código para OROCOS (el MW basado en componentes más extendido) y ROS. Finalmente, se presentan dos casos de estudio, el primero de ellos consiste en una aplicación industrial para el ensamblado de faro de vehículos que se ejecuta sobre OROCOS. El segundo caso de estudio es una aplicación de robótica de servicios en la que un robot manipulador antropomórfico realiza la tarea de seguimiento de un objeto en movimiento. Este segundo caso de estudio se ejecuta sobre ROS., Los autores quieren agradecer la subvención parcial de este trabajo a través de los proyectos DPI2011-27284, TEP2009-5363 y AGR-6429.

The layered software architecture is the model commonly adopted for the development of information systems since it favors the modularity and the scalability of the systems. On the other hand, the emergence of model engineering aims to raise the level of abstraction to allow developers to reason on models, and less in code. The research question is to combine the two approaches to facilitate the work of developers. The proposal resulting from this study is based on a set of concepts defined using the UML profiles. These concepts include services, business components, and data persistence. Then the Kruchten model is adopted to represent the development cycle according to several views, each view being represented by UML diagrams derived from the previously defined profiles. Finally, rules are available for checking inter-view consistency, from refinement to code generation. The result is a step towards the definition of a domain specific ADL and a development process as much as it includes the expected characteristics of such a language, namely: the fundamental concepts, the support tools and the multiview development.

State-space modeling is useful for prognostics of safety-critical systems. However, building such a model that embeds all the system requirements is a challenge. Furthermore, it requires expertise and hence isn't easily understood by all the stakeholders. UML can handle these challenges. A proposed approach converts a UML model into a state-space model. Researchers validated this approach on 13 safety-critical systems for nuclear power plants, focusing on the emergency core cooling system.

Software metrics have become an essential part of software development because of their importance in estimating cost, effort, and time during the development phase. Many metrics have been proposed to assess different software quality attributes, including stability. A number of software stability metrics have been proposed at the class, architecture, and system levels. However, these metrics typically target the source code. This paper proposes a software stability metrics suite at the model level for three UML diagrams: class, use case, and sequence. These three diagrams represent the most common diagrams in the three UML views: structural, functional, and behavioral. We introduce a client–master assessment approach to avoid measurement duplication. We also theoretically and empirically validate the proposed metrics suite. We also provide examples to demonstrate the use of the proposed metrics and their application as indicators of software stability.

Providing a complete life cycle of UML consistency management process.Presenting a thematic taxonomy of existing state-of-the-art UML consistency management activities based on a set of parameters extracted from the literature.Analytically comparing current state-of-the-art UML consistency management approaches including their commonalities and differences.Outlining a number of potential research issues in this field of study. Unified Modeling Language (UML) has become the de-facto standard to design todays large-size object-oriented systems. However, focusing on multiple UML diagrams is a main cause of breaching the consistency problem, which ultimately reduces the overall software models quality. Consistency management techniques are widely used to ensure the model consistency by correct model-to-model and model-to-code transformation. Consistency management becomes a promising area of research especially for model-driven architecture. In this paper, we extensively review UML consistency management techniques. The proposed techniques have been classified based on the parameters identified from the research literature. Moreover, we performed a qualitative comparison of consistency management techniques in order to identify current research trends, challenges and research gaps in this field of study. Based on the results, we concluded that researchers have not provided more attention on exploring inter-model and semantic consistency problems. Furthermore, state-of-the-art consistency management techniques mostly focus only on three UML diagrams (i.e., class, sequence and state chart) and the remaining UML diagrams have been overlooked. Consequently, due to this incomplete body of knowledge, researchers are unable to take full advantage of overlooked UML diagrams, which may be otherwise useful to handle the consistency management challenge in an efficient manner.

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.

International audience; The ever-increasing design complexity of embedded systems is constantly pressing the demand for more abstract design levels and possible methods for automatic verification and synthesis. Transforming a text-based user requirements document into semantically sound models is always difficult and error-prone as mostly these requirements are vague and improperly documented. This paper presents a framework to specify textual requirements graphically in standard modeling formalisms like uml and marte in the form of temporal and logical patterns. The underlying formal semantics of these graphical models allow to eliminate ambiguity in specifications and automatic design verification at different abstraction levels using these patterns. The semantics of these operators/patterns are presented formally as state automatons and a comparison is made to the existing ccsl relational operators. To reap the benefits of mde, a software plugin TemLoPAC is presented as part of the framework to transform the graphical patterns into ccsl and Verilog-based observers.

Unified Modeling Language (UML) is a modeling language widely used in the field of software engineering. It is a standard to visualize the design of a system structurally and behaviorally. UML tools are software tools used to create UML diagrams, perform model and diagram interchange, model transformation, code generation, reverse engineering and round-trip engineering, There are many free UML tools available to be downloaded in the internet. This paper serves as a survey for ten UML tools and gives recommendation to users on which UML tools to be used in different situations. The main contribution of the paper is to compare the ten up to date UML tools in several aspects.

ContextBusiness process modeling is an activity that includes several different roles, e.g. business analysts, technical analysts and software developers. The resulting process diagrams can be either simple or complex. Nonetheless, they must be understandable to everyone, even those without the necessary knowledge of process modeling notations. ObjectiveThe goal of our research was to evaluate intuitive understandability of diagrams, modeled in different process modeling notations, with regard to diagram complexity. MethodAn empirical research was conducted, including 103 students with the goal to empirically validate the intuitiveness of the diagrams, modeled in most commonly used process modeling notations, i.e. Unified Modeling Language 2.0 Activity Diagram (UML AD), Business Process Model and Notation (BPMN) and Event Driven Process Chain (EPC). Results were analyzed using the Kruskal-Wallis test, together with the Mann-Whitney post hoc tests with Bonferroni correction. ResultsIn the case of processes with lesser complexity, participants using BPMN diagrams were significantly outperformed by those using either EPC or UML AD ones. However, when complexity of processes was higher, participants using EPC diagrams performed significantly worse than those using the UML AD and BPMN counterparts. Moreover, participants that used UML AD diagrams were not significantly outperformed by users of diagrams in other process modeling notations, regardless of their complexity. Thus, UML AD was recognized as being the most versatile notation. ConclusionSince the existing studies do not offer a holistic overview of the intuitive understandability of process diagrams with different complexity, modeled in different process modeling notations, our research can help decide which notation to use when representing processes that have to be understandable by all stakeholders. Lower complexity BPMN diagrams were outperformed by EPC or UML AD ones.Higher complexity EPC diagrams were outperformed by BPMN or UML AD ones.UML AD was recognized as being the most versatile notation.Our study can help decide which notation to use when representing processes.

Solution for modelling and generation of explicit links in UML composite structures.Five connection patterns for condensed modelling of complex topologies.UML profile with stereotypes and validity constraints for connection patterns.Semantic rules for generating explicit links based on connection patterns.Generation algorithm and proof-of-concept implementing the generation algorithm. Model-driven engineering can help in mitigating ever-growing complexity of modern software systems. In this sense, the Unified Modelling Language (UML) has gained a thick share in the market of modelling languages adopted in industry. Nevertheless, the generality of UML can make it hard to build complete code generators, simulators, model-based analysis or testing tools without setting variability in the semantics of the language. To tailor semantics variability the notion of semantic variation point has been introduced in UML 2.0.Our research focuses on the semantic variation point that leaves the rules for matching multiplicities of connected instances of components and ports undecided in UML composite structures. In order to allow model analysability, simulation and code generation, this semantics needs to be set. At the same time, leaving the burden of this task to the developers is often overwhelming for complex systems.In this paper we provide a solution for supporting modelling and automatic calculation and generation of explicit interconnections in complex UML composite structures. This is achieved by (i) defining a set of connection patterns, in terms of a UML profile, and related semantic rules for driving the calculation, (ii) providing a generation algorithm to calculate the explicit interconnections.

Always before we start creating or accessing a particular system, it is more than necessary to have a clearer picture of how to create, respectively, how to approach a certain system, in this case of a e-business system. It is much easier as for systems makers, as well as for ordinary users when they have before them a model of how to be accessed in such a system, because such a thing will orient users much easier to purchase products online through various systems on the one hand, but on the other hand it would help makers of systems create much easier such systems when they have already before them the right design. Modeling systems may be done in different ways, depending on the context of its research, but we in this paper we will use UML diagrams for modeling online system where we will make a comparison between UML diagrams and we will present each type of UML diagram in terms of customer access in online systems. Also using predictive techniques as CPM and PERT techniques in the paper we will present the main activities required for access to an online system by different users, and their graphic presentation and critical path finding, which shows the best way to approach such a system. There shall not fail and the description of business models and the introduction of some e-business models that are commonly used in practice in the days of today.

Using IoT protocols in the development process of manufacturing systems.An approach to automate the integration of mechatronic components in the IoT environment.An extension of UML to support the transformation of traditional OO interfaces of manufacturing components to REST-like ones.UML4IoT: A UML profile for the automatic generation of the LWM2M layer.Performance analysis and evaluation of a LWM2M based IoT solution for manufacturing systems. Internet of Things (IoT) is changing the world. The manufacturing industry has already identified that the IoT brings great opportunities to retain its leading position in economy and society. However, the adoption of the IoT changes the development process of the manufacturing system and raises many challenges. In this paper, the modern manufacturing system is considered as a composition of cyber-physical, cyber and human components, and IoT is used as a glue for their integration as far as their cyber interfaces are concerned. An approach based on a UML profile for the IoT is presented to fully automate the generation process of the IoT-compliant layer that is required for the cyber-physical component to be effectively integrated into the modern IoT manufacturing environment. The approach can also be applied at the source code level specification of the component in case that a UML design specification is not available. A prototype implementation of the myLiqueur production laboratory system is used to demonstrate the applicability and effectiveness of the UML4IoT approach.

Mobile UML (M-UML) has been proposed as an extension of UML to model mobile agent-based software systems. As UML, M-UML suffers from lack of formal semantics due to its semi-formal nature which penalize the verification of correct behavior of the modeled systems. This paper provides a graphical yet formal approach for the modeling, simulation and verification of mobile statechart diagrams using graph transformations in the AToM3 tool. The authors have firstly proposed meta-models for mobile statechart diagram and flowgraph. Then, a twofold graph grammar is developed for the automatic mapping of mo-bile statechart diagrams into flowgraphs and in the same time generates the cor-responding p-calculus specification. This graph grammar enables either execu-tion through simulation by flowgraphs or verification through model checking, using existing tools (e.g. the Mobility Workbench, MWB). An illustrative example of the authors' approach is provided.

Duplication in software systems is an important issue in software quality assurance. While many methods for software clone detection in source code and structural models have been described in the literature, little has been done on similarity in the dynamic behaviour of interactive systems. In this paper, we present an approach to identifying near-miss interaction clones in reverse-engineered UML sequence diagrams. Our goal is to identify patterns of interaction (“conversations”) that can be used to characterize and abstract the run-time behaviour of web applications and other interactive systems. In order to leverage existing robust near-miss code clone technology, our approach is text-based, working on the level of XMI, the standard interchange serialization for UML. Clone detection in UML behavioural models, such as sequence diagrams, presents a number of challenges—first, it is not clear how to break a continuous stream of interaction between lifelines (representing the objects or actors in the system) into meaningful conversational units. Second, unlike programming languages, the XMI text representation for UML is highly non-local, using attributes to reference-related elements in the model file remotely. In this work, we use a set of contextualizing source transformations on the XMI text representation to localize related elements, exposing the hidden hierarchical structure of the model and allowing us to granularize behavioural interactions into conversational units. Then we adapt NICAD, a robust near-miss code clone detection tool, to help us identify conversational clones in reverse-engineered behavioural models. These conversational clones are then analysed to find worrisome interactions that may indicate security access violations.

Model transformations constitute the key technology for model-driven software development, a software engineering discipline which became more and more important during the last decade. While tool support for unidirectional batch transformations is rather mature, bidirectional and incremental transformations are only weakly investigated. Nevertheless, several usage scenarios demand for incremental and bidirectional transformations, like round-trip engineering between UML class models and Java source code. This paper presents a bidirectional transformation between UML class models and a Java model which is obtained from Java source code. The transformation is written in QVT Relations, a declarative model transformation language provided by the OMG. While the case study demonstrates that it is possible to specify bidirectional transformations between heterogeneous metamodels in a single relational specification, it also reveals some inherent limitations of the language and the corresponding tool support.

The Unified Modeling Language (UML), with its 14 different diagram types, is the de-facto standard modeling language for object-oriented software modeling and documentation. Since the various UML diagrams describe different views of one, and only one, software system under development, they strongly depend on each other in many ways. In other words, the UML diagrams describing a software system must be consistent. Inconsistencies among these diagrams may be a source of faults during software development and analysis. It is therefore paramount that these inconsistencies be detected, analyzed and -- hopefully -- fixed. The goal of this workshop was to gather input and feedbacks on UML consistency rules from the community. This workshop provided an opportunity for researchers who have been working in the area of UML consistency to interact with each other at a highly interactive venue, improve the body of knowledge on UML consistency rules and discuss ideas for further research in this area. This report summarizes details of the workshop and the results obtained that day.

Activities of specification, analysis and design of real-time systems (RTS) are highly dependent on an effective understanding of the application domain and on the thorough representation of their basic requirements. Model-based approaches using modeling languages such as UML are often applied to contribute to handle complexity of RTS development. However, UML alone does not completely represent important features associated with these systems, such as relationship with hardware elements and an effective representation of timing constraints. This article explores the combined use of UML and its profiles SysML and MARTE for modeling hardware and software requirements of RTS, with application to a case of controlling urban road traffic. The SysML profile alone does not present the representation of temporal, behavioral and performance requirements. The MARTE profile provides key resources to specify non-functional requirements for RTS, in addition to a clear description of the various relevant aspects of requirements definition of RTS, as for instance, temporal aspects and constraints. The main objective is to present the combined application of SysML with MARTE stereotypes, which enables the specification of different features of individual software requirements. Thus, in addition to the factors mentioned above, we can say that the proposed approach has an important role to specify RTS at different levels of detail and levels of abstraction.

Model Driven Engineering (MDE) aims to expedite the software development process by providing support for transforming models to running systems. Many modeling tools provide forward engineering features, which automatically translate a model into a skeletal program that developers must complete. Inconsistencies between a design model and its implementation, however, can arise, particularly when a final implementation is developed dependently on the code from which it was generated. Manually checking that an implementation conforms to its model is a daunting task. Thus, an MDE tool that developers can use to check that implementations conform to their models can significantly improve a developer's productivity. This paper presents a model-based approach for testing whether or not an implementation satisfies the constraints imposed by its design model. Our model-based testing approach aims to efficiently reduce the test input space while supporting branch coverage criteria. To evaluate the approach's ability to uncover inconsistencies, we developed a prototypical tool and applied it to the Eclipse UML2 projects. We were able to uncover inconsistencies between the models and their implementations using the tool.

This paper discusses an approach to generate VHDL descriptions from high-level specifications, namely UML/MARTE models that include aspect-oriented semantics. Standard UML diagrams describe the handling of functional requirements, whereas crosscutting concerns associated with the non-functional requirements are handled by aspects. UML-to-VHDL transformation is performed automatically by a script-based code generation tool named GenERTiCA. For that, mapping rules scripts define how to generate VHDL constructs from model elements, including the implementation of aspects adaptations. The generated VHDL description does not require any manual modification, in order to be fully synthesized onto a FPGA device. Some case studies have been performed to evaluate the proposed approach, including examples of real systems implemented as a FPGA-based embedded system. Obtained results show an improvement in system design in terms of an increase in system performance as well as a better utilization of FPGA reconfigurable resources. Such positive results are related to a better modularization of components achieved by using the proposed high-level approach. These case studies demonstrate the practicability of full translation of platform-independent specifications into VHDL descriptions.