Search

Unified Modelling Language (UML) has been conferred as the de facto standard in modeling by majority in the software system development community. Among the various types of diagrams that exist under the umbrella of UML is Sequence Diagram. Sequence Diagrams are capable of modeling interactional behaviours as well as dynamic happenings in a system, and as such are generally used in the modeling of complex software systems. However in this paper, Sequence Diagrams are used in the modeling of the IEEE 802.11 Carrier Sense Multiple Access with Collision Avoidance (CSMA/CA) protocol. The Sequence Diagram representing this protocol will then be used for formal, mathematical analysis by first transforming the Sequence Diagram through the MDA model transformation tool called SD2PN, and performing analysis such as liveness analysis, boundedness analysis and reachability analysis of the resulting Petri Net.

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.

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.

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.

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

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

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.

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.

Modeling functions is a key aspect of artifact design, including software engineering and business systems modeling, but it is likewise of fundamental importance in natural systems modeling, for example in modeling biological organisms. The Unified Modeling Language (UML), which originated from object-oriented software engineering, is nowadays a de facto standard for conceptual modeling and its current applications go far beyond software engineering. The paper investigates first to what extent UML is suited for modeling functions. We survey various approaches to function modeling with UML and identify their limitations. Based on the conducted analysis, we introduce a UML profile for function modeling, called the Function Modeling Language (FueL). FueL enables the modeling of the structure of functions, of relations between functions, such as function decomposition, as well as of function ascription, i.e., of relations linking functions with other types of entities. The main application field that we considered while developing FueL is bioinformatics. Nonetheless, the presented profile is domain-independent and is capable of modeling cross-domain systems. The profile has been tested on fragments of the Molecular Function Ontology, a sub-ontology of the Gene Ontology. In this connection the paper further demonstrates that the applications of FueL transcend the construction of new models, by showing how the profile aids restructuring and refactoring existing models.

This paper proposes a mathematical model to verify a reverse engineering approach which converts a form fill format document into a UML class diagram. The proposed approach used to convert a form fill format document into a UML class diagram consists of the following phases. The first phase is the capturing process that scans the form document and identifies the form components into tables; the second step is the normalization process that normalizes the tables in the first phase. The third phase is the mapping process to construct and build the relationship diagram. Finally, the translation process is conducted to construct and build the class diagrams. To verify the correctness of algorithms Interpreted Perti Nets Models will be generated to implement the proposed transformation processes (i.e. Capturing, normalization, mapping, and translation process). This verification is done because the importance of this approach as a helpful algorithm for researchers and practitioners in the Software Engineering field, since most of the reverse engineering approaches are based on source code. This approach is tested by using several word form fill format documents and shows a significant result.

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.

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.

UML has become a de-facto standard for design and development of object-oriented systems. On the other hand, UML includes various diagrams and notations which are missing of formal semantics. There does not exist much work to transform completely UML models to executable codes by any of the computer-aided software engineering tools because of the hidden semantics under the UML diagrams. Moreover, UML models cannot be used for automated analysis for validation and verification of the systems. Therefore, an integration of UML and semantics-based techniques such as formal methods is required to overcome such type of issues. Further, proof of correctness of software models plays a key role to ensure the quality of the final system to be developed. This paper presents a systematic method for transformation and verification of UML sequence diagrams into Z specification. The method works by translating and analysing few important combined fragments of sequence diagrams using Z notation. At first, formal specification of primary constructs is provided by capturing the hidden semantics under the diagram. Formal analysis of interaction operators namely options, alternatives, loops and break of the fragments is provided. The combined fragments are important because it allows multiple scenarios to increase an expressive power of sequence diagram by various control flows. Finally, formal analysis is provided by Z/Eves tool to check the syntax, type and proof for consistency and correctness of the specification.

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.

The unified modeling language (UML) is one of the most commonly used modeling languages in the software industry. It simplifies the complex process of design by providing a set of graphical notations, which helps express the objectoriented analysis and design of software projects. Although UML is applicable to different types of systems, domains, methods, and processes, it cannot express certain problem domain needs. Therefore, many extensions to UML have been proposed. In this paper, we propose a framework for integrating the UML extensions and then use the framework to propose an integrated unified modeling language-graphical (iUML-g) form. iUML-g integrates the existing UML extensions into one integrated form. This includes an integrated diagram for UML class, sequence, and use case diagrams. The proposed approach is evaluated using a case study. The proposed iUML-g is capable of modeling systems that use different domains.

