Search

This paper basically focuses on improving readability of software models. The goal of this research is the enhancement of readability and usability of UML diagrams which increases the interaction between users, programmers and software. UML generally focuses on the main aspect of the software, putting aside other concerns or "useful information" and only tries to display specific aspect at a certain time. Although, specific representation simplifies the understandability of whole diagram, removes useful contextual information. We demonstrate how to represent contextual information by visualizing "useful information" in UML diagrams. These diagrams are created from Java code using reverse engineering plug-in. This goal is achieved by adding extra information to diagram elements in form of different visual variables (such as color, brightness, text and border decoration, etc.). "Useful information" could be any obtained information during the software proceeding. Useful information and its relevant visual variables have been mapped to Java annotations, and this visualized information has been added to diagram. Embedding the "useful information" as Java annotations was done by means of Java language. Afterward, representing and visualizing contextual information in UML diagrams was conducted by JavaScript.

Models are primary artifacts in software development which influence the quality of the process and product. While students are trained to use design and development methodologies few teaching approaches address how they should create and evaluate alternative models to find a good solution. This paper suggests to complement common teaching formats with facilitated modeling sessions where small groups of students collaboratively work on a modeling problem. This experience increases the students' understanding of the importance of a shared understanding of the problem and design space. Students should also understand that they can actively shape their collaboration accordingly. A facilitation method for co-located modeling sessions with a multi-touch editor for UML class diagrams is introduced and its effectiveness is investigated in a comparative empirical study. The results suggest that students in facilitated teams not only developed more ideas than self-directed teams but that they also assessed and discussed them more thoroughly to come to a shared solution. Participants in both conditions considered the modeling session as a useful supplement for learning object-oriented modeling.

The Unified Modeling Language (UML) is widely taught in academia and has good acceptance in industry. However, there is not an ample dataset of UML diagrams publicly available. Our aim is to offer a dataset of UML files, together with meta-data of the software projects where the UML files belong to. Therefore, we have systematically mined over 12 million GitHub projects to find UML files in them. We present a semi-automated approach to collect UML stored in images, .xmi, and .uml files. We offer a dataset with over 93,000 UML diagrams from over 24,000 projects in GitHub.

Large and complicated UML models are not useful, because they are difficult to understand. This problem can be solved by using several diagrams of the same system at different levels of abstraction. Unfortunately, UML does not define an explicit set of rules for ensuring that diagrams at different levels of abstraction are consistent. We define such a set of rules, that we call diagram refinement. Diagram refinement is intuitive, and applicable to several kinds of UML diagrams (mostly to structural diagrams but also to use case diagrams), yet it rests on a solid mathematical basis---the theory of graph homomorphisms. We illustrate its usefulness with a series of examples.

Context: Open Source is getting more and more collaborative with industry. At the same time, modeling is today playing a crucial role in development of, e.g., safety critical software. Goal: However, there is a lack of research about the use of modeling in Open Source. Our goal is to shed some light into the motivation and benefits of the use of modeling and its use within project teams. Method: In this study, we perform a survey among Open Source developers. We focus on projects that use the Unified Modeling Language (UML) as a representative for software modeling. Results: We received 485 answers of contributors of 458 different Open Source projects. Conclusion: Collaboration seems to be the most important motivation for using UML. It benefits new contributors and contributors who do not create models. Teams use UML during communication and planning of joint implementation efforts.

Presents features of Knowledge Base' construction for Nature-Technogenic Control System. Structure and components of this Knowledge Base are considered in accordance with working standards (IDEF0, UML 1.4). Software development processes based on design techniques (SADT, UML) are discussed. Diagrams shown depict structural and functional composition of Knowledge Base using CASE-tools (BPWin, PlantUML).

