Search

The research field of Intelligent Service Robots, which has become more and more popular over the last years, covers a wide range of applications from climbing machines for cleaning large storefronts to robotic assistance for disabled or elderly people. When developing service robot software, it is a challenging problem to design the robot architecture by carefully considering user needs and requirements, implement robot application components based on the architecture, and integrate these components in a systematic and comprehensive way for maintainability and reusability. Furthermore, it becomes more difficult to communicate among development teams and with others when many engineers from different teams participate in developing the service robot. To solve these problems, we applied the COMET design method, which uses the industry-standard UML notation, to developing the software of an intelligent service robot for the elderly, called T-Rot, under development at Center for Intelligent Robotics (CIR). In this paper, we discuss our experiences with the project in which we successfully addressed these problems and developed the autonomous navigation system of the robot with the COMET/UML method.

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.

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) activity diagrams can model the flow of stateful business objects among activities, implicitly specifying the life cycles of those objects. The actual object life cycles are typically expressed in UML state machines. The implicit life cycles in UML activity diagrams need to be discovered in order to derive the actual object life cycles or to check the consistency with an existing life cycle. This paper presents an automated approach for synthesizing a UML state machine modeling the life cycle of an object that occurs in different states in a UML activity diagram. The generated state machines can contain parallelism, loops, and cross-synchronization. The approach makes life cycles that have been modeled implicitly in activity diagrams explicit. The synthesis approach has been implemented using a graph transformation tool and has been applied in several case studies.

Systems which manipulate important volumes of data need to be managed with Real-Time (RT) databases. These systems are subject to several temporal constraints related to data and to transactions. Thus, their design remains a complex task. To remedy this complexity, it is necessary to integrate design methods to support data and transactions temporal constraints. Among the design methods, those based on patterns have been widely used in several fields. However, despite their advantages, these patterns present some shortcomings. Indeed, they do not manage efficiently the patterns variability and they do not specify the pattern elements when they are instantiated. To overcome these limitations, we propose, in this paper, a new UML profile to (i) express the variability in patterns and (ii) to identify the pattern elements in its instance. Besides, in order to well-capture the knowledge of the domain, the proposed profile extends UML with concepts related to real-time databases and integrates OCL (Object Constraint Language) to enforce the variation points consistency. Finally, we give an example of a RT pattern that illustrates these UML extensions, where we implement the proposed profile and we validate the pattern diagrams using the constraints we have proposed. Keywords: UML profile, Design patterns, Object Constraint Language, Real-time database

This study is intended to generate an application tools (CASE tools) that allows a software developer to create a modeling system design using Unified Modeling Language (UML), especially in making use case, activity or class diagrams more quickly and easily. The tools developed will also facilitate developers in doing UML modeling by accessing the network through a web-based internet application. With the web-based applications, the users require only a browser and an internet connection to use this application. This application also helps developers to understand of how to make UML diagrams correctly and good. In this research traditional methods Scrum model is used. Scrum method is Agile methods that is a process to cultivate software easily and can be developed in accordance with the development of information technology. Scrum is using empirical methods or in other words every stage in it involves inspection and adaptation.

Part 1: Regular Papers; International audience; Various frameworks are available for modeling an organizational setting. Their constituting models nevertheless mostly choose a particular decision level to represent perceived reality meaning that some introduce coarse-grained (i.e. abstract) elements and some others fine-grained (i.e. detailed) ones. Sometimes, in a same model, elements of various levels of granularity can be mixed like for example in the i* strategic rationale model. The main drawback is that this leads to hard to read and complex models, not ideal for easy and quick understanding of the software problem. Also, within the industry, poor unification in the use of models does exist. The various Unified Modeling Language (UML) models and the Business Process Model and Notation (BPMN) are nevertheless rather popular. In this paper, we study the use of the Business Use Case Model – an extension of the classical UML use-case model defined in the Rational Unified Process (RUP) – and the BPMN Business Process Model (BPM) as a unified framework for knowledge representation at strategic, tactical and operational levels. By default, the RUP advises to use UML activity diagrams for operational-level knowledge representation. Their main drawback is that they have been engineered to model software behavior with respect to the user and not business process modeling at large. The BPMN BPM thus offers more perspectives for pure business process modeling; that is why it mostly used in the industry for this purpose. The use of these models in a unified way is ensured by traceability at the various levels of modeling.

International audience; Validation of mobile applications needs taking account of context (such network topology) and interactions between mobile nodes. Scenario-based approaches are well-suited to describe the behavior and interactions to observe in distributed systems. The difficulty to control accurately the execution context of such applications has led us to use passive testing. This paper presents a toolset which supports specification and verification of scenarios. A UML-based formal language, called TERMOS, has been implemented for specifying scenarios in mobile computing systems. These scenarios capture the key properties which are automatically checked on the traces, considering both the spatial configuration of nodes and their communication. We give an overview of the language design choices, its semantics and the implementation of the tool chain. The approach is demonstrated on a case study.

