Recursion Aware Modeling and Discovery For Hierarchical Software Event Log Analysis (Extended)

This extended paper presents 1) a novel hierarchy and recursion extension to the process tree model; and 2) the first, recursion aware process model discovery technique that leverages hierarchical information in event logs, typically available for software systems. This technique allows us to analyze the operational processes of software systems under real-life conditions at multiple levels of granularity. The work can be positioned in-between reverse engineering and process mining. An implementation of the proposed approach is available as a ProM plugin. Experimental results based on real-life (software) event logs demonstrate the feasibility and usefulness of the approach and show the huge potential to speed up discovery by exploiting the available hierarchy.Comment: Extended version (14 pages total) of the paper Recursion Aware Modeling and Discovery For Hierarchical Software Event Log Analysis. This Technical Report version includes the guarantee proofs for the proposed discovery algorithm

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

Towards the use of sequence diagrams as a learning aid

Comunicação apresentada no "Sixth Program Visualization Workshop", Darmstadt (Alemanha), Junho de 2011Compared to imperative programing, object-oriented programming brings additional complexities. These complexities are especially challenging for the novice and, as a consequence to the teacher. Hence, it is no surprise that the teaching and learning of object-oriented programming is an extremely popular topic in computer science education research. This work in progress paper presents the objectives and structure of a tool under development for novice object-oriented programmers that intends to ease code understanding. That is accomplished through the use of sequence diagrams, one of the most popular behavior diagrams in the Unified Modeling Language (OMG, 2011), the de facto standard for object- oriented modelling. More specifically, the tool allows the generation of execution traces as sequence diagrams: for a given program run, the student is able to visualize the respective execution as a sequence diagram. Next, we present the Java2Sequence tool

Towards Dynamic Reverse Engineering Visual Contracts from Java

Visual contracts provide a concise and intuitive representation of preand postconditions for operations in object-oriented or component-based systems, which can be used for documentation, testing, or simulation. However, defining visual contracts to correctly describe the behaviour of existing classes or components requires a deep understanding of their data model and behaviour.We propose an approach to automatically extract instantiated versions of visual contracts, or contract instances, by observing the changes an operation performs on the objects in a system. We describe and evaluate the approach and tool to extract contract instances using the case study of Java-based DOM implementation NanoXML

Ensuring behavioural equivalence in test-driven porting

In this paper we present a test-driven approach to porting code from one object-oriented language to another. We derive an order for the porting of the code, along with a testing strategy to verify the behaviour of the ported system at intra and inter-class level. We utilise the recently defined methodology for porting C++ applications, eXtreme porting, as a framework for porting. This defines a systematic routine based upon porting and unit-testing classes in turn. We augment this approach by using Object Relation Diagrams to define an order for porting that minimises class stubbing. Since our strategy is class-oriented and test-driven, we can ensure the structural equivalence of the ported system, along with the limited behavioural equivalence of each class. In order to extend this to integration-level equivalence, we exploit aspect-oriented programming to generate UML sequence diagrams, and we present a technique to compare such automatically-generated diagrams for equivalence. We demonstrate and evaluate our approach using a case study that involves porting an application from C++ to Java

Ensuring behavioural equivalence in test-driven porting

In this paper we present a test-driven approach to porting code from one object-oriented language to another. We derive an order for the porting of the code, along with a testing strategy to verify the behaviour of the ported system at intra and inter-class level. We utilise the recently defined methodology for porting C++ applications, eXtreme porting, as a framework for porting. This defines a systematic routine based upon porting and unit-testing classes in turn. We augment this approach by using Object Relation Diagrams to define an order for porting that minimises class stubbing. Since our strategy is class-oriented and test-driven, we can ensure the structural equivalence of the ported system, along with the limited behavioural equivalence of each class. In order to extend this to integration-level equivalence, we exploit aspect-oriented programming to generate UML sequence diagrams, and we present a technique to compare such automatically-generated diagrams for equivalence. We demonstrate and evaluate our approach using a case study that involves porting an application from C++ to Java

Extracting UML Class Diagrams from Object-Oriented Fortran: ForUML

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

Evolution Of Object-Oriented Methods From The Reverse Engineering Of Programming Code

Many software development projects fail because of their inability to deliver the product in a timely and cost-effective manner, i.e. the software crisis. In a commercial airline company, a safety-critical system for preventing a “single-point of failure” needs to be developed and certified. To meet the project deadline an Agile approach was used in developing the first portion of the system. An appropriate software development methodology, i.e. reverse-engineering was then applied to the software system to develop method that would be used in system maintenance and evaluation. The goals of this research study were to develop a segment of one of the UML activity diagrams as a purposeful and systematic methodology for conducting reverse-engineering on complete safety critical systems of the airline system. This was done to capture very high and very low-level designs of software engineering and to verify and validate the source code. The UML activity diagram was developed from a source code of an aircraft-gate assignment system. This was done in order to capture very low-level details of the program code, from which the model was reversed engineered. The diagram was made to represent the entire source code, by going through and analyzing the source code line-by-line. Whenever there is a condition in the source code, the diagram branches out and interacts with other activities. To directly see the flow of the program, the directional arrows in the diagram were assigned. With the data flow of the source code being represented in the visual format of the UML activity diagram, the interaction of each component can be easily understood and identified. The user can see the information that goes into each method, and what each method required. Once the user understands the flow of data within the program, the user can validate and verify that the software was developed with correct methods. As the UML activity diagram represented the pseudo code of the program in a graphic way, it should be a good candidate to be used as a tool to help in reverse-engineering safety critical systems of an airline system. The UML activity diagram should be able to represent all aspects required in the deconstruction phrase of the reverse-engineering methodology. With the source code in the graphic diagram form, it should be much easier to identify the structure, functions and determine how each aspect of the program interact with each other so that the activity diagram can be used in a formal methodology for reverse-engineering