US8381188B2

US8381188B2 - Leveraging the relationship between object IDs and functions in diagnosing software defects during the post-deployment phase

Info

Publication number: US8381188B2
Application number: US12/631,549
Authority: US
Inventors: Kurian John; Kamala Parvathanathan
Original assignee: International Business Machines Corp
Current assignee: International Business Machines Corp
Priority date: 2009-12-04
Filing date: 2009-12-04
Publication date: 2013-02-19
Also published as: US20120166884A1; US20110138360A1; US8381190B2

Abstract

A hashing tool can be used to generate Object UIDs from a software application. The software application can be tested. A change and release management system can receive Object UIDs involved in a defect uncovered during the testing. The change and release management system can receive names of functions involved in the defect uncovered during the testing and defect fixing. A graphical representation of function names versus Object UIDs for which the defect occurred can be created.

Description

BACKGROUND

The present disclosure relates to the field of software and, more particularly, to leveraging the relationship between object IDs and functions in diagnosing software defects during the post-deployment phase.

After software is bought and used by the end user, there is typically a support process in place to help support the end user. Usually, a support team in the organization accepts the support call and helps the customer depending on the type of support required. There may be different levels of support staff in the support team.

For example, an initial call can be accepted by a support person at the Level 0. This person logs the call and tries to solve the problem at a basic level. If this person cannot help, he or she escalates the issue to the next level, typically to the Level 1 support engineer. The Level 1 support engineer tries to understand the problem, and tries basic configuration help. The problem escalates, for example, to Level 2. At Level 2 the typical problems addressed are related to some advanced configuration or other known issue of the software being unable to co-exist with other software products. The problem escalates to Level 3 if there is a defect or bug, which has to be fixed in the source code of the software application. Different organizations may have different numbers of levels. One of these levels will typically have someone responsible for fixing defects or bugs in software products.

The person at Level 3 who has to fix defects or bugs can have the source code of the software and a change management system to help with addressing the defects. In an organization that uses multiple levels, this top level person leverages all the symptoms articulated by the lower level support people on this case before it gets to him or her. The person who has to fix defects in the source code finds the cause within the source code and fixes the source code to solve the particular problem.

A function verification test (FVT) cycle is a period in time when most of the functionality of a software application is tested during development. This testing is typically done in iterations or cycles so that each FVT cycle catches newer defects. A project plan for software application development may specify that there be one or more function verification testing cycles during the development of the software product. There is an inherent gap in the software development lifecycle and process in that the data collected from the FVT phase is not reused in any other phase, especially in post-sales support.

SUMMARY

There is a lot of information related to every defect which is reported and fixed during the function verification cycle, which can be used by support teams.

Various embodiments provide the usage of tools such as a change and release management tool and a function verification test tool to capture such data and render the data in a format which support teams can more easily interpret to focus in on the causality of issues more quickly. This helps post-sales/post-release support people. This particularly helps support engineers who are new to a particular application.

Some embodiments provide systems and methods to map a symptom of a defect against its cause in a usable format to aid a support team in diagnosing software defects. In some embodiments, an object which has a defect is identified from a functional verification test or tester's report. In some embodiments, a stack trace of a defect is used to determine where the defect emanated in the source code.

Some embodiments provide creating a mapping of an Object UID versus the origin of the defect within the source code. In some embodiments, the mapping is created in a spread sheet, and then a heat map generator is used to scan the spread sheet and generate a heat map to be used by a support team.

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

FIG. 1 is a pictorial flow chart of an exemplary embodiment of a method for handling software defects and a data processing network or system for carrying out the method.

FIG. 2 is a pictorial flowchart showing details of a step of the method of FIG. 1.

FIG. 3 is a pictorial flowchart illustrating use of a product produced by the method of FIG. 1.

DETAILED DESCRIPTION

FIG. 1 illustrates a method in accordance with various embodiments. During application development, such as in a function verification test cycle 12, a test engineer 14 captures a stack of software objects (object unique identifiers or UIDs) which were involved in the failure of a particular test 16 of a software product (application) 18.

A stack can be a last in, first out (LIFO) data structure. An object can be a component of a software program that knows how to perform certain actions and to interact with other pieces of the program. An object can have a set of data along with methods for manipulating that data. The objects described herein can be, for example, objects for graphical user interfaces.

Object UIDs for various objects in the software 18 can be generated using the method and system described below in connection with FIG. 2.