International audience; IDF is an Incremental Development Framework which supports the development and the verification of UML models for concurrent and reactive systems. IDF offers refinement and extension techniques the goal of which is to check the preservation of liveness properties during the model developments. Here, we improve the framework in order to analyze models from a safety point of view. Some techniques such as refinement maintain safety properties, however, extension does not maintain such properties. For this purpose, we associate IDF with the experienced tools of safety analysis based on the BIP language by translating UML models into BIP. We demonstrate on a basic example the comple-mentarity of liveness and safety analyses.

We define a method for simplifying UML schemas to improve efficiency of reasoning.The method deals with schemas with general 1st-order constraints (i.e. most OCL).The method can be incorporated in any UML/OCL reasoning tool.Experiments show time improvements from x2 to x370 in different tools/schemas. Ensuring the correctness of a conceptual schema is an essential task in order to avoid the propagation of errors during software development. The kind of reasoning required to perform such task is known to be exponential for UML class diagrams alone and even harder when considering OCL constraints. Motivated by this issue, we propose an innovative method aimed at removing constraints and other UML elements of the schema to obtain a simplified one that preserve the same reasoning outcomes. In this way, we can reason about the correctness of the initial artifact by reasoning on a simplified version of it. Thus, the efficiency of the reasoning process is significantly improved. In addition, since our method is independent from the reasoning engine used, any reasoning method may benefit from it.

Conference of 2017 IEEE International Conference on Software Architecture, ICSA 2017 ; Conference Date: 3 April 2017 Through 7 April 2017; Conference Code:127837; International audience; UML state machines and composite structure models are efficient to design the behavior and structure of architectures. In Model Driven Engineering (MDE), code can be automatically generated from the models. Nevertheless, current UML tools only produce skeleton code which is then fine-tuned by programmers. The modifications in code, which may violate the architecture correctness, must be synchronized with the model to make architecture and code consistent. However, current approaches cannot handle the synchronization when there is a significant abstraction gap between architecture and code. This paper proposes to ease synchronization between model and code, through a bidirectional mapping between code and architecture specified by UML composite structure and state machine. The proposed mapping is a means for a synchronization mechanism proposed in our previous work, which allows concurrent modifications made in model and code, and keeps them synchronized. We propose an evaluation plan for the approach and expose preliminary experimental results.

International audience; In the paper process of moving from software requirements to Unified Modeling Language (UML) diagrams has been studied. It shows the importance of this process and discusses many comparative studies in the field. A questionnaire related to the study was distributed worldwide to many research groups, academia, and industry to know the current status of using requirement management tools, knowledge of using UML in software development, frequently used UML diagrams, and the methodology used to generate UML diagrams from requirements. The paper emphasises that there is a need to do some important research in the area of requirements Natural Language processing (NLP) to obtain UML diagrams, and generalize process of using automatic or semi-automatic methodology to generate UML diagrams from requirements.

Objective : The main objective of our study is to assess whether the use of UML (Unified Modeling Language) object diagrams improves comprehensibility of software design when this kind of diagrams is added to UML class diagrams. Method : We have conducted a family of four controlled experiments. We involved groups of bachelor and master students. Results : Results suggest that the use of object diagrams does not always introduce significant benefits in terms of design comprehensibility. We found that benefits strongly depend on the experience of participants and their familiarity with UML. More experienced participants achieved better design comprehensibility when provided with both class and object diagrams, while less experienced seemed to be damaged when using class and object diagrams together. Results also showed the absence of substantial variations in the time needed to comprehend UML models, with or without object diagrams. Implications : Our results suggest that it is important to be aware and take into account experience and UML familiarity before using object diagrams in software modeling.

One argument in the discussion about the adoption of UML in industry is the supposedly large effort it takes to do modeling. Our study explores how the creation of UML models can be understood to consist of different cognitive activities: (i) designing: thinking about the design (ideation, key-design decision making), (ii) notation expression: expressing a design in a modeling notation and (iii) layouting: the spatial organization of model elements in a diagram. We explain that these different subactivities relate to different short-term and long-term benefits of modeling. In this study we present two controlled experiments with a total of 100 subjects creating models for a small system. In these experiments we focus on software models as represented through UML class diagram. Our results show that at least 56% of the effort spent on creating a class model is actually due to designing. Notation expression is around 41% of the model creation effort and layouting is in the order of 3%. This finding suggests that a significant part of creating models is devoted to design thinking about the problem.

