DETAILED ACTION
Claims 1-20 are pending in the application.
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 .
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.
Examiner’s Notes
The Examiner cites particular sections in the references as applied to the claims below for the convenience of the applicant(s). 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(s) fully consider the references in their 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.
Claim Objections
Claims 11-20 are objected to because of the following informalities:
Claim 11: “the steps” (lines 3-4) should have been –steps—.
Claims 12-19 inherit the features of claim 11 and are objected to accordingly.
Claim 20: “the steps” (line 4) should have been –steps—.
Appropriate corrections are required. Applicant is advised to review the entire claims for further needed corrections.
Claim Rejections - 35 USC § 112(b)
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.
Claims 13-16 and 19 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.
Claims 13-16 and 19 recite “The one or more non-transitory computer-readable media of claim 11, further comprising the steps of”. However, it is not clear how the claimed “computer-readable media” comprises steps. That is, it is not clear if these claims are referring to the media comprising further instructions or if these claims are referring to a method.
For the following analysis, the Examiner will consider the limitation “The one or more non-transitory computer-readable media of claim 11, further comprising the steps of” as referring to –The one or more non-transitory computer-readable media of claim 11, comprising further instructions that, when executed by the one or more processors, cause the one or more processors to perform steps of—.
Claim Rejections - 35 USC § 102
The following is a quotation of the appropriate paragraphs of 35 U.S.C. 102 that form the basis for the rejections under this section made in this Office action:
A person shall be entitled to a patent unless –
(a)(1) the claimed invention was patented, described in a printed publication, or in public use, on sale, or otherwise available to the public before the effective filing date of the claimed invention.
Claims 1-20 are rejected under 35 U.S.C. 102(a)(1) as being anticipated by Hussels et al. (US 2020/0104198 A1; from IDS filed on 04/19/2026; hereinafter “Hussels”).
With respect to claim 1, Hussels teaches: A computer-implemented method for executing application code across different execution environments (see e.g. paragraph 15: “retrieve a set of calls to invoke code on an on-demand code execution system (e.g., to process a data item included or referenced in the call), and to pass each call to the on-demand code execution system… on-demand code execution system can route calls from the poller device to any suitable environment”), the method comprising:
causing a first function container (see e.g. paragraph 21: “isolated containers that are created on the virtual machine instances”) to execute a first function (see e.g. paragraph 18: “define a “task,” and implement specific functionality corresponding to that task when executed on a virtual machine instance of the on-demand code execution system. Individual implementations of the task on the on-demand code execution system may be referred to as an “execution” of the task (or a “task execution”)”; and paragraph 21: “execution of tasks on the on-demand code execution environment… program codes can be executed in isolated containers that are created on the virtual machine instances”) based on a first portion of the application code (see e.g. paragraph 18: “submit or designate computer-executable code to be executed by virtual machine instances on the on-demand code execution system. Each set of code on the on-demand code execution system may define a “task,” and implement specific functionality corresponding to that task when executed on a virtual machine instance”; and paragraph 21: “When the on-demand code execution environment receives a request to execute the program code of a user (a “task”), which specifies one or more computing constraints for executing the program code of the user, the on-demand code execution environment may select a virtual machine instance for executing the program code of the user based on the one or more computing constraints specified by the request and cause the program code of the user to be executed on the selected virtual machine instance. The program codes can be executed in isolated containers that are created on the virtual machine instances”) to generate first output data (see e.g. paragraph 38: “container in which the task is executed, and cause the output data to be provided back to the user”); and
causing a second function container (see e.g. paragraph 21: “isolated containers that are created on the virtual machine instances… executing the user code in one or more containers”) to execute a second function (see e.g. paragraph 18: “define a “task,” and implement specific functionality corresponding to that task when executed on a virtual machine instance of the on-demand code execution system. Individual implementations of the task on the on-demand code execution system may be referred to as an “execution” of the task (or a “task execution”)”; and paragraph 21: “execution of tasks on the on-demand code execution environment… program codes can be executed in isolated containers that are created on the virtual machine instances”) based on a second portion of the application code (see e.g. paragraph 18: “submit or designate computer-executable code to be executed by virtual machine instances on the on-demand code execution system. Each set of code on the on-demand code execution system may define a “task,” and implement specific functionality corresponding to that task when executed on a virtual machine instance”; and paragraph 21: “When the on-demand code execution environment receives a request to execute the program code of a user (a “task”), which specifies one or more computing constraints for executing the program code of the user, the on-demand code execution environment may select a virtual machine instance for executing the program code of the user based on the one or more computing constraints specified by the request and cause the program code of the user to be executed on the selected virtual machine instance. The program codes can be executed in isolated containers that are created on the virtual machine instances”) to generate second output data (see e.g. paragraph 38: “container in which the task is executed, and cause the output data to be provided back to the user”),
wherein the first function executes within a first execution environment (see e.g. paragraph 21: “virtual machine instances”) associated with the first container (see e.g. paragraph 21: “program codes can be executed in isolated containers that are created on the virtual machine instances”; and paragraph 22: “virtual machine instance manager receives user-initiated requests to execute code, and identifies a pre-configured virtual machine instance to execute the code based on configuration information associated with the request. The virtual machine instance manager can further allocate the identified virtual machine instance to execute the user's code at least partly by creating and configuring containers inside the allocated virtual machine instance”), and wherein the second function executes within a second execution environment (see e.g. paragraph 21: “virtual machine instances”) associated with the second container (see e.g. paragraph 21: “program codes can be executed in isolated containers that are created on the virtual machine instances”; and paragraph 22: “virtual machine instance manager receives user-initiated requests to execute code, and identifies a pre-configured virtual machine instance to execute the code based on configuration information associated with the request. The virtual machine instance manager can further allocate the identified virtual machine instance to execute the user's code at least partly by creating and configuring containers inside the allocated virtual machine instance”).
Hussels discloses a virtual machine instance manager that allocates multiple virtual machine instances (i.e. execution environments) to execute tasks (i.e. functions) within containers created on the virtual machine instances.
With respect to claim 2, Hussels teaches: The computer-implemented method of claim 1, wherein the first container is derived from a first base image corresponding to a first operating system (see e.g. paragraph 3: “virtual machine instance type configurations are often contained within a device image, which includes static data containing the software (e.g., the OS and applications together with their configuration and data files, etc.)”; paragraph 21: “each virtual machine instance has one or more software components (e.g., operating systems … the virtual machine instances in the pool have already been booted and loaded with particular operating systems”; and Fig. 1: “OS 152A”), and the second container is derived from a second base image corresponding to a second operating system (see e.g. paragraph 3: “virtual machine instance type configurations are often contained within a device image, which includes static data containing the software (e.g., the OS and applications together with their configuration and data files, etc.)”; paragraph 21: “each virtual machine instance has one or more software components (e.g., operating systems … the virtual machine instances in the pool have already been booted and loaded with particular operating systems”; and Fig. 1: “OS 152B”).
With respect to claim 3, Hussels teaches: The computer-implemented method of claim 1, further comprising generating a multi-container computing environment that includes the first function container and the second function container (see e.g. paragraph 21: “isolated containers that are created on the virtual machine instances… executing the user code in one or more containers created on the virtual machine instances”; and Fig. 1), wherein the multi-container computing environment is coupled to a shared storage (see e.g. paragraph 15: “save the state information to a resilient storage system (e.g., a network storage location with built-in redundancy)”; paragraph 20: “enable state information to be efficiently maintained between code executions on on-demand code execution systems”; and paragraph 49: “state information, maintained across individual executions of a task”), and wherein the first function container and the second function container communicate with one another via the shared storage (see e.g. paragraph 20: “enable state information to be efficiently maintained between code executions on on-demand code execution systems”; paragraph 21: “program codes can be executed in isolated containers that are created on the virtual machine instances”; paragraph 49: “state information, maintained across individual executions of a task”; and paragraph 70: “The result of the task execution, as returned at (8), can include new state information, as updated to reflect the task execution. At (9), the poller device 132 updates its current state information with the new state information (e.g., by replacing it's own state information with the new state information), which updated state information can then be passed in a next call”).
With respect to claim 4, Hussels teaches: The computer-implemented method of claim 1, further comprising:
executing the first portion of the application code to push a first message onto a queue (see e.g. paragraph 15: “calls can be illustratively maintained as a queue, such as a message queue on a stream data processing system… retrieve an initial batch of calls from the queue, and iteratively submit each call to the on-demand code execution”), wherein the first message corresponds to a first processing task performed during execution of the first function (see e.g. paragraph 18: “define a “task,” and implement specific functionality corresponding to that task when executed on a virtual machine instance of the on-demand code execution system. Individual implementations of the task on the on-demand code execution system may be referred to as an “execution” of the task (or a “task execution”)”); and
executing the second portion of the application code to push a second message onto the queue (see e.g. paragraph 15: “calls can be illustratively maintained as a queue, such as a message queue on a stream data processing system… retrieve an initial batch of calls from the queue, and iteratively submit each call to the on-demand code execution”), wherein the second message corresponds to a second processing task performed during execution of the second function (see e.g. paragraph 18: “define a “task,” and implement specific functionality corresponding to that task when executed on a virtual machine instance of the on-demand code execution system. Individual implementations of the task on the on-demand code execution system may be referred to as an “execution” of the task (or a “task execution”)”).
With respect to claim 5, Hussels teaches: The computer-implemented method of claim 1, further comprising:
polling a queue to obtain a first message corresponding to a first processing task (see e.g. paragraph 15: “a poller device, which operates to retrieve a set of calls to invoke code on an on-demand code execution system (e.g., to process a data item included or referenced in the call), and to pass each call to the on-demand code execution system. The set of calls can be illustratively maintained as a queue, such as a message queue on a stream data processing system. Illustratively, a poller device… retrieve an initial batch of calls from the queue, and iteratively submit each call to the on-demand code execution system”);
configuring the first container to execute the first function based on the first message to perform the first processing task (see e.g. paragraph 15: “on-demand code execution system can route calls from the poller device to any suitable environment”; paragraph 21: “execution of tasks on the on-demand code execution environment… program codes can be executed in isolated containers that are created on the virtual machine instances”; and paragraph 18);
polling the queue to obtain a second message corresponding to a second processing task (see e.g. paragraph 15: “a poller device, which operates to retrieve a set of calls to invoke code on an on-demand code execution system (e.g., to process a data item included or referenced in the call), and to pass each call to the on-demand code execution system. The set of calls can be illustratively maintained as a queue, such as a message queue on a stream data processing system. Illustratively, a poller device… retrieve an initial batch of calls from the queue, and iteratively submit each call to the on-demand code execution system”); and
configuring the second container to execute the second function based on the second message to perform the second processing task (see e.g. paragraph 15: “on-demand code execution system can route calls from the poller device to any suitable environment”; paragraph 21: “execution of tasks on the on-demand code execution environment… program codes can be executed in isolated containers that are created on the virtual machine instances”; and paragraph 18).
With respect to claim 6, Hussels teaches: The computer-implemented method of claim 1, further comprising launching an agent container (see e.g. Fig. 1: “Worker Manager(s) 140”) within a multi-container computing environment that includes the first function container and the second function container (see e.g. paragraph 46: “The on-demand code execution system 110 further includes one or more worker managers 140 that manage the execution environments, such as virtual machine instances 150… each worker manager 140 manages an active pool 140A, which is a group (sometimes referred to as a pool) of virtual machine instances 150 executing on one or more physical host computing devices that are initialized to execute a given task”), wherein the agent container causes the first function container to execute the first function and causes the second function container to execute the second function (see e.g. paragraph 46: “each worker manager 140 manages an active pool 140A, which is a group (sometimes referred to as a pool) of virtual machine instances 150 executing on one or more physical host computing devices that are initialized to execute a given task”; and paragraph 49: “worker manager 140 may modify a virtual machine instance 150 (if necessary) and execute the code of the task within the instance 150”).
With respect to claim 7, Hussels teaches: The computer-implemented method of claim 1, wherein the first function comprises a first media processing operation that generates a first portion of media data (see e.g. paragraph 38: “on-demand code execution system 110 may modify the behavior (e.g., logging facilities) of the container in which the task is executed, and cause the output data to be provided back to the user”; paragraph 44: “the output interface may transmit data regarding task executions (e.g., results of a task, errors related to the task execution, or details of the task execution, such as total time required to complete the execution, total data processed via the execution, etc.) to the user computing devices 102”; and paragraph 55: “provide output information for an optional display (not shown) via the input/output device interface 196”; note that, displaying task results as output information inherently discloses displaying visual media corresponding to the output), and wherein the second function comprises a second media processing operation that generates a second portion of media data (see e.g. paragraph 38: “on-demand code execution system 110 may modify the behavior (e.g., logging facilities) of the container in which the task is executed, and cause the output data to be provided back to the user”; paragraph 44: “the output interface may transmit data regarding task executions (e.g., results of a task, errors related to the task execution, or details of the task execution, such as total time required to complete the execution, total data processed via the execution, etc.) to the user computing devices 102”; and paragraph 55: “provide output information for an optional display (not shown) via the input/output device interface 196”; note that, displaying task results as output information inherently discloses displaying visual media corresponding to the output).
With respect to claim 8, Hussels teaches: The computer-implemented method of claim 1, further comprising:
determining that execution of the first function is complete (see e.g. paragraph 44: “output interface may transmit data regarding task executions (e.g., results of a task, errors related to the task execution, or details of the task execution, such as total time required to complete the execution”);
causing the first function container to release one or more resources associated with the first function (see e.g. paragraph 32: “on-demand code execution system 110… a system of rapidly provisioned and released computing resources, often referred to as a “cloud computing environment.””; and Fig. 6, step 618);
determining that execution of the second function is complete (see e.g. paragraph 44: “output interface may transmit data regarding task executions (e.g., results of a task, errors related to the task execution, or details of the task execution, such as total time required to complete the execution”); and
causing the second function container to release one or more resources associated with the second function (see e.g. paragraph 32: “on-demand code execution system 110… a system of rapidly provisioned and released computing resources, often referred to as a “cloud computing environment.””; and Fig. 6, step 618).
With respect to claim 9, Hussels teaches: The computer-implemented method of claim 1, further comprising:
determining that execution of the first function is complete (see e.g. paragraph 44: “output interface may transmit data regarding task executions (e.g., results of a task, errors related to the task execution, or details of the task execution, such as total time required to complete the execution”);
copying the first output data to a shared storage (see e.g. paragraph 16: “mechanism for retaining state information between processing of calls is to configure each execution environment, during processing of a call, to write its state information to a persistent external location, such as network data storage”; paragraph 20: “enable state information to be efficiently maintained between code executions on on-demand code execution systems”; and paragraph 49: “state information, maintained across individual executions of a task”);
determining that execution of the second function is complete (see e.g. paragraph 44: “output interface may transmit data regarding task executions (e.g., results of a task, errors related to the task execution, or details of the task execution, such as total time required to complete the execution”); and
copying the second output data to the shared storage (see e.g. paragraph 16: “mechanism for retaining state information between processing of calls is to configure each execution environment, during processing of a call, to write its state information to a persistent external location, such as network data storage” )”; paragraph 20: “enable state information to be efficiently maintained between code executions on on-demand code execution systems”; and paragraph 49: “state information, maintained across individual executions of a task”), wherein the first function container and the second function container are coupled to the shared storage (see e.g. paragraph 20: “enable state information to be efficiently maintained between code executions on on-demand code execution systems”; paragraph 21: “program codes can be executed in isolated containers that are created on the virtual machine instances”; paragraph 49: “state information, maintained across individual executions of a task”; and paragraph 70: “The result of the task execution, as returned at (8), can include new state information, as updated to reflect the task execution. At (9), the poller device 132 updates its current state information with the new state information (e.g., by replacing it's own state information with the new state information), which updated state information can then be passed in a next call”).
With respect to claim 10, Hussels teaches: The computer-implemented method of claim 1, wherein the first execution environment and the second execution environment are derived from different operating systems (see e.g. paragraph 21: “each virtual machine instance has one or more software components (e.g., operating systems … the virtual machine instances in the pool have already been booted and loaded with particular operating systems”; and Fig. 1: “OS 152A”, “OS 152B”).
With respect to claims 11-17: Claims 11-17 are directed to one or more non-transitory computer-readable media including instructions that, when executed by one or more processors, cause the one or more processors to implement active functions corresponding to the method disclosed in claims 1, 10, and 3-7, respectively; please see the rejections directed to claims 1, 10, and 3-7 above which cover the limitations recited in claims 11-17. Note that, Hussels also discloses non-transitory computer readable media containing computer program instructions to implement the method disclosed in claims 1, 3-7, and 10 (see e.g. paragraph 56).
With respect to claim 18, Hussels teaches: The one or more non-transitory computer-readable media of claim 11, wherein the first container is configured to execute a first library that is compatible with a first operating system (see e.g. paragraph 3: “virtual machine instance type configurations are often contained within a device image, which includes static data containing the software (e.g., the OS and applications together with their configuration and data files, etc.)”; paragraph 21: “each virtual machine instance has one or more software components (e.g., operating systems, language runtimes, libraries, etc.) loaded thereon… the virtual machine instances in the pool have already been booted and loaded with particular operating systems”; and Fig. 1: “OS 152A”), and the second container is configured to execute a second library that is compatible with a second operating system ((see e.g. paragraph 3: “virtual machine instance type configurations are often contained within a device image, which includes static data containing the software (e.g., the OS and applications together with their configuration and data files, etc.)”; paragraph 21: “each virtual machine instance has one or more software components (e.g., operating systems, language runtimes, libraries, etc.) loaded thereon… the virtual machine instances in the pool have already been booted and loaded with particular operating systems”; and Fig. 1: “OS 152B”).
With respect to claim 19, Hussels teaches: The one or more non-transitory computer-readable media of claim 11, further comprising the steps of:
executing the first portion of the application code to trigger a rule-based workflow (see e.g. paragraph 18: “on-demand code execution system can further enable users to trigger execution of a task based on a variety of potential events, such as detecting new data at a network-based storage system, transmission of an application programming interface (“API”) call to the on-demand code execution system, or transmission of a specially formatted hypertext transport protocol (“HTTP”) packet to the on-demand code execution system”) that populates a queue with a first message corresponding to the first function (see e.g. paragraph 15: “calls can be illustratively maintained as a queue, such as a message queue on a stream data processing system… retrieve an initial batch of calls from the queue, and iteratively submit each call to the on-demand code execution”; and paragraph 18); and
executing the second portion of the application code to issue an application programming interface (API) call (see e.g. paragraph 18: “on-demand code execution system can further enable users to trigger execution of a task based on a variety of potential events, such as… transmission of an application programming interface (“API”) call to the on-demand code execution system”) that populates the queue with a second message corresponding to the second function (see e.g. paragraph 15: “calls can be illustratively maintained as a queue, such as a message queue on a stream data processing system… retrieve an initial batch of calls from the queue, and iteratively submit each call to the on-demand code execution”; and paragraph 18).
With respect to claim 20: Claim 20 is directed to a system comprising one or more memories storing instructions and one or more processors coupled to the one or more memories that, when executing the instructions, perform active functions corresponding to the method disclosed in claim 1; please see the rejection directed to claim 1 above which also covers the limitations recited in claim 20. Note that, Hussels also discloses a computing system comprising memory 180 with instructions and a processing unit 190 to implement the method disclosed in claim 1 (see e.g. paragraphs 55-60; Fig. 2).
CONCLUSION
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure:
Nelson et al. (US 2014/0137104 A1) discloses an application resource scheduler that provides task container VMs to a distributed computing application for processing the application’s tasks (see paragraph 39).
Qureshi et al. (US 10,007,509 B1) discloses containers that execute various tasks wherein each container contains a container agent configured to perform various tasks with containers and applications included in the container (see column 3, lines 13-33).
Contact Information
Any inquiry concerning this communication or earlier communications from the examiner should be directed to Umut Onat whose telephone number is (571)270-1735. The examiner can normally be reached M-Th 9:00-7:30.
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, Kevin L Young can be reached at (571) 270-3180. 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.
/UMUT ONAT/Primary Examiner, Art Unit 2194
