Optimizing software codebases using advanced code complexity metrics

Aspects of the disclosure relate to codebase effort tracking. A computing platform may detect accessing of a first code resource by a user of a computing device and initiate tracking of a first interaction time associated with the first code resource. Subsequently, the computing platform may detect loss of interaction with the first code resource and terminate tracking of the first interaction time. Then, the computing platform may detect accessing of a second code resource by the user of the computing device and initiate tracking of a second interaction time associated with the second code resource. Based on the tracking of the respective interaction times, the computing platform may generate and store a code complexity metric. Then, the computing platform may repeat one or more steps for a third code resource and update the code complexity metric based on a third interaction time associated with the third code resource.

BACKGROUND

Aspects of the disclosure relate to computer software development. In particular, one or more aspects of the disclosure relate to determining code or application complexity, for example, by tracking software development efforts and productivity.

Traditional metrics such as cyclomatic complexity are often used to estimate code complexity. Cyclomatic complexity may provide a quantitative measure of the number of linearly independent paths through code, but fails to provide a full picture of which areas of a codebase are consuming inordinate amounts of developer time. For example, code that includes many logic paths might have high cyclomatic complexity, but the code in each logic path might be relatively straightforward. Conversely, code that includes few logic paths might have low cyclomatic complexity, but the code in each logic path might still be very complex. In many instances, for example, poor naming conventions, poorly organized code, or novel code may cause developers to spend unbalanced amounts of times in certain areas of a codebase. Therefore, it may be difficult to use traditional metrics to gauge allocation of resources, plan project timelines, and identify areas of a codebase for optimization.

SUMMARY

Aspects of the disclosure provide effective, efficient, scalable, and convenient technical solutions that address and overcome the technical problems associated with determining code complexity. In particular, one or more aspects of the disclosure provide techniques for codebase effort tracking. Some aspects of the disclosure provide insight into code complexity based on how time is spent (e.g., by developers) in a codebase during development. Additional aspects of the disclosure may provide reports or notifications for a comprehensive and accurate understanding of code complexity for a software development project. Additional aspects of the disclosure may provide techniques for efficient allocation of resources, accurate planning of project timelines, and quick identification of areas of a codebase for optimization or remediation (e.g., responding to regulatory requirements or security events).

In accordance with one or more embodiments, a computing platform having at least one processor, a communication interface, and memory may detect accessing of a first code resource of a codebase by a user of a computing device. Responsive to detecting the accessing of the first code resource, the computing platform may initiate tracking of a first interaction time indicative of a time of an interaction by the user of the computing device with the first code resource. Next, the computing platform may detect loss of the interaction by the user of the computing device with the first code resource. Responsive to detecting the loss of the interaction with the first code resource, the computing platform may terminate tracking of the first interaction time associated with the first code resource. Then, the computing platform may detect accessing of a second code resource of the codebase by the user of the computing device. Responsive to detecting the accessing of the second code resource, the computing platform may initiate tracking of a second interaction time indicative of a time of an interaction by the user of the computing device with the second code resource. Based on the tracking of the first interaction time and the second interaction time, the computing platform may generate a code complexity metric indicative of a complexity of the codebase. Then, the computing platform may store the code complexity metric in at least one database.

In some embodiments, the computing platform may detect loss of the interaction by the user of the computing device with the second code resource and, responsive to detecting the loss of the interaction with the second code resource, terminate tracking of the second interaction time associated with the second code resource.

In some embodiments, the computing platform may detect accessing of a third code resource of the codebase by the user of the computing device, responsive to detecting the accessing of the third code resource, initiate tracking of a third interaction time indicative of a time of an interaction by the user of the computing device with the third code resource, and update the code complexity metric based on the third interaction time associated with the third code resource.

In some embodiments, the first code resource, the second code resource, and the third code resource may include different code resources.

In some embodiments, detecting accessing of a respective code resource may include detecting accessing of a file, a class, or a function.

In some embodiments, detecting loss of an interaction with a respective code resource may include detecting an expiration of a predetermined duration of time after which accessing of the respective code resource is detected.

In some embodiments, the computing platform may associate the code complexity metric with user identification information, associate the code complexity metric with timestamp information, and normalize the code complexity metric based on the user identification information or the timestamp information.

