Method, apparatus and program product for managing objects in a software development project

Abstract

The present disclosure relates to a method, a device and a program product for managing objects in a software development project. In one method, in response to receiving a commit request for committing a set of objects in a software development project, a set of historical commit requests associated with the set of objects is obtained based on a commit history of the software development project, a historical commit request in the set of historical commit requests relates to the set of objects. A candidate object is selected from at least one object different from the set of objects to which the historical commit request relates. An association between the candidate object and the set of objects is determined. In response to determining that the association satisfies a predetermined condition, the candidate object is identified as a missing object, the missing object representing an object associated with the commit request but not included in the commit request. A corresponding device and computer program product are provided. With exemplary implementations of the present disclosure, objects missing in a commit request can be automatically checked.

Description

Technical Field

[0001] The various implementations of this disclosure relate to software development, and more specifically, to methods, apparatus, and computer program products for managing objects in software development projects. Background Technology

[0002] With the advancement of software development technologies, the number of objects involved in software development projects is increasing dramatically. For large-scale software projects, a single project may involve thousands or even tens of thousands of objects. During the development and updates of software products, software engineers may update one or more objects and submit the updated objects to the codebase using commit requests. It's understood that complex relationships exist between these objects, and software engineers may forget to modify certain objects, resulting in some objects being missing from commit requests. Therefore, how to more effectively manage objects in software development projects has become a hot research topic. Summary of the Invention

[0003] Therefore, it is desirable to develop and implement a technical solution for managing objects in software development projects in a more efficient manner. This solution is expected to manage multiple objects in a software development project in a more convenient and efficient way. Furthermore, it is hoped that it can automatically check for missing objects in submitted requests, thereby improving the efficiency of the software development process.

[0004] According to a first aspect of this disclosure, a method for managing objects in a software development project is provided. In this method, in response to receiving a submission request for submitting a set of objects in the software development project, a set of historical submission requests associated with the set of objects is obtained based on the submission history of the software development project, wherein the historical submission requests in the set of historical submission requests involve the set of objects. Candidate objects are selected from at least one object involved in the historical submission requests that is different from the set of objects. An association relationship between the candidate objects and the set of objects is determined. In response to determining that the association relationship satisfies predetermined conditions, the candidate objects are identified as missing objects, where a missing object represents an object associated with a submission request but not included in the submission request.

[0005] According to a second aspect of this disclosure, an electronic device is provided, comprising: at least one processor; volatile memory; and a memory coupled to the at least one processor, the memory having instructions stored therein, the instructions causing the device to perform a method according to the first aspect of this disclosure when executed by the at least one processor.

[0006] According to a third aspect of this disclosure, a computer program product is provided, which is tangibly stored on a non-transient computer-readable medium and includes machine-executable instructions for performing the method according to a first aspect of this disclosure. Attached Figure Description

[0007] The features, advantages, and other aspects of various implementations of this disclosure will become more apparent from the accompanying drawings and the following detailed description, which illustrate, by way of example and not limitation, several implementations of this disclosure. In the drawings:

[0008] Figure 1 A block diagram illustrating an application environment in which exemplary implementations of this disclosure may be implemented is shown schematically;

[0009] Figure 2 A block diagram illustrating an exemplary implementation of this disclosure of a process for managing objects in a software development project is shown schematically.

[0010] Figure 3 A flowchart illustrating an exemplary implementation of this disclosure for managing objects in a software development project is shown schematically.

[0011] Figure 4 A block diagram illustrating a process for obtaining a set of candidate objects according to an exemplary implementation of this disclosure is shown schematically.

[0012] Figure 5 A block diagram illustrating an exemplary implementation of this disclosure is shown.

[0013] Figure 6 A block diagram illustrating an exemplary implementation of the present disclosure for displaying a set of missing objects is shown.

[0014] Figure 7 A block diagram illustrating an exemplary implementation of the present disclosure for displaying a set of missing objects is shown.

[0015] Figure 8 A block diagram illustrating an exemplary implementation of this disclosure for determining the temporal distribution of a set of missing objects is shown schematically; and

[0016] Figure 9 A block diagram of a device for managing objects in a software development project, according to an exemplary implementation of this disclosure, is shown schematically. Detailed Implementation

[0017] Preferred implementations of this disclosure will now be described in more detail with reference to the accompanying drawings. While preferred implementations of this disclosure are shown in the drawings, it should be understood that this disclosure may be implemented in various forms and should not be limited to the implementations set forth herein. Rather, these implementations are provided to make this disclosure more thorough and complete, and to fully convey the scope of this disclosure to those skilled in the art.

