Let me try and answer this from my own experience – which closely matches that of the typical person you highlight in your question.
Until recently I had (what I thought) were pretty good computing skills. For work I could do some very clever tricks with systems like Excel. I think I can safely say I knew and used the vast majority of Excel’s functionality. I could code up some pretty interesting, in-depth programs / macros in VBA that called APIs and manipulated tons of data. I was also pretty good at the command line and writing functions in R. I was even pretty good (so I thought) with understanding hardware and networking. For bigger projects, I thought I could communicate clearly and “on the level” with devs in my organisation.
But I’d never tried to build an entire, self-contained piece of software.
So I thought I would build my very own moderate-scale project; given my experiences with Excel and R, I thought I had enough skills to have a decent crack at it.
How to find the perfect Software Development resources is really difficult.
I had no idea what I was in for.
Here’s my response based on that (ongoing) experience:
- People have a lack of experience / reference point with tasks similar to programming
- The general quality of software encountered by people on a daily basis creates some pretty severe cognitive dissonance as to skill requirements
- People have almost zero experience with strong logic / mathematics / abstractions
- People have a preference for soft-tasks that are “interpreted” rather than hard-tasks which require precision, completeness and persistence
Experience / Reference Points
Firstly, as you say yourself, many people have never tried building software before, so they have no reference point for its difficulty…that seems a bit recursive, but bear with me:
People may understand that programming is writing code, but they probably don’t realise that writing code is just an abstraction from processing a very wide range of tasks and procedures – most of which involve some facility with mathematics and hard logic (two things many people find difficult to deal with other than the rudimentary basics).
This shows why the comparison with building a house is a little off…people don’t try building houses (or going to the Olympics) because they have some general idea of the difficulty of those goals from their life experience. For instance, you learn growing up that physical building requires exhaustive labor. Likewise with going to the Olympics – most people try running 100m and find it pretty hard to get anywhere close to 10 seconds. They also find out pretty quick that to even get incremental improvement requires extraordinary effort.
Yet until you dive head-first into trying to get a computer to do exactly the (n) things you want it to do, in exactly the right sequence, producing the correct output as quickly as possible it’s just too vague to understand what that might require.
Which brings me to my second point
Software Quality Today:
Think of all the different types of software the average person >15 years of age interacts with every day – probably without even noticing. It’s mostly just *there* and it *works* without much effort on their part. Everything from dating to re-heating their food to driving their cars involves explicit or implicit interaction with software.
But there’s a disconnect between people’s experience of a front-end (which is often, at best, just using wrappers enabled by a GUI) and what actually goes into “making the magic happen”. People’s association is with clean, simple, direct interfaces — so they apply the same linear inference they use elsewhere in life and assume software design must also be pretty simple and clean.
It’s actually a testament to today’s software engineers that this is the case. You guys can mask pretty vast complexity with some fairly simple interfaces (just look at what’s going on behind the scenes with Quora or Facebook – or even just pulling down a simple webpage).
So you only have yourselves to blame 😉 .
Logic / Math Requirements
This one is pretty self-explanatory.
To get software to do anything meaningful requires a decent grasp of logic. And most people aren’t comfortable with explicitly demarcating logical branches of a series of tasks.
Sure…people might grasp [if (x) do (y)]. But they might not get multiple nesting of that type of logic (ie [if (x>n), do (y) else if(and( x<n, var =”ABC”), do(z) while (z>k.. etc etc)]). Even if they can implicitly understand all the steps and calculations involved, they might not like the (often exhaustive) process of actually having to make such logic explicit and precise for a machine to understand — in a language the machine *can* understand.
Preference for soft / interpreted tasks over hard / explicit tasks:
Given the above, I think it is also a safe generalization that people prefer natural forms of communication. And communicating with a computer is quite unnatural.
Computers don’t grasp feelings. They can’t read between lines. They don’t process what you “meant” them to do. They do *exactly* what they’re commanded to do; no more, no less.
We all know that degree of precision is far from the norm in social interactions. We nudge or wink or make non-verbal gestures that are communicating a significant portion of our intention and meaning. That’s lost the moment you sit in front of a command prompt. And I think it is a major reason why people vastly underestimate the difficulty of building software.
Building anything (even something quite trivial) requires precision and detail that is just not present in many other fields. Building software is unforgiving and objective (it works or it doesn’t). Yet the interaction with software hides all this complexity and boils it down to mouse clicks and cute, clean graphics.
I think this objectivity is also a bit counter-cultural. In life, students get half-marks for almost right answers. You might not get fired if you half-ass a particular job. You don’t have to (often 😉 ) define terms with your spouse before arguing with them. So we’ve become a bit soft.
Computers make us feel stupid because they don’t give us half marks. They just spit back errors. You can’t build half-right software – that’s worse than no software at all because of the time you’ve wasted trying to build it. They make us perform or else force us to raise-our-game. They require us to think more rigorously and precisely. They don’t tolerate generalities and vagueness.
That scares our soft, western mindset. We’re not used to the way such direct, objective feedback makes us feel about ourselves.
Take heart devs / engineers. You’re doing your jobs so well these days that people think what you’re doing is easy. It’s really an enormous compliment.
The upside is that people will try…and fail…to do it for themselves. But this has two pleasing side-effects. The first is that they will likely be much more willing to pay you software engineering folk to do their thinking for them. The second is that you will possibly have a much more understanding and sympathetic audience in future.