
Learn to Code, It's Harder Than You Think - mikehadlow
http://mikehadlow.blogspot.com/2015/12/learn-to-code-its-harder-than-you-think.html
======
paulcole
There's a big gulf between knowing how to code and working as a professional
software developer.

I'm a writer for a marketing agency, but I write Google App Scripts,
JavaScript, and PHP on a regular basis to automate tasks, try out ideas I
have, etc.

There's no way I could work as a professional software developer, but I know
how to code enough to help make my professional/personal life easier and more
fun.

Isn't there something to be said for that? Not every skill needs to lead
directly to a job. Can't it just be another skill to have when you need it?

I learned to code through Codecademy and trial and error with frequent Stack
Overflow searches. If I can figure it out, anyone can.

Edit: For anyone saying they would hire me, I'm flattered but am very happy
working as a writer who gets to program occasionally. If you're interested,
here are two little projects I've put together:
[http://playRollo.com](http://playRollo.com) and
[http://WriteByNumbers.com](http://WriteByNumbers.com). Feedback? Email me,
paulcole@gmail.com.

~~~
mattmanser
Err, yeah, you could work as a professional programmer if you wanted to.

You can code. The whole point the article is trying to get across is that a
lot of people are simply unable to learn how to code. You've learnt. You CAN
become a professional.

You just don't realize it.

The step you've taken is the hard one. In fact, there's another big dirty
secret in programming.

A load of professional programmers aren't able to do what you can do, they
can't make new programs. They can only modify existing programs. Making new
programs is beyond them (or at least takes them an inordinate amount of time).
Automating scripts to make their job easier is something that they would take
weeks to do.

EDIT: I'm not sure I agree with the article though, I've heard several
arguments that we simply teach programming badly. Especially in universities.

~~~
sbov
There's a dirtier secret:

A load of professional programmers are not able to make new programs.

A load of professional programmers are not able to modify existing programs.

And a load of professional programmers are not able to finish programs.

Almost no-one is good at all 3. Most are extremely bad at least one of these.

Lots of people who are "good" at making new programs are actually pretty bad.

~~~
galfarragem
Does HR know this? I'm afraid not.

~~~
dragonwriter
If HR is doing something other than providing expertise on managing
relationships (particularly, the formal and compliance-related aspects of
those relationships) for supervisory/management staff that are the domain
experts providing knowledge related to the skill sets needed for the staff
which are or will be reporting to them, then the organization has a
fundamental (though, to be sure, distressingly common) design flaw.

------
gabemart
I feel like the discussion around this post will suffer from a lack of
specificity over what a 'software developer' is.

Someone who works primarily on small javascript web applications has a really
different job from someone who works on a large application built on a LAMP
stack, or someone who writes complex iOS applications, or someone designs
self-driving car software for Google, or someone who works on embedded
software for pacemakers, or someone who writes operating systems or designs
programming languages.

Each of these jobs probably have a particular set of paths that lead to them.
Two people who are both 'software developers' don't necessarily have similar
skills, training or education.

~~~
Alex3917
> Each of these jobs probably have a particular set of paths that lead to
> them.

I think the commonality is that at the minimum you need to be able to read
English at a proficient level, which weeds out the vast majority of American
adults.

~~~
eloff
The vast majority of adults can't read English well? Let's get real here,
that's not even close to the truth.

~~~
Alex3917
Out of curiosity, what makes you believe that? I live in America, and your
claim sounds somewhat bizarre.

~~~
eloff
You meant to reply to the parent right? Just look at the published studies on
the topic. One can argue for roughly 20% functionally illiterate easily, any
higher and its really just speculation. Certainly far from a "vast majority"

------
moyix
> Other research points to similar results. There seems to be a ‘double hump’
> in the outcome of any programming course between those who can code and
> those who can’t.

> “In particular, most people can't learn to program: between 30% and 60% of
> every university computer science department's intake fail the first
> programming course.”

Argh, I knew when I opened the article that its evidence would end up pointing
to the "camel has two humps" study.

That study has been retracted, and the author regrets the damage it may have
caused to computer science education:

[http://retractionwatch.com/2014/07/18/the-camel-doesnt-
have-...](http://retractionwatch.com/2014/07/18/the-camel-doesnt-have-two-
humps-programming-aptitude-test-canned-for-overzealous-conclusion/)

> Though it’s embarrassing, I feel it’s necessary to explain how and why I
> came to write “The camel has two humps” and its part-retraction in (Bornat
> et al., 2008). It’s in part a mental health story. In autumn 2005 I became
> clinically depressed. My physician put me on the then-standard treatment for
> depression, an SSRI. But she wasn’t aware that for some people an SSRI
> doesn’t gently treat depression, it puts them on the ceiling. I took the
> SSRI for three months, by which time I was grandiose, extremely self-
> righteous and very combative – myself turned up to one hundred and eleven. I
> did a number of very silly things whilst on the SSRI and some more in the
> immediate aftermath, amongst them writing “The camel has two humps”. I’m
> fairly sure that I believed, at the time, that there were people who
> couldn’t learn to program and that Dehnadi had proved it. Perhaps I wanted
> to believe it because it would explain why I’d so often failed to teach
> them. The paper doesn’t exactly make that claim, but it comes pretty close.
> It was an absurd claim because I didn’t have the extraordinary evidence
> needed to support it. I no longer believe it’s true.

------
conductr
I liken coding to playing a musical instrument.

Some people are musically inclined, they can learn easily and fast and they
tend to the best. But most people require some level of training complimented
by the dedication of what amounts to mostly self-practice. So in a way, you're
self taught.

The vast majority of people are willing to buy an instrument, just to see if
they are musically inclined, but when they find out they aren't they don't
have the dedication to do it the hard way.

~~~
amelius
> I liken coding to playing a musical instrument.

Except with a musical instrument, _anybody_ can judge whether you are good at
it. Not so with programming. Everybody who ever wrote one line of HTML can
call themself a programmer, but only trained people can tell whether you are a
good one.

You might say at this point: so what? But I think the distinction is
important, because it may be the reason the "driving force" is missing for a
lot of people. If programming really had "rock stars" we might have had a lot
more good programmers.

~~~
teh_klev
Counterpoint, I can knock out a first class "Stairway to Heaven" in the local
electric guitar shop simply by remembering where my fingers should be but not
having any clue about what chords and notes they are.

Can I be judged to be an accomplished musician upon that sole rendition?

~~~
dasboth
Of course not. There isn't really a programming equivalent though. I guess you
could memorise the syntax for one specific, complicated program and you're
right, that wouldn't make you a programmer.

------
teach
[I made a similar reply down below, but I think this belongs here, too.]

I've made my living by teaching beginners to code. I have been doing it for
the better part of two decades, and I specialize in teaching students that
have little aptitude for it.

In my experience, many students can learn how to code, but it takes a very
long time!

For example, I make my students code FizzBuzz. It is literally the 106th
project I make them do. That is, they have completed 105 complete computer
programs before getting to FizzBuzz. And many of them still struggle with it.
The nuance of else/if needing to be ordered in a certain way is something they
still don't have a good grip on.

Programming a computer is very very hard for most people, but that doesn't
mean they can't do it.

~~~
tonyedgecombe
Why do you do it, my guess is most people here would never knowingly hire
someone who struggled with such a basic concept.

~~~
teach
Because my kids keep practicing for ten years after my class before getting
jobs.

All my students are aged 14-18.

------
hashkb
Also, shoveling bootcampers into the industry is bad for real engineers and
the quality of their software. Management everywhere is lowering the bar so
they can hit their hiring goals and pretending the consequences are natural.

~~~
sotojuan
It really hurts new CS grads too. They usually go for similar jobs as Bootcamp
grads, but may get rejected because they don't have the "practical" experience
(i.e. latest frameworks) Bootcamps grads may have. So instead of grooming and
training students with a four year foundation in Computer Science, they go for
the cheap route and hire someone who just knows APIs.

I admit my post has a lot of generalizations and I know Bootcamp people that
are great engineers and CS grads that are not, but I think you get my point. I
see a lot of frustration over this in /r/cscareerquestions.

~~~
dudul
I would argue that CS grads who do not spend some time learning practical
skills on the side are idiots and completely misunderstand the industry they
are trying to enter.

Bootcamps claim that they can help people who lack the proper foundations or
the discipline to learn on their own, these are assets that CS students should
have, they should therefore apply their knowledge and training to learn on
their own the tools that are used in the industry.

~~~
sotojuan
> I would argue that CS grads who do not spend some time learning practical
> skills on the side are idiots and completely misunderstand the industry they
> are trying to enter.

I agree, but then I realize I live in a bubble.

Here and in /r/cscareerquestions, everyone knows to do side projects. In my
school, most people don't. Neither do my friends in other schools. They may
get one internship but that's the only "practical" thing they do (usually good
enough to get a job though). A lot of my friends are much busier than me and
don't have time to teach themselves stuff on top of school and life, at least
not well enough to get a job.

Perhaps we need to stress a bit more practicality in CS curriculum?

~~~
dagw
_Perhaps we need to stress a bit more practicality in CS curriculum?_

No, we need to stop telling people who want a career in web development to get
a degree in Computer Science. And universities should stop convincing people
who really want to be software engineers to study computer science. If you
want to work as a structural engineer you'll probably get a degree in
structural or mechanical engineering. You don't get a degree in theoretical
physics and complain that since structural engineering is just a practical
application of theoretical physics your physics curriculum really should be
more focused on practical engineering.

~~~
mywittyname
> You don't get a degree in theoretical physics and complain that since
> structural engineering is just a practical application of theoretical
> physics your physics curriculum really should be more focused on practical
> engineering.

I sometimes feel like we should just call Computer Science what it really is,
Applied Computational Mathematics. Because, you're exactly right, there is a
disconnect between the teachings and expectations of most CS programs.

Then again, my CS program offered lots of 'practical' courses, like iOS and
web development. They even created a BA program that removed most of the math
requirements and replaced them with those vocationally related classes.

~~~
dagw
_Then again, my CS program offered lots of 'practical' courses, like iOS and
web development. They even created a BA program that removed most of the math
requirements and replaced them with those vocationally related classes._

That sounds like great programs that all universities should offer. They just
shouldn't call it a CS program.

------
matthewtoast
The article's main point is solid: Learning to code is hard mostly because
coding is hard -- not just because there aren't enough learning opportunities
and not just because we aren't welcoming enough. And learn-to-code merchants
who say "Coding is easy!" are a bit untruthful in the infomercial kind of way.
As those of us who do it professionally know, coding is often tear-your-hair-
out difficult. Misery loves company! :-)

