System, method and program product for correcting semantic errors in code using peer submitted code snippets

0001The present application is a continuation of U.S. patent application Ser. No. 12/195,368, filed on Aug. 20, 2008, and entitled, “System, Method and Program Product for Correcting Semantic Errors in Code Using Peer Submitted Code Snippets,” which is incorporated herein by reference.

BACKGROUND

0002The present invention relates to computer systems and software, and more specifically to an automated technique for correcting semantic errors in code in an integrated development environment (IDE), using peer submitted code snippets.

0003Most application development activities are managed within an Integrated Development Environment (IDE). Errors in code can be related to syntax, or can also be related to semantics. Code semantic errors can further be related to language semantics, where the code violates the semantics of the underlying language, or semantics related to the use of a third party library. Typically, an IDE provides an editor that is configured to validate code syntax, highlight syntactic errors in a particular language and is configured to offer appropriate corrections for any syntax errors. When the editor identifies a syntax error, matching records are displayed to offer corrections. Often, an IDE provides a rules engine used to highlight language semantic errors, which can be difficult to identify and to correct. As such, there is a need for an application developer to find ways to effectively monitor and correct such semantic errors during development of software.

SUMMARY

0004A method, system and/or program product corrects semantic errors in code in an integrated development environment. The method includes inputting, using a code editor, code being developed in an integrated development environment. One or more nodes, in a syntax tree constructed for inputting the code, are identified as containing semantic errors pertaining to use of a third-party library. A primary executable code snippet and a secondary code snippet for correcting the semantic errors are displayed. If execution of the primary code snippet does not correct the semantic errors, then the secondary code snippet is automatically executed.

0005In another aspect, the invention provides a method for correcting semantic errors in code in an integrated development environment. The method includes inputting, using a code editor, code being developed by a developer in an integrated development environment, identifying, in a syntax tree constructed for the code inputted, one or more nodes containing semantic errors pertaining to use of a third-party library, choosing a node of the one or more nodes identified in the syntax tree constructed containing the semantic errors, displaying one or more suggestions for correcting the semantic errors identified for the node chosen, where the one or more suggestions include one or more code snippets associated with one or more collaboration records located for the node chosen and where the one or more code snippets are submitted by peer developers to correct the semantic errors identified for the node chosen, selecting at least one code snippet from the one or more code snippets displayed for correcting the semantic errors identified for the node chosen and executing the code inputted in the integrated development environment, where the at least one code snippet selected is automatically invoked to correct the semantic errors identified for the node chosen. In an embodiment, the identifying step further includes constructing, using a code parser, a syntax tree representation of the code inputted and parsing, by the code parser, the code inputted to identify the one or more nodes containing the semantic errors. In an embodiment, the identifying step further includes the step of providing a collaboration datastore for storing the one or more collaboration records containing respective invocations for identifying the one or more nodes containing the semantic errors, where a collaboration record includes one or more properties and where a respective invocation of the respective invocations includes a type of invocation and one or more parameters. In an embodiment, the identifying step further includes creating, using the one or more collaboration records located, visual indicators within the code editor for the one or more nodes containing the semantic errors identified. In an embodiment, the selecting step further includes providing a code snippet processor for maintaining the one or more code snippets associated with the one or more collaboration records located for the node chosen and configuring one or more parameters for the at least one code snippet selected for the node chosen, where the one or more parameters includes at least one of: input parameters, output parameters, input-output parameters, return values and execution order values. In an embodiment, the executing step further includes ascertaining whether or not the at least one code snippet selected for the node chosen is configured to correct the semantic errors contained within the node, if the at least one code snippet selected for the node is configured to correct the semantic errors contained within the node, fetching the at least one code snippet from the code snippet processor and executing the at least one code snippet fetched based on the type of invocation and the one or more parameters configured for the code snippet selected, where the type of invocation includes an execution order value comprising at least one of: before invocation, after invocation and only upon error. In an embodiment, the method further includes determining whether the execution of the at least one code snippet selected is successful in correcting the semantic errors identified and, if the execution of the at least one code snippet selected is not successful in correcting the semantic errors identified, selecting another code snippet from the one or more code snippets displayed for correcting the semantic errors identified for the node chosen and executing the code inputted in the integrated development environment, where the another code snippet selected is automatically invoked to correct the semantic errors identified for the node chosen.

0006In another aspect the invention provides a computer system for correcting semantic errors in code in an integrated development environment. The computer system includes a central processing unit, first program instructions to input code being developed in an integrated development environment, the first program instructions including instructions to construct, using a code parser, a syntax tree representation of the code inputted and to parse the code inputted and to identify the one or more nodes containing semantic errors pertaining to use of a third-party library in the code inputted, second program instructions to display, using one or more matching collaboration records located for a node chosen from the one or more nodes identified containing the semantic errors, one or more suggestions for correcting the semantic errors identified in the syntax tree constructed for the code inputted, where the one or more suggestions include one or more code snippets associated with one or more collaboration records located for the node chosen and where the one or more code snippets are submitted by peer developers to correct the semantic errors identified for the node chosen and third program instructions to execute the code inputted in the integrated development environment, where at least one code snippet selected from the one or more code snippets is automatically invoked to correct the semantic errors identified for the node chosen. In an embodiment, the second program instructions include instructions to provide a collaboration datastore for storing one or more collaboration records containing respective invocations for identifying the one or more nodes containing the semantic errors, where a collaboration record includes one or more properties and where a respective invocation of the respective invocations includes a type of invocation and one or more parameters and where the second program instructions include instructions to provide a code snippet processor for maintaining the one or more code snippets associated with the one or more collaboration records located for the node chosen.

