People vs Products

I’ve experienced an interesting arc over my twenty or so years (thus far) of software development.

I started out as a one-person shop, doing my own things, selling shareware. I had no manager nor technical lead. I had to make all my own decisions, in all aspects, without guidance or assistance.

Subsequently, during my four years at Apple, I did have a manager, but they focused on people, not the technical – myself and/or my colleagues collectively made the technical decisions, and provided technical leadership, and effectively set the product direction. My managers were there to make that as easy as possible for us.

Over my nearly eight years at Google, I observed the tail half of a major cultural transition for Google. Long before I started, Google had explicitly laid down a culture where managers were not product / technical leads. The two roles were physically separated, between different people, and they operated independently. Managers focused on people – career growth, happiness, basic productivity, & skills – while tech leads focused on the technical, the product. In fact the manager role was so principled about focus on people that managers would sometimes help their direct reports leave the company, if that was simply what was best for those people for their own success & growth. And, to be clear, not in a “you aren’t working out” sense, but for engineers that were excellent and simply didn’t have deserved opportunities available to them at Google.

By the time I joined, that culture was half-gone, but still present enough in my division for me to experience it. But by the time I left the culture was heavily weighted towards managers being technical leads.

In my nearly three years now at LinkedIn, I’ve completed that arc. LinkedIn culturally & executively emphasises managers as technical / product leads even moreso than Google ever did. As far as I’ve been told, LinkedIn always has (meaning, this is presumably the culture Yahoo had too, from which LinkedIn forked).

Having experienced most of this spectrum, I finally feel qualified to pass judgement on it.

Managers should not be leads.

I immediately, intuitively recognised & appreciated this at Google, but now I’m certain of it.

People management & (technical) product leadership are fundamentally at odds with each other. The needs of individuals are often at odds with the needs of the product. The product might need Natalie to really focus on churning through a bunch of menial tasks, but to evolve, Natalie might really need design experience & leadership opportunities.

Having one person (in authority) try to wear both hats creates conflict, bias, and inefficiency. It discourages dialogue, because you can never really trust where the polymorph stands. The roles require different skillsets, which rarely coexist in a single person and in any case are difficult to keep up to date in parallel. Context-switching between them is burdensome. It creates a power imbalance and perverse incentives.

Even if an individual is exceptionally talented at mitigating those problems, they simply don’t have the time to do both well. Being a product or technical lead is at least a full-time job. Likewise, helping a team of any real size grow as individuals requires way more hands-on, one-on-one attention than most people realise. It’s hard enough being good at either one of them alone – anyone that attempts doing both simultaneously ends up doing neither effectively.

I’ve had the opportunity to be both a technical lead only and a manager only. This is quite rare in the tech industry. I deeply appreciated being able to focus on just one of those roles at a time. I could be consistent, deliberate, and honest. I could, as a manager, tell people exactly what I thought they should or shouldn’t work on, irrespective of what the product(s) need, because I knew the technical lead(s) would worry about those angles. Conversely, when I was a technical lead, I could lay out what was simply, objectively best for the project, uncomplicated by individuals’ interests. In either case, there was real, other human being that could be debated with, as necessary, to find happy mediums.

Yet beyond just being more efficient and effective, the serendipitous consequence was that it gave agency to the individuals – whenever a conflict arose between people and products, it was revealed to them, and the implicit decision about it at least in part theirs to make. Most importantly, they knew that whichever way they leaned they had someone in their corner who had their back.

(Of course, sometimes they didn’t like having to make that decision, but putting it on them forced them to take control and responsibility for themselves, and evolve into more confident, happy, motivated developers.)

I suppose it’s no surprise that companies tends this way – to conflate people with products. These days, for many big tech companies, people literally are the products, and their humanity inevitably stripped away in the process. People are “promoted” into management from technical positions, and often by way of the Peter Principle, are not actually good people managers, nor able to relinquish their former role and ways of thinking. A hierarchy of technical leads in manager’s clothing becomes self-sustaining, self-selecting, and self-enforcing.

The question is: what’s the antidote?

Acknowledgement: I was inspired to pen this post by reading Tanner Wortham‘s Why Manager as Product Owner Will Usually Fail, which is essentially positing the same thing albeit in different terminology.

Better is the enemy of best

You might have heard the aphorism “Perfect is the enemy of good“.  If you’re in a technical field, you’ve probably used it, or had it used against you, to shut down a conversation.  It’s an effective way to do so because it insinuates that the target is thinking impractically, not focused on the problem at hand, rat-holing or bike-shedding or yak-shaving or otherwise getting distracted from “getting shit done”.  All clearly faults, right?

Its original wording, “better is the enemy of good”, more clearly reflects its defeatist mentality that presumes things can’t be much, if any, better than they are now – always implied as the aforementioned ‘good’.  It’s often taken to its extreme – unintentionally ironically – as part of perfect solution fallacies – that it must be impossible to achieve perfection, so why even try?

