Code Analysis Method and Related Device

Application No. 18/335,538

• Filed: Jun 15, 2023
• Examiner: DUAN, VIVIAN WEIJIA
• Art Unit: 2191
• Tech Center: 2100 — Computer Architecture & Software
• Assignee: Huawei Cloud Computing Technologies Co. Ltd.
• OA Round: 3 (Non-Final)

Office Action

DETAILED ACTION
This action is in response to the claims filed January 16, 2026. Claims 1-20 are pending. Claims 1, 8, and 15 are independent claims. Claims 1-3, 6-10, 13-15, 17, and 20 have been amended.
The 35 U.S.C. 101 rejection is maintained in view of Applicant’s arguments and amendments to the claims.

Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .

Claim Objections
Claim 9 is objected to because of the following informalities:
- Claim 9 reads “wherein the one or more processors are further configured to execute the instructions send the warning information by”. This should likely read “wherein the one or more processors are further configured to execute the instructions to send the warning information by”.
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-20 are rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Regarding claim 1, the limitation “determining…based on the identity information, the base version of the changed file form the code repository”, “determining…based on the first location, whether the base version of the changed file includes a target code block that overlaps the first location, wherein the target code block overlaps the first location when at least one of the one or more first line numbers of the changed code block is included in one or more second line numbers of the target code block”, and “generating…warning information when the base version includes the target code block that overlaps the first location and when the first author is different from a second author of the target code block” as drafted, is a function that, under their broadest reasonable interpretation, recites the abstract idea of a mental process. The limitation encompasses a human mind carrying out the function through observation, evaluation, judgement, and/or opinion, or even with the aid of pen and paper. Thus, these limitations recite and fall under the “Mental Processes” grouping of abstract ideas under Prong 1.
Under Prong 2, this judicial exception is not integrated into a practical application. The additional elements “by the server” is recited at a high level of generality such that it amounts to no more than mere instructions to apply the exception using a generic computer, and/or mere computer components. See MPEP 2106.05(f). The additional elements “receiving…from a collection agent of a first terminal in a distributed system, attribute information of a changed code block as feedback when code in a file being compiled in a work area of the first terminal changes with code of a corresponding file in a base version stored in a code repository of the first terminal, wherein the attribute information comprises identity information of a changed file, a first author of the changed code block, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file” and “sending…the warning information to a second terminal in the distributed system that is associated with a second author of the target code block” do nothing more than add the insignificant extra solution activity of merely gathering and transmitting data to the judicial exception. See 2106.05(g). 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 more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, the additional elements of “by a server” amount to no more than mere instructions, or generic computer/computer components to carry out the exception. For the limitations “receiving…from a collection agent of a first terminal in a distributed system, attribute information of a changed code block as feedback when code in a file being compiled in a work area of the first terminal changes with code of a corresponding file in a base version stored in a code repository of the first terminal, wherein the attribute information comprises identity information of a changed file, a first author of the changed code block, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file” and “sending…the warning information to a second terminal in the distributed system that is associated with a second author of the target code block”, the courts have identified mere data gathering and transmitting as well-understood, routine, and conventional activity. See MPEP 2106.05(d). Accordingly, the claims are not patent eligible under 35 U.S.C. §101.
Claim 2 does not recite additional mental steps. The limitations “wherein sending the warning information comprises” and “pushing, to the second terminal in the distributed system, the conflict list” amount to the insignificant extra solution activity of mere data gathering and transmission, which does not amount to a practical application under Prong 2, nor amount to significantly more under Step 2B as explained above. The limitation “storing, to a non-transitory computer readable storage medium the changed code block in a conflict list of changed code” amounts to the insignificant extra solution activity of data storage, which does not amount to practical application under Prong 2. See MPEP 2106.05(g). Under Step 2B, the limitation does not amount to significantly more, as the courts have identified storing and retrieving information in memory as well-understood, routine, and conventional activity. See MPEP 2106.05(d).
Regarding claim 3, the limitation “wherein the warning information indicates that the target code block is modified” merely describes the contents of the warning information in mental and data transmitting steps of claim 1. Merely further describing a mental step amounts to a mental step under Prong 1. Merely further describing data transmitting step amounts to the insignificant extra solution activity of data gathering, which does not amount to practical application under Prong 2, nor to significantly more under Step 2B as explained above.
Regarding claim 4, the limitation “when the target code block overlaps a second location of a particular code block in a code analysis library” is an additional mental step. The limitation “sending, to a second target terminal in the distributed system, second warning information …, wherein the particular code block is for defining a function or a variable” amounts to the insignificant extra solution activity of mere data gathering and transmission, which does not amount to a practical application under Prong 2, nor amount to significantly more under Step 2B as explained above. The limitation “wherein code compiled by the second target terminal comprises the function or the variable, and wherein the second warning information indicates that the function or the variable changes” merely further describes the code and warning of the mental and data gathering steps above, and thus does not amount to practical application under Prong 2, nor to significantly more under Step 2B, as explained above.
Regarding claim 5, the limitations “wherein when the target code block overlaps the second location, the method further comprises”, “analyzing the changed code block to determine first key information of a first object defined by the changed code block”, “determining second key information of a second object defined by the target code block, wherein the first object and the second object are functions or variables”, and “comparing the first key information with the second key information to determine difference information between the first key information and the second key information, and wherein the second warning information further indicates the difference information” are additional mental steps. Claim 5 does not recite additional limitations which may amount to practical application under Prong 2, nor amount to significantly more under Step 2B.
Regarding claim 6, the limitation “wherein when the first object and the second object are the functions, the first key information and the second key information comprise a first name of the functions, a first parameter in the functions, a return value in the functions, a first start line of the functions, a first end line of the functions, a first class to which the functions belong, a first file name of the first class, a function name of a second function called by the functions, a second parameter in the second function, a second start line of the second function, a second end line of the second function, a second class to which the second function belongs, a second file name of the second class, or a type name of an invoker that invokes the second function, or when the first object and the second object are the variables, the first key information and the second key information comprise a second name of the variables, a third start line of the variables, a third end line of the variables, or a type of the variables” merely describes the “first object” and the “second object” recited in the mental steps of claim 5. Therefore, claim 6 is directed to a mental process. Claim 6 does not recite additional limitations which may amount to practical application under Prong 2, nor amount to significantly more under Step 2B.
Claim 7 does not recite additional mental steps. The limitation “obtaining the attribute information comprises obtaining the attribute information of the changed code block that is from the collection agent module of the first terminal” amounts to the insignificant extra solution activity of mere data gathering and transmission, which does not amount to a practical application under Prong 2, nor amount to significantly more under Step 2B as explained above.
Regarding claims 8 and 15, the limitations “determine, based on the identity information, the base version of the changed file form the code repository”, “determine, based on the first location, whether the base version of the changed file includes a target code block that overlaps the first location, wherein the target code block overlaps the first location when at least one of the one or more first line numbers of the changed code block is included in one or more second line numbers of the target code block”, and “generate warning information when the base version includes the target code block that overlaps the first location and when the first author is different from a second author of the target code block” as drafted, is a function that, under their broadest reasonable interpretation, recites the abstract idea of a mental process. The limitation encompasses a human mind carrying out the function through observation, evaluation, judgement, and/or opinion, or even with the aid of pen and paper. Thus, these limitations recite and fall under the “Mental Processes” grouping of abstract ideas under Prong 1.
Under Prong 2, this judicial exception is not integrated into a practical application. The additional elements “an apparatus comprising: a memory configured to store instructions; and one or more processors coupled to the memory and configured to execute the instructions to:” and “a computer program product comprising instructions stored on a non-transitory computer-readable medium that, when executed by one or more processors, cause the apparatus to” is recited at a high level of generality such that it amounts to no more than mere instructions to apply the exception using a generic computer, and/or mere computer components. See MPEP 2106.05(f). The additional elements “obtain, from a collection agent module of a first terminal in a distributed system, attribute information of a changed code block as feedback when code in a file being compiled in a work area of the first terminal changes with code of a corresponding file in a base version stored in a code repository of the first terminal, wherein the attribute information comprises identity information of a changed file, a first author of the changed code block, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file” and “send, to a second terminal in the distributed system that is associated with a second author of the target code block, the warning information” do nothing more than add the insignificant extra solution activity of merely gathering and transmitting data to the judicial exception. See 2106.05(g). 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 more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, the additional elements of “an apparatus comprising: a memory configured to store instructions; and one or more processors coupled to the memory and configured to execute the instructions to:” and “a computer program product comprising instructions stored on a non-transitory computer-readable medium that, when executed by one or more processors, cause the apparatus to” amount to no more than mere instructions, or generic computer/computer components to carry out the exception. For the limitations “obtain, from a collection agent module of a first terminal in a distributed system, attribute information of a changed code block as feedback when code in a file being compiled in a work area of the first terminal changes with code of a corresponding file in a base version stored in a code repository of the first terminal, wherein the attribute information comprises identity information of a changed file, a first author of the changed code block, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file” and “send, to a second terminal in the distributed system that is associated with a second author of the target code block, the warning information”, the courts have identified mere data gathering and transmitting as well-understood, routine, and conventional activity. See MPEP 2106.05(d). Accordingly, the claims are not patent eligible under 35 U.S.C. §101.
Claims 9 and 16 do not recite additional mental steps. The limitations “wherein the one or more processors are further configured to execute the instructions send the warning information by:” and “pushing, to the second terminal in the distributed system, the conflict list” amount to the insignificant extra solution activity of mere data gathering and transmission, which does not amount to a practical application under Prong 2, nor amount to significantly more under Step 2B as explained above. The limitation “storing, to a non-transitory computer readable storage medium the changed code block in a conflict list of changed code” amounts to the insignificant extra solution activity of data storage, which does not amount to practical application under Prong 2. See MPEP 2106.05(g). Under Step 2B, the limitation does not amount to significantly more, as the courts have identified storing and retrieving information in memory as well-understood, routine, and conventional activity. See MPEP 2106.05(d). The limitation “wherein the one or more processors are further configured to execute the instructions” as recited in claim 16 amounts to mere instructions to apply generic computer/computer components, which does not amount to practical application under Prong 2, nor to significantly more, as explained above.
Regarding claim 10 and 17, the limitation “wherein the warning information indicates that the target code block is modified” merely describes the contents of the warning information in mental and data transmitting steps of claims 8 and 15. Merely further describing a mental step amounts to a mental step under Prong 1. Merely further describing data transmitting step amounts to the insignificant extra solution activity of data gathering, which does not amount to practical application under Prong 2, nor to significantly more under Step 2B as explained above.
Regarding claims 11 and 18, the limitation “when the target code block overlaps a second location of a particular code block in a code analysis library” is an additional mental step. The limitation “send, to a second target terminal in the distributed system, second warning information …, wherein the particular code block is for defining a function or a variable” amounts to the insignificant extra solution activity of mere data gathering and transmission, which does not amount to a practical application under Prong 2, nor amount to significantly more under Step 2B as explained above. The limitation “wherein code compiled by the second target terminal comprises the function or the variable, and wherein the second warning information indicates that the function or the variable changes” merely further describes the code and warning of the mental and data gathering steps above, and thus does not amount to practical application under Prong 2, nor to significantly more under Step 2B, as explained above.
Regarding claims 12 and 19, the limitations “analyze, when the target code block overlaps the second location, the changed code block to determine first key information of a first object defined by the changed code block”, “determine second key information of a second object defined by the target code block, wherein the first object and the second object are functions or variables”, and “compare the first key information with the second key information to determine difference information between the first key information and the second key information, and wherein the second warning information further indicates the difference information” are additional mental steps. Claims 12 and 19 does not recite additional limitations which may amount to practical application under Prong 2, nor amount to significantly more under Step 2B.
Regarding claim 13, the limitation “wherein when the first object and the second object are the functions, the first key information and the second key information comprise a first name of the functions, a first parameter in the functions, a return value in the functions, a first start line of the functions, a first end line of the functions, a first class to which the functions belong, a first file name of the first class, a function name of a second function called by the functions, a second parameter in the second function, a second start line of the second function, a second end line of the second function, a second class to which the second function belongs, a second file name of the second class, or a type name of an invoker that invokes the second function, or when the first object and the second object are the variables, the first key information and the second key information comprise a second name of the variables, a third start line of the variables, a third end line of the variables, a type of the variables, or a variable value” merely describes the “first object” and the “second object” recited in the mental steps of claim 12. Therefore, claim 13 is directed to a mental process. Claim 13 does not recite additional limitations which may amount to practical application under Prong 2, nor amount to significantly more under Step 2B.
Regarding claims 14 and 20 do not recite additional mental steps. The limitation “wherein the one or more processors are further configured to obtain the attribute information of the changed code block that is from the collection agent module of the first terminal” amounts to the insignificant extra solution activity of mere data gathering and transmission, which does not amount to a practical application under Prong 2, nor amount to significantly more under Step 2B as explained above.

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-20 are rejected under 35 U.S.C. 103 as being unpatentable over US 20190339964 A1 (hereinafter “Young”), in view of US 20130036400 A1 (hereinafter “Bak”).

