DETAILED ACTION
The Office Action is in response to claims filed 7/26/2024.
Claims 1-20 are currently pending.
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Claim Objections
Applicant is advised that should claim 9 be found allowable, claim 10 will be objected to under 37 CFR 1.75 as being a substantial duplicate thereof. When two claims in an application are duplicates or else are so close in content that they both cover the same thing, despite a slight difference in wording, it is proper after allowing one claim to object to the other as being a substantial duplicate of the allowed claim. See MPEP § 608.01(m).
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.
The factual inquiries for establishing a background for determining obviousness under 35 U.S.C. 103 are summarized as follows:
1. Determining the scope and contents of the prior art.
2. Ascertaining the differences between the prior art and the claims at issue.
3. Resolving the level of ordinary skill in the pertinent art.
4. Considering objective evidence present in the application indicating obviousness or nonobviousness.
Claims 1-3, 15, and 17-18 are rejected under 35 U.S.C. 103 as being unpatentable over US 11385892 B1 hereinafter “Zhang” in view of US 20250085931 A1 hereinafter “Carrara” and further in view of US 12596755 B1 hereinafter “Carter”.
With regards to claim 1, Zhang teaches
A system for software code development (Zhang Column 2 Lines 41-45, “Software modernization broadly refers to converting, rewriting, or porting legacy software applications or systems to more modern computer programming languages, software libraries, protocols, hardware platforms, application architectures, cloud-based services, and the like.”) that estimates runtime processing efficiency of serverless applications (Zhang Column 9 lines 27-67 to Column 10 Lines 1-4, “FIG. 2 is a diagram illustrating the use of a modernization service agent to collect and generate application profile data identifying the subunits of a software application and associated dependency and performance data according to some embodiments [that estimates runtime processing efficiency of serverless applications]… For example, the descriptive profile data 204 can include, for each identified subunit of an application, information describing some or all of: a name of the subunit, a description of the subunit, a size of the subunit, types of interfaces associated with the subunit (e.g., input and output), dependencies associated with the subunit (e.g., to other subunits, to packages, etc.), an operating platform associated with the subunit (e.g., an OS and version, system architecture, programming language, framework(s) and versions, memory, etc.), features associated with the subunit such as, for example, an average or maximum execution time, a latency requirement, whether the subunit is stateful or stateless (e.g., based on memory, local file, or database usage), performance requirements (e.g., shared resources), environment variables, API payload size, burst workload, disk usage, memory usage, CPU usage, IPv4 or IPv6, IPC, RPC usage, etc.”)
to provide recommendations for more efficient code for the serverless applications, (Zhang Column 10 Lines 45-62, “ In some embodiments, at circle “5,” an assessment service 124 uses a software architecture knowledgebase 130 to determine, based on the identified subunits and dependency and performance data, a recommended software architecture from a set of candidate software architectures (e.g., candidate software architectures possibly including a service-oriented application (SOA) architecture, a microservices architecture, a serverless architecture, etc.). In some embodiments, a software modernization ontology model is defined and used to describe each of the three software architectures (possibly in addition to any number of other software modernization concepts), although generally other types of data structures and models can be used such as decision trees, text-based models, database models, machine learning (ML) based models etc. In general, the software architecture knowledgebase 130 includes data indicating relevant features and constraints associated with each of the candidate software architectures under consideration.”) [Examiner’s Note: Further modernization means to provide more efficient serverless architecture optimization.] the system comprising
one or more processors; and one or more non-transitory, computer-readable mediums, comprising instructions that, when executed by one or more processors, cause operations (Zhang Column 14 Lines 55-65 to Column 15 Lines 1-3, “Some or all of the operations 500 (or other processes described herein, or variations, and/or combinations thereof) are performed under the control of one or more computer systems configured with executable instructions and are implemented as code (e.g., executable instructions, one or more computer programs, or one or more applications) executing collectively on one or more processors, by hardware or combinations thereof. The code is stored on a computer-readable storage medium, for example, in the form of a computer program comprising instructions executable by one or more processors. The computer-readable storage medium is non-transitory. In some embodiments, one or more (or all) of the operations 500 are performed by a software modernization service 102, modernization agent 132, or other component of the other figures.”) comprising:
retrieving a first code base of a first user from a first computing service provided by a cloud platform; (Zhang Column 8 Lines 15-40, “Although referred to herein as an “agent,” in general, a modernization agent 132 can include a software agent, a standalone application, a server, or any other type of software application, and may be accessed using any of a GUI, CLI, web-based API, or any other type of interface. In some embodiments, instead of using a modernization agent 132, users can instead obtain application profile data 136 using other software tools or processes and upload the data using an API provided by the modernization service 102 [from a first computing service provided by a cloud platform]. As part of the assessment process, in some embodiments, a user invokes an “inventory” command provided by a modernization agent 132 and used to identify applications located within the user's computing environment 134 (e.g., including software application 142 in the example of FIG. 1) [retrieving a first code base of a first user]… The software modernization service 102 may then in turn instruct a modernization agent 132 or other software agents running in the user computing environment 134 to perform some or all of the operations described in reference to FIG. 1 such as, for example, identifying an inventory of applications, obtaining application profile data 136 for one or more selected applications, and performing various application modernization analyses”)
parsing the first code base to determine a first set of [lambda] functions in the first code base; (Zhang Column 9 Lines 28-49, “FIG. 2 is a diagram illustrating the use of a modernization service agent to collect and generate application profile data identifying the subunits of a software application and associated dependency and performance data according to some embodiments … An application graph 202 thereby enables a user to readily understand and visualize the constituent parts of an application and to help identify sensible subunits. In other embodiments, other static and dynamic application analysis techniques are used to identify an application's subunits.”) [Examiner’s Note: For one of ordinary skill in the art an application graph can encompass something like an AST which are used to parse codebases and identify functions therein.]
performing one or more tracing operations on the first code base to determine respective runtime processing efficiencies for the first set of [lambda] functions; (Zhang Column 7 Lines 48-58, “For example, in some embodiments, a modernization agent 132 is configured to collect and generate application profile data 136, including a subunit list 138 and associated dependency and performance data 140, based on application artifacts 146 (e.g., source code or other types of application artifacts such as bytecode, Common Intermediate Language (CIL) code, etc., used to implement a software application 142 and possibly stored in a source code repository 144) and monitoring the execution of the software application 142. As described in more detail hereinafter, once the subunit list 138 and associated dependency and performance data 140 is obtained”)
Zhang does not teach: generating training data by labeling the first set of lambda functions with the respective runtime processing efficiencies;
training, using the training data, a first artificial intelligence model to generate outputs of recommendations for alternative lambda functions in response to receiving inputs of code samples;
receiving a first code sample [for a first serverless application;] identifying a first lambda function in the first code sample;
generating a first feature input for the first artificial intelligence model based on the first code sample and the first lambda function;
inputting the first feature input into the first artificial intelligence model to generate a first output;
generating for display, on a user interface, first recommendation comprising a second lambda function for replacing the first lambda function in the first code sample.
However, in an analogous art Carrara teaches generating training data by labeling the first set of [lambda] functions with the respective runtime processing efficiencies; (Carrara [0088], “The use of generative AI to assist a developer in developing control code 908 or other aspects of an industrial control project can abstract the developer from the details of the control programming language itself, facilitating a higher-level approach to code creation that allows the developer to express the functional requirements for an industrial control system in a natural, plain language manner, with the generative AI model 226—trained with industry-specific sets of training data an industrial knowledge—creating control code 908 that aligns with the requirements. This approach can also mitigate the need for developers to manually define detailed device configurations or specify data tags for the control code 908, instead allowing the generative AI model 226 to infer and set specific device or tag configurations based on inferences of the user's functional requirements and the industry-specific training of the model 226. By relying on the generative AI model 226 to generate some or all of the control code 908 or other aspects of a system project, the system 202 allows the developer to focus more exclusively on the desired functional and performance results of the control design—e.g., in terms of speed, cost, efficiency, etc.—and letting those results drive automated generation of suitable control code 908.”) [Examiner’s Note: Although training data allows a developer to focus on speed/cost/efficiency (processing efficiencies) these parameters can be data tags/labels for control code for specified training of a generative model.]
training, using the training data, a first artificial intelligence model to generate outputs of recommendations for alternative [lambda] functions (Carrara [0086], “To this end, some embodiments of generative AI component 210 can be configured to monitor design input 512 over time and, based on this monitoring, learn correlations between certain design actions (e.g., addition of certain code modules or snippets to design projects, selection of certain visualizations, etc.) and types of industrial assets, industrial sequences, or industrial processes being designed [training, using the training data, a first artificial intelligence model]. The generative AI component 210 can refine the generative AI model's training using these learned correlations, which can subsequently be used to automatically generate control code 908 or render recommendations during subsequent project development sessions. For example, if generative AI model 226 determines, based on analysis of design input 512 received during a design session, that a designer is currently developing a control project involving a type of industrial equipment that has been programmed and/or visualized in the past in a repeated, predictable manner, the generative AI component 210 can instruct user interface component 204 to render recommended development steps or control code 908 the designer may wish to incorporate into the system project 302 based on how this equipment was configured and/or programmed in the past [to generate outputs of recommendations for alternative lambda functions]”) in response to receiving inputs of code samples;
receiving a first code sample […] (Carrara [0123], “Some embodiments of the industrial IDE system 202 can also include project conversion tools that use the generative AI model 226 to perform various types of conversions or enhancements on submitted control code. FIG. 15 is a diagram illustrating conversion of control code 1502a submitted to the IDE system 202 to converted code 1502b using generative AI. In this example embodiment, users can submit control code 1502a to the IDE system 202 in a manner similar to submission of control code 1102 described above in connection with FIG. 11. In this case, the control code 1502a is submitted for conversion or enhancement by the system's project conversion component 216.”) [Examiner’s Note: By submission of control code the system receives the code in order to generate recommendations as an output.]
identifying a first [lambda] function in the first code sample; (Carrara [0129], “Also, in some embodiments, the generative AI model 226 can be trained to examine submitted control code 1502a and generate plain language comments to be assigned to specific lines (e.g., ladder logic rungs) or sections of the code. These comments serve as human-readable descriptors that provide a functional summary or label for their corresponding lines or section of code. In such embodiments, this training can teach the model 226 to recognize lines or segments of code that are designed to carry out known control functions ”) [Examiner’s Note: Segments of code, sections of code, specific lines of code can refer to a lambda function.]
generating a first feature input for the first artificial intelligence model based on the first code sample and the first [lambda] function; (Carrara [0117], “ In an example scenario, a user wishing to generate control code 908 for carrying out a specific control function, or who has a question about a submitted control program, can submit an initial plain language request or query that broadly states the functional requirement or query. The prompt enhancement component 214 can parse this initial request to determine the type of information or service being requested, and either refine and contextualize the initial query in a manner expected to assist the model 226 to more quickly and accurately arrive at the desired answer or design solution, or render one or more query responses 1402 that prompt the user for further information that will allow the model 226 to provide a more complete or accurate solution to the user's request, or that collaborate with the user in exploring potential content variations likely to satisfy the user's needs. This prompt engineering can be based in part on learned knowledge of the types of questions that need to be answered in order to generate control code 908 or other control system components that align with the requirements of an automation system for which the project is being designed.”) [Examiner’s Note: A section of control code and the control code itself describes a code sample/lambda function that are used to contextualize and formulate a feature prompt/input engineered specifically for the machine learning model]
inputting the first feature input into the first artificial intelligence model to generate a first output; (Carrara [0060-62], “Through interaction with the system's user interface component 204, developers can submit design input 512 to the IDE system 202 in various supported formats. Design input 512 can comprise explicit control code (e.g., control logic, structured text, sequential function charts, etc.), visualization programming, and device configuration parameter definitions. Additionally, design input 512 can include other types of input conveying the functional specifications or design goals for the automation system, and the system's generative AI component 210 can generate portions of the system project 302 to align with these design goals using generative AI techniques … Based on this design input 512, user interface component 204 can render design feedback 518 designed to assist the developer in connection with developing a system project 302 for configuration, control, and visualization of an industrial automation system. At least some of this design feedback 518 can comprise prompts generated by the generative AI component 210 requesting specific items of information that can be used to generate portions of the system project 302 using generative AI. These generative AI features will be described in more detail herein.”) and
generating for display, on a user interface, first recommendation comprising a second [lambda] function for replacing the first [lambda] function in the first code sample. (Carrara [0102], “Based on this analysis, the generative AI component 210 can render a notification identifying any deviations from an applicable industrial standard or protocols. If deviations from relevant safety standards (or other types of industrial standards) are found, the user interface component 204 can render recommendations or other types of feedback for bringing the code 1102 into compliance with the internal or external standards. This feedback can take the form of text-based recommendations (e.g., recommendations to rewrite an indicated portion of the code 1102 to comply with a defined programming standard), syntax highlighting, error highlighting, auto-completion of code snippets, or other such formats.”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Carrara into the teachings of Zhang. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of an AI based rules engine to generate recommendations designing control functions (Carrara [0082]).
The combination of Zhang and Carrara does not teach a lambda function.
However in an analogous art Carter teaches a lambda function (Carter Column 6 Lines 35-61, “In the example of FIG. 1, the observability platform 130 may include a query building engine 104 that uses an impatient query engine and lambda function(s) (not pictured). A lambda function may be a self-contained serverless application code written in a supported language and runtime to perform one or more computational tasks. For example, a function may be an independent unit of execution and deployment, such as a microservice. The observability platform 130 is configured to execute many instances of the same function or of different functions in an efficient and flexible manner. ”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Carter into the teachings of Zhang in view of Carrara. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of utilizing an AI/LLM engine with complex instructions to solve problems and generate natural language or code (Carter Column 10 Lines 6-33).
Claim 2 is directed to a method corresponding to the system limitations as disclosed in claim 1. Thus, claim 2 is rejected for the same reasons set forth in claim 1.
With regards to claim 3, the rejection of claim 2 is incorporated.
Zhang does not teach: receiving a user input accepting the first recommendation;
and generating a second code sample replacing the first lambda function with the second lambda function.
However, in an analogous art Carrara teaches receiving a user input accepting the first recommendation; (Carrara [0101], “These can include, for examples, modifications that will reduce the amount of code without substantively altering the code's intended functionality; modifications that will improve one or more performance metrics of the automation system to be controlled by the code 1102 (e.g., speed, energy consumption, machine uptime, product throughput, cycle time, etc.), or otherwise cause a performance metric to satisfy a criterion indicative of improved performance; modifications that reduce the number of data tags consumed by the code 1102; or other such modifications. In some cases, the system 202 can allow the user to respond to the initial recommendation with one or more follow-up questions about the modification or its impacts on system performance, if the use desires additional information prior to accepting the proposed modifications (e.g., “Will this modification increase energy consumption?”, “How much will product output increase if this modification is implemented?”, etc.). The generative AI component 210 can respond to these queries with the requested information, as determined based on further analysis by the generative AI model 226. Once satisfied, the user can indicate acceptance of the recommended modifications, which can then be integrated into the code 1102.”)
and generating a second code sample replacing the first lambda function with the second lambda function.(Carrara [0124], “The project conversion component can perform various types of conversions on the control code 1502a. For example, the project conversion component 216 can leverage the generative AI component 210 (and model 226) to convert the functional format of the code 1502a from a first code format or language to a second code format or language, and generate converted control code 1502b that is functionally equivalent or similar to control code 1502a but formatted according to the second format. Example control code formats for the first or second formats can include, but are not limited to, ladder logic, structured text, functional block diagrams, industrial DSL, Python, C++, or other such formats.”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Carrara into the teachings of Zhang. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of an AI based rules engine to generate recommendations designing control functions (Carrara [0082]).
With regards to claim 15, the rejection of claim 2 is incorporated.
Zhang further teaches wherein retrieving the first artificial intelligence model further comprises: receiving a first trigger for a code sample update; (Zhang Column 14 Lines 38-50, “In some embodiments, at circle “4,” the user may then cause a modernization agent 132 to reanalyze the application based on the refactored application artifacts 408B, resulting in updated application profile data 400B. In some embodiments, at circle “5,” the modernization agent 132 then causes the generation of a new architecture recommendation request 402. In some embodiments, based on the updated application profile data 400B, the assessment service 124 generates a new recommendation 404B, where the new recommendation may instead recommend the previously unsuitable software architecture assuming the identified impediments have been resolved in the updated version of the software application 142.”)
The combination of Zhang and Carrara does not teach: detecting the first trigger during execution of the first code sample;
determining to retrieve the first artificial intelligence model based on detecting the first trigger.
However, in an analogous art Carter teaches detecting the first trigger during execution of the first code sample; (Carter Column 6 Lines 35-61, “ The observability platform 130 may rely on the server 120 to maintain session state. In the example of FIG. 1, the observability platform 130 may include a query building engine 104 that uses an impatient query engine and lambda function(s) (not pictured). A lambda function may be a self-contained serverless application code written in a supported language and runtime to perform one or more computational tasks. For example, a function may be an independent unit of execution and deployment, such as a microservice. The observability platform 130 is configured to execute many instances of the same function or of different functions in an efficient and flexible manner. The observability platform 130 executes each function in its own container. For example, when a function is created, the observability platform 130 packages it into a new container and executes that container on a multi-tenant cluster of machines on demand. In some implementations, the observability platform 130 executes one or more functions in response to events (e.g., multiple individual requests with associated timestamps) and automatically manages the computing resources required by that code [detecting the first trigger during execution of the first code sample]. For example, the observability platform 130 may be configured to receive HTTP requests from the server 120 via an API of the web service 124, automatically provision back-end services triggered by the HTTP requests, and deallocate such services when corresponding application code is not in use. ”)
determining to retrieve the first artificial intelligence model based on detecting the first trigger. (Carter Column 17 Lines 32-48, “For example, the resulting responses received from one of the multiple generative AI engines 302(a-n) may be more appropriate and/or more tailored to the requesting user of the observability platform based on a context bundle that is generated and/or determined per request. In an embodiment, the generated responses are received in parallel from the multiple generative AI engines 302(a-n), and various methods may be employed by the AI engine selection module 318 to determine which response is the best for the requesting user. In other embodiments, A/B testing is employed by the AI engine selection module 318 to determine which response best meets the needs of the requesting user based on user feedback. In further embodiments, experimentation, testing, and validation methods and techniques may be used by the AI engine selection module 318 to select between the multiple generative AI response engines 302(a-n).”) [Examiner’s Note: the observability platform can generate queries/requests/triggers that cause an AI selection module to select between AI models/engines trained for the most appropriate result.]
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Carter into the teachings of Zhang in view of Carrara. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of utilizing an AI/LLM engine with complex instructions to solve problems and generate natural language or code (Carter Column 10 Lines 6-33).
Claims 17-18 are directed to one or more non-transitory, computer-readable mediums corresponding to the method limitations as disclosed in claim 2-3. Thus, claims 17-18 are rejected for the same reasons set forth in claims 2-3.
Claims 4, 8, and 19 are rejected under 35 U.S.C. 103 as being unpatentable over Zhang in view of Carrara in view of Carter, as applied to claims 2 and 17 above, and further in view of US 11775352 B1 hereinafter “Krishnegowda”.
With regards to claim 4, the rejection of claim 2 is incorporated.
The combination of Zhang, Carrara, and Carter teaches lambda functions but does not teach: determining the respective runtime processing efficiencies for the first set of [lambda] functions further comprises: performing a first tracing operation on the first set of [lambda] functions;
and receiving a first result of the first tracing operation.
However, in an analogous art Krishnegowda teaches determining the respective runtime processing efficiencies for the first set of [lambda] functions further comprises: performing a first tracing operation on the first set of [lambda] functions;
and receiving a first result of the first tracing operation. (Krishnegowda Columns 6-7 Lines 56-57 and 1-15, “FIG. 2 is a flow diagram of a computerized method 200 of automated prediction of computing resource performance scaling using reinforcement learning, using system 100 of FIG. 1. Performance testing and tracing module 106a executes (step 202) one or more performance tests against production computing environment 108 to capture performance data for one or more computing resources (i.e., virtual machines or pods or containers in VM/pod layer 108a; lambda functions in function layer 108b, and databases in database layer 108c). In some embodiments, module 106a initiates a plurality of transactions for processing by production computing environment 108, where the transactions are the same or similar to those that would be initiated by end users via client computing device(s) 102. For example, the one or more performance tests may comprise one or more programmatic scripts that, when executed by module 106a, generate and submit transactions to environment 108. During execution of the performance tests, module 106a is configured to trace execution of the transactions throughout the layers 108a, 108b, 108c of environment 108—in one embodiment, module 106a deploys a tracing tool to each layer of environment which captures relevant performance information (e.g., response time(s), results, errors) of the transactions and of related computing resources (e.g., processor/memory usage, application instance count, concurrency, scaling, etc.). ”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Krishnegowda into the teachings of Zhang in view of Carrara and further in view of Carter. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, while tracing the functions to determine characteristics of a cloud computing application, as in Krishnegowda. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of organizing availability of resource configurations by classifying optimal system in view of a cost tolerance (Krishnegowda Column 7 Lines 51-58).
With regards to claim 8, the rejection of claim 2 is incorporated.
Zhang does not teach: performing one or more tracing operations on the first code base;
However, in an analogous art Carrara teaches performing one or more tracing operations on the first code base; (Carrara [0086], “To this end, some embodiments of generative AI component 210 can be configured to monitor design input 512 over time and, based on this monitoring, learn correlations between certain design actions (e.g., addition of certain code modules or snippets to design projects, selection of certain visualizations, etc.) and types of industrial assets, industrial sequences, or industrial processes being designed.”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Carrara into the teachings of Zhang. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of an AI based rules engine to generate recommendations designing control functions (Carrara [0082]).
The combination of Zhang Carrara and Carter teaches a lambda function but does not teach: determining a runtime characteristic of each [lambda] function of the first set of [lambda] functions based on the one or more tracing operations
However, in an analogous art Krishnegowda teaches determining a runtime characteristic of each [lambda] function of the first set of [lambda] functions based on the one or more tracing operations. (Krishnegowda Columns 6-7 Lines 56-57 and 1-15, “FIG. 2 is a flow diagram of a computerized method 200 of automated prediction of computing resource performance scaling using reinforcement learning, using system 100 of FIG. 1. Performance testing and tracing module 106a executes (step 202) one or more performance tests against production computing environment 108 to capture performance data for one or more computing resources (i.e., virtual machines or pods or containers in VM/pod layer 108a; lambda functions in function layer 108b, and databases in database layer 108c). In some embodiments, module 106a initiates a plurality of transactions for processing by production computing environment 108, where the transactions are the same or similar to those that would be initiated by end users via client computing device(s) 102. For example, the one or more performance tests may comprise one or more programmatic scripts that, when executed by module 106a, generate and submit transactions to environment 108. During execution of the performance tests, module 106a is configured to trace execution of the transactions throughout the layers 108a, 108b, 108c of environment 108—in one embodiment, module 106a deploys a tracing tool to each layer of environment which captures relevant performance information (e.g., response time(s), results, errors) of the transactions and of related computing resources (e.g., processor/memory usage, application instance count, concurrency, scaling, etc.). ”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Krishnegowda into the teachings of Zhang in view of Carrara and further in view of Carter. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, while tracing the functions to determine characteristics of a cloud computing application, as in Krishnegowda. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of organizing availability of resource configurations by classifying optimal system in view of a cost tolerance (Krishnegowda Column 7 Lines 51-58).
Claim 19 is directed to one or more non-transitory, computer-readable mediums corresponding to the method limitations as disclosed in claim 4. Thus, claim 19 is rejected for the same reasons set forth in claim 4.
Claims 5 and 20 are rejected under 35 U.S.C. 103 as being unpatentable over Zhang in view of Carrara in view of Carter as applied to claims 2 and 17 above, and further in view of US 20240256242 A1 hereinafter “Goyer”.
With regards to claim 5, the rejection of claim 2 is incorporated.
The combination of Zhang, Carrara, and Carter does not teach retrieving the first code base of the first user further comprises: accessing a first computing service provided by a cloud platform;
and providing first credentials for validating access to the first code base
However, in an analogous art Goyer teaches retrieving the first code base of the first user further comprises: accessing a first computing service provided by a cloud platform; (Goyer [0033], “When a change event 106 has been approved via the validation system 104, the validation system 104 may approve and/or initiate the integration of the code change into the CI/CD system 102. As shown in this example, the validation system 104 may forward a code integration request 122 based on the change event 106, including the modified code from the developer's local development environment, to the CI/CD system 102. The CI/CD system 102 may receive and/or upload the modified code and perform the necessary code replacements or overwrites to merge the modified code from the developer into the application codebase within the shared repository.”)
and providing first credentials for validating access to the first code base (Goyer [0023], “To perform and analyze the validations for requested software changes, the validation system 104 may interact with various users having different roles and/or different authorization credentials via user devices 108. For example, the validation system 104 may receive software deployment requests (e.g., change events 106) from developers via user devices 108(1) … Additionally, as described in more detail below, the validation system 104 may provide interfaces to interact with authorized administrators via user devices 108(3). Such interfaces may for example, allow authorized users to define the sets of validations required for particular software components, particular deployment environments, and/or particular developers/teams. The validation system 104 also may provide interfaces to allow authorized users to review and analyze the validation results/metrics for large numbers of change events performed over a time period, including groups of validations based on software components, developers or development teams, and/or deployment environments, etc.”) [Examiner’s Note: validations allow administrators to determine which development team or individual developer has the appropriate credentials to access particular software components/code bases.]
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Goyer into the teachings of Zhang in view of Carrara and further in view of Carter. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, and sharing software between different environments using profile information for defined/specified access, as in Goyer. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of building, executing, validating, and receiving software in different environments private or otherwise (Goyer [0010]).
Claim 20 is directed to one or more non-transitory, computer-readable mediums corresponding to the method limitations as disclosed in claim 5. Thus, claim 20 is rejected for the same reasons set forth in claim 5.
Claim 6 is rejected under 35 U.S.C. 103 as being unpatentable over Zhang in view of Carrara in view of Carter as applied to claim 2 above, and further in view of US 20260072811 A1 hereinafter “Pillay”.
With regards to claim 6, the rejection of claim 2 is incorporated.
The combination of Zhang, Carrara, and Carter teaches wherein parsing the first code base to determine the first set of lambda functions but does not teach further comprises: generating a tokenized code base based on the first code base;
and processing the tokenized code base to generate an abstract syntax tree.
However, in an analogous art Pillay teaches further comprises: generating a tokenized code base based on the first code base;
and processing the tokenized code base to generate an abstract syntax tree. (Pillay [0066], “Analyzing source code to create a structural dependency graph involves several detailed steps that are important for optimizing regression testing. This graph visually represents the relationships and dependencies between various code elements, which helps in identifying specific areas of the codebase affected by changes. Initially, the source code is parsed to convert it into an intermediate representation that may be readily analyzed. Lexical analysis is employed to tokenize the code into manageable pieces called tokens, representing fundamental elements such as keywords, operators, identifiers, and literals. This is followed by syntactic analysis, which uses these tokens to construct an Abstract Syntax Tree (AST). The AST provides a hierarchical tree representation of the syntactic structure of the source code, where each node represents a construct such as, for example, a variable declaration, function call, or control structure.”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Pillay into the teachings of Zhang in view of Carrara and further in view of Carter. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, and breaking up the software into tokens to generate a graph and parse for desired features therein, as in Pillay. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of generating an AST from source code to detect, map, and analyze changes over affected code elements (Pillay [0025]).
Claim 7 is rejected under 35 U.S.C. 103 as being unpatentable over Zhang in view of Carrara in view of Carter as applied to claim 2 above, in view of Krishnegowda and further in view of US 20160179654 A1 hereinafter “Cox”.
With regards to claim 7, the rejection of claim 2 is incorporated.
The combination of Zhang, Carrara, and Carter teaches lambda functions but does not teach: wherein determining the respective runtime processing efficiencies for the first set of [lambda] functions further comprises: determining, during a first run, a first respective execution time for each [lambda] function in the first set of [lambda] functions;
However, in an analogous art Krishnegowda teaches wherein determining the respective runtime processing efficiencies for the first set of [lambda] functions further comprises: determining, during a first run, a first respective execution time for each [lambda] function in the first set of [lambda] functions; (Krishnegowda Columns 6-7 Lines 56-57 and 1-15, “FIG. 2 is a flow diagram of a computerized method 200 of automated prediction of computing resource performance scaling using reinforcement learning, using system 100 of FIG. 1. Performance testing and tracing module 106a executes (step 202) one or more performance tests against production computing environment 108 to capture performance data for one or more computing resources (i.e., virtual machines or pods or containers in VM/pod layer 108a; lambda functions in function layer 108b, and databases in database layer 108c). In some embodiments, module 106a initiates a plurality of transactions for processing by production computing environment 108, where the transactions are the same or similar to those that would be initiated by end users via client computing device(s) 102. For example, the one or more performance tests may comprise one or more programmatic scripts that, when executed by module 106a, generate and submit transactions to environment 108. During execution of the performance tests, module 106a is configured to trace execution of the transactions throughout the layers 108a, 108b, 108c of environment 108—in one embodiment, module 106a deploys a tracing tool to each layer of environment which captures relevant performance information (e.g., response time(s), results, errors) of the transactions and of related computing resources (e.g., processor/memory usage, application instance count, concurrency, scaling, etc.). ”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Krishnegowda into the teachings of Zhang in view of Carrara and further in view of Carter. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, while tracing the functions to determine characteristics of a cloud computing application, as in Krishnegowda. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of organizing availability of resource configurations by classifying optimal system in view of a cost tolerance (Krishnegowda Column 7 Lines 51-58).
The combination of Zhang, Carrara, Carter, and Krishnegowda does not teach: determining, during a second run, a second respective execution time for each lambda function in the first set of lambda functions;
However, in an analogous art Cox teaches determining, during a second run, a second respective execution time for each lambda function in the first set of lambda functions; (Cox [0048], “The monitoring and recording may be repeated 106 for repeat executions of the source code resulting in the collection of multiple time elapse values for each block. This data may be analyzed to obtain an average elapsed time for a block and its standard deviation.”) [Examiner’s Note: A source code can have multiple code blocks (functions/lambda functions) wherein repeated executions will allow for collection of individual block execution times.]
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Cox into the teachings of Zhang in view of Carrara in view of Carter and further in view of Krishnegowda. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, while tracing the functions to determine characteristics of a cloud computing application, as in Krishnegowda, and execution of the code while monitoring runtime performance, as in Cox. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of defining blocks of source code during execution to record elapsed time of the block (Cox [0019]).
Claim(s) 9-11 are rejected under 35 U.S.C. 103 as being unpatentable over Zhang in view of Carrara in view of Carter as applied to claim 2 above, and further in view of US 20250284515 A1 hereinafter “Segner”.
With regards to claim 9, the rejection of claim 2 is incorporated.
The combination of Zhang, Carrara, and Carter teaches a lambda function does not teach: determining a second runtime efficiency for the second [lambda] function; and
generating for display the second runtime efficiency in the first recommendation.
However, in an analogous art Segner teaches determining a second runtime efficiency for the second [lambda] function; and
generating for display the second runtime efficiency in the first recommendation. (Segner [0017], “For example, the optimization device may obtain telemetry data from the cloud system to determine performance requirements of an application based on the telemetry data, the virtualized instance that the application is currently deployed on, and a processing performance score for the virtualized instance on which the application is currently deployed. The optimization device may identify one or more recommended virtualized nodes that may be more efficient for the deployment of the application using a processing capacity utilization score of the application. In some implementations, the optimization device may determine efficiency scores for respective virtualized nodes of the one or more recommended virtualized nodes using one or more efficiency metrics (e.g., for one or more resources associated with the cloud computing environment). The optimization device may perform an action associated with a selection of a virtualized node via which the application is to be deployed, such as displaying the one or more recommended virtualized nodes (e.g., to enable a user to view and select one of the recommended virtualized nodes) and/or causing the application to be deployed via one of the recommended virtualized nodes.”) [Examiner’s Note: A virtualized node is described as a lambda function in paragraph 13.]
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Segner into the teachings of Zhang in view of Carrara and further in view of Carter. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, in order to generate and view processing efficiency of an updated version of recommended software, as in Segner. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of deploying cloud computing environments in accordance with virtualized nodes (lambda functions) that is correctly provisioned for optimal performance (Segner [0015-17]).
Claim 10 discloses the same limitations as disclosed in claim 9. Thus claim 10 is rejected for the same reasons set forth in claim 9.
With regards to claim 11, the rejection of claim 2 is incorporated.
The combination of Zhang, Carrara, and Carter teaches a lambda function but does not teach: determining a first runtime efficiency for the first [lambda] function;
determining a second runtime efficiency for the second [lambda] function;
comparing the first runtime efficiency to the second runtime efficiency; and
based on comparing the first runtime efficiency to the second runtime efficiency, selecting the second [lambda] function for replacing the first lambda function in the first code sample.
However, in an analogous art Segner teaches determining a first runtime efficiency for the first [lambda] function;
determining a second runtime efficiency for the second [lambda] function; (Segner [0017], “For example, the optimization device may obtain telemetry data from the cloud system to determine performance requirements of an application based on the telemetry data, the virtualized instance that the application is currently deployed on, and a processing performance score for the virtualized instance on which the application is currently deployed. The optimization device may identify one or more recommended virtualized nodes that may be more efficient for the deployment of the application using a processing capacity utilization score of the application. In some implementations, the optimization device may determine efficiency scores for respective virtualized nodes of the one or more recommended virtualized nodes using one or more efficiency metrics (e.g., for one or more resources associated with the cloud computing environment). The optimization device may perform an action associated with a selection of a virtualized node via which the application is to be deployed, such as displaying the one or more recommended virtualized nodes (e.g., to enable a user to view and select one of the recommended virtualized nodes) and/or causing the application to be deployed via one of the recommended virtualized nodes.”) [Examiner’s Note: telemetry data is where processing efficiency is determined for instances of a virtualized node otherwise described as a lambda function.]
comparing the first runtime efficiency to the second runtime efficiency; and
based on comparing the first runtime efficiency to the second runtime efficiency, selecting the second lambda function for replacing the first lambda function in the first code sample. (Segner [0044-45], “For example, the client device may display processing characteristics of the currently virtualized node and processing characteristics of one or more recommended virtualized nodes in the same user interface and/or the same graphical element. This may enable reliable comparison of different virtualized nodes and a comparison of the efficiencies of the respective virtualized nodes. This may enable a reliable and/or accurate comparison of different virtualized nodes that can be used for a deployment of the application. For example, in some cases, the client device may obtain a user input indicating that the application is to be deployed via a recommended virtualized node. The client device (and/or the optimization device) may cause the application to be deployed via the recommended virtualized node. For example, the recommended virtualized node selected by the user may be more efficient than the current virtualized node (e.g., in terms of the metric used to calculate the efficiency scores). “) [Examiner’s Note: A virtualized node is described as a lambda function in paragraph 13.]
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Segner into the teachings of Zhang in view of Carrara and further in view of Carter. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, in order to generate and view processing efficiency of an updated version of recommended software, as in Segner. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of deploying cloud computing environments in accordance with virtualized nodes (lambda functions) that is correctly provisioned for optimal performance (Segner [0015-17]).
Claim(s) 12-13 are rejected under 35 U.S.C. 103 as being unpatentable over Zhang in view of Carrara in view of Carter as applied to claim 2 above, and further in view of US 12517704 B1 hereinafter “Ostrovsky”.
With regards to claim 12, the rejection of claim 2 is incorporated.
The combination of Zhang, Carrara, and Carter teaches a lambda function but does not teach: wherein generating for display the first recommendation further comprises: determining a preceding line of code in the first code sample;
determining an interaction between the preceding line of code and the first [lambda] function; and
validating the second [lambda] function based on the interaction.
However, in an analogous art Ostrovsky teaches wherein generating for display the first recommendation further comprises: determining a preceding line of code in the first code sample; (Ostrovsky Column 10 Lines 13-23, “Readers will further appreciate that the position of each input token 306 in the input sequence signifies the order or context in which the input token 306 appears, as the preceding and following input tokens 306 in the input sequence provides context for a particular input token 306. In such a way, the context helps the code generation model(s) 118 understand the relationships and dependencies between various input tokens 306, thereby helping the code generation model(s) 118 generate accurate and contextually relevant suggested code 316 that can ultimately be presented as a recommended code completion 312 or leveraged in some other way.”)
determining an interaction between the preceding line of code and the first [lambda] function; (Ostrovsky Column 12 Lines 36-49, “The code generation model(s) 118 may maintain an internal state that keeps track of the context of the code it is generating, where the context can include variables, function declarations, loops, conditionals, and other elements that are used to generate code that follows a logical and semantically correct structure. The code generation model(s) 118 may therefore be designed to understand and replicate the structure, syntax, and semantics of programming languages and computer programs that the code generation model(s) 118 can access, including those computer programs that are part of the domain-specific codebase. Readers will appreciate that the code generation model(s) 118 may generate code up to a specified length, until a specific stop token is reached, or in some other way.”)
validating the second [lambda] function based on the interaction. (Ostrovsky Column 14 Lines 20-29, “In some embodiments, the suggested code to insert into the computer program is generated further based on at least one additional knowledge augmentation techniques. The additional knowledge augmentation techniques may be embodied, for example, as one or more technologies, processes, tools, or so on that can be used to generate additional signals that may be leveraged in coordination with generative language models to improve the quality of output from the generative language models. For example, the generative language models (e.g., the code generation model(s) 118) may be augmented with dense retrieval, static analysis, memorizing transformers, or other technologies. “) [Examiner’s Note: Static Analysis can be used to determine the validity of a generated function]
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Ostrovsky into the teachings of Zhang in view of Carrara and further in view of Carter. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, in order to validate the updated replacement function in accordance with desired code features, as in Ostrovsky. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of using data sources with pieces of code that will be useful in retrieval models to generate program code (Ostrovsky Column 11 Lines 42-55).
With regards to claim 13, the rejection of claim 2 is incorporated.
The combination of Zhang, Carrara, and Carter does not teach: determining a first syntax in the first lambda function;
validating the second lambda function based on the second lambda function comprising the first syntax.
However, in an analogous art Ostrovsky teaches determining a first syntax in the first lambda function; (Ostrovsky Column 14 Lines 38-44, “These embeddings capture the semantic meaning of words and textual passages (e.g., a line of code, a function) and allow for efficient similarity calculations rather than relying exclusively on simpler techniques such as keyword matching. This means they can retrieve documents that are conceptually similar even if the keywords don't match exactly.”) [Examiner’s Note: using keywords/embeddings to determine matching similarities can help determine syntax similarities between first and second functions in any kind of language/file.] and
validating the second lambda function based on the second lambda function comprising the first syntax. (Ostrovsky Column 19 Lines 33-62, “In some embodiments, generative AI systems may be enhanced through retrieval augmentation that allows for efficient retrieval and filtering of relevant pieces of code that may ultimately be presented to a user for inclusion in some code that the user is developing, or otherwise included in some code that is being generated. In some embodiments, separate models may be trained to do the retrieval. These models may be used, for example, to look at a piece of code (i.e., code that is being written by a developer), compare it to some other code/search the knowledge base for the most relevant piece of code, and then present that relevant piece of code to the developer. To train these retrieval models, the models may need to be provided with many examples of code that is related so as to enable the model to identify related code. To generate a signal that relates two pieces of code, some embodiments may examine existing code repositories and look at each change that is made in the code repository and identify situations in which changing a first piece of code was followed by a second piece of code being changed, as this may be indicative of the first piece of code and the second piece of code being related.”) [Examiner’s Note: Embeddings in a codebase can determine software semantics/syntax. The retrieval models will use the information to compare and find a second piece of code related to the semantics/syntax of the first piece of code.]
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Ostrovsky into the teachings of Zhang in view of Carrara, and further in view of Carter. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, in order to validate the updated replacement function in accordance with desired code features, as in Ostrovsky. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of using data sources with pieces of code that will be useful in retrieval models to generate program code (Ostrovsky Column 11 Lines 42-55).
Claim(s) 14 is rejected under 35 U.S.C. 103 as being unpatentable over Zhang in view of Carrara in view of Carter as applied to claim 2 above, and further in view of US 12340194 B1 hereinafter “Silver”
With regards to claim 14, the rejection of claim 2 is incorporated.
Zhang, Carrara, and Carter teaches a lambda function but does not teach: retrieving an approved [lambda] function list;
and validating the second [lambda] function based on the approved [lambda] function list.
However, in an analogous art Silver teaches retrieving (Silver Column 16 Lines 5-15, “he system may route the validated request to the appropriate module or component responsible for handling model validation tasks. This module may be part of the software development environment and is designed to manage validation procedures for different models within projects. Upon receiving the validation request, the system may retrieve necessary data related to the first model from the project repository or database. This data may include model specifications, documentation, testing protocols, and/or other relevant information needed for validation.”) an approved [lambda] function list; (Silver Column 16 Lines 40-46, “The artificial intelligence model may be trained to validate code samples based on labeled source content and labeled code samples. The labeled source content may comprise rulesets for security vulnerabilities that are extracted and reformatted from a plurality of sources. The labeled code samples may comprise a first subset of labeled code samples successfully validated against the rulesets”) [Examiner’s Note: A request can send data from database which is used to retrieve an approved list or subset list of code samples/functions which can be used for further validation.]
and validating the second [lambda] function based on the approved [lambda] function list. (Silver Column 16 Lines 50-61, “The labeled code samples may comprise a first subset of labeled code samples successfully validated against the rulesets and a second subset of labeled code samples unsuccessfully validated against the rulesets. For example, the system may gather a diverse set of labeled source content containing rulesets for security vulnerabilities. These rulesets should cover a broad range of potential vulnerabilities. The system collects labeled code samples categorized into two subsets: code samples that successfully pass validation against the rulesets and code samples that fail validation against the rulesets due to security vulnerabilities (or other criteria). For example, the system may initiate the validation process for the first model based on predefined criteria or validation procedures, which may involve running tests, simulations, and/or comparisons against expected outcomes or benchmarks to verify the model's accuracy, performance, and/or compliance with specified requirements.”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Silver into the teachings of Zhang in view of Carrara, and further in view of Carter. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, with a list of previously validated functions to verify the updated replacement function, as in Silver. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of identifying, assessing, mitigating, and/or monitoring risks arising from model usage (Silver Column 4 Lines 37-48).
Claim(s) 16 is rejected under 35 U.S.C. 103 as being unpatentable over Zhang in view of Carrara in view of Carter as applied to claim 2 above, and further in view of Cox
With regards to claim 16, the rejection of claim 2 is incorporated.
Zhang does not teach: updating the training data with the first lambda function.
However, in an analogous art Carrara teaches updating the training data with the first lambda function (Carrara [0088], “The use of generative AI to assist a developer in developing control code 908 or other aspects of an industrial control project can abstract the developer from the details of the control programming language itself, facilitating a higher-level approach to code creation that allows the developer to express the functional requirements for an industrial control system in a natural, plain language manner, with the generative AI model 226—trained with industry-specific sets of training data an industrial knowledge—creating control code 908 that aligns with the requirements. This approach can also mitigate the need for developers to manually define detailed device configurations or specify data tags for the control code 908, instead allowing the generative AI model 226 to infer and set specific device or tag configurations based on inferences of the user's functional requirements and the industry-specific training of the model 226. By relying on the generative AI model 226 to generate some or all of the control code 908 or other aspects of a system project, the system 202 allows the developer to focus more exclusively on the desired functional and performance results of the control design—e.g., in terms of speed, cost, efficiency, etc.—and letting those results drive automated generation of suitable control code 908.”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Carrara into the teachings of Zhang. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of an AI based rules engine to generate recommendations designing control functions (Carrara [0082]).
The combination of Zhang, Carrara, and Carter does not teach: determining a first runtime efficiency for the first lambda function;
labeling the first lambda function with the first runtime efficiency;
However, Cox teaches determining a first runtime efficiency for the first lambda function;
labeling the first lambda function with the first runtime efficiency; (Cox [0028], “ According to another aspect of the present invention, a system is presented for providing elapsed time indications for source code in a development environment, comprising: a block defining component for defining blocks of source code to be timed during source code execution; a time monitoring component for monitoring defined blocks of source code during execution to determine an elapsed time for the execution of the defined block of source code; a time recording component for recording the elapsed time for a defined block of source code; and an annotating component for providing an elapsed time indication for the defined block of source code.”) [Examiner’s Note: A block of source code can be defined as a function. Cox teaches the method of observing a combination of source code blocks to determine runtime efficiency.]
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Cox into the teachings of Zhang in view of Carrara, and further in view of Carter. This combination of teachings would have resulted in a system to recommend an updated software architecture for the purpose of modernized and dynamically adjusted serverless functions, as in Zhang, and using artificial intelligence to dynamically generate replacement functions in accordance to system specifications, as in Carrara, and an observability platform providing an artificial intelligence model that generates serverless software as a lambda function, as in Carter, and execution of the code while monitoring runtime performance, as in Cox. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of defining blocks of source code during execution to record elapsed time of the block (Cox [0019]).
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to TRAVIS VIET TRAN whose telephone number is (571)272-3720. The examiner can normally be reached Monday-Friday 8:30AM-5PM.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Wei Mui can be reached at 571-272-3708. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/T.V.T./ Examiner, Art Unit 2191
/WEI Y MUI/Supervisory Patent Examiner, Art Unit 2191
Prosecution Insights