The aim of this paper is to propose an augmented framework for verifying and validating the static aspect of safety critical systems by analysing the UML class diagrams and the relationship between them. Since UML is a semi formal language which is provn to ambiguities due to its various graphical notations, hence Formal analysis of UML class diagram is required. Moreover, class diagram play an important role in system designing phase especially in safety critical systems. Any ambiguity or inconsistency in design can result in potential failure. Formal methods are the mathematical tools and methodology which are sandwiched at various stages of software development process to ensure the correctness, consistency and completeness of software artifacts such as requirement specifications, design etc. In this article, Z notation is used for the purpose of analysis formally and later on verified by the Z/EVES tool.

Software development life cycle is a structured process, including the definition of user requirements specification, the system design, and programming. The design task comprises the transfer of natural language specifications into models. The class diagram of Unified Modeling Language has been considered as one of the most useful diagrams. It is a formal description of user's requirements and serves as inputs to the developers. The automated extraction of UML class diagram from natural language requirements is a highly challenging task. This paper explains our vision of an automated tool for class diagram generation from user requirements expressed in natural language. Our new approach amalgamates the statistical and pattern recognition properties of natural language processing techniques. More than 1000 patterns are defined for the extraction of the class diagram concepts. Once these concepts are captured, an XML Metadata Interchange file is generated and imported with a Computer-Aided Software Engineering tool to build the corresponding UML class diagram. Copyright © 2015 John Wiley & Sons, Ltd.

Context: UML software development relies on different types of UML diagrams, which must be consistent with one another. UML Synthesis techniques suggest to generate diagram(s) from other diagram(s), thereby implicitly suggesting that input and output diagrams of the synthesis process be consistent with one another. Objective: Our aim is to provide a comprehensive summary of UML synthesis techniques as they have been described in the literature to date to then collect UML consistency rules, which can then be used to verify UML models. Method: We performed a Systematic Mapping Study by following well-known guidelines. We selected 14 studies by means of a search with seven search engines executed until January, 2018. Results: Researchers have not frequently published papers concerning UML synthesis techniques since 2004. We present a set of 47 UML consistency rules collected from the different synthesis techniques analyzed. Conclusion: Although UML diagrams synthesis doesn’t seem to be an active line of research, it is relevant since synthesis techniques rely on enforcing diagram consistency, which is an active line of research. We collected consistency rules which can be used to check UML models, specifically to verify if the diagrams of a model are consistent with one another.

In this chapter, we finish our coverage of UML 2.5 behavioral modeling by concentrating on State Machine Diagrams . The State Machine Diagrams within UML 2.5 focus on states, events, and the triggered transitions between states.

In this chapter, we will cover what you need to know what you need to know about the unified modeling language (UML) 2.5 specification, the organization of UML, some modeling basics, and the UML diagrams.

Many researches to testing object-oriented systems (OOSs) have been proposed for the past decade. After all, almost all large OO software specifications still contain incompleteness, inconsistency, and ambiguity. The framework can be defined using any state-based specification notation and used to derive test cases from state-based specifications in this paper, it is demonstrated using the RSML notation. A state transition diagram (STD) derived from RSML specification provides a complete behavior of a given OOS. System testing is concerned with testing an entire system based on its specifications. In the context of object-oriented, UML development, this means that system test requirements are derived from UML analysis artifacts such as use cases, their corresponding sequence and collaboration diagrams, class diagrams. The goal is here to support the derivation of functional system test requirements, which will be transformed into test cases once we have detailed design information. In this paper, we describe a methodology in a practical way and illustrate it with an example. In this paper a framework that formally defines test data sets and their relation to the operations in a specification and to other test data sets, providing structure to the testing process.

Software interoperability and application integration can be realized through using their respective conceptual data models, which may be represented in different conceptual data modeling languages. Such modeling languages seem similar, yet are known to be distinct. Several translations between subsets of the languages' features exist, but there is no unifying framework that respects most language features of the static structural components and constraints. We aim to fill this gap. To this end, we designed a common and unified ontology-driven metamodel of the static, structural components, and constraints in such a way that it unifies ER, EER, UML Class Diagrams v2.4.1, and ORM and ORM2 such that each one is a proper fragment of the consistent metamodel. The paper also presents some notable insights into the relatively few common entities and constraints, an analysis on roles, relationships, and attributes, and other modeling motivations are discussed. We describe two practical use cases of the metamodel, being a quantitative assessment of the entities of 30 models in ER/EER, UML, and ORM/ORM2, and a qualitative evaluation of inter-model assertions.

