
Stop saying learning to code is easy - david90
http://www.hanselman.com/blog/StopSayingLearningToCodeIsEasy.aspx
======
VeejayRampay
I really feel like current salaries are too much to bear for honchos of the
industry and that there's been a recent push to make it seem like "programming
is easy" and "everybody can take up code". I agree that the learning process
has been made much easier than it ever was before (MOOC, screencasts,
collaborative learning, cornucopia of open source code available everywhere),
but that's only the first step in the learning process.

That part (the one that leads to being able to produce code) has actually
always been rather "easy". It's the next steps that are usually hard. Learning
data structures, design, architecture, how to collaborate with coworkers, how
to fix, debug and review code, mastering the associated tools (shell, git,
regex, making a given editor your home and harnessing its power, etc).

From what I've observed with more junior developers that are usually coming
through self-learning or accelerated programs, it's not the "code" that is
hard, it's those following phases because in the end, they're what really
matters.

Though, don't get me wrong, it's absolutely nice that we're pushing
programming literacy and making it more accessible for everyone, I just feel
like we should not be selling false hope.

~~~
Joeri
> I really feel like current salaries are too much to bear for honchos of the
> industry and that there's been a recent push to make it seem like
> "programming is easy" and "everybody can take up code".

Salaries are too high from the perspective of many executives because they
have the programmers doing low-value work. Instead of carefully considering
what merits building they just have them build everything and then see what
sticks and what doesn't.

If programmers were paid like executives, they would only be asked to write
code that made a clear difference towards a company's bottom line. Much
thought would go into the decision-making and preparation process before code
was written to make sure that both problem and solution were appropriate and
well understood. You would have whole fields of lower-wage analysts whose job
it was to prepare the work of the programmer. There would be much less code
written, but the code that was written would be much more valuable.

~~~
jakobegger
If you want to be paid like an executive, you need to behave like an
executive. Programmers that just do what they are told will never be treated
like an executive. Instead of doing duplicate pointless work, tell your
superiors what they really want and do that. If you just implement whatever
someone else tells you to do, you are a coding monkey, not a programmer. Stop
dreaming of 'low wage analysts' that do the dirty work for you, and just do
it. Programmers need to take more responsibilities rather than less; after
all, who can understand the project better than the programmer who creates it?

------
jaggederest
The problem that I see is the imprecision of english when it comes to the word
"hard".

There are many different kinds of hard. There's hard like "I have to put
effort into it", there's hard like "if you were not born being able to do it,
you can't do it", and there's hard like "even people who can do it are only
capable at their absolute best moments".

So the issue is not "Is programming difficult?" \- clearly any learned skill
is difficult to bring to an expert level.

The question I see people asking is, "Can the average person with diligence
and application _ever_ learn to program well?", and the answer is obviously
yes, they can. It's not "hard" like running a <3:50 mile is "hard".

It's also not hard like "Can you taste PTC or distinguish red and green", in
that you either "are born with it" or aren't, and find it effortless if you
are capable.

So many people that I've met assume that they're fundamentally incapable of
understanding algorithmic thought, and that's very sad. They don't need to be
Kernighan or Torvalds in order to gain value from learning some programming
skills.

~~~
rubber_duck
I think "learning to code" is more ambiguous. I have a designer friend getting
in to web design - I've helped him out pick up some jQuery - he learned the
stuff that was useful to him pretty fast. Is he a programmer ? No. Can he
write code ? Yes.

So yea writing code is easy, copy-paste and replace the stuff that seems
relevant to you, especially when you have a quick iteration method like a
REPL.

Control flow might take a while to fully grasp but still it's not hard to
understand, but takes practice to get comfortable with.

~~~
kamaal
Humans generally have a way to look for patterns of repeated effort that could
be automated, and then proceed to automate them one way or the other.

It has nothing to with programming. We are trained through evolution to
conserve resources as much as we possibly can.

The guy who invented the wheel was the first programmer.

