Method, apparatus, device, and medium for developing code based on devops

Abstract

There is a method for developing code based on DevOps. The method comprises: receiving a commit from developers (110); creating a CI / CD pipeline for the commit and running the CI / CD pipeline (120); sending information of the failed CI / CD pipeline to a Large Language Model if the CI / CD pipeline is failed (130); generating a new branch, error reason and bug fixing suggestion by the Large Language Model to fix the failed CI / CD pipeline, and sending the new branch, error reason and bug fixing suggestion to the developers (140).

Description

Method, apparatus, device, and medium for developing code based on DevOpsFIELD

[0001] The present disclosure relates to the technical field of industry digitalization, in particular to a method, apparatus, device, and medium for developing code based on DevOps.BACKGROUND

[0002] DevOps is an efficient software engineering tool for delivering software products with a quick iterative mode. The CI / CD (Continuous Integration / Continuous Delivery) pipeline is used for representing the DevOps process of each commit by developers.

[0003] Developers need to fix the failed CI / CD pipelines manually based on the error messages logged by DevOps platforms, CI / CD pipelines and print information. Manual debugging leads to low efficiency and prone to errors.SUMMARY

[0004] Embodiments of the present disclosure propose a method, apparatus, device, and medium for developing code based on DevOps.

[0005] In a first aspect, there is provided a method for developing code based on DevOps, comprising:

[0006] receiving a commit from developers;

[0007] creating a CI / CD pipeline for the commit and running the CI / CD pipeline;

[0008] sending information of the failed CI / CD pipeline to a Large Language Model if the CI / CD pipeline is failed;

[0009] generating a new branch, error reason and bug fixing suggestion by the Large Language Model to fix the failed CI / CD pipeline, and sending the new branch, error reason and bug fixing suggestion to the developers.

[0010] Therefore, the present disclosure proposes a method for developing code based on DevOps, a Large language model is introduced to fix failed CI / CD pipeline. Therefore, manual operations are reduced and debugging efficiency is improved.

[0011] In an example, wherein the method comprises:

[0012] iterating all branches in all projects;

[0013] detecting first failed CI / CD pipeline and first succeeded CI / CD pipeline after the first failed CI / CD pipeline for each branch;

[0014] generating training data with differences between two commits corresponding to the first failed CI / CD pipeline and the first succeeded CI / CD pipeline;

[0015] setting the detected first succeeded CI / CD pipeline as starting point to iterate CI / CD pipeline;

[0016] training the Large Language Model with the training data.

[0017] In an example, wherein the method comprises:

[0018] receiving a commit from developers;

[0019] creating a CI / CD pipeline for the commit and running the CI / CD pipeline;

[0020] judging if the CI / CD pipeline failed, if the CI / CD pipeline failed, setting the current failed CI / CD pipeline as a beginning commit pipeline, if the CI / CD pipeline succeed, judging if there is a marked beginning commit pipeline;

[0021] if there is a marked beginning commit pipeline, setting the current succeed commit as the ending commit pipeline;

[0022] generating training data with differences between two commits corresponding to the beginning CI / CD pipeline and the ending CI / CD pipeline;

[0023] training the Large Language Model with the training data.

[0024] In an example, wherein the method comprises:

[0025] categorizing the training data by commit message type;

[0026] training the Large language model with the categorized training data.

[0027] In an example, wherein the method comprises:

[0028] receiving an attempt time threshold set by developers;

[0029] stopping fixing the failed CI / CD pipeline if the Large Language Model reached the attempt time threshold.

[0030] In an example, wherein the method comprises:

[0031] generating an error analysis branch to summarize the error message and all fix attempts by the Large language model;

[0032] send the error analysis branch and error analysis results to the developers.

[0033] In a second aspect, there is provided an apparatus for developing code based on DevOps, comprising:

[0034] a receiving module, configured to receive a commit from developers;

[0035] a creating module, configured to create a CI / CD pipeline for the commit and running the CI / CD pipeline;

[0036] a sending module, configured to send information of the failed CI / CD pipeline to a Large Language Model if the CI / CD pipeline failed;

[0037] a generating module, configured to generate a new branch by the Large Language Model to fix the failed CI / CD pipeline, and sending the new branch to the developers.

[0038] In a third aspect, there is provided an electronic device comprising a processor and a memory, wherein an application program executable by the processor is stored in the memory for causing the processor to execute a  method for identifying building block as described in any of the above.