[0018] The term “comprising” and its variations, as used herein, signify open inclusion, i.e., “including but not limited to.” Unless otherwise stated, the term “or” means “and / or.” The term “based on” means “at least partially based on.” The terms “one example implementation” and “one implementation” mean “at least one example implementation.” The term “another implementation” means “at least one additional implementation.” The terms “first,” “second,” etc., may refer to different or the same objects. Other explicit and implicit definitions may also be included below.

[0019] For ease of description, please refer to [reference 1] first. Figure 1 This describes an application environment based on an exemplary implementation of the present disclosure. Figure 1 A block diagram schematically illustrates an application environment 100 in which exemplary implementations of this disclosure may be implemented. For example... Figure 1 As shown, software development project 110 may involve multiple objects 112 (e.g., thousands). As the software development process progresses, software engineers may update a set of objects 122 (e.g., 10) and use commit request 120 to submit the updated set of objects 122 to the codebase. The codebase may include commit history 130 to store historical information incrementally throughout the development process. For example, historical commit request 140 may involve a set of historical objects 142, ..., and historical commit request 150 may involve a set of historical objects 152.

[0020] It will be understood that multiple objects 112 may involve various types. For example, objects may include files and / or directories. Files may include, for example, one or more formats of software code files, library files, configuration files, etc. Directories may include, for example, directories for storing the various files mentioned above and / or test cases, etc. Since software development projects 110 may involve thousands or even more objects, software engineers may forget to update certain objects during development. For example, a software engineer may forget to commit a file. Or, for example, a software engineer may add statements to a file that call test cases but forget to copy the test cases to the appropriate directory. This results in missing directories in the commit request.

[0021] Currently, technical solutions based on manual methods for checking submission requests have been proposed. For example, a checklist can be created, and software engineers need to verify that each submission request includes all required objects according to the configuration in the checklist. However, checklist-based solutions require a significant amount of manual work, and errors during checklist creation and manual processing can lead to the failure to detect missing objects in the submission request. Therefore, there is a need for a technical solution that automatically checks for missing objects in submission requests, and it is expected that this solution will be compatible with existing software development systems, thereby improving software development efficiency.

[0022] To at least partially eliminate the defects in the above-described technical solutions, a method for managing objects in a software development project is provided according to an exemplary implementation of this disclosure. First, see... Figure 2 To describe the summary of this disclosure. Figure 2 A block diagram schematically illustrates a process 200 for managing objects in a software development project according to an exemplary implementation of this disclosure. Figure 2 As shown, when a submission request 120 involving a set of objects 122 is received, one or more candidate objects 210 can be identified from the submission history 130, and an association relationship 220 between the set of objects 122 and the candidate objects 210 can be determined. If the association relationship 220 meets a predetermined condition, the candidate object 210 is considered a potential missing object, and the candidate object 210 is added as a missing object to the missing object set 230.

[0023] Using the exemplary implementation of this disclosure, candidate objects 210 that have an association 220 with a set of objects 122 (e.g., have been submitted simultaneously multiple times) can be found from the submission history 130, so that software engineers can further verify whether the submission request 120 is erroneous. In this way, the manual workload of the software development process can be reduced and the efficiency of the software development process can be improved.

[0024] See below. Figure 3 Further details are described regarding an exemplary implementation according to this disclosure. Figure 3 A flowchart illustrating an exemplary implementation of a method 300 for managing objects in a software development project, according to this disclosure, is shown schematically. Figure 3 As shown, at box 310, in response to receiving a commit request 120 for submitting a set of objects 122 in a software development project, a set of historical commit requests associated with the set of objects 122 is determined based on the commit history 130 of the software development project. Here, each historical commit request in the set of historical commit requests includes an identifier of the set of objects submitted in that historical commit request.

[0025] According to an exemplary implementation of this disclosure, a set of historical commit requests can be determined based on various methods. For example, all historical commit requests in commit history 130 can be considered as a set of historical commit requests. In this case, a set of historical commit requests may include historical commit requests 140, ..., and historical commit request 150. When commit history 130 includes a large number of historical commit requests, subsequent processing will involve a significant amount of computation. Therefore, commit history 130 can be filtered to find one or more historical commit requests that are more relevant to the current commit request 120.

[0026] According to an exemplary implementation of this disclosure, commit request 120 can be compared one by one with each of a plurality of historical commit requests to determine a set of historical commit requests. Specifically, if it is determined that a set of historical objects involved in a certain historical commit request intersects with a set of objects 122, the historical commit request is added to a set of historical commit requests; otherwise, processing continues to the next historical commit request in commit history 130. According to an exemplary implementation of this disclosure, a set of historical commit requests H′ can be determined using the following formula 1.