------
danbruc
Learning to write code is not too hard, maybe not the easiest thing but really
not too hard. Writing good code - readable, maintainable, secure code with few
bugs - on the other hand is really hard. The gap between a non-programmer and
a junior developer is way narrower than the gap between a junior developer and
a good senior developer.

And something that I am missing in most of those articles is that writing code
is actually the easy part of the job, the hard part is talking to the customer
and figuring out what they actually want you to do and then keep up with them
changing their mind every four weeks and still somehow manage to ship
something that roughly does what it currently is supposed to do.

~~~
x5n1
The hard part, as you describe it, is usually not the job of coders. It's the
job of project managers. In lesser organization the coders are doing work that
management is suppose to be doing, so they might be doing multiple roles which
makes their job much harder.

~~~
nilkn
I don't agree. This isn't to disparage the job of project managers, but I
think you're going too far in the opposite direction and disparaging the job
of developers too much here.

Quoting from the top-level comment:

> Writing good code - readable, maintainable, secure code with few bugs - on
> the other hand is really hard.

How is a project manager going to help with this? This is clearly the
responsibility of the programmer, not the PM.

> the hard part is talking to the customer and figuring out what they actually
> want you to do and then keep up with them changing their mind every four
> weeks and still somehow manage to ship something that roughly does what it
> currently is supposed to do.

I wonder if you interpreted this too literally. Sure, the act of talking to
the customer is itself a bit challenging in some cases, but I think the point
is that it's _especially_ challenging to engineer a system subject to changing
requirements because if you're not good and careful you could build yourself
into a corner.

A good PM can help a ton here by figuring out how to talk to the customer and
spending a lot of time doing so. But I don't think there's any reason to
believe that's actually harder than building the requested system, and if any
requirement does change, it's not going to affect the PM directly at all -- it
will be an order of magnitude harder for the developers to deal with that than
the PM.

Finally, I think developers taking on management roles is exactly what's
needed, and it's exactly what happens in most top tech companies. Sure, if you
look at extremely high ranking VPs at a place like Google, you'll find many
ex-McKinsey Harvard MBAs (alongside engineers as well), but in general the
middle management at these places is composed of programmers to a very
significant extent.

------
franciscop
Totally agree. I have taught to some friends and my gf (pointing that it's
people that I care about). What I tell them is that there's easy parts and
difficult parts, and that things like SUM() in excel _is_ a basic way of
programming.

Then I teach them about html+css but starting only on the "easy-ish" part. So
using my own library [1] for things like ".row" where you'd need either
floats+negative margins or flexbox. Teaching them about images, images sizes
(should be set at 100% in many situations), colors, backgrounds, paragraphs
and links. That really motivates them.

Then some day they will need more advanced things, but if they can make a
layout with the content then they become really motivated since they can see
their programming real time.

I have to do this mainly because some people hate "irrationally" maths, so if
I taught the same way I started learning --calculating primes-- then they'd be
bored to death. Instead I like choosing something they are personally
connected: what website do you like? Okay, let's do something similar...

I've even tried doing a small course for free [2], but so far it's not been
really effective with those people I'm teaching, but some other friends asked
me things about it :)