That said, I have two problems with the article.

#1 - I don't like the idea of qualifications. Sure, the lack of career-path
guarantees sucks, but that anarchy also benefits us. If I can get my hands on
a computer, I can learn to code on my own (with lots of hard work, yes), build
what I dream of, change my life. I can sidestep red tape, bias, prejudice, and
credentialism that might work against me elsewhere.

#2 - I dislike the vague word 'aptitude', which the author uses many times.
The idea of 'aptitude' may help distinguish Mozart from Salieri, but not
Salieri from his cousin Fred. What I mean is, at the level most of us operate
at, mightn't factors like motivation, persistence, and health affect us more
than 'aptitude'? If the article replaced the word 'aptitude' with 'motivation'
I'd like it better.

------
acconrad
_Hard_ programming is harder than you think. Coding schools are mostly
teaching CRUD web development and a watered-down version of data science aimed
at business analysts, which isn't that hard. You're not going to get folks
lining up to take an embedded systems, graphics, or compiler bootcamp.

~~~
vinceguidry
Web development (it's more than just CRUD) is hard. Even with the best web
development framework, the state of the art in tooling, you're looking at at
least a year of focused study before really being able to take a job.

It doesn't require hard math, but it's still hard in that the sheer number of
languages, tools, best practices, technologies is daunting.

And they keep changing. My father is an electrician, after learning the ropes
from him, I went into low voltage, which he wouldn't learn how to do because
it "keeps changing", meaning you had to take a little bit of time every year
to learn some new things. Full stack web developers have to take significant
amounts of time every _day_ to learn new things.

I've seen devs who were perfectly comfortable with all the math and "real dev"
practically break down when presented with a web project. More than one of
them admitted to me after beating their heads against it for a few weeks that
it was harder than it looked.

I can understand if you can't appreciate the difficulty. But try taking on a
significant project before calling it easy.

~~~
serge2k
> I've seen devs who were perfectly comfortable with all the math and "real
> dev" practically break down when presented with a web project. More than one
> of them admitted to me after beating their heads against it for a few weeks
> that it was harder than it looked.

Because they haven't done it before.

Hard because you have to learn the framework of the week, deal with shitty
tooling, and leverage design skills you haven't ever really had to develop is
a very different thing than hard because you have to design and build a
complex system with strict requirements and intractable problems.

~~~
vinceguidry
> hard because you have to design and build a complex system with strict
> requirements and intractable problems.

That sounds like web dev. The intractability of the problems comes from the
fashion-like nature of how often things change and the speed at which they
have to change. The more you learn, the more you can do, but also the
requirements will change as a function of your abilities. Maintaining an
business advantage demands it.

The framework doesn't have to change, the tooling can be self-designed, the
design skills can be learned, and web dev remains hard and interesting. I
understand that lots of devs don't appreciate it, but I still find it
interesting after 5 years, and expect it to remain so after 20.

I liken it to a craft, take woodworking as an example. Sure, anybody can learn
to bang nails into wood. But the way you hit a nail into a piece of wood the
first time is going to be way different than the way you bang it in after 5
years, and it's going to be a totally different experience to the way you bang
it in after 40 years.

There's a definite craft to choosing frameworks, growing tooling, and
fashioning design to solve interface problems.

Is it as hard as hard math? No. Is it harder than 99% of people can do at all,
and harder than 80% of _software developers_ can do _well_? I fully believe
so.

------
yarper
I agree with the author that boot-camps and the learn-to-code attitude teaches
people generally that they could easily "do it if they wanted". This is
slightly different to the intended message which is "you should do it, we can
help".

Historically for me, I'm sure that kind of attitude pushed my clueless bosses
into thinking I'm some kind of semi-skilled lackey that can readily be
replaced with outsourced staff or graduate hires. It's kind of a self feeding
one, because if they do outsource it works for a while, until a kind of
critical mass happens and it starts falling apart. The confirmation bias after
making this call also makes it almost impossible to undo.

I'd disagree on one point - and that is that programmer is a synonym for
software developer. It's one thing coding yourself up some scripts at home,
another thing altogether building a reliable, scalable technical solution
within a (possibly large) team. All software developers are programmers, but
not all programmers are software developers.

------
mgirdley
I loathe these type articles.

They're complex arguments to justify the attitude that "only we chosen few
(men) with serious tech degrees are gifted enough to do important work in
code."

Tech is a big, prosperous industry and will be bigger if we act welcoming
rather than creating complex arguments to protect our turf.

Disclaimer: Am a white male with a CS degree who runs a coding bootcamp.

~~~
dandare
The article arguments for the very opposite. Did your bias prevented you from
reading it till the end before commenting? :)