0007In an embodiment, the second program instructions include instructions to create semantic error markers within a code editor for identifying the one or more nodes containing the semantic errors. In an embodiment, the third program instructions include instructions to choose the node from the one or more nodes identified containing the semantic errors and to configure one or more parameters for the at least one code snippet selected for the node chosen, where the one or more parameters includes at least one of: input parameters, output parameters, input-output parameters, return values and execution order values. In an embodiment, the third program instructions include instructions to ascertain whether or not the at least one code snippet selected for the node chosen is configured to correct the semantic errors contained within the node and, if the at least one code snippet selected for the node is configured to correct the semantic errors contained within the node, the third program instructions including instructions to fetch the at least one code snippet from the code snippet processor and to execute the at least one code snippet fetched based on the type of invocation and the one or more parameters configured for the code snippet selected, where the type of invocation includes an execution order value comprising at least one of: before invocation, after invocation and only upon error. In an embodiment, the third program instructions include instructions to determine whether the execution of the at least one code snippet selected is successful in correcting the semantic errors identified and, if the execution of the at least one code snippet selected is not successful in correcting the semantic errors identified, the third program instructions including instructions to select another code snippet from the one or more code snippets displayed for correcting the semantic errors identified for the node chosen and to execute the code inputted in the integrated development environment, where the another code snippet selected is automatically invoked to correct the semantic errors identified for the node chosen. In an embodiment, each of the first, second and third program instructions are stored in the computer system for execution by the central processing unit.

0008In yet another aspect, the invention provides a computer program product for correcting semantic errors in code in an integrated development environment. The computer program product comprises a computer readable medium, first program instructions to input code being developed by a developer in an integrated development environment, the first program instructions including instructions to construct, using a code parser, a syntax tree representation of the code inputted and to parse the code inputted and to identify the one or more nodes containing semantic errors pertaining to use of a third-party library in the code inputted, second program instructions to display, using one or more matching collaboration records located for a node chosen from the one or more nodes identified containing the semantic errors, one or more suggestions for correcting the semantic errors identified in the syntax tree constructed for the code inputted, where the one or more suggestions include one or more code snippets associated with one or more collaboration records located for the node chosen and where the one or more code snippets are submitted by peer developers to correct the semantic errors identified for the node chosen and third program instructions to execute the code inputted in the integrated development environment, where at least one code snippet selected from the one or more code snippets is automatically invoked to correct the semantic errors identified for the node chosen. In an embodiment, the second program instructions include instructions to provide a collaboration datastore for storing one or more collaboration records containing respective invocations for identifying the one or more nodes containing the semantic errors, where a collaboration record includes one or more properties and where a respective invocation of the respective invocations includes a type of invocation and one or more parameters and where the second program instructions include instructions to provide a code snippet processor for maintaining the one or more code snippets associated with the one or more collaboration records located for the node chosen. In an embodiment, the second program instructions include instructions to create semantic error markers within a code editor for the semantic errors identified using the one or more collaboration records located, the second program instructions including instructions to create, using the one or more collaboration records located, visual indicators within the code editor for the one or more nodes containing the semantic errors identified. In an embodiment, the third program instructions include instructions to choose the node from the one or more nodes identified containing the semantic errors and to configure one or more parameters for the at least one code snippet selected for the node chosen, where the one or more parameters includes at least one of: input parameters, output parameters, input-output parameters, return values and execution order values. In an embodiment, the third program instructions include instructions to ascertain whether or not the at least one code snippet selected for the node chosen is configured to correct the semantic errors contained within the node and, if the at least one code snippet selected for the node is configured to correct the semantic errors contained within the node, the third program instructions include instructions to fetch the at least one code snippet from the code snippet processor and to execute the at least one code snippet fetched based on the type of invocation and the one or more parameters configured for the code snippet selected, where the type of invocation includes an execution order value comprising at least one of: before invocation, after invocation and only upon error. In an embodiment, the third program instructions include instructions to determine whether the execution of the at least one code snippet selected is successful in correcting the semantic errors identified and, if the execution of the at least one code snippet selected is not successful in correcting the semantic errors identified, the third program instructions including instructions to select another code snippet from the one or more code snippets displayed for correcting the semantic errors identified for the node chosen and to execute the code inputted in the integrated development environment, where the another code snippet selected is automatically invoked to correct the semantic errors identified for the node chosen. In an embodiment, each of the first, second and third program instructions are recorded on the computer readable medium.

