Senior Developer Assessment: Re-aligning Expectations
Today we assessed our 20th candidate for position of senior developer, using a small test that I drafted some time ago. Since then I’ve spoken about how the test was dumbed down since one of the questions was perceived as being too difficult. The assessment consists of three questions, which I’ve dubbed Fibonacci, Quicksort and University. I’ve already discussed two of the questions, namely Quicksort and University.
Although not an earth-shattering sample, 20 is a number that we can start to draw pretty graphs with, so I’ve included a summary of the results alongside.
We can speculate about what it tells us:
- There’s something wrong with University; nobody has come up with a satisfactory answer;
- In the case of Fibonacci, there’s something wrong with the candidates; only five people have come up with a satisfactory answer.
Ok, my second conclusion above is possibly a little harsh. I think it’s a little harsh, because upon inspection by others, it’s elicited use of some power words like “mathlete” and “math-wiz”.
Now Fibonacci is the only question that I haven’t posted for all to see, mostly because I thought it was too simplistic and therefore quite uninteresting. Given these results though, I’ve been prompted to reword it completely. I mean, if only math-wiz’s have what it takes to do it then I can’t make any assumptions about the background that a candidate may have in the arithmeticmaths department.
What follows is the version of Fibonacci as it was up until now:
I’ve taken great pains to remove anything that may constitute an implicit (read “unfair”) assumption about mathematical background and I’ve reworded the question to provide a lot more hand-holding for the candidate. This should also help in offsetting the nervousness factor.
Here’s my updated version:
Senior Developer Assessment Revisited
This is really part two of the article I wrote “What is a Senior Developer?”. I’ve received some shrill feedback on my choice of assessment problem:
- Too math’y!
- Standards too exacting!
- A bit much to ask of your typical commercial developer.
So I’ve taken this all to heart and decided to revamp the Solver question. Actually, I’ve decided to drop it completely and replace it with something a lot less “math’y” but possibly no more representative of real-world requirements.
A suggestion that was given me: “get them to sort stuff”. Ok, so what would making someone jump through “sort algorithm” hoops prove? After all, these days, sorting things amounts to a call to List<T>.Sort—I mean honestly, who ever needs to resort to first principles when sorting these days? I’m willing to take a different tack—if I’m testing something slightly different, that is, not knowledge, but the ability to absorb and apply … well then that’s slightly different. Besides … dealing with pointers is generally seen as unnecessary masochism, but some people still regard it as crucial background to being a good developer.
So this time, I’ve actually taken the time to capture the requirements in detail; this amounts to softening things up a little since the general consensus seems to be that the original assessment was too demanding (at least, the Solver question was).
Quicksort, above, doesn’t test ability to perform research independently, and offers a lot of hand-holding, but it is somewhat less daunting than Solver. I can’t help thinking though that things are being dumbed-down a little too much.
The dumbing-down:
- This is limited to System.String, but could easily be extended to be generic (bonus points if the candidate takes the initiative to do this!);
- I haven’t specified any constraints in terms of efficiency issues (the naïve implementation is, of course, a horrible memory hog);
- I don’t know if I could provide any more hand-holding than this, it’s practically paint-by-numbers.
I have been somewhat vague about one thing, namely choice of pivot. I have arguably been a little tricky in this question because the example isn’t consistent in how the pivot is chosen. The astute candidate will quickly realise that choice of pivot isn’t crucial.
Here’s my solution, coded up in approximately 20 minutes:
public static class QuickSorter
{
public static IEnumerable<string> QuickSort(IEnumerable<string> jumbled)
{
if (jumbled.Count() < 2)
return jumbled;
else
{
return
QuickSort(AllLessThan(jumbled.ElementAt(0), jumbled.Skip(1)))
.Concat(jumbled.Take(1))
.Concat(
QuickSort(AllGreaterThan(jumbled.ElementAt(0), jumbled.Skip(1))));
}
}
private static IEnumerable<string> AllLessThan(string value, IEnumerable<string> others)
{
return AllSatisfying(others, s => String.Compare(value, s) > 0);
}
private static IEnumerable<string> AllGreaterThan(string value, IEnumerable<string> others)
{
return AllSatisfying(others, s => String.Compare(value, s) <= 0);
}
private static IEnumerable<string> AllSatisfying(IEnumerable<string> others, Predicate<string> predicate)
{
return others.Where(s => predicate(s));
}
}
Things to notice about my implementation:
- It’s pretty much declarative, thanks to Linq, of course;
- It’s not very efficient … no in-place swapping; that’s what you get in twenty minutes.
I think that this provides a less jarring assessment experience for a would-be candidate than Solver, especially if our candidate isn’t a math-wiz.
22 comments