In some embodiments, the computing platform may determine that the user of the computing device is interacting with a respective code resource based on tracking a cursor on a viewport of the computing device, tracking a keyboard input on the viewport of the computing device, tracking facial movements of the user of the computing device, or tracking processor activity on the computing device.

In some embodiments, the computing platform may apply a machine learning algorithm to the code complexity metric to identify one or more problematic areas of the codebase, and initiate remedial action of the one or more problematic areas of the codebase. In some embodiments, initiating the remedial action of the one or more problematic areas of the codebase may include sending a notification of the one or more problematic areas of the codebase to a management computing device. In some embodiments, applying the machine learning algorithm to the code complexity metric to identify the one or more problematic areas of the codebase may include identifying a technical debt area of the codebase or a resource constrained area of the codebase.

In some embodiments, the computing platform may apply an unsupervised clustering algorithm to the code complexity metric to generate clusters of data associated with contributing users of the codebase, identify insight information about the contributing users of the codebase based on the generated clusters of data, and generate a report based on the insight information. In some embodiments, identifying the insight information may include identifying training opportunities for the contributing users of the codebase or skillset mismatches associated with tasks assigned to the contributing users of the codebase.

In some embodiments, the computing platform may prompt the user of the computing device to provide productivity information indicating a level of productivity of the user of the computing device during a predetermined period of time, and normalize the code complexity metric based on the productivity information provided by the user of the computing device.

DETAILED DESCRIPTION

FIGS. 1A and 1Bdepict an illustrative computing environment for codebase effort tracking in accordance with one or more example embodiments. Referring toFIG. 1A, computing environment100may include one or more computing devices and/or other computing systems. For example, computing environment100may include codebase effort tracking computing platform110, database computer system120, user computing device130, and management computing device140. Although one user computing device130is shown for illustrative purposes, any number of user computing devices may be used without departing from the disclosure. In addition, although one management computing device140is shown for illustrative purposes, any number of management computing devices may be used without departing from the disclosure.

As illustrated in greater detail below, codebase effort tracking computing platform110may include one or more computing devices configured to perform one or more of the functions described herein. For example, codebase effort tracking computing platform110may include one or more computers (e.g., laptop computers, desktop computers, servers, server blades, or the like).

Database computer system120may include different information storage entities storing code and/or code resource information (e.g., file, class, or function information), user identification information (e.g., a user ID), timestamp or other time information (e.g., a data collection time, or an amount of time spent interacting with a code resource), user productivity information (e.g., user-provided distraction response information), and/or other information associated with code complexity determinations.

User computing device130may include one or more computing devices and/or other computer components (e.g., processors, memories, communication interfaces). For instance, user computing device130may be a server, desktop computer, laptop computer, tablet, mobile device, or the like, and may be used by a software developer, or the like. In addition, user computing device130may be associated with an enterprise organization operating codebase effort tracking computing platform110.

Management computing device140may include one or more computing devices and/or other computer components (e.g., processors, memories, communication interfaces). For instance, management computing device140may be a server, desktop computer, laptop computer, tablet, mobile device, or the like, and may be used by a software development manager, human resources manager, training partner, or the like. In addition, management computing device140may be associated with an enterprise organization operating codebase effort tracking computing platform110.

Computing environment100also may include one or more networks, which may interconnect one or more of codebase effort tracking computing platform110, database computer system120, user computing device130, and management computing device140. For example, computing environment100may include network150. Network150may include one or more sub-networks (e.g., local area networks (LANs), wide area networks (WANs), or the like). For example, network150may include a private sub-network that may be associated with a particular organization (e.g., a corporation, financial institution, educational institution, governmental institution, or the like) and that may interconnect one or more computing devices associated with the organization. For example, codebase effort tracking computing platform110, database computer system120, user computing device130, and management computing device140may be associated with an organization (e.g., a financial institution), and network150may be associated with and/or operated by the organization, and may include one or more networks (e.g., LANs, WANs, virtual private networks (VPNs), or the like) that interconnect codebase effort tracking computing platform110, database computer system120, user computing device130, management computing device140. Network150also may include a public sub-network that may connect the private sub-network and/or one or more computing devices connected thereto (e.g., codebase effort tracking computing platform110, database computer system120, user computing device130, and management computing device140) with one or more networks and/or computing devices that are not associated with the organization.

