DETAILED ACTION
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Claims 1-20 are pending in this office action.
Claim Objections
Claim 5 is objected to because of the following informalities: Claim 5 in line 3 recites the following: “..a CRUD record action..”.. the claim uses an abbreviation /acronym that is not defined what is directed to. The examiner interprets it as: The acronym CRUD stands for Create, Read, Update, and Delete . Appropriate correction is required.
Claim Rejections - 35 USC § 101
35 U.S.C. 101 reads as follows:
Whoever invents or discovers any new and useful process, machine, manufacture, or composition of matter, or any new and useful improvement thereof, may obtain a patent therefor, subject to the conditions and requirements of this title.
Claims 1-8 and 11-19 are rejected under 35 U.S.C. 101 because the claimed invention is directed to a judicial exception (i.e., a law of nature, a natural phenomenon, or an abstract idea) without significantly more.
the claimed invention is directed to an abstract Idea without significantly more.
Claims 1 and 19 recite:
“…and generate the object by performing an action.….”; OR “..and generating the object by performing one or both of: (i) generating a new object; and (ii) modifying an existing object.”;
“..perform validation and/or update actions to the seed data” OR “performing validation and/or update actions to the seed data”;
that are certainly a mental process that a person can carry out mentally through observation, evaluation, judgment and/or opinion, or even with the aid of pen and paper.
Claims 1 and 19 additionally recite:
“…a processing unit comprising one or more processors; and one or more data stores comprising machine-readable instructions,…”.
“…receive a request to initiate an object templating subroutine; in response to the request to initiate the object templating subroutine, obtain a seed file, the seed file containing seed data relating to an object to be generated”;
The additional elements “…a processing unit comprising one or more processors; and one or more data stores comprising machine-readable instructions…” are directed to generic computer components which are recited at a high level of generality, but to nothing more than an instruction implement “to apply” the abstract idea using a generic computer. See MPEP 2106.05(f).
The additional elements “…receive a request to initiate an object templating subroutine; in response to the request to initiate the object templating subroutine, obtain a seed file, the seed file containing seed data relating to an object to be generated …” are directed to storing, retrieving and manipulating a described data, that is mere data gathering/storing and does nothing more than adding insignificant extra solution activity to the judicial exception, that is a mere data gathering. See MPEP 2106.05(g).
Claims 1 and 19 additional elements do not add meaningful limits to practicing the abstract idea, but to nothing more than an instruction to apply the abstract idea using a generic computer. Thus, the additional elements fail to integrate the judicial exception into a practical application.
Claims 1and 19 does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with regard to integration of the abstract idea into a practical application, the additional elements “…a processing unit comprising one or more processors; and one or more data stores comprising machine-readable instructions…” are generic computer component used as a tool to perform the abstract idea.
With regard to the additional element “…receive a request to initiate an object templating subroutine; in response to the request to initiate the object templating subroutine, obtain a seed file, the seed file containing seed data relating to an object to be generated …” the court have found and identified retrieving/storing/manipulating information as well understood, routine conventional activity in the art. See MPEP 2106.05(d).
Accordingly, the additional elements do not provide an inventive concept, thus claims 1and 19 are not patent eligible.
-Dependents claims 2-8, and 11-18:
A- Claim 2“..wherein the generated object is a logical unit in a low-code or no-code software development platform..”
Claim 5”.. wherein the plurality of object templates include one or combinations of:..”
Claim 6”.. wherein the seed file contains metadata that is configured to be used by the object generation subroutine after the seed data has been validated and/or updated…”
Claim 7”… wherein the seed file contains metadata that is populated with data provided by the user and/or populated with data associated with the user stored in one or more data stores..”
Claim 13”.. wherein the object is at least one of..”
Claim 14”.. wherein each composite object is a combination of at least two objects…”
Claim 16”..” wherein the seed file includes least two metadata sections including..”
Claim 17”.. wherein the seed data includes groups of metadata..”
Claim 18”.. wherein each group includes a trigger subsection and an object metadata subsection..”
That are data description or specification, and as discussed above fails to integrate the judicial exception into a practical application nor sufficient to amount to significantly more than the judicial exception
B- Claim 3“..wherein the generated object is configured to be displayed in a graphical model displaying a plurality of software objects in a software architecture…”;
That is data output and as discussed above fails to integrate the judicial exception into a practical application nor sufficient to amount to significantly more than the judicial exception
C- 4“…select the seed file from a plurality of object templates stored in the one or more data stores…”
8“…wherein the validation and/or update actions comprise determining whether to generate the new object and/or whether to modify or reference/use the existing object…”
11 “..wherein validating and/or updating the seed file is performed, at least in part, based on design rules established by the system and configured to enforce best design practices…”
12”.. wherein validating and/or updating the seed file is performed, at least in part, based on user inputs received via a graphical user interface…”
15 “..wherein, to perform the validation and/or update actions, the system is configured to..”
That are a mental process.
Dependent claims 2-8, and 11-18 recite limitations that further describe or define the data in the mental process and further fail to integrate the judicial exception into a practical application nor sufficient to amount to significantly more than the judicial exception. Dependents claims 2-8, and 11-18 are not patent eligible.
Claim Interpretation
The following is a quotation of 35 U.S.C. 112(f):
(f) Element in Claim for a Combination. – An element in a claim for a combination may be expressed as a means or step for performing a specified function without the recital of structure, material, or acts in support thereof, and such claim shall be construed to cover the corresponding structure, material, or acts described in the specification and equivalents thereof.
The following is a quotation of pre-AIA 35 U.S.C. 112, sixth paragraph:
An element in a claim for a combination may be expressed as a means or step for performing a specified function without the recital of structure, material, or acts in support thereof, and such claim shall be construed to cover the corresponding structure, material, or acts described in the specification and equivalents thereof.
The claims in this application are given their broadest reasonable interpretation using the plain meaning of the claim language in light of the specification as it would be understood by one of ordinary skill in the art. The broadest reasonable interpretation of a claim element (also commonly referred to as a claim limitation) is limited by the description in the specification when 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph, is invoked.
As explained in MPEP § 2181, subsection I, claim limitations that meet the following three-prong test will be interpreted under 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph:
(A) the claim limitation uses the term “means” or “step” or a term used as a substitute for “means” that is a generic placeholder (also called a nonce term or a non-structural term having no specific structural meaning) for performing the claimed function;
(B) the term “means” or “step” or the generic placeholder is modified by functional language, typically, but not always linked by the transition word “for” (e.g., “means for”) or another linking word or phrase, such as “configured to” or “so that”; and
(C) the term “means” or “step” or the generic placeholder is not modified by sufficient structure, material, or acts for performing the claimed function.
Use of the word “means” (or “step”) in a claim with functional language creates a rebuttable presumption that the claim limitation is to be treated in accordance with 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph. The presumption that the claim limitation is interpreted under 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph, is rebutted when the claim limitation recites sufficient structure, material, or acts to entirely perform the recited function.
Absence of the word “means” (or “step”) in a claim creates a rebuttable presumption that the claim limitation is not to be treated in accordance with 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph. The presumption that the claim limitation is not interpreted under 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph, is rebutted when the claim limitation recites function without reciting sufficient structure, material or acts to entirely perform the recited function.
Claim limitations in this application that use the word “means” (or “step”) are being interpreted under 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph, except as otherwise indicated in an Office action. Conversely, claim limitations in this application that do not use the word “means” (or “step”) are not being interpreted under 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph, except as otherwise indicated in an Office action.
This application includes one or more claim limitations that do not use the word “means,” but are nonetheless being interpreted under 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph, because the claim limitation(s) uses a generic placeholder that is coupled with functional language without reciting sufficient structure to perform the recited function and the generic placeholder is not preceded by a structural modifier. Such claim limitation(s) is/are:
Claims
Place Holders
Functions
20
one or more client devices Client device
receive
20
Frontend system
manage
20
System
Provide ; receive; obtain, perform validation, generate and deploy
20
Backend system
Manage, generate
Because this/these claim limitation(s) is/are being interpreted under 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph, it/they is/are being interpreted to cover the corresponding structure described in the specification as performing the claimed function, and equivalents thereof.
If applicant does not intend to have this/these limitation(s) interpreted under 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph, applicant may: (1) amend the claim limitation(s) to avoid it/them being interpreted under 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph (e.g., by reciting sufficient structure to perform the claimed function); or (2) present a sufficient showing that the claim limitation(s) recite(s) sufficient structure to perform the claimed function so as to avoid it/them being interpreted under 35 U.S.C. 112(f) or pre-AIA 35 U.S.C. 112, sixth paragraph.
Claim Rejections - 35 USC § 103
In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis (i.e., changing from AIA to pre-AIA ) for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status.
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claims 1-8 and 11-17 and 19 are rejected under 35 U.S.C. 103 as being unpatentable over Kaduwela et al US20200409666A1 in view of Moore et al 20110265061A1.
As per claim 1, Kaduwela discloses a system for partially-automated software development, the system comprising:
a processing unit comprising one or more processors; and one or more data stores comprising machine-readable instructions, wherein the system is configured to:
[0008]”An embodiment of the present invention provides a system for providing a multi-technology visual integrated data management and analytics development and deployment environment, the system comprising a processor communicatively coupled to a non-transitory memory, a display, and an input device, the non-transitory memory containing a program configured to call the processor to execute the steps of:”;
receive a request to initiate an object templating subroutine:
[0063] “The method 300 begins by initiating a request to generate code 302. For example, a user may provide a command using a client device 202 through the GUI to combine two data sets. The request is relayed to the backend services module 218, and the request is formatted”;
in response to the request to initiate the object templating subroutine, obtain a seed file,
[0070]” At step 348, the fulfiller 228a identifies parallel and dependent nodes and computes a node order sequence to be used in carrying out the request. At step 350, the fulfiller 228a invokes the necessary code generation template(s) for the target platform. Each template contains executable code that will run on the target platform as well as placeholders for dynamic values”;
perform validation and/or update actions to the seed data:
[0075]“The backend services module 218 validates the information contained in the request. For example, the backend services module 218 checks whether the user has sufficient access to have the request processed; if the user does not, a suitable notification is returned to the client device 202 and the method does not proceed until an authorized user initiates a request (e.g., until the user provides acceptable credentials).
and generate the object by performing an action:
[0065]” The method proceeds to step 322, and the backend services module 218 returns the retrieved executable code as a response to the request, concluding the method at step 314 as the retrieved code is presented to the user via the client device 202.”;
[0072] “At step 324, The backend service module 218 updates the repository on the metadata server 110 to contain the newly generated code”;
But not explicitly:
the seed file containing seed data relating to an object to be generated;
Moore discloses:
the seed file containing seed data relating to an object to be generated;
[0045] “Further, each business rule 105 is generally associated with one or more code files 135 to be generated from one or more templates 115, i.e., as specified by business rules 105. Therefore, next, in step 320, computer 101 generally writes to the config file 110 location information, e.g., names and/or paths, e.g., locations in a directory, uniform resource locators, etc., of the one or more templates 115 specified by the current business rule 105. In addition, if the current business rule 105 specifies a value for any variables that may be included in a template 115, such values are also written to the config file 110”;
It would have obvious to one having ordinary skill in the art before the effective filling date of the claimed invention to combine the teachings of cited references. One of ordinary skill in the art before the effective filling date of the claimed invention would have been motivated to incorporate the teachings of Moore into teachings of Kaduwela to generate code from templates of a business rule. Furthermore, to perform validation of the source code generated either recently generated or pre-existing code. [Moore 0059].
As per claim 2, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses:
wherein the generated object is a logical unit in a low-code or no-code software development platform:
[0064] “If the user has sufficient access, the method proceeds to step 316 where the backend services module 218 checks whether the executable code necessary to perform the request already exists in the repository on the metadata server 110. For example, if the user has previously created a predefined job and has requested that the job be rerun on a new data set, the necessary code will have been previously generated and can be retrieved from the metadata server 110.”;
[0068] Once the request manager 222 is informed that a request should be processed, the method continues with step 330 whereby the request is sent to a code generation handler 226, such as handler 226b”;
Examiner interpretation: in Fig. 3 step 316 the method checks for code if already exist( no code), if not the code is generated(low-code);
As per claim 3, the rejection of claim 2 is incorporated and furthermore Kaduwela discloses:
wherein the generated object is configured to be displayed in a graphical model displaying a plurality of software objects in a software architecture:
[0072]“At step 322, the backend service module 218 sends the code to the client device 202 via the UI services module 214 and the UI application 216, where it is displayed to the user and the method completes.”;
As per claim 4, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses:
wherein, to obtain the seed file, the system is configured to: select the seed file from a plurality of object templates stored in the one or more data stores:
[0043] “This is accomplished by using pre-created templates that are included with the system to automatically migrate the workflow to the new software platform by generating the necessary executable code to run the workflow on the new platform.”;
[0071]”The nodes for reading and writing files are also connected to nodes for the data objects to be read and written to, respectively. In this example, the fulfiller 228a accesses the following templates in order: delimitedfilereader; tablereader; append; and delimitedfilewriter. These templates are created in advance and each corresponds to an operation that may be performed using the target platform.”;
As per claim 5, the rejection of claim 4 is incorporated and furthermore Kaduwela discloses:
wherein the plurality of object templates include one or combinations of: (1) a default application, (2) a create record action, (3) an update record action, (4) a delete record action, (5) a CRUD record action, (6) an event record action, (7) a view record data action, (8) data sync action, (9) a data manipulation function, and/or (10) a data structure action:
[0042] “The system is configured to perform several discrete tasks, including generating code to be processed by a particular software platform (also referred to herein as a “technology” or “mode”); executing code using a remote compute server (i.e., which will run the code using a particular software platform); and migrating code created to be processed using one software platform to another software platform. Using these tasks, users are able to create rule sets and check lists for performing data analysis and verification. Each of these functions is discussed separately herein.”;
As per claim 6, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses:
wherein the seed file contains metadata that is configured to be used by the object generation subroutine after the seed data has been validated and/or updated:
[0084] The method 500 begins at step 502 by initiating a request to migrate code. The request is relayed from the client device 202 to the backend services module 218. The backend services module 218 validates the information contained in the request and formats the request correctly. In an embodiment, the request is formatting using JSON and contains the request details (i.e., the current target platform for which the existing code was prepared and the new target platform to which the code must be migrated), the requestor details, the job details, the node details, and existing metadata for both target platforms. Once the request is formatted, the backend services module 218 validates the information contained in the request.
As per claim 7, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses,:
wherein the seed file contains metadata that is populated with data provided by the user and/or populated with data associated with the user stored in one or more data stores:
[0099] “ At step 728, the backend services module 218 collects the details of the definition items used in the checks contained in the check list. At step 728, the backend services module 218 extracts the check details, including all of the associated conditions and actions for each check. At step 730, the backend services module 218 extracts the checks with validations or standarizations associated with them, and at step 732 it creates a code generation request containing all of the check details and passes the request to the code generation fulfiller 228a via a handler 226a.
As per claim 8, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses,:
wherein the validation and/or update actions comprise determining whether to generate the new object and/or whether to modify or reference/use the existing object:
[0064] If the user has sufficient access, the method proceeds to step 316 where the backend services module 218 checks whether the executable code necessary to perform the request already exists in the repository on the metadata server 110”;
[0066] In the event that either code is not available from the repository on the metadata server 110 or if the job has been updated since the code was generated, the method proceeds instead to step 320 whereat the request is sent to the request manager 222 for processing.
As per claim 11, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses:
wherein validating and/or updating the seed file is performed, at least in part, based on design rules established by the system and configured to enforce best design practices:
[0099] “ At step 728, the backend services module 218 extracts the check details, including all of the associated conditions and actions for each check. At step 730, the backend services module 218 extracts the checks with validations or standarizations associated with them, and at step 732 it creates a code generation request containing all of the check details and passes the request to the code generation fulfiller 228a via a handler 226a.”;
As per claim 12, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses:
wherein validating and/or updating the seed file is performed, at least in part, based on user inputs received via a graphical user interface:
[0098]”At step 722, the GUI presents the user with a transformations module 704 (through which the user manipulates the created check lists and ties them to particular data by formatting variables in the check lists based on the desired data).
As per claim 13, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses:
wherein the object is at least one of: a standardized object, an account-specific object, and/or a composite object:
[0105] As shown in FIG. 12, a user can provide data object authorization by selecting the authorization pane 1202, selecting an authorization scheme 1204 (i.e., S3 Credentials), and dragging a selected authorization scheme onto a designated data object node 1206 on the canvas 1208.
As per claim 14, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses:
wherein each composite object is a combination of at least two objects:
[0063]”The method 300 begins by initiating a request to generate code 302. For example, a user may provide a command using a client device 202 through the GUI to combine two data sets. The request is relayed to the backend services module 218, and the request is formatted.
As per claim 15, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses:
wherein, to perform the validation and/or update actions, the system is configured to: perform one or combinations of: (1) a name deconflict process, (2) a reusable object process; (3) an authorization process; and/or (4) a customization process:
[0075]“For example, the backend services module 218 checks whether the user has sufficient access to have the request processed; if the user does not, a suitable notification is returned to the client device 202 and the method does not proceed until an authorized user initiates a request (e.g., until the user provides acceptable credentials).’;
As per claim 16, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses:
wherein the seed file includes least two metadata sections including a first metadata section and a second metadata section, wherein the first metadata section includes identification or description data, and the second metadata section includes object metadata
[0090] “FIG. 6 illustrates the process flow of performing creating new business rules by a user. Business rules are logically defined rules that determine how data should be manipulated so as to perform a desired operation, such as performing data analytics. By design, business rules are created in a logical format that is platform agnostic, so as to permit the user to perform operations on any platform compatible with the system without having to write or understand the platform specific source code.”;
As per claim 17, the rejection of claim 16 is incorporated and furthermore Kaduwela discloses:
wherein the seed data includes groups of metadata, each group corresponds to a particular object type and contains metadata to generate or update at least one object:
[0091] “The method 600 begins at step 610 as the user interacts with a definitions/business rules module 602 via the client device 202. The definitions/business rules module 602 is a GUI that contains all of the tools a user requires to provide the needed input to create a new business rule. At step 610, the user defines logical definition items using the GUI. At step 612, the user employs the logical definition items to create logical business rules. At step 614, the user creates one or more rule sets, each comprising one or more business rules and, for rule sets containing at least two business rules, the order in which the business rules should be performed”;
As per claim 19, Kaduwela discloses a method for partially-automated software development, the computer-implemented method comprising:
receiving a request to initiate an object templating subroutine:
[0063] “The method 300 begins by initiating a request to generate code 302. For example, a user may provide a command using a client device 202 through the GUI to combine two data sets. The request is relayed to the backend services module 218, and the request is formatted”;
in response to the request to initiate the object templating subroutine, obtaining a seed file,
[0070]” At step 348, the fulfiller 228a identifies parallel and dependent nodes and computes a node order sequence to be used in carrying out the request. At step 350, the fulfiller 228a invokes the necessary code generation template(s) for the target platform. Each template contains executable code that will run on the target platform as well as placeholders for dynamic values”;
performing validation and/or update actions to the seed data:
[0075]“The backend services module 218 validates the information contained in the request. For example, the backend services module 218 checks whether the user has sufficient access to have the request processed; if the user does not, a suitable notification is returned to the client device 202 and the method does not proceed until an authorized user initiates a request (e.g., until the user provides acceptable credentials).
and generating the object by performing one or both of: (i) generating a new object; and (ii) modifying an existing object.:
[0065]” The method proceeds to step 322, and the backend services module 218 returns the retrieved executable code as a response to the request, concluding the method at step 314 as the retrieved code is presented to the user via the client device 202.”;
[0072] “At step 324, The backend service module 218 updates the repository on the metadata server 110 to contain the newly generated code”;
But not explicitly:
the seed file containing seed data relating to an object to be generated;
Moore discloses:
the seed file containing seed data relating to an object to be generated;
[0045] “Further, each business rule 105 is generally associated with one or more code files 135 to be generated from one or more templates 115, i.e., as specified by business rules 105. Therefore, next, in step 320, computer 101 generally writes to the config file 110 location information, e.g., names and/or paths, e.g., locations in a directory, uniform resource locators, etc., of the one or more templates 115 specified by the current business rule 105. In addition, if the current business rule 105 specifies a value for any variables that may be included in a template 115, such values are also written to the config file 110”;
It would have obvious to one having ordinary skill in the art before the effective filling date of the claimed invention to combine the teachings of cited references. One of ordinary skill in the art before the effective filling date of the claimed invention would have been motivated to incorporate the teachings of Moore into teachings of Kaduwela to generate code from templates of a business rule. Furthermore, to perform validation of the source code generated either recently generated or pre-existing code. [Moore 0059].
Claims 9-10 and 20 are rejected under 35 U.S.C. 103 as being unpatentable over Kaduwela et al US20200409666A1 in view of Moore et al 20110265061A1 and Dinh et al US20210132935A1..
As per claim 9, the rejection of claim 1 is incorporated and furthermore Kaduwela discloses :
wherein generating the object outputs, a portable file
[0070]“At step 350, the fulfiller 228a invokes the necessary code generation template(s) for the target platform. Each template contains executable code that will run on the target platform as well as placeholders for dynamic values.”;
But not explicitly:
A file configured to be deployed in a plurality of operating environments:
Dinh discloses:
A file configured to be deployed in a plurality of operating environments:
[0062] “Once the microservice code has been validated by the validation engine 160, the code is provided to a deployment component 175 which configures the code for deployment and/or deploys the code on one or more cloud computing platforms, for example, as part of FaaS, CaaS and/or PaaS offerings”;
It would have obvious to one having ordinary skill in the art before the effective filling date of the claimed invention to combine the teachings of cited references. One of ordinary skill in the art before the effective filling date of the claimed invention would have been motivated to incorporate the teachings of Dinh into teachings of Kaduwela and Moore to design and develop applications for cloud-based microservices architectures, there is a need for techniques and systems which can efficiently modify existing code and/or generate new code so that the code is capable of being deployed on a microservices-based cloud platform [Dinh 0005].
As per claim 10, the rejection of claim 9 is incorporated and furthermore Kaduwela discloses:
wherein the system is further configured to transmit the portable file to a user environment
[0072]“At step 324, The backend service module 218 updates the repository on the metadata server 110 to contain the newly generated code. At step 322, the backend service module 218 sends the code to the client device 202 via the UI services module 214 and the UI application 216, where it is displayed to the user and the method completes.”;
But not explicitly:
the user environment being configured to use the portable file to deploy the new object and/or modified existing object;
Dinh discloses:
the user environment being configured to use the portable file to deploy the new object and/or modified existing object:
[0062] “Once the microservice code has been validated by the validation engine 160, the code is provided to a deployment component 175 which configures the code for deployment and/or deploys the code on one or more cloud computing platforms, for example, as part of FaaS, CaaS and/or PaaS offerings”;
It would have obvious to one having ordinary skill in the art before the effective filling date of the claimed invention to combine the teachings of cited references. One of ordinary skill in the art before the effective filling date of the claimed invention would have been motivated to incorporate the teachings of Dinh into teachings of Kaduwela and Moore to design and develop applications for cloud-based microservices architectures, there is a need for techniques and systems which can efficiently modify existing code and/or generate new code so that the code is capable of being deployed on a microservices-based cloud platform [Dinh 0005].
As per claim 20, Kaduwela discloses a system for partially-automated software development, the system comprising:
a client device associated with a user account and configured to receive user intentions via graphical user interfaces:
This element is interpreted under 35 U.S.C. 112(f) as the device 105 with structure of fig. 6(processor/memory)associated with a user account and configured to receive input/output through a GUI using steps [0104];
Kaduwela discloses a user device (processor and memory) with a GUI as in figure 1 where the GUI is displayed and provided to the user for input/output [0050].
Examiner interpretation:
[0010] receiving an instruction from said user of said system via said input device;
[0054] The authentication server 112 verifies the identity of users and confirms that users are authorized to perform various tasks, such as access the system or utilize particular client nodes 114a, 114b.
a frontend system configured to manage interactions with one or more client devices, the one or more client devices being configured to receive user intentions via one or more graphical user interfaces:
This element is interpreted under 35 U.S.C. 112(f) as the device 130 with structure of fig. 6(processor/memory)associated as a façade for interaction to the user interface of the client device [0029].
Kaduwela discloses a server (processor and memory) that communicates with a client device to dispay information in the GUI [0051].
Examiner interpretation:
[0009] rendering a graphical user interface and displaying said graphical user interface to a user of said system, said graphical user interface presenting said user with an option for generating code for a first software platform, said code configured to perform one or more data analytics operations when executed by said first software platform;
[0051] In the embodiment shown in FIG. 1, the GUI resides on the application server 108, which comprises a web server. The application server 108 transmits the GUI to the client device 118, which displays it to the user and obtains input from the user in response. The application server 108 is configured to interact directly with other components of the internal network 102 and indirectly with components of the client network 104 (i.e., via the engine 106)”;
and a backend system configured to manage a plurality of template recipes and generate software objects based on one or more of the plurality of template recipes:
This element is interpreted under 35 U.S.C. 112(f) as the device 140 with structure of fig. 6(processor/memory)associated as a façade for templates management[0007].
Kaduwela discloses a backend server (processor and memory) that communicates with a client device and manage: store and retrieve templates [0052].
Examiner interpretation:
[0041]”By interacting with the system at a logical level, and having the executable code for each separate platform created automatically by the system using predefined templates, the user does not need to be proficient in programming or using each separate platform.”
wherein the system is configured to:
provide, via the frontend system, the graphical user interfaces to the client device; receive, via the frontend system, the user intentions from the client device:
This element is interpreted under 35 U.S.C. 112(f) as the device with structure of fig. 6(processor/memory)associated as a façade for interacting with the user device through GUI [0007].
Kaduwela discloses system(processor and memory) that communicates with a client device and allow user to input request through such user interface[0022].
Examiner interpretation:
[0022] a client device comprising a display and an input device communicatively coupled to said application server, wherein said client device is configured to receive a graphical user interface from said application server, display said graphical user interface on said display, and relay input from said input device to said application server;
obtain, via the backend system, a seed file based on the user intentions,:
This element is interpreted under 35 U.S.C. 112(f) as the device with structure of fig. 6(processor/memory)associated as a façade for interacting to retrieve the seed file[0020].
Kaduwela discloses system(processor and memory) that communicates with a client device and allow user receive and interact with business rules definitions [0091].
Examiner interpretation:
[0070]” At step 348, the fulfiller 228a identifies parallel and dependent nodes and computes a node order sequence to be used in carrying out the request. At step 350, the fulfiller 228a invokes the necessary code generation template(s) for the target platform. Each template contains executable code that will run on the target platform as well as placeholders for dynamic values”;
using the frontend system, perform validation and/or update actions to the seed data based on (1) design rules and (2) user requests, via the graphical user interfaces:
This element is interpreted under 35 U.S.C. 112(f) as the device with structure of fig. 6(processor/memory)associated as a façade for interacting with the seed file[0022].
Kaduwela discloses system(processor and memory) that communicates with a client device and allow user receive and interact with business rules definitions [0091].
Examiner interpretation:
[0092] At step 616, the GUI presents the user with a transformations module 604 (through which the user manipulates the created rule sets and ties them to particular data by formatting variables in the rule sets based on the desired data). At step 618, the user maps variables in the rule set which correspond to various logical definitions to fields in the data to be processed. For example, the user may create a rule set for analyzing the rent charged at various properties. At step 618, the user will map the variable corresponding to the amount of rent charged to the particular column heading or field in the data which lists rent. This permits one logical rule set to be used to process data in a wide variety of formats without the need for the user to do more than map the necessary variables”;
in response to an instantiation condition being satisfied, generate, via the backend system and based on the validated and/or updated seed data, a second file configured to instantiate a run-time version of the object:
This element is interpreted under 35 U.S.C. 112(f) as the device with structure of fig. 6(processor/memory) r interacting with the seed file[0007].
Kaduwela discloses system(processor and memory) that communicates with a client device and allow user receive and interact with business rules definitions[0091].
[0075]“The backend services module 218 validates the information contained in the request. For example, the backend services module 218 checks whether the user has sufficient access to have the request processed; if the user does not, a suitable notification is returned to the client device 202 and the method does not proceed until an authorized user initiates” ;
[0070]”At step 348, the fulfiller 228a identifies parallel and dependent nodes and computes a node order sequence to be used in carrying out the request. At step 350, the fulfiller 228a invokes the necessary code generation template(s) for the target platform. Each template contains executable code that will run on the target platform as well as placeholders for dynamic values. At step 352, the fulfiller 228a identifies any placeholders for dynamic values that need to be updated, and at step 354 the placeholders are replaced with values based on the request to create fully executable code that will run on the target platform.
But not explicitly:
wherein the seed file contains seed data relating to an object to be generated;
deploy the run-time version of the object.
Moore discloses:
the seed file containing seed data relating to an object to be generated;
[0045] “Further, each business rule 105 is generally associated with one or more code files 135 to be generated from one or more templates 115, i.e., as specified by business rules 105. Therefore, next, in step 320, computer 101 generally writes to the config file 110 location information, e.g., names and/or paths, e.g., locations in a directory, uniform resource locators, etc., of the one or more templates 115 specified by the current business rule 105. In addition, if the current business rule 105 specifies a value for any variables that may be included in a template 115, such values are also written to the config file 110”;
It would have obvious to one having ordinary skill in the art before the effective filling date of the claimed invention to combine the teachings of cited references. One of ordinary skill in the art before the effective filling date of the claimed invention would have been motivated to incorporate the teachings of Moore into teachings of Kaduwela to generate code from templates of a business rule. Furthermore, to perform validation of the source code generated either recently generated or pre-existing code. [Moore 0059].
But not explicitly:
deploy the run-time version of the object.
Dinh discloses:
deploy the run-time version of the object.
This element is interpreted under 35 U.S.C. 112(f) as the device with structure of fig. 6(processor/memory) deploying the object[0031].
Dinh discloses system(processor and memory) that using a deployment component for deplying the code[0062].
Examiner interpretation
[0062] “Once the microservice code has been validated by the validation engine 160, the code is provided to a deployment component 175 which configures the code for deployment and/or deploys the code on one or more cloud computing platforms, for example, as part of FaaS, CaaS and/or PaaS offerings”;
It would have obvious to one having ordinary skill in the art before the effective filling date of the claimed invention to combine the teachings of cited references. One of ordinary skill in the art before the effective filling date of the claimed invention would have been motivated to incorporate the teachings of Dinh into teachings of Kaduwela and Moore to design and develop applications for cloud-based microservices architectures, there is a need for techniques and systems which can efficiently modify existing code and/or generate new code so that the code is capable of being deployed on a microservices-based cloud platform [Dinh 0005].
Claim 18 is rejected under 35 U.S.C. 103 as being unpatentable over Kaduwela et al US20200409666A1 in view of Moore et al US20110265061A1 and Agrawal et al US20060168557A1.
As per claim 18, the rejection of claim 17 is incorporated and furthermore Kaduwela does not explicitly disclose:
wherein each group includes a trigger subsection and an object metadata subsection, wherein the trigger subsection defines dependent object/field relationships.
Agrawal discloses:
wherein each group includes a trigger subsection and an object metadata subsection, wherein the trigger subsection defines dependent object/field relationship:
[0013]“displaying a graphical user interface corresponding to the template definition environment, wherein the graphical user interface comprises: template creation controls for creating templates; template dependency controls for creating dependency relationships among templates created using the template creation controls; and a display area for depicting icons corresponding to templates created using the template creation controls and relationships among the templates”;
[0044] “he template model includes template definitions, template type definitions, template attribute definitions, and relationships of dependency and generalization between templates. ;
It would have obvious to one having ordinary skill in the art before the effective filling date of the claimed invention to combine the teachings of cited references. One of ordinary skill in the art before the effective filling date of the claimed invention would have been motivated to incorporate the teachings of Agrawal into teachings of Kaduwela and Moore to define a template model that can be reused in more than one solution architecture. The created templates are used for developing solution architecture. The architecture definition environment allows developers to specify dependencies among architecture elements which greatly simplify software change management and adaptation [Agrawal 0024].
Pertinent arts:
US20120065810A1:
A template processing unit 1003 properly embeds various parameters set by the developer in the software by using a velocity compiler as an internal or external command.
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to BRAHIM BOURZIK whose telephone number is (571)270-7155. The examiner can normally be reached Monday-Friday (8-4: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, Wei Y Mui can be reached at 571-270-2738. 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.
/BRAHIM BOURZIK/ Examiner, Art Unit 2191
/WEI Y MUI/ Supervisory Patent Examiner, Art Unit 2191