0009Further, in yet another aspect, the invention provides a process for deploying computing infrastructure including integrating computer-readable code into a computing system, where the code in combination with the computing system is capable of performing a process of correcting semantic errors in code in an integrated development environment, the process includes inputting, using a code editor, code being developed by a developer in an integrated development environment, constructing, using a code parser, a syntax tree representation of the code inputted, identifying, in the syntax tree constructed for the code inputted, one or more nodes containing semantic errors pertaining to use of a third-party library, choosing a node of the one or more nodes identified in the syntax tree constructed containing the semantic errors, displaying one or more suggestions for correcting the semantic errors identified for the node chosen, where the one or more suggestions include one or more code snippets associated with one or more collaboration records located for the node chosen and where the one or more code snippets are submitted by peer developers to correct the semantic errors identified for the node chosen, selecting at least one code snippet from the one or more code snippets displayed for correcting the semantic errors identified for the node chosen and executing the code inputted in the integrated development environment, where the at least one code snippet selected is automatically invoked to correct the semantic errors identified for the node chosen. The process further includes providing a collaboration datastore for storing the one or more collaboration records containing respective invocations for identifying the one or more nodes containing the semantic errors, where a collaboration record includes one or more properties and where a respective invocation of the respective invocations includes a type of invocation and one or more parameters. In an embodiment, the identifying step further includes creating, using the one or more collaboration records located, visual indicators within the code editor for the one or more nodes containing the semantic errors identified. In an embodiment, the displaying step further includes ascertaining whether or not the developer wishes to apply a suggestion of the one or more suggestions displayed for the node and, if the developer wishes to apply the suggestion of the one or more suggestions displayed for the node, applying the suggestion to the node to correct the semantic errors identified. In an embodiment, the identifying step further includes ascertaining whether or not the at least one code snippet selected for the node chosen is configured to correct the semantic errors contained within the node, if the at least one code snippet selected for the node is configured to correct the semantic errors contained within the node, fetching the at least one code snippet from the code snippet processor and executing the at least one code snippet fetched based on the type of invocation and the one or more parameters configured for the code snippet selected, where the type of invocation includes an execution order value comprising at least one of: before invocation, after invocation and only upon error. In an embodiment, the executing step further includes determining whether the execution of the at least one code snippet selected is successful in correcting the semantic errors identified, if the execution of the at least one code snippet selected is not successful in correcting the semantic errors identified, selecting another code snippet from the one or more code snippets displayed for correcting the semantic errors identified for the node chosen and executing the code inputted in the integrated development environment, where the another code snippet selected is automatically invoked to correct the semantic errors identified for the node chosen.

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

0010The accompanying drawings, which are incorporated in and form a part of this specification, illustrate embodiments of the invention and, together with the description, serve to explain the principles of the invention:

0011<figref idref="DRAWINGS">FIG. 1</figref> is a schematic block diagram of a Java integrated development environment (IDE) for correcting semantic errors identified in code, using peer submitted code snippets, in accordance with an embodiment of the present invention.

0012<figref idref="DRAWINGS">FIG. 2</figref> depicts an example of a code snippet comprising of a set of lines of code for correcting semantic errors identified in code inputted in an integrated development environment (IDE), in accordance with an embodiment of the present invention.

0013<figref idref="DRAWINGS">FIG. 3</figref> depicts an illustration of a code snippet selection interface for selecting one or more code snippets for correcting semantic errors in code inputted into a code editor in an integrated development environment (IDE), in accordance with an embodiment of the present invention.

0014<figref idref="DRAWINGS">FIG. 4</figref> depicts an example of a code snippet submitted by a peer developer comprising of a method with two parameters and a return value for correcting a semantic error identified in the code inputted into an integrated development environment (IDE), in accordance with an embodiment of the present invention.

0015<figref idref="DRAWINGS">FIG. 5</figref> depicts an example of a code being developed by a developer that contains an invocation for executing a code snippet, such that, the code snippet is invoked according to the property described in the invocation, in accordance with an embodiment of the present invention.

0016<figref idref="DRAWINGS">FIG. 6</figref> depicts an illustration of a code snippet configuration interface for configuring one or more code snippets for correcting semantic errors in code inputted into a code editor in an integrated development environment (IDE), in accordance with an embodiment of the present invention.

0017<figref idref="DRAWINGS">FIG. 7</figref> is a schematic block system diagram depicting various ways in which a code snippet may be configured to be invoked by an invocation for correcting semantic errors in code being developed by a developer, in accordance with an embodiment of the present invention.

0018<figref idref="DRAWINGS">FIGS. 8A and 8B</figref> together depict a flowchart outlining the steps performed for correcting semantic errors in code, using peer submitted code snippets, in accordance with an embodiment of the present invention.

0019<figref idref="DRAWINGS">FIG. 9</figref> is a schematic block system diagram of an integrated development environment (IDE), such as, a Java IDE for correcting semantic errors in code, using code snippets, in accordance with an embodiment of the present invention.

DETAILED DESCRIPTION

0020Reference throughout this specification to “one embodiment,” “an embodiment,” or similar language means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the present invention. Thus, appearances of the phrases “in one embodiment,” “in an embodiment,” and similar language throughout this specification may, but do not necessarily, all refer to the same embodiment.

0021Moreover, the described features, structures, or characteristics of the invention may be combined in any suitable manner in one or more embodiments. It will be apparent to those skilled in the art that various modifications and variations can be made to the present invention without departing from the spirit and scope of the invention. Thus, it is intended that the present invention cover the modifications and variations of this invention provided they come within the scope of the appended claims and their equivalents. Reference will now be made in detail to the preferred embodiments of the invention.

0022Many of the functional units described in this specification have been referred to as modules or components, in order to more particularly emphasize their implementation independence. A module may be implemented in programmable hardware devices such as field programmable gate arrays, programmable array logic, programmable logic devices or the like. Modules may also be implemented in software for execution by various types of processors. An identified module or component of executable code may, for instance, comprise one or more physical or logical blocks of computer instructions, which may, for instance, be organized as an object, procedure, or function. Nevertheless, the executables of an identified module need not be physically located together, but may comprise disparate instructions stored in different locations which, when joined logically together, comprise the module and achieve the stated purpose for the module.

0023Further, a module of executable code could be a single instruction, or many instructions, and may even be distributed over several different code segments, among different programs, and across several memory devices. Similarly, operational data may be identified and illustrated herein within modules, and may be embodied in any suitable form and organized within any suitable type of data structure. The operational data may be collected as a single data set, or may be distributed over different locations including over different storage devices and over disparate memory devices. Furthermore, modules may also be implemented as a combination of software and one or more hardware devices. For instance, a module may be embodied in the combination of a software executable code stored on a memory device. In a further example, a module may be the combination of a processor that operates on a set of operational data.

