DETAILED ACTION
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA . 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 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.
Status of the application
This Office Action is in response to Applicant's Application filed on 04/08/2024. Claims 1-20 are pending for this examination.
Examiner Interview
Examiner initiated an interview with the attorney Mr. Bryan S. Wade (Reg # 58,228). Examiner found allowable subject matter in the claim set and requested the attorney to consider some proposed amendments for advancing prosecution. Attorney tried to contact his client with the proposal. However, apparently the attorney did not get a chance to discuss the proposed amendments with the client.
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-20 are rejected under 35 U.S.C 101 because the claimed invention is directed to an abstract idea without significantly more. The claims do not fall within at least one of the four categories of patent eligible subject matter because the claimed invention is directed to an abstract idea without significantly more. This judicial exception is not integrated into a practical application.
For claim 1,
Step 1 – All limitations directed to statutory subject matter: Yes
Step 2A – Prong 1: Does claim 1 recite an abstract idea? Yes
Claim 1 recites “automatically”; and “extracting dependency information from a file of a program…; from at least the dependency information, constructing a dependency set which identifies a set of candidate build dependencies of the program; utilizing the dependency set to generate program representations, including an expression type representation which represents an expression type of an expression of the program, and a call target representation which represents a call target of the program; and emitting at least a portion of each of the program representations; wherein the extracting, constructing, utilizing, and emitting are performed without building the program…” which recites functions that can be reasonably carried out in the human mind with the aid of pen and paper, through observation, evaluation, judgment, opinion, thus it is reasonable to analyze this limitation as reciting a mental process.
Step 2A – Prong 2: Does the additional element integrate the judicial exception into a practical application? No
The additional elements of “automatically” and “ the extracting performed by a dependency extraction tool in a dependency extraction tool execution…wherein the dependency extraction tool is external to any compiler or any interpreter which has an executable code generation capability, and wherein the dependency extraction tool execution is free of any completed and successful attempt to build an executable version of the program” merely recite instructions to implement an abstract idea on a generic computer, or merely uses a generic computer or computer components as a tool to perform the abstract idea and it does not integrated the judicial exception into a practical application. See MPEP 2106.05(f)
Step 2B – Does the additional element amount to significantly more than the judicial exception? Does the claim recite an inventive concept? No
The additional elements of “automatically” and “ the extracting performed by a dependency extraction tool in a dependency extraction tool execution…wherein the dependency extraction tool is external to any compiler or any interpreter which has an executable code generation capability, and wherein the dependency extraction tool execution is free of any completed and successful attempt to build an executable version of the program” merely recite instructions to implement an abstract idea on a generic computer, or merely uses a generic computer or computer components as a tool to perform the abstract idea and they do not amount to significant more than the judicial exceptions, See MPEP 2106.05(f)
For claim 11,
Step 1 – All limitations directed to statutory subject matter: Yes
Step 2A – Prong 1: Does claim 1 recite an abstract idea? Yes
Claim 11 recites “… perform a buildless dependency set construction method which comprises extracting dependency information from a file of a program, constructing a dependency set from at least the dependency information, the dependency set identifying a set of candidate build dependencies of the program, the dependency set residing in and configuring the at least one digital memory, generating a program representation which is consistent with at least one candidate build dependency of the dependency set, the program representation including an expression type representation which represents an expression type of an expression of the program or a call target representation which represents a call target of the program, or both, and emitting at least a portion of the program representation; and wherein the extracting, constructing, generating, and emitting are performed without building an executable version of the program” which recites functions that can be reasonably carried out in the human mind with the aid of pen and paper, through observation, evaluation, judgment, opinion, thus it is reasonable to analyze this limitation as reciting a mental process.
Step 2A – Prong 2: Does the additional element integrate the judicial exception into a practical application? No
The additional elements of “a computing system, comprising: at least one digital memory; at least one processor in operable communication with the at least one digital memory, the at least one processor configured to perform…” merely recite instructions to implement an abstract idea on a generic computer, or merely uses a generic computer or computer components as a tool to perform the abstract idea and it does not integrated the judicial exception into a practical application. See MPEP 2106.05(f)
Step 2B – Does the additional element amount to significantly more than the judicial exception? Does the claim recite an inventive concept? No
The additional elements of “a computing system, comprising: at least one digital memory; at least one processor in operable communication with the at least one digital memory, the at least one processor configured to perform…” merely recite instructions to implement an abstract idea on a generic computer, or merely uses a generic computer or computer components as a tool to perform the abstract idea and they do not amount to significant more than the judicial exceptions, See MPEP 2106.05(f)
For claim16
Step 1 – All limitations directed to statutory subject matter: Yes
Step 2A – Prong 1: Does claim 16 recite an abstract idea? Yes
Claim 16 recites “…perform a buildless dependency set construction method … the method comprising…extracting dependency information from a file of a program, the extracting performed …; from at least the dependency information, constructing a dependency set which identifies a set of candidate build dependencies of the program; utilizing the dependency set to generate program representations; and emitting at least a portion of the program representations; wherein the extracting, constructing, utilizing, and emitting are performed without building the program…” which recites functions that can be reasonably carried out in the human mind with the aid of pen and paper, through observation, evaluation, judgment, opinion, thus it is reasonable to analyze this limitation as reciting a mental process.
Step 2A – Prong 2: Does the additional element integrate the judicial exception into a practical application? No
The additional elements of “A computer-readable storage device configured with data and instructions which upon execution by a processor perform” “automatically”, “…performed by an execution of a dependency extraction tool… wherein the execution of the dependency extraction tool is free of any completed and successful attempt to build a full executable version of the program” merely recite instructions to implement an abstract idea on a generic computer, or merely uses a generic computer or computer components as a tool to perform the abstract idea and it does not integrated the judicial exception into a practical application. See MPEP 2106.05(f)
Step 2B – Does the additional element amount to significantly more than the judicial exception? Does the claim recite an inventive concept? No
The additional elements of “A computer-readable storage device configured with data and instructions which upon execution by a processor perform” “automatically”, “…performed by an execution of a dependency extraction tool… wherein the execution of the dependency extraction tool is free of any completed and successful attempt to build a full executable version of the program” merely recite instructions to implement an abstract idea on a generic computer, or merely uses a generic computer or computer components as a tool to perform the abstract idea and they do not amount to significant more than the judicial exceptions . See MPEP 2106.05(f)
Claim 2 recites “further comprising adhering to a version selection priority order while constructing the dependency set, wherein the version selection priority order specifies a version recited in a repository as a high priority choice, specifies an installed version as a medium priority choice, and specifies a latest version as a low priority choice.” This is a description of how a dependency set constructed. Here “constructing” and “specifies” are mental processes, which do not show a practical use of the abstract idea.
Claim 3 recites “gathering a list of program component identifications”. This is adding an mental process added to an abstract idea, which does not show a practical use of the abstract idea.
Claim 4 recites “further comprising deduplicating the list of program component identifications”. Here deduplicating is mental process, which does not show a practical use of the abstract idea.
Claim 5 recites “categorizing program component identifications”. Here “categorizing” is a mental process, which does not show a practical use of the abstract idea.
Claim 6 recites “generating a markup language file, and converting the markup language”. Here “generating” and “converting” are insignificant extra solution activity, which does not show a practical use of the abstract idea.
Claims 7, 8, 9 and 10 all recite “constructing the dependency set”. Here constructing is a mental process.
Claim 12 and 13 further describes the “dependency extraction tool”. Hence it merely describes an abstract idea.
Claim 14 and 15 are substantially similar to claim 7 and hence can be shown that they patent eligible.
Claim 17, 18, 19 and 20 describe the method, where the method is an abstract idea. Hence these claims are part of the abstract idea.
Claim Rejections - 35 USC § 102
The following is a quotation of the appropriate paragraphs of 35 U.S.C. 102 that form the basis for the rejections under this section made in this Office action:
A person shall be entitled to a patent unless –
(a)(1) the claimed invention was patented, described in a printed publication, or in public use, on sale, or otherwise available to the public before the effective filing date of the claimed invention.
Claims 1, 11, 12 and 16 Claims are rejected under 35 U.S.C. 102(a)(1) as being anticipated by Sharma et al (hereinafter Sharma, Patent No.: US 9,531,745).
As per claim 1, Sharma teaches,
A buildless dependency set construction method performed in a computing system,
the method comprising automatically:
extracting dependency information from a file of a program, the extracting performed by a dependency extraction tool in a dependency extraction tool execution; from at least the dependency information, constructing a dependency set which identifies a set of candidate build dependencies of the program; (Sharma recites in column 14, starting at line 14, “In either case, the discovery operation extracts the metadata from such a project to find the build dependencies that would be needed for the generation of the abstract program representation.” This shows dependency information extraction.)
utilizing the dependency set to generate program representations, (Sharma recites in column 14, starting at line 14, “In either case, the discovery operation extracts the metadata from such a project to find the build dependencies that would be needed for the generation of the abstract program representation.” This shows dependency is used for generating an abstract program representation, which is a “program representation”.)
including an expression type representation which represents an expression type of an expression of the program, and (Sharma recites in column 13 starting at line 28, “function-definition={function-name, formal-variables, local-variables, operations}”. Here expression type is “function-definition”, then it shows the expression.)
a call target representation which represents a call target of the program; and (Sharma recites in column 13 starting at line 35, “simple-call-operation = {caller-signature, callee-signature, arguments}”. This shows call target representation.)
emitting at least a portion of each of the program representations; (Sharma shows in Fig. 6 step 604 generation of the abstract program representation and in step 606 serializing and archiving in to ARSA (Archive for security analysis) file. Sharma recites in column 12 starting at line 34 “With this approach, the ARSA file 518 is protected from being reverse-engineered even if it moved off-premises (into the cloud) or otherwise shared with other users, teams and even organizations.” This shows that the ARSA file which includes the abstract program representation is distributed to other teams.)
wherein the extracting, constructing, utilizing, and emitting are performed without building the program; and (Sharma Figs. 6 and 7 show the steps of extracting from a code component, running the “Generator tool” [step 706] to create the abstract program representation and then serialize and archive and then distribute the abstract program representation. The figure does not show any “building the program” from the construction of the dependency set. Step 702 shows discovery operation. Sharma recites in column 14, starting at line 14, “In either case, the discovery operation extracts the metadata from such a project to find the build dependencies that would be needed for the generation of the abstract program representation.” Fig. 7 or anywhere else, the prior art does not teach creation of an executable.)
wherein the dependency extraction tool is external to any compiler or any interpreter which has an executable code generation capability, and wherein the dependency extraction tool execution is free of any completed and successful attempt to build an executable version of the program. (Sharma Fig. 7 shows a “generator tool”. Sharma recites in column 11 starting at line 42, “An abstract program representation refers to a highly-compact version of the actual source code it represents. An APR for a particular source code component is generated automatically, preferably from either an existing build system or a source repository, and it is then encapsulated into a particular binary format for consumption by static application security tools, which may operate on premises or via a cloud-based services platform.” This shows that “generator tool” is separate from the build system and runs separately from system building. System building generates an executable version of the program and it is not part of the “generator tool”.)
As per claim 11, Sharma teaches
A computing system, (Sharma Fig. 2 shows a computing system)
comprising:
at least one digital memory; (Sharma Fig. 2 box 206)
at least one processor in operable communication with the at least one digital memory, (Sharma Fig. 2 box 204)
the at least one processor configured to perform a buildless dependency set construction method which comprises extracting dependency information from a file of a program, constructing a dependency set from at least the dependency information, the dependency set identifying a set of candidate build dependencies of the program, (Sharma recites in column 14, starting at line 14, “In either case, the discovery operation extracts the metadata from such a project to find the build dependencies that would be needed for the generation of the abstract program representation.” This shows dependency information extraction.)
the dependency set residing in and configuring the at least one digital memory,
generating a program representation which is consistent with at least one candidate build dependency of the dependency set, (Sharma recites in column 14, starting at line 14, “In either case, the discovery operation extracts the metadata from such a project to find the build dependencies that would be needed for the generation of the abstract program representation.” This shows that “build dependency [or dependency set] would be needed”. This means the dependency set is saved in memory to be used later. This also shows that the dependency set is used for generating an abstract program representation, which is a “program representation”.)
the program representation including an expression type representation which represents an expression type of an expression of the program or (Sharma shows an example of an abstract program representation in column 13 lines 25-38. Sharma recites in column 13 starting at line 28, “function-definition={function-name, formal-variables, local-variables, operations}”. Here expression type is “function-definition”, then it shows the expression.)
a call target representation which represents a call target of the program, or both, (Sharma recites in column 13 starting at line 35, “simple-call-operation = {caller-signature, callee-signature, arguments}”. This shows call target representation.)
and emitting at least a portion of the program representation; and (Sharma shows in Fig. 6 step 604 generation of the abstract program representation and in step 606 serializing and archiving in to ARSA (Archive for security analysis) file. Sharma recites in column 12 starting at line 34 “With this approach, the ARSA file 518 is protected from being reverse-engineered even if it moved off-premises (into the cloud) or otherwise shared with other users, teams and even organizations.” This shows that the ARSA file which includes the abstract program representation is distributed to different teams.)
wherein the extracting, constructing, generating, and emitting are performed without building an executable version of the program. (Sharma Fig. 7 shows the steps of extracting from a code component, running the “Generator tool” to create the abstract program representation and then serialize and archive and then distribute the abstract program representation. Fig. 6 and 7 shows extraction, construction, and generating of build dependency set and creation of abstract program representation and distribution. Sharma recites in column 14, starting at line 14, “In either case, the discovery operation extracts the metadata from such a project to find the build dependencies that would be needed for the generation of the abstract program representation.” Fig. 7 or anywhere else, the prior art does not teach creation of an executable.)
As per claim 12, Sharma teaches,
comprising a dependency extraction tool residing in and configuring the at least one digital memory, wherein the extracting, constructing, generating, and emitting are each performed at least in part by executing at least a portion of the dependency extraction tool, and (Sharma Figs 6 and 7 show the steps of extracting from a code component, running the Generator tool to create dependency set and then create an abstract program representation from the dependency set. Then the abstract program representation is serialized and archived and then distributed. The figure does not explicitly show construction of the dependency set. However, step 702 shows discovery operation. Sharma recites in column 14, starting at line 14, “In either case, the discovery operation extracts the metadata from such a project to find the build dependencies that would be needed for the generation of the abstract program representation.” Fig. 7 or anywhere else, the prior art does not teach creation of an executable.)
wherein the dependency extraction tool is external to any compiler or any interpreter which has an executable code generation capability. (Sharma recites in column 11 starting at line 42, “An abstract program representation refers to a highly-compact version of the actual source code it represents. An APR for a particular source code component is generated automatically, preferably from either an existing build system or a source repository, and it is then encapsulated into a particular binary format for consumption by static application security tools, which may operate on premises or via a cloud-based services platform.” This shows that “generator tool” is separate from the build system and runs separately from system building to an executable file.)
As per claim 16, this is a computer-readable storage claim that substantially parallels the limitations of the method claim 1. It would have been obvious to one of ordinary skill in the art before the time of the effective filing date of the invention to implement the prescribed method steps as a computer-readable storage method.
Claim Rejections - 35 USC § 103
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 3 and 20 are rejected under AIA 35 U.S.C. 103 as being unpatentable over Sharma as applied to claims 1 and 16 in view of Dongsheng et al. (hereinafter Dongsheng, CN116679930A).
As per claim 3, Sharma teaches dependency set extraction from build artifacts. Sharma does not teach “further comprising: gathering a list of program component identifications from at least one of: a restored package, a name-value parameter persisted data file, a restored file containing a list of files included in a project, a list of restored packages, or a project dependency graph file; and including the list of program component identifications in the dependency set.” However, in analogous art of dependency set creation, Dongsheng teaches,
further comprising:
gathering a list of program component identifications from at least one of:
a restored package, a name-value parameter persisted data file, a restored file containing a list of files included in a project, a list of restored packages, or a project dependency graph file; and including the list of program component identifications in the dependency set. (DongSheng recites in [0010] “The identifier generation module is used to obtain the list of dependency files of the target front-end project to be built, and generate file identifiers based on the list of dependency files.”)
Therefore, it would have been obvious to a person of the ordinary skill in the art before the effective filling date of the invention to modify the above teaching of Sharma of dependency set creation by incorporating the teaching “further comprising:
gathering a list of program component identifications from at least one of:
a restored package, a name-value parameter persisted data file, a restored file containing a list of files included in a project, a list of restored packages, or a project dependency graph file; and including the list of program component identifications in the dependency set.” of Dongsheng. The modification would have been obvious because one of the ordinary skills of the art would have implemented the function of creating an index list of dependency files so that the dependency files can be appropriately managed and dependency tree can be conveniently built and maintained.)
As per claim 20, DongSheng teaches,
wherein the method comprises gathering a program component identification from at least a restored file containing a list of files included in a project. (DongSheng recites in [0010] “The identifier generation module is used to obtain the list of dependency files of the target front-end project to be built, and generate file identifiers based on the list of dependency files.”)
Claim 6 is rejected under AIA 35 U.S.C. 103 as being unpatentable over Sharma as applied to claim 1 in view of Barcellona (Publication No.: US 2008/0127040).
As per Claim 6, Sharma teaches dependency set extraction from build artifacts. Sharma does not teach “further comprising: generating a markup language file, and converting the markup language file to a programming language source code of the program.” However, in analogous art of dependency set creation, Barcellona teaches,
further comprising: generating a markup language file, and converting the markup language file to a programming language source code of the program. (Barcellona recites in [0011] “Many modern code generators, such as those introduced in conjunction with Microsoft Corporation's Software Factories Initiative, generate source code using markup-language templates, which resembles server-sides scripts written in ASP or PHP in that they embed executable code in special markup language tags.”)
Therefore, it would have been obvious to a person of the ordinary skill in the art before the effective filling date of the invention to modify the above teaching of Sharma of dependency set creation by incorporating the teaching “further comprising: generating a markup language file, and converting the markup language file to a programming language source code of the program” of Barcellona. The modification would have been obvious because one of the ordinary skills of the art would have implemented the function of generating a markup language file and converting it to a source code. Creating a markup language is easier and more intuitive than creating a source code.
Claims 7 and 14 are rejected under AIA 35 U.S.C. 103 as being unpatentable over Sharma as applied to claims 1 and 11 in view of Zhiyu (Publication No.: WO2019227899).
As per claim 7, Sharma teaches dependency set extraction from build artifacts. Sharma does not teach “wherein constructing the dependency set comprises at least one of: producing an index which maps a package to a list of one or more classes which are used in the package; producing an index which maps a package onto an archive file.” However, in analogous art of dependency set creation, Zhiyu teaches,
wherein constructing the dependency set comprises at least one of:
producing an index which maps a package to a list of one or more classes
which are used in the package; or (Zhiyu recites in claim 4, “If the second element is a string, then the second element itself is used as the index value corresponding to the second element; If the second element is a class, then the name of the second element is used as the index value corresponding to the second element;”.)
producing an index which maps a package onto an archive file. (Not considered)
Therefore, it would have been obvious to a person of the ordinary skill in the art before the effective filling date of the invention to modify the above teaching of Sharma of dependency set creation by incorporating the teaching “wherein constructing the dependency set comprises at least one of: producing an index which maps a package to a list of one or more classes which are used in the package; producing an index which maps a package onto an archive file.” of Zhiyu. The modification would have been obvious because one of the ordinary skills of the art would have implemented the function of generating indices for classes in a dependency set such that the dependency set can be managed conveniently.
As per claim 14, Zhiyu teaches,
wherein constructing the dependency set comprises using an index which maps a package to a list of one or more classes which are used in the package. (Zhiyu recites in claim 4, “If the second element is a string, then the second element itself is used as the index value corresponding to the second element; If the second element is a class, then the name of the second element is used as the index value corresponding to the second element;”.)
References of Note
Examiner has cited particular columns, line numbers, references, or figures in the references applied to the claims above for the convenience of the applicant. Although the specified citations are representative of the teachings of the art and are applied to specific limitations within the individual claim, other passages and figures may apply as well. It is respectfully requested from the applicant in preparing responses to fully consider the reference in entirety, as potentially teaching all or part of the claimed invention. See MPEP §§ 2141.02 and 2123.
Contact Information
Any inquiry concerning this communication or earlier communications from the examiner should be directed to HOSSAIN MORSHED whose telephone number is (571)272-3335. The examiner can normally be reached on Monday – Friday12:00 PM – 9 PM Eastern Time. The email address for the examiner is hossain.morshed@uspto.gov.
Examiner interviews are available via telephone or 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 Mui can be reached on (571)272-3708.
/HOSSAIN M MORSHED/Primary Examiner, Art Unit 2191
April 2, 2026
Prosecution Insights