

Discovering Senior Developers from Source Code History - garysieling
http://www.garysieling.com/blog/discovering-senior-developers-from-source-code-history

======
digitallogic
Sounds like a useful tool for tracking answering questions like "who knows the
most about file/subsystem/internal concept X". Questions where false positives
are more or less in inconsequential and easily corrected.

But number of commits is a horrible way to infer seniority. Unless you value
"frequency of checkpointing changes" above all else. You get what you measure,
so I suspect OP is going to get a lot of small commits in the future.

~~~
garysieling
Yeah, it's not like you'd use this to figure out who should be paid the most,
- it's "who should I hand the phone to" when someone calls several years after
a project finishes, and if that's wrong occasionally it's ok. And, there's no
incentive to be #1 in the result :)

The reason it works is that people write commit message like "Fix X for ACME
Corp", and the project leads tend to work on the project for the most calendar
time - they may not have the most commits if they have to attend meetings, but
after a project/release "finishes", one person ends up sticking around for a
while to handle any issues that come up. That naturally gives them some small
commits.

To me the risk to me is that this may not generalize, since different
projects/products are run in varying ways.

~~~
digitallogic
Sadly there are people who would use a tool like this to make decisions like
what to pay their employees. I guessed based on the title that you might fall
into that camp. Glad to hear I was wrong.

I could imagine search with some standards (commit message format,
branch/rebase strategies, requiring an associated tickets) would be really
effective, though not so much the general case. Hope you can share in a follow
up post if you find ways to deal work around these problems.

~~~
garysieling
The people who've been most interested so far have either been in some type of
architect role where they had some advisory involvement in what a large number
of teams are doing, or people who took over a flailing project. Part of the
idea of this is to show something that's useful and relatively easy to set up,
it could easily show attributes other than the author - it'd be nice to tie
together tickets involving database issues or browser rendering for instance.

I have some material for a couple follow-ups to this, so stay tuned - dealing
with code separate from natural language text is an interesting topic as well.

------
tessierashpool
I do something similar with bash when I start a new project. Code's here:

[https://github.com/gilesbowkett/rewind](https://github.com/gilesbowkett/rewind)

It's just useful to profile the team in terms of who writes the most code, or
to profile the project in terms of when it's seen the most activity. The first
time I did this, it was a rescue project, and the people who we were rescuing
didn't even bother to properly introduce us to the rest of the team (the real
thing they needed rescuing from was team dysfunction), so I'd have been at a
real disadvantage if I hadn't done the analysis.

------
malandrew
Check out git-extras from TJ Holowaychuk. It's git-summary function is
excellent for finding solid contributors that are not the maintainer on open-
source projects:

[https://github.com/visionmedia/git-
extras](https://github.com/visionmedia/git-extras)

------
andreastt
You can also look at their driver's license. That should tell you a thing or
two about seniority.

~~~
ethnt
Age does not correlate in any way to seniority.

~~~
makmanalp
Except it often does. I've been in multiple situations where people who knew
less then me were more senior, simply because they had been around longer.

~~~
gknoy
A better measure might often be time-at-the-company. I'm older than some of my
coworkers, but they wrote 3/4 of the codebase I work in. Commits seem like a
good proxy for knowledge.

You could also graph commits over time in particular repos/apps/folders, and
see who is has been the main maintainer/developer for those sections of the
codebase at various times. Cool stuff!

