EXPERTISE SCORE VECTOR FOR SOFTWARE COMPONENT MANAGEMENT

Techniques for an expertise score vector for software component management are described herein. An aspect includes maintaining a plurality of metrics in an expertise score vector corresponding to a developer. Another aspect includes identifying a subset of the plurality of metrics that are relevant to a work item corresponding to a software component. Another aspect includes applying respective weights to the subset of the plurality of metrics. Another aspect includes determining an expertise score for the developer based on the weighted subset of the plurality of metrics, wherein determining the expertise score comprises determining a magnitude of a vector comprising the weighted subset of the plurality of metrics. Another aspect includes assigning the work item to the developer based on the expertise score.

BACKGROUND

The present invention generally relates to computer systems, and more specifically, to an expertise score vector for software component management in a computer system.

Computer systems control almost every aspect of our life—from writing documents to controlling traffic lights. Such computer systems are controlled by software components that may be written by teams of software developers. The software components may be relatively complex, requiring relatively large numbers of developers working together to produce and maintain computer code that is executed on a computer system. Further, computer systems may be often error-prone, and thus require a testing phase in which any errors should be discovered. The testing phase is considered one of the most difficult tasks in designing a computer system. The cost of not discovering an error may be enormous, as the consequences of the error may be disastrous.

SUMMARY

Embodiments of the present invention are directed to an expertise score vector for software component management. A non-limiting example computer-implemented method includes maintaining a plurality of metrics in an expertise score vector corresponding to a developer. The method also includes identifying a subset of the plurality of metrics that are relevant to a work item corresponding to a software component. The method also includes applying respective weights to the subset of the plurality of metrics. The method also includes determining an expertise score for the developer based on the weighted subset of the plurality of metrics, wherein determining the expertise score comprises determining a magnitude of a vector comprising the weighted subset of the plurality of metrics. The method also includes assigning the work item to the developer based on the expertise score

DETAILED DESCRIPTION

One or more embodiments of the present invention provide an expertise score vector for software component management. An organization may produce and maintain computer software products for use on computer systems that include multiple software components. Each software component may be assigned a team of developers that are responsible for the software component. Creating software (i.e., developing) for different computer systems that implement relatively complex software components may require specialized knowledge and skills by a software developer. Such knowledge and skills may be gained through experience developing for a particular computer system and/or software component. In order to maintain relatively high quality in software that is produced by an organization, respective expertise score vectors may be maintained for each developer in an organization to identify levels of skills and component mastery for individual developers. Work items may be assigned to developers based on expertise scores that are determined based on the expertise score vectors. For example, a more experienced developer having a higher expertise score may be assigned relatively complex work items, while a less experienced developer having a lower expertise score may be assigned relatively simple work items.

An expertise score vector may include any appropriate metrics regarding a developer, including but not limited to time spent using a technology or skill (i.e., five years using Java, 6 months doing front-end development, etc.), certifications, awards, and/or badges earned, time spent working on a software component, number of lines of code written using a technology, and number of lines of code written in a software component. The expertise score vector may be used to create a vector topology including a subset of metrics that may be used to determine a developer's expertise score for a particular skill or software component. An expertise score may be determined by tracking the various metrics in the expertise score vector, applying respective weights to the metrics that are relevant to the particular software component or skill, adding the weighted metrics to a subset vector, and calculating the magnitude of the subset vector.

Embodiments of an expertise score vector may include a regression testing metric that quantifies how quickly a developer's committed code passes regression testing. If a developer writes code that fails regression, the developer may then fix the issues and resubmit the code for an additional round of regression testing. Regression testing may be repeated a number of times; however, for code that fails regression testing repeatedly, the developer may be adjusting the code just to pass regression, which may result in relatively low quality code. Committed code that passes regression testing with a relatively low number of testing iterations may indicate a higher level of expertise regarding the software component by the developer.