This article presents a novel technique to formally verify models of real-time systems captured through a set of heterogeneous UML diagrams. The technique is based on the following key elements: (i) a subset of Unified Modeling Language (UML) diagrams, called Coretto UML (C-UML), which allows designers to describe the components of the system and their behavior through several kinds of diagrams (e.g., state machine diagrams, sequence diagrams, activity diagrams, interaction overview diagrams), and stereotypes taken from the UML Profile for Modeling and Analysis of Real-Time and Embedded Systems; (ii) a formal semantics of C-UML diagrams, defined through formulae of the metric temporal logic Tempo Reale ImplicitO (TRIO); and (iii) a tool, called Corretto, which implements the aforementioned semantics and allows users to carry out formal verification tasks on modeled systems. We validate the feasibility of our approach through a set of different case studies, taken from both the academic and the industrial domain.

Web applications pervade our life, being crucial for a multitude of economic, social and educational activities. For this reason, their quality has become a top-priority problem. End-to-End testing aims at improving the quality of a web application by exercising it as a whole, and by adopting its requirements specification as a reference for the expected behaviour. In this paper, we outline a novel approach aimed at generating test scripts for web applications from either textual or UML-based requirements specifications. A set of automated transformations are employed to keep textual and UML-based requirements specifications synchronized and, more importantly, to generate End-to-End test scripts from UML artefacts.

In the paper a method of using the Unified Modeling Language for specification of digital systems, especially logic controllers, is presented. The proposed method is based mainly on the UML state machine di- agrams and uses Hierarchical Concurrent Finite State Machines (HCFSMs) as a temporary model. The paper shows a way to transform the UML diagrams, expressed in XML language, to the form that is acceptable by reconfigurable FPGAs (Field Programmable Gate Ar- rays). The UML specification is used to generate an eective program in Hardware Description Languages (HDLs), especially Verilog.

To comprehend an object-oriented software, visualizing object interactions performed as a UML sequence diagram is a promising technique for helping developers. However such UML sequence diagrams are typically too huge to comprehend behavior. In this paper, we propose a novel technique to generate abstracted sequence diagrams based on the information of applied GoF design patterns in a source code. We discuss effectiveness of our approach through a case study applying our implemented tool to an open source software.

Unified Modelling Language (UML) has a graphical notation for 13 different types of diagrams and can be used as a general modelling tool. Well-known examples of diagram types are class diagrams for modelling classes that can be instanced into objects, state machine diagrams for modelling states in systems and activity diagrams for modelling process flows. A literature survey shows that UML has been used to model concepts and methodologies of risk assessment and risk management. One example is the Coras Framework. The international standard CEI IEC 61882 Hazard and operability (HAZOP) studies describes concepts for investigating and detecting possible hazards in systems. In CEI IEC 6882, guide words like ‘More’ and ‘Less’ are applied to system parameters to invoke deviations in the system and assess possible hazards due to the deviation from the design intent. In this paper, we have used UML to model concepts of CEI IEC 61882 Hazards and operability studies. Diagrams of UML were used to show dependencies and relations between parts of the target system and concepts of CEI IEC 61882. Extensions of UML are suggested to better capture and display the concepts of CEI IEC 61882, the results of a HAZOP study and emerging risk. These extensions are referred to as UML for emerging risks (UML-ER).

International audience; Currently, it is well recognized that coupling graphical and formal notations offers several advantages. Indeed, even if a graphical representation permits to design a visual, synthetic and user-friendly view of the system, it may be source of ambiguity and does not permit any formal verification. Formal methods help to remedy these shortcomings by giving a precise semantics to graphical notations such that it becomes possible to verify a large range of properties and even to generate correct implementations. Nevertheless, users cannot take a full advantage of the benefits of such a combination if it is not supported by an automatic tool that liberates them from the tedious translation activity. Following this direction, the present paper describes the main functionalities of a tool that automatically generates a formal secure access control filter for information systems. The goal of the filter is to regulate the access to data of an information system according to a set of static and dynamic rules. Data are described using a UML class diagram, whereas the static and dynamic rules are modeled using \textsc{SecureUML} and UML activity diagrams respectively. Basically, the tool automatically generates the B formal specification corresponding to these diagrams and the filter

To verify embedded systems early in the design stages, we need formal ways to requirements specification which can be as close as possible to natural language interpretation, away from the lower ESL/RTL levels. This paper proposes to contribute to the FSL (Formal Specification Level) by specifying natural language requirements graphically in the form of temporal patterns. Standard modeling artifacts like UML and MARTE are used to provide formal semantics of these graphical models allowing to eliminate ambiguity in specifications and automatic design verification at different abstraction levels using these patterns.; Pour vérifier des systèmes embarqués tôt dans le cycle de conception, il est nécessaire de disposerde langages d'exigences aussi proche que possible de l'expression des besoins en langage naturel. Ce papier s'inscrit dans l'initiative FSL (Formal Specification Level) et propose un langage graphique, s'appuyant sur UML pour décrire des exigences formelles basées sur un ensemble de patrons temporels. Il réutilise très largement des constructions UML et MARTE et s'appuie sur la sémantique du langage CCSL pour éliminer les ambiguïtés dans les spécifications, exécuterles modèles et permettre la vérification de ces modèles au niveau système.

