Dynamic Information To Maintain Software Tasks

Published Date: 02 Nov 2017

Abstract - An Integrated Development Environment (IDE) is the primary tool used by developers to maintain software system. Modern IDEs such an Eclipse IDE present static view of source code, but such view neglecting information about runtime behaviour of software systems. An approach Senseo used to collect and integrate dynamic information with static view of source code. An intra-procedural control flow model is useful to optimize the time and correctness of software tasks. The software tasks maintained by reduction of time spent and improved the correctness.

Keywords - Object oriented concepts, integrated environments, dynamic analysis, and software maintenance.

I. INTRODUCTION

Software Maintenance is a process of adaptation of a software product after delivery to accurate defects, to increase performance or other attributes, or to adjust the product to a customized environment. Maintenance required certifying that the system continues to satisfy user requirements. Maintenance is appropriate to systems developed using any software development model. The system changed due to corrective and non-corrective software activities. Maintenance must be perform in order to correct errors, correct requirements and design flaws improve the design, Make enhancements, Interface with other systems.

An integrated development environment (IDE) is the primary tool used by developers to maintain software system. An object oriented system concepts like inheritance, abstract types and polymorphism are difficult to understand. Modern IDEs such an Eclipse IDE present static view of source code, but such view neglecting information about runtime behaviour of software systems. To improve an understanding of java based applications employing polymorphism or abstract types to extend the Eclipse IDE to integrate dynamic information. Such information enables the programmer to explore and understand the intra procedural control flow of system to see the runtime types in the source code views that are, for example subtypes of statically defined types. Intra procedural control flow is very useful to optimize the software activities.

The previous work had limited and several flaws. (i) dynamic information was just integrated locally in the source code views on a method level, thus there was no overview of the entire system, (ii) dynamic collaboration between source artefacts, such as packages or classes, was not made visible, and (iii) gathering of dynamic information such as run-time types was inefficient. The source code of application refers to abstract types, while at run time concrete subtypes are used and gathering of dynamic information such as runtime types are inefficient. We use partial behavioural reflection method to collect the dynamic information from java applications. The Ext plug-in is continuously updating the dynamic information to the Eclipse IDE. The intra procedural control flow of system is very useful to optimize the software tasks in the IDEs. In this paper has following contributions, first to integrate the dynamic information to IDEs, Second to analyze what is all the dynamic information to be integrated and finally augment the static view of source with dynamic information in IDEs to maintain the software tasks. As a result dynamic information integrates into IDEs and software activities are maintained by reduction of time spent and improved correctness in software systems.

II. RELATED WORK

1. Augmenting Eclipse with Dynamic Information

The approach is used to enhance static source perspectives of Eclipse with dynamic information such as exact runtime type information or memory and object allocation statistics. Dynamic information can leverage the understanding for the behaviour and structure of a system. The dynamic data congregation is based on aspects to analyze running Java systems. To combine dynamic information into Eclipse a plug-in realized for extending the Eclipse Java Development Toolkit (JDT) called Senseo. The plug-in augments existing IDE tools of Eclipse and several standard views of JDT such as the Package Explorer with dynamic information. Besides these enhancements, Senseo offers several visualizations such as an overview of the association within the software system. The report on the efficiency of approach is to gather dynamic information.

2. Visualizing Calling Context Profiles with Ring Charts

Calling context profiling is a common technique to explore the dynamic behaviour of programs and to find the reasons for performance problems. Calling context profiling yields dynamic metrics separately for each calling context, such as the number of method invocations or the CPU time used to calling context. A calling context is a sequence of methods that were called but have not yet completed; that is, a calling context corresponds to the methods symbolized on the call stack at some moment during program execution. Calling context profiling helps analyse the dynamic inter-procedural control flow of applications. The technique was particularly important for understanding and optimizing object-oriented software, where polymorphism and dynamic binding often hinder static analyses. Typically, object-oriented applications make use of many short methods such that inter procedural control flow can become very complex and focus intra procedural control flow is simple and useful to optimize the results.

3. Dynamic Analysis of Java Programs