In the embodiments illustrated in FIG. 1, the Object UIDs (which are generated from the hashing process) along with the defects are entered 20 in a change and release management (or source code management) system 22 (e.g., by the tester). Typically, when a software product is built, source code and defects are tracked in a change and release management (CRM) or source code management (SCM) system 22 such as, for example, Bugzilla™, Rational ClearCase™ or Rational ClearQuest™. The change management system 22 is used so that stakeholders can communicate with each other about defects that are found and the changes to the source code which will result. Change management systems are typically used during the period when a software product is being developed.

More particularly, in the illustrated embodiment, the

Object UIDs

24, 25, 26 etc. of objects involved in a defect are received and recorded (stored in a database) by the change and release management system 22. In some embodiments, the change and release management system 22 has a list of all Object UIDs, from the system and method of FIG. 2, and a tester 14 indicates which UIDs were involved with a defect.

A developer 28 who fixes 30 a defect can capture a stack trace and can use the stack trace to determine where the defect potentially emanates in the source code. A stack trace or stack traceback is a report of the functions instantiated by the execution of a program. It keeps track of how local variables change on each invocation of a routine as well as the values that they return. The developer 28 enters 32 the functions involved in a defect in the change and release management system 22. More particularly, the change and release management system 22 receives and records (stores in memory) a list of

functions

34, 35, 36 etc. involved in the defect.

In the illustrated embodiments, a heat map creator tool 38 walks all the defects and maps an exhaustive list 40 of functions in this application 18 to an exhaustive list 42 of object unique identifiers to produce a heat map 44 with function names on one axis and Object UIDs on another axis. The heat map creator 38 walks the defect record and creates a pheromone map from Object UID versus function. In time, more of the occurrences of links between Object UIDs and functions will result in “hotter” areas on the heat map.

In some embodiments, different colors are used to indicate different heat levels. For example, a bright red color may indicate a high occurrence linkage between a particular object and a particular function, a dark green color may indicate a low defect rate, and orange, yellow, and light green colors may indicate intermediate defect rates. Other colors or other graphical or tabular indications of potential problem areas can be used in other embodiments.

The heat map 44 is then stored as an artifact along with code frozen bits (final source code) of this particular software product for later use by support people. In some embodiments, the heat map 44 is a spreadsheet. In some embodiments, the heat map creator 38 and the change and release management system 22 are defined by separate computer devices that are in communication with one another over a network. In other embodiments, the heat map creator 38 and the change and release management system 22 are defined by a single computer device.

FIG. 2 illustrates a system and method for generating the list 42 of all

Object UIDs

24, 25, 26, etc. of FIG. 1, in some embodiments. As illustrated in FIG. 2, a hashing tool 46 is used to create the list 42 of object unique identifiers (UIDs) from the unique characteristics of respective objects (such as elements or objects of a graphical user interface 48). Any one of a variety of functional testing tools 50 can be employed to create these Object UIDs. The lists 42 and 40 (see FIG. 1) of object unique identifiers and functions are captured in the change and release management system 22.

When a defect is reported from the production environment, the support engineer can simulate the defect in his or her own environment. During the process of simulation, the engineer will use the Object UID creation tool which is the hashing tool to generate the Object UID of the Graphical User object which is showing the symptom of the particular defect.

As illustrated in FIG. 3, after the software 18 has been released, higher level support people (e.g., Level 2 and Level 3 support people) are provided access to the heat map 44. These support people, when given a support problem, can look up the heat maps and find out which are the functions that are likely candidates to have created a defect, involving the particular Object UIDS, and solve the problem faster. In some embodiments, the change and release management system 22 and/or the heat map creator 38 and/or a network containing the change and release management system 22 and the heat map creator 38 has an access control, and access is given to a (post-release) customer support person. For example, it may be necessary to use a password to gain access to a network and only certain persons on the network are given permission to access the change and release management system 22 and/or the heat map creator 38, and a customer support person is given such access.

Embodiments of the invention can take the form of entirely hardware elements, entirely software elements or a combination containing both hardware and software elements. In a preferred embodiment, embodiments of the invention are implemented as software elements, which include but are not limited to firmware, resident software, microcode, etc.

Furthermore, embodiments of the invention can take the form of a computer program product accessible from a computer-usable or computer-readable medium providing program code for use by or in connection with a computer or any instruction execution system. For the purposes of this description, a computer-usable or computer readable medium can be any apparatus that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.

The medium can be an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device) or a propagation medium. Examples of a computer-readable medium include a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk and an optical disk. Current examples of optical disks include compact disk—read only memory (CD-ROM), compact disk—read/write (CD-R/W) and DVD.