This paper addresses the overall problem of estimating the quality of a test suite when testing is performed at a platform-independent level, using executable UML models. The problem is that the test suite is often required to fulfill structural code coverage criteria. In the avionics domain it is usually required that the tests achieve 100% coverage according to logic-based coverage criteria. Such criteria are less effective when applied to executable UML models than when they are applied to code because the action code found in such models contains conditions in navigation and loops that are not explicit and therefore not captured by logic-based coverage criteria. We present two new coverage criteria for executable UML models, and we use an industrial application from the avionics domain to show that these two criteria should be combined with a logic-based criterion when testing the executable UML model. As long as the coverage is less than 100% at the model level, there is no point in running the tests at the code level since all functionality of the model is not yet tested, and this is necessary to achieve 100% coverage at the code level.

International audience; Massively Parallel Multi-Processors System-on-Chip (MP2SoC) architectures require efficient programming models and tools to deal with the massive parallelism present within the architecture. In this paper, we propose a tool which automates the generation of the System-Level Architecture Model (S-LAM) from a Unified Modeling Language-based (UML) model annotated with the Modeling and Analysis of Real-Time and Embedded Systems (MARTE) profile. The S-LAM-based description of the MP2SoC architecture is conformed to the IP-XACT standard. The integration of our generator within a co-design framework provides the specification of the whole MP2SoC system using UML and MARTE. Then, gradual refinements allow the execution of a rapid prototyping process.

In this paper, we present a model-driven approach for the derivation of inter-component-interaction specifications from runtime tests. In particular, we use test-execution traces to record interactions between architectural components based on testing object-oriented systems. The resulting models are specified via UML diagrams. In order to transform test executions to corresponding component and interaction models, we define conceptual mappings (transformation rules) between a test-execution metamodel and the UML2 metamodel. As a proof of concept, we integrated the approach into our tool KaleidoScope.

Analysis and design are important phases in the system development lifecycle. In these phases, developers record information necessary for properly understanding the nature of the systems under consideration.We consider a particular type of system, named Remote Lab that allows both teachers and students to perform real experiments over the internet and we focus on Virtual Instrument Systems in Reality (VISIR). We describe a summarized web interface of VISIR using the Unified Modeling Language (UML). Our case study aims at identifying the requirements of VISIR and at creating a set of UML diagrams that succinctly provide enough information to both developers and users so that they acquire enough information for building a general understanding of it. Additionally, we provide elements for extending UML to better support further user interface development in VISIR.

In this paper, and in the context of a course of 1st cycle in Informatics, and following the guidelines of the Information Systems courses provided by ACM/AIS, we propose the use of Google tools and Lucidchart modeling tool, aligned with Bloom's taxonomy in our model BML Context Oriented (BML-CO) in a Requirements Engineering course based on Unified Modelling Language (UML) to modeling and specify requirements to a software system. Teaching Requirements Engineering and, in particular modeling and specification requirements, at the higher education institutions is an “arduous” task according to the literature that the proposed approach wants contribute for filling this gap.

The development of a complex software system involves many actors, whose skills and knowledge are very heterogeneous. The requirements representation made using the Business Process notations is far more understandable than the classic UML representation, at least for Business experts, as it allows to investigate the system from other points of view which are not merely connected the development of the software itself. However, it is not possible to completely disregard UML representations, as they catch software design information which would be lost otherwise. In order to use both representations as basic tools through the whole software development life cycle, a key point is to ensure that they can be easily combined together to facilitate the development of the system software assets. In this paper we address this interoperability scope and provide a unified semantic representation, capable of covering every aspect of software development life cycle and of bonding the different Business and Software development points of view, from the requirements definition to the actual implementation of the source code, including the migration of applications to the Cloud.

We conducted an extensive systematic literature review (SLR) based on 8,000+ publications for 2005-2012.We examined 90 UML-based domain-specific languages (DSLs) for their design decisions.We extracted 27 reusable design decisions and 7 characteristic DSL designs into a publicly available design-decision catalog.One third of the documented design decisions can be combined to characterize more than 60% of the reviewed DSLs. When developing domain-specific modeling languages (DSMLs), software engineers have to make a number of important design decisions on the DSML itself, or on the software-development process that is applied to develop the DSML. Thus, making well-informed design decisions is a critical factor in developing DSMLs. To support this decision-making process, the model-driven development community has started to collect established design practices in terms of patterns, guidelines, story-telling, and procedural models. However, most of these documentation practices do not capture the details necessary to reuse the rationale behind these decisions in other DSML projects. In this paper, we report on a three-year research effort to compile and to empirically validate a catalog of structured decision descriptions (decision records) for UML-based DSMLs. This catalog is based on design decisions extracted from 90 DSML projects. These projects were identified-among others-via an extensive systematic literature review (SLR) for the years 2005-2012. Based on more than 8,000 candidate publications, we finally selected 84 publications for extracting design-decision data. The extracted data were evaluated quantitatively using a frequent-item-set analysis to obtain characteristic combinations of design decisions and qualitatively to document recurring documentation issues for UML-based DSMLs. We revised the collected decision records based on this evidence and made the decision-record catalog for developing UML-based DSMLs publicly available. Furthermore, our study offers insights into UML usage (e.g. diagram types) and into the adoption of UML extension techniques (e.g. metamodel extensions, profiles).