The research, development and applications of software measurement have been carried out for more than forty years. Many researchers have done much in it, obtained lots of theoretical results, and developed a series of practical applications. At present, with the rapid development of object-oriented technology used in software theories and application, how to measure software in an effectively and scientifically way is becoming a hot and difficult issue. Class diagram as the most important UML model, its reasonable design has a remarkable effect on the ultimate system. This paper applies information entropy-based multi-attribute decision in UML class diagram metrics, providing a method to measure UML class diagram complexity weights. Its attributes out of information entropy and attributes’ weigh vectors can measure the complexity of objectoriented software effectively and scientifically. Besides, case analysis can prove this metric’s usability. The more precise experiment outcome has proved that the method is connected to human’s experience, and also can be applied to improve software quality.

In the present work, we describe a procedure and a prototype implementation for the automatic recognition of design patterns from documentation of software artefacts design and implementation, provided in a machine readable form, namely, the XML Metadata Interchange XMI coded representation of UML class diagrams. The procedure exploits a semantic representation of the patterns to be recognized, based on an existing Web Ontology Language OWL, known as object design ontology layer ODOL, defined by the University of Massey New Zealand, which has been augmented with an OWL-S based representation of the patterns' dynamic behaviour. Both the UML set of diagrams related to the analysed software artefacts and the ODOL+OWL-S patterns representation are automatically scanned and translated into a first-order logic representation namely Prolog. A set of first-order logic rules, independent from the specific pattern to be recognized, has been defined to describe the heuristics and features which trigger the recognition, exploiting the Prolog description of the patterns to be recognized and the base of Prolog facts, which represents the UML documentation. Copyright © 2015 John Wiley & Sons, Ltd.

Unified Modeling Language UML activity diagrams are widely used to model concurrent interaction among multiple objects. In this paper, we propose a transformation-based approach to generating scenario-oriented test cases for applications modeled by UML activity diagrams. Using a set of transformation rules, the proposed approach first transforms a UML activity diagram specification into an intermediate representation, from which it then constructs test scenarios with respect to the given concurrency coverage criteria. The approach then finally derives a set of test cases for the constructed test scenarios. The approach resolves the difficulties associated with fork and join concurrency in the UML activity diagram and enables control over the number of the resulting test cases. We further implemented a tool to automate the proposed approach and studied its feasibility and effectiveness using a case study. Experimental results show that the approach can generate test cases on demand to satisfy a given concurrency coverage criterion and can detect up to 76.5% of seeded faults when a weak coverage criterion is used. With the approach, testers can not only schedule the software test process earlier, but can also better allocate the testing resources for testing concurrent applications. Copyright © 2015John Wiley & Sons, Ltd.

Refactoring is an important software development process involving the restructuring of a model to improve its internal qualities without changing its external behavior. In this paper, we propose a new approach of model refactoring based on the combined use of UML, B and CSP. UML models are described by class diagrams, OCL constraints, and state machine diagrams. We detail a refactoring pattern that allows for the introduction of an association relationship between two existing classes. We illustrate our proposal by giving a case study involving the SAAT (Software Architecture Analysis Tool) system.

As the rapid development of modern society, it's hard for traditional workflow technologies to meet the variant requirements inside an enterprise. The research focus of workflow technology has been moved to flexibly adjustable workflow models that can easily and fast adapt to business change. In terms of this point, a flexible workflow model is put forward based on the UML technology. Several UML diagrams, such as class diagram, activity diagram and sequence diagram, are introduced to illustrate both model elements and detailed working mechanism of the workflow model. In addition, the strategy of flexible adaption is proposed to deal with changes. Based on this model, a general-purpose system of project application and review is designed and implemented, which is able to adapt flexibly to the business flow changes of project applying after putting into use.

At the early stage of software lifecycle, the complexity measurement of UML class diagrams plays an important role in software development, testing and maintenance, and provides guidance for developing high quality software. In order to study which one is better, simple or complex metrics, this paper analyzes and compares four typical metrics of UML class diagrams from experimental software engineering view points. Understandability, analyzability and maintainability were classified and predicted for 27 class diagrams related to a banking system by means of algorithm C5.0 within the famous toolkit Weka. Results suggest that the performance of simple metrics is not inferior to that of complex metrics, in some cases even better than that of complex metrics.

