Skip to Content

Uncle Bob is Ruining Software

Posted on

Let’s start with a couple of premises:

  1. There are 10x programmers out there,
  2. Some programming techniques are better than others.

I don’t think either of these is particularly controversial. The first is pretty widely accepted and borne out by studies. And we see examples of the second everywhere: see for example all of the pissfights about static vs dynamic typing. We may not agree on which is better, but a lot of people think one of them is better, which means that a lot of people believe that some techniques are better than others.

Let’s add one more premise: 10x programmers might not use the best programming techniques.

This might be a little less obvious, but I think it’s a pretty straightforward argument. It’s crazy to expect anyone to always use the best tools. And it’s easy to find two software giants who argue about something; see again typing wars.

Now for the crazy leap in logic: 10x programmers are bad for the industry.

I like to think I’m a pretty decent programmer, but every programmer thinks that, so statistically I’m about average. If I want to improve, I’d look into using better languages and developing better techniques. How do I found out what are ‘better techniques’? I can’t look into the research because there’s almost no software engineering research out there. I could do a ton of experiments, but that takes time and runs into the blub problem. The fastest and simplest way is to look into what the community thinks are the best techniques and trust that they’re correct. And the community gets its best techniques from the people who are most successful, which are the 10x programmers.

Here’s the thing, though: if the technique is some 10% detrimental, then the 10x becomes a 9x- which is still far better than the average programmer. The 10x would still be incredibly successful despite the bad technique. That means the 10x can still act as an authority on best practices, even if it’s not a best practice! We have no a priori way to determine whether a given practice is good or bad purely based on what the best programmers do, because the best programmers using poor techniques are still the best programmers.

Take Robert Martin. He’s a hugely influential software engineer and has played a large role in popularizing several practices, such as TDD and SOLID. But if he instead fell in love with APL and property testing he’d likely be just as effective a programmer and just as effective in advocating for them instead. Uncle Bob is an untrustworthy authority because he’s such a good programmer!

Some strawman counterarguments I can easily attack:

  • “He’s speaking about things he knows work.” He knows what he prefers doing. Is he the best judge on whether or not that’s effective? There are a lot of cases where people think they’re better at something but actually worse.
  • “He’s speaking from experience.” So are COBOL programmers.
  • “Are you arguing that we shouldn’t listen to experts because they’re too good? Because that’s really dumb.” Yeah, it’s silly and riddled with holes, I just like the idea that something can be so good at programming that we shouldn’t listen to anything they say about it.

So can we do instead? The only thing we can trust is hard scientific research, but that’s incredibly expensive and a lot of people think it’s impossible to study programmers. Also, we can’t trust research either. We could also invest a lot of time in our own exploration, but that’s boring. We could force 10x programmers to argue topics, which I’d like to see happen more- it isn’t great but it helps a little, and it’s entertaining to watch experts shout at each other. I don’t think the experts will be very happy doing that, though.

I think the main takeaway is we should start using gotos again, because Dijsktra was an expert so we can’t trust him.