Latest Event Updates

Using StackOverflow Careers to hire developers in London

Posted on Updated on

My previous blog post on finding a new developer job in London reminded me of a blog I posted internally (at my previous company) last year summarizing my experiences with StackOverflow Careers when hiring developers in London. Here is a cross-post for your enjoyment!

Finding good software developers is hard. So I’m constantly looking for new and innovative ways to find those great developers. Some of the ways we currently go about it include:

  • Agencies
  • A job advert on StackOverflow, a hugely popular programmer’s Q&A website
  • Twitter + Facebook
  • London .NET user groups
  • A physical advert on a notice board at a local training agency

Using these methods we’ve recruited two great developers over the last few months, however filling my last vacancy was turning out to be tricky (exacerbated by a seemingly massive August/September slowdown). Recently we decided to try a new avenue: the StackOverflow candidate database. This is a tool that allows you to search a database of developers that have created profiles on the StackOverflow site when wanting to post questions about software coding and wanting to answer other programmers questions. This is an important difference to sites like LinkedIn because the primary motivation to have a profile on StackOverflow is to participate in an online community of programmers, not to look for job. Consequently, the programmers that one can find using the StackOverflow candidate database are on average usually higher skilled and more passionate about their craft than other online candidate databases. There are a variety of criteria to search on, enabling me to quite specifically identify candidates that would suit the role.

SO

So we purchased access for one week. I managed to message over a dozen eligible candidates and then I realized a curious thing. Even though the candidates that I had message had marked their profiles as “actively seeking positions”, it turns out that this probably means something more like “looking for opportunities if that opportunity is a huge pay increase to go to Google or Facebook”. In other words, developers might indicate on their profile that they are active seekers but as they haven’t actually taken the step to hand over an updated CV to a recruiter, it would take more than a message out of the blue to ‘dislodge’ them from their current employer. While all replies were professional and complimentary of the role on offer, most candidates were not open to our new opportunity.

Nevertheless, we were able to find one developer interested in what we had to offer; within a week we’d interviewed him, liked him and he’d accepted our offer!

SO2

The effort to hire great people, I suspect in any industry, often requires a lot of energy, guile, patience and persistence. You never know when that advert on a random job board or networking at that industry event will turn up your next great addition to the team. It pays to always be on the lookout, and in the mean time, constantly strive to make your team/department a better place to work. The StackOverflow candidates database is definitely something we would try again in future should more developer opportunities become available.

“The key for us, number one, has always been hiring very smart people.”

– Bill Gates

Finding a new developer job in London

Posted on Updated on

As transparency seems to be the new black (I’ve read quite a few posts on HN recently about people fully documenting their earnings, for example), I thought I’d blog about finding a new developer job in London. Nothing too exciting but visiting various shops, comparing interview processes, and working with recruiters is always…entertaining.

Firstly, here’s a quick run down of the places I visited and some notes of my experience/observations (WordPress table editing is not so good, so excuse the rudimentary layout)

Company (type) Source Interview Stages Date Outcome Notes / Observations
Digital Agency in Croydon StackOverflow 1st (Face2Face) 7th Nov No callback First interview! This one was all about getting experience (I would probably never work in Croydon…); Had to hack a to-do list together in 20 mins. Unpracticed at Razor so this probably took longer than it should’ve! Good guys but company not really progressive enough in terms of technology
Shrink-wrapped Accountancy software in Charing Cross Jobserve (urgh) 1st (online test); 2nd (30 min phone interview) 9th Nov Not taken forward (by me) Online test was C#/CLR trivia galore (got 64% doh); phone interview was 3 guys asking some random questions, not very coherent. Not the best interview process in the world but no loss as unlikely that I’d work in something as exciting as accountancy!
Shoreditch Music industry startup StackOverflow 1st (pair programming f2f interview) 12th Nov No callback This was intimidating as I had/have these guys on a pedestal, especially the Director of Engineering who is active in the community and has seemingly done an amazing job using progressive ideas to create a successful engineering outfit. Consequently stuffed the interview up, howlers include trying to mock a concrete class with Moq and not pointing out mutability as problematic. At least I learned about the Chain-of-Responsibility pattern and was able to show them FluentAssertions. All is not lost!
Big City Management Consultancy StackOverflow 1st (30 mins HR phone interview) 15 Nov Not taken forward by them Pictured myself wearing suits everyday and going from client site to client site hacking in fixes in a tech debt creation frenzy (am I being harsh on city tech?). Interview went well but in the end I was “not a match for their requirements”, most likely because I said I wasn’t going to do any Java…
Charity platform Recruiter 1st (Online test); 2nd (f2f w/ CTO); 3rd (f2f w/ Architect & Technical Manager) 19 – 23 Nov Offer Accepted Great looking company that looks after its people and is technology-focused; liked the people I met in the interview – enthused, passionate, skilled, etc. High retension, always a good sign. Good tech stack, office space, progressive culture etc etc. Job done!