The article deals with two principles of business workflow modeling, Petri nets and UML notation, that are the acceptable approaches to business modeling and can be used also for business documents workflow. The special type of Petri nets, WF-nets and UML activity diagrams are used in this article and both modeling ways are presented on the concrete business workflow and then there are presented and specified their advantage and disadvantage for business documents flows. At beginning it is explained the word workflow in context business documents, its features, principles and using in business environment. After that it is clarified that the UML is OMG’s most-used specification, and the way the world models not only application structure, behavior, and architecture, but also business process, workflows and data structure. Activity diagram UML is good way to show how different workflows in the business are managed, how they start, go and stop. Diagrams also show many different decision paths that can be taken from start to finish. State charts can be used as a detail the transitions or changes of states when documents can go through in the business. They show how a documents moves from one state to another and the rules that govern that change. Petri-nets offer a graphical notation for stepwise processes that include choice, iteration, and concurrent execution. Unlike UML Petri nets have an exact mathematical definition of their execution semantics, with a well-developed mathematical theory for process analysis. In the article there are modeled a special type of Petri nets, the WF-nets. The practical part of article incorporates two models of concrete business documents workflows presented in these notations, their comparison and recommendation for using these diagrams in business process management.

Aspect-Oriented Modeling (AOM) techniques facilitate separate modeling of concerns and allow for a more flexible composition of the resulting models than traditional techniques. While this improves the understandability of each submodel, in order to reason about the behavior of the composed system and to detect conflicts among submodels, automated tool support is required. We propose a technique and tool support for fully automatic detection of conflicts between aspects at the model level; more specifically, our approach works on models defined in UML with an extension for modeling pointcuts and advice. As back-end we use a graph-based model checker, for which we have defined an operational semantics of UML diagrams, pointcuts and advice. In order to simulate the system, we automatically derive a graph model from the diagrams. The simulation result is another graph, which represents all possible program executions, and which can be verified against a declarative specification of invariants. To demonstrate our approach, we discuss a UML-based AOM model of the "Crisis Management System" (CMS) and a possible design and evolution scenario. The complexity of the system makes conflicts among composed aspects hard to detect: already in the case of five simulated aspects, the state space contains 9991 different states and 99 different execution paths. Nevertheless, using appropriate pruning methods, the state space only grows polynomially with the number of aspects. In practical cases, the order of the polynomial is very small, e.g., 2 in the case of the simulated CMS; therefore, the automatic analysis scales.

UML is a visual language. However surprisingly, there has been very little attention in either research or practice to the visual notations used in UML . Both academic analyses and official revisions to the standard have focused almost exclusively on semantic issues, with little debate about the visual syntax. We believe this is a major oversight and that as a result, UML 's visual development is lagging behind its semantic development. The lack of attention to visual aspects is surprising given that the form of visual representations is known to have an equal if not greater effect on understanding and problem solving performance than their content. The UML visual notations were developed in a bottom-up manner, by reusing and synthesising existing notations, with choice of graphical conventions based on expert consensus. We argue that this is an inappropriate basis for making visual representation decisions and they should be based on theory and empirical evidence about cognitive effectiveness. This paper evaluates the visual syntax of UML using a set of evidence-based principles for designing cognitively effective visual notations. The analysis reveals some serious design flaws in the UML visual notations together with practical recommendations for fixing them.

The technological developments in networking solutions, information and communication services create the basis for the provisioning of complex, realtime services. This paper addresses the charging and billing of such advanced services. Advanced services will be composed of services provided by various 3rd party providers residing in different domains. Hence, charging and billing of advanced services requires a billing system capable of composing charging and billing information from providers in different domains on a near real-time basis. We present an enterprise model for real-time inter-domain billing, comprising the role of the end-user, subscriber, the service provider, the 3rd party provider, and the billing provider. The model builds on the RM-ODP Enterprise Viewpoint, the eTOM and the Shared Information/Data model (SID).

