DETAILED ACTION
This action is in response to the claims filed June 14, 2024. Claims 1-8 are pending. Claim 1 is independent claims.
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Claim Objections
Claim 1 is objected to because of the following informalities:
- Claim 1 reads “uploading, by the artificial intelligence computing device,”. This should likely read “uploading, by the artificial intelligence computing device;”
Appropriate correction is required.
Claim Rejections - 35 USC § 112
The following is a quotation of 35 U.S.C. 112(b):
(b) CONCLUSION.—The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the inventor or a joint inventor regards as the invention.
The following is a quotation of 35 U.S.C. 112 (pre-AIA ), second paragraph:
The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the applicant regards as his invention.
Claims 1-8 are rejected under 35 U.S.C. 112(b) or 35 U.S.C. 112 (pre-AIA ), second paragraph, as being indefinite for failing to particularly point out and distinctly claim the subject matter which the inventor or a joint inventor (or for applications subject to pre-AIA 35 U.S.C. 112, the applicant), regards as the invention.
Claim 1 recites the limitation “uploading, by the artificial intelligence computing device”. It is unclear in this limitation what is being uploaded by the device, and to where the device is uploading to. For the purposes of examination, “uploading” is read to be “deploying” as consistent with functions presented in the specification. Claims 2-8 are rejected in view of their dependency on claim 1.
Claim 2 recites the limitation “the artificial intelligence device”. There is insufficient antecedent bases for this limitation in the claim. The limitation is interpreted to read “the artificial intelligence computing device” as is consistent with the language of claim 1. Claims 3-6 are rejected in view of their dependency on claim 1.
Claims 3 recites the limitation "the results of the unit test drafts" in line 2. There is insufficient antecedent basis for this limitation in the claim. Neither claim 3, nor claim 1 from which claim 3 is based, recites a result or any running of unit test drafts which may generate a result. For the purposes of examination, the claim is read as “a result of the unit test drafts”. Claims 4-6 are rejected in view of their dependency on claim 3.
Claim 4 recites “refracting,…the code to fix bugs”. Specifically in regards to “refracting”, it is unclear how code may be refracted to fix bugs. The limitation is interpreted to read “refactoring…the code to fix bugs” as is consistent with the specification. Claims 5-6 are rejected in view of their dependency on claim 4.
Claim 8 recites “wherein the developer and the artificial intelligence computing device are configured to create the updated code”. If is unclear how a human developer is to be configured. For the purposes of examination, the configuration is interpreted to apply only to the artificial intelligence computing device, and not to the developer.
Claim Rejections - 35 USC § 101
35 U.S.C. 101 reads as follows:
Whoever invents or discovers any new and useful process, machine, manufacture, or composition of matter, or any new and useful improvement thereof, may obtain a patent therefor, subject to the conditions and requirements of this title.
Claims 1-8 are rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Regarding claim 1, the limitations “developing code by a developer, the code being associated with a codebase…”, “updating…the developed code to provide docstrings and comments for the developed code with an Integrated Development Environment”, “providing…proposed changes to the developed code on a pipeline, and providing a risk assessment of the proposed changes to the developed code”, “generating…unit test drafts for the updated code”, and “merging, by the developer, the updated code into a branch of the codebase on the repository on a server…” as drafted, are functions that, under their broadest reasonable interpretation, recite the abstract idea of a mental process. The limitation encompasses a human mind carrying out the function through observation, evaluation, judgement, and/or opinion, or even with the aid of pen and paper. Thus, these limitations recite and call under the “Mental Processes” grouping of abstract ideas under Prong 1.
Under Prong 2, this judicial exception is not integrated into a practical application. The additional elements “by an artificial intelligence computing device” are recited at a high level of generality such that it amounts to no more than mere instructions to apply the exception using a generic computer, and/or mere computer components. See MPEP 2106.05(f). The limitations “stored on a repository within a server”, “uploading…”, and “before the updated code on the pipeline is stored within the repository” do nothing more than add the insignificant extra solution activity of merely storing and retrieving information from memory to the judicial exception. See MPEP 2106.05(g). The limitation “receiving…the developed code” does nothing more than add the insignificant extra solution activity of merely gathering and transmitting data to the judicial exception. See MPEP 2106.05(g). Accordingly, the additional elements do not integrate the recited judicial exception into a practical application and the claim is therefore directed to the judicial exception.
Under Step 2B, the claims do not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, the additional elements of “by an artificial intelligence computing device” amount to no more than mere instructions, or generic computer/computer components to carry out the exception. For the limitations ““stored on a repository within a server”, “uploading…”, and “before the updated code on the pipeline is stored within the repository”, the courts have identified merely storing and retrieving information from memory to be well-understood, routing and conventional activity. See MPEP 2106.05(d). For the limitations “receiving…the developed code”, the courts have identified mere data gathering and transmission to be well-understood, routing, and conventional activities. See MPEP 2106.05(d). Accordingly, the claims are not patent eligible under 35 U.S.C. §101.
Regarding claim 2, the limitation “updating branches of the code on the repository within the server via…the developer” is an additional mental step. The limitation “via the artificial intelligence device” merely apply generic computer/computer components to the abstract idea, which does not amount to practical application, nor to significantly more as explained above.
Regarding claim 3, the limitation “classifying the pull request by confidence level” is an additional mental step. The limitation “initiating a pull request for the results of the unit test drafts” amounts to mere data gathering and transition, which does not amount to practical application under Prong 2, nor to significantly more under Step 2B, as explained above.
Regarding claim 4, the limitations “determining a first-level confidence level for the pull request” and “refracting…the code to fix bugs and approving the pull request” are additional mental steps. The limitation “by the artificial intelligence computing device” merely apply generic computer/computer components to the abstract idea, which does not amount to practical application, nor to significantly more as explained above.
Regarding claim 5, the limitations “determining a second-level confidence level for the pull request” and “reviewing, by a reviewer, changes to the code associated with the pull request” are additional mental steps. Claim 5 does not recite additional limitations which may amount to practical application, nor amount to significantly more.
Regarding claim 6, the limitation “merging the code associated with the pull request into a codebase on a remote repository” is an additional mental step. Claim 6 does not recite additional limitations which may amount to practical application, nor amount to significantly more.
Regarding claim 7, the limitation “determining…a missing docstring for the code” is an additional mental step. The limitation “by the artificial intelligence computing device” merely apply generic computer/computer components to the abstract idea, which does not amount to practical application, nor to significantly more as explained above.
Regarding claim 8, the limitation “wherein the developer…are configured to create the updated code” is an additional mental step. The limitation “and the artificial intelligence computing device” merely apply generic computer/computer components to the abstract idea, which does not amount to practical application, nor to significantly more as explained above.
Claim Rejections - 35 USC § 103
In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis (i.e., changing from AIA to pre-AIA ) for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status.
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claims 1, 2, 7, and 8 are rejected under 35 U.S.C. 103 as being unpatentable over US 20210405976 A1 (hereinafter “Gaitonde”), in view of US 20240311146 A1 (hereinafter “M”), further in view of “Auto-Documentation for Software Development” by Zheng et. al, (hereinafter “Zheng”), further in view of Applicant Admitted Prior Art (hereinafter “AAPA”).
Regarding claim 1, Gaitonde discloses:
A method for code development with generative artificial intelligence, the method comprising (Paragraph [0005]-[0006]):
- developing code by a developer, the code being associated with a codebase stored on a repository within a server (Paragraph [0051], “The method 2000 of an example embodiment includes: establishing, by use of a data processor and a data network, a data connection with a software code repository (processing block 2010); …using a first bot of the collection of bots to perform an automatic code review of a software module from the software code repository (processing block 2030)”) [Examiner’s remarks: Developed code is saved in a software repository (software repository within a server).];
- receiving, by an artificial intelligence computing device, the developed code (Paragraph [0006], “In the particular example embodiment, the bots can be implemented using machine learning techniques, trained deep neural networks, classifiers, or other types of trainable execution models”; Paragraph [0051], “The method 2000 of an example embodiment includes: establishing, by use of a data processor and a data network, a data connection with a software code repository (processing block 2010); …using a first bot of the collection of bots to perform an automatic code review of a software module from the software code repository (processing block 2030)”) [Examiner’s remarks: The bots which run on machine learning (artificial intelligence) receive code from a software code repository for review.];
…
- uploading, by the artificial intelligence computing device (Paragraph [0006], “In the particular example embodiment, the bots can be implemented using machine learning techniques, trained deep neural networks, classifiers, or other types of trainable execution models”; Paragraph [0044], “A Deployment Bot can be configured to automatically create software builds and deployments for QA testing. Any issues found during the coding or deployment process can be logged and reported for correction or resolution during the coding process”; Paragraph [0046], “As shown in FIG. 8, a Deployment Bot can be configured to automatically create software builds and deployments for testing or production release”) [Examiner’s remarks: As noted in the 35 U.S.C. 112(b) rejection, due to lack of clarity, uploading is interpreted as deploying for the purposes of interpretation. Gaitonde discloses deploying code using artificial intelligence.],
…
- generating, by the artificial intelligence computing device, unit test drafts for the updated code (Paragraph [0006], “In the particular example embodiment, the bots can be implemented using machine learning techniques, trained deep neural networks, classifiers, or other types of trainable execution models”; Paragraph [0042], “As shown in FIG. 5, a Unit Testing Bot can be configured to generate unit test cases for testing coded software modules”) [Examiner’s remarks: The machine learning implement bots (artificial intelligence computing device) may be used to generate unit tests for the software modules (updated code).];
…
Gaitonde does not explicitly disclose:
- updating, by the artificial intelligence computing device, the developed code to provide docstrings and comments for the developed code with an Integrated Development Environment;
…
- providing, by the artificial intelligence computing device, proposed changes to the developed code on a pipeline, and providing a risk assessment of the proposed changes to the developed code;
…
- merging, by a developer, the updated code into a branch of the codebase on the repository on a server before the updated code on the pipeline is stored within the repository.
However, M discloses:
- providing, by the artificial intelligence computing device, proposed changes to the developed code on a pipeline, and providing a risk assessment of the proposed changes to the developed code (Paragraph [0014], “A computer-implemented method, in accordance with yet another aspect of the present invention, includes collecting data existing in a development system that relates to the code change request, in response to receiving a code change request to merge new code with existing code. Factors from the collected data are computed for assessing a risk of promoting the new code, the factors including at least: a developer information factor characterizing a developer of the new code, a developer availability factor characterizing an availability of the developer, and an environment health analysis factor characterizing a health of a production environment of the existing code. The factors include labeled data. Items of the labeled data that have a label indicating the item has no impact on a confidence score are filtered out prior to computing the confidence score. The factors are processed to compute the confidence score for the code change request.”; Paragraph [0057], “The new code may be submitted via a code change request, such as a pull request, sometimes also referred to as a merge request”; Paragraph [0087], “Any analytics, Artificial Intelligence (AI), and/or Machine Learning (ML) technique known in the art, but trained and/or configured according to the teachings herein, may be used to process the classified data into the factor information”) [Examiner’s remarks: The proposed changes (pull or merged code) is pushed onto a pipeline, along with a risk assessment of the code by a computing model.];
…
- merging, by a developer, the updated code into … the codebase on the repository on a server before the updated code on the pipeline is stored within the repository (Paragraph [0057], “Each developer 302-308 issues a unique pull request requesting that the new code be merged into existing code, such as source code, deployed code, etc. In the example shown, the new code is to be merged with source code stored in a project repository 310. Developer A 302 and developer C 306 are authorized developers in this example, e.g., they are listed as authorized developers in a developer information database 311. Because developer A 302 and developer C 306 are authorized, their new code is merged with the source code in the repository and deployed to production 314 with minimal or no human gatekeeping, in this example via a continuous integration and continuous deployment (CI/CD) pipeline 312”) [Examiner’s remarks: The code is merged by a developer into an existing source code in the repository for deployment in a CI/CD pipeline.].
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of M into the teachings of Gaitonde to include “providing, by the artificial intelligence computing device, proposed changes to the developed code on a pipeline, and providing a risk assessment of the proposed changes to the developed code” and “merging, by a developer, the updated code into a branch of the codebase on the repository on a server before the updated code on the pipeline is stored within the repository”. As stated in M, “The foregoing method significantly reduces the time between submitting a code change request and promotion of the new code for deployment. For example, by leveraging intelligence derived from within the development system, the human gatekeeping process can be eliminated for some code change requests based on a high confidence score” (Paragraph [0007]). Automated risk assessment and merging of code ensures that code in a repository can be updated and is kept up to date and consistent in a timely manner and reduces requirements for human intervention. Merging code is also well known in the art. Therefore, it would be obvious to one of ordinary skill in the art to combine AI driven code development with automated merging of code.
The combination of Gaitonde and M does not explicitly disclose:
- updating, by the artificial intelligence computing device, the developed code to provide docstrings and comments for the developed code with an Integrated Development Environment;
However, Zheng discloses:
- updating, by the artificial intelligence computing device, the developed code to provide docstrings and comments for the developed code with an Integrated Development Environment (Abstract, “Our integrated tool uses Deep Learning methods to construct a semantic understanding of the code. Just like machine translation in natural languages, Autodoc can translate snippets of code to comments, and insert them as short summaries inside the docstring”; Page 2, “To make code documentation more accessible, we chose to integrate the Autodoc tool into the software development process with an emphasis on the ease of use. We experimented with two areas of deployment: Integration into an IDE as a plug-in…”; Page 2, “Autodoc, in a nutshell, is a post processor for a precompiled code. By manipulating the Abstract Syntax Tree (AST) we can insert docstrings into the code automatically”) [Examiner’s remarks: An artificial intelligence (Deep learning method) is used to insert comments and docstrings into code through an IDE.];
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of Zheng into the combined teachings of Gaitonde and M to include “updating, by the artificial intelligence computing device, the developed code to provide docstrings and comments for the developed code with an Integrated Development Environment”. As stated in Zheng, “Good documentation will help shorten the development cycle and improve the overall team efficiency as well as maintainability. In today’s crowd-driven development environment, good documentation can go a long way in building a developer community from scratch. To that end, we took the first steps in building a tool called Autodoc that can assist software developers in writing better documentation faster” (Abstract). Automated documentation of code ensures code readability for code collaboration, while also demanding less time from engineers who can instead code instead of writing documentation. Therefore, it would be obvious to one of ordinary skill in the art to combine AI driven code development with identifying missing docstrings in automated docstring generation.
The combination of Gaitonde, M, and Zheng does not explicitly disclose:
- merging… the updated code into a branch of the codebase…
However, AAPA discloses:
- merging…the updated code into a branch of the codebase (Paragraph [0004], “Version control systems provide a centralized repository where all changes to the code are stored, along with information about who made the changes and when they were made. Version control systems also reduce the risk of errors and conflicts when multiple developers are working on the same codebase, and allow developers to work on their branches of the code. The branches of code can be merged back into the main codebase once the changes have been reviewed and approved”) [Examiner’s remarks: AAPA discloses the ability to merge updated code into a branch of the codebase to be merged into the main codebase. One of ordinary skill in the art understands that this may be combined with the merging of the updated code as described by Zheng.]…
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of AAPA into the combined teachings of Gaitonde, M, and Zheng to include “merging…the updated code into a branch of the codebase”. As stated in AAPA, “Utilizing version control systems, developers can keep track of changes made to the code for the software applications over time, collaborate with other developers on the same codebase, and revert to previous versions of the code if necessary…Version control systems also reduce the risk of errors and conflicts when multiple developers are working on the same codebase, and allow developers to work on their branches of the code” (Paragraph [0004]). Merging branches allows for multiple developers to work at the same time and consolidate a single version of code, retaining consistency while ensuring collaboration. Therefore, it would be obvious to one of ordinary skill in the art to combine AI driven code development with merging branches of code.
Regarding claim 2, the rejection of claim 1 is incorporated; and Gaitonde further discloses:
- updating … the code on the repository within the server via the artificial intelligence device and the developer (Paragraph [0024], “In the example embodiment, the software design and coding phase represents a phase wherein software executables and data structures are designed to a particular requirements specification and implemented in a particular programming language(s). To support this phase, the example embodiment can provide one or more bots to automate portions of the software requirements analysis, design, and coding phase. For example, the example embodiment can provide a requirements bot, a coding bot, a code review bot, and a secure bot. … The coding bot can also be configured to automatically generate executable code…In each case, the bots can be configured as rule-based automated processing modules or trained machine learning automated processing modules”; Paragraph [0040], “The automated software engineering system 200 can also have access to code repositories 212 and servers, networks, or other computing environments 214 of the code developers and quality assurance (QA) personnel. The software being developed, tested, and deployed by the automated software engineering system 200 can be stored and accessed in the code repositories 212 and servers, networks, or other computing environments 214”) [Examiner’s remarks: Developers and AI are used to update code which is saved on a repository in a server.].
The combination of Gaitonde, M, and Zheng does not explicitly disclose:
- updating branches of the code…
However, AAPA discloses:
- updating branches of the code … (Paragraph [0004], “Version control systems provide a centralized repository where all changes to the code are stored, along with information about who made the changes and when they were made. Version control systems also reduce the risk of errors and conflicts when multiple developers are working on the same codebase, and allow developers to work on their branches of the code. The branches of code can be merged back into the main codebase once the changes have been reviewed and approved”).
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of AAPA into the combined teachings of Gaitonde, M, and Zheng to include “updating branches of the code”. As stated in AAPA, “Utilizing version control systems, developers can keep track of changes made to the code for the software applications over time, collaborate with other developers on the same codebase, and revert to previous versions of the code if necessary…Version control systems also reduce the risk of errors and conflicts when multiple developers are working on the same codebase, and allow developers to work on their branches of the code” (Paragraph [0004]). Merging branches allows for multiple developers to work at the same time and consolidate a single version of code, retaining consistency while ensuring collaboration. Therefore, it would be obvious to one of ordinary skill in the art to combine AI driven code development with merging branches of code.
Regarding claim 7, the rejection of claim 1 is incorporated; and the combination of Gaitonde and M does not explicitly disclose:
- determining, by the artificial intelligence computing device, a missing docstring for the code.
However, Zheng discloses:
- determining, by the artificial intelligence computing device, a missing docstring for the code (Abstract, “Our integrated tool uses Deep Learning methods to construct a semantic understanding of the code. Just like machine translation in natural languages, Autodoc can translate snippets of code to comments, and insert them as short summaries inside the docstring”; Page 2, “In the step (Box 2), we parse the source code to extract an AST data structure that is used to detect and extract the docstring components from the code including the location of docstring in the code. If a docstring field is missing, we will then synthesize a new docstring and insert it into the code”) [Examiner’s remarks: If the docstring field (docstring for the code) is missing, it is identified and a docstring created and inserted into the code. This may be completed by an AI computing device (deep learning).].
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of Zheng into the combined teachings of Gaitonde and M to include “determining, by the artificial intelligence computing device, a missing docstring for the code”. As stated in Zheng, “Good documentation will help shorten the development cycle and improve the overall team efficiency as well as maintainability. In today’s crowd-driven development environment, good documentation can go a long way in building a developer community from scratch. To that end, we took the first steps in building a tool called Autodoc that can assist software developers in writing better documentation faster” (Abstract). Automated documentation of code ensures code readability for code collaboration, while also demanding less time from engineers who can instead code instead of writing documentation. Therefore, it would be obvious to one of ordinary skill in the art to combine AI driven code development with identifying missing docstrings in automated docstring generation.
Regarding claim 8, the rejection of claim 1 is incorporated; and Gaitonde further discloses:
- wherein the developer and the artificial intelligence computing device are configured to create the updated code (Paragraph [0024], “The coding bot can also be configured to automatically generate executable code…In each case, the bots can be configured as rule-based automated processing modules or trained machine learning automated processing modules. The training of the machine learning, neural network, or classifier bots is described in more detail below. The bots supporting the software design and coding phase of the SDLC can analyse completed software modules or automatically generate executable code in serial or in parallel and may be executed around the clock to significantly speed up the automatic generation and validation of the designed and coded software modules during the software design and coding phase”; Paragraph [0032], “The automated software engineering system 200 can be configured to provide data communications for the user platforms 140 serving as networked platforms for project managers and senior management at management platforms 120, process group coordinators at process group platforms 125, software developers at developer platforms 130, and system administrators at system administrative platforms 135. The automated software engineering system 200 can provide SDLC information in a digital or computer-readable form to these user platforms 140 via the network 115”) [Examiner’s remarks: The developer and machine learning automated developer platforms can work together to create updated code.].
Claims 3-6 are rejected under 35 U.S.C. 103 as being unpatentable over US 20210405976 A1 (hereinafter “Gaitonde”), in view of US 20240311146 A1 (hereinafter “M”), further in view of “Auto-Documentation for Software Development” by Zheng et. al, (hereinafter “Zheng”), further in view of Applicant Admitted Prior Art (hereinafter “AAPA”), and further in view of US 20200019493 A1 (hereinafter “Ramakrishna”).
Regarding claim 3, the rejection of claim 2 is incorporated; and Gaitonde does not explicitly disclose:
- initiating a pull request for the results of the unit test drafts;
- classifying the pull request by confidence level.
However, M discloses:
- initiating a pull request for … (Paragraph [0057], “The new code may be submitted via a code change request, such as a pull request, sometimes also referred to as a merge request”);
- classifying the pull request by confidence level (Paragraph [0014], “A computer-implemented method, in accordance with yet another aspect of the present invention, includes collecting data existing in a development system that relates to the code change request, in response to receiving a code change request to merge new code with existing code. Factors from the collected data are computed for assessing a risk of promoting the new code, the factors including at least: a developer information factor characterizing a developer of the new code, a developer availability factor characterizing an availability of the developer, and an environment health analysis factor characterizing a health of a production environment of the existing code. The factors include labeled data. Items of the labeled data that have a label indicating the item has no impact on a confidence score are filtered out prior to computing the confidence score. The factors are processed to compute the confidence score for the code change request.”; Paragraph [0057], “The new code may be submitted via a code change request, such as a pull request, sometimes also referred to as a merge request”) [Examiner’s remarks: A proposed code change request (pull request) can be classified by confidence level.].
The combination of Gaitonde, M, Zheng, and AAPA does not explicitly disclose:
- … the results of the unit test drafts;
However, Ramakrishna discloses:
- … the results of the unit test drafts (Paragraph [0003], “The method may include updating, based on the unit test result and the functional test result, the new software code to generate updated new software code, and automatically deploying the updated new software code in a quality assurance environment. The method may include selecting a regression test from a plurality of regression tests, where the regression test is to be performed on the updated new software code, and performing, via the quality assurance environment, the regression test on the updated new software code to generate a regression test result. The method may include updating, based on the regression test result, the updated new software code to generate final software code, and automatically deploying the final software code in a production environment for execution”) [Examiner’s remarks: Gaitonde disclosed generating unit tests for code. Ramakrishna discloses running said tests and obtaining the results. One of ordinary skill in the art understands that the methods of Gaitonde and Ramakrishna may be combined to obtain test results which may be pulled (obtained) for any given pull request of a new code.];
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of Ramakrishna into the combined teachings of Gaitonde, M, Zheng, and AAPA to include “the results of the unit test drafts”. As stated in Ramakrishna, “In this way, the software deployment platform may improve the quality of software code changes and may reduce defect rates in software code changes. The software deployment platform may reduce test execution time and may provide a consolidated view for tracking software development status from requirement creation to deployment in a production environment” (Paragraph [0013]). Automated code testing, changes, and deployment allow for more accurate code in production, while reducing the number of man hours required to ensure code functionality. Obtaining results from code testing allows the developer to know what is wrong with a given piece of code for debugging. Therefore, it would be obvious to one of ordinary skill in the art to combine AI driven code development with retrieval of unit testing results.
Regarding claim 4, the rejection of claim 3 is incorporated; and Gaitonde does not explicitly disclose:
- determining a first-level confidence level for the pull request, and refracting, by the artificial intelligence computing device, the code to fix bugs and approving the pull request.
However, M discloses:
- determining a first-level confidence level for the pull request, … and approving the pull request (Paragraph [0007], “The foregoing method significantly reduces the time between submitting a code change request and promotion of the new code for deployment. For example, by leveraging intelligence derived from within the development system, the human gatekeeping process can be eliminated for some code change requests based on a high confidence score. Accordingly, the inherent delays of such human gatekeeping process are avoided”; Paragraph [0145], “For example, by leveraging intelligence derived from within the development system, the human gatekeeping process can be eliminated for some code change requests based on a high confidence score”).
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of M into the teachings of Gaitonde to include “determining a first-level confidence level for the pull request, …and approving the pull request”. As stated in M, “The foregoing method significantly reduces the time between submitting a code change request and promotion of the new code for deployment. For example, by leveraging intelligence derived from within the development system, the human gatekeeping process can be eliminated for some code change requests based on a high confidence score” (Paragraph [0007]). Automated merging of code ensures that code in a repository can be updated and is kept up to date and consistent. Merging code is also well known in the art. Therefore, it would be obvious to one of ordinary skill in the art to combine AI driven code development with automated merging of code.
The combination of Gaitonde, M, Zheng, and AAPA does not explicitly disclose:
- … and refracting, by the artificial intelligence computing device, the code to fix bugs…
However, Ramakrishna discloses:
and refracting, by the artificial intelligence computing device, the code to fix bugs (Paragraph [0003], “The method may include updating, based on the unit test result and the functional test result, the new software code to generate updated new software code, and automatically deploying the updated new software code in a quality assurance environment. The method may include selecting a regression test from a plurality of regression tests, where the regression test is to be performed on the updated new software code, and performing, via the quality assurance environment, the regression test on the updated new software code to generate a regression test result. The method may include updating, based on the regression test result, the updated new software code to generate final software code, and automatically deploying the final software code in a production environment for execution”; Paragraph [0018, “In some implementations, the software deployment platform may process the software code and the software code change, with a model (e.g., a machine learning model), to determine the one or more tasks to implement the software code change”) [Examiner’s remarks: Ramakrishna discloses using AI to refactor (update) code based on unit test results.]
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of Ramakrishna into the combined teachings of Gaitonde, M, Zheng, and AAPA to include “and refracting, by the artificial intelligence computing device, the code to fix bugs”. As stated in Ramakrishna, “In this way, the software deployment platform may improve the quality of software code changes and may reduce defect rates in software code changes. The software deployment platform may reduce test execution time and may provide a consolidated view for tracking software development status from requirement creation to deployment in a production environment” (Paragraph [0013]). Automated code testing, changes, and deployment allow for more accurate code in production, while reducing the number of man hours required to ensure code functionality. Therefore, it would be obvious to one of ordinary skill in the art to combine AI driven code development with AI driven debugging.
Regarding claim 5, the rejection of claim 4 is incorporated; and Gaitonde does not explicitly disclose:
- determining a second-level confidence level for the pull request, and reviewing, by a reviewer, changes to the code associated with the pull request;
However, M discloses:
- determining a second-level confidence level for the pull request, and reviewing, by a reviewer, changes to the code associated with the pull request (Paragraph [0007], “The foregoing method significantly reduces the time between submitting a code change request and promotion of the new code for deployment. For example, by leveraging intelligence derived from within the development system, the human gatekeeping process can be eliminated for some code change requests based on a high confidence score. Accordingly, the inherent delays of such human gatekeeping process are avoided. In other cases where the confidence score is lower because the risks are higher, the normal process can be used, e.g., a production team performs a gatekeeping process to assess the new code prior to promotion”) [Examiner’s remarks: A confidence score (confidence level) for the pull request is determined and if it is lower than acceptable, reviewers (production team) reviews the new code (code associated with the pull request) before approving it.].
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of M into the teachings of Gaitonde to include “determining a second-level confidence level for the pull request, and reviewing, by a reviewer, changes to the code associated with the pull request”. As stated in M, “Accordingly, the inherent delays of such human gatekeeping process are avoided. In other cases where the confidence score is lower because the risks are higher, the normal process can be used, e.g., a production team performs a gatekeeping process to assess the new code prior to promotion” (Paragraph [0007]). Assessing risk level to determine if code should go through human review saves time by avoiding the more time consuming human review when it is likely to be unnecessary. Therefore, it would be obvious to one of ordinary skill in the art to combine AI driven code development with risk assessment and human review.
Regarding claim 6, the rejection of claim 5 is incorporated; and Gaitonde does not explicitly disclose:
- merging the code associated with the pull request into a codebase on a remote repository.
However, M discloses:
- merging the code associated with the pull request into a codebase on a remote repository (Paragraph [0057], “Each developer 302-308 issues a unique pull request requesting that the new code be merged into existing code, such as source code, deployed code, etc. In the example shown, the new code is to be merged with source code stored in a project repository 310. Developer A 302 and developer C 306 are authorized developers in this example, e.g., they are listed as authorized developers in a developer information database 311. Because developer A 302 and developer C 306 are authorized, their new code is merged with the source code in the repository and deployed to production 314 with minimal or no human gatekeeping, in this example via a continuous integration and continuous deployment (CI/CD) pipeline 312”).
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of M into the teachings of Gaitonde to include “determining a second-level confidence level for the pull request, and reviewing, by a reviewer, changes to the code associated with the pull request”. As stated in M, “The foregoing method significantly reduces the time between submitting a code change request and promotion of the new code for deployment. For example, by leveraging intelligence derived from within the development system, the human gatekeeping process can be eliminated for some code change requests based on a high confidence score” (Paragraph [0007]). Automated merging of code ensures that code in a repository can be updated and is kept up to date and consistent. Merging code is also well known in the art. Therefore, it would be obvious to one of ordinary skill in the art to combine AI driven code development with automated merging of code.
Pertinent Prior Art
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure. - US 20190243617 A1 discloses using machine learning to analyze various aspects of changes to code.
- US 11334351 B1 discloses a machine learning system which predicts software quality based on a variety of metrics.
- US 9921948 B2 discloses using machine learning and various classifiers to determine the risk level of a new code commit.
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to VIVIAN WEIJIA DUAN whose telephone number is (703)756-5442. The examiner can normally be reached Monday-Friday 8:30AM-5PM.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Wei Y Mui can be reached at (571) 272-3708. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/V.W.D./Examiner, Art Unit 2191 /WEI Y MUI/Supervisory Patent Examiner, Art Unit 2191
Prosecution Insights