Some key observations and takeaways from the whole process:

  • Recruiters are the usual annoying and manipulative lot but actually finding a decent one is possible and can make a big difference.
  • Overall though, I’d definitely start with the StackOverflow job boards (avoid Jobserve like the plague!) where you can find lots of decent companies and also do THEM a favour, as if you’re recruited through SO their costs are lowered by around 7k-10k per role in recruiting fees. I did note that SO is slowly starting to “jump the shark” though, carrying ads from Big Consultancy Inc who aren’t really doing interesting things with tech. Along with SO who will feature most of the bigger, more established outfits, also be very sure to pay SiliconMilkRoundabout a visit at one of their twice-yearly shindigs, where there are many much smaller but very exciting companies who are looking for adventurous types to join their cutting edge startups. If working on something interesting and novel is high on your list, SMR is a must.
  • Another observation I made was the presence of huge variance in interview techniques and processes. In my opinion it turns out that the places you would rather work tend to avoid online tests of the multiple-choice questionnaire type, and have some element of your own code, whether that is pair programming at the interview or submitting your solution to their problem question over email. In my own hiring I have had the most success with:
    • 1st stage: CV screening that I do, screening on modern tech (ORMS, IoC, TDD etc) and passion for the craft (OSS/blogs/twitter/etc)
    • 2nd stage: 45 min phone interview going over technical basics (including questions like “What problem does IoC solve?”) and some recent work experience; If successful I give email a programming challenge and ask them to submit a project that solves it.
    • 3rd stage: 2 part face-to-face, 1st part soft-skills, 2nd part hard-skills where we talk about his/her code submission and possibly ask them to extend it in the interview.
  • Finally, the last observation I made was that it is seemingly quite a small world in the London tech scene! New hires in my old company were from places that invited me to interview, fellow colleagues from work were being submitted for some of the same jobs I was, some through the same recruiters, some through different recruiters, etc. Felt like a bit of a crowded space at times!

Anyway, my job is done as I’m now at a much better outfit than before, so hopefully I won’t have to traverse the recruitment maze again for a long while and I can get back to creating software and help building good teams. Hope you find this little anecdote interesting!

NBuilder Utility for Child Complex Types

Posted on Updated on

NBuilder is a tool for .NET that allows the easy creation of test objects. It provides new instances of any class you provide (as a generic parameter) and those instances are populated with garbage data. I find that using NBuilder for test objects is a nice explicit way to show that the test does not care about the data but just needs an object in a decent enough state not to produce NullReferenceExceptions.

So given:


public class ComplexType
{
    public string Name { get; set; }
    public int Number {get;set;}
}

You could have the following test:


[Test]
public void Should_Return_Instantiated_Object_With_Test_Values()
{
    var result = Builder<ComplexObject>.CreateNew().Build();
    result.Should().NotBeNull();
    result.Name.Should().Be("Name1");
    result.Number = 1;
}

By the way that was also using FluentAssertions.

However, even after a fair bit of Googling I’m not sure why it does not include the creation of child complex objects, recursively. Instead these end up as null. So given:


public class OuterComplexType
{
    public int Number { get; set; }
    public InnerComplexType InnerComplexType { get; set; }
}

public class InnerComplexType
{
    public string Name { get; set; }
}

The following test would fail:


[Test]
public void Should_Return_Instantiated_Object_When_Given_Object_With_Complex_Properties()
{
    var result = Builder<OuterComplexType>.CreateNew().Build();
    result.InnerComplexType.Should().NotBeNull();
    result.InnerComplexType.Name.Should().Be("Name1");
    result.Number = 1;
}

So I wrote a little utility class that helped with this situation (see the Gist here). I have not used it in anger very much yet, so let me know if you spot any potential improvements.

using System;
using System.Linq;

using FizzWare.NBuilder;

namespace MarkGibaud.UnitTest.Utilities
{
    public static class NBuilderUtility
    {
        public static T Create<T>()
        {
            return (T)Create(typeof(T));
        }

        private static object Create(Type type)
        {
            if (type.IsInterface)
            {
                var firstConcreteImplementation = type.Assembly.GetTypes().FirstOrDefault(t => type.IsAssignableFrom(t) && !t.IsInterface);
                if (firstConcreteImplementation != null)
                    type = firstConcreteImplementation;
                else
                    return null;
            }

            var baseType = Build(type) ?? Build(Nullable.GetUnderlyingType(type));

            var complexTypeProperties = baseType.GetType().GetProperties().Where(p => !p.PropertyType.Namespace.Contains("System")).ToList();

            if (!complexTypeProperties.Any())
            return baseType;

            foreach (var complexTypeProperty in complexTypeProperties)
                complexTypeProperty.SetValue(baseType, Create(complexTypeProperty.PropertyType), null);

            return baseType;
        }

        private static object Build(Type type)
        {
            var builderClassType = typeof(Builder<>);
            Type[] args = { type };
            var genericBuilderType = builderClassType.MakeGenericType(args);
            var builder = Activator.CreateInstance(genericBuilderType);
            var createNewMethodInfo = builder.GetType().GetMethod("CreateNew");
            var objectBuilder = createNewMethodInfo.Invoke(builder, null);
            var buildMethodInfo = objectBuilder.GetType().GetMethod("Build");
            return buildMethodInfo.Invoke(objectBuilder, null);
        }
    }
}

Usage is something like this:

[Test]
public void Should_Return_Instantiated_Object_When_Given_Object_With_ComplexType_Properties()
{
    var result = NBuilderUtility.Create<OuterComplexType>();
    result.InnerComplexType.Should().NotBeNull();
    result.InnerComplexType.Name.Should().Be("Name1");
    result.Number = 1;
}

I guess the next step is to integrate this functionality into a fork of the NBuilder project…I’ll save that for a rainy day.

Personal Kanban

Posted on Updated on

My software development team at work recently decided to dispense with our Kanban board and move back to Scrum (long story). The result is that we are now working from a ‘vanilla’ Scrum board and I can no longer measure cycle time, see all the work in progress, easily see impediments/bottle-necks, and all the usual benefits that come with a visual mapped value stream.

Wanting to continue on my path to deepening my understanding of Kanban as well as trying it out in different scenarios, I thought I’d give Personal Kanban a try. Jim Benson wrote the book, which I would be tempted to describe as possibly the GTD of the Lean world. Jim’s advice includes that the usual to-do list lacks context and does not do a good job of providing feedback and communicating progress as well as a Personal Kanban (PK) board.

So I’ve created a PK board and put it up in my home office (aka the bedroom):

It’s decidedly low-tech. I have four columns: Backlog, Next Up, In Progress and Done. That’s the value stream mapped. I have four corresponding boxes at the bottom of every work item card, in which I will note the dates that the card moved into a particular column. That’s cycle time sorted. I’ve divided work items into categories like ‘Presentation’, ‘Book’, ‘Blog-post’, etc. That’s the similar-sizing of work sorted (albeit using the hack of categorizing the work, much like t-shirts sizing does for Kanban software teams). Natural space on the board is limited to around 3-4 cards, so that’s the first stab at limiting work-in-progress sorted. I plan to retrospect every 6 weeks or so and record the data (eg. average time to read a book), so that’s the continuous improvement trigger sorted.