Regarding claim 1, Young discloses:
A method, comprising:
- receiving, by a server from a collection agent of a first terminal in a distributed system, attribute information of a changed code block as feedback when code in a file being compiled in a work area of the first terminal changes …, wherein the attribute information comprises …, a first author of the changed code block, (Paragraph [0003], “In response to the first edit, the processor may be further configured to transmit change set information including the first edit to a codebase host server [receiving, by a server from a collection agent]”; Paragraph [0016], “The processor 18 may be further configured to transmit first change set information 40 including the first edit 42 to the codebase host server 70. In some embodiments, the first change set information 40 may be transmitted to the codebase host server 70 in response to the processor 18 receiving the first edit 42. The first change set information 40 may further include a first edit timestamp 44 of the first edit 42, which may indicate a time at which the first edit 42 was performed at the editor window 26 or saved in the non-volatile memory 16 [attribute information of a changed code block as feedback when code in a file being compiled in a work area of the first terminal changes…]. Additionally or alternatively, the first change set information 40 may further include a first device identifier 46 of the first client computing device 10 [wherein the attribute information comprises…a first author of the changed code block]. The first device identifier 46 may indicate that the first change set information 40 is sent to the codebase host server 70 by the first client computing device 10, rather than some other computing device [of a first terminal in a distributed system]”) [Examiner’s remarks: A collection agent (the processor) on the first client computing device (first terminal) transmits code changes to a server along with attribute information in response to code being changed. Attribute information may include the device identifier which indicates the author of the changed code.]…;
…
- determining, by the server [code conflict information] (Paragraph [0018], “the codebase host server 70 may determine that a pending merge conflict exists between the first edit 42 and the second edit 72”) [Examiner’s remarks: Young discloses information regarding code conflicts being determined by a server.]…;
- generating, by the server, warning information … and when the first author is different from a second author of the target code block (Paragraph [0003], “The processor may be further configured to receive, from the codebase host server, a first conflict notification indicating that the first edit and at least a second edit to the code file have a pending merge conflict”; Paragraph [0021], “The first conflict notification 50 may further include a second device identifier 86 of the second client computing device 80. The second device identifier 86 may indicate that the second edit 72 was performed at the second client computing device 80. In some embodiments, as shown in FIG. 3, the first conflict notification 50 may further include an option 84 to transmit a second conflict notification 82 to the second client computing device 80. Similarly to the first conflict notification 50, the second conflict notification 82 may include a common code instruction indication 54 that indicates one or more code instructions 32 at which the first edit 42 and the second edit 72 intersect. The second conflict notification 82 may additionally or alternatively include the first edit timestamp 44 and/or the second edit timestamp 74. In some embodiments, the second conflict notification 82 may include the first device identifier 46 [generating, by the server, warning information … and when the first author is different from a second author of the target code block]”) [Examiner’s remarks: The server generates warning information when there are two different authors in a code conflict and may send a notification to each.]; and
- sending, by the server, the warning information to a second terminal in the distributed system that is associated with a second author of the target code block (Paragraph [0019], “In some embodiments, the second edit 72 to the code file 30 may be performed at a second client computing device 80. The second edit 72 may be performed at a second distributed source code authoring management system client 88 executed by a processor of the second computing device 80. In such embodiments, the codebase host server 70 may additionally transmit a second conflict notification 82 to the second client computing device 80”; Paragraph [0022], “In addition, the first conflict notification 50 and/or the second conflict notification 82 may facilitate communication between a first developer who made the first edit 42 and a second developer who made the second edit 72 [sending, by the server, the warning information to a second terminal in the distributed system that is associated with a second author of the target code block]”) [Examiner’s remarks: Warning information is sent to a second terminal (second computing device) with a second associated developer (author of code).].
Young does not explicitly disclose:
- …with code of a corresponding file in a base version stored in a code repository of the first terminal, wherein the attribute information comprises identity information of a changed file, …, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file;
- determining, by the server, based on the identity information, the base version of the changed file from the code repository;
- … based on the first location, whether the base version of the changed file includes a target code block that overlaps the first location, wherein the target code block overlaps the first location when at least one of the one or more first line numbers of the changed code block is included in one or more second line numbers of the target code block;
- …when the base version includes the target code block that overlaps the first location…
However, Bak discloses:
- …with code of a corresponding file in a base version stored in a code repository of the first terminal, wherein the attribute information comprises identity information of a changed file, …, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file (Paragraph [0003], “According to one embodiment, a method for pre-merge conflict avoidance may include identifying by a computer system a portion of interest of a revision-controlled base source code stored in a source-code repository, the base source code being developed by a plurality of developers; determining by the computer system whether at least one of the developers has made a change to a portion of a first copy of the base source code corresponding to the portion of interest prior to commitment of the first copy of the base source code to the source-code repository; and in response to a determination that the developer has made a change to the portion of interest, producing a notification about the change to the portion of interest by the developer [with code of a corresponding file in a base version stored in a code repository of the first terminal]”; Paragraph [0043], “RCS 80 may maintain one or more log files 112, shown in FIG. 5, that list and describe each change to the base source code. A log file 112 may detail each change by file name and line number, for example, the log file 112 thereby being an example of a source of information indicative of changes being made to the base source code by the team or plurality of developers. For example, if a developer 74 checks in a revised version of a source-code file 90 that contains an inserted line of code, then RCS 80 may write data to one or more log files 112, such as a commit log file, to document the insertion [wherein the attribute information comprises identity information of a changed file, …, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file]”) [Examiner’s remarks: changed code blocks are associated with files in a version control repository. Attribute information regarding identity (file name) and location information (line number) of changed code. It is obtained when developer checks in revised code which would be done through a terminal.];
- determining, by the server based on the identity information, the base version of the changed file from the code repository (Paragraph [0058], “As mentioned elsewhere, the check-out operation may allow a developer to designate a version and obtain a working copy of all or part of the base source code synchronized to that version. In some embodiments, during a check-out operation 100, RCS 80 may additionally register an association between developer 74 and the portion of the source code being checked out by developer 74. RCS 80 may perform this registration by default and may identify all or part of the checked-out source code as a portion of interest [determining, by the server based on the identity information, the base version of the changed file from the code repository]”) [Examiner’s remarks: The RCE may track and determine based on code information the base version that an edited code is synchronized to.];
- … based on the first location, whether the base version of the changed file includes a target code block that overlaps the first location, wherein the target code block overlaps the first location when at least one of the one or more first line numbers of the changed code block is included in one or more second line numbers of the target code block (Paragraph [0043], “RCS 80 may maintain one or more log files 112, shown in FIG. 5, that list and describe each change to the base source code. A log file 112 may detail each change by file name and line number, for example, the log file 112 thereby being an example of a source of information indicative of changes being made to the base source code by the team or plurality of developers. For example, if a developer 74 checks in a revised version of a source-code file 90 that contains an inserted line of code, then RCS 80 may write data to one or more log files 112, such as a commit log file, to document the insertion”; Paragraph [0055], “To do so, RCS 80 may, as indicated at 202 a and 202 b, identify a portion of interest of revision-controlled base source code 98 stored in repository 96 and under development by team 72 of developers 74 a-74 n. As indicated at 204 a and 204 b, RCS 80 may determine whether a developer who has checked out a copy 102 of the base source code has made a change to his or her copy within a portion of the copy corresponding to the portion of interest of the base source code”; Paragraph [0061], “The determination that triggers the notice may be the detection of changes to copies 102 a and 102 b that (if checked in) would modify the same line of the same file in the base source code. In some embodiments, RCS 80 may allow developers 74 a or 74 b to specify determinations that depend on criteria in addition to, or other than, a literal match of line numbers in file 90 a in the base source code. For example, the criteria might enable detecting changes within a range of line numbers bracketing a single line being changed (that is, RCS 80 performs a proximity match within a predetermined or specified range of lines)”; Paragraph [0049], “If development environment 60 has a client-server architecture, portions of RCS 80 may run or reside on one or more servers, and portions may run or reside on one or more client workstations 64. Those skilled in the art will understand that networked environments can express similar functionality thorough diverse architectural designs” [based on the first location, whether the base version of the changed file includes a target code block that overlaps the first location, wherein the target code block overlaps the first location when at least one of the one or more first line numbers of the changed code block is included in one or more second line numbers of the target code block]) [Examiner’s remarks: Bak discloses tracking portions of interest (target blocks) in a base code and comparing the tracked line numbers or range of line numbers with the edited code to determine if a conflict has occurred using the RCS. Bak discloses portions of the RCS being on a server. Young discloses using a server to determine conflict information. One of ordinary skill in the art may perform the conflict determination procedure of Bak on a server as proposed by Young.];
- …when the base version includes the target code block that overlaps the first location (Paragraph [0055], “To do so, RCS 80 may, as indicated at 202 a and 202 b, identify a portion of interest of revision-controlled base source code 98 stored in repository 96 and under development by team 72 of developers 74 a-74 n. As indicated at 204 a and 204 b, RCS 80 may determine whether a developer who has checked out a copy 102 of the base source code has made a change to his or her copy within a portion of the copy corresponding to the portion of interest of the base source code”; Paragraph [0061], “The determination that triggers the notice may be the detection of changes to copies 102 a and 102 b that (if checked in) would modify the same line of the same file in the base source code. In some embodiments, RCS 80 may allow developers 74 a or 74 b to specify determinations that depend on criteria in addition to, or other than, a literal match of line numbers in file 90 a in the base source code. For example, the criteria might enable detecting changes within a range of line numbers bracketing a single line being changed (that is, RCS 80 performs a proximity match within a predetermined or specified range of lines)” [when the base version includes the target code block that overlaps the first location])[Examiner’s remarks: Bak discloses triggering a notice based on overlaps in line numbers. Young discloses triggering a notification when there are different authors for a detected conflict. In combination, the invention may trigger notification when there is a code conflict with different authors based on line number.]…
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of Bak into the teachings of Young to include “with code of a corresponding file in a base version stored in a code repository of the first terminal, wherein the attribute information comprises identity information of a changed file, …, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file”, “determining, by the server, based on the identity information, the base version of the changed file from the code repository”, “based on the first location, whether the base version of the changed file includes a target code block that overlaps the first location, wherein the target code block overlaps the first location when at least one of the one or more first line numbers of the changed code block is included in one or more second line numbers of the target code block”, and “when the base version includes the target code block that overlaps the first location”. As stated in Bak, “Each developer may potentially change any file, and a change to any file may potentially trigger a need to change one or more other files. Each developer must remain alert to changes implemented by other developers that might impact his or her work, so that the developer can if necessary, make compatible changes or coordinate compatible changes with the other developers” (Paragraph [0002]). Adding the ability to compare code by location and determine if there is overlapping or changed code and informing the relevant developers reduces the amount of potential code conflict caused by incompatible merges. This saves time in both development and later testing phases. Tracking line numbers reduces the number of times code needs to be fully compared to a base version. Therefore, it would be obvious to one or ordinary skill in the art to combine a distributed system of code editors with code comparison using changed line numbers.