[0027]

[0028] Where S new H represents the current commit request 120, H represents all historical commit requests in commit history 130, and S represents the current commit request 120. PR This represents a historical commit request in H. Formula 1 states that if a historical commit request S... PR With the currently submitted request S new If a non-empty intersection exists, then the historical submission request S will be... PR Add to a set of historical commit requests H′.

[0029] See below. Figure 4 Describe more details about the comparison. Figure 4 A block diagram illustrating a process 400 for obtaining a set of candidate objects according to an exemplary implementation of this disclosure is shown. Figure 4 As shown, the current commit request 120 involves a set of objects 122, and the historical commit request 140 involves a set of historical objects 142. (As...) Figure 4As shown, if there is an intersection 410 between a set of objects 122 and a set of historical objects 142, then historical commit requests 140 can be added to a set of historical commit requests 420. Furthermore, objects outside the intersection of a set of historical objects 142 can be added to a candidate object set 430. Generally, multiple objects submitted simultaneously in a single commit request are usually highly correlated, while multiple objects never submitted simultaneously in a single commit request are usually less correlated. Therefore, based on whether there is an intersection between a set of objects 122 and a set of historical objects 142, irrelevant historical commit requests can be filtered out, thereby reducing the computational load of subsequent processing.

[0030] return Figure 3 At box 320, a candidate object can be selected from at least one object that is different from the set of objects involved in the historical submission request. In other words, candidate object 210 can be selected from the candidate object set 430. According to an exemplary implementation of this disclosure, each candidate object in the candidate object set 430 can be processed one by one. For example, the association between each candidate object and the set of objects 122 involved in the current submission request 120 can be determined one by one.

[0031] At box 330, the association 220 between candidate object 210 and a set of objects 122 is determined. For ease of description, the following support function is first defined. According to an exemplary implementation of this disclosure, support represents the number of times a set of objects appears in a set of historical submission requests. Support can be determined based on the following formula 2.

[0032]

[0033] Where S represents a set of objects, H′ represents a set of submitted requests, S PR S represents a historical commit request in H′, and support(S,H′) represents the number of times S appears in H′.

[0034] Suppose S includes two objects: {object1, object2}, and H′ includes the following three historical commit requests:

[0035] Historical submission request 1: {object1, object2, object3}

[0036] Historical submission request 2: {object1, object3, object4}

[0037] Historical submission request 3: {object1, object4, object5}

[0038] At this point, since {object1, object2} only appears in historical submission request 1, support(S,H′) = 1.

[0039] According to an exemplary implementation of this disclosure, the frequency of occurrence can be determined in several ways. For example, it can be determined based on comparison. Alternatively, it can be determined based on an FP-Tree (Frequent Pattern Tree). FP-Tree is a currently proposed algorithm for identifying frequently occurring patterns in a sample dataset. An FP-Tree can be constructed based on submission history, thus determining the frequency of occurrence in a faster and more efficient manner.

[0040] According to one exemplary implementation of this disclosure, the association relationship 220 may include the association relationship between the candidate object 210 and various subsets of a set of objects. Specifically, see [link to relevant documentation]. Figure 5 The diagram schematically illustrates a process 500 for determining associations between candidate objects and subsets of a set of objects according to an exemplary implementation of the present disclosure. Specifically, a subset 510 of a set of objects may first be determined, and then an association 220 may be determined between each candidate object 210 in the candidate object set 430 and a subset 510 of the set of objects 122. Similar processing may be performed on each subset to find potential missing objects associated with each subset.

[0041] Suppose a set of objects 122 includes multiple objects 512, ..., 514, ..., and 516. Multiple candidate subsets of the set of objects 122 can be determined. For example, multiple candidate subsets can be determined based on the number of objects included in each subset, in ascending order. Specifically, candidate subsets can be determined that include one object, candidate subsets that include two objects, ..., and candidate subsets that include all objects. It will be understood that since determining association 220 involves a significant amount of computation, multiple candidate subsets can be filtered to exclude subsets that are not helpful in finding the missing object.

[0042] According to an exemplary implementation of this disclosure, the support level of each candidate subset relative to a set of historical submission requests can be determined separately. If the support level is higher than a predetermined support threshold, the candidate subset is added to a subset of a set of objects. Figure 5 As shown, subset 510 may include objects 514, ..., 516. In this case, further operations can be performed on subset 510 based on its support relative to a set of historical commit requests 420. A threshold number can be pre-specified, for example, set to 3 (or another value). If subset 510 has appeared more than 3 times in a set of historical commit requests 420, the association between subset 510 and candidate object 210 is further determined. Otherwise, if the number of appearances is not more than 3, subset 510 can be discarded and the next subset can be processed.

