Uncle Bob recently wrote a post about what he calls “The Churn”. By “The Churn” Uncle Bob means, I think, pointless innovation. Or rather, the belief that innovation puts us on a monotonically increasing trajectory called “progress.” In other words, the churn is the belief that “the next big thing” will solve all our problems and be better than the current thing.
I think that Uncle Bob has a good point, in that the belief that adopting functional programming, or adopting agile, or adopting a better git workflow, or whatever, will not automatically make us successful or solve all our problems. After all, writing software is hard; at the end of the day, we have to exhaustively specify the behavior of a complex system, and that specification must be complex or it won’t be exhaustive. (This point is also from Uncle Bob, in Clean Code.)
So given that there is churn – people continually invent and learn new techniques in the face of diminishing returns – and that at least some of this time is wasted, why do people do it? Whence this temptation to innovation rather than mastery?
I think the first reason that people are tempted to innovate rather than master something is that it’s frankly easier to start things than to finish them. Here’s an example: The other day I installed as Haskell interpreter and wrote a “hello world” and a program that printed out the first N square integers, or something equally useless and first-project-y. And it was easy! I don’t think it took an hour. “But,” you might say, “Haskell is hard!” And you would be right, but starting Haskell is easy. Haskell doesn’t get hard until you want to be good at it.
Now, I have some unfinished side projects, but I spent time learning three Haskell commands because it was easier. I think that is the first reason for the churn. I know C# syntax pretty well at this point. If I want to get better and C#, I need to do some serious thinking and reading, I need to solve hard problems in the language and then refactor those solutions to be more readable. And that would be a lot of work. I already picked a lot of low hanging fruit, and what’s left are gross, small apples at awkward heights. But with Haskell, heck, I don’t even know how to read files off the disk! If I spent a weekend playing with Haskell, I would get 300% better. If I spend the same weekend playing we C#, I will only get 3 or 4% better. So Haskell is more attractive because starting out in Haskell is easier than mastering C#.
So perhaps reason 1 for the churn is that innovation is easier than mastery. I think another reason that people churn is that in languages we know well, we know where all the annoying problems are, but in languages we don’t know, we don’t know where the problems are. For example, in C# I’ve seen libraries where someone’s use of inheritance made a simple change really difficult to implement, and the C# regex API is pretty annoying. Also, you can write concurrency bugs in C# pretty easily if you’re not paying attention. I don’t even know whether Haskell has regular expressions. I hear it’s better at concurrency because of immutable state and lazy evaluation, but I couldn’t swear to it because I’ve never done anything non-trivial in Haskell.
I think then the second reason for the churn is that an unknown quantity of unknown problems seems smaller than a known quantity of known problems. Of course, the unknown problems might be smaller, but that’s a guess. By definition, we don’t know whether the known problems are smaller than the unknown problems. So like Hamlet, rather than face our current confusing regex APIs, we “fly unto others we know not of.”
And I think the third example is peer pressure. Look on Twitter sometime at the programmers. Everyone (rather, everyone who wants to share) is writing some sort of functional microservice that runs in docker containers on scalable cloud infrastructures. And who wants to be the guy who writes line of business apps in a language that’s ten years old! It’s not even containerized, duh. No one wants to feel left out of a great party, so we tend to follow trends, and people who set trends are people who brag on twitter about what they’re doing, and people who brag on twitter about what they’re doing and doing new things. So we do new things.
I think maybe I’ve answered the question: Programmers churn because we’re afraid of being left out of cool new technologies, we prefer (perhaps mistakenly) solving unknown problems to dealing with known problems, and we find it easier to race through the simple parts of learning a new language or framework than to slog through the mire of learning the edge cases and idiosyncrasies of a language and framework we already know.
Hmm. Maybe the next big thing won’t solve all our problems after all.
Till next time, happy learning.