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 .
DETAILED ACTION
1. This initial office action is based on the application filed on 03/26/2024, which claims 1-20 have been presented for examination.
Status of Claim
2. Claims 1-20 are pending in the application and have been examined below, of which, claims 1, 16 and 20 are presented in independent form.
Priority
3. No priority document has been filed in this application.
Information Disclosure Statement
4. The information disclosure statement (IDS) submitted on 03/26/2024. The submission is in compliance with the provisions of 37 CFR 1.97. Accordingly, the information disclosure statement is being considered by the examiner.
Examiner Notes
5. Examiner cites particular columns and line numbers in the references as applied to the claims below for the convenience of the applicant. Although the specified citations are representative of the teachings in the art and are applied to the specific limitations within the individual claim, other passages and figures may apply as well. It is respectfully requested that, in preparing responses, the applicant fully consider the references in entirety as potentially teaching all or part of the claimed invention, as well as the context of the passage as taught by the prior art or disclosed by the examiner.
Abstract Objections
6. Abstract, lines 1, 2 and 5 recite “Some embodiments…” Applicant is reminded of the proper language and format for an abstract of the disclosure.
The abstract should be in narrative form and generally limited to a single paragraph on a separate sheet within the range of 50 to 150 words in length. The abstract should describe the disclosure sufficiently to assist readers in deciding whether there is a need for consulting the full patent text for details.
The language should be clear and concise and should not repeat information given in the title. It should avoid using phrases which can be implied, such as, “The disclosure concerns,” “The disclosure defined by this invention,” “The disclosure describes,” etc. In addition, the form and legal phraseology often used in patent claims, such as “means” and “said,” should be avoided.
Claim Objections
7. Claims 10-12 are objected to because of the following informalities:
Claims 10-12 recite the limitation/element "each comprise" in line 2. This limitation/element should be changed to – each comprises [[comprise]] --.
Claim 11 recites the limitation/element “whose value” in line 3, should be removed or replaced.
Appropriate correction is required.
Claim Rejections - 35 USC § 112
The following is a quotation of 35 U.S.C. 112(b):
(b) CONCLUSION.—The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the inventor or a joint inventor regards as the invention.
The following is a quotation of 35 U.S.C. 112 (pre-AIA ), second paragraph:
The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the applicant regards as his invention.
8. Claims 5-7 are rejected under 35 U.S.C. 112(b) or 35 U.S.C. 112 (pre-AIA ), second paragraph, as being indefinite for failing to particularly point out and distinctly claim the subject matter which the inventor or a joint inventor (or for applications subject to pre-AIA 35 U.S.C. 112, the applicant), regards as the invention.
Claim 5 recites “accessing data in an internal data structure which is a part of a runtime”, in lines 2-3 appears to mis-descriptive/unclear; and as such, it renders the claim indefinite.
Claims 6-7 depend on claim 5 are also rejected under 112(b).
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.
9. 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 analysis specific to Claims 1 and 15 is being presented below.
Claims 1, 16 and 20:
Step 1 Analysis:
Claim 1 of the instant application is direct to apparatus.
Claim 16 of the instant application is direct to process.
Claim 20 of the instant application is direct to apparatus.
Step 2 Analysis:
Claims 1 and 20 recites:
(a) receiving an edit request which requests an edit to an original version of a source code, the original version and the edit request specifying an edited version of the source code, the original source code corresponding to a portion of a program which is loaded for execution in the computing system;
(b) determining that a safe implementation of the edited version depends on at least a run time selection which is indeterminate in the edited version of the source code;
(c) generating the safe implementation of the edited version;
(d) installing the safe implementation of the edited version into the program as a hot reload; and
(e) modifying an original version implementation of the source code original version to deny an attempt to execute the original version implementation (claim 1); modifying an original version implementation of the source code original version to throw an exception in response to an attempt to execute the original version implementation (claim 20).
Step 2A -- Prong 1:
The claims 1 and 20 recite the limitations of:
(b) determining that a safe implementation of the edited version depends on at least a run time selection which is indeterminate in the edited version of the source code;
Limitation (b) limitation that, as drafted, are processes that, under its broadest reasonable interpretations, covers performance of the limitation in the mind. That is, nothing in the claim elements precludes the step from practically being performed in the mind or with a pen and paper, i.e. “determining” can be performed in the human mind through observation, evaluation, judgement, opinion with the aid of pen and paper. As such, these limitations fall within the “Mental Processes” grouping of abstract ideas.
Step 2A -- Prong 2:
The claim 1 recites the additional limitations of “a computing system/the computing system”. The limitations of “a computing system/the computing system” are recited at a high level of generality, i.e., merely instructions to implement the abstract idea on a generic computer or merely uses a computer as a tool to perform the abstract idea. Claim 20 recites the additional limitations of “A computer-readable storage device”, “a processor” and “a computing system/the computing system”. The limitations of “A computer-readable storage device”, “a processor” and “a computing system/the computing system” are recited at a high level of generality, i.e., merely instructions to implement the abstract idea on a generic computer or merely uses a computer as a tool to perform the abstract idea. Additionally, limitations (a) and (d-e) perform as well-understood, routine and conventional activity and limitation (c) are merely insignificant extra solution activity of outputting data. Accordingly, these additional elements do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea.
Step 2 Analysis:
Claim 16 recites:
(a) receiving an edit request which requests an edit to an original version of a source code, the original version and the edit request specifying an edited version of the source code, the original source code corresponding to a portion of a program which is loaded for execution in the computing system,
(b) determining that a safe implementation of the edited version depends on at least a run time selection which is indeterminate in the edited version of the source code,
(c) performing the edit request,
(d) generating the safe implementation of the edited version,
(e) installing the safe implementation of the edited version into the program as a hot reload, including installing a body of a lambda routine, and
(f) modifying an original version implementation of the source code original version to deny an attempt to execute the original version implementation.
Step 2A -- Prong 1:
The claim 16 recites the limitation of:
(b) determining that a safe implementation of the edited version depends on at least a run time selection which is indeterminate in the edited version of the source code,
Limitation (b) limitation that, as drafted, are processes that, under its broadest reasonable interpretations, covers performance of the limitation in the mind. That is, nothing in the claim elements precludes the step from practically being performed in the mind or with a pen and paper, i.e. “determining” can be performed in the human mind through observation, evaluation, judgement, opinion with the aid of pen and paper. As such, these limitations fall within the “Mental Processes” grouping of abstract ideas.
Step 2A -- Prong 2:
The claim 1 recites the additional limitations of “A computing system”; “at least one digital memory”; “at least one processor” and “the at least one processor configured to execute a hot load method”. The limitations of “A computing system”; “at least one digital memory”; “at least one processor” and “the at least one processor configured to execute a hot load method” are recited at a high level of generality, i.e., merely instructions to implement the abstract idea on a generic computer or merely uses a computer as a tool to perform the abstract idea. Additionally, limitations (a) and (e-f) perform as well-understood, routine and conventional activity and limitations (c-d) are merely insignificant extra solution activity of processing/outputting data. Accordingly, these additional elements do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea.
Step 2B: (claims 1, 16 and 20)
As explained with respect to Step 2A Prong Two, the additional elements in the claim are recited at a high level of generality and amount to no more than mere instructions to apply the exception using generic computer components. Accordingly, the additional elements do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea. The same analysis applies here in 2B, i.e., simply adding extra-solution activity or well-understood, routine and conventional activity or generic computer components does not integrate a judicial exception into a practical application at Step 2A or provide an inventive concept in Step 2B since the courts have identified functions such as gathering, displaying, updating/modifying, transmitting/receiving and storing/installing data as well- understood, routine, conventional activity. See MPEP 2106.05(d) and See MPEP 2106.05(g) . Therefore, the claims does not integrate the judicial exception into a practical application at Step 2A Prong 2 or recite additional elements that amount to significantly more than the judicial exception at Step 2B.
Dependent claims
Additionally, claim 2 recites “wherein the run time selection includes a selection between (a) executing a lambda only once, and (b) executing the lambda more than once” as drafted, is a process that, under its broadest reasonable interpretations, covers performance of the limitation in the mind. That is, nothing in the claim elements precludes the step from practically being performed in the mind or with a pen and paper, i.e. “selection” can be performed in the human mind through observation, evaluation, judgment, opinion with the aid of pen and paper. As such, this limitation falls within the “Mental Processes” grouping of abstract idea. Accordingly, these limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 2 is ineligible.
Additionally, claim 3 recites “wherein the run time selection includes a selection between (a) executing an in-place modification of the original version implementation, and (b) executing a new instance generated from the edited version” as drafted, is a process that, under its broadest reasonable interpretations, covers performance of the limitation in the mind. That is, nothing in the claim elements precludes the step from practically being performed in the mind or with a pen and paper, i.e. “selection” can be performed in the human mind through observation, evaluation, judgment, opinion with the aid of pen and paper. As such, this limitation falls within the “Mental Processes” grouping of abstract idea. Accordingly, these limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 3 is ineligible.
Additionally, claim 4 recites “wherein the run time selection includes a selection between (a) reusing an existing body of a lambda routine, and (b) executing a replacement body of the lambda routine” as drafted, is a process that, under its broadest reasonable interpretations, covers performance of the limitation in the mind. That is, nothing in the claim elements precludes the step from practically being performed in the mind or with a pen and paper, i.e. “selection” can be performed in the human mind through observation, evaluation, judgment, opinion with the aid of pen and paper. As such, this limitation falls within the “Mental Processes” grouping of abstract idea. These limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 4 is ineligible.
Additionally, claim 5 recites “wherein the run time selection includes a selection between (a) accessing data in an internal data structure which is a part of a runtime, and (b) accessing data in an external data structure which resides outside the runtime” as drafted, is a process that, under its broadest reasonable interpretations, covers performance of the limitation in the mind. That is, nothing in the claim elements precludes the step from practically being performed in the mind or with a pen and paper, i.e. “selection” can be performed in the human mind through observation, evaluation, judgment, opinion with the aid of pen and paper. As such, this limitation falls within the “Mental Processes” grouping of abstract idea. These limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 5 is ineligible.
Additionally, claim 6 recites “wherein accessing data in the external data structure which resides outside the runtime comprises accessing an address of a lambda routine” is merely insignificant extra solution activity of accessing data. Accordingly, these limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 6 is ineligible.
Additionally, claim 7 recites “wherein the address of the lambda routine resides in a handler or resides in a handler dispatcher” is merely insignificant extra solution activity of locating data. Accordingly, these limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 7 is ineligible.
Additionally, claim 8 recites “wherein the original version of the source code and the edited version of the source code each comprise a lambda routine body” is merely insignificant extra solution activity defining data. Accordingly, these limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 8 is ineligible.
Additionally, claim 9 recites “wherein the original version of the source code and the edited version of the source code each comprise an invocation of a routine via a routine pointer” is merely insignificant extra solution activity defining data. Accordingly, these limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 9 is ineligible.
Additionally, claim 10 recites “wherein the original version of the source code and the edited version of the source code each comprise an instance of an interface programming language feature” is merely insignificant extra solution activity defining data. Accordingly, these limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 10 is ineligible.
Additionally, claim 11 recites “wherein the original version of the source code and the edited version of the source code each comprise an indirection whose value is indeterminate in the edited version of the source code” is merely insignificant extra solution activity defining data. Accordingly, these limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 11 is ineligible.
Additionally, claim 12 recites “wherein the original version of the source code and the edited version of the source code each comprise a language-integrated query expression” is merely insignificant extra solution activity defining data. Accordingly, these limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 12 is ineligible.
Additionally, claim 13 recites “wherein the original version of the source code and the edited version of the source code each comprise a self-contained portion of a user interface which includes a processing logic to enable a dynamic behavior” is merely insignificant extra solution activity defining data. Accordingly, these limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 13 is ineligible.
Additionally, claim 14 recites “wherein modifying the original version implementation comprises inserting a code which is configured to upon execution throw an exception” is merely insignificant extra solution activity of monitoring data. These limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 14 is ineligible.
Additionally, claim 15 recites “wherein the safe implementation of the edited version does at least one of: adds a non-static lambda; adds a lambda with a non-captured current object instance reference; adds a lambda configured to upon execution access a non-captured variable; adds a lambda configured to upon execution access captured variables from at least two scopes; includes a modified lambda signature” are merely insignificant extra solution activity of gathering data. The limitations “modifies a membership of a set of variables captured by a lambda; modifies a scope of a variable captured by a lambda; or modifies a membership of a set of variables accessed by a lambda upon execution” which performs as well-understood, routine and conventional activity. These limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 15 is ineligible.
Additionally, claim 17 recites “wherein the safe implementation of the edited version comprises code which upon execution does at least one of: adds a non-static lambda; adds a lambda with a non-captured current object instance reference; adds a lambda configured to upon execution access a non-captured variable; adds a lambda configured to upon execution access captured variables from at least two scopes” are merely insignificant extra solution activity of gathering data. These limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 17 is ineligible.
Additionally, claim 18 recites “wherein the safe implementation of the edited version comprises code which includes a modified lambda signature” are merely insignificant extra solution activity of gathering data. These limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 18 is ineligible.
Additionally, claim 19 recites “wherein the safe implementation of the edited version comprises code which upon execution does at least one of: modifies a membership of a set of variables captured by a lambda; modifies a scope of a variable captured by a lambda; or modifies a membership of a set of variables accessed by a lambda upon execution” which performs as well-understood, routine and conventional activity. These limitations do not integrate the abstract idea into a practical application because they do not impose any meaningful limits on practicing the abstract idea or provide an inventive concept and thus do not amount to significantly more that the abstract idea. As such, these claims fail both Step 2A prong 2 and Step 2B. Therefore, claim 19 is ineligible.
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.
10. Claim(s) 1, 3-6,14-18 and 20 is/are rejected under 35 U.S.C. 103 as being unpatentable over Hashimi et al. (US Patent No. 11573787 B1 – IDS filed on 03/26/2024 --herein after Hashimi) in view of Wolfram (EP 4027239 A1 – herein after Wolfram)
Regarding claim 1.
Hashimi discloses
A hot reload method performed in a computing system (the code change is stored within an in-memory editor buffer, and is uncommitted to any source code file. It is determined that the code change can be applied to the running software application using hot reload – See Abstract), the method comprising automatically:
receiving an edit request (a user input represents a code change that can be applied to application 119 using hot reload – col. 8, lines 10-11) which requests an edit to an original version of a source code (a user input user input represents a code change that can be applied to application 119 using hot reload when the code change is determined to be complete – See col. 8, lines 13-15), the original version and the edit request specifying an edited version of the source code (existing code element name (e.g., method name, variable name, structure name, class name, etc.) – See col. 8, lines 23-25. Hot reload implementations detect when changes are made to one or more source code files on disk, and apply those changes to a running application. Hot reload operates by creating new types and new versions of updated methods – See col. 1, lines 38-44), the original source code corresponding to a portion of a program which is loaded for execution in the computing system (code change to be incrementally compiled to create a code entity (or entities) that can be loaded into a running application's memory space – col. 7, lines 2-5. Compile one or more portions of source code of the running application 122 affected by the code change 127 that was identified by the change identification component 130 – See col. 8, lines 51-62);
determining that a safe implementation of the edited version depends on at least a run time selection which is indeterminate in the edited version of the source code (the running application 122 utilizes a plurality of different programming languages (and, correspondingly, a plurality of different runtimes) – See col. 11, lines 26-38. Each of hot reload agents 112 interfaces with a runtime system 120 (e.g., using hot reload support 121 of that runtime system) to apply one or more code changes and/or one or more static file changes to a running application (e.g., running application 122) – See col. 9, lines 2-9. Determines whether a code change can be applied to the running software application using hot reload based on determining if the code change is actually compatible with hot reload technology being used. For example, some hot reload technologies are limited in the types of code changes that can be applied while an application is running, and the completeness determination component 131 ensures that a give code change can actually be applied using that technology – See col. 8, lines 37-46. Examiner respectfully notes that corresponding a runtime is as a runtime selection);
generating the safe implementation of the edited version (when using a compiled programming language, the change communication component 134 uses each hot reload agent identified in act 304 to communicate a new code entity or entities generated in act 303 to hot reload support 121 of runtime system 120 – See col. 11, lines 54-58);
installing the safe implementation of the edited version into the program as a hot reload (the hot reload orchestrator 114 is configured to coordinate use of other components of the development environment 105 in order to implement methods for hot reloading a running application with an unsaved source code change – See col. 6, lines 49-53); and
Hashimi discloses implement methods for hot reloading a running application with an unsaved source code change – See col. 6, lines 49-53. Hashimi does not disclose
modifying an original version implementation of the source code original version to deny an attempt to execute the original version implementation.
Wolfram discloses
modifying an original version implementation of the source code original version to deny an attempt to execute the original version implementation (modify the behavior of the agent functionality, at runtime, by means of a modification of the program flow configuration data, it is advantageously possible, according to the present invention, to flexibly, smoothly and quickly adapt the behavior of the both the agent functionality and the legacy software application such as to be able… – See paragraph [0029]. It checks (in a given time interval repeatedly according to a predefined repetition rate) whether the configuration-files (i.e. the method definition or the program flow configuration data 210 and the class mapper 220) have been modified; if so, it triggers a reload of the configuration and an update of changed interceptors… it checks on startup if the installed Java-version and the runtime environment are compatible with the agent functionality 200 (i.e. the lambda agent); it optionally adapts Java or runtime environment requirements. Execute old code (i.e. internally in the legacy software application 100); -- Execute new service (i.e. externally to the legacy software application 100); --Switch by defined percentage between old and new; -- Throw an Event/illegal code – See paragraphs [0070-0073]. Throws illegalArgumentException – See paragraphs [0038]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Wolfram’s teaching into Hashimi’s invention because incorporating Wolfram’s teaching would enhance Hashimi to enable to incrementally either update or modify procedures or methods or functions within the legacy software application, or to move processes or functions from the legacy software application towards an external execution environment as suggested by Wolfram (paragraph [0014]).
Regarding claim 3, the method of claim 1,
Hashimi discloses
wherein the run time selection includes a selection between (a) executing an in-place modification of the original version implementation (modify software – See col. 5, lines 42-57), and (b) executing a new instance generated from the edited version (detect when there is static file change to source of the running software (e.g., based on identifying an uncommitted change to a static file, or based on identifying a new version of a static file), and uses one or more hot reload agents to push that static file change to an application runtime corresponding to the running application – See col. 2, lines 12-18).
Regarding claim 4, the method of claim 1,
Wolfram discloses
wherein the run time selection includes a selection between (a) reusing an existing body of a lambda routine ( instrumenting the legacy software application's bytecode the agent functionality is able to interact, dynamically and/or at runtime of the bytecode, with at least one procedure or procedure call as part of the legacy software –See Abstract. Application the agent functionality, also called lambda agent in the context of the present invention, is agnostic to the legacy software application (some requirements need to be fulfilled) and therefore can be reused – See paragraph [0014]), and (b) executing a replacement body of the lambda routine (instrumented or triggered procedure or procedure call - , or alternatively an external piece of software(especially through different network protocols) that finally could replace the (old) function of the legacy software application – See paragraph [0022]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Wolfram’s teaching into Hashimi’s invention because incorporating Wolfram’s teaching would enhance Hashimi to enable to replace the old function as suggested by Wolfram (paragraph [0022]).
Regarding claim 5, the method of claim 1,
Wolfram discloses
wherein the run time selection includes a selection between (a) accessing data in an internal data structure which is a part of a runtime (procedure call is executed by the legacy software application's bytecode 101, i.e. internally to the legacy software application 100. Hence, the inbound method call (reference sign 3) corresponds to the actual internal execution of the at least one procedure 105 or procedure call – See paragraph [0063), and (b) accessing data in an external data structure which resides outside the runtime (software application's procedures are executed externally – See paragraph [0063]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Wolfram’s teaching into Hashimi’s invention because incorporating Wolfram’s teaching would enhance Hashimi to enable to replace the old function of external execution as suggested by Wolfram (paragraph [0063]).
Regarding claim 6, the method of claim 5,
Wolfram discloses
wherein accessing data in the external data structure which resides outside the runtime comprises accessing an address of a lambda routine (Such services or microservices 310 are able to be written in any type of language, and can be run in any environment, be it local (i.e. outside of the computing or execution environment 150 of the legacy software application 100, or within, or cloud based. The only condition to be fulfilled is the reachability or accessibility by the agent functionality 200 (or lambda agent).– See paragraph [0054]. The target service is addressable and reachable by the used protocols. Often, services and microservices 310 are built to replace or enhance an existing legacy software application 100 – See paragraph [0068]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Wolfram’s teaching into Hashimi’s invention because incorporating Wolfram’s teaching would enhance Hashimi to enable to the reachability or accessibility by the lambda agent functionality as suggested by Wolfram (paragraph [0054]).
Regarding claim 14, the method of claim 1,
Wolfram discloses
wherein modifying the original version implementation comprises inserting a code which is configured to upon execution throw an exception (instrument the execution of the legacy software application's bytecode, wherein by means of intercepting or instrumenting the legacy software application's bytecode the agent functionality is able to interact, dynamically and/or at runtime of the bytecode, with at least one procedure or procedure call as part of the legacy software application. In this respect, the agent functionality uses the interception functionality or instrumentation functionality or introspection functionality as available within the respective computing or execution environment of the software application – See paragraphs [0019-0020]. Execute old code (i.e. internally in the legacy software application 100); -- Execute new service (i.e. externally to the legacy software application 100); --Switch by defined percentage between old and new; -- Throw an Event) – See paragraph [0073]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Wolfram’s teaching into Hashimi’s invention because incorporating Wolfram’s teaching would enhance Hashimi to use code injection and instrumentation that is applicable to any software application running within or on the computing or execution environment) as suggested by Wolfram (paragraph [0014]).
Regarding claim 15, the method of claim 1,
Wolfram discloses
wherein the safe implementation of the edited version does at least one of:
adds a non-static lambda;
adds a lambda with a non-captured current object instance reference;
adds a lambda configured to upon execution access a non-captured variable;
adds a lambda configured to upon execution access captured variables from at least two scopes;
includes a modified lambda signature;
modifies a membership of a set of variables captured by a lambda;
modifies a scope of a variable captured by a lambda; or
modifies a membership of a set of variables accessed by a lambda upon execution (update or modify procedures or methods or functions…update or modify procedures or methods or functions within the legacy software application – See paragraph [0014]. MethodSignature - the signature (parameter types) of the method (or procedure, i.e. the at least one procedure 105 or procedure call) that is to be intercepted – See paragraph [0070]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Wolfram’s teaching into Hashimi’s invention because incorporating Wolfram’s teaching would enhance Hashimi to enable to modify methods as suggested by Wolfram (paragraph [0070]).
.
Regarding claim 16.
Hashimi discloses
A computing system (computing device – See Fig. 1A), comprising:
at least one digital memory (memory, 103 – See Fig. 1A);
at least one processor in operable communication with the at least one digital memory, the at least one processor configured to execute a hot reload method (processor 101 – Fig. 1A), the method comprising:
(a) receiving an edit request (a user input represents a code change that can be applied to application 119 using hot reload – col. 8, lines 10-11) which requests an edit to an original version of a source code (a user input user input represents a code change that can be applied to application 119 using hot reload when the code change is determined to be complete – See col. 8, lines 13-15), the original version and the edit request specifying an edited version of the source code (existing code element name (e.g., method name, variable name, structure name, class name, etc.) – See col. 8, lines 23-25. Hot reload implementations detect when changes are made to one or more source code files on disk, and apply those changes to a running application. Hot reload operates by creating new types and new versions of updated methods – See col. 1, lines 38-44), the original source code corresponding to a portion of a program which is loaded for execution in the computing system (code change to be incrementally compiled to create a code entity (or entities) that can be loaded into a running application's memory space – col. 7, lines 2-5. Compile one or more portions of source code of the running application 122 affected by the code change 127 that was identified by the change identification component 130 – See col. 8, lines 51-62);
(b) determining that a safe implementation of the edited version depends on at least a run time selection which is indeterminate in the edited version of the source code (the running application 122 utilizes a plurality of different programming languages (and, correspondingly, a plurality of different runtimes) – See col. 11, lines 26-38. Each of hot reload agents 112 interfaces with a runtime system 120 (e.g., using hot reload support 121 of that runtime system) to apply one or more code changes and/or one or more static file changes to a running application (e.g., running application 122) – See col. 9, lines 2-9. Determines whether a code change can be applied to the running software application using hot reload based on determining if the code change is actually compatible with hot reload technology being used. For example, some hot reload technologies are limited in the types of code changes that can be applied while an application is running, and the completeness determination component 131 ensures that a give code change can actually be applied using that technology – See col. 8, lines 37-46. Examiner respectfully notes that corresponding a runtime is as a runtime selection);
(c) performing the edit request (the change identification component 130 detects a code change 127 made by a developer at the editor 106 – See col. 10, lines 4-17),
(d) generating the safe implementation of the edited version (when using a compiled programming language, the change communication component 134 uses each hot reload agent identified in act 304 to communicate a new code entity or entities generated in act 303 to hot reload support 121 of runtime system 120 – See col. 11, lines 54-58),
(e) installing the safe implementation of the edited version into the program as a hot reload, [[including installing a body of a lambda routine]] (the hot reload orchestrator 114 is configured to coordinate use of other components of the development environment 105 in order to implement methods for hot reloading a running application with an unsaved source code change – See col. 6, lines 49-53),
Hashimi discloses implement methods for hot reloading a running application with an unsaved source code change – See col. 6, lines 49-53. Hashimi does not disclose
including installing a body of a lambda routine, and
(f) modifying an original version implementation of the source code original version to deny an attempt to execute the original version implementation.
Wolfram discloses
(e) installing the safe implementation of the edited version into the program as a hot reload including installing a body of a lambda routine (installing/loading Java-version – See page 18. The lambda agent instruments (or intercepts or triggers) running code (i.e. bytecode) of the legacy system (within the legacy software application's computing or execution environment), controlled by dynamic configuration (i.e. the (content of the) program flow configuration data - that may change over time to be adapted to new requirements, especially triggering hot reloads). Lambda agent (i.e. a comparatively small piece of software) is attached to this legacy software application – See paragraph [0022]), and
(f) modifying an original version implementation of the source code original version to deny an attempt to execute the original version implementation (modify the behavior of the agent functionality, at runtime, by means of a modification of the program flow configuration data, it is advantageously possible, according to the present invention, to flexibly, smoothly and quickly adapt the behavior of the both the agent functionality and the legacy software application such as to be able… – See paragraph [0029]. It checks (in a given time interval repeatedly according to a predefined repetition rate) whether the configuration-files (i.e. the method definition or the program flow configuration data 210 and the class mapper 220) have been modified; if so, it triggers a reload of the configuration and an update of changed interceptors… it checks on startup if the installed Java-version and the runtime environment are compatible with the agent functionality 200 (i.e. the lambda agent); it optionally adapts Java or runtime environment requirements. Execute old code (i.e. internally in the legacy software application 100); -- Execute new service (i.e. externally to the legacy software application 100); --Switch by defined percentage between old and new; -- Throw an Event/illegal code – See paragraphs [0070-0073]. Throws illegalArgumentException – See paragraphs [0038]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Wolfram’s teaching into Hashimi’s invention because incorporating Wolfram’s teaching would enhance Hashimi to enable to incrementally either update or modify procedures or methods or functions within the legacy software application, or to move processes or functions from the legacy software application towards an external execution environment as suggested by Wolfram (paragraph [0014]).
Regarding claim 17, the system of claim 16,
Wolfram discloses
wherein the safe implementation of the edited version comprises code which upon execution does at least one of:
adds a non-static lambda;
adds a lambda with a non-captured current object instance reference;
adds a lambda configured to upon execution access a non-captured variable (the agent functionality 200 (or lambda agent) is started with the legacy (software) application 100. This corresponds to the first step, during which the agent functionality 200 is triggered to be operated together with the legacy software application 100 running on or in the computing or execution environment 150 of the legacy software application 100. Therefore, the start parameters of the legacy(software) application 100 will add some parameters. Once started, all further actions may be added or revoked dynamically - especially by means of modifying program flow configuration data 210 – See paragraphs [0057-0058]);
adds a lambda configured to upon execution access captured variables from at least two scopes
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Wolfram’s teaching into Hashimi’s invention because incorporating Wolfram’s teaching would enhance Hashimi to enable to add or revoke dynamically - especially by modifying program as suggested by Wolfram (paragraphs [0057-0058]).
Regarding claim 18, the system of claim 16,
Wolfram discloses
wherein the safe implementation of the edited version comprises code which includes a modified lambda signature (update or modify procedures or methods or functions…update or modify procedures or methods or functions within the legacy software application – See page 4. MethodSignature - the signature (parameter types) of the method (or procedure, i.e. the at least one procedure 105 or procedure call) that is to be intercepted – See paragraph [0070]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Wolfram’s teaching into Hashimi’s invention because incorporating Wolfram’s teaching would enhance Hashimi to enable to modify methods as suggested by Wolfram (paragraph [0070]).
Regarding claim 20.
Hashimi discloses
A computer-readable storage device configured with data and instructions which upon execution by a processor perform a hot reload method in a computing system (the code change is stored within an in-memory editor buffer, and is uncommitted to any source code file. It is determined that the code change can be applied to the running software application using hot reload – See Abstract), the method comprising automatically:
receiving an edit request (a user input represents a code change that can be applied to application 119 using hot reload – col. 8, lines 10-11) which requests an edit to an original version of a source code (a user input user input represents a code change that can be applied to application 119 using hot reload when the code change is determined to be complete – See col. 8, lines 13-15), the original version and the edit request specifying an edited version of the source code (existing hot reload implementations detect when a new version of a source code file is available, and update a corresponding running application based on recompiling that source code file in its entirety (e.g., in a compiled language), or based on interpreting a new version of a file (e.g., in an interpreted language) – See col. 1, lines 48-53), the original source code corresponding to a portion of a program which is loaded for execution in the computing system (code change to be incrementally compiled to create a code entity (or entities) that can be loaded into a running application's memory space – col. 7, lines 2-5. Compile one or more portions of source code of the running application 122 affected by the code change 127 that was identified by the change identification component 130 – See col. 8, lines 51-62);
determining that a safe implementation of the edited version depends on at least a run time selection which is indeterminate in the edited version of the source code (the running application 122 utilizes a plurality of different programming languages (and, correspondingly, a plurality of different runtimes) – See col. 11, lines 26-38. Each of hot reload agents 112 interfaces with a runtime system 120 (e.g., using hot reload support 121 of that runtime system) to apply one or more code changes and/or one or more static file changes to a running application (e.g., running application 122) – See col. 9, lines 2-9. Determines whether a code change can be applied to the running software application using hot reload based on determining if the code change is actually compatible with hot reload technology being used. For example, some hot reload technologies are limited in the types of code changes that can be applied while an application is running, and the completeness determination component 131 ensures that a give code change can actually be applied using that technology – See col. 8, lines 37-46. Examiner respectfully notes that corresponding a runtime is as a runtime selection);
generating the safe implementation of the edited version (when using a compiled programming language, the change communication component 134 uses each hot reload agent identified in act 304 to communicate a new code entity or entities generated in act 303 to hot reload support 121 of runtime system 120 – See col. 11, lines 54-58);
installing the safe implementation of the edited version into the program as a hot reload (the hot reload orchestrator 114 is configured to coordinate use of other components of the development environment 105 in order to implement methods for hot reloading a running application with an unsaved source code change – See col. 6, lines 49-53); and
Hashimi does not disclose
modifying an original version implementation of the source code original version to throw an exception in response to an attempt to execute the original version implementation.
Wolfram discloses
modifying an original version implementation of the source code original version to throw an exception in response to an attempt to execute the original version implementation (modify the behavior of the agent functionality, at runtime, by means of a modification of the program flow configuration data, it is advantageously possible, according to the present invention, to flexibly, smoothly and quickly adapt the behavior of the both the agent functionality and the legacy software application such as to be able… – See paragraph [0029]. It checks (in a given time interval repeatedly according to a predefined repetition rate) whether the configuration-files (i.e. the method definition or the program flow configuration data 210 and the class mapper 220) have been modified; if so, it triggers a reload of the configuration and an update of changed interceptors… it checks on startup if the installed Java-version and the runtime environment are compatible with the agent functionality 200 (i.e. the lambda agent); it optionally adapts Java or runtime environment requirements. Execute old code (i.e. internally in the legacy software application 100); -- Execute new service (i.e. externally to the legacy software application 100); --Switch by defined percentage between old and new; -- Throw an Event/illegal code – See paragraphs [0070-0073]. Throws illegalArgumentException – See paragraphs [0038]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Wolfram’s teaching into Hashimi’s invention because incorporating Wolfram’s teaching would enhance Hashimi to enable to incrementally either update or modify procedures or methods or functions within the legacy software application, or to move processes or functions from the legacy software application towards an external execution environment as suggested by Wolfram (page 4).
11. Claim(s) 2 and 9-10 is/are rejected under 35 U.S.C. 103 as being unpatentable over Hashimi and Wolfram as applied to claim 1 above, and further in view of Levitt et al. (US Pub. No. 2024/0020100 A1 – herein after Levitt).
Regarding claim 2, the method of claim 1,
Levitt discloses
wherein the run time selection includes a selection between (a) executing a lambda only once, and (b) executing the lambda more than once (it may be a simple job scheduler (for example, a cron job) that starts another Operator at intervals. It may be a single Lambda function that runs once and exits – See paragraph [0116]. Upgrades to the executable applications require getting the latest JSON file versions, like a simple package manager. There is no need to restart the environment core unless core code changes. This potentially means real-time (i.e. no downtime), in-place code updates. This may involve some hot code reloading requirements. Executable applications may run to completion and then use the newer version when run again – See paragraphs [0139-0141]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Levitt’s teaching into Hashimi’s and Wolfram’s inventions because incorporating Levitt’s teaching would enhance Hashimi and Wolfram to enable to run Lambda function once as suggested by Levitt (paragraph [0116]).
Regarding claim 9, the method of claim 1,
Levitt discloses
wherein the original version of the source code and the edited version of the source code each comprise an invocation of a routine via a routine pointer (If a change is required, a new function template file is provided with pointers to the new version. The function template files may be hashed, so that when they are later downloaded from decentralized file systems, the expected hash can be compared with the actual hash to ensure that no tampering or misdirection is occurring. If the hashes match, then it is confirmed that the correct file is being used – See paragraph [0047]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Levitt’s teaching into Hashimi’s and Wolfram’s inventions because incorporating Levitt’s teaching would enhance Hashimi and Wolfram to enable to provide file with pointers to the new version as suggested by Levitt (paragraph [0047]).
Regarding claim 10, the method of claim 1,
Levitt discloses
wherein the original version of the source code and the edited version of the source code each comprise an instance of an interface programming language feature (A function-based executable application generated by the environment may be defined by addresses of linked instances of customer building-block functions managed by the environment and backed by an in-memory data state machine that stores the states of the functions – See paragraph [0014]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Levitt’s teaching into Hashimi’s and Wolfram’s inventions because incorporating Levitt’s teaching would enhance Hashimi and Wolfram to enable to generate application by the environment is defined by addresses of linked instances as suggested by Levitt (paragraph [0051]).
12. Claim(s) 7-8 and 12-13 is/are rejected under 35 U.S.C. 103 as being unpatentable over Hashimi and Wolfram as applied to claim 6 above, and further in view of Schmidt et al. (US Pub. No. 2025/0021309 A1 – herein after Schmidt).
Regarding claim 7, the method of claim 6,
Schmidt discloses
wherein the address of the lambda routine resides in a handler or resides in a handler dispatcher (UI builder 121 can produce adjustable layout programming instructions which can be integrated into application 126 (e.g., UI placeholder 154, streaming UI handler 256) – See paragraph [0144]. AWS Lambda can be an event-driven, serverless computing platform provided by AMAZON as a part of the AMAZON WEB SERVICES. LAMBDA can be a computer service that runs code in response to events and automatically manages the compute resources required by that code – See paragraph [0249]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Schmidt’s teaching into Hashimi’s and Wolfram’s inventions because incorporating Schmidt’s teaching would enhance Hashimi and Wolfram to enable to runs code in response to events and automatically manages the compute resources required by that code as suggested by Smidt (paragraph [0249]).
Regarding claim 8, the method of claim 1,
Schmidt discloses
wherein the original version of the source code and the edited version of the source code each comprise a lambda routine body (a program, a sub-routine, a portion of a program, or a software component or a hardware component capable of performing one or more stated tasks or functions – See paragraphs [0043-0046]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Schmidt’s teaching into Hashimi’s and Wolfram’s invention because incorporating Schmidt’s teaching would enhance Hashimi and Wolfram’s to performing one or more stated tasks or functions or a sub-routine, a portion of a program as suggested by Schmidt (paragraph [0043-0046]).
Regarding claim 12, the method of claim 1,
Schmidt discloses
wherein the original version of the source code and the edited version of the source code each comprise a language-integrated query expression if a user presses the number “5”, the number 5 appears on the alpha-numeric field. The programmer also implements logic for the operations: +−*/. Accordingly, a user may enter mathematical expressions such as 4+5*3. Then, the user could make the equals sign (=), a UI element created to be a Data Aware Component, that takes the entered information on the text field, sends it to a web service that performs the calculation, and then updates the alpha-numeric field UI with the result of that expression – See paragraph [0233]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Schmidt’s teaching into Hashimi’s and Wolfram’s invention because incorporating Schmidt’s teaching would enhance Hashimi and Wolfram’s to update the expression as suggested by Schmidt (paragraph [0233]).
Regarding claim 13, the method of claim 1,
Schmidt discloses
wherein the original version of the source code and the edited version of the source code each comprise a self-contained portion of a user interface which includes a processing logic to enable a dynamic behavior (individual design elements may also be defined in accordance with a desired run-time behavior. By way of example, some objects can be defined to have run-time behaviors that are either static or dynamic. The attributes of dynamic objects may change in response to predefined run-time events generated by the underlying application that is to incorporate the UI design under edit 125 – See paragraph [0093]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Schmidt’s teaching into Hashimi’s and Wolfram’s invention because incorporating Schmidt’s teaching would enhance Hashimi and Wolfram’s to change in response to predefined run-time events generated by the underlying application that is to incorporate the UI design under edit as suggested by Schmidt (paragraph [0093]).
13. Claim(s) 11 is/are rejected under 35 U.S.C. 103 as being unpatentable over Hashimi and Wolfram as applied to claim 1 above, and further in view of Matousek et al. (US Pub. No. 2023/0019235 A1 – herein after Matousek).
Regarding claim 11, the method of claim 1,
Matousek discloses
wherein the original version of the source code and the edited version of the source code each comprise an indirection whose value is indeterminate in the edited version of the source code (Upon retrieval of such notification, the UI framework replaces all updated reloadable types in its data structures with their corresponding new versions that include the updates. It should be appreciated that the usage pattern of reloadable types is such that allows the types to be replaced with their new versions. In other words, the user code that references these types will reference them indirectly (e.g. via a base type, an interface, or dynamic dispatch) rather than directly referencing specific version of the type – See paragraph [0022]).
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Matousek’s teaching into Hashimi’s and Wolfram’s invention because incorporating Matousek’s teaching would enhance Hashimi and Wolfram’s to allow the types to be replaced with new versions indirectly as suggested by Matousek (paragraph [0022]).
14. Claim(s) 19 is/are rejected under 35 U.S.C. 103 as being unpatentable over Hashimi and Wolfram as applied to claim 16 above, and further in view of Kruszewski et al. (US Pub. No. 2018/0024911 A1 – herein after Kruszewski).
Regarding claim 19, the system of claim 16,
Kruszewski discloses
wherein the safe implementation of the edited version comprises code which upon execution does at least one of:
modifies a membership of a set of variables captured by a lambda;
modifies a scope of a variable captured by a lambda (Scope -- reference to statement object, that describes scope for current statement – See paragraph [0190]); or
modifies a membership of a set of variables accessed by a lambda upon execution.
It would have been obvious to one ordinary skill in the art before the effective filing date of claimed invention to use Kruszewski’s teaching into Hashimi’s and Wolfram’s invention because incorporating Kruszewski’s teaching would enhance Hashimi and Wolfram to enable to modify procedures or methods or functions within software code as suggested by Wolfram (page 4).
Conclusion
15. The prior art made of record and not relied upon is considered pertinent to applicant's disclosure.
Rose et al. (US Pub. NO. 2020/0026530 A1) discloses performing type-constrained operations for plug-in types are disclosed. A runtime environment encounters a request to perform a type-constrained operation that requires evaluating a type constraint associated with a particular plug-in type. The runtime environment lacks sufficient native instructions to evaluate type constraints associated with plug-in types. The runtime environment accesses a plug-in type framework to obtain a particular type descriptor instance associated with the particular plug-in type – See Abstract and specification for more details.
Chen et al. (US Pub. No. 2022/0229659 A1) discloses determining whether a code update for the service is available at a central repository of the computing environment and, in response to determining that the code update is available, retrieving the code update from the central repository. The method further includes performing a modification of the service in view of the code update – See Abstract and specification for more details.
Burgos (US Pub. No. 2021/0117308 A) discloses a digital software recorder (DSR) leverages the functionality of a container management software platform, such as Docker, to permit time-travel debugging of a containerized software application, including pausing, playing, rewinding, and fast-forwarding execution of the application, by using snapshots taken by a snapshot manager service as the basis for setting the application state at points in the application's execution, thus saving debugging time that would otherwise be incurred by restarting an application – See Abstract and specification for more details.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to MONGBAO NGUYEN whose telephone number is (571)270-7180. The examiner can normally be reached Monday-Friday 8am-5pm.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Hyung S. Sough can be reached at 571-272-6799. 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.
/MONGBAO NGUYEN/ Examiner, Art Unit 2192