A tool *J is a complete system for gathering, computing and presenting metrics from Java programs. The aim is to understand the program behaviour as compiler and runtime system developers, and so solves a number of surprisingly difficult problems. The trace generator produces a stream of program events from a program execution, which is then fed to the analyzer. The analyzer calculates the actual metrics and produces summary information as an XML file which can then be incorporated into a database or viewed using different means. The analyzer in *J processes the generated traces and computes appropriate metrics. The component is itself a pipeline of modular metric computations and other components, and so provides flexibility in trace processing as well as easy modification to the set of analyses. Analysis operations in *J are organized hierarchically as Packs and Operations.

4. Enriching Eclipse’s Static Source Views with Dynamic Metrics

Maintaining object-oriented systems that use inheritance abstract types and polymorphism is difficult, since runtime information, such as which object methods are actually invoked at a call site, is not visible in the static source code. Senseo have been realized, an Eclipse plug-in enhancing static view of source with different dynamic metrics, such as runtime types, the number of objects created, or the size of memory allocated in particular methods. Senseo integrates dynamic information like package tree, ruler columns and mouse hovers enhanced in Eclipse source code views.

III. INTEGRATING DYNAMIC INFORMATION IN IDES

An approach Senseo is to enhance IDEs with dynamic information toward the goal of supporting the understanding of runtime behaviour of applications. First present the architecture of Senseo an Eclipse plug-in implemented. Second discuss different kinds of dynamic information that can support program understanding.

1. Architecture

Dynamic Information can be collected using a Java Virtual Machine (JVM) with a native code interface JVM Tool Interface (JVMTI). For compatibility and portability reasons we choose byte code instrumentation technique. High-level Aspect-Oriented Programming used to identify instrumentation as an aspect. A Senseo plug-in implemented to gather dynamic information from application while the system executed. The application dynamically analysed within the IDE and developers have to execute it with Senseo. Before starting the application developers can define what kind of dynamic information should be gathered at runtime. Senseo aggregate dynamic information over all application runs executed with it, but can clear the store and start once again.

2. Dynamic Information

The Senseo plug-in integrates following dynamic information into IDE.

1 Method invocation, that is, which method was invoked with which receiver and argument types. Then record types are recorded.

2 The number of invocations is recorded to ease location frequently invoked methods or unused code.

3 Developer to locate expensive code with the help of number of created objects.

4 The actual size of created objects is known from memory allocation.

IV. COLLECTING DYNAMIC INFORMATION

Traditional approaches to collecting dynamic information such as tracing is inefficient to provide dynamic data are displayed at runtime in Eclipse IDE. We use an approach known as partial behavioural reflection that enables selective collection of systems runtime information. A full behavioural reflection that reflects every runtime event occurring in a application should be very inefficient. So we need to focus of dynamic analysis and selectively reflect on specific part of application execution.

APPLICATION VIRTUAL MACHINE

MAJOR TOOL

IDENTIFY ASPECTS

DYNAMIC DATA

STORAGE

Fig.1. Setup to gather dynamic information

A partial behavioural reflection model of reflex presents mechanism to select entities and operations. An entity in the model is the link and operations are method invocations of java based applications.

V. RESULTS

In this section, we present detailed experimental results of Senseo plug-in implemented in IDE.

1. Experimental Design

This experiment aims at quantitatively and qualitatively evaluating the impact of Senseo and the dynamic information it integrates in the Eclipse IDE on developer productivity in terms of efficiently and correctly solving typical software maintenance tasks. Therefore we analyze time variable in this experiment. This experiment also exposes which kind of tasks benefit the most from the availability of dynamic metrics in the IDE. The experimental design is opted for similar to the one applied in the study of Cornelissen which evaluated a trace visualizing tool called EXTRAVIS.

Study Hypothesis. We claim that the availability of the Senseo plug-in reduces the amount of time it takes to solve software maintenance tasks. Accordingly, we formulate the following null hypothesis:

H0: Having available Senseo does not impact the time for solving the maintenance tasks.

Congruently, we formulate these two alternative hypotheses:

H1: Having available Senseo reduces the time for solving the maintenance tasks.

2. Subject System and Tasks

As a subject system chosen JEdit4 is an open-source text editor written in Java. JEdit consists of 32 packages with 5275 methods in 892 classes totalling more than 100 KLOC. We selected for JEdit as a subject system as it is medium sized and representative for many software projects found in industry. JEdit has a long history of development period nearly ten years and involving more than ten developers. Even though it has been refactored several times, a careful analysis of the code quality revealed several design flaws, such as the use of