[0039] In a fourth aspect, there is provided a computer-readable medium comprising computer-readable instructions stored thereon is provided, wherein the computer-readable instructions for executing a method for identifying building block as described in any of the above.

[0040] In a fifth aspect, there is provided a computer program product comprising a computer program, when the computer program is executed by a processor for executing a method for identifying building block as described in any of the above.BRIEF DESCRIPTION OF THE DRAWINGS

[0041] To make technical solutions of examples of the present disclosure clearer, accompanying drawings to be used in description of the examples will be simply introduced hereinafter. Obviously, the accompanying drawings to be described hereinafter are only some examples of the present disclosure. Those skilled in the art may obtain other drawings according to these accompanying drawings without creative labor.

[0042] Fig. 1 is an exemplary flowchart of a method for developing code based on DevOps according to an embodiment of the present disclosure.

[0043] Fig. 2 is an exemplary schematic diagram of a typical CI / CD pipeline diagram in DevOps process in the prior art.

[0044] Fig. 3 is an exemplary system schematic diagram according to an embodiment of the present disclosure.

[0045] Fig. 4 is an exemplary flowchart of a training process of Large Language Model according to an embodiment of the present disclosure.

[0046] Fig. 5 is an exemplary schematic diagram of a training process of Large Language Model according to an embodiment of the present disclosure.

[0047] Fig. 6 is an exemplary schematic diagram of a process for a training process of Large Language Model according to another embodiment of the present disclosure.

[0048] Fig. 7 is an exemplary workflow of a process for developing code according to an embodiment of the present disclosure.

[0049] Fig. 8 is an exemplary workflow of a process for developing code according to another embodiment of the present disclosure.

[0050] Fig. 9 is an exemplary schematic diagram of an apparatus for developing code based on DevOps according to an embodiment of the present disclosure.

[0051] Fig. 10 is an exemplary structural diagram of an electronic device according to an embodiment of the present  disclosure.

[0052] List of reference numbers:

[0053] 100 method for developing code based on DevOps

[0054] 110-140 steps

[0055] 30 developer

[0056] 31 development environment

[0057] 311 development machine

[0058] 32 server

[0059] 321 code repository

[0060] 322 CI / CD runner

[0061] 323 Large Language Model

[0062] 401-412 steps

[0063] 601-610 steps

[0064] 701-707 steps

[0065] 801-810 steps

[0066] 900 apparatus for developing code based on DevOps

[0067] 910 creating module

[0068] 920 running module

[0069] 930 generating module

[0070] 940 pushing module

[0071] 1000 electronic device

[0072] 1010 processor

[0073] 1020 memoryDETAILED DESCRIPTION

[0074] To make the purpose, technical scheme, and advantages of the disclosure clearer, the following examples are given to further explain the disclosure in detail. Nouns and pronouns related to people in this patent application are not limited to specific gender.

[0075] To be concise and intuitive in description, the scheme of the disclosure is described below by describing several representative embodiments. Many details in the embodiments are only used to help understand the scheme of the disclosure. However, it is obvious that the technical scheme of the disclosure can be realized without being limited  to these details. To avoid unnecessarily blurring the scheme of the disclosure, some embodiments are not described in detail, but only the framework is given. Hereinafter, "including" refers to "including but not limited to" , "according to... " refers to "at least according to..., but not limited to... " . When the number of an element is not specifically indicated below, it means that the element can be one or more, or can be understood as at least one.

[0076] Fig. 2 is an exemplary schematic diagram of a typical CI / CD pipeline diagram in DevOps process in the prior art. As shown in Fig. 2, a pipeline is created to represent the DevOps process of each commit by developers. In Fig 2, pipeline 4 corresponding to commit 4 of branch A succeeded, meanwhile pipeline 3 corresponding to commit 3 of branch A, pipeline 2 corresponding to commit 2 of branch B, pipeline 1 corresponding to commit 1 of branch C failed. Developers need to fix the failed CI / CD pipelines manually based on the error messages logged by DevOps platforms, CI / CD pipelines and print information.

[0077] The present disclosure proposes a method for developing code based on DevOps. Fig. 1 is an exemplary flowchart of a method 100 for developing code based on DevOps according to an embodiment of the present disclosure. As shown in Fig. 1, the method 100 comprises:

[0078] Step 110, receiving a commit from developers;

[0079] Developers develop codes in development machine of the development environment and can commit changes to code repository. Changes may include source code, scripts, commit comments, and any other files under this repository. Code repository can be deployed in a server. Server may be an enterprise server or cloud server.

[0080] Step 120, creating a CI / CD pipeline for the commit and running the CI / CD pipeline;

[0081] CI / CD pipeline is a key component of DevOps, enabling the continuous integration and deployment of software changes. CI / CD pipeline can be created and run in a CI / CD runner. A CI / CD pipeline include one or more stages, and stage include one or more jobs. For example, a CI / CD pipeline may include stage build-base-images, build, unit-test, sonarqube, build image and robot-test, wherein the stage build may include job build-ui and build-ui-for-ci.

[0082] Step 130, sending information of the failed CI / CD pipeline to a Large Language Model if the CI / CD pipeline failed;

[0083] Large language model (LLM) refers to a type of artificial intelligence model that is trained on a massive amount of text data to generate human-like responses or generate new content. If the CI / CD pipeline failed, information such as log is sent to the Large language model. At beginning, the Large Language Model is trained with a general dataset and / or general CI / CD pipelines that are from public repositories. Then when the Large Language Model is deployed to cloud or enterprise server, the Large Language Model can be retrained or improved with the CI / CD pipelines of private projects. Detailed training process of Large language model will be described in Fig. 4 and Fig.  6 as below. As the Large language model is trained with data of failed CI / CD pipelines, it can be used to fix the failed CI / CD pipelines.

[0084] Step 140, generating a new branch, error reason and bug fixing suggestion by the Large Language Model to fix the failed CI / CD pipeline, and sending the new branch, error reason and bug fixing suggestion to the developers.

[0085] The Large Language Model generates a new branch to modify files to attempt to fix the failure. Another commit corresponding to the code modification will be sent to CI / CD runner to run and check whether it is succeeded. Afterwards when the new CI / CD pipeline is succeeded, the new branch, error reason and bug fixing suggestion will be sent to the developers. In one embodiment, a branch merge request is sent to developers. Developers can review and confirm merging the new branch to their own branch to fix the failed CI / CD pipeline.

[0086] Embodiments of the present disclosure propose a method for developing code based on DevOps, a Large language model is introduced to fix failed CI / CD pipeline. Therefore, manual operations are reduced and debugging efficiency is improved.

[0087] In one embodiment of the present disclosure, wherein the method comprises:

[0088] receiving an attempt time threshold set by developers;

[0089] stopping fixing the failed CI / CD pipeline if the Large Language Model reached the attempt time threshold.

[0090] For example, developers can set the attempt time as 3 or more, to decide how many time they want LLM to attempt fix the branch. If the LLM still failed after 3 times, attempt to fix the failed CI / CD pipeline is stopped.

[0091] In one embodiment of the present disclosure, wherein the method comprises:

[0092] generating an error analysis branch to summarize the error message and all fix attempts by the Large language model;

[0093] send the error analysis branch and error analysis results to the developers.

[0094] For example, if the LLM still failed after 3 times, summary of the error message and all the attempts are put into an error analysis branch that contains a MD file, e.g. ErrorAnalysis. MD for developers for further analysis of the error.

[0095] Fig. 3 is an exemplary system schematic diagram according to an embodiment of the present disclosure. As shown in Fig. 3, development environment 31 may include development machine 311. Development machine 311 is used by developers to develop software. The developers commit changes (e.g. features, fixed bugs, etc. ) to a remote server with the development machines 311.

[0096] Server 32 may be a remote DevOps platform on cloud or enterprise. Server 32 includes code repository 321, CI / CD runner 322 and Large Language Model 323.

[0097] Code repository 321 is based on software version controlling tool. Developers can create and maintain source  code in projects and commit changes to code repository 321. For each commit, a CI / CD pipeline is created to execute DevOps process if there are CI / CD scripts included in the source code. Code repository is configured to push information of CI / CD pipelines to Large Language Model for further processing.

[0098] CI / CD runner 322 is an environment used for executing each step of the CI / CD pipeline. CI / CD runner 322 may be a physical machine, a virtual machine, or a container.