0024Reference is now made to <figref idref="DRAWINGS">FIG. 1</figref>, which illustrates an embodiment of a computer infrastructure <b>100</b> for correcting semantic errors in code in an integrated development environment (IDE), using one or more peer submitted code snippets, in accordance with an embodiment of the invention. Turning to <figref idref="DRAWINGS">FIG. 1</figref>, <figref idref="DRAWINGS">FIG. 1</figref> depicts a schematic block system diagram illustrating one embodiment of a computer infrastructure <b>100</b>, which illustrates an integrated development environment (IDE) for correcting semantic errors due to use of third party libraries in the code, using code snippets submitted by peer developers. In an embodiment, the integrated development environment (IDE) boundary <b>120</b> comprises an IDE software application that comprises one or more program modules or program components for correcting semantic errors in code being developed, using code snippets submitted by peer developers. In an embodiment, the IDE software application includes one or more code editors that an application developer may use to write code in a specific programming language. Besides providing a convenient interface to view and modify code, a code editor is able to validate code syntax, highlight syntactic errors and offer corrections. In an embodiment, as shown in <figref idref="DRAWINGS">FIG. 1</figref>, the integrated development environment (IDE) boundary <b>120</b> comprises a Java integrated development environment (IDE) <b>120</b> for correcting semantic errors found in Java code being developed, using peer submitted code snippets for the Java programming language. A semantic error occurs when code violates the semantics of the underlying language or violates use of a third-party library. As depicted in <figref idref="DRAWINGS">FIG. 1</figref>, the Java integrated development environment (IDE) boundary <b>120</b> includes a code editor component <b>102</b> (simply referred to herein after as “code editor”), a snippet selection user interface component <b>104</b> (simply referred to herein after as “snippet selection user interface”), a snippet configuration user interface component <b>106</b> (simply referred to herein after as “snippet configuration user interface”), a snippet marker component <b>108</b> (simply referred to herein after as “snippet selection user interface”), a code parser component <b>110</b> (simply referred to herein after as “code parser”), a snippet processor component <b>112</b> (simply referred to herein after as “snippet processor”), a code executor component <b>114</b> (simply referred to herein after as “code executor”) and a collaboration record locator component <b>116</b> (simply referred to herein after as “collaboration record locator”). The code editor <b>102</b> is used by a programmer or developer to input or enter code. As a developer enters code into the code editor <b>102</b>, the code parser <b>110</b> reads and parses the entered code. Further, the code parser <b>110</b> constructs an Abstract Syntax Tree (AST) representation of the code inputted in the code editor <b>102</b>. Using the collaboration record locator <b>116</b>, the code parser <b>110</b> identifies all semantic errors in the use of third party libraries in the entered or inputted code. In an embodiment, the collaboration record locator <b>116</b> uses the AST constructed by the code parser <b>110</b> to locate one or more collaboration records stored or maintained in a collaboration datastore <b>142</b> within a repository <b>140</b>. In an embodiment, the collaboration datastore <b>142</b> is located in a remote repository <b>140</b> and is accessed over a network <b>130</b>. However, it is understood that the collaboration datastore <b>142</b> may be located in a local repository within integrated development environment (IDE) <b>120</b>, where each developer may have access to their own local datastore, and where the datastores may be configured to update each other via replication. Further, in an embodiment, the collaboration record locator <b>116</b> returns the collaboration records retrieved from the collaboration datastore <b>142</b> to the snippet marker <b>108</b>. The snippet marker <b>108</b> creates visual indicators in the code editor <b>102</b> for lines of code identified with semantic errors for which code snippets exist. The developer uses the snippet selection user interface <b>104</b> to view and select existing code snippets. Additionally, the developer uses snippet configuration user interface <b>106</b> to configure selected code snippets. The code snippet selections and code snippet configurations, and the location of the actual code snippets are maintained by the snippet processor <b>112</b>. Further, in an embodiment, the code executor <b>114</b> runs the code entered by the developer in the IDE <b>120</b> and uses snippet processor <b>112</b> to invoke one or more code snippets selected to correct the semantic errors found in the inputted code. As shown in <figref idref="DRAWINGS">FIG. 1</figref>, the system <b>100</b> which includes a Java integrated development environment (IDE) boundary <b>120</b> is intended to represent any type of computer architecture that is maintained in a secure environment (i.e., for which access control is enforced). It should be understood, however, that although not shown, other hardware and software components (e.g., compiler, debugger, additional computer systems, routers, firewalls, etc.) could be included in system <b>100</b>. Also, it will be understood by one skilled in the art that the invention may be used in conjunction with other programming languages for correcting semantic errors in code due to use of third party libraries, using code snippets.

