DETAILED ACTION
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 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-3 are rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more. Claim 1 recites, “parsing a source code statement…”, “finding dependencies of the programming language construct” and “deactivating the programming language construct and the dependencies”. The limitations of “parsing”, “finding” and “deactivating” as drafted are functions that, under their broadest reasonable interpretation, recite the abstract idea of a mental process. The limitations encompass a human mind carrying out the function through observation, evaluation, judgment and /or opinion, or even with the aid of pen and paper. Thus, this limitation recites and falls within 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 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. Accordingly, claim 1 is not patent eligible under 35 USC 101.
Claim 2, claims “evaluating whether the condition is satisfied”, the step of “evaluating” is an additional limitation of the abstract idea “mental process”. Nothing in the claimed limitation prevents this limitation from being performed in the mind. The examiner states that if the condition is not satisfied then the compiling step is not performed. Therefore, the additional elements of the compiling step is neither a practical application under prong 2, nor an inventive concept under step 2B.
Claim 3, claims further defines a condition. The additional elements are neither a practical application under prong 2, nor an inventive concept under step 2B
Claims 16-23 are rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more. Claim 1 recites, “encountering a statement naming a construct”, “identifying a dependency” and “deactivating the construct and the dependency”. The limitations of “encountering”, “identify” and “deactivating” as drafted are functions that, under their broadest reasonable interpretation, recite the abstract idea of a mental process. The limitations encompass a human mind carrying out the function through observation, evaluation, judgment and /or opinion, or even with the aid of pen and paper. Thus, this limitation recites and falls within 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 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. Accordingly, claim 1 is not patent eligible under 35 USC 101.
Claim 17, further defines the construct. The additional elements are neither a practical application under prong 2, nor an inventive concept under step 2B.
Claim 18, further defines the dependency. The additional elements are neither a practical application under prong 2, nor an inventive concept under step 2B.
Claim 19, further defines the construct modification tag. The additional elements are neither a practical application under prong 2, nor an inventive concept under step 2B.
Claim 20, further defines the condition. The additional elements are neither a practical application under prong 2, nor an inventive concept under step 2B.
Claim 21, claims “evaluating the computation function with the construct and dependency deactivated…”, “evaluating the computational functions with the construct and the dependency activated…”, and “comparing the first of the computational outputs with the second of the computational outputs”. The steps of “evaluating”, “evaluating” and “comparing” are additional steps of the abstract idea “mental process”. Nothing in the claimed limitations prevents the limitations from being performed in the mind.
Claim 22, claims “marking the construct as non-essential”. The step of “marking” is an additional limitation of the abstract idea “mental process”. Nothing in the claimed limitations prevents the limitations from being performed in the mind.
Claim 23, claims “marking the dependency as non-essential”. The step of “marking” is an additional limitation of the abstract idea “mental process”. Nothing in the claimed limitations prevents the limitations from being performed in the mind.
Claim Rejections - 35 USC § 102
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.
(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.
Claim 16-20 are rejected under 35 U.S.C. 102a1 as being anticipated by Agarwal et al. (US 2017/0068647 A1).
As per claim 16, Agarwal et al. further teaches, A method of compiling source code for a computer program, the method comprising:
encountering a statement naming a construct of the source code, the statement including a construct-modification tag conveying a compiler request; and
responsive to the compiler request, identifying a dependency of the construct; and
deactivating the construct and the dependency of the construct.”
Agarwal et al. further teaches, if a developer seeks to isolate a problem in a declarative file by commenting out a single declaration, the editor of embodiments may act to identify and comment out the identified declaration as well as nonidentified but applicable dependencies, applicable to the text or object to be commented out (0019-0020). Also see 0028.
Agarwal et al. teaches, as shown in figure 2 lines of text (source code) that have been processed with a Comment_Out action. Each of the lines that are commented out begins with a “##” (keyword) as an indicator for a compiler not to run these specific lines (programming language construct) of scripts. Other symbols besides the “##” may be used, with the preferred syntax chosen being consistent with the compiler anticipated to compile the script for execution (0031). Agarwal et al. teaches an editor can compile but not run the commented-out text (0008).
As per claim 17, Agarwal et al. further teaches, “The method of claim 16, wherein the construct comprises at least one of a data type, an element of a data type, a function, and an element of a function.”
Related dependencies may also be located and commented out as well (0007). Dependencies applicable to the text or object are identified and commented out (0019). Also see 0028.
As per claim 18, Agarwal et al. further teaches, “The method of claim 16, wherein the dependency comprises at least one of a linked relationship statement, a create statement, a delete statement, and an object-level dependency.”
Related dependencies may also be located and commented out as well (0007). Dependencies applicable to the text or object are identified and commented out (0019). Also see 0028.
As per claim 19, Agarwal et al. further teaches, “The method of claim 16, with the construct-modification tag further comprising a condition, the method further comprising evaluating the condition before deactivating the construct.”
Agarwal et al. teaches, as shown in figure 2 lines of text (source code) that have been processed with a Comment_Out action. Each of the lines that are commented out begins with a “##” as an indicator for a compiler not to run these specific lines (programming language construct) of scripts. Other symbols besides the “##” may be used, with the preferred syntax chosen being consistent with the compiler anticipated to compile the script for execution (0031). Agarwal et al. teaches an editor can compile but not run the commented-out text (0008). The examiner interprets the “##” indicator to be the modification tag and condition. If it does not exist the compiler will compile and run the text and if it does exist the compiler will compile and not run (deactivate) the commented-out text.
As per claim 20, Agarwal et al. further teaches, “The method of claim 19, wherein the condition specifies at least one of an expiration time of the construct-modification tag, a date, a code version, a production indicator, status of a portion of source code, and a status of a second keyword.”
Agarwal et al. teaches, as shown in figure 2 lines of text (source code) that have been processed with a Comment_Out action. Each of the lines that are commented out begins with a “##” as an indicator for a compiler not to run these specific lines (programming language construct) of scripts. Other symbols besides the “##” may be used, with the preferred syntax chosen being consistent with the compiler anticipated to compile the script for execution (0031). Agarwal et al. teaches an editor can compile but not run the commented-out text (0008). The examiner interprets the “##” indicator to be the status that the text is commented out and not to be run.
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-3 are rejected under 35 U.S.C. 103 as being unpatentable over Agarwal et al. (US 2017/0068647 A1) and further in view of Jaeger et al. (US 2024/0134666 A1).
As per claim 1, A method of compiling source code, the method comprising:
parsing a source code statement, the source code statement having:
a keyword associated with a construct-modification tag conveying a compiler request;
a programming language construct; and
wherein the keyword identifies the programming language construct to be deactivated during compilation;”
Agarwal et al. teaches, as shown in figure 2 lines of text (source code) that have been processed with a Comment Out action. Each of the lines that are commented out begins with a “##” (keyword modification tag/compiling request) as an indicator for a compiler not to run these specific lines (programming language construct) of scripts. Other symbols besides the “##” may be used, with the preferred syntax chosen being consistent with the compiler anticipated to compile the script for execution (0031). Agarwal et al. teaches an editor can compile but not run the commented-out text (0008).
However, Agarwal et al. does not explicitly appear to teach, “compiling source code, the method comprising:
parsing a source code statement, the source code statement having:
a keyword associated with a construct-modification tag conveying a compiler request;
a programming language construct; and
wherein the keyword identifies the programming language construct to be deactivated during compilation;”
Jaeger et al. (US 2024/0134666 A1), teaches a typical compiler tokenizes and parses source code, constructs a abstract syntax tree to represent the code in an intermediate representation, and then use a code generator to translate the intermediate representation into executable code in the instruction set of the target architecture (00005).
It would have been obvious to one of ordinary skill in the art before the effective filing date to modify Agarwal et al. with Jaeger et al. Agarwal et al. teaches an editor that allows a user to disable/comment out a declaration in test/source code. Agarwal et al. teaches, as shown in figure 2 lines of text (source code) that have been processed with a Comment_Out action. Each of the lines that are commented out begins with a “##” (keyword) as an indicator for a compiler not to run these specific lines (programming language construct) of scripts. Therefore, Agarwal et al. teaches source code to be compiled, that contains commented out declarations and commented out dependencies of the declaration. Jaeger et al. teaches a compiler that parses source code to generate executable code, therefore the compiler of Jaeger et al. can compile/parse the source code of Agarwal et al. and would be able to recognize commented out declarations. Applying the known technique of compiling in Jaeger et al. to Agarwal et al. will allow it to compile its modified source code while disabling the commented out sections.
“finding dependencies of the programming language construct; and
deactivating the programming language construct and the dependencies.”
Agarwal et al. further teaches, if a developer seeks to isolate a problem in a declarative file by commenting out a single declaration, the editor of embodiments may act to identify and comment out the identified declaration as well as nonidentified but applicable dependencies, applicable to the text or object to be commented out (0019-0020). Also see 0028. Agarwal et al. teaches an editor can compile but not run the commented-out text (0008).
As per claim 2, Agarwal et al. and Jaeger et al. further teach, “The method of claim 1, wherein the source code statement also has a condition, further comprising:
evaluating whether the condition is satisfied;
compiling the programming language construct when the condition is not satisfied; and
wherein the finding and deactivating are performed responsive to the condition being satisfied.
Agarwal et al. further teaches, if a developer seeks to isolate a problem in a declarative file by commenting out a single declaration, the editor of embodiments may act to identify and comment out the identified declaration as well as nonidentified but applicable dependencies, applicable to the text or object to be commented out (0019-0020). Also see 0028. The examiner states that the condition is determining that there is a dependency to comment out/deactivate.
“compiling the programming language construct when the condition is not satisfied; and”
The examiner states that, Agarwal et al. teaches the editor is able identify and comment out the identified declaration as well as nonidentified but applicable dependencies. Therefore, the condition would be if a dependency is found. When a single declaration is complete, all dependencies will be found and commented out prior to the code being ready to compile. Agarwal et al. teaches an editor can compile but not run the commented-out text (0008). Therefore, a compilation cannot be performed until all dependencies of the identified declaration are found.
Jaeger et al. (US 2024/0134666 A1), teaches a typical compiler tokenizes and parses source code, constructs a abstract syntax tree to represent the code in an intermediate representation, and then use a code generator to translate the intermediate representation into executable code in the instruction set of the target architecture (00005).
As per claim 3, Agarwal et al. further teaches, “The method of claim 2, wherein the condition comprises at least one of an expiration time of a construct-modification tag, a date, a code version, a production indicator, a status of a portion of source code, and a status of a second keyword.”
Agarwal et al. further teaches, if a developer seeks to isolate a problem in a declarative file by commenting out a single declaration, the editor of embodiments may act to identify and comment out the identified declaration as well as nonidentified but applicable dependencies (status of portion), applicable to the text or object to be commented out (0019-0020). Also see 0008 and 0028. The examiner interprets the status to be if there is a dependency that needs to be commented out.
Claims 4-15 are rejected under 35 U.S.C. 103 as being unpatentable over Agarwal et al. (US 2017/0068647 A1) and further in view of Jaeger et al. (US 2024/0134666 A1) and Chandnani et al. (US 9,463,499 B1).
As per claim 4, Agarwal et al. teaches, A method of compiling source code, the method comprising:
parsing a source code statement, the source code statement having:
a keyword; and
a programming language construct;
wherein the keyword identifies the programming language construct to be deactivated;”
Agarwal et al. teaches, as shown in figure 2 lines of text (source code) that have been processed with a Comment_Out action. Each of the lines that are commented out begins with a “##” (keyword) as an indicator for a compiler not to run these specific lines (programming language construct) of scripts. Other symbols besides the “##” may be used, with the preferred syntax chosen being consistent with the compiler anticipated to compile the script for execution (0031). Agarwal et al. teaches an editor can compile but not run the commented-out text (0008).
However, Agarwal et al. does not explicitly appear to teach, “compiling source code, the method comprising:
parsing a source code statement, the source code statement having:
a keyword;
a programming language construct; and
wherein the keyword identifies the programming language construct to be deactivated;”
Jaeger et al. (US 2024/0134666 A1), teaches a typical compiler tokenizes and parses source code, constructs a abstract syntax tree to represent the code in an intermediate representation, and then use a code generator to translate the intermediate representation into executable code in the instruction set of the target architecture (00005).
It would have been obvious to one of ordinary skill in the art before the effective filing date to modify Agarwal et al. with Jaeger et al. Agarwal et al. teaches an editor that allows a user to disable/comment out a declaration in test/source code. Agarwal et al. teaches, as shown in figure 2 lines of text (source code) that have been processed with a Comment_Out action. Each of the lines that are commented out begins with a “##” (keyword) as an indicator for a compiler not to run these specific lines (programming language construct) of scripts. Therefore, Agarwal et al. teaches source code to be compiled, that contains commented out declarations and commented out dependencies of the declaration. Jaeger et al. teaches a compiler that parses source code to generate executable code, therefore the compiler of Jaeger et al. can compile/parse the source code of Agarwal et al. and would be able to recognize commented out declarations. Applying the known technique of compiling in Jaeger et al. to Agarwal et al. will allow it to compile its modified source code while disabling the commented out sections.
“compiling the programming language construct into a first executable code;
finding dependencies of the programming language construct;
deactivating the programming language construct and the dependencies; and
compiling the source code into a second executable code with the programming language construct and the dependencies deactivated.”
Agarwal et al. further teaches, if a developer seeks to isolate a problem in a declarative file by commenting out a single declaration, the editor of embodiments may act to identify and comment out the identified declaration as well as nonidentified but applicable dependencies, applicable to the text or object to be commented out (0019-0020). Also see 0028. Agarwal et al. teaches an editor can compile but not run the commented-out text (0008).
However Agarwal et al. does not explicitly appear to teach,
“compiling the programming language construct into a first executable code;
finding dependencies of the programming language construct;
deactivating the programming language construct and the dependencies; and
compiling the source code into a second executable code with the programming language construct and the dependencies deactivated.”
Chandnani et al. teaches, an exercised function can be one of many different program languages (column 13, lines 8-18). Chandnani et al. teaches that the selected exercised function can be removed by commenting out at last a portion of the selected exercised function in source code (column 17, lines 26-36). Chandnani et al. further teaches, automatically replaying a previously recorded scenario to an application (compiled first executable code) that includes a plurality of functions, thereby exercising a subset of the application functions through their execution by at least one processor and producing a scenario behavior form the application. The system then automatically trims from the application at least one dead function which was not exercised during execution of the scenario on the application to form a trimmed version of the application. A replay is performed of the recorded scenario using the trimmed version (compiled second executable code) of the application to produce a candidate behavior of the application (column 14, lines 31-58). Chandnani et al. teaches the system removes the selected exercised functions from a web application by commenting out at least a portion of the selected exercised function in a source code of the web application (column 17, lines 26-36).
The examiner states, that as shown above the application can comprise of source code since it can be made up of many different language and that dead functions can be removed by commenting out a portion of the source code. It is also shown above that both the application and a trimmed application are executed with the same scenario. The examiner states that it would be inherent for the source code of the application and the source code of the trimmed application to be compiled in order to be executed as taught in Chandnani et al. Compiling source code to execute it is shown above in Jaeger et al. paragraph 0005 and is well known to one of ordinary skill in the art.
It would have been obvious to one of ordinary skill in the art before the effective filing date to modify Agarwal et al. and Jaeger et al. with Chandnani et al. Agarwal et al. teaches disabling/commenting out declarations in source code and also determining dependencies of the declaration and commenting them out too. Chandnani et al. teaches executing a scenario on a first set of code, removing dead code from the code and the executing the scenario on the modified code with the dead code removed. The results of the execution are compared and used to determine if the removed dead code effects the output or not. This will allow Agarwal et al. to make sure when declarations and their dependencies are commented out or disabled, that they are not effecting the system in a negative way.
As per claim 5, Chandnani et al. further teaches, “The method of claim 4, further comprising:
executing the first executable code to produce a first computational result; and
executing the second executable code to produce a second computational result.”
Chandnani et al. further teaches, automatically replaying a previously recorded scenario to an application that includes a plurality of functions, thereby exercising a subset of the application functions through their execution by at least one processor and producing a scenario behavior form the application. The system then automatically trims from the application at least one dead function which was not exercised during execution of the scenario on the application to form a trimmed version of the application. A replay of the recorded scenario using the trimmed version of the application to produce a candidate behavior of the application (column 14, lines 31-58).
As per claim 6, Chandnani et al. further teaches, “The method of claim 5, further comprising:
comparing the first and second computational results; and
sending a first message responsive to the first and second computational results being the same.”
Chandnani et al. further teaches, automatically replaying a previously recorded scenario to an application that includes a plurality of functions, thereby exercising a subset of the application functions through their execution by at least one processor and producing a scenario behavior form the application. The system then automatically trims from the application at least one dead function which was not exercised during execution of the scenario on the application to form a trimmed version of the application. A replay of the recorded scenario using the trimmed version of the application to produce a candidate behavior of the application. The behaviors are then compared If, there is a match the(same) the disabled function is removed (first message) (column 14, lines 31-58).
As per claim 7, Chandnani et al. further teaches, The method of claim 6, further comprising:
sending a second message responsive to the first and second computational results being different.“sending a first message responsive to the first and second computational results being the same.”
Chandnani et al. further teaches, the behaviors are then compared if there is a match the disabled function is removed (First message). If they don’t match the disabled function is reenabled (second message) (column 14, lines 31-58).
As per claim 8, Agarwal et al. further teaches, “The method of claim 4, wherein the dependencies are dependent statements associated with the programming language construct.”
Related dependencies may also be located and commented out as well (0007). Dependencies applicable to the text or object are identified and commented out (0019). Also see 0028.
As per claim 9, Chandnani et al. further teaches, “The method of claim 7, wherein:
the first message indicates that the programming language construct is nonessential; and
the second message indicates that the programming language construct is essential.
Chandnani et al. further teaches, the behaviors are then compared if there is a match the disabled function is removed (First message, non-essential). If they don’t match the disabled function is reenabled (second message, essential) (column 14, lines 31-58).
As per claim 10, Agarwal et al. further teaches, “The method of claim 7, wherein the dependencies include one dependent feature of the programming language construct.”
Related dependencies may also be located and commented out as well (0007). Dependencies applicable to the text or object are identified and commented out (0019). Also see 0028.
As per claim 11, Chandnani et al. further teaches, “The method of claim 10, wherein:
the first message indicates that the programming language construct and its dependent feature are nonessential; and
the second message indicates that the dependent feature of the programming language construct is essential.”
Chandnani et al. further teaches, the behaviors are then compared if there is a match the disabled function is removed (First message, non-essential). If they don’t match the disabled function is reenabled (second message, essential) (column 14, lines 31-58).
As per claim 12, Agarwal et al. and Chandani et al. further teach, “The method of claim 4, wherein the dependencies include a plurality of dependent features of the programming language construct, and further comprising:
for each of the plurality of dependent features:
deactivating the programming language construct and the dependent feature;
compiling one of a plurality of third executable codes with the programming language construct and the dependent feature deactivated; and
executing the one of a plurality of third executable codes to produce one of a plurality of third computational results.”
Agarwal et al. further teaches, if a developer seeks to isolate a problem in a declarative file by commenting out a single declaration, the editor of embodiments may act to identify and comment out the identified declaration as well as nonidentified but applicable dependencies, applicable to the text or object to be commented out (0019-0020). Also see 0028.
Chandnani et al. further teaches, automatically replaying a previously recorded scenario to an application (compiled first executable) that includes a plurality of functions, thereby exercising a subset of the application functions through their execution by at least one processor and producing a scenario behavior form the application. The system then automatically trims from the application at least one dead function which was not exercised during execution of the scenario on the application (compiled third executable) to form a trimmed version of the application. A replay of the recorded scenario using the trimmed version of the application to produce a candidate behavior of the application. The behaviors are then compared If, there is a match the(same) he disabled function is removed (first message) (column 14, lines 31-58).
As per claim 13, Chandnani et al. further teaches, “The method of claim 12, further comprising:
for each of the plurality of dependent features:
comparing the corresponding one of the third computational results with the first computational result.”
Chandnani et al. further teaches, the behaviors are then compared if there is a match the disabled function is removed. If they don’t match the disabled function is reenabled (column 14, lines 31-58).
As per claim 14, Chandnani et al. further teaches, “The method of claim 13, further comprising:
for each of the plurality of dependent features:
sending a second message responsive to the respective third computational result and first computational result being different.”
Chandnani et al. teaches, the behaviors are then compared if there is a match the disabled function is removed. If they don’t match the disabled function is reenabled (second message) (column 14, lines 31-58).
As per claim 15, Chandnani et al. further teaches, “The method of claim 14, wherein each second message indicates that the respective dependent feature of the programming language construct is essential.”
Chandnani et al. teaches, the behaviors are then compared if there is a match the disabled function is removed (First message). If they don’t match the disabled function is reenabled (second message, essential) (column 14, lines 31-58).
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 21-23 are rejected under 35 U.S.C. 103 as being unpatentable over Agarwal et al. (US 2017/0068647 A1) and further in view of Chandnani et al. (US 9,436,449 B1).
As per claim 21, Agarwal et al. does not explicitly appear to teach, “The method of claim 16, wherein the compiling provides instructions for performing computational functions producing computational outputs, the method further comprising:
evaluating the computational functions with the construct and the dependency deactivated to produce a first of the computational outputs;
evaluating the computational functions with the construct and the dependency activated to produce a second of the computational outputs; and
comparing the first of the computational outputs with the second of the computational outputs.
Chandnani et al. further teaches, automatically replaying a previously recorded scenario to an application that includes a plurality of functions, thereby exercising a subset of the application functions through their execution by at least one processor and producing a scenario behavior form the application. The system then automatically trims from the application at least one dead function which was not exercised during execution of the scenario on the application to form a trimmed version of the application. A replay of the recorded scenario using the trimmed version of the application to produce a candidate behavior of the application. The behaviors are then compared If, there is a match the(same) he disabled function is removed (first message) (column 14, lines 31-58).
It would have been obvious to one of ordinary skill in the art before the effective filing date to modify Agarwal et al. with Chandnani et al. Agarwal et al. teaches disabling/commenting out declarations in source code and also determining dependencies of the declaration and commenting them out too. Chandnani et al. teaches executing a scenario on a first set of code, removing dead code from the code and the executing the scenario on the modified code with the dead code removed. The results of the execution are compared and used to determine if the removed dead code effects the output or not. This will allow Agarwal et al. to make sure when declarations and their dependencies are commented out or disabled, that they are not affecting the system in a negative way.
As per claim 22, Chandani et al. further teaches, “The method of claim 21, further comprising marking the construct as non-essential responsive to the comparing.”
Chandnani et al. further teaches, the behaviors are then compared if there is a match the disabled function is removed (First message, non essential). If they don’t match the disabled function is reenabled (second message, essential) (column 14, lines 31-58).
As per claim 23, Chandani et al. further teaches, “The method of claim 22, further comprising marking the dependency as non-essential responsive to the comparing.”
Chandnani et al. further teaches, the behaviors are then compared if there is a match the disabled function is removed (First message, non essential). If they don’t match the disabled function is reenabled (second message, essential) (column 14, lines 31-58).
Response to Arguments
Applicant's arguments filed 5/14/2026 have been fully considered but they are not persuasive.
Regarding 35 U.S.C § 101
Applicant argues, “Claims 1-23 are pending, with claims 1, 4, and 16 being independent. Claim 1 has been amended. Applicant respectfully requests reconsideration.
Response to Rejection Under 35 U.S.C. @ 101 Claim 1 has been amended to recite a keyword "associated with a construct- modification tag conveying a compiler request" and to recite that the programming language construct and its dependencies are deactivated "during compilation," clarifying that the claimed steps are performed by a compiler during the act of compilation. This amendment is consistent with the specification and does not narrow the scope of the claim. These steps (parsing source code statements, identifying construct-modification tags, finding dependencies of a programming language construct, and deactivating that construct and its dependencies) are not capable of being performed in the human mind. They are compiler operations that require a computer executing compiler software. Applicant respectfully submits that the rejection is addressed by the foregoing amendment and remarks.”
The examiner disagrees. While the claim may state, “deactivated during compilation” and that all steps are performed during compilation, the claim never claims the full steps of compilation such as generating an executable. The only compilation steps stated in the claim are “finding dependencies” and “deactivating the programming language construct and the dependencies”. Nothing in the claimed limitation prevents these limitations from being performed in the mind.
Regarding 35 U.S.C § 103
Regarding claim 16, applicant argues, “Amended claim 1 recites, inter alia, a keyword "associated with a construct- modification tag conveying a compiler request," wherein the keyword identifies the programming language construct to be deactivated "during compilation." Agarwal does not teach this limitation.
Agarwal describes toggling software features by annotating source code or using GUI controls to mark blocks as active or inactive. Agarwal's mechanism operates at the level of textual adjacency and GUI state. Code blocks are identified for toggling based on structural proximity to annotation markers in the source file or via external toggle controls, not via a construct-modification tag embedded in the source code statement itself that conveys a request to the compiler. Agarwal's feature toggling is a source-editing or pre- processing operation; it does not occur during compilation as a result of the compiler interpreting a tag in a source code statement. Jaeger does not cure this deficiency. Applicant respectfully requests allowance of claim 1.”
The examiner respectfully disagrees. As claimed, “…parsing a source code statement, the source code statement having:
a keyword associated with a construct-modification tag conveying a compiler request;…
…wherein the keyword identifies the programming language construct to be deactivated during compilation;
finding dependencies of the programming language construct; and
deactivating the programming language construct and the dependencies.”
Agarwal et al. teaches, as shown in figure 2 lines of text (source code) that have been processed with a Comment Out action. Each of the lines that are commented out begins with a “##” (keyword modification tag/compiling request) as an indicator for a compiler not to run these specific lines (programming language construct) of scripts. Other symbols besides the “##” may be used, with the preferred syntax chosen being consistent with the compiler anticipated to compile the script for execution (0031). Therefore, the examiner interprets the “##” to be a keyword associated with a construct-modification tag conveying a compiler request. Agarwal et al. teaches an editor can compile but not run the commented-out text (0008). Therefore, during compilation, the compiler will identify the “##” keyword that will instruct it to compile but not run the commented-out text, therefore the text section is now deactivated. A user is able to place the comments within the code, however it is the compiler that interprets the keyword and makes a decision to not run the commented-out text. For these reasons the current rejection stands.
Regarding claim 4, applicant argues, “Independent claim 4 recites compiling the programming language construct into a first executable code, finding dependencies of the construct, deactivating the construct and its dependencies, and then compiling the source code into a second executable code with the construct and dependencies deactivated. This dual-compilation approach produces two distinct executables for comparison. Agarwal does not teach this method. Agarwal operates at the source code editing level and does not compile source code twice for the purpose of comparing executables with and without a targeted construct. Chandnani relates to source code navigation and analysis but does not teach dual compilation of source code with and without a targeted construct. Jaeger similarly provides no teaching of the dual-compilation steps of claim 4. Applicant respectfully requests allowance of claim 4.”.
The examiner respectfully disagrees. Applicant's arguments fail to comply with 37 CFR 1.111(b) because they amount to a general allegation that the claims define a patentable invention without specifically pointing out how the language of the claims patentably distinguishes them from the references. Chandnani et al. teaches replaying a scenario on an application that includes a plurality of functions. Therefore, its inherent that the application must be compiled to execute the application that includes a plurality of functions. Next Chandnani et al. teaches, a function is trimmed/commented out from the application and the replay scenario is then performed using the trimmed application (column 14, lines 31-58). Again, the application code must be compiled in order for the application to be executed. Both Agarwal et al. and Chandnani et al. teach the commenting out of a function from source code. Agarwal et al. teaches an editor can compile but not run the commented-out text (0008). Jaeger et al. teaches the performance of a compiler to parse code and generate a executable. Together, these references would allow Agarwal et al. to compile code that may or may not have commented out sections and execute a scenario in order to see the difference between the execution of the application with all functions and the application with a commented out function to make sure the commented out section is not effecting the system in a negative way, thereby improving the system by getting rid of unneeded functions.
Regarding 35 U.S.C § 103
Regarding claim 16, applicant argues, “Independent claim 16 recites "encountering a statement naming a construct of the source code, the statement including a construct-modification tag conveying a compiler request." Agarwal does not disclose this element. Agarwal's annotations exist adjacent to or surrounding code blocks in the source file and operate via GUI toggle state. They are not construct-modification tags embedded within source code statements that convey requests to the compiler. Because Agarwal does not disclose a construct-modification tag conveying a compiler request within the source code statement, Agarwal does not anticipate claim 16. Applicant respectfully requests allowance of claim 16.”
The examiner disagrees. Agarwal et al. teaches, as shown in figure 2 lines of text (source code) that have been processed with a Comment Out action. Each of the lines that are commented out begins with a “##” (keyword modification tag/compiling request) as an indicator for a compiler not to run these specific lines (programming language construct) of scripts. Other symbols besides the “##” may be used, with the preferred syntax chosen being consistent with the compiler anticipated to compile the script for execution (0031). Therefore, the examiner interprets the “##” to be a construct-modification tag conveying a compiler request. Agarwal et al. teaches an editor can compile but not run the commented-out text (0008). Therefore, during compilation, the compiler will identify the “##” tag that will instruct it to compile but not run the commented-out text, therefore the text section is now deactivated. A user is able to place the comments within the code, however it is the compiler that interprets the keyword and make a decision to not run the commented-out text. For these reasons the current rejection stands.
Conclusion
Applicant's amendment necessitated the new ground(s) of rejection presented in this Office action. Accordingly, THIS ACTION IS MADE FINAL. See MPEP § 706.07(a). Applicant is reminded of the extension of time policy as set forth in 37 CFR 1.136(a).
A shortened statutory period for reply to this final action is set to expire THREE MONTHS from the mailing date of this action. In the event a first reply is filed within TWO MONTHS of the mailing date of this final action and the advisory action is not mailed until after the end of the THREE-MONTH shortened statutory period, then the shortened statutory period will expire on the date the advisory action is mailed, and any nonprovisional extension fee (37 CFR 1.17(a)) pursuant to 37 CFR 1.136(a) will be calculated from the mailing date of the advisory action. In no event, however, will the statutory period for reply expire later than SIX MONTHS from the mailing date of this final action.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to MARK A GOORAY whose telephone number is (571)270-7805. The examiner can normally be reached Monday - Friday 10:00am - 6:00pm.
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, Lewis Bullock can be reached at 571-272-3759. 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.
/MARK A GOORAY/ Examiner, Art Unit 2199
/LEWIS A BULLOCK JR/ Supervisory Patent Examiner, Art Unit 2199
Prosecution Insights