Regarding claim 2, the rejection of claim 1 is incorporated; and Young does not explicitly disclose:
- storing, to a non-transitory computer readable storage medium, the changed code block in a conflict list of changed code; and
- pushing, to the second terminal in the distributed system, the conflict list.
However, Bak discloses:
- storing, to a non-transitory computer readable storage medium, the changed code block in a conflict list of changed code (Paragraph [0076], “The content of notification 124 may include any data associated with the pending change, portion of interest, or source of information. For example, if a first developer has checked out and changed a portion of the source code, and if a second developer has checked out and changed an overlapping portion of the source code, then the content of the notification to one developer individually may include the common file name, one or more line numbers, the source-code change implemented by the other developer, the name, email address, and/or phone number of the other developer, and other information detailing the pending change and potential merge conflict”; Paragraph [0016], “Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing”; Paragraph [0047], “During a check-in (commitment) operation 106, RCS 80 may perform a merge operation 130 a or 130 b to propagate changes from the working copy into one or more specified trunks or branches, for example, by means of a file-comparison operation that yields a list of differences between the working copy and the base source code, so that the differences may be stored as a record of the change”) [Examiner’s remarks: Information regarding the conflict including the code block may be saved in a computer readable storage medium to be sent for notification.]; and
- pushing, to the second terminal in the distributed system, the conflict list (Paragraph [0005], “wherein producing a notification about the change to the portion of interest may include producing a respective notification for each developer that has made a change to a respective common portion of the base source code”) [Examiner’s remarks: The conflict list (change) may be pushed out to any number of terminals in a distributed system.].
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of Bak into the teachings of Young to include “storing, to a non-transitory computer readable storage medium, the changed code block in a conflict list of changed code” and “pushing, to the second terminal in the distributed system, the conflict list”. As stated in Bak, “Each developer may potentially change any file, and a change to any file may potentially trigger a need to change one or more other files. Each developer must remain alert to changes implemented by other developers that might impact his or her work, so that the developer can if necessary make compatible changes or coordinate compatible changes with the other developers” (Paragraph [0002]). The ability to store and notify users about change information allows for better collaboration on large projects by reducing the potential amount of merge conflicts. Therefore, it would be obvious to one or ordinary skill in the art to combine a distributed system of code editors with storage and notification of code changes.