Embodiments of an expertise score vector may include a problem records metric that tracks a number of problem records that have been opened for code written by an individual developer. A developer with a higher number of problem records per line of committed code may have a lower problem records metric value than a developer having a lower number of problem records per line of code. However, it is possible that committed code written by a developer is run relatively infrequently in the deployed software component. For example, if a developer writes code for a code path that is not often exercised, then even if problems exist in the code, a problem record may not be opened for the code. Therefore, the problem records metric for a piece of code may be weighted according to an amount of time that the code has been deployed in the field. A problem record may impact the developer's problem records metric more severely based on the amount of time the code has been deployed, i.e., for code that has been deployed a longer time, a problem record may not impact the problem records metric as much as a problem record corresponding to code that has been deployed a relatively short amount of time. The severity and type of a problem record may also be extracted and used to weigh the effect of the problem record on the developer's problem records metric. For example, a low severity bug or a documentation error may not affect a problem records metric as much as a problem that causes a major loss of functionality.

Before code written by a developer is added to a code base of a software component, another developer may perform a code review of the code. When a developer reviews another developer's code, submits a request for a change, and that change is honored, it may be determined that the reviewing developer has expertise regarding the code. A code review change metric in the expertise score vector may track a number of times change requests by a reviewing developer are implemented in the reviewed code, and the reviewer's expertise score may increase based on the code review change metric. The code review change metric may be decreased based on a number of review change requests by a reviewer that are ignored.

Committed code in a software component may be analyzed for various quality metrics. The analysis may include static analysis and/or linting in some embodiments. One or more code quality metrics may be tracked that include, but are not limited to, a number of comments, degree of code complexity, adherence to convention (e.g., style), and number of code smells. Individual metrics may be weighted based on relative importance (e.g., missing a comment may be weighted lower than introducing an extreme level of code complexity into a software component). The quality metrics may be combined with review comments and automated regression results to determine an overall measurement of code quality. The overall code quality measurement may be determined for an individual developer for a specific software component, or across multiple software components, and may be used to determine the developer's expertise score. Code smells may indicate problems in committed code, as good code may have less code smells than bad code. When a developer submits code, the number of code smells may be calculated, and an average code smell per lines of code can be calculated for the developer and saved in the expertise score vector.

Metrics in an expertise score vector may be weighted such that selected metrics may carry different weights in determining an expertise score of a developer. For example, if time spent working on a particular software component is determined to be less important than time spent using Java for the particular software component, the time for the particular software component metric may be multiplied by a smaller weight (e.g., 0.5) while time spent using Java metric may be multiplied by a larger weight (e.g., 1.15) before the weighted metrics are used to determine an overall expertise score. An overall expertise score may be determined by calculating the magnitude of a subset vector that includes the selected, weighted metrics from the expertise score vector. An overall expertise score may be calculated for a particular skill or software component in some embodiments, such that only metrics in the expertise score vector that are related to the particular skill or software component are used to determine the overall expertise score.

As shown inFIG. 1, the computer system100has one or more central processing units (CPU(s))101a,101b,101c, etc. (collectively or generically referred to as processor(s)101). The processors101can be a single-core processor, multi-core processor, computing cluster, or any number of other configurations. The processors101, also referred to as processing circuits, are coupled via a system bus102to a system memory103and various other components. The system memory103can include a read only memory (ROM)104and a random access memory (RAM)105. The ROM104is coupled to the system bus102and may include a basic input/output system (BIOS), which controls certain basic functions of the computer system100. The RAM is read-write memory coupled to the system bus102for use by the processors101. The system memory103provides temporary memory space for operations of said instructions during operation. The system memory103can include random access memory (RAM), read only memory, flash memory, or any other suitable memory systems.

The computer system100comprises an input/output (I/O) adapter106and a communications adapter107coupled to the system bus102. The I/O adapter106may be a small computer system interface (SCSI) adapter that communicates with a hard disk108and/or any other similar component. The I/O adapter106and the hard disk108are collectively referred to herein as a mass storage110.

Software111for execution on the computer system100may be stored in the mass storage110. The mass storage110is an example of a tangible storage medium readable by the processors101, where the software111is stored as instructions for execution by the processors101to cause the computer system100to operate, such as is described herein below with respect to the various Figures. Examples of computer program product and the execution of such instruction is discussed herein in more detail. The communications adapter107interconnects the system bus102with a network112, which may be an outside network, enabling the computer system100to communicate with other such systems. In one embodiment, a portion of the system memory103and the mass storage110collectively store an operating system, which may be any appropriate operating system, such as the z/OS or AIX operating system from IBM Corporation, to coordinate the functions of the various components shown inFIG. 1.