0025Reference is now made to <figref idref="DRAWINGS">FIG. 2</figref>, reference numeral <b>200</b>, which illustrates an example of a code snippet for correcting a semantic error identified in code that is being developed by a peer developer, in accordance with an embodiment of the invention. As shown in <figref idref="DRAWINGS">FIG. 2</figref>, a code snippet is a piece of code that runs within an execution context and meaningfully alters some aspect of that execution. In an embodiment, as shown in <figref idref="DRAWINGS">FIG. 2</figref>, a code snippet comprises a set of lines of code submitted by a peer to correct a semantic error in the developer's use of a third-party library. In an embodiment, when a node is identified in the abstract syntax tree (AST) as containing a semantic error pertaining to use of third-party library, a matching collaboration record is located for that identified node in the AST. In an embodiment, the collaboration record matching the identified node contains one or more suggestions for correcting the semantic error in the identified node, where some suggestions contain code snippets submitted by peer developers. In an alternate embodiment, a collaboration record itself may contain one or more code snippets. Further, in an embodiment, each submitted code snippet has a property (referred to herein as “execution property”) that specifies when the code snippet should be executed. In an embodiment, the execution property specifying when the code snippet should be executed includes an execution order value comprising at least one of: before invocation, after invocation or only upon error and, preferably, is selected from the execution order value group consisting essentially of before invocation, after invocation or only upon error. In particular, if the property specifies that the code snippet should be executed “before invocation”, then the code snippet is executed before the node in the AST is called. On the other hand, if the property specifies that the code snippet should be executed “after invocation”, then the code snippet is executed after the node in the AST is called. Similarly, if the property specifies that the code snippet should be executed “only upon error”, then the code snippet is executed only if executing the node results in a specific set of errors. In an embodiment, this execution property is configured by the peer developer submitting the code snippet, as discussed further herein below with respect to <figref idref="DRAWINGS">FIG. 6</figref>. Upon execution of the developer's code, the peer submitted code snippet is invoked according to the execution property described herein above.

0026Turning to <figref idref="DRAWINGS">FIG. 3</figref>, reference numeral <b>300</b> illustrates a code snippet selection interface for selecting one or more code snippets for correcting semantic errors in code inputted into a code editor in an integrated development environment (IDE), in accordance with an embodiment of the invention. In an embodiment, the IDE collects all such code snippets associated with the collaboration record and presents the available code snippets to the developer. The developer may select one code snippet to use. Alternately, the developer may select multiple code snippets, where one code snippet is designated as primary and selected by default for execution. If the code executor encounters an error, then execution switches to using a second code snippet. This process is repeated until either the execution of one selected code snippet is successful or all selected code snippets have been executed, but with errors. As shown in <figref idref="DRAWINGS">FIG. 3</figref>, the snippet selection interface <b>300</b> displays to a developer a list of all available code snippets <b>310</b> corresponding to a node identified as containing a semantic error. In particular, the snippet selection interface displays, on a display, the available code snippets (reference numeral <b>310</b>) that a developer can choose from. In an embodiment, the developer highlights an available code snippet from the Available Code Snippets list <b>310</b> and clicks on the add button (reference numeral <b>330</b>) to add the highlighted code snippet among the one or more of the available code snippets <b>310</b> listed in <figref idref="DRAWINGS">FIG. 3</figref> to the Selected Code Snippets list <b>320</b>. As shown under “Selected Code Snippets” (Reference numeral <b>320</b>) in <figref idref="DRAWINGS">FIG. 3</figref>, the developer has already selected code snippets <b>5</b>, <b>3</b> and <b>8</b> for correcting a semantic error in code under development. Further, as shown under “Available Code Snippets” (reference numeral <b>310</b>), there are still some other code snippets that are available for the developer to choose from, namely, code snippet <b>1</b>, <b>2</b>, <b>4</b>, <b>7</b> and <b>8</b>. In an embodiment, the developer highlights a selected code snippet listed under “Selected Code Snippets” (reference numeral <b>320</b>) and then clicks on the remove button (reference numeral <b>340</b>) to remove a previously added code snippet from the list of selected code snippets <b>320</b>. Further, the developer uses the up button (reference numeral <b>350</b>) and/or the down button (reference numeral <b>360</b>) to specify the order of selection for execution of the list of selected code snippets <b>320</b>. As such, the code executor executes code snippet <b>5</b> first. If the code executor encounters an error executing code snippet <b>5</b>, then execution switches to using the next code snippet in the list <b>320</b>, namely, code snippet <b>3</b>. Similarly, if the code executor encounters an error executing code snippet <b>3</b>, then execution switches to using the next code snippet in the list <b>320</b>, namely, code snippet <b>6</b>. This process is repeated until either the execution of a selected code snippet is successful or all three selected code snippets (shown in list <b>320</b> of <figref idref="DRAWINGS">FIG. 3</figref>) have been executed, but with errors.

0027Reference is now made to <figref idref="DRAWINGS">FIGS. 4 and 5</figref>, which together illustrate an embodiment of using a code snippet to correct a semantic error identified in code inputted into a code editor in an integrated development environment (IDE), in accordance with an embodiment of the invention. In particular, as shown in <figref idref="DRAWINGS">FIG. 4</figref>, the code snippet <b>400</b> submitted by a peer developer comprises a method with two parameters and a return value, where the IDE allows the developer to configure the method. Further, the code snippet <b>400</b> is associated with the invocation in line <b>5</b> of <figref idref="DRAWINGS">FIG. 5</figref>, reference numeral <b>500</b>, which shows an example of code being developed by a developer. In particular, the code snippet <b>400</b> is configured to correct the semantic error identified in the code being developed, using the code snippet. It is understood by one skilled in the art that a code snippet may also be a class with one or more methods, where a predefined method with parameters and a return value is always invoked.