Regarding claim 3, the rejection of claim 1 is incorporated; and Young further discloses:
- wherein the warning information indicates that the target code block is modified (Paragraph [0026], “The first conflict notification 50 therefore includes a common code instruction indication 54 that indicates, “Pending merge conflict at line 2.” The first conflict notification 50 further includes a first edit timestamp 44 that indicates “Last edited by you at 10:03:14, 4/6/2018.” The first conflict notification 50 further includes a second edit timestamp 74 that also includes a second device identifier 86. The second edit timestamp 74 indicates, “Last edited by Developer B at 8:15:01, 4/6/2018.” In addition, the first conflict notification 50 includes an option 84 to transmit a second conflict notification 82 to a second client computing device 80. The option 84 indicates, “Message Developer B.” When the option 84 is selected using an input device 22 of the first client computing device 10, the processor 18 may transmit the second conflict notification 82 to the second client computing device 80”) [Examiner’s remarks: The notification (warning) indicates conflicts from edits (modified code) in the target code.].

Regarding claim 4, the rejection of claim 1 is incorporated; and Young further discloses:
- further comprising sending, to a second target terminal in the distributed system, second warning information when the target code block overlaps a second location of a particular code block in a code analysis library, wherein the particular code block is for defining a function or a variable, wherein code compiled by the second target terminal comprises the function or the variable, and wherein the second warning information indicates that the function or the variable changes (Paragraph [0017], “For example, the first edit 42 may change the type of a variable, and the second edit 72 may add a line of code in which the variable is used with its type unchanged. As another example, the first edit 42 may delete the definition of a function that is called in a line added in the second edit 72. If the first edit 42 and the second edit 72 were both applied to the code file 30, one or more errors would be introduced into the code file”; Paragraph [0026], “The first conflict notification 50 therefore includes a common code instruction indication 54 that indicates, “Pending merge conflict at line 2.” … In addition, the first conflict notification 50 includes an option 84 to transmit a second conflict notification 82 to a second client computing device 80. The option 84 indicates, “Message Developer B.” When the option 84 is selected using an input device 22 of the first client computing device 10, the processor 18 may transmit the second conflict notification 82 to the second client computing device 80”) [Examiner’s remarks: The warning information may indicate that a merge conflict occurs in response to a change in variable or function at the specified line.].