Additional input/output devices are shown as connected to the system bus102via a display adapter115and an interface adapter116and. In one embodiment, the adapters106,107,115, and116may be connected to one or more I/O buses that are connected to the system bus102via an intermediate bus bridge (not shown). A display119(e.g., a screen or a display monitor) is connected to the system bus102by a display adapter115, which may include a graphics controller to improve the performance of graphics intensive applications and a video controller. A keyboard121, a mouse122, a speaker123, etc. can be interconnected to the system bus102via the interface adapter116, which may include, for example, a Super I/O chip integrating multiple device adapters into a single integrated circuit. Suitable I/O buses for connecting peripheral devices such as hard disk controllers, network adapters, and graphics adapters typically include common protocols, such as the Peripheral Component Interconnect (PCI). Thus, as configured inFIG. 1, the computer system100includes processing capability in the form of the processors101, and, storage capability including the system memory103and the mass storage110, input means such as the keyboard121and the mouse122, and output capability including the speaker123and the display119.

In some embodiments, the communications adapter107can transmit data using any suitable interface or protocol, such as the internet small computer system interface, among others. The network112may be a cellular network, a radio network, a wide area network (WAN), a local area network (LAN), or the Internet, among others. An external computing device may connect to the computer system100through the network112. In some examples, an external computing device may be an external webserver or a cloud computing node.

It is to be understood that the block diagram ofFIG. 1is not intended to indicate that the computer system100is to include all of the components shown inFIG. 1. Rather, the computer system100can include any appropriate fewer or additional components not illustrated inFIG. 1(e.g., additional memory components, embedded controllers, modules, additional network interfaces, etc.). Further, the embodiments described herein with respect to computer system100may be implemented with any appropriate logic, wherein the logic, as referred to herein, can include any suitable hardware (e.g., a processor, an embedded controller, or an application specific integrated circuit, among others), software (e.g., an application, among others), firmware, or any suitable combination of hardware, software, and firmware, in various embodiments.

Turning now toFIG. 2, a process flow diagram of a method200for software component management using an expertise score vector is generally shown in accordance with one or more embodiments of the present invention. Method200may be implemented in conjunction with any appropriate computer system, such as computer system100ofFIG. 1. In block201of method200, a regression testing metric is determined for a developer, and a regression testing metric in an expertise score vector associated with the developer is updated based on the determination. The regression testing metric may be determined based on a number of attempts required for committed code by the developer to pass regression testing. A relatively large number of attempts required for committed code to pass regression testing may correspond to a lower regression testing metric in some embodiments. Block201of method200may be triggered based on a developer committing code to any software component, and the committed code being subjected to regression testing. In some embodiments, for a developer that contributes to multiple software components, separate regression testing metrics may be maintained in the expertise score vector for the different software components. Determination of the regression testing metric is discussed below with respect toFIG. 3.

In block202, a problem records metric is determined for the developer, and a problem records metric in an expertise score vector associated with the developer is updated based on the determination. The problem records metric may be determined based on a problem record being received that corresponds to deployed code that was written by the developer. Block202of method200may be triggered based on a problem record being received for the developer's code. In some embodiments, for a developer that contributes to multiple software components, separate problem records metrics may be maintained in the expertise score vector for the different software components. Determination of the problem records metric is discussed below with respect toFIG. 4.

In block203, a code change review metric is determined for the developer, and a code change review metric in an expertise score vector associated with the developer is updated based on the determination. The code change review metric may be determined for a reviewing developer based on a code review by the reviewing developer of committed code that was written by another developer. Block203of method200may be triggered based on a reviewing developer submitting a code review change request for committed code that was written by another developer(s). In some embodiments, for a developer that performs code reviews for multiple software components, separate code change review metrics may be maintained in the expertise score vector for the different software components. Determination of the code change review metric is discussed below with respect toFIG. 5.