I can already report that it helps to focus by forcing me to decide what is important to work on and limiting those options. The power here is as much as selecting what you WON’T spend time on as what you will. With strict WIP limits, you know that the only way you can start reading that next book you’re excited about getting into is by finishing the previous one – a potentially powerful hack. Anything that makes me START less and FINISH more is definitely a good thing.

I hope to report back a lot more in a few more weeks. I’m especially interested to discover the drawbacks of a system like this. So stay tuned!

Why Product Management is now as important as Software Development

Posted on Updated on

I could’ve written this post at least 6 months ago, if not more, as it was really later last year / earlier this year that I began to cotton on to a new area of expertise opening up in the world of Software Development: that of Product Management.

Being the Dev Team Leader of a team that has really good engineering but is pretty light on product management skills led me to tweet a quote from Marty Cagan’s book “Inspired: How to Create Products Customers Love” earlier this year:

“It doesn’t matter how good your engineering team is if they are not given something worthwhile to build.”

Increasingly these days I think the problem is (generally) becoming less about building stuff that “doesn’t break” and much more about the problem of building relevant, dare I say useful, software. In the world of enterprise it is still Project Managers and Business Analysts that occupy this space, and these skillsets don’t seem to include the ones that help us determine whether our users are delighted or our stakeholders are enfranchised (eg. Analytics / Customer Feedback, Stakeholder Prioritization models, UX/Usability skills, Agile product development skills like MVP, etc).

I think part of the problem is also wrapped up in the configuration of the present-day large organisation (at least in mine), where the PM/BAs do not act as champions of the product but rather as relatively disenfranchised interfaces between the developers and the ‘business’ users, who for far too long we have mistakenly believed understand how to build software applications. This configuration doesn’t allow for the PM/BA to really own the product, or own a vision for the product, thereby not shouldering the actual responsibility of user satisfaction and resulting in an incoherent or indeed non-existent product strategy, and generally little value derived over a period of time.

I now see two parts to a successful software team. The first part is the software delivery part: Good engineers, good engineering ethic (TDD, refactoring / tech debt payoff, etc), Continuous Delivery capability enabling fast-feedback, etc etc. Input here is requirement (probably a story or epic in Agile terms), output is a piece of working software in production, with hopefully a very short duration of time between these two things. The second part is the product discovery part – “What should we build?”. Input here is things like customer feedback both quantitative (analytics) and qualitative (surveys), the vision of the product (from a Product Management team with a strong sense of what should/could work!), and of course any other stakeholders you might have (people that have a stake in the product but might not use it directly – eg. call centre agents that get more demand when the website goes down). Output here is of course, a new requirement/epic/story.

These two parts are as critical as each other. A cracking product manager might as well go home instead of be frustrated by a team of developers that repeatedly churn out broken software un-timeously. Likewise, customers can see little value in a cracking software development team churning out irrelevant features.

I recommend the reading of two books that talk a lot about this space:

Marty Cagan is part of the Silicon Valley Product Group, and his site has a lot more information about Product Management. This books succinctly summarises what a good Product Manager is and isn’t, and provides a lot of practical advice to get going with better product management practices immediately.

The second book is also hugely popular and focuses on how Lean Principles-inspired product development results in products that matter – must read material for any aspiring Product Managers! Eric Ries also blogs at startuplessonslearned.com.

These two books will fast-track your introduction to this area, and allow you start thinking about whether the activities undertaken by those who are telling you what to build really the ones that uncover what users want.

I’m looking forward to watching how the Product Management space evolves and discovers more about how we can incorporate insight gained from better knowledge of our users into the development of ever more useful software!

Knowledge Management Dissertation

Posted on Updated on

I’m updating my CV at the moment and a friend suggested I put my Knowledge Management dissertation online, for access and posterity.

Here is the abstract:

Knowledge management is an important competence for organisations to achieve in the new knowledge-powered economy. However, over a decade of attempts by organisations to achieve effective knowledge management supported by sophisticated technical tools has produced more failures than successes. With new ‘Enterprise 2.0’ tools powered by ‘Web 2.0’ technologies now ubiquitously available, organisations have a better chance than ever before to realise the dreams of knowledge management. But obstacles remain, many of them centering around employees’ behaviour and perceptions. Organisations need to support and encourage employees towards knowledge management behaviours in order to successfully implement a KM strategy. We investigate the perceptions of employees in reaction to the deployment of wiki-based KMS application ìn a medium-sized multi-national corporation. We find that support and management is needed in six specific aspects of the KM initiative. The results should prove instructive to other organisations wanting to begin or improve their knowledge management strategies.

You can get the full PDF here:

KM 2.0: Employee Perceptions of a Wiki-based KMS Deployment

Feature Cycle Time Analysis

Posted on Updated on

A few weeks ago the iTropics team took a detailed look at the journey of a medium sized feature going through the system of development. One objective was to calculate this task’s Cycle Time, a metric from Lean that is defined as the length of time a feature takes to go from beginning development to “done done” or QA’d successfully. This definition could also be expanded to include specification through to deployed-into-production. I also had another objective though, and this was to highlight a specific form of waste in the system known as “hand-off” waste, or the delays that occur when one functional role has completed their part and the feature is awaiting the next functional role to begin theirs. For most processes in organisations, it is common to find that a large part of the total time that a task takes to complete is actually idle time. Unfortunately the Scrum model of software development does not have any mechanisms to highlight this waste, and thus this problem is not very frequently addressed.

So I manually tracked this feature as it went though specification to development to QA (and looping back a few times) and the results were quite interesting, though I must say I wasn’t surprised by the amount of hand-off waste we discovered.

photo (6)

Above is what the board looked like after we’d spoken about it. The numbers are the days in February, the red letters are the days where value-adding activity was undertaken (spec, dev, qa).

What we found was that the feature took from the 6th February, when we had a meeting with Contiki about the requirements of the feature, until the 29th February when it was deployed (in actual fact we might have continued past that date but I stopped counting as we were close enough!). As this was only a medium-sized feature it is pretty clear that this duration is probably open to improvement. On further inspection and discussion we found that there was a delay of a week between talking to Contiki and finalizing a specification, a delay of another week while deployment issues were sorted out, and further intermittent delay due to a few QA rejections (the specific reasons for these delays aren’t relevant here Smile). All in all, only around 7 or 8 days of actual work across Spec/Dev/QA were needed, but this feature still took 23 real days (or 17 working days) to turn around. That means that over 50% of this task’s total duration, nothing was getting done on it! That seems like a problem worth solving.

I believe most of this waste is simply due to a lack of focus on the individual features as they go through the system, or what Lean describes as too much work-in-progress. Most of the time, an individual engaging in multi-tasking takes longer to do each task than if they’d done each task one at a time. In the same way, a development team working on too many features at the same time means that each task takes longer to complete than if there were fewer features in progress, principally because there is more waiting time between functional roles while complete work on all the other items being worked on. Research also shows that increased work-in-progress in a system also negatively affects quality.

Another interesting observation I made later was that that 50%+ waste time is agnostic to the size of the feature. Now we have yet to find out if this feature is a typical case, but if it is, it means that when we are estimating story sizes we are only factoring in less that 50% of the activity involved, and the hand-off waste is ignored. Now you might say the hand-off waste would probably be consistent across all sizes of stories, and you’d probably be right (although I do suspect there is a fair bit of variation, which will throw off individual estimates), but isn’t it a bit stupid to be putting as much time into estimation as we do, only for over 50% of the time actually taken to complete the feature is left up to chance?

The team agreed that we found this analytical tool to be a useful way to make waste visible and thus get us into a position to start doing something about it. I might well manually track a few more stories this way, but we are hoping that Greenhopper will allow us to get these measurements automatically and fuel our retrospectives for ideas on how to improve the Cycle Time of our features.