In one or more arrangements, codebase effort tracking computing platform110, database computer system120, user computing device130, and management computing device140may be any type of computing device capable of receiving a user interface, receiving input via the user interface, and communicating the received input to one or more other computing devices. For example, codebase effort tracking computing platform110, database computer system120, user computing device130, management computing device140, and/or the other systems included in computing environment100may, in some instances, include one or more processors, memories, communication interfaces, storage devices, and/or other components. As noted above, and as illustrated in greater detail below, any and/or all of the computing devices included in computing environment100may, in some instances, be special-purpose computing devices configured to perform specific functions.

Referring toFIG. 1B, codebase effort tracking computing platform110may include one or more processor(s)111, memory(s)112, and communication interface(s)113. A data bus may interconnect processor111, memory112, and communication interface113. Communication interface113may be a network interface configured to support communication between codebase effort tracking computing platform110and one or more networks (e.g., network150or the like). Memory112may include one or more program modules having instructions that when executed by processor111cause codebase effort tracking computing platform110to perform one or more functions described herein and/or one or more databases and/or other libraries that may store and/or otherwise maintain information which may be used by such program modules and/or processor111.

In some instances, the one or more program modules and/or databases may be stored by and/or maintained in different memory units of codebase effort tracking computing platform110and/or by different computing devices that may form and/or otherwise make up codebase effort tracking computing platform110. For example, memory112may have, store, and/or include a codebase effort tracking module112a, a codebase effort tracking database112b, and a machine learning engine112c. Codebase effort tracking module112amay have instructions that direct and/or cause codebase effort tracking computing platform110to, for instance, intelligently monitor or track how developers spend their time in a codebase and generate insight into code complexity, as discussed in greater detail below. Codebase effort tracking database112bmay store information used by codebase effort tracking module112aand/or codebase effort tracking computing platform110in intelligently monitoring or tracking how developers spend their time in a codebase, generating insight into code complexity, and/or in performing other functions, as discussed in greater detail below. Machine learning engine112cmay have instructions that direct and/or cause codebase effort tracking computing platform110to set, define, and/or iteratively redefine rules, techniques and/or other parameters used by codebase effort tracking computing platform110and/or other systems in computing environment100in generating insight into code complexity.

FIGS. 2A-2Edepict an illustrative event sequence for codebase effort tracking in accordance with one or more example embodiments.FIG. 3depicts an illustrative time tracking flowchart for codebase effort tracking in accordance with one or more example embodiments. For purposes of illustration,FIGS. 2A-2EandFIG. 3will be discussed together.

Referring toFIG. 2A, at step201, a user of a computing device (e.g., user computing device130), may access and begin interacting with a first code resource of a codebase. For example, the first code resource may be a file in the codebase. At step202, codebase effort tracking computing platform110may detect the accessing of the first code resource by the user of the computing device (e.g., user computing device130).

At step203, codebase effort tracking computing platform110may initiate tracking of a first interaction time associated with the first code resource. In initiating tracking of the first interaction time associated with the first code resource, codebase effort tracking computing platform110may utilize one or more time tracking tools or applications (e.g., one or more timers installed on a user computing device). The first interaction time may be indicative of an amount of time spent by the user of the computing device (e.g., user computing device130) interacting with the first code resource. In some examples, codebase effort tracking computing platform110may determine that the user of the computing device (e.g., user computing device130) is interacting with (e.g., actively focusing on or working on) the first code resource based on tracking a cursor (e.g., a mouse cursor) on a viewport of the computing device, tracking a keyboard input on the viewport of the computing device, tracking facial or body movements of the user of the computing device (e.g., using eye detection or motion detection), or tracking processor activity on the computing device (e.g., CPU process inspection).

At step204, codebase effort tracking computing platform110may detect loss of the interaction by the user of the computing device (e.g., user computing device130) with the first code resource. At step205, responsive to detecting the loss of interaction with the first code resource, codebase effort tracking computing platform110may terminate tracking of the first interaction time associated with the first code resource. In some examples, detecting loss of the interaction with the first code resource may include detecting an expiration of a predetermined duration of time (e.g., a time window or threshold), such as a predetermined number of minutes, or other time measurement, after which accessing of the first code resource is detected (e.g., at step202).

