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;
a programming language construct; and
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.
“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.
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).
Conclusion
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