Modeling correct software-intensive Systems of Systems architectures is a challenging research direction that can be mastered by providing modeling abstractions. For this purpose, we provide an iterative modeling solution for a multi-scale description of software architectures. We provide a visual notation extending the graphical UML notations to represent structural as well as behavioral features of software architectures. We define a step-wise iterative process from a coarse-grain to a fine-grain description. The intermediate iterations provide a description with a given abstraction that allow the validation to be conducted significantly while remaining tractable w.r.t. complexity. The iterative process involves both system-independent structural features ensuring the model correctness, and system-specific features related to the expected behavior of the modeled domain. We apply our approach for a methodological design of an Emergency Response and Crisis Management System (ERCMS).

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.

We present Precise Service-Oriented Modelling (Precise SOM) - a novel lightweight method for integrated domain and business process modelling, which follows the service-oriented paradigm, and uses a UML profile as notation - and a detailed workflow to guide the production of the models. In our method the produced UML models are precisely defined by means of a metamodel, a set of constraints, and a limited set of UML constructs to help modellers to avoid common mistakes and to guarantee, by construction, a good quality. Precise SOM has been successfully used in an industry-academic project concerning the modelling of a big harbour.

The semantics of Unified Modeling Language (UML) version 2.5, as defined by Object Management Group (OMG), are informal which leads to critical problems like ambiguities, inconsistencies, vagueness and misinterpretations. The solution to all aforementioned issues associated with UML is the transformation of UML informal semantics into formal mathematical semantics. The Executable Node and Activity Group are principal components of UML 2.5 Activity Diagram and they have not been completely formalized in existing researches so far. Our earlier publications presented formalization of structural semantics of UML 2.5 Activity Diagram in Z notation. This paper is an extension of our previous work by comprehensive formalization of structural semantics of Executable Node and Activity Group into Z notation. The defined formal semantic are then verified using various proof techniques offered by Z/EVES toolset.

To provide assistance functions in context of surgical interventions, the use of medical workflows plays an important role. Workflow models can be used to assess the progress of an on-going surgery, enabling tailored (i.e., context sensitive) support for the medical practitioner. Subsequently, this provides opportunities to prevent malpractices, to enhance the patient's outcome and to preserve a high level of satisfaction. In this work, we propose a framework which enables a formalization of medical workflows. It is driven by a dialog of medical as well as technical experts and is based on the Unified Modeling Language (UML). An easy comprehensible UML activity serves as a starting point for the automatic generation of more complex models that can be used for the actual estimation of the progress of a surgical intervention. In this work, we present translation rules, which allow to transfer a given UML activity into a Dynamic Bayesian Network (DBN). The methods are presented for the application example of a cholecystectomy (surgical removal of the gallbladder).

Concurrency is a challenging and difficult task for software testing. Many researchers try to solve this problem and propose a solution, i.e. control flow graph, breadth first search (BFS), combined activity diagram and I/O explicit activity diagram. This paper proposes the method to generate concurrent test cases from UML activity diagrams. This method first builds a concurrent activity diagram from an ordinary UML activity diagram. It then transforms a UML activity diagram to an activity graph. Using dynamic programming techniques to find the number of total paths and of total condition paths in concurrent test cases. Test coverage measures the amount of tests performed by a set of tests which can also assure the quality of tests.

UML sequence diagrams are visual representations of object interactions in a system and can provide valuable information for program comprehension, debugging, maintenance, and software archeology. Sequence diagrams generated from legacy code are independent of existing documentation that may have eroded. We present a framework for static generation of UML sequence diagrams from object-oriented source code. The framework provides a query refinement system to guide the user to interesting interactions in the source code. Our technique involves constructing a hypergraph representation of the source code, traversing the hypergraph with respect to a user-defined query, and generating the corresponding set of sequence diagrams. We implemented our framework as a tool, StaticGen, analyzing a corpus of 30 Android applications. We provide experimental results demonstrating the efficacy of our technique.

Business Process Model and Notation is a standard for process modeling. However, such models do not specify the time issues such as time of performing tasks or time of utilizing the resources. We propose the complementary UML sequence model generated from the BPMN model. Such a model can support time specification and provide direct time visualization. It is also suitable for validation in terms of time matters by domain experts as well as can be used to estimate and test methods in the systems based on random examination of the critical paths.