In block204, a code quality metric is determined for the developer, and a code quality metric in an expertise score vector associated with the developer is updated based on the determination. The code quality metric may be determined based on a code quality analysis of committed code that was written by the developer. Block204of method200may be triggered based on a developer committing code to any software component, and the committed code being subjected to code quality analysis. The code quality analysis may include static analysis and/or linting of the committed code in some embodiments. Any appropriate code quality metrics may be determined in block204, including but not limited to a number of comments, degree of code complexity, adherence to convention (e.g., style), and number of code smells. Individual metrics may be weighted based on relative importance (e.g., missing a comment may be weighted lower than introducing extreme levels of code complexity into a software component). For example, code smells may indicate problems in committed code, as good code may have less code smells than bad code. When a developer commits code for a software component, the number of code smells in the committed code may be automatically calculated in block204, and an average code smell per lines of code can be calculated for the developer and saved in a code quality metric in the expertise score vector. Code quality metrics may be combined with review comments and automated regression results in some embodiments to determine an overall measurement of code quality. In some embodiments, the code quality metric may include an average number of compile attempts per committed code unit of contribution. In some embodiments, the code quality metric may include an average number of commits per committed code unit of contribution. An overall code quality measurement may be determined for an individual developer for a specific software component, or across multiple software components for a specific skill.

In block205, respective weights may be applied to selected metric fields in the expertise score vector of the developer, and the selected weighted metrics may be combined to determine an expertise score corresponding to the developer. The selected metrics in an expertise score vector may be weighted such that different metrics may carry different weights in determining the expertise score. For example, if time spent working on a particular component is determined to be less important than time spent using Java for a particular software component, the time for the particular component metric may be multiplied by a smaller weight (e.g., 0.5) while time spent using Java metric may be multiplied by a larger weight (e.g., 1.15) before the weighted metrics are used to determine an overall expertise score for the software component. An expertise score may be determined by calculating a magnitude of a subset vector that includes the set of weighted selected metrics. An expertise score may be calculated for a particular skill or software component in some embodiments, such that only metrics in the expertise score vector that are related to the particular skill or software component are selected and used to determine the expertise score. Any of the metrics that were updated according to blocks201,202,203, and204may be selected, and have respective weights applied, to determine an expertise score in block205.

In block206, a work item is assigned to the developer based on the expertise score that was determined in block205. For example, for a work item that is related to a particular software component, an expertise score may be determined for each developer on a team corresponding to the software component in block206. The expertise scores may be calculated using metrics from each developer's expertise score vector that are determined to be relevant to the particular software component. The work item may then be assigned to a developer from the team based on the calculated expertise scores, e.g., a developer having a highest expertise score may be selected for a relatively complex and/or higher priority work item in block206, while a developer having a lower expertise score may be selected for a less complex and/or lower priority work item in block206.

Embodiments of method200may be implemented in software component management system600ofFIG. 6A, which is discussed in further detail below. An embodiment of an expertise score vector, which may be used in conjunction with method200, is discussed below with respect toFIG. 6B.

The process flow diagram ofFIG. 2is not intended to indicate that the operations of the method200are to be executed in any particular order, or that all of the operations of the method200are to be included in every case. Additionally, the method200can include any suitable number of additional operations.

FIG. 3shows a process flow diagram of a method300for determination of a regression testing metric for an expertise score vector for software component management in accordance with one or more embodiments of the present invention. Method300may be implemented in conjunction with any appropriate computer system, such as computer system100ofFIG. 1, and may be performed in block201of method200ofFIG. 2. In block301, based on a work item being assigned to a developer, a regression count (NUM_REGRESS) is initialized for the work item. In block302, code corresponding to the work item is committed by the developer. In block303, regression testing is performed on the code that was committed in block302. The regression testing of block303may be performed in any appropriate manner. In block304it is determined whether the code passed the regression testing of block303. If the code did not pass the regression testing, flow proceeds from block304to block305, and NUM_REGRESS is incremented. Flow then proceeds from block305back to block302, in which the developer commits corrected code corresponding to the work item based on the failure of the regression testing that was determined in block304. The corrected code is then regression tested in block303, and it is determined whether the corrected code passed the regression testing in block304. Blocks304,305,302, and303are repeated until it is determined that the code corresponding to the work item has passed the regression testing in block304. Based on the code corresponding to the work item passing the regression testing in block304, flow proceeds from block304to block306, and a regression testing metric in the developer's expertise score vector is updated based on NUM_REGRESS.