Regarding claim 5, the rejection of claim 4 is incorporated; and Young further discloses:
wherein when the target code block overlaps the second location, the method further comprises (Paragraph [0017], “For example, the first edit 42 may change the type of a variable, and the second edit 72 may add a line of code in which the variable is used with its type unchanged. As another example, the first edit 42 may delete the definition of a function that is called in a line added in the second edit 72. If the first edit 42 and the second edit 72 were both applied to the code file 30, one or more errors would be introduced into the code file [wherein when the target code block overlaps the second location, the method further comprises]:
- analyzing the changed code block to determine first key information of a first object defined by the changed code block (Paragraph [0017], “The pending merge conflict may be a potential merge conflict between the first edit 42 and the second edit 72 detected by the codebase host server 70. For example, the first edit 42 may change the type of a variable, and the second edit 72 may add a line of code in which the variable is used with its type unchanged. As another example, the first edit 42 may delete the definition of a function that is called in a line added in the second edit 72. If the first edit 42 and the second edit 72 were both applied to the code file 30, one or more errors would be introduced into the code file [analyzing the changed code block to determine first key information of a first object defined by the changed code block]”) [Examiner’s remarks: The first edit is analyzed for key information (definition of a function, type of variable used) to determine is a conflict is caused with the second code.];
- determining second key information of a second object defined by the target code block, wherein the first object and the second object are functions or variables (Paragraph [0017], “The pending merge conflict may be a potential merge conflict between the first edit 42 and the second edit 72 detected by the codebase host server 70. For example, the first edit 42 may change the type of a variable, and the second edit 72 may add a line of code in which the variable is used with its type unchanged. As another example, the first edit 42 may delete the definition of a function that is called in a line added in the second edit 72. If the first edit 42 and the second edit 72 were both applied to the code file 30, one or more errors would be introduced into the code file [determining second key information of a second object defined by the target code block, wherein the first object and the second object are functions or variables]”) [Examiner’s remarks: The second edit is analyzed for key information (definition of a function, type of variable used) to determine is a conflict is caused with the first code.]; and
- comparing the first key information with the second key information to determine difference information between the first key information and the second key information, and wherein the second warning information further indicates the difference information (Paragraph [0017], “The pending merge conflict may be a potential merge conflict between the first edit 42 and the second edit 72 detected by the codebase host server 70. For example, the first edit 42 may change the type of a variable, and the second edit 72 may add a line of code in which the variable is used with its type unchanged. As another example, the first edit 42 may delete the definition of a function that is called in a line added in the second edit 72. If the first edit 42 and the second edit 72 were both applied to the code file 30, one or more errors would be introduced into the code file”; Paragraph [0018], “The processor 18 of the first client computing device 10 may be further configured to receive, from the codebase host server 70, a first conflict notification 50 indicating that the first edit 42 and at least the second edit 72 to the code file 30 have a pending merge conflict [comparing the first key information with the second key information to determine difference information between the first key information and the second key information, and wherein the second warning information further indicates the difference information]”) [Examiner’s remarks: The key information of the first code and second code are analyzed to see if a conflict is caused. If a conflict is cause, then a conflict notification is created indicating that there is a conflict between the edits (difference information).].

Regarding claim 6, the rejection of claim 5 is incorporated; and Young further discloses:
- wherein when the first object and the second object are the functions, the first key information and the second key information comprise a first name of the functions, a first parameter in the functions, a return value in the functions, a first start line of the functions, a first end line of the functions, a first class to which the functions belong, a first file name of the first class, a function name of a second function called by the functions, a second parameter in the second function, a second start line of the second function, a second end line of the second function, a second class to which the second function belongs, a second file name of the second class, or a type name of an invoker that invokes the second function, or when the first object and the second object are the variables, the first key information and the second key information comprise a second name of the variables, a third start line of the variables, a third end line of the variables, or a type of the variables (Paragraph [0017], “As another example, the first edit 42 may delete the definition of a function that is called in a line added in the second edit 72. If the first edit 42 and the second edit 72 were both applied to the code file 30, one or more errors would be introduced into the code file”) [Examiner’s remarks: The first code object and the second object are functions, and the key information is the function name (may delete the definition of a function).].

Regarding claim 7, the rejection of claim 1 is incorporated; and Young further discloses:
- wherein obtaining the attribute information comprises obtaining the attribute information of the changed code block that is from the collection agent of the first terminal (Paragraph [0016], “The processor 18 may be further configured to transmit first change set information 40 including the first edit 42 to the codebase host server 70. In some embodiments, the first change set information 40 may be transmitted to the codebase host server 70 in response to the processor 18 receiving the first edit 42. The first change set information 40 may further include a first edit timestamp 44 of the first edit 42, which may indicate a time at which the first edit 42 was performed at the editor window 26 or saved in the non-volatile memory 16. Additionally or alternatively, the first change set information 40 may further include a first device identifier 46 of the first client computing device 10. The first device identifier 46 may indicate that the first change set information 40 is sent to the codebase host server 70 by the first client computing device 10, rather than some other computing device [wherein obtaining the attribute information comprises obtaining the attribute information of the changed code block that is from a collection agent module of the first terminal]”) [Examiner’s remarks: The processor (collection agent) in the terminal obtains attribute information (author information, client device identifier, code information).].

Regarding claim 8, Young discloses:
An apparatus, comprising:
a memory configured to store instructions (Paragraph [0012]); and
one or more processors coupled to the memory and configured to execute the instructions to (Paragraph [0012]):
obtain, from a collection agent module of a first terminal in a distributed system, attribute information of a changed code block as feedback when code in a file being compiled in a work area of the first terminal changes …, wherein the attribute information comprises …, a first author of the changed code block (Paragraph [0003], “In response to the first edit, the processor may be further configured to transmit change set information including the first edit to a codebase host server [obtain, from a collection agent module of]”; Paragraph [0016], “The processor 18 may be further configured to transmit first change set information 40 including the first edit 42 to the codebase host server 70. In some embodiments, the first change set information 40 may be transmitted to the codebase host server 70 in response to the processor 18 receiving the first edit 42. The first change set information 40 may further include a first edit timestamp 44 of the first edit 42, which may indicate a time at which the first edit 42 was performed at the editor window 26 or saved in the non-volatile memory 16 [attribute information of a changed code block as feedback when code in a file being compiled in a work area of the first terminal changes …, wherein the attribute information comprises …, a first author of the changed code block]. Additionally or alternatively, the first change set information 40 may further include a first device identifier 46 of the first client computing device 10 [wherein the attribute information comprises…a first author of the changed code block]. The first device identifier 46 may indicate that the first change set information 40 is sent to the codebase host server 70 by the first client computing device 10, rather than some other computing device [of a first terminal in a distributed system]”) [Examiner’s remarks: A collection agent (the processor) on the first client computing device (first terminal) transmits code changes to a server along with attribute information in response to code being changed. Attribute information may include the device identifier which indicates the author of the changed code.] …;
…
generate warning information … and when the first author is different from a second author of the target code block (Paragraph [0003], “The processor may be further configured to receive, from the codebase host server, a first conflict notification indicating that the first edit and at least a second edit to the code file have a pending merge conflict”; Paragraph [0021], “The first conflict notification 50 may further include a second device identifier 86 of the second client computing device 80. The second device identifier 86 may indicate that the second edit 72 was performed at the second client computing device 80. In some embodiments, as shown in FIG. 3, the first conflict notification 50 may further include an option 84 to transmit a second conflict notification 82 to the second client computing device 80. Similarly to the first conflict notification 50, the second conflict notification 82 may include a common code instruction indication 54 that indicates one or more code instructions 32 at which the first edit 42 and the second edit 72 intersect. The second conflict notification 82 may additionally or alternatively include the first edit timestamp 44 and/or the second edit timestamp 74. In some embodiments, the second conflict notification 82 may include the first device identifier 46 [generate warning information … and when the first author is different from a second author of the target code block]”) [Examiner’s remarks: The server generates warning information when there are two different authors in a code conflict and may send a notification to each.]; and
send, to a second terminal in the distributed system that is associated with a second author of the target code block, the warning information (Paragraph [0019], “In some embodiments, the second edit 72 to the code file 30 may be performed at a second client computing device 80. The second edit 72 may be performed at a second distributed source code authoring management system client 88 executed by a processor of the second computing device 80. In such embodiments, the codebase host server 70 may additionally transmit a second conflict notification 82 to the second client computing device 80”; Paragraph [0022], “In addition, the first conflict notification 50 and/or the second conflict notification 82 may facilitate communication between a first developer who made the first edit 42 and a second developer who made the second edit 72 send, to a second terminal in the distributed system that is associated with a second author of the target code block, the warning information]”) [Examiner’s remarks: Warning information is sent to a second terminal (second computing device) with a second associated developer (author of code).].
Young does not explicitly disclose:
- …with code of a corresponding file in a base version stored in a code repository of the first terminal, wherein the attribute information comprises identity information of a changed file, …, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file;
- determine, based on the identity information, the base version of the changed file from the code repository;
- determine, based on the first location, whether the base version of the changed file includes a target code block that overlaps the first location, wherein the target code block overlaps the first location when at least one of the one or more first line numbers of the changed code block is included in one or more second line numbers of the target code block;
- … when the base version includes the target code block that overlaps the first location…
However, Bak discloses:
- …with code of a corresponding file in a base version stored in a code repository of the first terminal, wherein the attribute information comprises identity information of a changed file, …, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file (Paragraph [0003], “According to one embodiment, a method for pre-merge conflict avoidance may include identifying by a computer system a portion of interest of a revision-controlled base source code stored in a source-code repository, the base source code being developed by a plurality of developers; determining by the computer system whether at least one of the developers has made a change to a portion of a first copy of the base source code corresponding to the portion of interest prior to commitment of the first copy of the base source code to the source-code repository; and in response to a determination that the developer has made a change to the portion of interest, producing a notification about the change to the portion of interest by the developer [with code of a corresponding file in a base version stored in a code repository of the first terminal]”; Paragraph [0043], “RCS 80 may maintain one or more log files 112, shown in FIG. 5, that list and describe each change to the base source code. A log file 112 may detail each change by file name and line number, for example, the log file 112 thereby being an example of a source of information indicative of changes being made to the base source code by the team or plurality of developers. For example, if a developer 74 checks in a revised version of a source-code file 90 that contains an inserted line of code, then RCS 80 may write data to one or more log files 112, such as a commit log file, to document the insertion [wherein the attribute information comprises identity information of a changed file, …, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file]”) [Examiner’s remarks: changed code blocks are associated with files in a version control repository. Attribute information regarding identity (file name) and location information (line number) of changed code. It is obtained when developer checks in revised code which would be done through a terminal.];
- determine, based on the identity information, the base version of the changed file from the code repository (Paragraph [0058], “As mentioned elsewhere, the check-out operation may allow a developer to designate a version and obtain a working copy of all or part of the base source code synchronized to that version. In some embodiments, during a check-out operation 100, RCS 80 may additionally register an association between developer 74 and the portion of the source code being checked out by developer 74. RCS 80 may perform this registration by default and may identify all or part of the checked-out source code as a portion of interest [determine, based on the identity information, the base version of the changed file from the code repository]”) [Examiner’s remarks: The RCS may track and determine based on code information the base version that an edited code is synchronized to.];
- determine, based on the first location, whether the base version of the changed file includes a target code block that overlaps the first location, wherein the target code block overlaps the first location when at least one of the one or more first line numbers of the changed code block is included in one or more second line numbers of the target code block (Paragraph [0043], “RCS 80 may maintain one or more log files 112, shown in FIG. 5, that list and describe each change to the base source code. A log file 112 may detail each change by file name and line number, for example, the log file 112 thereby being an example of a source of information indicative of changes being made to the base source code by the team or plurality of developers. For example, if a developer 74 checks in a revised version of a source-code file 90 that contains an inserted line of code, then RCS 80 may write data to one or more log files 112, such as a commit log file, to document the insertion”; Paragraph [0055], “To do so, RCS 80 may, as indicated at 202 a and 202 b, identify a portion of interest of revision-controlled base source code 98 stored in repository 96 and under development by team 72 of developers 74 a-74 n. As indicated at 204 a and 204 b, RCS 80 may determine whether a developer who has checked out a copy 102 of the base source code has made a change to his or her copy within a portion of the copy corresponding to the portion of interest of the base source code”; Paragraph [0061], “The determination that triggers the notice may be the detection of changes to copies 102 a and 102 b that (if checked in) would modify the same line of the same file in the base source code. In some embodiments, RCS 80 may allow developers 74 a or 74 b to specify determinations that depend on criteria in addition to, or other than, a literal match of line numbers in file 90 a in the base source code. For example, the criteria might enable detecting changes within a range of line numbers bracketing a single line being changed (that is, RCS 80 performs a proximity match within a predetermined or specified range of lines)”; Paragraph [0049], “If development environment 60 has a client-server architecture, portions of RCS 80 may run or reside on one or more servers, and portions may run or reside on one or more client workstations 64. Those skilled in the art will understand that networked environments can express similar functionality thorough diverse architectural designs” [determine, based on the first location, whether the base version of the changed file includes a target code block that overlaps the first location, wherein the target code block overlaps the first location when at least one of the one or more first line numbers of the changed code block is included in one or more second line numbers of the target code block]) [Examiner’s remarks: Bak discloses tracking portions of interest (target blocks) in a base code and comparing the tracked line numbers or range of line numbers with the edited code to determine if a conflict has occurred using the RCS. Bak discloses portions of the RCS being on a server. Young discloses using a server to determine conflict information. One of ordinary skill in the art may perform the conflict determination procedure of Bak on a server as proposed by Young.];
- … when the base version includes the target code block that overlaps the first location (Paragraph [0055], “To do so, RCS 80 may, as indicated at 202 a and 202 b, identify a portion of interest of revision-controlled base source code 98 stored in repository 96 and under development by team 72 of developers 74 a-74 n. As indicated at 204 a and 204 b, RCS 80 may determine whether a developer who has checked out a copy 102 of the base source code has made a change to his or her copy within a portion of the copy corresponding to the portion of interest of the base source code”; Paragraph [0061], “The determination that triggers the notice may be the detection of changes to copies 102 a and 102 b that (if checked in) would modify the same line of the same file in the base source code. In some embodiments, RCS 80 may allow developers 74 a or 74 b to specify determinations that depend on criteria in addition to, or other than, a literal match of line numbers in file 90 a in the base source code. For example, the criteria might enable detecting changes within a range of line numbers bracketing a single line being changed (that is, RCS 80 performs a proximity match within a predetermined or specified range of lines)” [when the base version includes the target code block that overlaps the first location])[Examiner’s remarks: Bak discloses triggering a notice based on overlaps in line numbers. Young discloses triggering a notification when there are different authors for a detected conflict. In combination, the invention may trigger notification when there is a code conflict with different authors based on line number.] …
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of Bak into the teachings of Young to include “…with code of a corresponding file in a base version stored in a code repository of the first terminal, wherein the attribute information comprises identity information of a changed file, …, and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file”, “determine, based on the identity information, the base version of the changed file from the code repository”, “determine, based on the first location, whether the base version of the changed file includes a target code block that overlaps the first location, wherein the target code block overlaps the first location when at least one of the one or more first line numbers of the changed code block is included in one or more second line numbers of the target code block”, and “when the base version includes the target code block that overlaps the first location…”. As stated in Bak, “Each developer may potentially change any file, and a change to any file may potentially trigger a need to change one or more other files. Each developer must remain alert to changes implemented by other developers that might impact his or her work, so that the developer can if necessary, make compatible changes or coordinate compatible changes with the other developers” (Paragraph [0002]). Adding the ability to compare code by location and determine if there is overlapping or changed code and informing the relevant developers reduces the amount of potential code conflict caused by incompatible merges. This saves time in both development and later testing phases. Tracking line numbers reduces the number of times code needs to be fully compared to a base version. Therefore, it would be obvious to one or ordinary skill in the art to combine a distributed system of code editors with code comparison using changed line numbers.