This chapter discusses the metamodeling base of Unified Modeling Language (UML) and how it can be used to improve it. The metamodeling base defines that there exist a metamodel that describes and includes all the elements needed for UML to exist as we know it. In other words, a metamodel is used to specify the model that builds UML. One of the UML metamodel principles is its extensibility. In fact, the most common and suitable way for improving UML is to use its extensibility mechanisms—the profiles. By improving UML with the profile mechanism, it is possible to adapt and use ordinary UML compliant modeling tools. Thus, by creating a profile of UML the costs of adaption in industry for such new language is lowered and it can be adapted faster (in comparison with creating a Meta-Object Facility (MOF)-based solution which forces to implement new modeling tools along with the very new language).

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.

Manual verification of the consistency between UML state machine diagrams and sequence diagrams is labor-intensive and prone to make mistakes. We provide an automatic tool written in Java that performs the verification by translating UML diagrams into a process description of CSP\(_M\) language. The tool takes in a PlantUML file and verifies the consistency with a model-checker FDR.

In the last 30 years there were numerous model generated software systems offered targeting problems with the development productivity and the resulting software quality. CASE tools developed due today’s date are being advertised as having “complete code-generation capabilities”. Nowadays the Object Management Group (OMG) is calling similar arguments in regards to the Unified Modeling Language (UML) models at different levels of abstraction. It is being said that software development automation using CASE tools enables significant level of automation. Actual today’s CASE tools are usually offering a combination of several features starting with a model editor and a model repository for a traditional ones and ending with code generator (that could be using a scripting or domain-specific (DSL) language), transformation tool to produce the new artifacts from the manually created and transformation definition editor to define new transformations for the most advanced ones. Present paper contains the results of CASE tool (mainly UML editors) comparison against the level of the automation they are offering.

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.

In this paper we will present the results of research into the semantics of association end multiplicities (aems) in the unified modeling language (uml). In this paper we will give a precise definition of the aem concept in uml based upon the various definition ‘fragments’ we have encountered in the uml literature and we will give explicit rules for the application of the aem for the conceptual modeling of an application subject area.

The success of Model-Driven Engineering (MDE) relies on the quality of the employed models. Thus, quality assurance through validation and verification has a tradition within MDE. But model verification is typically done in the context of specialized approaches and provers. Therefore, verification tasks are expressed from the viewpoint of the chosen prover and approach requiring particular expertise and background knowledge. This contribution suggests to take a new view on verification tasks that is independent from the employed approach and prover. We propose to formulate verifications tasks in terms of the used modeling language itself, e.g. with UML and OCL. As prototypical example tasks we show how (a) questions concerning model consistency can be expressed with UML object diagrams and (b) issues regarding state reachability can be defined with UML sequence diagrams.