[0043] Assuming the support of subset 510 is 10 (10 > 3), the association relationship 220 between subset 510 and candidate object 210 is then determined. Using the exemplary implementation of this disclosure, the number of subsets to be processed can be reduced, thereby reducing the computational load of subsequent operations.

[0044] According to an exemplary implementation of this disclosure, the concept of confidence level is proposed. Here, confidence level represents the probability that candidate object 210 is a missing object. Specifically, candidate object 210 can be added to subset 510 to form a new subset, which may include object 514, ..., object 516 and candidate object 210. Further, the support of subset 510 relative to a set of historical commit requests 420 and the new support of the new subset relative to the set of historical commit requests 420 can be determined separately. Further, confidence level can be determined based on support and new support. According to an exemplary implementation of this disclosure, confidence level can be determined based on the following formula 3.

[0045]

[0046] Where S represents subset 510, f represents candidate object 210, and H′ represents a set of submission requests 420, and confidence(S,f,H′) represents the confidence of the new subset obtained after adding f to S. Specifically, the numerator represents the support of the new subset after adding f to S relative to H′, and the denominator represents the support of subset S relative to H′. Assuming the support of the new subset is 9, that is, the new subset S∪{f} has appeared 9 times in H′, then the confidence at this time is...

[0047] You will understand; the above is only for reference. Figure 5 Formula 3 describes the processing of a subset 510 of a set of objects 122 and a candidate object 210 in a set of candidate objects 430. Each subset of objects 122 and each candidate object in the set of candidate objects 430 can be processed in a similar manner. For example, each subset can be paired with each candidate object to form a tuple (subset, candidate object), and Formula 3 described above can be used to determine the confidence associated with each tuple as an association 220.

[0048] According to an exemplary implementation of this disclosure, the candidate object set 430 can be set to include all candidate objects involved in a set of historical submission requests 420 that are not in a set of objects 122. For example, the candidate object set 430 can be determined based on the following formula 4:

[0049]

[0050] Where F cand This indicates a candidate object set of 430, condition 1. This indicates that the objects in the candidate object set are not part of the group of objects 122 (S) involved in the current submission request 120. new In ), and condition 2 This indicates that the objects in the candidate object set are among the historical objects involved in a set of historical submission requests 420.

[0051] According to an exemplary implementation of this disclosure, in order to reduce the number of candidate objects included in the candidate object set 430, the candidate object set 430 can be further filtered based on a support threshold (e.g., 3). Specifically, the candidate object set 430 can be determined based on the following formula 5:

[0052]

[0053] Where F cand This indicates that the candidate object set is 430, and condition 1... and condition 2 This has the same meaning as in Formula 4. In condition 3 of Formula 5, “support({f},H′)≥n*c”, n represents the support threshold (e.g., 3), and c represents the confidence threshold (e.g., 80%). Condition 3 means that the support of candidate object f relative to a set of historical submissions should be greater than or equal to n*c. Using condition 3, candidate objects with a historical occurrence frequency lower than n*c can be filtered out from the candidate object set. In this way, the number of objects in the candidate object set 430 can be reduced, thereby reducing the computational load of subsequent operations.

[0054] According to an exemplary implementation of this disclosure, each object in the candidate object set 430 can be traversed to determine a candidate object. In other words, for each object in the candidate object set 430, the association relationship 220 between that object and each subset of the set of objects 122 can be determined.

[0055] return Figure 3At box 340, in response to determining that the association meets a predetermined condition, a candidate object is added to the missing object set 230, which represents potential missing objects in the software development project that are not in a set of objects 122. The specific process of determining the association 220 based on confidence level has been described above. Here, the determined association 220 can be compared with a predetermined threshold to determine whether a candidate object is a potential missing object. If the determined association 220 is higher than the predetermined threshold (e.g., 80% or other values), then candidate object 210 is considered a potential missing object, and candidate object 210 is added to the missing object set 230. Using the exemplary implementation of this disclosure, potential missing objects can be found conveniently and quickly, thereby reducing the workload of manual processing. According to an exemplary implementation of this disclosure, the missing object set 230 can initially be set to an empty set (i.e., ...). ), which can continuously add potential missing objects to the missing object set 230.