[0099] Large Language Model 323 is trained to return advice to the code repository 321 based on failed CI / CD pipeline about how to fix the failed CI / CD pipelines and create new branches to start new CI / CD pipelines to attempt to fix the failed CI / CD pipelines. If the new pipeline committed by LLM failed again, LLM will firstly try to check whether the error message is the same as last time, if not, LLM will try to fix the new error, otherwise, keep fixing the original error. Based on the advice and succeeded CI / CD pipelines, developers can fix the failed CI / CD pipeline or merge the branches created by Large Language Model into their branches.

[0100] In one embodiment of the present disclosure, wherein the method comprises:

[0101] iterating all branches in all projects;

[0102] detecting first failed CI / CD pipeline and first succeeded CI / CD pipeline after the first failed CI / CD pipeline for each branch;

[0103] generating training data with differences between two commits corresponding to the first failed CI / CD pipeline and the first succeeded CI / CD pipeline;

[0104] setting the detected first succeeded CI / CD pipeline as starting point to iterate CI / CD pipeline;

[0105] training the Large Language Model with the training data.

[0106] In one embodiment of the present disclosure, wherein the method comprises:

[0107] categorizing the training data by commit message type;

[0108] training the Large language model with the categorized training data.

[0109] For example, training data can be categorized by commit messages type such as feat, test, ci, and refactor. Then the Large language model will be trained with the categorized training data.

[0110] Fig. 4 is an exemplary flowchart of a training process of Large Language Model according to an embodiment of the present disclosure. As shown in Fig. 4, the training process includes:

[0111] Step 401, start;

[0112] Step 402, iterate all projects at code repository;

[0113] Step 403, iterate all branches of current project;

[0114] Step 404, detect the first failed CI / CD pipeline of current branch;

[0115] Step 405, detect the first succeeded CI / CD pipeline after the failed CI / CD pipeline in the same branch of the  current project;

[0116] Step 406, generate train data with differences between the two commits and metadata (e.g. commit id, pipeline id, branch name, etc. ) ;

[0117] Step 407, set the current detected first succeeded CI / CD pipeline as start point to iterate CI / CD pipeline;

[0118] Step 408, judge if all pipeline iteration finished, if no, back to step 404, or proceed to step 409;

[0119] Step 409, judge if all branch iteration finished, if no, back to step 403, or proceed to step 410;

[0120] Step 410, judge if all project iteration finished, if no, back to step 402, or proceed to step 411;

[0121] Step 411, train the large language model with the generated train dataset;

[0122] Step 412, end.

[0123] Fig. 5 is an exemplary schematic diagram of a training process of Large Language Model according to an embodiment of the present disclosure.

[0124] As shown in Fig. 5, the project ABC includes three branches A, B and C. Firstly for branch C, the first failed CI / CD pipeline is “Branch C, Commit 2, Pipeline 2” . Then the first succeeded CI / CD pipeline “Branch C, Commit 7, Pipeline 7” after the first failed CI / CD pipeline “Branch C, Commit 2, Pipeline 2” is found. The changes between these two CI / CD pipelines are collected as training data. Then there is no following failed CI / CD pipeline on branch C. Next, iterating CI / CD pipelines on branch B, the first failed CI / CD pipeline “Branch B, Commit 3, Pipeline 3” and the first succeeded CI / CD pipeline “Branch B, Commit 5, Pipeline 5” are found. The changes between these two CI / CD pipelines are collected as training data. Then there is no following failed CI / CD pipeline on branch B. Next, iterating CI / CD pipelines on branch A, the first failed CI / CD pipeline “Branch A, Commit 6, Pipeline 6” and the first succeeded CI / CD pipeline “Branch A, Commit 8, Pipeline 8” are found. The changes between these two CI / CD pipelines are collected as training data. Then there is no following failed CI / CD pipeline on branch A. After the above steps, there are no other branches, and the Large Language Model can be trained with the generated training data.

[0125] When the training process of LLM is finished, the LLM can be deployed to the cloud or enterprise server. Then the deployed LLM can be used for software development.

[0126] In one embodiment of the present disclosure, wherein the method comprises:

[0127] receiving a commit from developers;

[0128] creating a CI / CD pipeline for the commit and running the CI / CD pipeline;

[0129] judging if the CI / CD pipeline failed, if the CI / CD pipeline failed, setting the current failed CI / CD pipeline as a beginning commit pipeline, if the CI / CD pipeline succeed, judging if there is a marked beginning commit pipeline;