Regarding claim 9, the rejection of claim 8 is incorporated; and Young does not explicitly disclose:
storing, to a non-transitory computer readable storage medium, the changed code block in a conflict list of changed code; and
pushing, to the second terminal in the distributed system, the conflict list.
However, Bak discloses:
- storing, to a non-transitory computer readable storage medium, the changed code block in a conflict list of changed code (Paragraph [0076], “The content of notification 124 may include any data associated with the pending change, portion of interest, or source of information. For example, if a first developer has checked out and changed a portion of the source code, and if a second developer has checked out and changed an overlapping portion of the source code, then the content of the notification to one developer individually may include the common file name, one or more line numbers, the source-code change implemented by the other developer, the name, email address, and/or phone number of the other developer, and other information detailing the pending change and potential merge conflict”; Paragraph [0016], “Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing”) [Examiner’s remarks: Information regarding the conflict including the code block may be saved in a computer readable storage medium to be sent for notification.]; and
- pushing, to the second terminal in the distributed system, the conflict list (Paragraph [0005], “wherein producing a notification about the change to the portion of interest may include producing a respective notification for each developer that has made a change to a respective common portion of the base source code”) [Examiner’s remarks: The conflict list (change) may be pushed out to any number of terminals in a distributed system.].
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teachings of Bak into the teachings of Young to include “storing, to a non-transitory computer readable storage medium, the changed code block in a conflict list of changed code” and “pushing, to the second terminal in the distributed system, the conflict list”. As stated in Bak, “Each developer may potentially change any file, and a change to any file may potentially trigger a need to change one or more other files. Each developer must remain alert to changes implemented by other developers that might impact his or her work, so that the developer can if necessary make compatible changes or coordinate compatible changes with the other developers” (Paragraph [0002]). The ability to store and notify users about change information allows for better collaboration on large projects by reducing the potential amount of merge conflicts. Therefore, it would be obvious to one or ordinary skill in the art to combine a distributed system of code editors with storage and notification of code changes.

Regarding claim 10, the rejection of claim 8 is incorporated; and Young further discloses:
- wherein the warning information indicates that the target code block is modified (Paragraph [0026], “The first conflict notification 50 therefore includes a common code instruction indication 54 that indicates, “Pending merge conflict at line 2.” The first conflict notification 50 further includes a first edit timestamp 44 that indicates “Last edited by you at 10:03:14, 4/6/2018.” The first conflict notification 50 further includes a second edit timestamp 74 that also includes a second device identifier 86. The second edit timestamp 74 indicates, “Last edited by Developer B at 8:15:01, 4/6/2018.” In addition, the first conflict notification 50 includes an option 84 to transmit a second conflict notification 82 to a second client computing device 80. The option 84 indicates, “Message Developer B.” When the option 84 is selected using an input device 22 of the first client computing device 10, the processor 18 may transmit the second conflict notification 82 to the second client computing device 80”) [Examiner’s remarks: The notification (warning) indicates conflicts from edits (modified code) in the target code.].

Regarding claim 11, the rejection of claim 10 is incorporated; and Young further discloses:
wherein the one or more processors are further configured to execute the instructions to send, to a second target terminal in the distributed system, second warning information when the target code block overlaps a second location of a particular code block in a code analysis library, wherein the particular code block is for defining a function or a variable, wherein code compiled by the second target terminal comprises the function or the variable, and wherein the second warning information indicates that the function or the variable changes (Paragraph [0017], “For example, the first edit 42 may change the type of a variable, and the second edit 72 may add a line of code in which the variable is used with its type unchanged. As another example, the first edit 42 may delete the definition of a function that is called in a line added in the second edit 72. If the first edit 42 and the second edit 72 were both applied to the code file 30, one or more errors would be introduced into the code file”; Paragraph [0026], “The first conflict notification 50 therefore includes a common code instruction indication 54 that indicates, “Pending merge conflict at line 2.” … In addition, the first conflict notification 50 includes an option 84 to transmit a second conflict notification 82 to a second client computing device 80. The option 84 indicates, “Message Developer B.” When the option 84 is selected using an input device 22 of the first client computing device 10, the processor 18 may transmit the second conflict notification 82 to the second client computing device 80”) [Examiner’s remarks: The warning information may indicate that a merge conflict occurs in response to a change in variable or function at the specified line.].

Regarding claim 12, the rejection of claim 11 is incorporated; and Young further discloses:
- analyze, when the target code block overlaps the second location, the changed code block to determine first key information of a first object defined by the changed code block (Paragraph [0017], “The pending merge conflict may be a potential merge conflict between the first edit 42 and the second edit 72 detected by the codebase host server 70. For example, the first edit 42 may change the type of a variable, and the second edit 72 may add a line of code in which the variable is used with its type unchanged. As another example, the first edit 42 may delete the definition of a function that is called in a line added in the second edit 72. If the first edit 42 and the second edit 72 were both applied to the code file 30, one or more errors would be introduced into the code file [analyze, when the target code block overlaps the second location, the changed code block to determine first key information of a first object defined by the changed code block]”) [Examiner’s remarks: The first code and second code overlap at a location (second location). The first edit is analyzed for key information (definition of a function, type of variable used) to determine is a conflict is caused with the second code.];
- determine second key information of a second object defined by the target code block, wherein the first object and the second object are functions or variables (Paragraph [0017], “The pending merge conflict may be a potential merge conflict between the first edit 42 and the second edit 72 detected by the codebase host server 70. For example, the first edit 42 may change the type of a variable, and the second edit 72 may add a line of code in which the variable is used with its type unchanged. As another example, the first edit 42 may delete the definition of a function that is called in a line added in the second edit 72. If the first edit 42 and the second edit 72 were both applied to the code file 30, one or more errors would be introduced into the code file [determine second key information of a second object defined by the target code block, wherein the first object and the second object are functions or variables]”) [Examiner’s remarks: The second edit is analyzed for key information (definition of a function, type of variable used) to determine is a conflict is caused with the first code.]; and
- compare the first key information with the second key information to determine difference information between the first key information and the second key information, and wherein the second warning information further indicates the difference information (Paragraph [0017], “The pending merge conflict may be a potential merge conflict between the first edit 42 and the second edit 72 detected by the codebase host server 70. For example, the first edit 42 may change the type of a variable, and the second edit 72 may add a line of code in which the variable is used with its type unchanged. As another example, the first edit 42 may delete the definition of a function that is called in a line added in the second edit 72. If the first edit 42 and the second edit 72 were both applied to the code file 30, one or more errors would be introduced into the code file”; Paragraph [0018], “The processor 18 of the first client computing device 10 may be further configured to receive, from the codebase host server 70, a first conflict notification 50 indicating that the first edit 42 and at least the second edit 72 to the code file 30 have a pending merge conflict [compare the first key information with the second key information to determine difference information between the first key information and the second key information, and wherein the second warning information further indicates the difference information]”) [Examiner’s remarks: The key information of the first code and second code are analyzed to see if a conflict is caused. If a conflict is cause, then a conflict notification is created indicating that there is a conflict between the edits (difference information).].

