DETAILED ACTION
This is the initial Office action based on the application submitted on March 22, 2024.
Claims 1-20 are 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 Rejections - 35 USC § 103
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claims 1-3, 8, 9, 11-13 and 18-20 are rejected under 35 U.S.C. 103 as being unpatentable over US 20200201625 (hereinafter “Kryzhanovsky”) in view of US 20190163610 (hereinafter “Vent”).
As per Claim 1, Kryzhanovsky discloses:
receiving, by a user interface layer in a client terminal, application code input by a user (Paragraph [0048], “The client device 110A may receive user input responsive to a user making changes 116A to(e.g., typing text in) copy 109A of the committed version 107 of source code 140 via the client device110A. Source control module 118A on the client device 110A may generate a record of changes 119A to store the changes 116A. The client device 110A may transmit the changes 116A to the cloud-based environment 101 to be transmitted to other client devices 110 for real-time collaborative editing of the source code 140 on the source control platform 120. User interfaces 200 of FIGS. 2A-D correspond to a user interface (e.g., user interface 124B) of a client device 110B responsive to client device 110A making changes 116A to the copy 109A to help describe features of the present disclosure [receiving, by a user interface layer in a client terminal, application code input by a user] (emphasis added).”;
processing the input application code by a client-as-a-service layer in the client terminal and forwarding the input application code to be stored in a cloud-based repository (Paragraph [0025], “In implementations, repository 114 may store a committed version 107 of source code 140 that may include content (e.g., functions, statements, text, etc.). In one implementation, the committed version 107 of source code 140 may be any suitable source code including content that is uploaded to the cloud-based environment 101 by the client devices 110A-110Z or from a server within or outside of the cloud-based environment [processing the input application code by a client-as-a-service layer in the client terminal and forwarding the input application code to be stored in a cloud-based repository] (emphasis added).”;
Kzhanovsky does not disclose:
synchronizing application code stored in a cache with application code stored in the cloud-based repository; and
performing a runtime remodel on a runtime system based on the input application code.
However, Vent discloses:
synchronizing application code stored in a cache with application code stored in the cloud-based repository; and (Paragraph [0014], “The IDE 44 is coupled to a source code repository (“repo”) 46 of the type known in the art, as adapted in accord with the teachings hereof, that stores current and, typically, prior versions of web application source code (emphasis added).”; Paragraph [0015], “The server 51 and/or repository 47 can include a web or other interface of the type known in the art, as adapted in accord with the teachings hereof, to facilitate synchronization of its master code base (including of source code 27 corresponding to local source code 25) with the local code base on workstation 14, and to facilitate developer 48 maintenance of the master code base [synchronizing application code stored in a cache with application code stored in the cloud-based repository; and] (emphasis added).”;
performing a runtime remodel on a runtime system based on the input application code (Paragraph [0016], “ Once uploaded, executables of the web application 24 source code or portions thereof (e.g., file 25, 27) can be linked or otherwise integrated into an existing web application code base, if any, on the web server 30 as part of a “build” for execution in environment 22, all in the conventional manner known in the art as adapted in accord with the teachings hereof. See also, FIG. 2, steps 104, 106 [performing a runtime remodel on a runtime system based on the input application code] (emphasis added).”.
Kryzhanovsky is within the same field of endeavor as the claimed invention regarding source code control systems and, in particular, collaborative editing of source code. Vent is within the same field of endeavor as the claimed invention regarding a server digital data processor includes an application server providing an execution environment in which a web application comprising a plurality of classes or functions (collectively, “classes”) executes. Thus, Kryzhanovsky and Vent are analogous art to the claimed invention.
Therefore, it would have been obvious to one of ordinary skill in the art before effective filing date of the claimed invention to incorporate the teaching of Vent into the teaching of Kryzhanovsky to include “synchronizing application code stored in a cache with application code stored in the cloud-based repository; and
performing a runtime remodel on a runtime system based on the input application code.” The modification would be obvious because one of the ordinary skills in the art would be motivated to facilitate testing of the application on its way from development to production (Vent, paragraph [0002]).
As per Claim 2, the rejection of Claim 1 is incorporated; and Kryzhanovsky further discloses:
wherein the client-as-a-service layer runs in a web browser application of the client terminal (Paragraph [0035], “As discussed above, the client devices 110A-110Z may each include a web browser or a native client application. A user that is invited and becomes a collaborator of the committed version 107 of source code 140 may request access to a corresponding copy 109 of the committed version 107 of source code 140 via the web browser or the native client application. For example, the user may select the committed version 107 of source code 140 from the user interface 124 provided by the cloud-based environment 101 and presented by the web browser or the native client application [wherein the client-as-a-service layer runs in a web browser application of the client terminal] (emphasis added).”.
As per Claim 3, the rejection of Claim 1 is incorporated; and Kryzhanovsky further discloses:
wherein the processing further comprises performing version control processing on the input application code (Paragraph [0037], “In some implementations, client devices 110A-110Z may wholly execute source control modules 118A-118Z for real-time collaborative editing of an electronic document, such as the committed version 107 of source code 140. It may be noted that source control modules 118A-118Z of client devices 110A-110Z may be the same or similar to source control module 132 of source control platform 120 [wherein the processing further comprises performing version control processing on the input application code] (emphasis added).”.
As per Claim 8, the rejection of Claim 1 is incorporated; and Kryzhanovsky further discloses:
in response to receiving the application code, retrieving previously stored application code from the cloud-based repository and […] by merging, migrating, or deduplicating existing objects in the previously stored application code, based on the received application code (Paragraph [0010], “In some systems, multiple developers can edit or modify source code independently. A developer may download a piece of source code and work on the piece of source code. Another developer can download the same piece of source code and work on the same piece of source code. Both developers may not have knowledge of the changes the other developer is making to the source code. When the developer attempts to merge changes to the source code with a production version of the source code, the changes may conflict with other changes to the source code that were previously merged with the production version of the source code by the other developer (emphasis added).”; Paragraph [0048], “The client device 110A may receive user input responsive to a user making changes 116A to(e.g., typing text in) copy 109A of the committed version 107 of source code 140 via the client device110A [in response to receiving the application code, retrieving previously stored application code from the cloud-based repository and […] by merging, migrating, or deduplicating existing objects in the previously stored application code, based on the received application code] (emphasis added).”.
Kryzhanovsky does not explicitly disclose:
[…] performing a runtime remodel function […]
However, Vent discloses:
[…] performing a runtime remodel function […] (Paragraph [0016], “ Once uploaded, executables of the web application 24 source code or portions thereof (e.g., file 25, 27) can be linked or otherwise integrated into an existing web application code base, if any, on the web server 30 as part of a “build” for execution in environment 22, all in the conventional manner known in the art as adapted in accord with the teachings hereof. See also, FIG. 2, steps 104, 106 [[…] performing a runtime remodel function […]] (emphasis added).”.
Vent is within the same field of endeavor as the claimed invention regarding a server digital data processor includes an application server providing an execution environment in which a web application comprising a plurality of classes or functions (collectively, “classes”) executes. Thus, Vent is an analogous art to the claimed invention.
Therefore, it would have been obvious to one of ordinary skill in the art before effective filing date of the claimed invention to incorporate the teaching of Vent into the teaching of Kryzhanovsky to include “[…] performing a runtime remodel function […]” The modification would be obvious because one of the ordinary skills in the art would be motivated to facilitate testing of the application on its way from development to production (Vent, paragraph [0002]).
As per Claim 9, the rejection of Claim 8 is incorporated; and Kryzhanovsky further discloses:
[…] in the client-as-a-service layer of the client terminal (Paragraph [0048], “The client device 110A may receive user input responsive to a user making changes 116A to(e.g., typing text in) copy 109A of the committed version 107 of source code 140 via the client device110A [[…] in the client-as-a-service layer of the client terminal] (emphasis added).”.
Kryzhanovsky does not explicitly disclose:
wherein the runtime remodel function is performed […]
However, Vent discloses:
wherein the runtime remodel function is performed […] (Paragraph [0016], “ Once uploaded, executables of the web application 24 source code or portions thereof (e.g., file 25, 27) can be linked or otherwise integrated into an existing web application code base, if any, on the web server 30 as part of a “build” for execution in environment 22, all in the conventional manner known in the art as adapted in accord with the teachings hereof. See also, FIG. 2, steps 104, 106 [wherein the runtime remodel function is performed […]] (emphasis added).”.
Vent is within the same field of endeavor as the claimed invention regarding a server digital data processor includes an application server providing an execution environment in which a web application comprising a plurality of classes or functions (collectively, “classes”) executes. Thus, Vent is an analogous art to the claimed invention.
Therefore, it would have been obvious to one of ordinary skill in the art before effective filing date of the claimed invention to incorporate the teaching of Vent into the teaching of Kryzhanovsky to include “wherein the runtime remodel function is performed […]” The modification would be obvious because one of the ordinary skills in the art would be motivated to facilitate testing of the application on its way from development to production (Vent, paragraph [0002]).
Claims 11-13, 18 and 19 are apparatus claims corresponding to the method claims hereinabove (Claims 1-3, 8 and 9, respectively). Therefore, Claims 11-13, 18 and 19 are rejected for the same reasons set forth in the rejections of Claims 1-3, 8 and 9.
Claim 20 is non-transitory computer-readable storage medium claim corresponding to the method claim hereinabove (Claim 1). Therefore, Claim 20 is rejected for the same reasons set forth in the rejection of Claim 1.
Claims 4-6 and 14-16 are rejected under 35 U.S.C. 103 as being unpatentable over Kryzhanovsky in view of Vent as applied to claims 1, 3, 11 and 13 above, and further in view of US 20160092526 (hereinafter “Kothari”).
As per Claim 4, the rejection of Claim 3 is incorporated; and Kryzhanovsky further discloses:
wherein the performing version control processing comprises using a version control library […] where the version control library and […] (Paragraph [0023], “The cloud-based environment 101 may include source control platform 120 or a repository 114 (e.g., data store). The source control platform 120 may be separate from repository 114 and communicatively coupled to the repository 114. In some implementations, repository 114 may be part of source control platform 120 (emphasis added).”; (Paragraph [0024], “In implementations, repository 114 may store a committed version 107 of source code 140, changes 116, or records of changes 119. Contents of the repository 114 may further be described in the subsequent Figures [wherein the performing version control processing comprises using a version control library […] where the version control library and […]] (emphasis added).”;
The combination of Kryzhanovsky and Vent does not explicitly disclose:
[…] database mapping of the client-as-a-service layer […] the database mapping are stored in the client terminal.
However, Kothari discloses:
[…] database mapping of the client-as-a-service layer […] the database mapping are stored in the client terminal (Paragraph [0058], “shared repository of the data integration tool can be integrated with a branch/trunk of the version control system selected by an administrator. In some embodiments, the shared relational database repository of the data integration tool can be mapped to one trunk/branch present in the version control system repository by persisting information of a configured trunk/branch in the shared relational database repository of the data integration tool (emphasis added).”; Paragraph [0125], “FIG. 6, Computer A and Computer B each include a local version database that is a clone of the version database maintained by Server computer. Thus if a server dies, any of the client local repositories can be copied back up to the server to restore it. The mechanism of getting changes from a remote server repository to local repository is usually called “pulling or fetching,” and the mechanism of moving changes to a remote server repository from local repository is called “pushing” [[…] database mapping of the client-as-a-service layer […] the database mapping are stored in the client terminal] (emphasis added).”;
Kothari within the same field of endeavor as the claimed invention regarding a data integration system that integrate an object based data integration tool, such a GUI-based data integration tools, with version control systems using a relational database repository for persistence. Thus, Kothari is an analogous art to the claimed invention.
Therefore, it would have been obvious to one of ordinary skill in the art before effective filing date of the claimed invention to incorporate the teaching of Kothari into the combined teachings of Kryzhanovsky and Vent to include “[…] database mapping of the client-as-a-service layer […] the database mapping are stored in the client terminal.” The modification would be obvious because one of the ordinary skills in the art would be motivated to allow developers working on a shared relational database repository which can perform various version management operations (Kothari, paragraph [0065]).
As per claim 5, the rejection of Claim 4 is incorporated; and Kryzhanovsky discloses “the version control library”, but the combination of Kryzhanovsky and Vent does not explicitly disclose:
wherein […] and database mapping stored in the client terminal are used to communicate with the cache.
However, Kothari discloses:
wherein […] and database mapping stored in the client terminal are used to communicate with the cache (Paragraph [0125], “FIG. 6, Computer A and Computer B each include a local version database that is a clone of the version database maintained by Server computer. Thus if a server dies, any of the client local repositories can be copied back up to the server to restore it. The mechanism of getting changes from a remote server repository to local repository is usually called “pulling or fetching,” and the mechanism of moving changes to a remote server repository from local repository is called “pushing” [[…] database mapping of the client-as-a-service layer […] the database mapping are stored in the client terminal] (emphasis added).”;
Kothari within the same field of endeavor as the claimed invention regarding a data integration system that integrate an object based data integration tool, such a GUI-based data integration tools, with version control systems using a relational database repository for persistence. Thus, Kothari is an analogous art to the claimed invention.
Therefore, it would have been obvious to one of ordinary skill in the art before effective filing date of the claimed invention to incorporate the teaching of Kothari into the combined teachings of Kryzhanovsky and Vent to include “wherein […] and database mapping stored in the client terminal are used to communicate with the cache.” The modification would be obvious because one of the ordinary skills in the art would be motivated to allow developers working on a shared relational database repository which can perform various version management operations (Kothari, paragraph [0065]).
As per Claim 6, the rejection of Claim 1 is incorporated; and Kryzhanovsky further discloses:
wherein the client-as-a-service layer includes a library stored on the client terminal […] based on the application code input by the user (Paragraph [0023], “The cloud-based environment 101 may include source control platform 120 or a repository 114 (e.g., data store). The source control platform 120 may be separate from repository 114 and communicatively coupled to the repository 114. In some implementations, repository 114 may be part of source control platform 120 (emphasis added).”; Paragraph [0024], “In implementations, repository 114 may store a committed version 107 of source code 140, changes 116, or records of changes 119. Contents of the repository 114 may further be described in the subsequent Figures (emphasis added).”; Paragraph [0048], “The client device 110A may receive user input responsive to a user making changes 116A to(e.g., typing text in) copy 109A of the committed version 107 of source code 140 via the client device110A [wherein the client-as-a-service layer includes a library stored on the client terminal […] based on the application code input by the user] (emphasis added).”;
The combination of Kryzhanovsky and Vent does not explicitly disclose:
[…] that provides control interfaces to the user interface layer and generates database operations […]
However, Kothari discloses:
[…] that provides control interfaces to the user interface layer and generates database operations […] (Paragraph [0225], “In exemplary operation 1134, a customer using a client device, such as client device 1104, 1106 or 1108, may interact with cloud infrastructure system 1102 by requesting one or more services provided by cloud infrastructure system 1102 and placing an order for a subscription for one or more services offered by cloud infrastructure system 1102. In certain embodiments, the customer may access a cloud User Interface (UI), cloud UI 1112, cloud UI 1114 and/or cloud UI 1116 and place a subscription order via these UIs (emphasis added).”; Paragraph [0260], “In the box 1802 operation, the user selects an ETL Object from which the user wants to create a partial tag or label. At the box 1804, the system locks the relational database repository of the ETL tool by maintaining a lock flag before starting the partial sync process [[…] that provides control interfaces to the user interface layer and generates database operations […]] (emphasis added).”;
Kothari within the same field of endeavor as the claimed invention regarding a data integration system that integrate an object based data integration tool, such a GUI-based data integration tools, with version control systems using a relational database repository for persistence. Thus, Kothari is an analogous art to the claimed invention.
Therefore, it would have been obvious to one of ordinary skill in the art before effective filing date of the claimed invention to incorporate the teaching of Kothari into the combined teachings of Kryzhanovsky and Vent to include “[…] that provides control interfaces to the user interface layer and generates database operations […]” The modification would be obvious because one of the ordinary skills in the art would be motivated to allow developers working on a shared relational database repository which can perform various version management operations (Kothari, paragraph [0065]).
Claims 14-16 are apparatus claims corresponding to the method claims hereinabove (Claims 4-6, respectively). Therefore, Claims 14-16 are rejected for the same reasons set forth in the rejections of Claims 4-6.
Claims 7 and 17 are rejected under 35 U.S.C. 103 as being unpatentable over Kryzhanovsky in view of Vent and Kothari as applied to claims 6 and 16 above, and further in view of US 20150215376 (hereinafter “Kranz”).
As per Claim 7, the rejection of Claim 6 is incorporated; and the combination of Kryzhanovsky, Vent and Kothari does not explicitly disclose:
wherein the database operations comprise CRUD (Create, Read, Update, Delete) and transaction functions.
However, Kranz discloses:
wherein the database operations comprise CRUD (Create, Read, Update, Delete) and transaction functions (Paragraph [0038], “Each node API supports, for example, a notification service, an ext service, CRUD (create, retrieve, update and delete) database functions, other functions (etc.), and custom operations. Tenant ID's are used to route the API services to the various respective connectors [wherein the database operations comprise CRUD (Create, Read, Update, Delete) and transaction functions] (emphasis added).”;
Kranz is within the same field of endeavor as the claimed invention regarding cloud based data processing, and more specifically to systems and methods for deploying legacy software in the cloud. Thus, Kranz is an analogous art to the claimed invention.
Therefore, it would have been obvious to one of ordinary skill in the art before effective filing date of the claimed invention to incorporate the teaching of Kranz into the combined teachings of Kryzhanovsky, Vent and Kothari to include “wherein the database operations comprise CRUD (Create, Read, Update, Delete) and transaction functions.” The modification would be obvious because one of the ordinary skills in the art would be motivated to enable common, real-time monitoring and management for the database (Kranz, paragraph [0013]).
Claim 17 is an apparatus claim corresponding to the method claim hereinabove (Claim 7). Therefore, Claim 17 is rejected for the same reasons set forth in the rejections of Claim 7.
Claim 10 is rejected under 35 U.S.C. 103 as being unpatentable over Kryzhanovsky in view of Vent as applied to claim 1, and further in view of US 20230041490 (hereinafter “Vangati”).
As per Claim 10, the rejection of Claim 1 is incorporated; and Kryzhanovsky further discloses:
in response to receiving the application code […] associated with or affected by the application code and transmitting data to the identified other client terminals for execution or display (Paragraph [0019], “The technical solution may further include receiving a commit request identifying at least some of the source code changes from the record of changes from the first client device, committing the identified changes to generate a new committed version of the source code, and transmitting a corresponding copy of the new committed version of the source code to each client device (emphasis added).”; Paragraph [0026], “In implementations, changes 116 to copies 109 of committed version 107 of source code 140 by other users may be accessed, prepared for execution, or executed by client devices 110A-Z in real-time (emphasis added).”; Paragraph [0048], “The client device 110A may receive user input responsive to a user making changes 116A to(e.g., typing text in) copy 109A of the committed version 107 of source code 140 via the client device110A [in response to receiving the application code […] associated with or affected by the application code and transmitting data to the identified other client terminals for execution or display] (emphasis added).”.
Kryzhanovsky does not explicitly discloses:
[…] performing a client discovery mechanism in the client-as-a-service layer of the client terminal, wherein the client discovery mechanism comprises identifying other client terminals […]
However, Vangati discloses:
[…] performing a client discovery mechanism in the client-as-a-service layer of the client terminal, wherein the client discovery mechanism comprises identifying other client terminals […] (Paragraph [0142], “In some embodiments, client(s) communicatively coupled to a network become aware of other client(s) and the available services according to a process for discovering client(s) on the network. For example, when a client is coupled into the network it may broadcast a unique ID and the services it can offer. When first starting up, a client (e.g., device) might want to discover all other clients on the network, e.g., to know who to communicate with [[…] performing a client discovery mechanism in the client-as-a-service layer of the client terminal, wherein the client discovery mechanism comprises identifying other client terminals […]] (emphasis added).”.
Vangati is within the same field of endeavor as the claimed invention regarding A messaging system for exchanging messages between nodes in a network via a broker that uses a publish-subscribe message protocol, which nodes have object identifications (IDs). Thus, Vangati is an analogous art to the claimed invention.
Therefore, it would have been obvious to one of ordinary skill in the art before effective filing date of the claimed invention to incorporate the teaching of Vangati into the combined teachings of Kryzhanovsky and Vent to include “[…] performing a client discovery mechanism in the client-as-a-service layer of the client terminal, wherein the client discovery mechanism comprises identifying other client terminals […].” The modification would be obvious because one of the ordinary skills in the art would be motivated to allow discovery of the clients that are operatively (e.g., communicatively) coupled to the network (Vangati, paragraph [0006]).
Conclusion
The prior art made of record and not relied upon is considered pertinent to the Applicant’s disclosure. They are as follows:
US 2023/0325181 (hereinafter “Wei”) discloses software development technologies, and more specifically, to a code analysis method and a related device.
US 2023/0124113 (hereinafter “Hudson”) discloses method and system for identifying suspicious code contribution of a user to a source code repository.
US 2021/0303297 (hereinafter “Islam”) discloses a computer implemented method including a server system communicating identifier(s) identifying to a document management service of a second server system a portion of software code or other document parts.
US 2020/0379746 (hereinafter “Shivashankara”) discloses an application code updating apparatus.
Any inquiry concerning this communication or earlier communications from the Examiner should be directed to Yanbin Li whose telephone number is 571-272-0906. The Examiner can normally be reached on Monday through Friday from 8:30 AM to 4:30 PM ET.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, the Applicant is encouraged to use the USPTO Automated Interview Request (AIR) at https://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 more 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.
/Y.L./Examiner, Art Unit 2191
/WEI Y MUI/Supervisory Patent Examiner, Art Unit 2191
Prosecution Insights