~~~
klunger
No. The last paragraph of the article: "The majority of the population can not
learn to code at all, no matter how much training they receive. I doubt very
much if the plethora of quick learn-to-code courses will have any impact at
all on the skills shortage, or the problem of unskilled low pay and
unemployment. Let’s stop pretending that there are artificial barriers to
entry and accept that the main barrier to anyone taking it up is their natural
aptitude for it." This is very clearly another (tasteless) "we chosen few"
type article.

~~~
douche
When I was a young man, I dreamed of being a center for the Boston Celtics.
Unfortunately, my growth spurt stopped at 6'3", rather than the 6'8" or 7'
that I'd need to have a chance to even attempt it. I practiced my skyhook for
at least 10000 hours in high school, but I'd still get destroyed trying to
post up on Brian Scalabrine or Brian Cardinal.

Sometimes, you either have the capabilities to do the job, or you don't.

------
jdiez17
This article reflects my experience at University very well. I'm a self taught
programmer that ended up pursuing a CompSci degree. I'm in the last semester
of my BSc, and in hindsight I should have studied something else, like Physics
or Electrical Engineering.

The standards are ridiculously low. Most of my coursemates (final year CS
students) are literally unable to write software. They can write a single-file
cpp file in Code::Blocks on a good day. In my experience (and having talked to
plenty of other CompSci students, their experiences are similar to mine),
formal education in programming is generally reduced to teaching students all
about recursive functions, bubble sort and those kinds of things. There has
been a grand total of 0 lectures or labs about unit testing, version control,
API design, interoperability, etc. Let alone trying to communicate the idea of
"clear, maintainable" code. Only a very small minority of people can write
code, yet most of us will graduate.