By way of non-limiting example, referring toFIG. 3, at step305, codebase effort tracking computing platform110may detect when the file is opened, and at step310, begin tracking the time spent while the file is in active focus (e.g., file time tracking). At step315, codebase effort tracking computing platform110may continue tracking the time spent in the file as long as the user of the computing device (e.g., user computing device130) continues to interact with the file (e.g., the user or developer is actively focusing on the file, or the file remains viewable within a window of a development environment). At step318, when the user of the computing device (e.g., user computing device130), stops interacting with the file (e.g., the user or developer is no longer actively focusing on the file, or the file is no longer viewable within a window of a development environment), codebase effort tracking computing platform110may stop tracking the time spent in the file. For example, the user or developer may have switched to another file or to another program completely.

Referring toFIG. 2B, at step206, the user of the computing device (e.g., user computing device130), may access and begin interacting with a second code resource of a codebase. For example, the second code resource may be a class (e.g., a class within a file). At step207, codebase effort tracking computing platform110may detect the accessing of the second code resource by the user of the computing device (e.g., user computing device130).

At step208, codebase effort tracking computing platform110may initiate tracking of a second interaction time associated with the second code resource. In initiating tracking of the second interaction time associated with the first code resource, codebase effort tracking computing platform110may utilize one or more time tracking tools or applications (e.g., one or more timers installed on a user computing device). The second interaction time may be indicative of an amount of time spent by the user of the computing device (e.g., user computing device130) interacting with the second code resource. In some examples, codebase effort tracking computing platform110may determine that the user of the computing device (e.g., user computing device130) is interacting with (e.g., actively focusing on or working on) the second code resource based on tracking a cursor (e.g., a mouse cursor) on a viewport of the computing device, tracking a keyboard input on the viewport of the computing device, tracking facial or body movements of the user of the computing device (e.g., using eye detection or motion detection), or tracking processor activity on the computing device (e.g., CPU process inspection).

At step209, codebase effort tracking computing platform110may detect loss of the interaction by the user of the computing device (e.g., user computing device130) with the second code resource. At step210, responsive to detecting the loss of interaction with the second code resource, codebase effort tracking computing platform110may terminate tracking of the second interaction time associated with the second code resource. In some examples, detecting loss of the interaction with the second code resource may include detecting an expiration of a predetermined duration of time (e.g., a time window or threshold), such as a predetermined number of minutes, or other time measurement, after which accessing of the second code resource is detected (e.g., at step207).

By way of non-limiting example, referring toFIG. 3, at step320, with a file in active focus, codebase effort tracking computing platform110may detect when a class enters a viewport of the computing device (e.g., user computing device130), and at step325, begin tracking the time spent while the class is in active focus (e.g., class time tracking). At step330, codebase effort tracking computing platform110may continue tracking the time spent in the class as long as the user of the computing device (e.g., user computing device130) continues to interact with the class (e.g., the user or developer is actively focusing on the class, or the class remains viewable within a window of a development environment). Additionally or alternatively, since a class may span several screens and potentially several files, codebase effort tracking computing platform110may, at step330, continue class time tracking as long as any related class functions are visible in the viewport of the computing device (e.g., user computing device130) and the file is in active focus at step315. At step332, when the user of the computing device (e.g., user computing device130), stops interacting with the class (e.g., the user or developer is no longer actively focusing on the class and related class function(s), or the class and related class function(s) are no longer viewable within a window of a development environment), codebase effort tracking computing platform110may stop tracking the time spent in the class.

Referring toFIG. 2C, at step211, based on the tracking of the first interaction time associated with the first code resource and the second interaction time associated with the second code resource, codebase effort tracking computing platform110may generate a code complexity metric indicative of a complexity of the codebase. At step212, codebase effort tracking computing platform110may store the code complexity metric in at least one database (e.g., database computer system120), which may be maintained by the computing platform or any of the devices described herein.

Subsequently, codebase effort tracking computing platform110repeat one or more steps of the example event sequence discussed above (e.g., for additional or different code resources, such as modules or methods within a codebase) in determining code complexity more accurately and consistently. For example, at step213, a user of a computing device (e.g., user computing device130), may access and begin interacting with a third code resource of a codebase. For example, the third code resource may be a function (e.g., a function within a class). At step214, codebase effort tracking computing platform110may detect the accessing of the third code resource by the user of the computing device (e.g., user computing device130).