[0130] if there is a marked beginning commit pipeline, setting the current succeed commit as the ending commit  pipeline;

[0131] generating training data with differences between two commits corresponding to the beginning CI / CD pipeline and the ending CI / CD pipeline;

[0132] training the Large Language Model with the training data.

[0133] Fig. 6 is an exemplary schematic diagram of a process for a training process of Large Language Model according to another embodiment of the present disclosure. As shown in Fig. 6, the training process includes:

[0134] Step 601, start;

[0135] Step 602, developers commit changes (e.g. source code, scripts, commit comments, etc. )

[0136] Step 603, CI / CD pipeline is created for the commit;

[0137] Step 604, judge if the CI / CD pipeline failed? If yes, back to step 602, or proceed to step 605;

[0138] Step 605, set current commit as a beginning commit;

[0139] Step 606, judge if there is a marked beginning failed CI / CD pipeline, if no, proceed to step 610, or proceed to step 607;

[0140] Step 607, set current commit as the ending commit;

[0141] Step 608, generate training data with the changes between the beginning and current commits and metadata (e.g. commit id, pipeline id, branch name, etc. )

[0142] Step 609, train the large language model with the generated train dataset;

[0143] Step 610, end.

[0144] Fig. 7 is an exemplary workflow of a process for developing code according to an embodiment of the present disclosure. As shown in Fig. 7, the process includes:

[0145] Step 701, start;

[0146] Step 702, developers commit changes (e.g. source code, scripts, commit comments, etc. ) ;

[0147] Step 703, CI / CD pipeline is created for this commit;

[0148] Step 704, judge if the CI / CD pipeline failed, if yes, proceed to step 705, if no, proceed to step 707;

[0149] Step 705, Information of failed CI / CD pipeline is pushed to Large Language Model;

[0150] Step 706, Large Language Model return advice to developers;

[0151] Step 707, end.

[0152] Fig. 8 is an exemplary workflow of a process for developing code according to another embodiment of the present disclosure. As shown in Fig. 8, the process includes:

[0153] Step 801, start;

[0154] Step 802, developers commit changes (e.g. source code, scripts, commit comments, etc. ) ;

[0155] Step 803, CI / CD pipeline is created for the commit;

[0156] Step 804, judge if the CI / CD pipeline failed, if yes, proceed to step 805, if no, proceed to step 810;

[0157] Step 805, Information of failed CI / CD pipeline is pushed to Large Language Model;

[0158] Step 806, Large Language Models create a new branch with a generated advice to fix the detected issues;

[0159] Step 807, is this CI / CD pipeline failed? If yes, back to step 806, or proceed to step 808;

[0160] Step 808, Large Language Models return the advice and created branch to the code repository;

[0161] Step 809, code repository returns the generated branch to developers for reviewing and merging;

[0162] Step 810, end.

[0163] The present disclosure further proposes an apparatus for developing code based on DevOps. Fig. 9 is an exemplary schematic diagram of an apparatus 900 for developing code based on DevOps according to an embodiment of the present disclosure. As shown in Fig. 9, the apparatus 900 comprises:

[0164] a receiving module 910, configured to receive a commit from developers;

[0165] a creating module 920, configured to create a CI / CD pipeline for the commit and running the CI / CD pipeline;

[0166] a sending module 930, configured to send information of the failed CI / CD pipeline to a Large Language Model if the CI / CD pipeline failed;

[0167] a generating module 940, configured to generate a new branch by the Large Language Model to fix the failed CI / CD pipeline, and sending the new branch to the developers.

[0168] Embodiments of the present disclosure also propose an electronic device with a processor memory architecture. Fig. 10 is an exemplary structural diagram of an electronic device according to an embodiment of the present disclosure. As shown in Figure 10, electronic device 1000 includes a processor 1010, a memory 1020, and a computer program stored on memory 1020 that can run on processor 1010. When the computer program is executed by processor 1010, the method for identifying building block as described in either of the above is implemented. Among them, memory 1020 can be implemented as various storage media such as electrically erasable programmable read-only memory (EEPROM) , flash memory, programmable program read-only memory (PROM) , etc. Processor 1010 can be implemented to include one or more central processors or one or more field programmable gate arrays, wherein the field programmable gate array integrates one or more central processor cores. Specifically, the central processing unit or core can be implemented as a CPU, MCU, DSP, and so on.