Regarding claim 13, the rejection of claim 12 is incorporated; and Young further discloses:
wherein when the first object and the second object are the functions, the first key information and the second key information comprise a first name of the functions, a first parameter in the functions, a return value in the functions, a first start line of the functions, a first end line of the functions, a first class to which the functions belong, a first file name of the first class, a function name of a second function called by the functions, a second parameter in the second function, a second start line of the second function, a second end line of the second function, a second class to which the second function belongs, a second file name of the second class, or a type name of an invoker that invokes the second function, or when the first object and the second object are the variables, the first key information and the second key information comprise a second name of the variables, a third start line of the variables, a third end line of the variables, a type of the variables, or a variable value (Paragraph [0017], “As another example, the first edit 42 may delete the definition of a function that is called in a line added in the second edit 72. If the first edit 42 and the second edit 72 were both applied to the code file 30, one or more errors would be introduced into the code file”) [Examiner’s remarks: The first code object and the second object are functions, and the key information is the function name (may delete the definition of a function).].

Regarding claim 14, the rejection of claim 8 is incorporated; and Young further discloses:
- wherein the one or more processors are further configured to obtain the attribute information of the changed code block that is from the collection agent module of the first terminal (Paragraph [0016], “The processor 18 may be further configured to transmit first change set information 40 including the first edit 42 to the codebase host server 70. In some embodiments, the first change set information 40 may be transmitted to the codebase host server 70 in response to the processor 18 receiving the first edit 42. The first change set information 40 may further include a first edit timestamp 44 of the first edit 42, which may indicate a time at which the first edit 42 was performed at the editor window 26 or saved in the non-volatile memory 16. Additionally or alternatively, the first change set information 40 may further include a first device identifier 46 of the first client computing device 10. The first device identifier 46 may indicate that the first change set information 40 is sent to the codebase host server 70 by the first client computing device 10, rather than some other computing device [wherein the one or more processors are further configured to obtain the attribute information of the changed code block that is from the collection agent module of the first terminal]”) [Examiner’s remarks: The processor (collection agent) in the terminal obtains attribute information (author information, client device identifier, code information).].

Claims 15-20 are computer program product claims corresponding to the apparatus claims hereinabove (claims 8-12 and 14, respectively). Therefore, claims 15-20 are rejected for the same reasons as set forth in the rejections of claims 8-12 and 14, respectively.

Response to Arguments
Applicant's arguments filed January 16, 2026 have been fully considered but they are not persuasive.

In the Remarks, Applicant Argues:
As shown above, amended claim 1 recites a method comprising five steps performed by a server in a distributed system. In the first step, the server receives attribute information from a collection agent module of a first terminal as feedback when code in a file being compiled in a work area changes with code of a corresponding file in a base version stored in a code repository. The attribute information comprises identity information of the changed file, a first author of the changed code block, and a first location comprising one or more first line numbers. In the second step, the server determines the base version of the changed file from the code repository based on the identity information. In the third step, the server determines whether the base version of the changed file includes a target code block that overlaps the first location based on the first location of the changed code block. In the fourth step, the server generates warning information when the base version includes a target code block that overlaps the first location and when the first author is different from a second author of the target code block. In the fifth step, the server sends the generated warning information to a second terminal associated with the second author of the target code block. Claims 8 and 11 are amended to include similar elements. The system provides improved code conflict management in distributed development environments by detecting potential conflicts during active development, specifically while code is being compiled in a work area rather than only at merge time when conflicts have accumulated. By determining whether base versions include overlapping target code blocks and then routing warning information to the specific terminals associated with original code authors, the system enables developers to evaluate and address potential conflicts before they propagate to shared repositories. See Application, paragraphs 5-10, 17-20, 42-48. The claimed system operates during active code development rather than at merge time. The collection agent module of each terminal collects code, for example according to a preset rule, which may be time- based using a timer with a preset time period, threshold-based when a quantity of modified code lines reaches a preset value, or event-based when the file being compiled is closed. See Application, paragraphs 43-47. When the collection agent module determines that code changes with code of a corresponding file in a base version, the collection agent feeds back the change to the server. See Application, paragraph 42. This event-driven, rule-based architecture enables the server to receive attribute information and detect potential conflicts while code is being compiled in a work area and before the changed code is committed to a shared repository. The system then routes generated warning information to terminals associated with original code authors, because "an author of an original code block (that is, the target code block) is more familiar with the target code block" and "can more quickly determine whether a problem occurs when another programmer modifies the code block." See Application, paragraph 18. Importantly, the claimed system cannot function without the coordinated operation of multiple distributed components. The collection agent modules of the terminals must collect code being compiled in their respective work areas and determine whether the code changes with code of corresponding files in base versions stored in local code repositories. See Application, paragraphs 42-44. When changes are detected, the collection agent modules must communicate the attribute information, including the changed file identity, the author of the changed code block, and the line number location, back to the server. See Application, paragraph 48. The server, in turn, must be centralized to coordinate this information, determine base versions from code repositories, determine whether base versions include overlapping target code blocks, generate warning information, and route the generated warning information to the appropriate author terminals. See Application, paragraphs 34-41, 81-82. This architecture is inherently distributed and requires machine-to-machine communication across a network. The collection agent modules cannot mentally "feed back" attribute information to a server, and a human mind cannot serve as a centralized coordinator receiving change information from multiple terminals, determining base versions from code repositories, generating warning information, and routing warnings to specific author terminals across a distributed system. This architecture, which comprises collection agent modules operating according to preset rules, change-triggered attribute information transmission, server-side base version determination from code repositories, overlap analysis, warning information generation, and author-aware notification routing to distributed terminals, provides conflict detection during active development through the coordinated operation of distributed system components. The system is directed to a particular improvement in distributed version control, and is not merely line number comparison steps which may be performed mentally by an individual as asserted by the Office Action. Therefore, independent claims 1, 8, and 15 are not directed to an abstract idea, and consequently claims 1-20 are not directed to an abstract idea.

Examiner’s Response:
Examiner respectfully disagrees. Applicant argues that “The system is directed to a particular improvement in distributed version control, and is not merely line number comparison steps which may be performed mentally by an individual as asserted by the Office Action”. However, the claims as written, comprise the determining a base version of code, determining whether there is an overlap at a specified line, and generating warning information. These limitations, under their broadest reasonable interpretation, may be done by a human mind, with the aid of pen and paper. These limitations are therefore rejected under Prong 1 for being directed to the abstract idea of a mental step and does not move on to Prong 2 consideration for particular improvement. The remaining two limitations merely recite receiving information and sending information to a server, which is rejected under Prong 2 and Step 2B for merely receiving and transmitting data which does not integrate into practical application nor amount to significantly more. See MPEP 2106.05(g) and MPEP 2106.05(d). Furthermore, the claims merely recite instructions to apply a generic server which is a generic computer component and does not amount to practical application nor to significantly more. See MPEP 2106.05(f). Therefore, the rejection under 35 U.S.C. 101 is maintained.

In the Remarks, Applicant Argues:
Second and in the alternative, claims 1-20 provide limitations directed to a practical application of an abstract idea because claims 1-20: (1) add a specific limitation other than what is well-understood, routine, and conventional in the field; (2) provide an improvement to a technological field; and (3) are necessarily rooted in computer technology to overcome a problem specifically arising in the context of computers. See 2019 Revised Patent Subject Matter Eligibility Guidance, Document No. PTO-P-2018-0053 (January 7, 2019). First, as discussed below, claims 1, 8, and 15, and accordingly their dependent claims, include the specific limitation of change-triggered attribute information reception from a collection agent module operating on files being compiled in a work area, server-side determination of base versions from code repositories based on identity information, determination of whether base versions include overlapping target code blocks based on line number comparison, generation of warning information when overlap exists and authors differ, and author-aware notification routing that sends the generated warning information to terminals associated with original code authors. This architecture is not well-understood, routine, or conventional in the field, as conventional version control systems detect conflicts only at merge time after conflicts have accumulated, rather than during active development with targeted author-based notification.

Examiner’s Response:
Examiner respectfully disagrees. The claims, as drafted, does not describe a limitation which is not well-known, routine, and conventional. The limitations regarding determining a base version, determining whether lines of code blocks overlap, and generating a warning when an overlap exists and authors differ are mental steps. The addition of them being performed on a server comprises mere instructions to apply a generic computer/computer component (a server) to the judicial exception. The remaining steps, as drafted, merely recite sending information to a server and receiving information from a server, which are both merely data gathering and transmitting steps. Mere data gathering and transmission is an insignificant extra solution activity which is considered well-known, routine, and conventional. See MPEP 2106.05(g) and 2106.05(f). Therefore, the claims do not overcome the present rejection under 35 U.S.C. 101.

In the Remarks, Applicant Argues:
Second, claims 1-20 provide for an improvement in a technological field. The claims 1-20 improve distributed version control technology by detecting potential code conflicts during active development, while code is being compiled in a work area and before code is committed to shared repositories, and routing generated warning information to the specific developers whose code is affected. The original authors are more familiar with the target code blocks and best positioned to evaluate whether modifications create problems. This prevents the accumulation of merge conflicts that cause "great inconvenience to combination and resolution for a later version" as identified in the specification at paragraph 3.

