An Analysis and New Methodology for Reverse Engineering of UML Behavioral

The emergence of Unified Modeling Language (UML) as a standard for modeling systems has encouraged the use of automated software tools that facilitate the development process from analysis through coding. Reverse Engineering has become a viable method to measure an existing system and reconstruct the necessary model from its original. The Reverse Engineering of behavioral models consists in extracting high-level models that help understand the behavior of existing software systems. In this paper we present an ongoing work on extracting UML diagrams from object-oriented programming languages. we propose an approach for the reverse engineering of UML behavior from the analysis of execution traces produced dynamically by an object-oriented application using formal and semi-formal techniques for modeling the dynamic behavior of a system. Our methods show that this approach can produce UML behavioral diagrams in reasonable time and suggest that these diagrams are helpful in understanding the behavior of the underlying application

BENCHMARKING METODE RANCANG BANGUN WATERFALL DAN PEMODELAN BERBASIS OBJEK

This research is a research Benchmarking Waterfall Design Method and Object-Based Modeling. Software development has many models, software methodologies have evolved from time to time, including the Waterfall approach and the UML (Unified Modeling Language) approach. Waterfall is a software development model that is carried out sequentially and very systematically. Meanwhile, UML is a visual modeling method that serves as a means of designing object-oriented systems. The difference between the two models is that Waterfall is a structured method, while UML is a system analysis method, a representation of the programming method. This study aims to perform a comparison or benchmarking of each of these software models, which can assist in determining the most suitable model for the current software development process. The method used in this research is descriptive quantitative method, which analyzes data by describing or describing the data that has been collected as it is. From the results of this study, it can be concluded that the UML method is most suitable for software development, because UML in terms of development, is a method that has undergone evolution from previous methods, so this method can follow the use of users in designing projects on a medium to large scale. That are relevant to the current development

Business Modeling with the Support of Multiple Notations in Requirements Engineering

Requirements specification should not be concerned only with the software specification, but should also be able to integrate with the organizational models describing the environment in which the system will function. Agent–oriented conceptual modeling notations such as i* represents an interesting approach for modeling early phase requirements which includes organizational contexts, stakeholder intentions and rationale. Business Process Modeling notations such as BPMN are used to effectively conceptualize and communicate important process characteristics to relevant stakeholders. On the other hand, Unified Modeling Language (UML) is suitable for later phases of requirement capture which usually focus on completeness, consistency, and automated verification of functional requirements for the new system. In this paper, we illustrate the use of a methodology that facilitate and support the combined use of notation for modeling requirement engineering process in a synergistic fashion in a complex project for a large government Department. The notations we used were i*, BPMN and UML Use Case

A Graph Transformation Approach for Modeling and Verification of UML 2.0 Sequence Diagrams

Unified Modeling Language (UML) 2.0 Sequence Diagrams (UML 2.0 SD) are used to describe interactions in software systems. These diagrams must be verified in the early stages of software development process to guarantee the production of a reliable system. However, UML 2.0 SD lack formal semantics as all UML specifications, which makes their verification difficult, especially if we are modeling a critical system where the automation of verification is necessary. Communicating Sequential Processes (CSP) is a formal specification language that is suited for analysis and has many automatic verification tools. Thus, UML and CSP have complementary aspects, which are modeling and analysis. Recently, a formalization of UML 2.0 SD using CSP has been proposed in the literature; however, no automation of that formalization exists. In this paper, we propose an approach on the basis of the above formalization and a visual modeling tool to model and automatically transform UML 2.0 SD to CSP ones; thus, the existing CSP model checker can verify them. This approach aims to use UML 2.0 SD for modeling and CSP and its tools for verification. This approach is based on graph transformation, which uses AToM3 tool and proposes a metamodel of UML 2.0 SD and a graph grammar to perform the mapping of the latter into CSP. Failures-Divergence Refinement (FDR) is the model checking tool used to verify the behavioral properties of the source model transformation such as deadlock, livelock and determinism. The proposed approach and tool are illustrated through a case study

Engineering Enterprise Software Systems with Interactive UML Models and Aspect-Oriented Middleware

Large scale enterprise software systems are inherently complex and hard to maintain. To deal with this complexity, current mainstream software engineering practices aim at raising the level of abstraction to visual models described in OMG’s UML modeling language. Current UML tools, however, produce static design diagrams for documentation which quickly become out-of-sync with the software, and thus obsolete. To address this issue, current model-driven software development approaches aim at software automation using generators that translate models into code. However, these solutions don’t have a good answer for dealing with legacy source code and the evolution of existing enterprise software systems. This research investigates an alternative solution by making the process of modeling more interactive with a simulator and integrating simulation with the live software system. Such an approach supports model-driven development at a higher-level of abstraction with models without sacrificing the need to drop into a lower-level with code. Additionally, simulation also supports better evolution since the impact of a change to a particular area of existing software can be better understood using simulated “what-if” scenarios. This project proposes such a solution by developing a web-based UML simulator for modeling use cases and sequence diagrams and integrating the simulator with existing applications using aspect-oriented middleware technology

Use of UML 2.1 to model multi-agent systems based on a goal-driven software engineering ontology

In this paper, we present the use of UML 2.1 to model multi-agent systems based on a goal-driven software engineering ontology. The lack of an efficient standardized modeling language is evident. The uses of UML and stereotypes UML to model multi-agent systems have been proposed. However, there are still a number of issues with the existing approaches due to inconsistent semantics of the existing UML diagrams and unintuitive and complext notations. UML 2.1 allows representing more complex scenarios and introducing greater details into the modeling process enabling effective capture and representation of multi-agent actions and interactions. UML 2.1 has not only enabled the introduction of a notation for the Ontology based multi-agent systems, but also effective capture and representation of the dynamic processes associated with these Ontology based multi-agent systems

Foundations of the Unified Modeling Language.

Object-oriented analysis and design is an increasingly popular software development method. The Unified Modeling Language (UML) has recently been proposed as a standard language for expressing object-oriented designs. Unfortunately, in its present form the UML lacks precisely defined semantics. This means that it is difficult to determine whether a design is consistent, whether a design modification is correct and whether a program correctly implements a design. Formal methods provide the rigor which is lacking in object-oriented design notations. This provision is often at the expense of clarity of exposition for the non-expert. Formal methods aim to use mathematical techniques in order to allow software development activities to be precisely defined, checked and ultimately automated. This paper aims to present an overview of work being undertaken to provide (a sub-set of) the UML with formal semantics. The semantics will facilitate the use of the UML in the software development process by allowing development steps to be defined and checked