The process flow diagram ofFIG. 3is not intended to indicate that the operations of the method300are to be executed in any particular order, or that all of the operations of the method300are to be included in every case. Additionally, the method300can include any suitable number of additional operations.

FIG. 4shows a process flow diagram of a method400for determination of a problem records metric for an expertise score vector for software component management in accordance with one or more embodiments of the present invention. Method400may be implemented in conjunction with any appropriate computer system, such as computer system100ofFIG. 1, and may be performed in block202of method200ofFIG. 2. In block401, a problem record is received for deployed code that was written by a developer. The deployed code may be part of a particular software component. In block402, the received problem record is processed to determine a severity and type of the problem corresponding to the problem record. The processing may include natural language processing (NLP) to extract keywords from the problem record in some embodiments. A problem record score is determined in block402based on the determined severity and type of the problem associated with the problem record that was received in block401. For example, a low severity bug or a documentation error may correspond to a lower problem record score in block402than a problem that causes a major loss of functionality in the software component.

In block403, an amount of time the code associated with the problem record has been deployed in the field is determined. In block404, a weight is applied to the problem record score that was determined in block402according to the amount of time that was determined in block403. For example, for code that has been deployed in the field a relatively short amount of time before the problem was discovered and the problem record was generated, the problem record score may be given a higher weight (and correspondingly may decrease the developer's expertise score more) than if the code has been deployed in the field a relatively long amount of time before the problem record was generated. In block405, a problem records metric in the developer's expertise score vector is updated based on the weighted problem record score that was determined in block404. In some embodiments, the problem records metric that is updated in block405may be associated with the particular software component.

The process flow diagram ofFIG. 4is not intended to indicate that the operations of the method400are to be executed in any particular order, or that all of the operations of the method400are to be included in every case. Additionally, the method400can include any suitable number of additional operations.

FIG. 5shows a process flow diagram of a method500for determination of a code review change metric for an expertise score vector for software component management in accordance with one or more embodiments of the present invention. Method500may be implemented in conjunction with any appropriate computer system, such as computer system100ofFIG. 1, and may be performed in block203of method200ofFIG. 2. In block501, a reviewing developer submits a code review change request for committed code that was written by one or more other developers. The code review may have been triggered by the committing of the code that is being reviewed. In block502, it is determined whether the code review change request that was received in block501was implemented in the code. For example, if the code review change request is determined to be incorrect by the developer that wrote the reviewed code, the code review change request may not be implemented. If it is determined in block502that the code review change request was not implemented, flow proceeds from block502to block503. In block503, a code change review metric in the expertise score vector corresponding to the reviewing developer is decreased. If it is determined in block502that the code review change request was implemented, flow proceeds from block502to block504. In block504, a code change review metric in the expertise score vector corresponding to the reviewing developer is increased.

The process flow diagram ofFIG. 5is not intended to indicate that the operations of the method500are to be executed in any particular order, or that all of the operations of the method500are to be included in every case. Additionally, the method500can include any suitable number of additional operations.

Turning now toFIG. 6A, a software component management system600that includes an expertise score vector is generally shown in accordance with one or more embodiments of the present invention. Software component management system600may be implemented in conjunction with any appropriate computer system(s), including but not limited to computer system100ofFIG. 1. Software component management system600is in communication with software component code bases610A-N, which each include computer code written by one or more developers on teams corresponding to various software components. The software component management system600includes an expertise score vector module601, which may maintain a respective expertise score vector of expertise score vectors602A-N for each developer across various teams in the organization. Expertise score vector module601and expertise score vectors602A-N are discussed in further detail below with respect toFIG. 6B.

Software component management system600includes a problem records module603, which receives and manages problem records (e.g., bug reports) regarding the software component code bases610A-N. NLP module604performs analysis of problem records that are received by problem records module603and may, for example, output keywords that are identified in a problem record to work item management module605. Work item management module605creates work items based on problem records that are received by problem records module603. The work items may be created by work item management module605based on keywords that were identified by NLP module604in some embodiments. Work item management module605may also create work items based on new feature requests for the software components corresponding to software component code bases610A-N. Created work items are placed in a work item queue606by work item management module605. The work items in work item queue606are assigned to developers by work item management module605based on input from expertise score vector module601and data from the developers' respective expertise score vectors602A-N. Work queue points module640may track a respective workload for each developer that is currently assigned to any work items in work item queue606.

When new code is committed by a developer into any of software component code bases610A-N, code analysis module607may review the new code to determine a code quality of the new code. Review and testing module608may determine and apply a review and testing process to new code, and may also assign one or more developers to the review and testing process based on expertise score vectors602A-N. Review and testing module608may also provide data regarding the review and testing of code to expertise score vector module601.

Component complexity and onboarding score module609may determine a relative component complexity and an onboarding score for each software component corresponding to software component code bases610A-N. Component complexity and onboarding score module609may operate based on component mastery metrics631A-N and developer classification module622ofFIG. 6B, which are discussed below.

Software component management system600may implement embodiments of method200ofFIG. 2. Regression testing metrics, problem records metrics, code review change metrics, and code quality metrics, may be determined by expertise score vector module601according to blocks201-204of method200ofFIG. 2, and stored in expertise score vectors602A-N. Regression testing metrics may be determined by expertise score vector module601in block201of method200ofFIG. 2(according to method300ofFIG. 3) based on input from review and testing module608. Problem records metrics may be determined by expertise score vector module601in block202ofFIG. 2(according to method400ofFIG. 4) based on input from problem records module603and NLP module604. Code review change metrics may be determined by expertise score vector module601in block203of method200ofFIG. 2(according to method500ofFIG. 5) based on input from review and testing module608. Code quality metrics may be determined by expertise score vector module601in block204of method200ofFIG. 2based on input from code analysis module607. Expertise score vector module601may determine an expertise score using a selected set of weighted metrics from an expertise score vector of expertise score vectors602A-N in block205of method200ofFIG. 2, and a work item from work item queue606may be assigned to a developer by work item management module605based on the determined expertise score in block206of method200ofFIG. 2.

It is to be understood that the block diagram ofFIG. 6Ais not intended to indicate that the system600is to include all of the components shown inFIG. 6A. Rather, the system600can include any appropriate fewer or additional components not illustrated inFIG. 6A(e.g., additional memory components, embedded controllers, functional blocks, connections between functional blocks, modules, inputs, outputs, etc.). Further, the embodiments described herein with respect to system600may be implemented with any appropriate logic, wherein the logic, as referred to herein, can include any suitable hardware (e.g., a processor, an embedded controller, or an application specific integrated circuit, among others), software (e.g., an application, among others), firmware, or any suitable combination of hardware, software, and firmware, in various embodiments.

Turning now toFIG. 6B, an expertise score vector module601is generally shown in accordance with one or more embodiments of the present invention. Expertise score vector module601ofFIG. 6Bcorresponds to expertise score vector module601ofFIG. 6A, and manages a plurality of expertise score vectors602A-N. Expertise score vector module601includes an expertise score vector update module620, which may update any field in an expertise score vector602N based on data from problem records module603, work item management module605, code analysis module607, and review and testing module608in software component management system600.

Expertise score calculation module621may determine an expertise score for a developer based on the developer's expertise score vector602N. An expertise score may be determined based on any appropriate subset of the fields in expertise score vector602N, and the various fields in expertise score vector602N may each be given any appropriate weight in calculating an expertise score. An expertise score may be calculated by expertise score calculation module621for a specific skill in some embodiments, such that only fields related to the specific skill are used to calculate the expertise score for the specific skill. In some embodiments, an expertise score that is calculated for a specific skill or software component may be used to assign work items to developers by work item management module605as described in blocks205and206of method200ofFIG. 2. Developer classification module622may determine a classification for a developer based on an expertise score from expertise score calculation module621. In some embodiments, the developer classification that is calculated by developer classification module622may be used to assign work items to developers.

Expertise score vector602N corresponds to a single developer in an organization. Expertise score vector602N includes a developer and team identifier630, which includes a unique identifier of the developer corresponding to expertise score vector602N, and any teams that the developer is part of. A developer may be part of multiple teams in some embodiments. Expertise score vector602N includes a plurality of data fields corresponding to the developer.

Expertise score vector602N may include respective component mastery metrics631A-N for each software component that the developer has contributed work to. Component mastery metrics631A-N may include an amount of time required by the developer to produce a unit of contribution to the associated software component. The unit of contribution may be measured in any appropriate manner (e.g. task completed, or lines of code). A number of errors or defects found in committed code by, for example, code analysis module607and/or review and testing module608, that is related to a specific software component may also be tracked. For example, a number of defects detected in code per unit of contribution (e.g., lines of code or number of tasks) for a specific software component may be stored in component mastery metrics631A-N. The component mastery metrics631A-N may also include an amount of time spent on the software component, and a total number of contributions made to the software component. Developer classification module622may classify the developer with respect to a specific software component based on a set of component mastery metrics631A, or an overall component mastery metric corresponding to the specific software component. Work items may be assigned to the developer based on the classifications determined by developer classification module622, and also based on work queue points module640.

Expertise score vector602N may include a plurality of developer skill metrics632A-N. Each individual set of developer skill metrics632A-N may correspond to a specific skill (e.g., a programming language, a programming technique, such as recursion or multithreading, or a specific hardware element) possessed by the developer. Any appropriate metrics, including skill level and time spent on the skill, may be maintained in the developer skill metrics, such as developer skill metrics632A, corresponding to a specific skill. Developer skill metrics632A-N may be used in block203of method200ofFIG. 2, and blocks303and304of method300ofFIG. 3, to select developers to assign to a particular work item. The developer skill metrics632A-N may include any appropriate metrics, including but not limited to a language set (e.g., Java, Python, C, etc.), coding techniques, and code patterns. Developer skill metrics632A-N may track any appropriate particular techniques or technologies, including but not limited to recursion, loops, thread management, mutex locks, and interfacing with specific subcomponents. The developer skill metrics632A-N may track a number of commits by the developer per skill to quantify an amount of experience the developer has regarding the skill. A number of errors or defects found in committed code by, for example, code analysis module607and/or review and testing module608, that are related to the skill may also be tracked. For example, a number of defects detected in code per unit of contribution (e.g., lines of code or number of tasks) for a specific skill may be stored in developer skill metrics632A-N. Errors in code committed that is related to the skill may also be tracked. A code contribution by the developer may be scanned by code analysis module607(using, for example, static code analysis and/or NLP) to identify what the code does and any techniques that are implemented in the code contribution, and the developer skill metrics632A-N may be updated based on the scanning.

Expertise score vector602N may also include code quality metrics633, problem records metrics634, regression testing metrics635, and code review change metrics636. Regression testing metrics635may be maintained in expertise score vector602N by expertise score vector update module620according to block201of method200ofFIG. 2and method300ofFIG. 3. In some embodiments, regression testing metrics635may maintain separate regression testing metrics for different software components and/or developer skills. Problem records metrics634may be maintained in expertise score vector602N by expertise score vector update module620according to block202of method200ofFIG. 2and method400ofFIG. 4. In some embodiments, problem records metrics634may maintain separate problem records metrics for different software components and/or developer skills. Code review change metrics636may be maintained in expertise score vector602N by expertise score vector update module620according to block203of method200ofFIG. 2and method500ofFIG. 5. In some embodiments, code review change metrics636may maintain separate code review change metrics for different software components and/or developer skills. Code quality metrics633may be maintained in expertise score vector602N by expertise score vector update module620according to block204of method200ofFIG. 2. In some embodiments, code quality metrics633may maintain separate code quality metrics for different software components and/or developer skills.

It is to be understood that the block diagram ofFIG. 6Bis not intended to indicate that the expertise score vector module601is to include all of the components shown inFIG. 6B. Rather, the expertise score vector module601can include any appropriate fewer or additional components not illustrated inFIG. 6B(e.g., additional memory components, embedded controllers, functional blocks, connections between functional blocks, modules, inputs, outputs, etc.). Further, the embodiments described herein with respect to expertise score vector module601may be implemented with any appropriate logic, wherein the logic, as referred to herein, can include any suitable hardware (e.g., a processor, an embedded controller, or an application specific integrated circuit, among others), software (e.g., an application, among others), firmware, or any suitable combination of hardware, software, and firmware, in various embodiments. Further, expertise score vector602N is shown for illustrative purposes only. Embodiments of an expertise score vector such as expertise score vector602N may include any appropriate number and type of data fields in various embodiments.