Examiner’s Response:
Although Examiner does not dispute that the invention provides the described improvement, Examiner notes that MPEP 2106.04(d).III. states “Because a judicial exception alone is not eligible subject matter, if there are no additional claim elements besides the judicial exception, or if the additional claim elements merely recite another judicial exception, that is insufficient to integrate the judicial exception into a practical application”, i.e. that an improvement provided solely by improving an abstract idea itself is ineligible. Examiner further notes that most limitations within claim 1 have been identified as reflecting an abstract idea, such as through evaluation of the base version of an edited code, whether lines in the base code overlap with lines of edited code, and warning information, and the remaining limitations, including the new limitations, are mere instructions to apply the recited exceptions, by using a server, or amount to mere data gathering, as described in the 101 rejections above.

In the Remarks, Applicant Argues:
Third, in DDR Holdings, the Federal Circuit differentiated the claims from those that "merely recite the performance of some business practice known from the pre-Internet world along with the requirement to perform it on the Internet." DDR Holdings, LLC v. Hotels.com, L.P., No. 13-1505 (Fed. Cir. Dec. 5, 2014). Instead, it found the claims to be "necessarily rooted in computer technology in order to overcome a problem specifically arising in the realm of computer networks." Id., at 1257. As explained above, the claims are implemented using a distributed system architecture with collection agent modules on developer terminals that detect changes in work areas against base versions in code repositories, server-side determination of base versions, overlap analysis, warning information generation, and targeted notification routing to author-associated terminals. The claims are therefore necessarily rooted in computer technology in order to overcome the problem of accumulated code conflicts specifically arising in distributed software development environments where multiple programmers develop code separately. This problem is solved through a specific technical architecture where collection agent modules feed back attribute information to a server when code changes are detected, the server determines base versions from code repositories, determines whether base versions include overlapping target code blocks, generates warning information, and routes the generated warning information to terminals associated with original code authors, thereby enabling conflict detection during active development rather than only at merge time. As such, claims 1-20 are directed to a practical application, and thus the Applicant respectfully requests that the rejections under 35 U.S.C.§ 101 be withdrawn.

Examiner’s Response:
Examiner respectfully disagrees. In DDR Holdings, LLC. v. Hotels.com, L.P., 773 F.3d 1245, 1257, 113 USPQ2d 1097, 1105 (Fed. Cir. 2014) (hereinafter “DDR Holdings”), the court stated that “[the system] instructs an Internet web server of an ‘outsource provider’ to construct and serve to the visitor a new, hybrid web page that merges content associated with the products of the third-party merchant with the stored ‘visually perceptible elements’ from the identified host website.” The court also noted that, while claims “directed to nothing more than the performance of an abstract business practice on the Internet or using a conventional computer” are ineligible under § 101, the claims at issue in that case were not directed to an abstract idea because they were “necessarily rooted in computer technology in order to overcome a problem specifically arising in the realm of computer networks.”
Thus, in DDR Holdings, it was clear that the claims at issue could not be performed without the use of a computer because they require the manipulation of computer functionalities, such as constructing and serving to a visitor a new, hybrid web page that merges content associated with products of a third-party merchant with stored elements from a host website.
In contrast, it is clear in the present case that one could mentally/manually perform (with the aid of pen and paper) the various determining and generating steps of Claim 1, for example. Under the broadest reasonable interpretation, one could, as a practical matter, perform these steps because they do not require any manipulation of underlying computer operations/functionalities. Furthermore, the recitation of the limitations pertaining to an a server sending and receiving information from client systems under certain conditions do not require any manipulation of underlying computer operations/functionalities. Thus, Claim 1 is not analogous to DDR Holdings because unlike DDR Holdings, the limitations of Claim 1 considered individually or as an ordered combination, improve the technique of determining code conflicts not the technology involved in providing it and therefore, are not indicative of improving underlying computer operations/functionalities.
Therefore, for at least the reasons set forth above, the rejections made under 35 U.S.C. § 101 with respect to Claims 1, 11, and 20 are proper and therefore, maintained.

In the Remarks, Applicant Argues:
As shown, claim 1 requires [receiving, by a server from a collection agent of a
first terminal in a distributed system, attribute information as feedback. Claim 1 also requires the
attribute information is of a changed code block when code in a file being compiled in a work area
of the first terminal changes with code of a corresponding file in a base version stored in a code
repository of the first terminal. The limitations are supported in the specification, for example, in
paragraphs 42-44 and 48. Independent claims 8 and 15 also includes the same limitations. The
Office Action acknowledges that Young does not teach "obtaining, from a first terminal in a distributed system, attribute information of a changed code block, wherein the attribute information comprises identity information of a changed file and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file" (Office Action, page 9). Specifically, Young does not feed back attribute information to a server by a collection agent module on a terminal, and does trigger the detection based on code being compiled in a work area. Thus, Young fails to disclose receiving, by a server from a collection agent of a first terminal in a distributed system, attribute information of a changed code block as feedback when code in a file being compiled in a work area of the first terminal changes with code of a corresponding file in a base version stored in a code repository of the first terminal.

Examiner’s Response:
Examiner respectfully disagrees. While Examiner acknowledges that prior Office Action acknowledges that Young does not teach "obtaining, from a first terminal in a distributed system, attribute information of a changed code block, wherein the attribute information comprises identity information of a changed file and a first location of the changed code block in the changed file, and wherein the first location comprises one or more first line numbers of the changed code block in the changed file", this teaching refers to the claim in its entirety. In the present rejection, Young is used only to disclose obtaining attribute information from a first terminal, where the attribute information includes the first author of the changed code block. Young discloses a collection agent (processor of a first terminal) sending information to a server in response to code being changed on the first terminal. Therefore, Young, in combination with Bak, discloses receiving, by a server from a collection agent of a first terminal in a distributed system, attribute information of a changed code block as feedback when code in a file being compiled in a work area of the first terminal changes with code of a corresponding file in a base version stored in a code repository of the first terminal.

In the Remarks, Applicant Argues:
Bak also fails to disclose this limitation. Bak monitors, using a revision control system (RCS), working copies for changes prior to check-in. However, while Bak monitors working copies by having the server maintain access to terminals and communicate with workstations, Bak does not receive attribute information fed back by a collection agent of a terminal when code changes in a file during compilation time:
…
Bak, paragraphs 43, 61, and 63 (Emphases added). As shown, Bak initiates a pull by a server where
RCS 80 monitors working copies by maintaining access to terminals and communicating with
workstations in order to monitor local changes. As such, the server (i.e., RCS 80) reaches out to
check terminals. This monitoring architecture is the opposite of the claimed terminal-initiated push
architecture. Specifically, Bak's server is active (monitors, accesses, communicates to check) and
the terminals are passive (working copies are monitored), whereas claim 1 requires the terminal to
be active (collection agent detects and feeds back) and the server to be reactive (receives feedback).
Further, Bak monitors changes at check-in time or at constant intervals and not when code in a file
being compiled changes, but does not disclose or suggest compiling a code or a compiler for code.
Thus, Bak fails to disclose receiving, by a server from a collection agent of a first terminal in a distributed system, attribute information of a changed code block as feedback when code in a file being compiled in a work area of the first terminal changes with code of a corresponding file in a base version stored in a code repository of the first terminal. Since Bak fails to remedy the deficiency of Young, the combination of Young and Bak fails to render obvious claims 1-20.

Examiner’s Response:
Examiner respectfully disagrees. For sending changes to server when code is changed, Bak is not relied on. Rather, the relevant limitations are disclosed by Young, which teaches a client device sending to server information regarding code changes when code is changed at a client terminal. Therefore, the rejection of the claims using a combination of Young and Bak is maintained.

Pertinent Prior Art
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure. - US 20100257515 A1 discloses locating a baseline version of an edited program to determine changes.

Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to VIVIAN WEIJIA DUAN whose telephone number is [phone]. The examiner can normally be reached Monday-Friday 8:30AM-5PM.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Wei Y Mui can be reached at [phone]. 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.

/V.W.D./Examiner, Art Unit 2191
/WEI Y MUI/Supervisory Patent Examiner, Art Unit 2191

Prosecution Timeline

• Jun 15, 2023: Application Filed
• Jun 12, 2025: Non-Final Rejection — §101, §103
• Jul 07, 2025: Response Filed
• Oct 17, 2025: Final Rejection — §101, §103
• Jan 16, 2026: Response after Non-Final Action
• Feb 09, 2026: Request for Continued Examination
• Feb 23, 2026: Response after Non-Final Action
• Apr 03, 2026: Non-Final Rejection — §101, §103 (current)