At step215, codebase effort tracking computing platform110may initiate tracking of a third interaction time associated with the third code resource. In initiating tracking of the third interaction time associated with the first code resource, codebase effort tracking computing platform110may utilize one or more time tracking tools or applications (e.g., one or more timers installed on a user computing device). The third interaction time may be indicative of an amount of time spent by the user of the computing device (e.g., user computing device130) interacting with the third code resource. In some examples, codebase effort tracking computing platform110may determine that the user of the computing device (e.g., user computing device130) is interacting with (e.g., actively focusing on or working on) the third code resource based on tracking a cursor (e.g., a mouse cursor) on a viewport of the computing device, tracking a keyboard input on the viewport of the computing device, tracking facial or body movements of the user of the computing device (e.g., using eye detection or motion detection), or tracking processor activity on the computing device (e.g., CPU process inspection).

Referring toFIG. 2D, at step216, codebase effort tracking computing platform110may detect loss of the interaction by the user of the computing device (e.g., user computing device130) with the third code resource. At step217, responsive to detecting the loss of interaction with the third code resource, codebase effort tracking computing platform110may terminate tracking of the third interaction time associated with the third code resource. In some examples, detecting loss of the interaction with the third code resource may include detecting an expiration of a predetermined duration of time (e.g., a time window or threshold), such as a predetermined number of minutes, or other time measurement, after which accessing of the third code resource is detected (e.g., at step214). At step218, codebase effort tracking computing platform110may update the code complexity metric based on the third interaction time associated with the third code resource. At step219, codebase effort tracking computing platform110may store the updated code complexity metric in at least one database (e.g., database computer system120), which may be maintained by the computing platform or any of the devices described herein.

By way of non-limiting example, referring toFIG. 3, at step335, with a file and/or class in active focus, codebase effort tracking computing platform110may detect when a function enters a viewport of the computing device (e.g., user computing device130), and at step340, begin tracking the time spent while the function is in active focus (e.g., function time tracking). At step345, codebase effort tracking computing platform110may continue tracking the time spent in the function as long as the user of the computing device (e.g., user computing device130) continues to interact with the function (e.g., the user or developer is actively focusing on the function, or the function remains viewable within a window of a development environment). At step348, when the user of the computing device (e.g., user computing device130), stops interacting with the function (e.g., the user or developer is no longer actively focusing on the function, or the function is no longer viewable within a window of a development environment), codebase effort tracking computing platform110may stop tracking the time spent in the function.

Since different programming languages may organize and structure code differently, tracking time at granular levels (e.g., at a file level, at a class level, at a function level, and/or at additional levels), as discussed in detail above, may generate meaningful and useful metrics. For example, some programming languages organize classes by separate files whereas other programming languages may contain multiple classes within a single file. Additionally, a class may include many functions and there may be a subset of class functions that are consuming inordinate amounts of developer time. As a result, it is advantageous to track codebase effort at the granular file level, class level, and function level. Additionally, in some embodiments, the time tracked at the file level is not automatically the sum of the time spent on a particular class or function (e.g., due to partial classes that might be spread across multiple files).

Referring toFIG. 2E, at step220, in some embodiments, codebase effort tracking computing platform110may perform data normalization and/or machine learning operations. In some examples, codebase effort tracking computing platform110may associate or tag the code complexity metric with user identification information and/or timestamp information. Then, codebase effort tracking computing platform110may normalize the code complexity metric based on the user identification information or the timestamp information. Such user identification information may identify contributing users of the codebase (e.g., developers contributing to the codebase, including the user of the computing device130). Such timestamp information may correspond to respective tracked interaction times (e.g., times at which a time metric is collected).

In some examples, codebase effort tracking computing platform110may apply a machine learning algorithm (e.g., a supervised learning algorithm) to the code complexity metric to identify one or more problematic areas of the codebase and initiate remedial action of the one or more problematic areas of the codebase. For instance, initiating the remedial action of the one or more problematic areas of the codebase may include providing a notification of the one or more problematic areas of the codebase to a management computing device (e.g., management computing device140). For instance, applying the machine learning algorithm to the code complexity metric to identify the one or more problematic areas of the codebase may include identifying a technical debt area of the codebase (e.g., areas of code where shortcuts may have been taken during development of a software project in order to meet a deliverable) or a resource constrained area of the codebase (e.g., areas of code needing additional developers and/or developers with specific skillsets).