I have a module called "Software Quality and Process Management" (formerly
known as "Large Scale Software Engineering". Good thing they changed the name,
at least now it's not such a blatant lie). In this module, we learn all about
COCOMO, and how we should _estimate the number of lines of code_ a project
will use, and use that to figure out how many man-hours are required to
complete it. __WTF __. I 'm preaching to the choir here, but that's like
estimating the amount of effort it will take to design an airplane based on
the number of grams of aluminium in it. When someone raises their hand and
disagrees about the relationship between SLOC and person-hours (or even about
whether person-hours is a reasonable unit - it's not), the lecturer responds
with a blanket "you're entitled to your own opinion", but draws blanks when
asked about whether they know anyone who actually uses these methods in real
world software engineering and finds them useful. It's the same story when
they teach about the waterfall development process and other similar outdated
practices that are known to be detrimental to healthy software.

The vast majority of what I know about software engineering didn't come from
my time at University, and almost all of the software engineers I know have
had a similar experience. I know correlation does not imply causation, but
it's definitely food for thought.

~~~
bencollier49
This matches my experience. I was trying to hire a junior programmer, and got
someone in for interview who ostensibly had a first-class CS degree from a
Russell Group university, yet could not explain to me what Functional
Programming involved. He didn't even recognise the term.

(Incidentally, the university refused to corroborate his degree, on the
grounds that it would be a breach of the Data Protection Act, which boggled my
mind).

~~~
teh_klev
> junior programmer

> could not explain to me what Functional Programming involved

See that first term, give him/her a break.

I've worked with experienced devs with many year's experience who couldn't
explain the term functional programming, yet practice it every day. Just
because you don't know the fancy programming term du jour, doesn't mean you
aren't capable or competent.

Turns out I've been using the functional programming paradigm since 2001. It
wasn't until six years later I discovered there was a name for it.

------
codingdave
The unasked question is whether learning to code is only useful if you intend
to be a software developer. I believe that the logic and analytic skills
acquired from learning to code are useful throughout your life no matter what
job you take.

The analogy people in my company like to use is that everyone learns to write,
but not everyone becomes a novelist. Everyone learns arithmetic, not everyone
is a professional mathematician. Everyone takes science classes in school,
whether or not they intend to be a scientist.

Coding is pervasive enough that is is worth at least learning the basics. If
you turn out to like it and be good at it, go ahead and pursue it as a job.
Otherwise, those basics are just a part of modern literacy.

------
rdlecler1
If a only a small portion of the population will be adept at programming, and
training is less important, then it's likely that most of the potential talent
does not have formal training incompetent science. Therefore, coding schools
should give a second opportunity for those tho did not study computer science
in a formal university setting. Learning to code may help reveal those very
people.

~~~
gmfawcett
I assume you meant, "formal training in computer science," not "formal
training incompetent science". Autocorrect!!

~~~
kazinator
Autocorrect has real AI now, complete with topic-relevant opinions!

------
wawi
On the one hand, I wish to concede defeat in this argument, that indeed this
is a very British argument being made, one that is, essentially, "an excuse
for class", whereby a subject requiring high-order adept facilities is
available only to "a select few", 'because class system'.

On the other hand, beyond the borders of the colonial-imperial mindset, we
have kids in the slums who - precisely because they were not given the 'golden
ticket' of opportunity presented to a select few - had to actually .. you know
.. do the work of becoming a very good developer.

Good developers are not limited by class.

(disclaimer; have lived and worked with many good developers around the world,
and it has nothing to do with education and everything to do with spirit..)

~~~
fmstephe
I suspect that you have had very similar experiences to the author. The author
is quite clear that education is no indicator of ability to program.

I think the author would be very happy admit your hard working very good
developer friends into the set of 'good programmers'.

------
Cshelton
I think a large number of your 'self-taught' results come from the fact that
developing software is a profession where you always have to be learning, or
you won't be good. I have not met any programmer who has said competently (and
who actually are) I know everything about X. There is always learning to do in
this world, and in most cases, you are either learning as a group, on the job
training, or self taught. To an extent, being self taught will fall into all
of those categories. The people who show up to meet ups to learn are the ones
who want to go home and experiment with new things and practice their craft.
The programmers who expect to just learn something then shut off and treat
their day job as a 9-5 gig are the ones who fall behind quickly and become
'bad'. This is not the industry that allows for that. For example, the Web
right now is the wild west, 6 months ago you built something yet now, that's
no longer the best way to do it.

Many other professions are the same way, even the doctor example. They
constantly have to be learning to be great and the ones who stop 'learning'
and teaching themselves are the doctors I wouldn't want to treat me.

I also see, across many professions, the ones who are at the top of their
profession are the ones who have the ability to teach themselves. In college,
you learn very quickly how you learn. Some students have a very hard time
learning new concepts on their own, they must attend a lecture and have
interaction with the professor. However, on the other side of it, some
students get very little benefit from lecture. I would know, I was that way.
In a lecture I would always be doing something else, that's if I even went to
the lecture. I much preferred to teach myself, and when I run into something I
didn't understand, I found the resources that made sense to me to understand
something. This is what you have to do in the real world. Every student needs
to have the ability to do this in any profession. There is no, 'I finished
school, I'm done learning...'. You will be mediocre at your job at best if you
have that mentality.

So yes, programming is hard, being a doctor is hard, being the top percent of
ANY profession is hard.

~~~
bdcravens
Many "professional" educations require continued learning to maintain your
license. While I don't think a "programmer license" is a good thing, a
voluntary way of demonstrating this would be good

------
discardorama
Coding requires a mindset that some people just don't have, or haven't
developed yet. Ask any TA who has taught the basic "intro to CS" courses, and
you'll hear lots of anecdotes which show that some people just don't get it.

Here's an example:

    
    
        Q: write a program that reads 2 numbers from standard input, 
        and outputs their sum. For example:
        First number: 3
        Second number: 7
        Sum is: 10
    
    

Here's a solution someone submitted:

    
    
        print "First number: 3"
        print "Second number: 7"
        print "Sum is: 10"

~~~
joshcanhelp
There was a paper published about exactly this, summarized by Jeff Atwood [1].
Essentially, there appears, according to the authors, that there is a mindset
that people either have or don't have that allows them to understand the very
basics (variable assignment, iteration, etc) before they've had any training
at all. Students were tested before 3 weeks of education and after and the
results were essentially the same: the ones that got it in the beginning were
the same ones that got it at the end.

This supports the original article in one way by saying that it's not for
everyone and bootcamps for the general public are not going to help much, but
it contradicts the secondary point which is that we should be convincing
potential doctors and lawyers to start learning CS. Programming aptitude
doesn't start with intelligence or background, rather from something innate.

[1] [http://blog.codinghorror.com/separating-programming-sheep-
fr...](http://blog.codinghorror.com/separating-programming-sheep-from-non-
programming-goats/)

~~~
gyardley
I really wish people wouldn't link to ten-year-old drafts without checking on
current research. The article Atwood links to makes some totally bombastic
claims - here's the retraction and clarification of them:

[http://www.eis.mdx.ac.uk/staffpages/r_bornat/papers/camel_hu...](http://www.eis.mdx.ac.uk/staffpages/r_bornat/papers/camel_hump_retraction.pdf)

While a consistent mental model for things like assignment is a good sign, not
initially having it doesn't mean you can't learn how to code. Lately,
researchers have found that certain pedagogical techniques (especially pair
programming) are pretty effective at overcoming these deficiencies.

I wish I could understand why so many programmers are eager to assume their
skills are due to something 'innate'.

~~~
dragonwriter
> Lately, researchers have found that certain pedagogical techniques
> (especially pair programming) are pretty effective at overcoming these
> deficiencies.

That's interesting. Its interesting to me, because -- while I may or may have
developed the aptitude independently later without this -- I actually spent a
lot of time when I was first learning programming, in elementary/middle school
in the 1980s, pair programming (though, you know, the name wouldn't be coined
for quite a while) with my dad.

> I wish I could understand why so many programmers are eager to assume their
> skills are due to something 'innate'.

One reason might be because if anyone could learn it, programmers wouldn't be
able to view themselves as special.

Another might be because if people _realized_ everyone could learn it,
programmer salaries would fall from increased competition, so programmers have
financial self-interest in people _not_ believing that most people can learn
to code if they try, _especially_ if its true.

~~~
JoeAltmaier
Everybody can learn plumbing too. Doesn't mean the prices are going to fall.
Programming can be very fiddly, and most people hate that. I think our jobs
are safe.

~~~
dragonwriter
> Everybody can learn plumbing too. Doesn't mean the prices are going to fall.

Well, no, because "everyone can learning plumbing" is pretty widely accepted
(and has been for quite some time), so the effect of that belief being
accepted is already reflected in the current market price. (OTOH, the price is
_lower_ than it would be if it were widespread belief that becoming even
modestly competent at plumbing required unusual innate gifts that most people
lacked, and that attempting to learn plumbing was a complete waste of time for
people lacking those gifts.)

------
Shank
I'm currently in an undergraduate program for Computer Science at the
University of Wyoming.

At my level (third year Computer Science classes), I've had the following
class composition:

\- 2 classes dedicated to learning C++ (COSC 1010 was skipped, but included
here for numbers, and COSC 1020)

\- 2 classes dedicated to algorithms in C++ (COSC 2030, 3020)

\- 1 class dedicated to math (COSC 2300, discrete structures)

\- 1 class dedicated to functional programming (3015) (mostly proofs related
to recurrence relations)

In the future, it looks like my courses will be filled with networking,
operating systems, compilers, and a couple other math topics.

The problem is that most students only get a very foundational introduction to
programming in this program. Students are tasked with writing code, but only
limited quantities in very specific areas. That's algorithm development and
implementation.

The answer might be that students should be taking software development or
some other degree, but right now CS is the route most students try to take to
become developers. This isn't a good approach, because at the end they have
very little development experience -- only some algorithms and knowledge of
computers.

I too would answer with "self taught" for how I learned to program --
definitely not from this program thus far.

~~~
sgeisenh
In my opinion, it is very easy to teach the basic principles of software
development and design. Algorithmic thinking is much harder to teach. A CS
background sets you up to contribute ideas and produce efficient solutions to
challenging problems. A software development background sets you up to
implement ideas and solve problems quickly.

Obviously these are generalizations, but that's what I have seen in my
experience.

------
tsunamifury
" The majority of the population can not learn to code at all, no matter how
much training they receive."

What an arrogant, false, and self-aggrandizing fiction. Stop over-valuing
yourself -- coding isn't some ultra-difficult natural selection process
equivalent to winning an NBA Championship.

Designing complex services, scaling and maintaining them on a server stack is
hard. Developing, training, and shipping a useful deep-learning network and
making it into a useful product is hard. Coding is not hard.

I get sad when engineers, especially ones who's tone seems vaguely threatened,
start writing up these discouraging blog posts belittling 'noobs'. Its a
pleasing fiction that software engineers are just 'naturally better' and
therefor their jobs are ensured. I think that anyone who says this has likely
not been in the industry for very long -- because they would have seen scores
and scores of devs left behind due to not training up and getting beaten out
by upstarts who teach themselves and do well.

~~~
teach
Coding is, in fact, quite hard.

But that doesn't mean no one can learn it.

Playing the saxophone is quite hard but a lot of students learn how every
year, to varying degrees of skill.

~~~
tsunamifury
You're right -- the finer point seems to be that coding is not a binary state.
Its a lot of things along a spectrum and a lot of people make money at all
points.

------
heydonovan
I could not disagree more on the notion that software developers are looked
down upon. In my experience, all those developers are treated as omnipotent.
Having intelligence on another level. These are the people who wear hoodies in
the elevators, and carry around a Macbook, while everyone else is forced to
wear business attire (along with faces of misery and non-excitement). These
developers are the people that created Facebook, Twitter, Netflix, etc and are
known to have lots of cash, but never flaunt it. The same people that are seen
headed to the bars with their team, and enjoy the freedom to code from
anywhere that has Wi-Fi. Maybe it's just the fact that I've only ever worked
at startup companies, but other professions are seen as simple, and clear cut
as to how to go about it. "Oh, you're an accountant? Anyone can do that, just
go to school, follow the steps, and a degree awaits at the finish line".

~~~
teh_klev
_> In my experience, all those developers are treated as omnipotent. Having
intelligence on another level. These are the people who wear hoodies in the
elevators, and carry around a Macbook, while everyone else is forced to wear
business attire (along with faces of misery and non-excitement). These
developers are the people that created Facebook, Twitter, Netflix, etc and are
known to have lots of cash, but never flaunt it_

Not being rude, but I'm trying hard to figure out if this comment is
parody/sarcasm or if you genuinely believe this fantasy?

------
peteyPete
I'm a bit torn on this one. Some languages and concepts are harder than
others. Some people are more visual than others. Some people would excel in
low level languages where others would excel doing front end web dev where
things are a bit more visual and often a bit less abstract.

The biggest thing with coding is finding something you like... Passion is the
key here. Some things will come easier than others but if you're passionate,
even if you're not a bloody genius and it takes you many times before you get
something, you'll spend enough time and eventually get it. And over time
you'll get better and better.

In 12 years working in the field I can say I've worked with a fair amount of
devs. I've worked in very small software companies, medium sized companies and
fortune 500 companies. I've worked with self taught devs and people with
degrees. The biggest difference between someone who's great at their job and
not is not the education but the passion. Its not even the book smarts. Some
people are smart as hell but just aren't passionate and don't enjoy what they
do at all. Every year your job feels a bit different. Languages evolve,
technologies evolve, libraries and frameworks evolve. You're constantly
working with new things. Some don't feel 100% different, others do. Once
you've learned a bunch, some new concepts are very easy to grasp. But at the
end of the day, if you hate it, you probably won't keep up and will quickly be
obsolete. Most new jobs will require a lot of learning. If not new languages
then new processes, infrastructure, code bases, etc. If you're passionate
enough to keep learning and patient enough to spend the time it personally
takes you to grasp concepts, then you can learn.

Its not for everyone. True. But not everyone will be developing physics
engines for games or deep learning algorithms.. Some coding skills are easier
to grasp than others and most people can, given time, become decent at some of
it.

------
jkot
> _There’s another problem with software development that’s the flip side of
> the low barriers to entry mentioned above, and that is there is no well
> established entry route into the profession. Try Googling for ‘how to become
> a doctor’, or ‘how to become a lawyer’ for example:_

... and it only takes 10 years to become a doctor.

~~~
sotojuan
Like scotty79 says, at least you know what you're doing in those ten years.
Perhaps an easier analogy would be a lawyer or engineer (ABET degree + coop)?
For programming, you get the following "advice":

* Get a degree

* Don't get a degree, go to a bootcamp/teach yourself

* Do side projects

* Get an internship

* Network and go to meet ups

* Learn algorithms and data structures

* Practice brain teaser questions

* Learn these languages

* Learn these languages' frameworks

I'm exaggerating and people can get hired by not know all (or any!) of these,
but you get my point. It can be a confusing and overwhelming path both for
people who want a career change or are graduating from university.

For some, the path to being a doctor is "easier".

------
Grue3
On the contrary, evidence suggests that people naturally learn to code when
faced with operating a programmable device (even if they don't know what
they're doing is coding). Everyone pretty much had to be able code to operate
a computer in the 80s. And they did, even lowly secretaries with no fancy
degrees. Now that people have to deal with closed-down computer systems that
come prepackaged with everything the user is supposed to need, the coding is
not necessary to be able to operate them. And then of course you get a
generation of people who aren't motivated to learn to code, because they don't
have to.

"Can't code" is the new "can't do math". What it really means is that the
person doesn't _want_ to code (or to do math), not that they _cannot_ do it.

------
bcg1
The article makes good points but is a little harsh... of course mastery takes
aptitude and practice and it is ridiculous to think that you could learn
anything even remotely complex in an hour or a day.

But the "learn to code" efforts that are referenced serve the important
purpose of exposing people who might have aptitude to the idea that they can
realize that aptitude. I imagine that people without the prerequisite aptitude
would just quit because it wouldn't interest them, and those who can cut it
would continue on auto-didactically. I'm not trying to be too critical, but
criticising those efforts with the idea that "it is hard, you probably can't
do it" is unhelpful at best.

------
todd-davies
Does anybody else think that Software Engineers might benefit from a
master/apprentice learning style?

Experienced devs could take on an apprentice for a year, kind of like an
internship, and the apprentice moves does 3-5 of these before moving into a
dev role themselves.

~~~
yarper
Yes, Robert "uncle bob" Martin is a fan

[https://8thlight.com/apprenticeship/](https://8thlight.com/apprenticeship/)

------
makmanalp
> There seems to be a ‘double hump’ in the outcome of any programming course
> between those who can code and those who can’t.

In my humble opinion, this is because the pedagogy sucks. Intro CS classes
tend to teach in a very weird way, with very conflicting goals. Is the point
to teach your way around a linux shell? Tooling? Basic programming?
Algorithmic thinking? Good engineering practices? To teach automata theory?
Complexity theory? Most courses answer "ALLLLLL OF IIIIIIITTT!"

Further down the article, you see that there is a large percentage of self-
taught programmers. I suspect that this ratio goes through the roof if you ask
"have you done a lot of CS / software learning on your own".

This is because self teaching lends itself better to learning and practicing
over and over the diverse variety of skills required to be a successful
programmer. Intro classes go very quick and fail to instill any of that. So
those who are successful are a lot of times those people who are already long
exposed to computers, algorithms, programming or the ideas accompanying those
in some shape or form. Or those who find it immediately fascinating and put in
much larger amounts of time than a course would normally require.

Those folks who simply haven't had a lot of time programming struggle, and
eventually they drop out. And nothing changes to improve this because part of
the class succeeds, and thus the conclusion made is that the part that dropped
out must have been "bad".

There's a false dichotomy here. Yes, programming is difficult. Yes, being
successful in the real world requires a lot of work. And yes, like any craft,
the rabbit hole only goes deeper. But the conclusion here isn't that most
people just "don't have the aptitude necessary". Most people, given the same
time and guidance, can succeed.

The most important part is that getting somewhere immediately /useful/ can be
quite quick. That's where programming shines - reasonably low investment costs
for a moderate benefit for a lot of people, which eventually rolls into a high
investment cost for a massive benefit.

------
austenallred
>All the evidence shows that programming requires a high level of aptitude
that only a small percentage of the population possess.

>The current fad for short learn-to-code courses is selling people a lie and
will do nothing to help the skills shortage for professional programmers.

Outside the obvious lack of definition as to what a "programmer" actually is,
this is a non sequitur (the conclusion doe not follow). There's an assumption
built in that those who _do_ possess a high level of aptitude already have CS
degrees or are self-taught because it comes to them naturally. What if there
are people who possess that high level of aptitude and they want something to
help them learn in a structured way?

Extrapolated, the author's argument could be seen as, "Sorry, there's no point
in teaching programming, because everyone with the aptitude to program already
knows how to program," and I think that is a recognizable falsehood, if only
anecdotally.

In other words, even given the assumption that programming _does_ require a
higher aptitude than some subset of the population does possess, there is no
surefire way to determine who that subset is based on credentialing.

~~~
serge2k
The lie they are selling is that anyone can learn to code in 10 weeks. While
this maybe true if you are targeting the correct subset of the population
(those who do have a natural aptitude), it's not true of a random sample of
the entire population. Since these schools sample from the entire population,
their chances of producing large numbers of skilled software developers are
low, and therefore they will do little to help with the shortages of those
developers.

Sounds like a reasonable argument to me.

~~~
austenallred
I don't think anyone pretends like you can "learn to code" in 10 weeks any
more than I "learned to speak Russian" in my three-month intensive Russian
course. Of course I didn't speak fluently by the time I left.

But I learned enough that when I lived in Ukraine I understood a bit of what
people were saying, I could communicate somewhat, and a couple of years later
I was reading Tolstoy.

People think about bootcamps all wrong. You don't leave like "holy shit I'm a
master programmer." You leave knowing, "OK, it'll take a while longer, but I
can contribute a bit now, and I'll pick up more as I go."

------
abathur
There's a lot of back-and-forth over whether it is easy or not or whether one
comparison or another works best.

I think it's fine to compare learning to write code with learning to write
human language. The best of us will still make mistakes; plenty of us will
always be incapable of writing well. Once upon a time the idea that everyone
needed to know how to write was laughable. These days, it's arguable how well
everyone needs to be able to write, but there's a general agreement that it's
worth giving people the opportunity to reach at least a basic level of
competency, even if their daily lives require little writing.

I had a miserable time learning to write (i.e., failed many assignments) until
a few things fell into place, and I saw how writing could be an important part
of thinking, learning, feeling, expressing, etc. I had a miserable time
learning to code through coursework in highschool and college until a few
things fell into place and I saw how code could be an important part of
thinking, learning, feeling, expressing, etc.

How did/do we sell everyone on trying to learn to write human language? AFAIK,
with some superlative rhetoric about how useful/necessary writing can be
without much dithering over what portion of the population will ever be good
enough to make a living at it.

So there are varying levels of irresponsibility when it comes to saying
everyone should code. There's probably a big potential social upside to
fudging things a little to suggest everyone should learn some programming
throughout school; it's much more negligent to tell someone with a boring but
stable job to quit and blow a few grand on a coding bootcamp without an
inkling that they're prepared.

------
sklogic
> _All the evidence shows that programming requires a high level of aptitude
> that only a small percentage of the population possess._

No such evidence, at least not in any respectful sources.

> _will do nothing to help the skills shortage_

Who said that _this_ is the immediate goal of teaching as many people as
possible to code?

> _Given the skills shortage one would expect graduates from computer science
> courses to have very high employment rates._

This logic is broken on so many levels that it's even embarrassing to comment.
Let's start with a trivial nitpicking that _Computer Science_ education got
nothing to do with the _Software Engineering_.

> _there are two populations: one that finds programming a relatively painless
> and indeed enjoyable thing to learn and another that can’t learn no matter
> how good the teaching_

It is really embarrassing that the guy who wrote it calls himself a programmer
- i.e., someone who is supposed to be logical and rigorous.

There are far more categories that these two. And the most important category,
targeted by all the programmes he's mocking, is the people who do no even know
if they'll find programming enjoyable, because they never tried.

------
mei0Iesh
Where was the proof presented for this? That idea doesn't sit well with me at
all. Maybe they meant to say that it's hard for most people to want to sit
still and stare at text all day. It's hard to ignore urges to go out rather
than stay inside and read tutorials on the web.

I don't think programming itself is hard. Most people program. It's just that
they do it without thinking about the steps they're programming, and they do
it without a computer. Parents program all the time, "If you don't finish your
homework before 7 PM, then you will not get dessert!"

I think this is an article, and one with votes on here, because it's
flattering the audience. Maybe say complicated mathematics is hard. But not
"coding". That's what dumb people like me do who prefer to stay inside and
play around with text on a computer. Of all the possible jobs I can think of,
coding is near the bottom of the list in terms of difficulty. Anything
involving a jackhammer is much rougher.

~~~
teach
Your perspective is incorrect.

I've made my living by teaching beginners to code. I have been doing it for
the better part of two decades, and I specialize in teaching students that
have little aptitude for it.

I make my students code FizzBuzz. It is literally the 106th project I make
them do. That is, they have completed 105 complete computer programs _before_
getting to FizzBuzz.

And many of them still struggle with it. The nuance of else/if needing to be
ordered in a certain way is something they still don't have a good grip on.

Programming a computer is very very hard for most people.

~~~
wes-exp
The ill-conceived notion that parents giving children procedural instructions
is somehow like programming brings me to a question for you as a teacher.

I've noticed that the industry really prides itself on algorithms and this is
commonly reflected in interviews.

However, it seems to me that merely discussing algorithms, however clever they
might be, is actually an intuitive human activity not unlike the example of
the parent verbalizing procedural instructions to their child. Therefore, I
would argue that algorithm design, though clearly an intellectual challenge in
its own right, does not target the essential part that makes programming hard
and inaccessible to so many people. (Disclaimer: a high-level algorithm
discussion is usually followed by whiteboard coding, which I'm ignoring in
this critique as a separate kind of activity).

Do you agree with this claim that algorithm design is not actually the thing
that makes programming so difficult for laypeople? Can you give your take on
what _does_ make programming hard or what students struggle with the most?

~~~
teach
I think algorithm design _is_ hard. Most students/people can't break down a
problem into small enough steps for the computer to do them.

Are you familiar with the concept of "chunking" in memory research? Well,
computers don't chunk but humans do. Humans tend to think about their
algorithms in terms of the chunks they already know, but for computers
sometimes each chunk has to be broken down into much smaller sub-steps.

And that's non-intuitive and hard. When explaining stuff to a human you get
immediate non-verbal or sometimes verbal feedback if they don't understand the
chunks, but computers just give a syntax error.

SECONDLY. Students have trouble making an accurate mental model of what the
computer is doing at each step, so they can't trace through the code, much
less create new code.

Those are the two biggies, in my experience.

~~~
wes-exp
It sounds like what you're describing is not figuring out at a high level what
to do, but formalizing that into low-level instructions for a computer. This
goes exactly to my point. What I meant by "algorithm design" is strategy
selection, which I want to be careful to separate from strategy _formalization
for a computer_. It is the latter that I think laypeople struggle with the
most, however, the fascination with algorithms often drives attention to the
former. For example, it's easy to be impressed by the cleverness of binary
search, but it's actually relatively straightforward to understand as a high-
level concept. The harder thing for a layperson is to formalize binary search
into a working set of computer steps. I think there is a certain cognitive
bias at play, where the formality of fine detail seems lowly and menial, so we
want to skip over it, in spite of the fact that it's actually the biggest
hurdle for most people to overcome.

------
Kaotique
Many politicians and policy makers think that anyone can become an engineer of
any kind with just a course of a couple months. Good example is the
politicians who argue that a high influx of Syrian refugees can solve the lack
of available IT and mechanical engineers in the Netherlands. It doesn't matter
that they don't speak the language, it doesn't matter that they have no
engineering education, it doesn't matter that they don't have any experience.
Anyone can do it right?

Being an electrical engineer is just connecting 2 wires, right? Being a
programmer is just booting up your text editor, right?

Becoming a good programmer doesn't require a degree but it helps to set a good
base for your knowledge. On top of that you need thousands of hours of self
teaching.

------
fsniper
In this matter, I'm not with the "everybody should know to code" camp. I
believe people, ordinary do not need to do any task with computers or even if
they do, they need not to teach it to the computers.

This movement will create a few good coders from children, but also make more
haters against the profession.

------
Paul_S
Driving is hard. Or not. Driving an F1 car is hard. Driving an 18 wheeler is
hard. Driving a Fiat is not. You can probably learn to "move" an 18 wheeler or
an F1 car but bets are off whether or not you're going to go on to win any
races. Have I run this analogy into the ground yet?

------
robotnoises
For the most part I agree. However, part of the reason why other professions
like "doctor" or "architect" don't permit crash course bootcamp-style training
for its entrants is because, for the most part, the stakes are much higher.
Sure, there are lots of high-stakes programming jobs, but for the most part,
being a bad programmer won't kill anyone.

------
mattbgates
I developed a website for anyone to practice their HTML, CSS, Javascript
coding skills. It is a quick, user-friendly single webpage creation platform
without having to deal with hosting or registration. Feel free to practice or
make permanent pages. Feedback welcome! [http://mypost.io/](http://mypost.io/)

------
chad_strategic
TLDR:

I'm a self taught coder, due in part to the recession of 08. I would encourage
anybody that has a desire an passion to learn, don't let anybody discourage
you as there are a lot of "negative nellies" floating around out there.

If your long term career goal is to be CTO at a big company, then you should
probably go school. Other wise there is plenty of room in the market for all
types of developers/codes.

[http://www.businessinsider.com/jack-dorsey-on-
programmers-20...](http://www.businessinsider.com/jack-dorsey-on-
programmers-2013-3)

------
mixturez
I hate the hype about coding. It's not for everybody. I only code when i need
to solve complex problems or design a product for money or my use.

------
dandare
I am really entertained by the note that there are high barriers to entry to
learning to code. Almost all coders I know are self thought or chose a school
as an afterthought because they were experimenting with coding from early age.

------
dandare
So large percentage of programmes are self thought (including me) yet I had to
lie on my applications to companies that unanimously asked for a CS degree.

------
asQuirreL
A lot of the observations in this article are very interesting, but
personally, I drew different conclusions.

The first one is the main thesis of the post which is that some people have an
innate ability to program that others do not possess, and that this is a thing
that cannot be learnt. As a result, telling people that it is "easy to code"
is a lie.

Firstly, it is actually not clear to me that this ability to pick up
programming principles cannot be taught. All we know is that our _current
methods_ of teaching yield a double hump distribution for programming ability.

Secondly, if people were actually saying "you will find coding easy" to anyone
and everyone then I agree that they are probably concealing the truth. But
actually, if you read the tagline on the example given (The Year of Code
initiative) it says:

> Start coding this year, it's easier than you think.

"It's easier _than you think_ " (emphasis mine). This is quite a different
statement to a flat out "it's easy", and it's one I agree with. To most
people, coding appears difficult because they simply don't know the answers to
a few key questions (E.g. Where do I write the code? What do I do to run my
code? How does the computer understand what I've written?). The (basic)
answers to these questions are comprehensible to most people, and furnish them
with the ability to write code (maybe not well, but that's a whole other
story).

Next observation:

> Folks, which industries/professions give up their own free time to provide
> free/open training to people wishing to enter the sector? Curious

The fact that only the software development industry seems to do this is
painted as a negative thing in the article. Why is that? I ask because this is
a fact I think we should be proud of. I personally enjoy what I do so much,
that I happily spend time out of my week, teaching it to others for free. I
don't do this because I think all the people I teach will go on to become
successful software engineers, but rather because I want to widen the net, and
expose more people to what we do, because for some of them (maybe even just
one of them) this might be their "true calling".

I got into programming originally from watching a cousin of mine editing the
themes of his Wordpress blog. He went on to study English Literature and
Psychology; To him, coding was just this tool that allowed him to publish his
views, but to my 9 year old self, watching him, it really struck a chord and I
was hooked. Now, there is not a thing in the world I could imagine myself
doing rather than writing code and loving every minute of it (And no amount of
"social status" is going to turn me to a life of law, medicine or
architecture). What an opportunity I would have lost if I had not seen my
cousin working on his blog... Every week-long learn to code course, and every
"hour of code" initiative works towards bringing such opportunities to the
wider public.

Finally, on the role of Computer Science degrees: I am currently in my final
year of a Masters in CS, which I have also enjoyed studying immensely. I would
not say that it has contributed directly to my skills as a software engineer,
but the things I have learnt have changed the ways in which I approach
problems. Very few people write structural induction proofs, loop invariants
or abstract specifications to prove the correctness of their programs, but I
have found them to be great ways to think about how to write better code.
These skills, however, are complementary to those that make a good software
engineer, not a substitute. There's no way to prove yourself out of a rat's
nest of class hierarchies and control structures.