UML Diagrams are considered as a main component in requirement engineering process and these become an industry standard in many organizations. UML diagrams are useful to show an interaction, behavior and structure of the system. Similarly, in requirement engineering, formal specification methods are also being used in crucial systems where precise information is required. It is necessary to integrate System Models with such formal methods to overcome the requirements errors i.e. contradiction, ambiguities, vagueness, incompleteness and mixed values of abstraction. Our objective is to integrate the Formal Specification Language (Z) with UML Sequence diagram, as sequence diagram is an interaction diagram which shows the interaction and proper sequence of components (Methods, procedures etc.) of the system. In this paper, we focus on components of UML Sequence diagram and then implement these components in formal specification language Z. And the results of this research papers are complete integrated components of Sequence diagram with Z schemas, which are verified by using tools and model based testing technique of Formal Specifications. Results can be more improved by integrating remaining components of Sequence and other UML diagrams into Formal Specification Language.

Context Awareness is the mechanism through which systems can adapt to the needs of a user by monitoring the context. Context includes environment, spatial, temporal, etc information that is used to infer the current activity. UML is used to design a context aware system. The context aware system is viewed as an Object Oriented software product. The UML model is generated through ArgoUML, a free UML modelling tool. The Use Case Diagram, the Sequence Diagrams and the Class Diagram are modelled using this tool. The Class Diagram is subjected to CK metrics to identify the strengths and weaknesses of the design. The measurements show that the proposed model is within the recommended range.

The UML model of database is a frame foundation of developing a database, this paper recommends a way to build data model based on the urban heating pipe networks by using VISIO[1] modeling tools. There are two ways that Use Case Diagram and Static Structure Diagram. The article describes the function of database application system, data structure and relationship on the heating-pipe network. The data structure model makes it more clear and lower redundancy when the developers are developing an application system of 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.

In model driven architecture (MDA), system requirements are first captured by UML (unified modeling language) use cases with sequence diagrams to describe their intended use and implemented by classes of objected-oriented languages in the subsequent design stages. It is important that the dynamic behavior specified by the sequence diagrams is in full compliance with the implementation classes. This paper proposes an automatic approach and tool support for generating class contracts, which define a precondition and a postcondition for each operation of the class. The former serves as a guard to ensure invocations of the operations respect the semantics introduced by the sequence diagrams, and the latter places the system in a legal state to facilitate the succeeding operation calls. The contracts can be easily mapped to code of an object-oriented language such as Java. Thus, the approach helps to bridge the gap between the requirements and design stages of system development process. We use our model transformation tool to first generate a UML protocol state machine from the sequence diagrams, and then derive the contracts for a controller class. The transformations take into account the concurrency and critical constructs of the respective UML diagrams.

A Business Process (BP) is defined to be a set of activities and tasks that is undertaken in some specified partial order to achieve an organizational goal. The validation of a BP is crucial for this goal to be achieved. The Unified Modeling Language (UML) Activity Diagram (ACT) is one of several ways of modeling a BP. Petri Nets (PNs) offer a more formal BP modeling language that also supports validation. A special class of PNs, called Workflow-Nets (WFNs), is specifically used to define a sound BP that is deadlock-free and bounded. The application of this definition requires a BP in the UML ACT form to be converted to a WFN. There are several proposed transformation algorithms from an ACT to an equivalent WFN representation in the literature. However, transforming a BP to an equivalent WFN requires knowledge of both the ACT and the WFN formalisms, and the transformation is also time consuming. This paper proposes a set of three structural rules for an ACT model of a BP to ensure the soundness property. The rules also help identify the errors if soundness of a BP cannot be established. We show that these structural rules are necessary for a sound BP modeled by the UML ACT. An illustrative example is also presented.

Unified Modeling Language (UML) is the most comprehensive and widely accepted object-oriented modeling language due to its multi-paradigm modeling capabilities and easy to use graphical notations, with strong international organizational support and industrial production quality tool support. However, there is a lack of precise definition of the semantics of individual UML notations as well as the relationships among multiple UML models, which often introduces incomplete and inconsistent problems for software designs in UML, especially for complex systems. Furthermore, there is a lack of methodologies to ensure a correct implementation from a given UML design. The purpose of this investigation is to verify and validate software designs in UML, and to provide dependability assurance for the realization of a UML design. In my research, an approach is proposed to transform UML diagrams into a semantic domain, which is a formal component-based framework. The framework I proposed consists of components and interactions through message passing, which are modeled by two-layer algebraic high-level nets and transformation rules respectively. In the transformation approach, class diagrams, state machine diagrams and activity diagrams are transformed into component models, and transformation rules are extracted from interaction diagrams. By applying transformation rules to component models, a (sub)system model of one or more scenarios can be constructed. Various techniques such as model checking, Petri net analysis techniques can be adopted to check if UML designs are complete or consistent. A new component called property parser was developed and merged into the tool SAM Parser, which realize (sub)system models automatically. The property parser generates and weaves runtime monitoring code into system implementations automatically for dependability assurance. The framework in the investigation is creative and flexible since it not only can be explored to verify and validate UML designs, but also provides an approach to build models for various scenarios. As a result of my research, several kinds of previous ignored behavioral inconsistencies can be detected.