0028Reference is now made to <figref idref="DRAWINGS">FIG. 6</figref>, reference numeral <b>600</b>, which illustrates a code snippet configuration interface for configuring one or more code snippets available for correcting semantic errors in code being developed by a developer in an integrated development environment, in accordance with an embodiment of the invention. Upon execution of the developer's code <b>500</b>, shown in <figref idref="DRAWINGS">FIG. 5</figref>, the peer submitted code snippet is invoked according to the execution property specified in the code snippet, such as, before invocation, after invocation or only upon error. In an embodiment, the developer code with its dependencies and the code snippet with its dependencies are compiled independent of each other. During execution, the code executor uses information contained in the snippet processor to determine when the code snippet needs to be invoked. In particular, the code executor merges the code snippet with the executing code in one of three ways. First, the code snippet is “in lined” with the developer code, such that, the code snippet and the developer code are part of a single frame (or method invocation). Second, the code snippet is maintained in a separate method, such that, the method is invoked from the developer code's frame resulting in the code snippet being executed within its own frame. Third, the code snippet is contained within a class whose instance is invoked and managed by the code executor during execution. As shown in <figref idref="DRAWINGS">FIG. 6</figref>, a snippet configuration interface (reference numeral <b>600</b>) is used to configure a code snippet. The configuration may contain input parameter configuration (reference numeral <b>610</b>) used to configure any input parameters used by the code snippet; output parameter configuration (reference numeral <b>620</b>) used to configure any output parameters that are created in the developer code and passed into the code snippet; input/output parameter configuration (reference numeral <b>630</b>) used to configure any parameters that are created in the developer code and passed into the code snippet, where they are modified; and return parameter configuration (reference numeral <b>640</b>) that are created in the code snippet and returned to the developer code. Referring to <figref idref="DRAWINGS">FIG. 6</figref>, a developer first configures any input parameters (reference numeral <b>610</b>), such as, “firstParamInstance” and “secondParamInstance”. Further, a developer configures any output parameters (reference numeral <b>620</b>), which in this example shows no output parameters. Furthermore, the developer configures any input/output parameters (reference numeral <b>630</b>), which in this example shows that no input/output parameters have been configured. Finally, the developer configures any return values (reference numeral <b>640</b>), such as, “objectInstance”.

0029Turning to <figref idref="DRAWINGS">FIG. 7</figref>, reference numerals <b>700</b>, <b>710</b>, <b>720</b> and <b>730</b> represent execution flows, with each illustrating various ways in which a code snippet may be configured to be invoked for correcting semantic errors in code being developed by a developer, in accordance with embodiments of the present invention. In an embodiment, as shown in <figref idref="DRAWINGS">FIG. 7</figref>, each circle represents a node in an execution flow, where a darker shade circle represents a node having a semantic error and where a checkered circle represents a code snippet. In an object oriented language, such as, Java, a node represents a message sent by one object to another object. More generally, a node is an abstraction for a set of lines of code. Turning to the schematic for execution flow <b>700</b>, circle <b>702</b> represents a node that contains a semantic error. Further, as shown in the schematic for execution flow <b>710</b>, code snippet <b>712</b> is configured to be invoked before execution of a node <b>714</b>, which contains a semantic error. On the other hand, as shown in the schematic for execution flow <b>720</b>, code snippet <b>724</b> is configured to be invoked after execution of node <b>722</b>, which contains a semantic error. Moreover, the schematic for execution flow <b>730</b> shows that code snippet <b>736</b> is configured to be invoked only in case of an error. In particular, as shown in the schematic for execution flow <b>730</b>, node <b>732</b> contains a semantic error, but the error in execution as a consequence of the semantic error occurs later at node <b>734</b>. As such, code snippet <b>736</b> is executed and the execution flow returns to execute node <b>734</b> again.

