Codermetrics

Observations on Coder Types

As a wrap-up to this chapter, I’d like to offer some observations on how Skill Metrics might apply for different types of coders. Not to stereotype or draw too broad of strokes, but at certain stages of development, coders are more likely to demonstrate certain strengths and weaknesses. You may choose to watch certain metrics more closely depending on the experience level and obligations of certain coders.

Architects

Coders designated as “architects” are usually the more experienced members of the team. Their assignments may differ from other coders, with a higher percentage of complex tasks, including design tasks. They may also be expected to spend more time guiding and assisting other team members, to ensure that the software is well-designed and high-quality.

The following Skill Metrics can be particularly relevant for architects:

Power

It is likely that architects will have a higher Power rating than many other coders, since they will probably have a higher percentage of more complex tasks. It would not be surprising for an architect to average lower Utility, since having a high number of complex tasks typically means fewer tasks as well.

Assists

Architects are often sought out for help by other members of the team, and should also be proactively guiding, mentoring, or otherwise helping team members, so you would expect architects to have a higher number of Assists than most coders.

Range

An architect will likely need to be involved with many areas of the software. The architect’s Range, therefore, will typically be above average for the team.

Tackles

Good architects will proactively anticipate issues and help solve key problems, so you should expect them to have an above-average number of Tackles over the course of a project.

Senior Coders

Senior coders are more experienced technically, therefore you will typically expect more productivity, higher quality, and in some cases more leadership. In some cases they may be specialized, in some cases they may be generalists, but either way they should be among the stronger and more consistent contributors on the team.

The following Skill Metrics can provide key insights for the contributions of senior coders:

Points

In general, you should expect senior coders to have higher average Points than other members of the team, either due to handling more complex tasks or simply completing more tasks.

O-Impact

The overall Offensive Impact of senior coders will also likely be above-average, as measured through the combination of Points, Utility, and Assists.

D-Impact

While it may not be a stated key responsibility for all your senior coders, many times the senior coders are those that field the most critical issues or provide added benefit through initiative and innovation. Overall, Defensive Impact will provide you insight as to how much the senior coders contribute in these dimensions, and you would expect some if not all your senior coders to measure well for D-Impact.

Temperature

Consistency of performance is something that you will typically expect from senior coders, and the Temperature metric will provide you a way to analyze that. If a coder is performing consistently, the Temperature will never get too low. Also, some senior coders may get “hot,” with periods of especially high productivity. Watching the Temperature metric, you may be able to spot those periods and take advantage of them (management adjustments based on metrics will be discussed more in later chapters).

Junior Coders

Junior coders may provide all kinds of contributions and display many types of skills, based on their education, background, personal tendencies, and capabilities. Unlike architects and senior coders, who are by definition more senior members of the team who probably have more well-established patterns (at least for teams that have been together for some time), junior coders are more unknown quantities. You may have an idea what a junior coder will do, where their strengths and weaknesses lay, but you can’t be sure.

For this reason, all Skill Metrics bear watching for junior coders and also for any interns you might have on a software development team. Metrics can be an excellent way to spot tendencies, strengths, and areas for improvement.

Among the metrics, however, a small set may be especially useful and bear close monitoring for junior coders:

Utility

In many cases junior coders will not be assigned the most complex tasks, and so Utility becomes the key metric to track and compare productivity.

Tackles

You won’t necessarily expect junior coders to demonstrate innovation or initiative, or proactively take on new areas and unassigned tasks—but when they do, it will be worth noting. Most junior coders will record few (if any) Tackles, making those that do have Tackles more impressive.

Turnovers

Clearly, with junior coders you want to spot times and areas where they might be struggling. Turnovers can be a key metric to help in this regard. Junior coders with a higher number of Turnovers, or a spike in Turnovers, might need more assistance. Alternatively, a lower number of Turnovers is a positive sign.

Plus-Minus

While this can be a useful metric for everyone on the software development team, for junior coders it bears close watching. You want to see how much the “positive” contribution of tasks completed outweighs the “negative” outcomes, such as production issues or incomplete tasks. Comparing junior coders to other members of the team (and to each other) with this metric, you can get a summary view of their overall contribution. Also it will be useful to watch the trend over time. Architects and senior coders may have a more consistent Plus-Minus, but with junior coders there will likely be variance. Ideally, you will see steady progression until a general plateau is reached, but spotting lack of progress can also be useful in helping identify where assistance is most needed.