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 .
This action is in response to response filed on 12/3/2025. This action is FINAL.
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-20 are rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more. Claim 1 recites, “discovering… hidden internal common code by analyzing the code…”, “identifying… unique application code based on the discovering them hidden internal common code” and “generating… a unique code module comprising the unique application code”. The limitations of “discovering”, “identifying” and “generating” as drafted are functions that, under their broadest reasonable interpretation, recite the abstract idea of a mental process. The limitations encompass a human mind carrying out the function through observation, evaluation, judgment and /or opinion, or even with the aid of pen and paper. Thus, this limitation recites and falls within the “Mental Processes” grouping of abstract ideas under Prong 1.
Under Prong 2, this judicial exception is not integrated into a practical application. The claim recites the following additional elements of “receiving…code…” and “transmitting… the unique code module”. The additional elements of receiving and transmitting are insignificant pre solution activities. They are recited at a high level of generality and do nothing more than add insignificant extra solution activities to the judicial exception (MPEP 2106.05(g)). Further, the limitation “a processor set” is recited at a high-level of generality such that it amounts no more than mere instructions to apply the exception using generic computer, and/or mere computer components, MPEP 2106.05(f). Accordingly, the additional elements do not integrate the recited judicial exception into a practical application and the claim is therefore directed to the judicial exception.
Under Step 2B, the claims do not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, the additional elements of “a processor set” amounts to no more than mere instructions, or generic computer/computer components to carry out the exception and for the limitations of “receiving” and “transmitting”, the courts have identified receiving and transmitting data as well-understood, routine and conventional activities. Se MPEP 2106.05(d) and MPEP 2106.05(f). The recitation of generic computer instruction and computer components to apply the judicial exception, and the well-understood, routine, conventional activities do not amount to significantly more, thus, cannot provide an inventive concept. Accordingly, claim 1 is not patent eligible under 35 USC 101.
Claim 2-4, The steps of “discovering” are additional limitation of the abstract idea “Mental Process”. Nothing in the claimed limitations prevents these limitations from being performed in the mind. These limitations are neither a practical application under prong 2, nor an inventive concept under step under step 2B.
Claim 5, The step of “isolating” is an additional limitation of the abstract idea “Mental Process”. Nothing in the claimed limitation prevents this limitation from being performed in the mind. The limitation is neither a practical application under prong 2, nor an inventive concept under step under step 2B.
Claim 6, The limitations are neither a practical application under prong 2, nor an inventive concept under step under step 2B, they just further describe the unique application code.
Claim 7, The limitations are neither a practical application under prong 2, nor an inventive concept under step under step 2B, they just further describe the receiving step.
Claims 8-9, further describes the mental process of “discovering”. The limitations are neither a practical application under prong 2, nor an inventive concept under step under step 2B.
Claim 10, The step of “determining” is an additional limitation of the abstract idea “Mental Process”. Nothing in the claimed limitation prevents this limitation from being performed in the mind. The limitation is neither a practical application under prong 2, nor an inventive concept under step under step 2B.
Claims 11-20, contain similar limitations to claims 1-10 and are therefore rejected for the same reasons.
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-9, 11-17 and 19-20 are rejected under 35 U.S.C. 103 as being unpatentable over Gupta et al. (US 10,579,370 B2).
As per claim 1 (Amended), Gupta et al. teaches the invention as claimed including, “A computer-implemented method, comprising:
receiving, by a processor set, code associated with a monolithic application;”A disintegration system may receive a name and a location for the monolith and may fetch the code of the monoliths (column 4, lines 47-56).
“discovering, by the processor set, hidden internal common code by analyzing the code associated with the monolithic application;
identifying, by the processor set, unique application code based on a weighting value of components of the code associated with the monolithic application being less than a threshold value that is set based on characteristics thereof, the weighting value depending on a number of the components that use the discovered hidden internal common code
The monolith application code is scanned to find nanoservice candidates. Methods are found in the code. The system then scans inside of the method to determine whether the method references or calls internal method. If the method calls another method which defined internally in the monolith application (hidden internal common code), it means that the method has a dependency on another method and the method cannot be a nanoservice, which is individual and stand-alone. If the method does not call another internal method (unique application code), the system adds the methods into a reference array. The system determines whether a method calls an external service. If a method does not call another internal method but calls an external service (unique application code), the method becomes a candidate of nanoservice (column 6, lines 29-65 and figures 2- 3).
The examiner states that ”a weighting value of components of the code“ is analogous to “the system determines whether the method references or calls and internal method”. As claimed the weighted value depends on the number of components that use the discovered hidden common code. Gupta teaches the system determines whether the method references or calls an internal method. Therefore, the weight would be true/1 if the method references or calls and internal method. Gupta teaches the system determines whether the method references or calls and internal method. If the method calls another method (true/1) which is defined internally in the monolith application, it means that the method has a dependency on another method and the method cannot be a nanoservice. Therefore, the method in Gupta would be above/equal to a threshold of 1 and it would not be a nanoservice candidate. Gupta further teaches, the system determines whether a method calls an external service. If a method does not call another internal method (less than threshold of 1) but calls an external service, the method becomes a candidate of nanoservice. Therefore, Gupta et al. meets the bounds of the limitation “a weighting value of components of the code associated with the monolithic application being less than a threshold value that is set based on characteristics thereof, the weighting value depending on a number of the components that use the discovered hidden internal common code”. Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention for the above limitation to be taught by Gupta et al. since both teach analogous variations of the same step, producing the same results and therefore would have been obvious to try.
“generating, by the processor set, a unique code module comprising the unique application code; and
transmitting, by the processor to a user device, the unique code module.”
Microservices can be generated according to shared characteristics by grouping a plurality of nanoservices having common characteristics. A user may choose one or more microservices to generate. Features include automatic deployment of the microservice (column 5, lines 4-46). Microservice Architecture enables individual services to be deployed and scaled independently (column 1, lines 32-35). Also see figure 7D.
As per claim 2, Gupta et al. further teaches, “The computer-implemented method of claim 1, further comprising discovering, by the processor set, explicitly declared common code by analyzing the code associated with the monolithic application.”
The monolith application code is scanned to find nanoservice candidates. Methods are found in the code. The system then scans inside of the method to determine whether the method references or calls internal method. If the method calls another method which defined internally in the monolith application, it means that the method has a dependency on another method and the method cannot be a nonoservice, which is individual and stand-alone. If the method does not call another internal method, the system adds the methods into a reference array. The system determines whether a method calls an external service. If a method does not call another internal method but calls an external service, the method becomes a candidate of nanoservice (column 6, lines 29-65 and figures 2- 3).
As stated above, the examiner states that Gupta et al. teaches all methods are found in the code. Therefore, the examiner states that it would have been obvious to one or ordinary skill in the art before the effective filing date for the found methods to include “explicitly declared common code”. The “unique application code” is the only code used to generate the unique code module. Therefore the “explicitly declared common code” is only found to exclude it from being used in a “unique module”. Since Gupta et al. teaches only selecting nanoservices that are “unique application code”, then it would be obvious that all other method types found would be excluded from the generated microservice/unique code modules. This is nothing more than a design choice and would have been obvious to try.
As per claim 3, Gupta et al. further teaches, “The computer-implemented method of claim 1, further comprising discovering, by the processor set, hidden external common code by analyzing the code associated with the monolithic application.” The monolith application code is scanned to find nanoservice candidates. Methods are found in the code. The system then scans inside of the method to determine whether the method references or calls internal method. If the method calls another method which defined internally in the monolith application, it means that the method has a dependency on another method and the method cannot be a nonoservice, which is individual and stand-alone. If the method does not call another internal method, the system adds the methods into a reference array. The system determines whether a method calls an external service. If a method does not call another internal method but calls an external service, the method becomes a candidate of nanoservice (column 6, lines 29-65 and figures 2- 3).
As stated above, the examiner states that Gupta et al. teaches all methods are found in the code. Therefore, the examiner states that it would have been obvious to one or ordinary skill in the art before the effective filing date for the found methods to include “hidden external common code”. The “unique application code” is the only code used to generate the unique code module. Therefore the “hidden external common code” is only found to exclude it from being used in a “unique module”. Since Gupta et al. teaches only selecting nanoservices that are “unique application code”, then it would be obvious that all other method types found would be excluded from the generated microservice/unique code modules. This is nothing more than a design choice and would have been obvious to try.
As per claim 4, Gupta et al. further teaches, “The computer-implemented method of claim 1, further comprising determining, by the processor set, third-party common code by analyzing the code associated with the monolithic application.”
The monolith application code is scanned to find nanoservice candidates. Methods are found in the code. The system then scans inside of the method to determine whether the method references or calls internal method. If the method calls another method which defined internally in the monolith application, it means that the method has a dependency on another method and the method cannot be a nonoservice, which is individual and stand-alone. If the method does not call another internal method, the system adds the methods into a reference array. The system determines whether a method calls an external service. If a method does not call another internal method but calls an external service, the method becomes a candidate of nanoservice (column 6, lines 29-65 and figures 2- 3).
As stated above, the examiner states that Gupta et al. teaches all methods are found in the code. Therefore, the examiner states that it would have been obvious to one or ordinary skill in the art before the effective filing date for the found methods to include “third-party common code”. The “unique application code” is the only code used to generate the unique code module. Therefore the “third-party common code” is only found to exclude it from being used in a “unique module”. Since Gupta et al. teaches only selecting nanoservices that are “unique application code”, then it would be obvious that all other method types found would be excluded from the generated microservice/unique code modules. This is nothing more than a design choice and would have been obvious to try.
As per claim 5, Gupta et al. further teaches, “The computer-implemented method of claim 1, further comprising isolating, by the processor set, the unique application code from the hidden internal common code of the code associated with the monolithic application.”
Microservice Architecture enables individual services to be deployed and scaled independently (column 1, lines 32-35). Microservices (isolated) may be generated according to shared characteristics by grouping a plurality of nanoservices having a common characteristic (column 5, lines 46).
A Nanoservice is individual and stand-alone (column 6, lines 29-65 and figures 2- 3).
As per claim 6, Gupta et al. further teaches, “The computer-implemented method of claim 1, wherein the unique application code describes one or more software components.
The monolith application code is scanned to find nanoservice candidates. Methods (software component) are found in the code. The system then scans inside of the method to determine whether the method references or calls internal method (column 6, lines 29-65 and figures 2- 3).
As per claim 7, Gupta et al. further teaches, “The computer-implemented method of claim 1, wherein receiving the code associated with the monolithic application comprises obtaining, by the processor set, the code associated with the monolithic application by accessing at least one of a data source or a knowledge base.
A disintegration system may receive a name and a location for the monolith and may fetch the code of the monoliths (column 4, lines 47-56).
As per claim 8, Gupta et al. further teaches, “The computer-implemented method of claim 1, wherein discovering the hidden internal common code comprises analyzing relationships between one or more software components of the code associated with the monolithic application.
The monolith application code is scanned to find nanoservice candidates. Methods are found in the code. The system then scans inside of the method to determine whether the method references or calls internal method. If the method calls another method which defined internally in the monolith application, it means that the method has a dependency on another method and the method cannot be a nonoservice, which is individual and stand-alone. If the method does not call another internal method, the system adds the methods into a reference array. The system determines whether a method calls an external service. If a method does not call another internal method but calls an external service, the method becomes a candidate of nanoservice (column 6, lines 29-65 and figures 2- 3).
As per claim 9, Gupta et al. further teaches, “The computer-implemented method of claim 8, wherein analyzing the relationships between one or more software components comprises determining dependencies between the one or more software components of the code associated with the monolithic application.”
The monolith application code is scanned to find nanoservice candidates. Methods are found in the code. The system then scans inside of the method to determine whether the method references or calls internal method. If the method calls another method which defined internally in the monolith application, it means that the method has a dependency on another method and the method cannot be a nonoservice, which is individual and stand-alone. If the method does not call another internal method, the system adds the methods into a reference array. The system determines whether a method calls an external service. If a method does not call another internal method but calls an external service, the method becomes a candidate of nanoservice (column 6, lines 29-65 and figures 2- 3).
As per claims 11, 15-17 and 19, they contain similar limitations to claims 1 and 5-9 and are therefore rejected for the same reasons.
As per claims 12-14 and 20, they contains similar limitations to claims 2-4 and are therefore rejected for similar reasons.
Claims 10 and 18 are rejected under 35 U.S.C. 103 as being unpatentable over Gupta et al. (US 10,579,370 B2) as applied to claim 1 above, and further in view of Singh et al. (US 11,775271 B1).
As per claim 10, Gupta et al does not explicitly appear to teach, “The computer-implemented method of claim 1, further comprising determining, by the processor set, a refactoring suitability score by comparing the received code associated with a monolithic application against the generated unique code module.”
Singh et al. teaches annotating a predicted portion of a second source code. The annotation may be a confidence score that is determined based on the highest probability and that indicates a confidence level that the predicted portion of the second source code generated by the translator is a correct translations of a corresponding portion of the first source code (column 11, lines 14-43).
It would have been obvious to one of ordinary skill in the art before the effective filing date to modify Gupta et al. with Singh et al. because both teach translating code. Gupta et al. teaches disintegrating a monolith service to microservices, which is translating parts of a monolith service to individual microservices. If one is translation code from one form to another, having a way to track the confidence score that the translation is correct will allow one to make sure they select the correct translation and would have been obvious to try.
As per claim 18, claim 18 contains similar limitations to claim 10 and is therefore rejected for the same reasons.
Response to Arguments
Applicant's arguments filed 12/3/2025 have been fully considered but they are not persuasive.
Regarding 35 U.S.C § 101 rejection
Applicant argues, “a human mind can neither discover hidden internal common code in a monolithic application, nor generate and transmit a unique code model to a user device. Complexity associated with monolithic application and challenges associated with refactoring them are explained in paragraph [0017]-[0021]”. The examiner first would like to state that nowhere in said claims is it stated that the code being analyzed is not some type of human readable source code or intermediate representation. Therefore, a human would be able to read/analyze the code and also generate new code. Applicant points to paragraphs 0017-0021, these paragraphs state that monolithic programs can grow and become complex and be updated multiple times. However, none of this is claimed. As claimed and under a broadest reasonable interpretation, the received coded could be a small amount of code associated with a monolithic application that is not old and has never been updated. Therefore, a human would be able to read the code to determine unique application code, identify using a weighting value to determine hidden internal common code and then using a generic computer or paper/pen write a unique code module comprising the unique application code. The examiner states that nothing in the claimed limitation precludes these steps from being performed in the mind and they are therefore part of the abstract idea “Mental Process”.
Applicant further argues, “In the present application, independent claim 1 is directed towards an improved technical solution that is inherently tied to a computing environment – isolating unique application code in a monolithic application for subsequent modernization therefore….
… In particular, the claims improve the technical field of modernizing monolithic applications in a computer system by identifying unique code based on a weighting value of components of the code associated with the monolithic application being less than a threshold number of components that use the discovered hidden internal common code.” The examiner respectfully disagrees and states that there is no improvement to the technical field of modernizing monolithic application in a computer system. As claimed, the monolithic application is never modified or improved in any way. A unique code module is generated comprising the unique application code and sent to a user device but it is never used in any way. Therefore, no improvement is realized.
Lastly applicant argues the examiner has not provided any explanation in the office action as to how the limitations of “receiving, by a processor set, code associated with a monolithic application” and “transmitting, by the processor to a suer device, the unique code module” can be considered insignificant extra-solution activities. The examiner states, as stated above in the current rejection, the courts have identified receiving and transmitting data as well-understood, routine and conventional activities. Se MPEP 2106.05(d) section II.
“i. Receiving or transmitting data over a network, e.g., using the Internet to gather data, Symantec, 838 F.3d at 1321, 120 USPQ2d at 1362 (utilizing an intermediary computer to forward information); TLI Communications LLC v. AV Auto. LLC, 823 F.3d 607, 610, 118 USPQ2d 1744, 1745 (Fed. Cir. 2016) (using a telephone for image transmission); OIP Techs., Inc., v. Amazon.com, Inc., 788 F.3d 1359, 1363, 115 USPQ2d 1090, 1093 (Fed. Cir. 2015) (sending messages over a network); buySAFE, Inc. v. Google, Inc., 765 F.3d 1350, 1355, 112 USPQ2d 1093, 1096 (Fed. Cir. 2014) (computer receives and sends information over a network); but see DDR Holdings, LLC v. Hotels.com, L.P., 773 F.3d 1245, 1258, 113 USPQ2d 1097, 1106 (Fed. Cir. 2014) ("Unlike the claims in Ultramercial, the claims at issue here specify how interactions with the Internet are manipulated to yield a desired result‐‐a result that overrides the routine and conventional sequence of events ordinarily triggered by the click of a hyperlink." (emphasis added)); “
As claimed, code is received and code is transmitted. Nothing in the clamed limitations teach a specific way in which these steps are performed. The claim generically performs the steps of receiving and transmitting and meet the above court cases which recognize receiving and or transmitting data over a network as well-understood, routine, conventional activities. This also aligns with MPEP 2106.05(g).
The additional elements of receiving and transmitting are insignificant pre solution activities. They are recited at a high level of generality and do nothing more than add insignificant extra solution activities to the judicial exception (MPEP 2106.05(g)). The receiving and transmitting are performed using generic computer components. Code is transmitted to a user device but is never used in any way. Therefore, these limitations fall under mere data gathering and are insignificant pre and post extra solution activities.
For the reasons above the current 101 rejections stand.
Regarding 35 U.S.C § 102 rejection
Applicant’s arguments are moot due to amendments. Please see the above rejection addressing the new limitations.
Conclusion
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure.
Punathil et al. (US 2020/0401386 A1), teaches reconfiguring a software application into a set of microservices for deployment (abstract). One or more modules are determined that do not depend on other parts of the application to identify a initial set of potential microservices (0018).
Applicant's amendment necessitated the new ground(s) of rejection presented in this Office action. Accordingly, THIS ACTION IS MADE FINAL. See MPEP § 706.07(a). Applicant is reminded of the extension of time policy as set forth in 37 CFR 1.136(a).
A shortened statutory period for reply to this final action is set to expire THREE MONTHS from the mailing date of this action. In the event a first reply is filed within TWO MONTHS of the mailing date of this final action and the advisory action is not mailed until after the end of the THREE-MONTH shortened statutory period, then the shortened statutory period will expire on the date the advisory action is mailed, and any nonprovisional extension fee (37 CFR 1.17(a)) pursuant to 37 CFR 1.136(a) will be calculated from the mailing date of the advisory action. In no event, however, will the statutory period for reply expire later than SIX MONTHS from the mailing date of this final action.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to MARK A GOORAY whose telephone number is (571)270-7805. The examiner can normally be reached Monday - Friday 10:00am - 6:00pm.
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, Lewis Bullock can be reached at 571-272-3759. 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.
/MARK A GOORAY/ Examiner, Art Unit 2199
/LEWIS A BULLOCK JR/ Supervisory Patent Examiner, Art Unit 2199