[1] [http://picnicss.com/](http://picnicss.com/) [2]
[https://en.libre.university/subject/4kitSFzUe](https://en.libre.university/subject/4kitSFzUe)

~~~
garrettgrimsley
You aren't teaching programming, you're teaching web design. Programming
doesn't have to start with calculating primes, but it does have to be actual
programming. Maybe try introducing the to something like Scratch or Logo.

~~~
lazerwalker
Serious question: how do you define "actual programming"?

CSS is a markup language, sure (although technically Turing-Complete,
depending on the spec), but it's still conceptually telling a computer what
you would like to happen. It's more declarative than imperative, but given the
wide number of different programming paradigms, I don't think that's a
problem.

~~~
rootlocus

      > Serious question: how do you define "actual programming"?
    

Solving problems by expressing algorithms in a language a computer can
interpret. CSS / HTML are not used for expressing algorithms or computations.
They're used for describing visual representations. They're an output format.

CSS has a spec in which it's Turing-Complete? Even if it's true, nobody uses
CSS like a Turing-Complete language. It's like saying JSON is Turing-Complete
because it's JavaScript.

~~~
erikpukinskis
Would you say Prolog is an output format too? It kind of is! My guess is you
just don't consider declarative languages "real programming".

What about running "rails new blog"? Is that programming?

What if you add "-d mysql"? Does that count?

What about changing a YAML config file? Not programming? Does it become
programming if the config file is written in Python?

What if it has a loop? Or what if you know that a certain key in the config
file will trigger a loop?

I don't think there is any firm line between computer use and computer
programming. I think there is only a spectrum between specialized and generic
computational primitives. HTML and CSS are somewhere in the middle of the
spectrum, between tapping a button and applying voltage to circuits.

~~~
rootlocus

      > My guess is you just don't consider declarative languages "real programming".
    

That's ridiculous. There's no "real" programming, and of course declarative
programming is.. programming. However, with declarative programming you're
still writing algorithms and doing computation (composing functions / querying
predicates).

    
    
      > Does it become programming if the config file is written in Python?
    

Is it an algorithm? No. It's just like JSON is for JavaScript.

    
    
      > I don't think there is any firm line between computer use and computer programming. 
    

Solving problems with algorithms is programming and while there is indeed a
fuzzy line there, I still find it far-fetched to consider writing
configuration files (which are static inputs without logic) or declaring html
structure / css styles (which again, lack any logic) programming.

~~~
erikpukinskis
CSS does have logic:

    
    
        div { color: red }
        .foo { color: blue }
    

is equivalent to:

    
    
        if classes.contain("foo")
          color = "blue"
        else
          color = "red"
    

How do you define algorithm in a way that excludes CSS?

------
vinceguidry
The main thing that makes learning how to code difficult is the sheer amount
of technologies you need to learn before you feel like you can make real
progress. Each individual technology isn't by itself particularly difficult,
with a few exceptions; (looking at you git) but also aren't particularly
useful by themselves.

You either have to be willing to learn a simpler stack and pick up skills
gradually, or deal with the intense frustration of drinking from the firehose
right out the gate.

When I was in high school, I went from doing BASIC to elementary web stuff to
trying to learn C++. (I didn't have practically anybody who knew how to code
to guide me) I gave up and didn't go back to coding for some ten years,
sticking to just being a power user.

If I were trying to teach someone to code nowadays, I wouldn't really know
where to begin. People want instant gratification without the frustration. You
can't have both. I've had limited success, but only after finally convincing
them that they have to be patient.

~~~
owenwil
I absolutely concurr. The hardest thing for me has simply been connecting the
dots. Suddenly needing to understand Git, or how to configure Apache, just to
learn PHP. THere are so many bits that aren't explained to you, all the while
you're jumping into the deep end with a language. It's hard to hang in there,
but it's worth it – however many don't.

~~~
vinceguidry
What we really need is sandbox dev environments. A one-click installer that
does everything you need to get a stack up and running and ready for code. But
it's way way way too complicated. Something like that wants to be a standard,
but won't be robust enough to actually solve the problems a standard solves.

I'm excited for functional package managers for this reason. It will give us a
framework for describing machine state that's actually useful enough to give
us real-world one-click install.

~~~
duncanawoods
A one-click installer sounds great but creating it is not the hard bit, its
choosing what goes into it. Its not just the Cambrian explosion of JS
frameworks and plugins but the whole stack of external dependencies from
databases, monitoring, build, testing and deploy.

There have been lots of attempts that pick a stack e.g. Angular-seed for the
MEAN stack but they make so many questionable choices that they don't have any
longevity. At one point it might have looked sensible but now Mongo is out of
favour and React has the ascendancy.

Maybe it needs an organisation like a Linux distribution, e.g. Ubuntu For Web,
that chooses a complete end to end stack, develops missing glue, maintains
forks when necessary and gives some sort of maintenance guarantee for LTS
releases and supports upgrade paths.

~~~
rorykoehler
JS is a mess. Even though there are standards they are implemented in such a
way that it is virtually impossible to keep up with for a non-seasoned dev.
The tools we use change quicker than ever, major changes all the time breaking
everything that came before, tutorials out of date the week after they are
written, new syntax that is widely used but not official meaning we have to
transpile everything. Everything mentioned is just another obstacle in the way
for a new dev to get started coding. By the time they've setup their dev
environment most will have lost all their enthusiasm.

------
tikhonj
It feels like you could write a perfectly symmetrical article—just as
convincing—in the opposite direction. We've been telling people "math is hard"
for years and look where that's gotten us. People seem do a better job of
learning abstract algebra if you trick them into _not_ thinking it's difficult
and arcane.

I'm not saying that one view or the other is right. Rather, I'm just saying
that _it 's not obvious_ which is better or even how much it matters. Posts
like this—which basically do say "it's obvious that..." and little more—aren't
contributing anything substantial.

------
sgeisenh
I'm not sure I agree. The title doesn't match the content. The title contends
that learning to code is hard, and I've never heard anybody disagree, learning
to code is difficult. But then the content of the post contends that coding
itself is hard. And I disagree. Programming difficulty is a function of a huge
number of factors. Among which familiarity and experience are paramount. If
you're writing a program that's familiar to one you've written before,
programming is easy. If you're writing a complex new system with little to no
precedent, programming is hard. There isn't a blanket statement that can be
made about the difficulty of programming, it is all contextual.

------
caffed
I am going to support Cory Koski's comment on your post:

I don't know what your intentions are, but you have a post titled "Stop saying
learning to code is easy" and a photo of three women with laptops. Are you
trying to make a correlation of women being glib about the difficulty of
software development/programming?

~~~
yborg
I don't know why the parent post is even trending on HN, it's content-less
trivial fluff, but I also facepalmed at the inclusion of the picture. I'm not
a supporter of the idea of the "patriarchy" meme, but putting this picture on
a post like that certainly implies at least an unconscious association in this
guy's mind. Good thing he's a "former professor".

~~~
rimantas
It says nothing about the author's mind, but your comment and the one above
says a lot about their authors. It's you making the asumptions.

------
codingdave
I work mostly with people teaching kids to code, and for our goals, it is
easy. We aren't trying to teach them how to write the most elegant and
efficient code... we are trying to get them to understand basic logic and
building blocks. We are teaching them how to solve problems, and debug their
work. And we are teaching them basic computer literacy.

If they are good at it and go deeper into software development or computer
science, then it may get hard. But it is a pessimistic view to look for
reasons why something will be hard, and pontificate on those problems. Why not
just help people take some simple steps, get a few successes under their
belts, and decide for themselves if they want to go into deeper more difficult
waters.

------
Waterluvian
Coding is like driving. Even someone from a developing nation who has never
seen it before can learn it. But we aren't all professional race car drivers.

It is easy. And it is very very hard.

~~~
draugadrotten
Coding is like singing. Even someone from a developing nation who has never
heard it before can learn it. But we aren't all professional opera singers. It
is easy. And it is very very hard.

~~~
Waterluvian
I like yours better.

------
prodigal_erik
I'm in favor of self-exclusion. Anyone who holds interviews should be aware
that there are way too many duds in the industry for no good reason. I want to
work with the obsessives who tell themselves "no, there must be some right way
to do this" rather than relying on some strange kind of cheerleading that
didn't exist when I started.

------
Philipp__
Sincerely I think it would be the best to meet somewhere in the middle,
between Scott's and symmetrical but opposite opinion on this matter.

I am student, and freelance developer. And I ask myself a lot of times, what
is the code that we write? Lines aren't clear like in electronics (I studied
EE for 2 years, after which I pivoted to CS), where you got rules, theorems,
which you use to analyze and build things. Code is a live thing. It grows, it
changes, it lives and it dies. And the most paradoxical thing of all is that
computers are pretty "dead" and dumb things, bunch of registers, ICs and
transistors. (I am oversimplifying things here to prove my point better).

The way we approach writing code always changes, code can be pretty personal
thing, you can have your own style (like handwriting). And possibilities are
almost endless now!

So I think people in general should stop treating things with black or white
principle. I feel that is very immature. Especially not coding.

Software development is single most weirdest and interesting things that
happened to me. It makes me scary and enthusiastic at the same time. It is
easy and hard at the same time. And I think it is really stupid to try to
ascribe any of those exclusive attributes. But everyone has it's own opinion.
And that is what makes dev culture and community so interesting in the end.

------
jokoon
I learned C/C++ by myself with "C++ for dummies". I was already taught
assembly at school at a very short class. I learned more from linux and C
through a linux fanboy, and I seriously learned industrial C++ at school, but
I already knew most of the basics.

I was obsessed about learning how to code because I always played a lot of
video games and loved electronics.

I don't have a degree, am chronically unemployed. I admit that learning code
is really about understanding the details. Having a taste for computers and
math is a huge advantage. If you don't, you will quickly hate it and only
learn it for a job, but not for passion.

I agree that code looks lame and is really not accessible, while most people
who need it, can't always afford to work with a programmer. There needs to be
solutions like MIT's scratch or anything that is more intuitive than textual
syntax. It's amazing what some people can manage to do with excel.

------
shafaq
Why everyone is being pushed to learn to code in the first place? The reason
behind 'coding is easy' is that industry needs lots of programmers? Really?

~~~
krapp
I think in part to flood the market with low quality applicants, and drive
salaries down.

~~~
imtringued
That will only increase hiring costs and increase the risk to get a lemon as
an employee.

------
prodmerc
Learning to fix electronics is easy. Learning to fix your car is easy. Just
open up the enclosure/hood and... do stuff :D

------
matchagaucho
Playing piano is hard, but teachers that keep the learning experience fun see
much lower drop-out rates.

Teaching, mentoring, and onboarding students to _enjoy_ coding is the real
hard work.

------
gingerrr
My personal variant has always been "learning to code is easy, you just have
to be okay with feeling completely stupid for a while until it clicks."

It's a way to encourage while being up front with the amount of time and
mental toil learning new ways of thinking and expressing your ideas takes.

It also encourages self-selection, as the few people who took it to heart are
some of the best devs I know now, they saw the challenge and remained
undaunted.

------
projektir
Interesting. I tend to learn better when I don't perceive something as "hard",
as that creates a mental block of sorts for me. Acquiring proficiency requires
significant amounts of time investment + effort, but it would seem "hard"
should denote something above that.

I tend to prefer terms like "tractable", where it's less about whether the
given problem is "easy" or "hard", and more about whether I can find a
productive way to reason about the problem. An easy subject can be made
intractable by the wrong kind of presentation. Most subjects that are very
/new/ to a given person may be intractable on the onset. Some subjects, ones
that I would call truly "hard", do not become tractable for a very long time.

So I don't know if I'd call software development hard, but it's still a new
and unfamiliar thing to a lot of people, and it can be quite intractable at
various times, which is basically what "bad documentation" means.

------
Mandatum
I think learning to code _is_ easy.

I've recently pointed a friend towards FreeCodeCamp, he's never tried
development but was asking about it (previous non-tech related jobs) so I
pointed him to the website.

Yesterday he must have spent 8 hours doing tutorials, occasionally asking
questions and has started building his first website. He's beginning to pick
up the basic building blocks of programming, not for loops and if blocks, but
data structures, debugging (Chrome is amazing), etc.

I think the hardest part of learning to code is choosing a language and
deciding what to build. The rest is Stack Overflow and online tutorials. Oh,
and a whole lot of time.

Sure to become an "Expert" you'll need to learn about a vast range of things
that are not code, but affect code - like security, best practices,
readability and maintainability, different stacks, etc. But getting your foot
in the door with the basics is pretty easy.

~~~
brianwawok
So this applies to anything.

I helped my friend learn to paint. Bought him a canvas and 4 brushes and some
paint. He watched YouTube all day yesterday . I think he painted this circle
thing that looked like a sun. Painting isn't hard.

------
ranci
Also, stop acting like people are idiots if they don't know how to do
something that you know how to do.

~~~
collyw
People often are idiots.

The other day, one of our non-technical members of staff said "I think people
are just to stupid to use our system". Glad she said it and not me.

------
Olscore
Sorry. I understand the sentiment behind this but disagree with advisory or
demands to speak a certain way. It's blatant political correctness and nobody
has an obligation to set another person's expectation regarding coding. In
common vernacular we say something is easy as an attempt to encourage a person
to continue. This would just be changing words in order to achieve the same
goal. What difference does it make if some say it's easy and others say it's
hard? Let the dynamic range of opinions be. Is it necessary to squash one
opinion over the other in an attempt to soothe the struggling of a few
newbies?

~~~
mden
I find meta-arguments like this really silly. You are simultaneously telling
him that people are entitled to their own opinions while at the same time
saying his opinion is invalid.

As to it being political correctness, I would argue that has little to do with
it. It's really marketing - an attempt to change the perception of something
to achieve some goal. No one's feelings are hurt when you say something is
challenging (I guess unless you explicitly say challenging compared to what).

------
danielmeneses
Yeap.. people usually forget how hard it was. Programming is not a natural
thinking so when learning, first forget what makes sense in "real world" and
embrace a new way of seeing thinks. I understand why some say that it's easy,
they're trying to bring more people to tech side, but my truth is: i do
programming because i really like and all the hard times to get there are
battles won, but don't try to win battles from something that don't stand out
for you, remember, you really need to like what you're doing. Peace.

------
stevetrewick
Think of it like sport. Anyone can have a go and have fun, jumpers for
goalposts and all that but the vast majority aren't going to end up as your
Ronaldos or Andy Murrays. And that's OK.

~~~
projektir
I don't think that's a very useful analogy since the standard for professional
athletes is an inflated moving target. Athletes are evaluated strictly in
comparison to other athletes and only the best athletes at a given time are
chosen for a very small set of positions. Whereas in software development,
there are lots of positions for the same specialization and plenty of average
people can make a comfortable living.

------
brandonmenc
Learning to code is easy (everyone who wrote a BASIC program as a child, raise
your hand.)

Learning to code well is difficult and requires years of experience,
obsession, and a titanic amount of patience.

~~~
mto
True, especially as a child it's not unnatural at all. I discovered qbasic by
accident and just played around until I could write small games. It never felt
hard, frustrating or exhausting. All fun and play.

That is the big difference to actually work in the field and have to do the
boring stuff too :)