[0056] According to an exemplary implementation of this disclosure, each candidate object in the candidate object set 430 can be processed sequentially. For example, the association 220 between the first candidate object and each subset can be determined first. If the association of the first candidate object with any subset is below a predetermined threshold (e.g., 80%), this indicates that the first candidate object is not a potential missing object, and the first candidate object can be removed from the candidate object set 430. If the association of the first candidate object with a subset is above a predetermined threshold (e.g., 80%), this indicates that the first candidate object is a potential missing object, and it can be added to the missing object set 230 and removed from the candidate object set 430.

[0057] Subsequently, similar processing can be performed on subsequent candidate objects in the candidate object set 430 to determine whether a subsequent candidate object is a potential missing object. According to an exemplary implementation of this disclosure, each object in the candidate object set 430 can be processed continuously until all objects have been processed.

[0058] According to an exemplary implementation of this disclosure, if the final candidate object set is empty, it indicates that all candidate objects have been processed, and the missing object set 230 includes all potentially missing objects. At this point, the missing object set 230 can be provided to the software engineer. Using this exemplary implementation, objects that may be missing in the submission request 120 can be quickly identified, prompting the software engineer to manually check whether the submission request 120 needs to be updated.

[0059] According to an exemplary implementation of this disclosure, an object may include at least one of directories and files in a software development project. In this case, the path of the directory or file can be used as the unique identifier of the object. It will be understood that the path may contain a large number of strings, which results in the object's identifier occupying a large amount of storage space and having low processing efficiency. According to an exemplary implementation of this disclosure, the aforementioned path can first be mapped to a shorter numeric identifier, and the numeric identifier can be used to represent the object. Assuming an object's path is "path / to / checks / tools / platform.pm", this path can be mapped to a 64-bit (or other bit length) identifier. In this way, on the one hand, the storage space for each object's identifier can be greatly saved, and on the other hand, the related computational performance can be improved.

[0060] See below. Figure 6 and Figure 7 The description is used to show more details about the missing object. Figure 6 A block diagram schematically illustrates a user interface 600 for displaying a missing set of objects according to an exemplary implementation of this disclosure. Figure 6 As shown, area 610 represents several configuration parameters during the execution of method 300 described above. For example, the parameter "candidatecount=327" indicates that the number of candidate objects included in the candidate object set is 327, the parameter "min support=3" indicates that the support threshold is 3, the parameter "min confidence=80%" indicates that the confidence threshold is 80%, and so on. Area 620 represents information related to a potential missing file. For example, "100.00%" indicates that the relevant confidence is 100, and the numerator and denominator values ​​when determining the confidence are "3 / 3" respectively. "path / to / checks / test / check1 / " indicates the path to the missing object, and this potential missing object was submitted with the object "path / to / checks / tools / check1.pm". Figure 6 The report also shows three other potential missing objects, each with a confidence level of 80%.

[0061] Figure 7 A block diagram schematically illustrates a user interface 700 for displaying a missing set of objects according to an exemplary implementation of this disclosure. The meanings of the various areas in this user interface are as follows: Figure 6 The content shown is similar, and therefore will not be repeated. Using the exemplary implementation of this disclosure, potential missing objects can be presented to software engineers in a graphical manner. Furthermore, software engineers can base their work on… Figure 6 and Figure 7The software engineer can determine the next action based on the content of the missing file suggestion. For example, the software engineer can update submission request 120 based on the suggested missing file. Alternatively, if a careful review reveals that the current software update does not involve the suggested missing file, the software engineer can mark the suggested missing file as an "error".

[0062] Using the exemplary implementation of this disclosure, Figure 6 and Figure 7 This can include detailed information related to potentially missing objects, helping software engineers understand why an object was marked as a potentially missing file. Furthermore, this information can also help software engineers identify relationships between objects and avoid similar errors in subsequent submissions.

[0063] As described above, according to an exemplary implementation of this disclosure, filtering can be performed on the submission history 130, the candidate object set 430, and multiple subsets of a set of objects 122, respectively, in order to reduce the amount of data to be processed and thus improve processing performance. Therefore, using the exemplary implementation of this disclosure, the missing object set 230 can be obtained within an acceptable time frame. Figure 8 A block diagram 800 schematically illustrates a method for determining the temporal distribution of a set of missing objects according to an exemplary implementation of this disclosure. Figure 8 In the graph, the horizontal axis shows the number of objects included in the submission request 120, and the vertical axis shows the time (in seconds) required to determine the relevant set of missing objects 230. Figure 8 Experimental data is shown for determining the corresponding set of missing objects for 50 submission requests. It can be observed that the larger the number of objects, the longer the computation time, and the processing time for the vast majority of submission requests (120) is less than 100 seconds.