info:eu-repo/semantics/submittedVersion Correctness of UML class diagrams annotated with OCL constraints can be checked using bounded verification techniques, e.g., SAT or constraint programming (CP) solvers. Bounded verification detects faults efficiently but, on the other hand, the absence of faults does not guarantee a correct behavior outside the bounded domain. Hence, choosing suitable bounds is a non-trivial process as there is a trade-off between the verification time (faster for smaller domains) and the confidence in the result (better for larger domains). Unfortunately, bounded verification tools provide little support in the bound selection process. In this paper, we present a technique that can be used to (i) automatically infer verification bounds whenever possible, (ii) tighten a set of bounds proposed by the user and (iii) guide the user in the bound selection process. This approach may increase the usability of UML/OCL bounded verification tools and improve the efficiency of the verification process. La corrección de los diagramas de clase UML anotados con restricciones OCL puede verificarse usando técnicas de comprobación limitada, por ejemplo, resolución SAT o de programación con restricciones (CP). La comprobación limitada detecta los fallos de manera eficiente pero, por otro lado, la ausencia de fallos no garantiza un comportamiento correcto fuera del dominio delimitado. Por lo tanto, la elección de límites adecuados no es un proceso trivial, ya que hay una compensación entre el tiempo de verificación (más rápido para dominios más pequeños) y la seguridad en el resultado (mejor para dominios más grandes). Desafortunadamente, las herramientas de comprobación limitada proporcionan poco soporte en el proceso de selección vinculado. En este artículo, presentamos una técnica que puede usarse para (i) inferir automáticamente límites de verificación siempre que sea posible, (ii) ajustar un conjunto de límites propuestos por el usuario y (iii) guiar al usuario en el proceso de selección vinculado. Este enfoque puede aumentar la usabilidad de las herramientas de comprobación limitada UML/OCL y mejorar la eficiencia del proceso de verificación. La correcció dels diagrames de classe UML anotats amb restriccions OCL es pot verificar usant tècniques de comprovació limitada, per exemple, resolució SAT o de programació amb restriccions (CP). La comprovació limitada detecta els errors de manera eficient però, d'altra banda, l'absència d'errades no garanteix un comportament correcte fora del domini delimitat. Per tant, l'elecció de límits adequats no és un procés trivial, ja que hi ha una compensació entre el temps de verificació (més ràpid per a dominis més petits) i la seguretat en el resultat (millor per a dominis més grans). Desafortunadament, les eines de comprovació limitada proporcionen poc suport en el procés de selecció vinculat. En aquest article, presentem una tècnica que pot usar-se per a (i) inferir automàticament límits de verificació sempre que sigui possible, (ii) ajustar un conjunt de límits proposats per l'usuari i (iii) guiar a l'usuari en el procés de selecció vinculat. Aquest enfocament pot augmentar la usabilitat de les eines de comprovació limitada UML/OCL i millorar l'eficiència del procés de verificació.

This paper proposes an automated test cases generation method from sequence diagrams and class diagrams with string constraints. The method supports UML 2.0 sequence diagrams including twelve combined fragments. An algorithm for generating test scenarios are developed to avoid test paths explosion without having data sharing points of threads in parallel fragments or weak sequencing fragments. Test data are also generated with solving constraints of string variables. We standardize string constraints and equations at the boundary of variables that are input formula of Z3-str solver. Comparing with the current approach of the solver, some preprocessing rules are extended for other operations such as charAt, lastindexOf, trim, startsWith and endsWith. If a result of the Z3-str is SAT, test data of each test scenario are generated to satisfy the constraints with boundary coverage. A tool is implemented to support the proposed method, and some experiments are also presented to illustrate the effectiveness of the tool.

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.

The main scope of the research is to analyse Unified Modelling Language (UML) models generation process from Enterprise Model (EM) in Information Systems (IS) development process by using knowledge-based subsystem. The knowledge-based subsystem is proposed as an additional computer aided software engineering (CASE) tool component to avoid IS development process based on empirics. For comprehensible perception there is also presented relation between EM and ontologies and its use in generation process.

Software reuse is a way to reduce costs and improve quality. However, in industry, the reuse of existing software artifacts is commonly done by ad hoc strategies such as clone-and-own. Clone-and-own leads to a set of system variants developed independently, despite of having similar parts. The maintenance of these independent variants is a difficult task, because of duplication and spread functionalities. One problem faced by developers and engineers is the lack of a global view of such variants, providing a better understanding of the actual state of the systems. In this paper we present an approach to discover the architecture of system variants using a search-based technique. Our approach identifies differences between models and uses these differences to generate candidate architectures. The goal is to find a candidate architecture most similar to a set of UML model variants. Our contribution is threefold: (i) we proposed an approach to discover model-based software architecture, (ii) we deal with the merging of multiple UML model variants; and (iii) our approach applies a search-based technique considering state-based merging of models. We evaluate our approach with four case studies and the results show that it is able to find good candidate architectures even when different features are spread among model variants.

