Researchers Submit Patent Application, "Debugging Method Using Program Inspectors to Debug Programs Developed Using Frameworks and Libraries", for Approval
The patent's assignee is Adobe Systems,inc.
News editors obtained the following quote from the background information supplied by the inventors: "The present disclosure relates, in general, to computers and programming and developing code and programs to be run by computers, and, more particularly, to improved methods for assisting programmers in debugging code when the programmers are using software frameworks, libraries, and/or collections, subroutines, bundles, groups, or the like of previously developed/programmed code to create a software product, program, or application.
"There is a growing trend toward developing or creating software programs or code by utilizing and building upon code previously written or created by others. For example, numerous software providers offer code that may be used to build a software program in the form of software libraries and frameworks that the programmers or developers may include in their new program or software product. To use software libraries, the programmer typically is forced to understand the functionality of each method while frameworks tend to be designed to facilitate software development by allowing programmers or developers to devote their time to meeting desired product functionality rather than dealing with the more standard, low-level details of providing a working software product. For example, the programmer is allowed to focus on higher level operations, such as account withdrawals in a financial application, instead of the mechanics of request handling, state management, and the like.
"In any of these cases, a software developer may be including others' code in their software product or application without fully understanding how each included code set or bundle of code works and operates. The code bases provided by libraries, frameworks, and the like are frequently very complex, and the developer is rarely an expert in programming in the particular language or in understanding how the framework controls process and data flow. Such abstraction of the lower-level details is useful until the time comes when the framework or library or a program built using the code provided in such a code base is not behaving as the developer expected or planned.
"At this point, the framework or developed program may not be able to run at all or runs in unexpected or undesired ways, and the program or framework may have one or more bugs that the developer has to identify and correct. The bug often is caused by some mismatch between the developer's usage of a framework's objects, a library's methods, a sources bundle of code, or the like in their software product, program, or application and the intended or standard usage of such previously developed code. However, since the developer did not write or create the code used from the framework, library, or other code base/source, debugging the framework or other software product is time consuming and, in some cases, impractical for the developer without outside or additional assistance from those intimately knowledgeable about the underlying code."
As a supplement to the background information on this patent application, VerticalNews correspondents also obtained the inventor's summary information for this patent application: "Briefly, a debugging environment and method is described that provides tools (e.g., dynamic program inspectors) that may be invoked from within a debugger to inspect the runtime state of an object or a set/bundle of code within a program. The developer or user of the tools or an inspector control module may act to identify one or more objects or sets of code within a program (such as within a framework) that may be a cause of the problem or that may have one or more bugs. The inspector control module may determine the type of object or set of code for each object or code set that has been identified and then invoke (such as from within the debugger) a subset of the tools or program inspectors based on this object or code set type suited for debugging or inspecting the particular suspected or identified objects or code sets.
"A prioritization module may be used by the inspector control module to receive and prioritize the feedback from the invoked tools or inspectors, and this prioritized feedback may then be provided to the developer or tool user (e.g., via a graphical user interface (GUI) or the like). The feedback helps identify problems or objects that may be acting improperly or in an unanticipated or nonstandard manner, and each issued identified by the program inspectors may be linked to a summary of the potential problem and one or more possible remedies that may be taken by the developer to address the problem or bug (e.g., a brief summary may be displayed with a link to a more detailed explanation of the problem and/or solution that may be accessible via a digital communication network or provided within the same computer system). It is likely that the debugging environment described herein may be valuable in a number of programming environments including framework environments where bugs may be frequently caused by misuses of the framework or simple mistakes for which traditional debugger features offer little or no assistance.
"More particularly, a debugging method is provided for use with computer programs that may include a number of objects. For example, the debugging method may be used to debug a software application that is being generated or developed using a framework from which a developer has chosen or included a number of objects, which correspond to sets or numerous lines of code that has been previously developed and debugged lines of code that work together when used in a conventional/standard manner to provide an intended functionality. The debugging method includes providing a debugging environment (such as an integrated development or debugging environment (IDE)) on a computer system (such as a developer's computer, workstation, network node, or the like). The debugging environment includes a debugger that is run to generate debugging information that may include runtime state information for each of the program components or objects. The library/framework code itself has usually been well debugged by its authors prior to being made available for outside developers. As such, any issues encountered by users of the framework are likely not to appear in a conventional debugger (e.g., as a crash or easily identified localized bug and the code may be free of programming errors that are detected by the debugger).
"The method further may include identifying one of the program components for inspection within the debugging environment, and this may be done by displaying a prompt within the debugger user interface that the developer/user may select to indicate that they think an object is acting improperly (e.g., is behaving in an unintended or nonstandard manner potentially from use of the object in an unintended manner or an object user error) for analysis by a set of program inspectors. The method may also include using an inspector selection module (which may be invoked by the debugger or another software module within the debugging environment) to select a set of program inspectors to perform the inspection of the identified object. The set of program inspectors may be selected by first determining the type of object or program component that has been identified or based upon a type of issue being debugged.
"The method may further include performing the inspection with these program inspectors and outputting (e.g., displaying in a debugging UI, printing to a printer, or the like) a report of the programming issues (e.g., nonstandard usages and so on) identified by the invoked set of program inspectors. Each of the program inspectors may be provided with a script that defines a particular object use error for an object (e.g., incorrect definition of a child, an object use that provides graphic that is not attached to a stage or drawn off stage, a use of a graphic object that produces a transparent graphic, a use that results in missing but expected overrides, or the like), and the script may be run or invoked within the debugging environment to query the object or program component (e.g., to query the debugging information that may include runtime state information on the component or object) to determine whether the object use error is present.
"The report or output provided by the program inspectors may include a brief explanation of the identified programming issues for the object along with a remedial or corrective course of action for each of these issues and, in some cases, a link to a detailed report on the issues and ways to debug these issues (e.g., a URI or the like to a debugging server storing the more detailed explanations and remedies for potential issues). The inspection may include prioritizing the programming errors and presenting the errors in a prioritized manner in the inspector output/report, and in some cases, the priority is based on identifiers/rankings of the inspectors that are indicative of the seriousness or importance of the potential issue identified by the particular inspector/script. In some cases, the programming errors or object use errors may be nonstandard uses of an object or programming component or use that was not intended/expected by the author of the set of code (such as an author of a set of code defining an object within a programming/software framework).
"According to another aspect of the description, a computer program product is provided that includes a computer useable medium and computer readable code embodied on the computer useable medium for causing a debugging of a software product having a number of objects in a framework. The computer readable code may include computer readable program code devices that cause a computer to select, from a plurality of program inspection scripts, a set of inspectors that are applicable to an identified one of the objects. Also, the computer readable code may include computer readable program code devices that cause the computer to invoke the set of inspectors to analyze runtime state information for the identified object. The invoked inspectors or scripts may act to determine whether a definition of a programming error (such as user's misuse or nonstandard use of an object) in the program inspection script of the inspector is satisfied.
"Further, the computer readable code may include computer readable program code devices that cause the computer to generate a report comprising output from the set of inspectors including a description of each of the identified programming errors and an associated programming remedy. In some cases, the computer readable code may also include computer readable program code devices that cause the computer to determine a type associated with the identified object, with the set of inspectors being identified as applicable when they are defined as applicable to the determined type (such as by an included list of relevant objects or object types). In some cases, the computer readable code may also include computer readable program code devices that cause the computer to run a debugger on the software product to generate the runtime state information for the identified object. Further, the code may include computer readable program code devices that cause the computer to generate a user interface and to display the user interface on a monitor, whereby the user interface includes the generated report. In some cases, the code also includes computer readable program code devices that cause the computer to receive user input via the user interface selecting the identified object prior to the selecting of the set of inspectors.
"With the use of the program inspectors/scripts, the runtime state is being inspected and not merely the lines of code or a portion of the program. For example, the inspectors may dynamically query an object, at runtime, about the current state of its members such as expected transitions during execution that are defined by the underlying code set. This is similar in some ways to a debugger showing the user the state of a program's variables, but a difference is that in addition to showing the user the current state of the object's members, there is associated logic (e.g., the inspector script) to inspect the object's state, alter its behavior based on the state it encounters, and then make inferences about the object's state in relation to its notions of the 'normal states' of that object in its current execution context.
"In brief, the program inspectors are not tied to specific lines of code, which could be readily debugged using static analysis of the code in a compiler. Instead, the code describes the creation of objects and then the transitions which should occur to the objects as the program is executing. This allows the debugger to run another program, while the original program is paused in the debugger, using the underlying programs current, e.g., paused, state as input. The additional program (or program inspector) is then, due to the reflexive nature of many languages, able to derive enough information from an object about its type and the current state (or runtime state) of the underlying program to decide what appears to be nonstandard or unanticipated. The program inspector may be thought of as a metaprogram that uses the state of the existing, paused program as input.
BRIEF DESCRIPTION OF THE DRAWINGS
"FIG. 1 illustrates in functional block form a computer system or network that is configured to support debugging processed described herein such as by providing a debugging environment including one or more invoked program inspectors for analyzing sets of code (e.g., multiple lines of code), objects, or the like to identify potential problems or bugs and recommended resolutions or debugging actions.
"FIG. 2 illustrates a flow chart of an exemplary program inspector-based debugging method such as may be implemented, for example, by operation of the system of FIG. 1.
"FIG. 3 illustrates an exemplary user interface as may be provided on a monitor by a debugger of an embodiment described herein such as during operation of the system of FIG. 1 to prompt a user or developer to run program inspectors on an object, component, subroutine, or set of code within a program to identify potential issues or bugs.
"FIG. 4 illustrates a dialog box that may be provided to report or provide inspector/debugger output to a user or developer that selects to run program inspectors on a program.
"FIG. 5 illustrates in functional block form a debugging system or network supporting use of Web-based extensions in a debugging environment (such as an integrated development or debugging environment (IDE)), with the extensions typically including program inspectors accessible within a user community or other source via a communications network.
"FIG. 6 illustrates a Web-based IDE extension method as may be provided by operation of the system or network of FIG. 5."
For additional information on this patent application, see: Brown,
Keywords for this news article include: Software,
Our reports deliver fact-based news of research and discoveries from around the world. Copyright 2014, NewsRx LLC
Most Popular Stories
- Obama Administration Releases Proposal to Regulate For-Profit Colleges
- Apple, HP, Intel May Take a Hit from Slowdown in Smartphone Sales Growth
- Elizabeth Vargas' Husband Marc Cohn Addresses Rumors
- Keurig Adds Peet's coffee, Alters Starbucks deal
- FDIC Files Lawsuit on Behalf of Banks Allegedly Hurt by Libor Scandal
- Motley Crue's Nikki Sixx Marries Model Courtney Bingham
- U.S. to Relinquish Gov't Control Over Internet
- Chinese e-Commerce Giant Alibaba Gears for IPO in U.S.
- Some California Cities Seeking Water Independence
- Will Missing Malaysian Jet Prompt Aviation System Change?