Previous: Idiot's Guide to ABI Versioning
Next: Magic numbers in C
I always assumed that programmers hate complex tools and, if given the option, choose simple tools that get the task done over complex multi-purpose ones. (And that complexity we encounter in the tools these days is mainly because develops are paid by hour rather than by delivery. If dealing with a complex tool meant you'll miss your kid's baseball game rather than just the project schedule slipping slightly, there would immediately be an enourmous pressure on tool developers to keep the tools simple and make them just work.)
Recent blog post from Tim Bray confirms that sentiment (to keep it short, he says that the tools today got so complex that programming ceased to be fun) but the subsequent discussion on Reddit shows that lot of people disagree wih him and say, in essence, "Stop whining and start learning the tools."
Putting aside the convenient explanation that it's just the Stockholm syndrome speaking, there are, as far as I can say, two possible explanations for the phenomenon.
Theory 1: People become less tolerant of complexity as they grow older.
While you are a newbie programmer, learning new technology is fun. It allows you to do new cool stuff and improve your skills in overall.
However, after 20 years in the industry learning a new framework that does exactly the same thing for umpteenth time gets annoying and makes you feel that you are wasting your time rather than doing anything useful.
Theory 2: Some people are born complexity-lovers while others are born complexity-haters.
According to this theory there are programmers who are mathematicians in their hearts. They love abstract problems and divising formally sound solutions for the problems. Once the solution is known, only the trivial task of implemening it remains. Programmer-mathematician wants to get rid of this boring task as fast as possible and thus prefers simple tools which don't require him to learn new stuff or spend his time trouble-shooting the tool.
And then there are programmers who are handymen under their skin. They love to assemble stuff. They are McGyver types capable of knitting an anti-shark suit out of old firehose. The ideal milieu for the handyman is a junkyard. After all, junkyard means many more cool anti-shark suits and fire-extinguishing slippers, many more Rube Goldberg machines and Frankenstein monsters. Handymen love complex multi-purpose tools because they are easy to repurpose and to use essentially as spare parts.
Finding out wheher theory 1 or theory 2 is correct is relevant for tool developers. In the former case there's no much point in creating complex tools unless, of course, you want to address specifically the segment of newbie developrs and become a star among teenage programmers. In the latter case, on the other hand, your complex tool is meant to be used by handymen and you should thus expect your shiny new web-development framework to become a component in an improvised cheese slicer. You should thus try to relax restricions placed on the user, make the tool easy to take apart, modify and be used it in unexpected ways.
Additionally, determining which theory is correct would make an interesing data point for psychology of programming research.
So, here's a simple way you can help with finding out what's the case. In the comments below specify numer of years you are programming and choose one of the following options:
A: Tim is right. Tools have got too complex these days and should be thoroughly simplified.
B: Tim is wrong. He should stop whining and learn the tools.
After we have sufficient numer of answers, I intend to chart the percentage of complexity-lovers vs. complexity-haters according to the experience level. If the resulting graph looks like this:
Then the theory 1 is correct: People get less complexity-tolerant as they grow more experienced. If, on the other hand, the graph looks like this:
Then the theory 2 is correct: Some people are mathematicians while others are handymen. The latter love complexity. It has nothing to do with experience level.
Martin Sústrik, July 25th, 2014
Previous: Idiot's Guide to ABI Versioning
Next: Magic numbers in C
Let me start with the survey myself: I am programming foe 30 years now (I was 10 when I started) and I vote for option A: the tools are indeed too complex these days.
10 Years in programming, 15 in IT. And Yes, A: Tools have got too complex these days and should be thoroughly simplified.
P.S. Mathematicians love to find generalized solutions for easy problems. It brings complexity to code.
Important distinction: The question here is what kind of tools they prefer to *use*, not what kind of tools they develop.
Basically A, even so the porclain could be an API driven B.
But count me as an A please. :) 10y of programming…
How about a twitter handle to get the answers?
Am mid 30's, have been programming since I was ~9. So that puts me in at about ~25 years of being sat in-front of a screen, ~16 years of that being paid to do so. Have worked on large telecoms systems through console game platforms. For me there is much beauty in simplicity. So my answer for this is Option A without a doubt.
Working for telecom makes person value simplicity, doesn't it? :)
Programming for 22+ years; definitely got to go with A. I have no particular issue with complexity where it cannot be avoided, but unnecessary complexity is just that - unnecessary - and as I get older I find myself becoming progressively less tolerant of it.
Bizarre, as both a mathematician and a programmer for 35 years (couldn't start at 9 no machines) mathematicians hate complexity - they don't mind (too much) when it arises from their simple models, but they sure as heck do not go seeking it out.
And yes I really despise model complex tool sets - hide the problem and stop you making process - bare bones editor and web page
Around 15 years of experience as a programmer, and vote for A.
Nice survey :)
Programming for 12+ years. Definitely A!
Oops! Everyone's voting for A so far. Looks like we are hitting self-selection bias here. Devops folks, where are you?
Wrote my first piece of code at ~10y old (I'm 36 now), commercial dev for ~15 years. I vote for A, of course, but…
I feel it's slightly more involved - software complexity often gives us just headaches (1st thought - using XML as configuration format, something I always considered being some sort of masochism), but I believe some problems are just complex and require complex software. It's very much domain-dependent.
It's interesting what you wrote about learning new frameworks and technologies being not as exciting as it used to be - just couldn't agree more. As a side-effect, at some point you just become more hype-resistant :) New technology to save the world? OK, let's wait 2-3 years…
And given all the complexity of the technologies around, it's more and more difficult to cope with day-2-day tasks without a little bit of (over?)specialization…
I am not oblivious of the complexity in some domains. I've even written about it: http://250bpm.com/blog:36
However, in this particular case, when I said "complex" what I really meant was "more complex that it neccessarily has to be".
Post preview:
Close preview