Model transformations support a model-driven design by providing an automatic translation of abstract models into more concrete ones, and eventually program code. Crucial to a successful application of model transformations is their correctness, in the sense that the meaning (semantics) of the models is preserved. This is especially important if the models not only describe the structure but also the intended behaviourof the systems. Reasoning about and showing correctness is, however, often impossible as the source and target models typically lack a precise definition of their semantics. In this paper, we take a first step towards provably correct behavioural model transformations. In particular, we develop transformations from UML Activities (which are visual models) to programs in TAAL, which is a textual Java-like programming language. Both languages come equipped with formal behavioural semantics, which, moreover, have the same semantic domain. This sets the stage for showing correctness, which in this case comes down to showing that the behaviour of every (well-formed) UML Activity coincides with that of the corresponding TAAL program, in a well-defined sense.

In this paper we will present the results of research into modelling pitfalls in (Extended) Entity Relationship modelling ((E)ER) and the Unified Modelling Language (UML). We will give a precise definition of the relationship cardinality/association end multiplicity concept in (E)ER and UML based upon the various definition 'fragments' we have encountered in the (E)ER and UML literature and we will give explicit rules for the application of these constructs for Knowledge Management (KM) in an educational setting.

This paper presents criteria for the adequacy of languages to represent interaction mechanisms. It then uses these criteria to analyse the adequacy of UML. We focus on the interaction mechanisms provided by Web Services technology and by CORBA for request/response, callback, polling and (multicast) message passing. We argue that the criteria for adequacy of a design language are that the language should: (1) be expressive enough to represent the mechanisms; (2) be easy to use when expressing them; (3) be platform independent in the sense that it does not force implementation decisions for a mechanism; and (4) behave corresponding to the mechanisms that it represents. We show that these criteria follow logically from the use of a design language in the design process. For UML we evaluate the first three criteria in a qualitative manner. To evaluate the fourth criteria, we present Coloured Petri Nets that capture the behaviour of both the mechanisms precisely and the UML constructs that represent them. Subsequently, we check the correspondence of their behaviour.

Part 11: Social Impact of EIS and Visualization; International audience; The aim of the paper is to present the advantages of the Use Cases transformation to the object layers and their visualization in 3D space to reduce complexity. Our work moves selected UML diagram from two-dimensional to multidimensional space for better visualization and readability of the structure or behaviour.Our general scope is to exploit layers for particular components or modules, time and author versions, particular object types (GUI, Business services, DB services, abstract domain classes, role and scenario classes), patterns and anti-patterns in the structure, aspects in the particular layers for solving crosscutting concerns and anti-patterns, alternative and parallel scenarios, pessimistic, optimistic and daily use scenarios.We successfully apply force directed algorithm to create more convenient automated class diagrams layout. In addition to this algorithm, we introduced semantics by adding weight factor in force calculation process.

Conference of 18th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems, MODELS 2015 ; Conference Date: 30 September 2015 Through 2 October 2015; Conference Code:118445; International audience; In the Model-Driven Engineering community, the abstract syntax of modeling languages is usually defined and implemented using metamodeling techniques. However, it is not the case for the concrete syntax of graphical modeling languages. Indeed, this concern is mostly specified by informal means. This practice leaves considerable leeway in the implementation and raises several standards compliance issues. Hence, toolsmiths can only rely on their interpretation of the standard and lack of systematic way to build conforming tool support. In this context, a first normative specification of the concrete syntax of UML 2.5 has been recently released using Diagram Definition. In this paper, we propose an approach that uses those formal specifications to systematically generate modeling language tool support that guarantees compliance to standard notation. We assess the approach on a subset of the UML class diagram implemented within the open-source Papyrus tool.

International audience; UML is defined as a visual modeling language for specifying, constructing, and documenting software intensive systems. In that context, UML diagrams play a central role in the whole software engineering process, starting from early analysis, through implementation, to maintenance. Recent surveys of UML use in industry showed that software practitioners use it on a regular basis, and particularly for communication and as a mental-assist tool. However, they also pointed out the following weaknesses: the lack of context, graphical layout problems, and the language’s inadequacy as a facility for communication between technical teams and their clients. In this paper, we present a general approach that addresses these problems by enhancing the effectiveness of UML models as a communication vehicle. Our approach is based on expressing stakeholder-specific viewpoints through the use of secondary notations. This involves the use of auxiliary visual variables (e.g., color, position, size) that are not formally specified in UML. To that end, we extend the traditional concept of layer found in many graphical editors to UML diagram editors. FlipLayers is an implementation of our approach. It is in the form of a plugin for the Papyrus modeling environment. One scenario with several case studies is presented in the paper to demonstrate the benefits of our approach and also to illustrate how to express viewpoints with FlipLayers.