0030In another embodiment, the invention provides a method for correcting semantic errors in an integrated development environment (IDE), using one or more code snippets, in accordance with an embodiment of the present invention. Further, in yet another embodiment, the invention provides a process for deploying computing infrastructure including integrating computer-readable code into a computing system, wherein the code in combination with the computing system is capable of performing a process of correcting semantic errors in code in an integrated development environment. Reference is now made to <figref idref="DRAWINGS">FIGS. 8A and 8B</figref>, respective flowcharts <b>800</b>A and <b>800</b>B, which together outline a method for correcting semantic errors in an integrated development environment (IDE), using one or more code snippets. The method begins in <b>800</b>A with a developer selecting in step <b>802</b> a node in the constructed abstract syntax tree (AST) representation of the code within an integrated development environment (IDE), which contains a semantic error. In step <b>804</b>, the code parser locates code snippets within an invocation of an associated collaboration record. The code parser further determines in step <b>806</b> whether or not code snippets exist to correct the semantic error identified in the node. If the code parser determines that code snippets do not exist to correct the semantic error in the node, then, the code editor determines if additional semantic errors exist in step <b>808</b>. If the code parser determines that additional semantic errors do not exist in step <b>808</b>, then the process continues with step <b>818</b> in <figref idref="DRAWINGS">FIG. 8A</figref>. However, if the code parser determines that additional semantic error do exist, then the process returns to step <b>802</b>, where the developer selects a node in the AST containing a semantic error. Going back to step <b>806</b>, if the code parser determines that code snippets do exist to correct the semantic error, then in step <b>810</b>, the snippet selection user interface presents all code snippets. In step <b>812</b>, the developer selects a code snippet to execute. The code parser adds in step <b>814</b> the selected code snippet to the snippet processor. Further, in step <b>816</b>, the code editor determines whether or not the developer wishes to pick or select a second code snippet. If the code editor determines that the developer wishes to pick a second code snippet, then the process returns to step <b>812</b>, where the developer selects a second code snippet to execute. If the code editor determines that the developer does not wish to pick a second code snippet, then the code editor determines in step <b>818</b> whether or not the developer wishes to configure the selected code snippets. If the developer does not wish to configure the selected code snippets in step <b>818</b>, then the process continues with step <b>836</b> in <figref idref="DRAWINGS">FIG. 8B</figref>. However, if the developer wishes to configure the selected code snippets in step <b>818</b>, then in step <b>820</b>, the snippet configuration user interface presents all selected code snippets to the developer. Further, the developer picks a code snippet to configure in step <b>822</b>. The developer configures any input parameters in step <b>824</b> and configures any output parameters in step <b>826</b>. The process continues with step <b>828</b> in <figref idref="DRAWINGS">FIG. 8B</figref>. In step <b>828</b> of <figref idref="DRAWINGS">FIG. 8B</figref>, the developer configures any parameters designated input/output parameters. Further, the developer configures any return value in step <b>830</b>. In step <b>832</b>, the developer assigns an execution order value for the code snippets selected. Further, in step <b>834</b>, a determination is made as to whether or not the developer wishes to configure another code snippet. If the developer wishes to configure another code snippet, the process continues with step <b>820</b> in <figref idref="DRAWINGS">FIG. 8A</figref>. If the developer does not wish to configure another code snippet in step <b>834</b>, then the developer executes, in step <b>836</b>, the code using the code executor in the integrated development environment. Next, in step <b>838</b>, the code editor determines whether or not the node to be invoked next contains any semantic error. If it is determined that the node to be invoked next does not contain any semantic errors, then the process continues with step <b>852</b> in <figref idref="DRAWINGS">FIG. 8B</figref>. However, if the code editor determines that the node to be invoked next does contain semantic errors, then the process continues with step <b>840</b>, where the code editor determines whether or not the code snippets selected to correct a semantic error are configured for a selected node. If the code snippets selected to correct a semantic error are determined not to be configured for a selected node, then the process continues with step <b>852</b> in <figref idref="DRAWINGS">FIG. 8B</figref>. However, if the code snippets selected to correct a semantic error are determined to be configured for a selected node in step <b>840</b>, then the code executor fetches the first code snippet selected from the snippet processor in step <b>842</b>. In step <b>844</b>, the code executor calls a code snippet based on the invocation property in the code snippet. In step <b>846</b>, the code executor determines whether or not an error is detected in executing the code snippet. If no errors are detected in step <b>846</b>, then the process continues with step <b>852</b> in <figref idref="DRAWINGS">FIG. 8B</figref>. However, if errors are detected in step <b>846</b>, then the code editor determines whether or not more code snippets are available in step <b>848</b>. If it is determined that more code snippets are available, then the code executor fetches the next snippet from the snippet processor in step <b>850</b> and the process returns to step <b>844</b>, where the code executor calls the code snippet based on invocation property. However, if it is determined in step <b>848</b> that more code snippets are not available, then the code executor determines in step <b>852</b> whether or not the developer wishes to continue execution of the code. If the developer wishes to continue execution of the code in step <b>852</b>, then the process returns to step <b>838</b>, where the code executor determines whether or not the next node to be invoked contains any semantic errors. If the developer does not wish to continue execution of the code in step <b>852</b>, the process ends.

0031Referring now to <figref idref="DRAWINGS">FIG. 9</figref>, there is illustrated a computer system <b>900</b> that includes a computer infrastructure <b>902</b> having a computer program product configured to correct semantic errors identified in a section of code under development, using code snippets, in accordance with an embodiment of the invention. The computer program product comprises a computer readable or computer-usable storage medium, which provides program code, such as, the Java integrated development environment (IDE) application <b>914</b> for correcting semantic errors identified in a section of Java code under development. The Java integrated development environment (IDE) application <b>914</b> can be loaded into computer system <b>904</b> from a type of computer readable media <b>936</b>, such as, a magnetic tape or disk, optical media, DVD, memory stick, semiconductor memory, etc. or downloaded from the Internet via a TCP/IP adapter card <b>938</b>. As depicted in <figref idref="DRAWINGS">FIG. 9</figref>, system <b>900</b> includes a computer infrastructure <b>902</b>, which is intended to represent any type of computer architecture that is maintained in a secure environment (i.e., for which access control is enforced). As shown, infrastructure <b>902</b> includes a computer system <b>904</b> that typically represents an application server or system <b>904</b> or the like that includes an integrated development environment (IDE) for developing software, such as the Java integrated development environment (IDE) <b>914</b> configured to correct semantic errors in code under development, using peer submitted code snippets. It should be understood, however, that although not shown, other hardware and software components (e.g., additional computer systems, routers, firewalls, etc.) could be included in infrastructure <b>902</b>.