The Unified Modeling Language (UML) is a notation and as such its specification does not contain any guidelines for software development process. Despite that UML is independent of particular methods and approaches, most of the UML modeling driven methods uses use case driven approach thus raising incomplete analysis of the problem domain functioning. Since UML modeling driven approaches are elaborated by different authors, their prescriptions differ. There is also difference in the use of use case narratives across various methods due to the lack of guidance on narrative format in the UML specification. The UML specification only states that “ use cases are typically specified in various idiosyncratic formats such as natural language, tables, trees, etc. Therefore, it is not easy to capture its structure accurately or generally by a formal model. ” This chapter discusses the current state of the art of UML-based software development approaches. Most attention is paid on the artifacts created by using the UML.

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.

Natural language text fall within the category of Controlled and Uncontrolled Natural Language. In this paper, an algorithm is presented to show that a given language text is controlled or uncontrolled. The parameters and framework is provided for UML diagram's repository. The parameter for controlled and uncontrolled languages is provided.

Aspect-Oriented Software Development (AOSD) is continuously gaining more importance as the complexity of software systems increases and requirement changes are high- rated. A smart way for making reuse of functionality without additional effort is separating the functional and non functional requirements. Aspect-oriented software development supports the capability of separating requirements based on concerns. AspectJ is one of the aspect-oriented implementations of Java. Using Model Driven Architecture (MDA) specifications, an AspectJ model representing AspectJ elements can be created in an abstract way with the ability to be applied in UML, Java or XML. One of the open source tools which support MDA and follows the standards of the Object Management Group (OMG) for both UML and MDA is Eclipse providing an implementation of MDA through Eclipse Modeling Framework (EMF). This paper focuses on creating a UML profile; a UML extension which supports language specifications for AspectJ using EMF. Our work is based on the latest UML specification (UML 2.5) and uses MDA to enable the inclusion of aspect-oriented concepts in the design process.

Unified Process Model (UP) is a customized framework for delivering iterative software. Unified Modelling Language (UML) is a tool used to build various diagrams which support incremental development of software system. This paper maps the workflows related to different phases of unified process model with various UML diagrams. A case study of Payroll Management System has been discussed specifying the use of UML diagrams in different phases of software development life cycle.

Model validation and verification tools should provide good support for generating test cases. We here sketch essential use cases for model validation and verification that help developers to find deficiencies in models on the basis of generated test cases and thus improve model quality. Along with such use cases, we demonstrate how to realize them in the UML and OCL tool USE. We apply the tool for a small case study showing the development of a relational database schema on the basis of a conceptual UML schema in form of a UML class diagram and accompanying OCL constraints.

The evolution of both general purpose and domain-specific meta-models and its impact on the existing models and modeling tools has been discussed extensively in the modeling research community. To assess the impact of domain-specific meta-model evolution on the modeling tools, a number of measures have been proposed by Durisic et al., NoC (Number of Changes) being the most prominent one. The proposed measures are evaluated on a case of AUTOSAR meta-model that specifies the language for designing automotive system architectures. In this paper, we assess the applicability of these measure and the underlying data-model for their calculation in a case study of Modelica and UML meta-models. Our preliminary results show that the proposed data-model and the measures can be applied to both analyzed meta-models as we were able to capture 68/77 changes on average per Modelica/UML release. However, only a subset of the data-model elements is applicable for analyzing the evolution of Modelica and also certain transformation of the data-model is required in case of UML. Despite these encouraging results, further studies are needed to assess the usefulness of the actual measures, e.g., NoC, in assessing the impact of Modelica/UML meta-model evolution on the modeling tools.

The article represents knowledge based UML Dynamic models (Use Case, Activity, State Machine, Protocol State Machine, Sequence, Communication, Timing and Interaction Overview) generation process from Enterprise Model (EM), where every model generation is defined with transformation algorithm. The algorithms description is presented as Activity diagrams with depiction an explanation of essential steps.

UML (Unified Modeling Language) is designed for all stages of software development, but it lacks precise semantic information. MDE (Model-driven engineering) takes the model as the primary software product and its main research direction is modeling and model transformation. We propose to explore the entity abstraction scenario where no existing classes fit as the representative entity for other classes through the data, information and knowledge recreation of existing classes and relationships with the introduction of knowledge graphs. In this paper, we proposed a knowledge graph to enhance model design between models.