[0169] It should be noted that not all steps and modules in the above processes and structural diagrams are necessary, and some steps or modules can be ignored according to actual needs. The execution sequence of each step is not fixed and can be adjusted as needed. The division of each module is only for the convenience of describing the functional division used. In actual implementation, a module can be divided into multiple modules, and the functions  of multiple modules can also be implemented by the same module. These modules can be in the same device or different devices.

[0170] The hardware modules in each implementation can be implemented mechanically or electronically. For example, a hardware module can include specially designed permanent circuits or logic devices (such as dedicated processors, such as FPGA or ASIC) to complete specific operations. Hardware modules can also include programmable logic devices or circuits temporarily configured by software (such as general-purpose processors or other programmable processors) for performing specific operations. As for the specific use of mechanical methods, either dedicated permanent circuits or temporarily configured circuits (such as software configuration) to implement hardware modules, it can be determined based on cost and time considerations.

[0171] The above is only a preferred embodiment of the present disclosure and is not intended to limit the scope of protection of the present disclosure. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of this disclosure shall be included within the scope of protection of this disclosure.

[0172] Independent of the grammatical term usage, individuals with male, female or other gender identities are included within the term.

Claims

1.A method (100) for developing code based on DevOps, comprising:receiving (110) a commit from developers;creating (120) a CI / CD pipeline for the commit and running the CI / CD pipeline;sending (130) information of the failed CI / CD pipeline to a Large Language Model if the CI / CD pipeline is failed;generating (140) a new branch, error reason and bug fixing suggestion by the Large Language Model to fix the failed CI / CD pipeline, and sending the new branch, error reason and bug fixing suggestion to the developers.2.The method (100) according to claim 1, wherein the method (100) comprises:iterating all branches in all projects;detecting first failed CI / CD pipeline and first succeeded CI / CD pipeline after the first failed CI / CD pipeline for each branch;generating training data with differences between two commits corresponding to the first failed CI / CD pipeline and the first succeeded CI / CD pipeline;setting the detected first succeeded CI / CD pipeline as starting point to iterate CI / CD pipeline;training the Large Language Model with the training data.3.The method (100) according to claim 1, wherein the method (100) comprises:receiving a commit from developers;creating a CI / CD pipeline for the commit and running the CI / CD pipeline;judging if the CI / CD pipeline failed, if the CI / CD pipeline failed, setting the current failed CI / CD pipeline as a beginning commit pipeline, if the CI / CD pipeline succeed, judging if there is a marked beginning commit pipeline;if there is a marked beginning commit pipeline, setting the current succeed commit as the ending commit pipeline;generating training data with differences between two commits corresponding to the beginning CI / CD pipeline and the ending CI / CD pipeline;training the Large Language Model with the training data.4.The method (100) according to claim 2 or 3, wherein the method (100) comprises:categorizing the training data by commit message type;training the Large language model with the categorized training data.5.The method (100) according to claim 1, wherein the method (100) comprises:receiving an attempt time threshold set by developers;stopping fixing the failed CI / CD pipeline if the Large Language Model reached the attempt time threshold.6.The method (100) according to claim 5, wherein the method (100) comprises:generating an error analysis branch to summarize the error message and all fix attempts by the Large language model;send the error analysis branch and error analysis results to the developers.7.An apparatus (900) for developing code based on DevOps, comprising:a receiving module (910) , configured to receive a commit from developers;a creating module (920) , configured to create a CI / CD pipeline for the commit and running the CI / CD pipeline;a sending module (930) , configured to send information of the failed CI / CD pipeline to a Large Language Model if the CI / CD pipeline failed;a generating module (940) , configured to generate a new branch by the Large Language Model to fix the failed CI / CD pipeline, and sending the new branch to the developers.8.An electronic device, comprising a processor (1010) and a memory (1020) , wherein an application program executable by the processor (1010) is stored in the memory (1020) for causing the processor (1010) to execute a method for identifying building block according to any one of claims 1-6.9.A computer-readable medium comprising computer-readable instructions stored thereon, wherein the computer-readable instructions for executing a method for identifying building block according to any one of claims 1-6.10.A computer program product comprising a computer program, upon the computer program is executed by a processor for executing a method for identifying building block according to any one of claims 1-6.

Images