The development of complex event-driven systems requires studies and analysis prior to deployment with the goal of detecting unwanted behavior. UML is a language widely used by the software engineering community for modeling these systems through state machines, among other mechanisms. Currently, these models do not have appropriate execution and simulation tools to analyze the real behavior of systems. Existing tools do not provide appropriate libraries (sampling from a probability distribution, plotting, etc.) both to build and to analyze models. Modeling and simulation for design and prototyping of systems are widely used techniques to predict, investigate and compare the performance of systems. In particular, the Discrete Event System Specification (DEVS) formalism separates the modeling and simulation; there are several tools available on the market that run and collect information from DEVS models. This paper proposes a model transformation mechanism from UML state machines to DEVS models in the Model-Driven Development (MDD) context, through the declarative QVT Relations language, in order to perform simulations using tools, such as PowerDEVS. A mechanism to validate the transformation is proposed. Moreover, examples of application to analyze the behavior of an automatic banking machine and a control system of an elevator are presented. El desarrollo de complejos sistemas guiados por modelos requiere de estudios y análisis previos a la implementación, con el objetivo de detectar comportamientos no deseados. UML es un lenguaje ampliamente usado por la comunidad de ingeniería de software para modelar estos sistemas a través de las máquinas de estados, entre otros mecanismos. En la actualidad, estos modelos no disponen de adecuadas herramientas de simulación y ejecución para analizar el comportamiento real de los sistemas. Las herramientas existentes no proveen librerías apropiadas (para el muestreo de distribuciones de probabilidad, ploteo, etc.) para construir y analizar modelos. El modelado y la simulación para el diseño y prototipado de sistemas son técnicas ampliamente usadas para predecir, investigar y comparar la performance de los sistemas. En particular, el formalismo Especificación de Sistemas de Eventos Discretos (Discrete Event System Specification - DEVS) separa el modelado de la simulación. Existen varias herramientas disponibles en el mercado que ejecutan y recopilan información de modelos DEVS. Este artículo propone un mecanismo de transformación de modelos de máquinas de estados UML a modelos DEVS en el contexto del desarrollo dirigido por modelos (Model-Driven Development - MDD) mediante el lenguaje declarativo QVT-Relations, a fin de realizar simulaciones utilizando herramientas tales como PowerDevs. Asimismo, se describe una propuesta para validar la transformación desarrollada. Finalmente, se presentan dos ejemplos de aplicación. El primero analiza el comportamiento de un cajero automático de un banco y el segundo analiza un sistema de control de ascensores.

Part 6: Wireless and Wired Networks; International audience; Many works were interested in studying the ways of organizing Web services into communities which allowed the onset of a variety of definitions and models. The new paradigm, launched by the use of Web services communities models was adopted by users in various fields such as those related to marketing, commerce, health care, etc. However, the proposed conceptual models suffer from dispersed points of view that have to be unified in order to offer generic conceptual support for experts and clerical users. The purpose of this work is to propose a unified conceptual model able to unify different points of view through a generic UML description profile of Web services communities characteristics well adapted to new concepts imposed by the use of communities. Thanks to the proposed unified model, users will be able to build themselves their communities regardless the case of study involving Web services.

This chapter presents a security engineering process based on UML security problem frames and concretized UML security problem frames. Both kinds of frames constitute patterns for analyzing security problems and associated solution approaches. They are arranged in a pattern system that makes dependencies between them explicit. The authors describe step-by-step how the pattern system can be used to analyze a given security problem and how solution approaches can be found. Then, solution approaches are specified by generic security components and generic security architectures, which constitute architectural patterns. Finally, the generic security components and the generic security architecture that composes them are refined, and the result is a secure software product built from existing and/or tailor-made security components.

Many scientists who implement computational science and engineering software have adopted the object-oriented (OO) Fortran paradigm. One of the challenges faced by OO Fortran developers is the inability to obtain high level software design descriptions of existing applications. Knowledge of the overall software design is not only valuable in the absence of documentation, it can also serve to assist developers with accomplishing different tasks during the software development process, especially maintenance and refactoring. The software engineering community commonly uses reverse engineering techniques to deal with this challenge. A number of reverse engineering-based tools have been proposed, but few of them can be applied to OO Fortran applications. In this paper, we propose a software tool to extract unified modeling language (UML) class diagrams from Fortran code. The UML class diagram facilitates the developers' ability to examine the entities and their relationships in the software system. The extracted diagrams enhance software maintenance and evolution. The experiments carried out to evaluate the proposed tool show its accuracy and a few of the limitations.

This paper presents the results of an empirical study aiming at comparing the support provided by ER and UML class diagrams during maintenance of data models. We performed one controlled experiment and two replications that focused on comprehension activities (the first activity in the maintenance process) and another controlled experiment on modification activities related to the implementation of given change requests. The results achieved were analyzed at a fine-grained level aiming at comparing the support given by each single building block of the two notations. Such an analysis is used to identify weaknesses (i.e., building blocks not easy to comprehend) in a notation and/or can justify the need of preferring ER or UML for data modeling. The analysis revealed that the UML class diagrams generally provided a better support for both comprehension and modification activities performed on data models as compared to ER diagrams. Nevertheless, the former has some weaknesses related to three building blocks, i.e., multi-value attribute, composite attribute, and weak entity. These findings suggest that an extension of UML class diagrams should be considered to overcome these weaknesses and improve the support provided by UML class diagrams during maintenance of data models.