It can be very difficult to rebut because in practice it’s somewhat subjective & contextual, and thus judged in the context of the dominant culture – which in tech, currently, is pervasively biased towards doing things.  Not necessarily the right things – just things.  Move fast and break things.

Further challenging the defence is that it’s often considered ‘above my pay grade’ to think about the bigger picture.  Especially down where the rubber meets the road and people have deadlines and quotas and (believe they) are judged solely by the volume of work they complete.  In that environment, targeting someone with that aphorism is labelling them as being disruptive, slowing things down, and not having their priorities in order.  A would-be tall poppy.  A Troublemaker™.

In short, it puts the target on the defensive for an indefensible position – and makes it personal, no less.  It is, in a way, a nuclear option – the conversation abruptly ends with no actual conclusion, and no problems actually addressed.

It is in fact a clever ruse, and while usually used well-meaningly rather than viciously & tactically, either way it’s usually used unfairly, inappropriately, and worst of all, incorrectly.

Amongst its many flaws, in practice if not in logic, I believe its worst is that it conflates the path of least resistance with the right path.

Building a better horse.

It is a pervasive practice within business to look at where you are now and where you can go from there.  This is called incremental planning.  An instrument & exemplar of this mentality is SWOT analysis.  In a nutshell:  what have I got going for me, what’s going against me, and how can I work with that against my immediate environment?

It is supposed to be applied tactically.  When misused as a strategy, it does so predicated on the belief that by incrementally improving along the path of least resistance – i.e. opportunistically – one will inevitably triumph above all others.

That is the kind of thinking which leads to building a better horse, rather than realising you can build a car instead.

It is applying the process of finding your local maximum, in ignorance to finding bigger maxima.  It is short-sighted and tunnel-visioned and preys on our lizard brain’s desire for constant gratification and reassurance that we’re making forward progress.

In a competitive environment it is guaranteed fatal, because sooner or later one of your competitors will find a bigger maximum.  Or worse, someone from outside your market entirely, not so constrained in their thinking, will come in and set up shop on the slopes of a much bigger maximum to begin with.  Ever heard of an ‘iPhone’?

Of course, not all tech environments actually have competition.  If you’re working on a company-internal product, yours is usually the only one within your company.  You have a captive market with zero competition.  So unfortunately, you’re free to produce bad products indefinitely, at least insofar as they’re not so bad that they bring down the whole company.  And for as long as you can convince your bosses that you’re working really hard and it’s a really hard problem and look at how big these closed bug numbers are.

Thankfully, there are other motivations – than market dominance or conservation – for building better things.  Some people have an innate desire to do so.

Where are you going?

The incremental planning approach leaves it to a higher power to determine if you’re even heading in the right direction.  It is by definition short-sighted, putting emphasis on speed and not direction.  It is dangerously optimistic.

If you don’t know where you’re going, you might not get there.

Yogi Berra

Incremental development is not the problem.  It is not at odds with vision & leadership.  It is just all too often confused with, and entangled with, incremental planning.

You cannot know where you should be going if you don’t know what the possibilities are, and specifically what the best possibilities are.  Once you’ve identified them, only then can you investigate how to get to them – and thus in what direction you need to move.

Thus why the first step in any kind of development – technical, business, or otherwise – must be to identify where you want to be, irrespective of where you are currently.  That in itself is a complicated task – full of whats and whys – but given that, then you figure out how you might get there.  With that map and route in hand, then you act on that, and only then do you turn your focus to speed – to execution.

And this is where “Perfect is the enemy of good” actually comes in, in its correct usage.  What you identify as the highest place to be might be very difficult to reach from where you are now.  Perhaps there is a different place that’s nearly as high, but much easier to get to.  That might offer the best return on investment, and thus be the best solution.  Especially if it gets you closer to the highest place as well – what you cannot do today, you might be able to do tomorrow.

You must, in effect, put the car before the horse.  If you do not currently possess the means to build a car, find a way of building better horses that gets you closer to building a car, so you at least have a chance of building cars in the future.

[Mechanical Horse patent image used under CC BY 2.0 license from Patents Wall Art on Flickr – available as real wall art through their Etsy store.]

‘Fake error’ about immutable values when using popFirst() on Array

It’s been a while since I wrote any meaningful Swift.  How I didn’t miss the Swift compiler’s bullshit error messages.

var someArray = ["Foo", "Bar"]

if let foo = someArray.popFirst() {
    print("Who cares, we never get here anyway.")
}

That yields, on the popFirst() method:  “Cannot use mutating member on immutable value: ‘someArray’ is immutable”.

No it’s not.  It’s simply not.

For whatever reason, if you instead call popFirst() on ArraySlice – ostensibly indistinguishable from a real Array – it works just fine.

var someArray = ["Foo", "Bar"][0...]

if let foo = someArray.popFirst() {
    print("Yet this works correctly.")
}

Sigh.

I presume it’s trying to tell me something stupidly obscure about Swift’s byzantine type system.  Good luck finding out what.  Good luck even finding the definition of the popFirst() method, since Xcode claims it doesn’t exist if you Command-Control-click on it.  But Xcode can’t find most things, so that in itself says very little.