In some examples, codebase effort tracking computing platform110may apply an unsupervised clustering algorithm to the code complexity metric to generate clusters of data associated with contributing users of the codebase. Based on the generated clusters of data, codebase effort tracking computing platform110may identify insight information about the contributing users of the codebase and generate a report based on the insight information. For instance, identifying the insight information comprises identifying (e.g., flagging) training or coaching opportunities for the contributing users of the codebase, or identifying skillset mismatches associated with tasks assigned to the contributing users of the codebase. In some examples, codebase effort tracking computing platform110may use the clustering information to identify individual developers belonging to a cluster of slow-performing developers. In some examples, codebase effort tracking computing platform110may use the clustering information to identify developers with skillsets that do not match the needs of a software development project (e.g., web developers assigned to a project that is primarily a database system).

At step221, in some embodiments, codebase effort tracking computing platform110may prompt, via a communication interface (e.g., communication interface113), the user of the computing device (e.g., user computing device130) to provide productivity information indicating a level of productivity of the user of the computing device (e.g., user computing device130) during a predetermined period of time. For example, in prompting the user of the computing device (e.g., user computing device130) to provide productivity information, codebase effort tracking computing platform110may cause the user computing device (e.g., user computing device130) to display and/or otherwise present one or more graphical user interfaces similar to graphical user interface400, which is illustrated inFIG. 4. As seen inFIG. 4, graphical user interface400may include text and/or other information polling the user of the user computing device (e.g., user computing device130) to provide a distraction response (e.g., “Using a scale of 0-5, 0=Not at all Distracted and 5=Very Distracted, how would you rate your productivity today? [0 . . . ] [1 . . . ] [2 . . . ] [3 . . . ] [4 . . . ] [5 . . . ]”). It will be appreciated that other and/or different notifications may also be provided.

Returning toFIG. 2E, at step222, codebase effort tracking computing platform110may receive, via the communication interface (e.g., communication interface113), the productivity information (e.g., developer-provided distraction response) from the user of the computing device (e.g., user computing device130). In addition, codebase effort tracking computing platform110may normalize the code complexity metric based on the productivity information provided by the user of the computing device (e.g., user computing device130).

At step223, codebase effort tracking computing platform110may generate and send, via a communication interface (e.g., communication interface113), reports or notifications (e.g., an information reporting dashboard) to a user of management computing device140or another user of a user computing device that provide a comprehensive and accurate understanding of code complexity for a software development project. At step224, codebase effort tracking computing platform110may cause the management computing device140to display and/or otherwise present the reports or notifications. For example, in generating a report or a notification, codebase effort tracking computing platform110may cause the management computing device (e.g., management computing device140) or other user computing device to display and/or otherwise present one or more graphical user interfaces similar to graphical user interface500, which is illustrated inFIG. 5. As seen inFIG. 5, graphical user interface500may include text and/or other information providing the user of the management computing device (e.g., management computing device140) with generated insight information about the contributing users (e.g., developers) of the codebase (e.g., “Welcome to your Reporting Dashboard. Here you may view: [Project Management Recommendations . . . ] [Identified Training Opportunities . . . ] [Identified Skillset Mismatches . . . ]”). It will be appreciated that other and/or different notifications may also be provided.

FIG. 6depicts an illustrative method for codebase effort tracking in accordance with one or more example embodiments. Referring toFIG. 6, at step605, a computing platform having at least one processor, a communication interface, and memory may detect accessing of a first code resource of a codebase by a user of a computing device. At step610, responsive to detecting the accessing of the first code resource, the computing platform may initiate tracking of a first interaction time indicative of a time of an interaction by the user of the computing device with the first code resource. At step615, the computing platform may detect loss of the interaction by the user of the computing device with the first code resource. At step620, responsive to detecting the loss of the interaction with the first code resource, the computing platform may terminate tracking of the first interaction time associated with the first code resource. At step625, the computing platform may detect accessing of a second code resource of the codebase by the user of the computing device. At step630, responsive to detecting the accessing of the second code resource, the computing platform may initiate tracking of a second interaction time indicative of a time of an interaction by the user of the computing device with the second code resource. At step635, based on the tracking of the first interaction time and the second interaction time, the computing platform may generate a code complexity metric indicative of a complexity of the codebase. At step640, the computing platform may store the code complexity metric in at least one database.