In this paper proposes an approach to the search for program solutions for software project or module. The initial data for the search are the class diagram of the developing project and the names of the public libraries structural elements. Search can be carried out among projects from public repositories and organizations internal repositories. The paper contains the structure of the ontology of the UML language and several design patterns presented in the ontology. The rules, nuances and examples of transferring an architectural solution to ontology are given. An example of proposed approach applying to the problem of searching architectural solutions for integration with the social network API is considered. The paper comprises an analysis of the results, conclusions and directions for further research.

This paper introduces our approach to a real-time synchronous collaborative modeling of software systems using 3D UML in a way similar to shared Google Document online with the aim to reduce the complexity of UML models and to increase work efficiency. In our approach, we decided to visualize the system with 2D UML diagrams on interconnected layers containing components (in class diagrams) or use case scenarios of the system (in sequence or activity diagrams) in 3D space. The goal of our method is to improve user's awareness of other developers in a multi-user workspace, adjust redundant components and visualize the history of user's actions in the UML class diagrams.

Existing domain ontologies are a source of domain knowledge about the specific areas of interest. The article presents a prototype tool for semantic validation of UML class diagrams. A knowledge base for validating the diagram is the domain ontology expressed in OWL 2 selected by the user of the tool. The tool automatically recognises if the diagram is compliant, not contradictory or contradictory to the selected domain ontology. Additionally, it proposes a set of suggestions what should be corrected in the class diagram in order for the diagram to more adequately reflect the needed domain.

We propose a novel approach for visualizing reverse-engineered Unified Modeling Language (UML) diagrams (class, object, and sequence) to improve Object-Oriented Program (OOP) comprehension on a web-based programming environment, JaguarCode. It aims to help students better understand static structure and dynamic behavior of Java programs and object-oriented programming concepts. This paper presents an evaluation of JaguarCode, supporting those UML diagrams to investigate its effectiveness and user satisfaction. The results of the experimental study revealed having synchronized UML diagrams positively impacted students' understanding of program execution. It was also observed that students were satisfied with the aspects of the synchronized visualizations of UML diagrams with source code.

It is very convenience to use the combination of design patterns as a key participant when on programming. However, in the methods of combination design patterns at present, there are several existing description methods often apply to one or several simple patterns. They are weak in supporting the combination of design patterns and the application tools; In this paper we use a new extension technology to describe the combination of design patterns by choosing the correct patterns, defining stereotypes, defining tagged values and constraints as well as an extending transform process. An instance described by the new UML extension technology, shows critical description points on how stereotypes involved in the combination of design patterns as well as methods and attributes of the classes, which made the class diagrams more comprehensive, and the transformation of model easier to be realized. The new UML extension technology has the advantages such as intuitive, full description, models transformation easily etc.

In software development, requirements, normally written in natural language, are documents that specify what users want in software products. Software developers then analyze these requirements to create domain models represented in UML diagrams in an attempt to comprehend what users need in the software products. These domain models are usually converted into design models and finally carried over into classes in source code. Thus, domain models have an impact on the final software products. However, creating correct domain models can be difficult when software developers are not skilled. Moreover, even for skilled developers, when requirements are large, wading through all requirements to create domain models can take times and might result in errors. Therefore, researchers have studied various approaches to apply natural language processing techniques to transform requirements written in natural language into UML diagrams. Those researches focus on requirements written in English. This paper proposes an approach to process requirements written in Thai to extract UML class diagrams using natural language processing techniques. The UML class diagram extraction is based on transformation rules that identify classes and attributes from requirements. The results are evaluated with recall and precision using truth values created by humans. Future works include identifying operations and relationships from requirements to complete class diagram extraction. Our research should benefit Thai software developers by reducing time in requirement analysis and also helping novice software developers to create correct domain models represented in UML class diagram.

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.

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.