A data processing system suitable for storing and/or executing program code will include at least one processor coupled directly or indirectly to memory elements through a system bus. The memory elements can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code in order to reduce the number of times code must be retrieved from bulk storage during execution.

Input/output or I/O devices (including but not limited to keyboards, displays, pointing devices, etc.) can be coupled to the system either directly or through intervening I/O controllers.

Network adapters may also be coupled to the system to enable the data processing system to become coupled to other data processing systems or remote printers or storage devices through intervening private or public networks. Modems, cable modems and Ethernet cards are just a few of the currently available types of network adapters.

The description set out above describes particular embodiments only and is not intended to limit the invention, whose scope is determined solely by the claims set out below. As used here, singular forms “a”, “an” and “the” are intended to include plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.

In compliance with the patent statutes, the subject matter disclosed herein has been described in language more or less specific as to structural and methodical features. However, the scope of protection sought is to be limited only by the following claims, given their broadest possible interpretations. The claims are not to be limited by the specific features shown and described, as the description above only discloses example embodiments.

Claims

1. A system comprising:

a function test tool used for testing software applications for defects;

an Object UID creator having a hashing tool generate Object unique identifiers (UIDs) from Graphical User Interface objects of a software application;

a change and release management system receiving and storing Object UIDs of objects involved in the defects uncovered during the testing as well as other Object UIDs from the software application, the change and release management system being further receiving and storing function names involved in the defects as well as other function names; and

a heat map creator generating a heat map that maps the function names versus the Object UIDs for which the defects emanate from, wherein the heat map is used to fix the defects of the software application.

2. The system in accordance with claim 1 wherein the heat map creator is in communication with the change and release management system.

3. The system in accordance with claim 1 and comprising a first computer device defining the heat map creator, and a second computer device, different from the first computer device, defining the change and release management system.

4. The system in accordance with claim 3 wherein the first computer device is in communication with the second computer device.

5. The system in accordance with claim 3 wherein the heat map creator creates the heat map with different colors used to indicate different levels of occurrence linkage between the Object UIDs and the function names.

6. A non-transitory computer program product comprising a computer readable storage medium having computer usable program code embodied therewith, the computer usable program code comprising:

computer usable program code being stored on a non-transitory storage medium, when executed by a processor tests software applications for defects;

computer usable program code being stored on a non-transitory storage medium, when executed by a processor generates Object unique identifiers (UIDs) from Graphical User Interface objects of a software application;

computer usable program code being stored on a non-transitory storage medium, when executed by a processor receives and stores Object UIDs of objects involved in the defects uncovered during the testing as well as other Object UIDs from the software application;

computer usable program code being stored on a non-transitory storage medium, when executed by a processor receives and stores function names involved in the defects as well as other function names; and

computer usable program code being stored on a non-transitory storage medium, when executed by a processor generates a heat map of the function names versus the Object UIDs for which the defects occurred; and

computer usable program code being stored on a non-transitory storage medium, when executed by a processor uses the heat map to fix the defects of the software application.

7. The computer program product in accordance with claim 6 wherein the heat map in used in post-release customer support of the software application.

8. The computer program product in accordance with claim 6 wherein computer usable program code generates the heat map with different colors used to indicate different levels of occurrence linkage between the Object UIDs and the function names.

9. The computer program product in accordance with claim 6 wherein the heat map is protected by access control, wherein the access to the heat map is provided to a customer support person via the access control.

10. A system comprising:

a hashing tool to generate Object unique identifiers (UIDs) from a software application;

a function verification testing tool to test the software application for defects;

a first computing device to:

store Object UIDs involved in the defects uncovered during the function verification test as well as other Object UIDs from the software application; and

store function names involved in the defects determined through the function verification testing tool;

a second computing device, communicatively coupled to the first computing device, to:

create a heat map by mapping the function names versus the Object UIDs for which the defects emanate from, wherein the heat map is used to fix defects of the software application; and

provide access to the heat map in providing customer support, wherein information about the defects learned during software development is made available to customer support using the heat map.

11. The system in accordance with claim 10 wherein the second computing device generates the heat map with different colors used to indicate different levels of occurrence linkage between the Object UIDs and the function names.

12. The system in accordance with claim 10 wherein the heat map is stored along with code frozen bits.

13. The system in accordance with claim 10 wherein the first computing device is a change and release management system.

14. The system in accordance with claim 10 wherein the first computing device is configured to use a stack trace to determine the functions involved in the defect.