0032In general, user <b>1</b> (reference numeral <b>930</b>) through user N (reference numeral <b>940</b>) may access the computer system <b>904</b>, which has deployed thereon the Java integrated development environment (IDE) application <b>914</b>, which implements the invention. As shown in <figref idref="DRAWINGS">FIG. 9</figref>, the system <b>904</b> (which has implemented thereon the Java integrated development environment (IDE) application <b>914</b>) is shown to include a storage system or repository <b>922</b>. In an embodiment, the storage system <b>922</b>, stores a collaboration datastore <b>926</b> that has stored therein one or more collaboration records <b>927</b> used for correcting semantic errors in code under development, using peer submitted code snippets. Further, the storage system <b>922</b> stores one or more code snippets <b>928</b> used for correcting semantic errors identified in code being developed. In particular, a developer or programmer (user <b>1</b>, reference numeral <b>930</b> through user N, reference numeral <b>940</b>) accesses the Java integrated development environment (IDE) application <b>914</b> running on system <b>904</b> over a network via interfaces (e.g., web browsers) loaded on a client, for example, a personal computer, a laptop, a handheld device, etc. In the case of the latter, the network can be any type of network such as the Internet, a local area network (LAN), a wide area network (WAN), a virtual private network (VPN), etc. In any event, communication with infrastructure <b>902</b> could occur via a direct hardwired connection (e.g., serial port), or via an addressable connection that may utilize any combination of wired line and/or wireless transmission methods. Moreover, conventional network connectivity, such as Token Ring, Ethernet, Wi-Fi (Wireless Fidelity) or other conventional communications standards could be used. Still yet, connectivity could be provided by conventional TCP/IP sockets-based protocol. In this instance, the parties could utilize an Internet service provider to establish connectivity to infrastructure <b>902</b>. It should be understood that under the present invention, infrastructure <b>902</b> could be owned and/or operated by a party such as a third party provider <b>950</b>, or by an independent entity. Regardless, use of infrastructure <b>902</b> and the teachings described herein could be offered to the parties on a subscription or fee-basis. In either scenario, an administrator <b>934</b> could support and configure infrastructure <b>902</b>, for instance, upgrading the Java IDE application <b>914</b> deployed on the computer system <b>904</b>.

0033The computer system <b>904</b> is shown to include a CPU (hereinafter “processing unit <b>906</b>”), a memory <b>912</b>, a bus <b>910</b>, and input/output (I/O) interfaces <b>908</b>. Further, the computer system <b>904</b> is shown in communication with external I/O devices/resources <b>924</b> and storage system <b>922</b>. In general, processing unit <b>906</b> executes computer program code, such as the Java integrated development environment (IDE) application <b>914</b> for correcting semantic errors within code being developed, using code snippets. While executing computer program code, the processing unit <b>906</b> can read and/or write data to/from memory <b>912</b>, storage system <b>922</b>, and/or I/O interfaces <b>908</b>. For instance, in one embodiment, the Java integrated development environment (IDE) application <b>914</b> stores the code snippets <b>928</b> within storage <b>922</b>. Alternatively, the data stored in storage <b>922</b> may be stored in a separate storage within the system <b>904</b>. Bus <b>910</b> provides a communication link between each of the components in computer system <b>900</b>, such that information can be communicated within the infrastructure <b>902</b>. External devices <b>924</b> can comprise any devices (e.g., keyboard, pointing device, display, etc.) that enable a user (developer or programmer) to interact with computer system <b>900</b> and/or any devices (e.g., network card, modem, etc.) that enable server <b>904</b> to communicate with one or more other computing devices.

0034Computer infrastructure <b>902</b> is only illustrative of various types of computer infrastructures for implementing the invention. For example, in an embodiment shown, computer infrastructure <b>902</b> comprises two or more computing devices (e.g., a server cluster) that communicate over a network to perform the various process steps of the invention. Moreover, computer system <b>900</b> is only representative of various possible computer systems that can include numerous combinations of hardware. To this extent, in other embodiments, computer system <b>900</b> can comprise any specific purpose computing article of manufacture comprising hardware and/or computer program code for performing specific functions, any computing article of manufacture that comprises a combination of specific purpose and general purpose hardware/software, or the like. In each case, the program code and hardware can be created using standard programming and engineering techniques, respectively. Moreover, processing unit <b>906</b> may comprise a single processing unit, or be distributed across one or more processing units in one or more locations, e.g., on a client and server. Similarly, memory <b>912</b> and/or storage system <b>922</b> can comprise any combination of various types of data storage and/or transmission media that reside at one or more physical locations. Further, I/O interfaces <b>908</b> can comprise any system for exchanging information with one or more external devices <b>924</b>. Still further, it is understood that one or more additional components (e.g., system software, math co-processing unit, etc.) not shown in <figref idref="DRAWINGS">FIG. 9</figref> can be included in computer system <b>900</b>. However, if computer system <b>900</b> comprises a handheld device or the like, it is understood that one or more external devices <b>924</b> (e.g., a display) and/or storage system(s) <b>922</b> could be contained within computer system <b>904</b>, and not externally as shown. Storage system <b>922</b> can be any type of system (e.g., a database) capable of providing storage for information under the present invention, such as the peer submitted code snippets <b>928</b>, stored in the collaboration datastore <b>926</b>. To this extent, storage system <b>922</b> could include one or more storage devices, such as a magnetic disk drive or an optical disk drive. In another embodiment, storage system <b>922</b> includes data distributed across, for example, a local area network (LAN), wide area network (WAN) or a storage area network (SAN) (not shown). Although not shown, additional components, such as cache memory, communication systems, system software, etc., may be incorporated into computer system <b>900</b>.

0035Accordingly, the invention provides a system, method, computer program product and a process for correcting semantic errors in the use of third-party libraries by using peer submitted code snippets to correct the semantic errors. A developer working with code in a code editor selects a node in the AST representation of the code identified as containing semantic errors. From a matching invocation of the associated collaboration record, the IDE presents an available set of code snippets submitted by peer developers to correct the semantic error. The developer selects and configures one or more snippets. When the code is executed, the selected code snippet is automatically invoked to correct the error.

0036The foregoing descriptions of specific embodiments of the present invention have been presented for the purpose of illustration and description. They are not intended to be exhaustive or to limit the invention to the precise forms disclosed, and obviously many modifications and variations are possible in light of the above teaching. The embodiments were chosen and described in order to best explain the principles of the invention and its practical application, to thereby enable others skilled in the art to best utilize the invention and various embodiments with various modifications as are suited to the particular use contemplated. It is intended that the scope of the invention be defined by the claims appended hereto and their equivalents.