------
digi_owl
For me at least learning to code have two different requirements.

The first is shared across languages, getting to grips with ifs and cases and
all that. That is relatively easy.

The second is pr language, and it involves learning what is available in the
libs and similar. And how to use those to do things like read and write files,
connect over networks, or draw a UI on screen. And those are bloody hard.

------
erlend_sh
For an alternative take on the exact same subject matter, see Quincy Larson's
"One does not simply learn to code"

[https://medium.freecodecamp.com/one-does-not-simply-learn-
to...](https://medium.freecodecamp.com/one-does-not-simply-learn-to-
code-f25bacdc5b62)

------
ranci
"Programming is easy" \-- person that has spent a significant percentage of
their life programming

------
kraftman
So we shouldn't tell people learning to code is easy, we should tell them it's
hard, complicated, exhausting, and exasperating, but it'll be worth it in the
end?

Why not just give them some easy code, help them through it, and let them see
if they enjoy it?

~~~
hartator
No one tells people being an architect or a writter is easy. Why lying?

~~~
Retra
Are you sure about that? Lots of hard-to-do things are said to be easy by
those who know how to do it. You might not think being an architect or writer
is easy, but someone who _is_ an architect or writer has a clear picture of
how to do it, and they might say it's easy.

~~~
mto
I have yet to meet a medical doctor saying "medicine is easy" \- because it
would diminish their status, salary and they love to brag how it is the
hardest thing to study.