[0064] Using the exemplary implementation of this disclosure, potential missing objects can be identified by mining the relationships between various objects in the submission history. In this way, the entire process is automated and requires no manual data annotation. Compared to existing technical solutions that require entirely manual operation, the exemplary implementation of this disclosure can automatically obtain potential missing objects, thereby reducing the manual workload of software engineers.

[0065] As mentioned above Figures 2 to 8Examples of methods according to this disclosure have been described in detail, and implementations of corresponding apparatus will be described below. According to an exemplary implementation of this disclosure, an apparatus for managing objects in a software development project is provided. The apparatus includes: an acquisition module configured to, in response to receiving a submission request for submitting a set of objects in the software development project, acquire a set of historical submission requests associated with the set of objects based on the submission history of the software development project, wherein the historical submission requests in the set of historical submission requests relate to the set of objects; a selection module configured to select candidate objects from at least one object, different from the set of objects, involved in the historical submission requests; a determination module configured to determine an association relationship between the candidate objects and the set of objects; and an identification module configured to, in response to determining that the association relationship satisfies predetermined conditions, identify the candidate objects as missing objects, wherein missing objects represent objects associated with a submission request but not included in the submission request. According to an exemplary implementation of this disclosure, the apparatus further includes modules for performing other steps in the method 300 described above.

[0066] Figure 9 A block diagram of a device 900 for managing data patterns according to an exemplary implementation of the present disclosure is shown schematically. As shown, the device 900 includes a central processing unit (CPU) 901, which can perform various appropriate actions and processes according to computer program instructions stored in read-only memory (ROM) 902 or loaded from storage unit 908 into random access memory (RAM) 903. Various programs and data required for the operation of the device 900 may also be stored in RAM 903. The CPU 901, ROM 902, and RAM 903 are interconnected via bus 904. An input / output (I / O) interface 905 is also connected to bus 904.

[0067] Multiple components in device 900 are connected to I / O interface 905, including: input unit 906, such as keyboard, mouse, etc.; output unit 907, such as various types of monitors, speakers, etc.; storage unit 908, such as disk, optical disk, etc.; and communication unit 909, such as network card, modem, wireless transceiver, etc. Communication unit 909 allows device 900 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0068] The various processes and procedures described above, such as method 300, can be executed by processing unit 901. For example, in some implementations, method 300 can be implemented as a computer software program tangibly contained in a machine-readable medium, such as storage unit 908. In some implementations, part or all of the computer program can be loaded and / or installed on device 900 via ROM 902 and / or communication unit 909. When the computer program is loaded into RAM 903 and executed by CPU 901, one or more steps of method 300 described above can be performed. Alternatively, in other implementations, CPU 901 can also be configured in any other suitable manner to implement the above-described processes / methods.

[0069] According to an exemplary implementation of this disclosure, an electronic device is provided, comprising: at least one processor; volatile memory; and a memory coupled to the at least one processor, the memory having instructions stored therein, the instructions, when executed by the at least one processor, causing the device to perform a method for managing objects in a software development project. The method includes: in response to receiving a submission request for submitting a set of objects in the software development project; obtaining a set of historical submission requests associated with the set of objects based on the submission history of the software development project, the historical submission requests in the set of historical submission requests relating to the set of objects; selecting candidate objects from at least one object in the historical submission requests that is different from the set of objects; determining an association relationship between the candidate objects and the set of objects; and in response to determining that the association relationship satisfies predetermined conditions, identifying the candidate objects as missing objects, the missing objects representing objects associated with the submission request but not included in the submission request.

[0070] According to an exemplary implementation of this disclosure, obtaining a set of historical commit requests includes: for historical commit requests in the commit history, in response to determining that a set of historical objects involved in the historical commit request intersects with a set of objects, adding the historical commit request to a set of historical commit requests.

[0071] According to an exemplary implementation of this disclosure, determining the association includes: determining a subset of a set of objects; and determining the association between the candidate object and the subset.

[0072] According to an exemplary implementation of this disclosure, determining a subset includes: determining the support of a candidate subset in a set of objects relative to a set of historical submissions, where the support represents the number of times the candidate subset appears in a set of historical submissions; and adding the candidate subset to a set of objects in response to determining that the support is higher than a predetermined support threshold.

[0073] According to an exemplary implementation of this disclosure, determining the association between a candidate object and a subset includes: adding the candidate object to the subset to form a new subset; determining the support of the subset relative to a set of historical commit requests and the new support of the new subset relative to a set of historical commit requests; and determining the association based on the support and the new support.