TABLE 1

The Software Maintenance Tasks

Task

Activities

Description

1.1

1.2

A 1, 9

A 1, 4 ,5

Feature understanding on a high architectural level

Describing package collaborations in this feature

2.1

2.2

A 8

A 4, 5, 6, 8

Assessing quality of three classes in terms of their external dependencies

Describing coupling between the packages of these three classes

3.1

3.2

A 1, 2, 4, 5

A 1, 3, 5, 7

Reporting and correcting about message sending and control flow in a class

Locating clients of this class and analyzing their communication paths

deprecated code, tight coupling of many source entities to package-external artefacts, or lack of cohesion in almost all packages, which makes JEdit hard to understand. We imagine many industrial systems to have similar quality problems, thus we consider JEdit to be a compatible subject application fairly usual for many industrial systems developers come across on their job. Furthermore, the domain of a text editor is familiar to everyone, thus no special domain-knowledge is required to understand JEdit.

The tasks gave to the subjects are concerned with analyzing and achieving an understanding for various features of JEdit. While choosing the tasks, main goal was to select tasks representative for real maintenance scenarios. Furthermore, these tasks must not be unfair towards dynamic analysis. To assure that these criteria are met, the selected tasks according to the framework proposed by Pacione. The nine principal activities identified for reverse engineering and software maintenance tasks covering both static and dynamic analysis. Based on these activities several characteristically tasks are proposed including all identified activities. The design of tasks is following this framework to respect all nine principal activities, which avoids a potential bias towards Senseo.

The definition of three tasks, each divided into two subtasks, resulting in six different questions we asked to the subjects. Table 1 outlines all three tasks and their subtasks and explains which of Pacione’s activities they cover. Subjects that can answer the questions quickly might spend considerably more time on the task when they notice that there is still much time available, thus the addition of a time-consuming task at the end which is not considered in the evaluation makes sure that subjects have a constant time pressure for all relevant tasks. The tasks cover all of Pacione’s activities.

The subjects cannot select from multiple choices but have to write a text in their own words. The quality of subjects answers by allotting scores from zero to four for each question. Before starting with the experiments, the two experimenters answered all prepared questions. We compared and combined both solutions to form an answer model which we then used to grade the subjects’ answers.

3. Time Result

On average the Senseo spent 15.5% less time solving the maintenance tasks. The time spent by the two plug-in is visualized as a box plot in Figure 2. To numerically verify whether Senseo has an impact on the time to answer the questions, we test the null hypothesis H0 which says that there is no impact. The Kolmogorov-Smirnov and the Levene test is successfully applied on the time data, thus we are able to apply Student’s t-test to evaluate H0. The application of the t-test allows us to reject the null hypothesis and instead accept the alternative hypothesis, which means that the time spent is statistically significantly reduced by the availability of Senseo as the p-value is with 0.0016 considerably lower than =0.05. We attribute this result to several factors: (i) the availability of dynamic information in the source code views helps developers to more quickly achieve an understanding how source artefacts communicate with each other, (ii) the visualizations of dynamic metrics such as number of method invocations

Fig.2. Comparing time spent between Eclipse and Senseo.

shown in ruler columns and package tree enable developers to quickly spot which source elements are executed and how often, and (iii) as the collaboration view accurately presents all source artefacts that are related or collaborating to a selected source entity such as a package, class or method, developers can more quickly navigate to code relevant for a specific task. Note that Senseo was an unfamiliar plug-in for all subjects, thus the results would be even better if participants had used Senseo in their daily work before doing the experiment

As Senseo can be used to gather dynamic information from java based applications used in the DaCapo suite in reasonable time, we conclude that Senseo is fast enough to cope even with large-sized applications, and it is possible to frequently transmit the collected dynamic information to the Eclipse plug-in, continuously providing up-to-date dynamic information to the software developer.

VI. CONCLUSION

The Senseo is an approach for gathering and integrating various kinds of dynamic information from running Java applications within the Eclipse IDE. The dynamic information provided includes callers, callees; runtime type information, method invocation counters, and objects allocation metrics. Senseo integrates dynamic information in the package tree, the ruler columns, and in the source editor tooltips of the Eclipse IDE.