Model-driven engineering (MDE) is a software engineering approach based on model transformations at different abstraction levels. It prescribes the development of software by successively transforming the models from abstract (specifications) to more concrete ones (code). Alloy is an increasingly popular lightweight formal specification language that supports automatic verification. Unfortunately, its widespread industrial adoption is hampered by the lack of an ecosystem of MDE tools, namely code generators. This paper presents a model transformation from Alloy to UML class diagrams annotated with OCL (UML+OCL) and shows how an existing transformation from UML+OCL to Alloy can be improved to handle dynamic issues. The proposed bidirectional transformation enables a smooth integration of Alloy in the current MDE contexts, by allowing UML+OCL specifications to be transformed to Alloy for validation and verification, to correct and possibly refine them inside Alloy, and to translate them back to UML+OCL for sharing with stakeholders or to reuse current model-driven architecture tools to refine them toward code., This work was funded by European Regional Development Fund (ERDF) through the COMPETE Programme (operational program for competitiveness) and by national funds through the FCT (Fundaaco para a Ciencia e a Tecnologia-portuguese Foundation for Science and Technology) within project FCOMP-01-0124-FEDER-020532. Part of the work was done while the first author was visiting the Software Design Group at CSAIL, MIT, USA, funded by FCT sabbatical grant SFRH/BSAB/1187/2011. The second author was also partially supported by QREN (the portuguese National Strategy Reference Chart) project 1621, while visiting the High-Assurance Software Laboratory at Universidade do Minho, Portugal. Finally, we would also like to thank all anonymous reviewers for the valuable comments and suggestions.

This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License. The most important advantage of Model Driven Engineering (MDE) is making available tools, concepts and languages to create and transform models. In this paper, we propose a framework to transform automatically UML activity diagram 2.0 (informal notation) to Petri Nets (formal notation) for the analysis purpose using INA analyzer tool. This transformation helps the software designers to analyze and verify properties. For realizing this transformation, we have proposed a meta-model for UML-AD and another one for PN. Based on these meta-models, we define a graph grammar that performs the transformation process. AToM3 is used as a tool for meta-modeling and graph transformation. We verify the resulting Petri nets with model checker INA. We illustrate our contribution with a detailed example. 56 612 617

We present an institution for UML state machines without hierarchical states. The interaction with UML class diagrams is handled via institutions for guards and actions, which provide dynamic components of states such as valuations of attributes but abstract away from details of class diagrams. We also study a notion of interleaving product, which captures the interaction of several state machines. The interleaving product construction is the basis for a semantics of composite structure diagrams, which can be used to specify the interaction of state machines. This work is part of a larger effort to build a framework for formal software development with UML, based on a heterogeneous approach using institutions.

A domain model can provide compact information about its corresponding software system for business people. If the software system exists without its domain model and documentation it is time-consuming to understand its behavior and structure only from the code. Reverse Engineering (RE) tools can be used for obtaining behavior and structure of the software system from source code. After that the domain model can be created. A short overview and an example of obtaining the domain model, Topological Functioning Model (TFM), from source code are provided in the paper. Positive and negative effects of the process of TFM backward derivation are also discussed.

International audience; In UML modeling, class diagrams permit to capture the entities involved in a system but also the associations they have with each other. These associations are characterized by a multiplicity on each role to state the min-max number of instances of the opposite class that can be linked to each instance of the class associated with the role. Since these multiplicities may be conflicting, it becomes necessary to check the global consistency of a class diagram. Such verification will ensure that it is possible to find an instantiation of the diagram that satisfies all the multiplicities. In this paper, we describe an automatized approach that permits to validate a class diagram by exhibiting a particular instance. Basically, this approach proceeds in two main steps: first, the multiplicities are represented as a mathematical model, then a constraint solver is used to determine whether it has at least one solution. The correctness of the approach, which is supported by an automatic tool, has been carried out using the B formal method

Effective and rigorous analysis of cooperative work settings is crucial to the successful development of CSCW systems. This paper investigates the relationship between the social organization of the work settings and the system development. Objectives of this paper are therefore twofold. First, it effectively analyses the social aspects of the work practices using the state-of-the-art techniques of ethnography. Such analysis provides rich and concrete portrayal of the situation thus helps systematic design of CSCW systems. Second it uses the standard Unified Modelling Language (UML) in order to represent and model the findings of the ethnographic analysis. UML-based representation of the findings has proven to be an important aid to the development of CSCW systems.