[0074] According to an exemplary implementation of this disclosure, selecting candidate objects includes: establishing a set of candidate objects based on at least one object; and traversing the set of candidate objects to determine candidate objects.

[0075] According to an exemplary implementation of this disclosure, the method further includes: removing a candidate object from the candidate object set in response to the candidate object being selected.

[0076] According to an exemplary implementation of this disclosure, the method further includes: adding missing objects to a set of missing objects; and providing a set of missing objects in response to a candidate set being empty.

[0077] According to one exemplary implementation of this disclosure, the objects in the set of objects include at least any one of the directories and files in a software development project.

[0078] According to an exemplary implementation of this disclosure, the method further includes: converting the path of an object to a numeric identifier; and using the numeric identifier to represent the object.

[0079] According to an exemplary implementation of this disclosure, a computer program product is provided, which is tangibly stored on a non-transient computer-readable medium and includes machine-executable instructions for performing a method according to this disclosure.

[0080] According to an exemplary implementation of this disclosure, a computer-readable medium is provided. The computer-readable medium stores machine-executable instructions that, when executed by at least one processor, cause the at least one processor to implement the method according to this disclosure.

[0081] This disclosure can be a method, apparatus, system, and / or computer program product. A computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for performing various aspects of this disclosure.

[0082] Computer-readable storage media can be tangible devices capable of holding and storing instructions for use by an instruction execution device. Computer-readable storage media can be, for example—but not limited to—electrical storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any suitable combination thereof. More specific examples (a non-exhaustive list) of computer-readable storage media include: portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disc read-only memory (CD-ROM), digital multifunction disc (DVD), memory sticks, floppy disks, mechanical encoding devices, such as punch cards or recessed protrusions storing instructions thereon, and any suitable combination thereof. The computer-readable storage media used herein are not to be construed as transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses through fiber optic cables), or electrical signals transmitted through wires.

[0083] The computer-readable program instructions described herein can be downloaded from computer-readable storage media to various computing / processing devices, or downloaded via a network, such as the Internet, local area network, wide area network, and / or wireless network, to an external computer or external storage device. The network may include copper transmission cables, fiber optic transmission, wireless transmission, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards them to the computer-readable storage media in the respective computing / processing device.

[0084] The computer program instructions used to perform the operations of this disclosure may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, status setting data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Smalltalk, C++, etc., and conventional procedural programming languages ​​such as the "C" language or similar programming languages. The computer-readable program instructions may execute entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving a remote computer, the remote computer may be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or may be connected to an external computer (e.g., via the Internet using an Internet service provider). In some implementations, electronic circuitry, such as programmable logic circuitry, field-programmable gate arrays (FPGAs), or programmable logic arrays (PLAs), is customized by utilizing the status information of the computer-readable program instructions to execute the computer-readable program instructions, thereby implementing various aspects of this disclosure.

[0085] Various aspects of this disclosure are described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products implemented according to this disclosure. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable program instructions.

[0086] These computer-readable program instructions can be provided to a processing unit of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus to produce a machine such that, when executed by the processing unit of the computer or other programmable data processing apparatus, they create means for implementing the functions / actions specified in one or more blocks of the flowchart and / or block diagram. These computer-readable program instructions can also be stored in a computer-readable storage medium that causes a computer, programmable data processing apparatus, and / or other device to operate in a particular manner. Thus, the computer-readable medium storing the instructions comprises an article of manufacture that includes instructions for implementing aspects of the functions / actions specified in one or more blocks of the flowchart and / or block diagram.

[0087] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable data processing apparatus, or other device to produce a computer-implemented process, thereby causing the instructions that execute on the computer, other programmable data processing apparatus, or other device to perform the functions / actions specified in one or more boxes of a flowchart and / or block diagram.

[0088] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of an instruction, which contains one or more executable instructions for implementing the specified logical function. In some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutive blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, may be implemented using a dedicated hardware-based system that performs the specified function or action, or using a combination of dedicated hardware and computer instructions.

[0089] Various implementations of this disclosure have been described above. The foregoing description is exemplary and not exhaustive, nor is it limited to the disclosed implementations. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described implementations. The terminology used herein is chosen to best explain the principles, practical applications, or improvements to technology in the market, or to enable others skilled in the art to understand the implementations disclosed herein.

Claims