~~~
Retra
Have you met a medical doctor who was trying to teach you his/her trade as a
medical student?

------
alien3d
Easy and costly also.Each time new framework and language, most of us will
endure dejavu to create same thing.We sometimes not up to all and do please
job hunter,interviewer.We arent scientis to know all weird formula phisyic ,
math and other

------
mrcabada
I disagree with this, maybe not because coding is easy, and I can't really
measure that because I've been coding since I'm 10 years old (I'm 26 now) so
it's been "normal" for me. But what I can tell is that learning to code is
like learning to do something else that requieres skills and time. It is as
easy as learning something else completely unrelated with computers, it
depends on you and how dedicated you are.

------
wcummings
Yeah, seriously, and stop teaching people how to code. You people are
seriously letting the cat out of the bag.

------
pier25
Anyone (probably) with a few tools and some wood can build a dog house.

But you need real pros to build a skyscraper.

------
Avshalom
If you run around telling people how hard programming is they'll never even
get to the point that it does become difficult. That's why we tell people it's
easy.

~~~
sotojuan
Surely there's a middle ground right? Being a surgeon is hard, being an
astronaut is hard... there's a lot of jobs popular culture says are hard but
it doesn't stop people from trying.

The thing with programming is that it's turned into one of those things people
say "you are born for". So when newbies have trouble with it, they give up and
say their minds don't "work that way". I think it's good to tell people that
anyone can learn the basics of programming and get started. No need to be a
genius for that. I don't know why but people seem to think programmers are
"different" than the general populace (even from those with other hard jobs).

But it's not easy. We've all dealt with hard problems in our jobs, classes, or
personal projects, right? If you tell people programming is easy they'll hit
that first roadblock like the article says and quit. Seen it happen many
times.

------
zfnsgmdydmy
Except it is easy. In fact, it was _designed to be easy_ by the language
architect. Unlike engineering where you're dealing with unchangeable laws of
physics, computer languages are designed to be written by people.

~~~
Retra
Programmers are still dealing with the laws of physics. This is why you get
10,000 asynchronous communication platforms all generally failing to result in
massive improvements in usability and parallelization. Most programming
problems are communication problems, and most communication problems are a
result of physical limitations.

~~~
zfnsgmdydmy
While, yes, you can't run CERN on a raspberry pi, the performance limitations
of the underlying CPU are a fundamentally separate problem (unless you're
developing for a microcontroller). Going out and writing code (any code!) is a
purely mental exercise that's unaffected by the outside world. Don't like the
syntax? Use another language! Want a feature that's not currently there?
Import a library! The point is that code was meant to be written, whether it
relies on a physical processor or not. You have lots of different options that
each try to make it easier for the programmer.

~~~
Retra
That's not entirely true either. Computer programming is largely performed
using text in a 2d grid, and there are a good deal of problems not suitable to
being represented that way. Language designers have to deal with this when
deciding what syntax to support, and how that maps to the desired semantics.
This is one of the reasons for the proliferation of so many different
languages in the first place.

------
tommynicholas
Learning to code is easy

------
shkkmo
Learning to code is easy, learning to use that ability to solve interesting
problems is hard.

------
spb
To be honest, I'm not surprised to hear a statement like this from Scott
Hanselman. Learning to code _is_ hard... when you have to do it inside
Microsoft's byzantine, arbitrary .NET ecosystem, with its mandatory thousand-
button GUI toolchains and fifty-file project baselines.

In environments with less absurd barriers to entry, like JavaScript, learning
to code _is_ easy (especially in light of the things Scott mentions in that
post, such as the vast swaths of community support available when running into
problems).