1. A method for managing objects in a software development project, comprising: In response to receiving a submission request for submitting a set of objects in the software development project, a set of historical submission requests associated with the set of objects is obtained based on the submission history of the software development project, wherein the historical submission requests in the set of historical submission requests involve the set of objects; Select a candidate object from at least one object that is different from the set of objects involved in the historical submission request; Determine the association between the candidate object and the group of objects; as well as In response to determining that the association meets predetermined conditions, the candidate object is identified as a missing object, which represents an object associated with the submission request but not included in the submission request.

2. The method according to claim 1, wherein obtaining the set of historical submission requests includes: Regarding the historical commit requests in the commit history, In response to determining that a set of historical objects involved in the historical commit request intersects with the set of objects, the historical commit request is added to the set of historical commit requests.

3. The method according to claim 1, wherein determining the association relationship includes: Determine a subset of the set of objects; as well as Determine the association between the candidate object and the subset.

4. The method of claim 3, wherein determining the subset comprises: Determine the support of a candidate subset of the set of objects relative to the set of historical commit requests, wherein the support represents the number of times the candidate subset appears in the set of historical commit requests; as well as In response to determining that the support is higher than a predetermined support threshold, the candidate subset label is added to a subset of the set of objects.

5. The method according to claim 3, wherein determining the association between the candidate object and the subset comprises: Add the candidate objects to the subset to form a new subset; Determine the support of the subset relative to the set of historical commit requests and the new support of the new subset relative to the set of historical commit requests, respectively; as well as The association is determined based on the support and the new support.

6. The method of claim 3, wherein selecting the candidate object comprises: Establish a candidate object set based on the at least one of the objects; as well as Traverse the set of candidate objects to determine the candidate objects.

7. The method of claim 6, further comprising: In response to the candidate object being selected, the candidate object is removed from the candidate object set.

8. The method of claim 7, further comprising: Add the missing object to the missing object set; as well as In response to the candidate object set being empty, the missing object set is provided.

9. The method of claim 1, wherein the objects in the set of objects include at least any one of the directories and files in the software development project.

10. The method of claim 9, further comprising: Convert the path of the object to a numeric identifier; as well as The object is represented by the numerical identifier.

11. An electronic device, comprising: At least one processor; Volatile memory; as well as A memory coupled to the at least one processor, the memory having instructions stored therein, which, when executed by the at least one processor, cause the device to perform a method for managing objects in a software development project, the method comprising: In response to receiving a submission request for submitting a set of objects in the software development project, a set of historical submission requests associated with the set of objects is obtained based on the submission history of the software development project, wherein the historical submission requests in the set of historical submission requests involve the set of objects; Select a candidate object from at least one object that is different from the set of objects involved in the historical submission request; Determine the association between the candidate object and the set of objects; and In response to determining that the association meets predetermined conditions, the candidate object is identified as a missing object, which represents an object associated with the submission request but not included in the submission request.

12. The device of claim 11, wherein obtaining the set of historical submission requests comprises: Regarding the historical commit requests in the commit history, In response to determining that a set of historical objects involved in the historical commit request intersects with the set of objects, the historical commit request is added to the set of historical commit requests.

13. The device of claim 11, wherein determining the association includes: Determine a subset of the set of objects; as well as Determine the association between the candidate object and the subset.

14. The device of claim 13, wherein determining the subset comprises: Determine the support of a candidate subset of the set of objects relative to the set of historical commit requests, wherein the support represents the number of times the candidate subset appears in the set of historical commit requests; as well as In response to determining that the support is higher than a predetermined support threshold, the candidate subset is added to a subset of the set of objects.

15. The device of claim 13, wherein determining the association between the candidate object and the subset comprises: Add the candidate objects to the subset to form a new subset; Determine the support of the subset relative to the set of historical commit requests and the new support of the new subset relative to the set of historical commit requests, respectively; as well as The association is determined based on the support and the new support.

16. The device of claim 13, wherein selecting the candidate comprises: Establish a candidate object set based on the at least one of the objects; as well as Traverse the set of candidate objects to determine the candidate objects.

17. The apparatus of claim 16, wherein the method further comprises: In response to the candidate object being selected, the candidate object is removed from the candidate object set.

18. The apparatus of claim 17, wherein the method further comprises: Add the missing object to the missing object set; as well as In response to the candidate object set being empty, the missing object set is provided.

19. The device of claim 11, wherein the objects in the set of objects include at least any one of directories and files in the software development project, and the method further comprises: Convert the path of the object to a numeric identifier; as well as The object is represented by the numerical identifier.

20. A computer program product tangibly stored on a non-transient computer-readable medium and comprising machine-executable instructions for performing the method according to any one of claims 1 to 10.

Images