
Coding is not the new literacy - wglass
http://www.chris-granger.com/2015/01/26/coding-is-not-the-new-literacy/
======
desdiv
Previous discussion from a month ago:
[https://news.ycombinator.com/item?id=8947603](https://news.ycombinator.com/item?id=8947603)

------
tyrfing
I think it's something a bit more basic - logic. Learning programming teaches
logic, because the computer will find every logical shortcoming in what you
tried to express.

Natural language is the bread and butter of our every day existence, and it is
a veritable swiss cheese of logic. Most people won't hear your argument and
notice the unfounded assumption that destroys the whole thing, but a compiler
will. Most people won't notice if you leave some of what you say implicit, but
your compiler will.

Something I've noticed over the years is that people, in general, are just not
good at logic. Very few things teach it, the few that explicitly cover it like
symbolic and formal logic classes are arcane, scary corners of the educational
system. Logic doesn't win arguments, it doesn't get you laid, it generally
doesn't help you interact with other people. It does teach you to think, but
like deodorant, nobody knows they need it until they already have it.

So, start small. Teach logic, teach people to think, teach them the very
fundamental underpinnings of programming. Programming is then just another way
for people to express what they already know, like learning a foreign language
rather than learning language in the first place.

I think most people saying "teach them to program!", at least the ones I've
seen calling out the "it teaches you a new way to think" part, actually mean
logic in general.

~~~
virmundi
Why teach these things with programming? Historically we, the west, have
taught these things with philosophy. That's how we went from tribalism to
democracy. Why not teach with philosophy?

I know that we live in a technical world, but no matter what, we live in a
philosophical world. Everyone deals with philosophy (either reflective or
forced upon them) daily. How we work with each other might be via a keyboard
and mouse, by why we work with each other is philosophical. It would be better
to teach various systems of thought, allow a dialectic to occur, and get a
better, more informed citizen.

~~~
TeMPOraL
Because philosophy is too imprecise. When you dig down to the most fundamental
concepts of CS you end up in what is usually considered the territory of
philosophers, only with a better mental toolkit to explore it.

There is an interesting paper by Scott Aaronson about the intersection of
those two disciplines and how the more CS-y approach can help solve
philosophical problems:

[http://www.scottaaronson.com/papers/philos.pdf](http://www.scottaaronson.com/papers/philos.pdf).

~~~
rpcope1
I guess there are a lot of STEM people that have never taken a course in
first/second order predicate calculus, which is usually lumped in under
philosophy. The field of computer science builds on and is rather indebted to
philosophers such as Wittgenstein and Godel; their finds provide the
theoretical background for all modern theoretical CS.

While what they teach at the university today for a philosophy degree may let
you focus on things that look imprecise, I find your statement is rather
ironic. The difference between someone, especially coming out of school, who
is well versed as a logician (hint they may have a math degree, but it's still
philosophy) versus some one who has been exposed only to computer science,
often parallels what I have seen interviewing people with a physics background
versus an engineering background: almost all of the time the engineer might be
able to give you enough to solve many of the problems, and have a little
background, but the physicist will typically have a far stronger "toolkit" to
analyze the problem, especially when the problem is novel. So goes it with a
CS grad versus a math grad, typically around here, though YMMV.

~~~
mr_luc
Is math classified as philosophy due to some historical accident? Is that
really relevant to the discussion at hand?

And wasn't Wittgenstein essentially out to destroy traditional philosophy?

~~~
TuringTest
Not an accident. Maths is philosophy in the same sense that physics is
philosophy (in fact it was called "natural philosophy"): both are subsets of
the general thing.

Philosophy is the "science of everything", and as such, all fields of
(western, academic) knowledge are considered parts of it. Math in particular
is formally equivalent to logic, which is the universal language on which
philosophy is written.

------
noelwelsh
The piece argues that "[c]oding, like writing, is a mechanical act". It's
certainly not the intent of the learn to code movement to teach typing skills!
This statement seems to grossly misrepresent what people mean when they say
"learn to code".

To learn to code _is_ to learn to model systems. Programs are built from
components -- abstractions -- and good programmers know a wide variety of
abstractions and understand how to combine them to achieve the desired effect.
A good program is one that accurately models the phenomena of interest,
whether that phenomena is something as simple as "display the user's profile"
or a complex simulation like a game.

Now I would agree that many of the current curriculums are terrible, and teach
no great insight into modelling. But that is the fault of the curriculum
designers -- often people who have neither great experience in teaching or in
programming. That doesn't mean there isn't good work being done, such as the
Program by Design team
([http://www.programbydesign.org/](http://www.programbydesign.org/)).

In short, I think the blog post builds a straw man argument. I agree it
absolutely belts crap out of that straw man, but that is beside the point.

~~~
puranjay
English major here. I'm currently learning how to code as part of a bootcamp
called (surprise surprise) "Coding is the New Literacy".

One of the things this program hammers in early is fundamental programming
principles like OOP. A lot of MOOCs skirt around these topics, forcing you to
'build' non-functional apps first. I've taken those courses and learned
nothing of real value.

This program, where I've been forced to learn algorithms, OOP, etc. has been
of much higher value. It's been harder, but I feel like I'm actually learning
the fundamental principles of programming.

I'll echo your sentiments: to learn how to program _is_ to learn how to model
systems.

~~~
acron0
I am trying to read between the lines of your comment and I _think_ you get
this but I'm going to spell it out anyway:

"...fundamental programming principles like OOP."

The key word here is "like". OOP is actually falling out of favor as a
successful way to express models. Make sure you investigate alternatives to
OOP (functional, procedural etc). As a graduate of OOP myself, it's
interesting and exciting to approach different paradigms. Experience tells me
that the best practices obsess over what things "do" rather than what things
"are" (which is a fluffy concept at best).

Anyway, tit for tat, YMMV. Glad you're doing something though.

~~~
robotkilla
How do you figure OOP is falling out of favor? I've seen a few arguments on HN
(the old OOP vs FP discussion) but do you actually expect the trend to
continue to the point that no one really uses OOP anymore? Highly doubtful.
And which specific part of the industry is OOP slipping into obscurity?

~~~
marrs
It's not so much that OOP is falling out of favour, but that functional
programming in particular is being rediscovered, probably because we have to
multithread now, and if bugs are hard to keep out of single-threaded code,
they're nigh on impossible to keep out of multi-threaded code.

In fairness, a lot of us never truly embraced OOP anyway. I've always avoided
objects unless I'm managing state. Even in OOP languages, much of my code
essentially repurposes objects as modules for storing functions. The fact that
they are implemented as methods is incidental. This is not an uncommon
pattern.

~~~
robotkilla
I'm stronger with OOP than I am with functional programming because I've been
doing OOP for longer. I started out with procedural programming when I was a
kid (BASIC and QBASIC), and have since moved on to PHP, Javascript, Python and
a bunch of other stuff.

Almost everything I've worked on in the last 8 years has involved OOP in
either PHP, Python or Perl. Perhaps I stumbled into a niche and have yet to
find my way out, but OOP has been a common theme in my career.

~~~
marrs
No, you stumbled into the mainstream. The wholesale migration to OOP was
complete by the end of the 90s.

But you've probably been doing functional programming within OO languages and
not realising it. For example, most of the PHP standard lib is functional. In
fact, PHP is really a multi-paradigm language. Python is much closer to a pure
OO language.

~~~
robotkilla
No, I do realize that PHP in functional. I suppose I misstated my history a
bit - I went from procedural to scripting languages, to functional to mostly
OOP in languages that support both functional and OOP.

I would say that Python isn't closer to a pure OO language than PHP, rather it
allows for more pure OO than PHP. I only say this because you can go pure
functional in Python as well.

------
fizixer
\- Coding is not the new literacy.

\- Neither is modeling.

\- Neither is externalizing mental models or whatever.

It's not the human obligation to become more and more creative and
resourceful, when less creative activities become less and less valuable, and
fail to help earn a living.

The author of this article claims that people are missing the point. He's
right. But he's missing the point as well, or at least arriving at a very
wrong conclusion.

We're at a cusp of a very very strange era. This is the era where humans, and
the capacity of human intellect, is approaching obsolescence. And the solution
is not to train everyone to become like Einstein or, in this case, Knuth, or
Steele, or Torvalds, or whatever.

"There can only be so many people in the entertainment industry" as Aubrey de
Grey puts it.

Similarly, there can only be so many people in the "coding industry".

These people are missing a key property of coding: Coding eats itself! Or as
Andreessen puts it "Software is eating the world". Meaning, coding by virtue
of it happening, ends up automating aspects of itself, to the point where, a
small kernel of information processing is able to carry out vast amounts of
informational activity, as opposed to requiring a vast number of coders as
those not familiar with coding tend to believe.

And this trend of automation will keep on increasing, giving rise to more and
more serious technological unemployment, all the way to the logical conclusion
of technological singularity. The sooner the "people in charge" realize this
bitter truth, the better it would be for everyone.

~~~
ObviousScience
You admit that computer and software are eating the world, but come to the
conclusion that it's useless to teach people to speak to them at a basic
level.

I'm not sure I follow your argument.

We don't teach literacy because we expect people to be professional writers,
but rather, that because the written word is a basic means of communicating
with each other and the world around them -- we're having this very discussion
through the power of literacy, even.

In what way do you think people advocating teaching programming mean in any
other sense?

When I advocate teaching programming to people, I don't envision a world full
of software developers, I imagine a world full of slightly more informed
software users. People who can interact with the Googles of the world by
writing a sentence (or even a Boolean expression!) using correct logic or who
can write a small Javascript snippet to automate a simple task like
highlighting certain things on a webpage or who can write a simple Python
script to get a rough approximation about how some numbers work.

Further, having even a tiny basis in computers - like the level of mathematics
we teach in high school (on average) - gives me a basis as a professional to
explain how things like Facebook work in a way that I can't now. It's much in
a similar way to how once people know what a variable and a function is, I can
explain more advanced math concepts using those ideas -- in a way that I
couldn't if I had to start at the very beginning with "this is a number".

So again, I'm not sure I follow your argument: if software is eating the
world, why wouldn't we teach people to speak basic software in addition to
basic spoken language?

~~~
fizixer
You seem to be coming from the opposing view of that of the article, that
coding 'is' the new literacy. I was more challenging the article's claim that
modeling is the new literacy, which I think isn't.

As to whether coding is the new literacy or not, I'd say we really need to ask
what is the purpose of education. If the purpose of education is
enlightenment, then yes, a child should learn how to code, but also how to
paint, how to play a musical instrument, and so on and so forth. But then some
children have the aptitude for one thing, some for another thing.

But I think the purpose of education as a means of making the individual
economically viable is becoming more and more futile with increased
automation. (In this regard I strongly adhere to the views expressed in the
video 'Humans Need Not Apply' by CGPGrey[1], and TED talks by Jeremy
Howard[2], Erik Brynjolfsson[3], Andrew McAfee[4]).

As to the need for coding so that humans could interact with machines, I think
in the long run, this is also going to progress to the point where the machine
would be aware of the abilities of the human it's dealing with and make it
easy for the human to interact with itself. (EDIT 1: I should also add that
interacting with machines is already happening at a massive scale when
everyone has a smartphone in their back pocket. And yet when the software goes
wrong, the inability of an average user to fix it is not the result of that
user not being coding literate, but rather the insurmountable complexity of
the code behind the easy-to-use interface, even if we ignore the hidden nature
of proprietary codes).

[1]
[https://www.youtube.com/watch?v=7Pq-S557XQU](https://www.youtube.com/watch?v=7Pq-S557XQU)

[2]
[https://www.youtube.com/watch?v=t4kyRyKyOpo](https://www.youtube.com/watch?v=t4kyRyKyOpo)

[3] [https://www.youtube.com/watch?v=sod-
eJBf9Y0](https://www.youtube.com/watch?v=sod-eJBf9Y0)

[4]
[https://www.youtube.com/watch?v=cXQrbxD9_Ng](https://www.youtube.com/watch?v=cXQrbxD9_Ng)

~~~
efuquen
> As to the need for coding so that humans could interact with machines, I
> think in the long run, this is also going to progress to the point where the
> machine would be aware of the abilities of the human it's dealing with and
> make it easy for the human to interact with itself.

And when is that long run going to play out, in the next 50, 100, 500 years? A
lot of the learn to code movement is about economic empowerment, providing an
avenue for economic advancement for children and adults, _especially_ children
and adults that wouldn't have thought coding as a career was possible for them
or have had the access to resources to really pursue it.

Yes, automation is eliminating jobs, but still creating new and well paying
technical ones. Whether and when we'll reach some technological singularity is
all based on a lot of conjecture, and how that ultimately will pan out with
how we structure our economy is impossible to predict. In the mean time we
have the current reality, one that most likely will result in tech providing
plenty of well paying jobs for at least a few more generations. The idea of
coding as literacy, as has been stated before, isn't that everyone needs to
become a software engineer. It's that as a person coming from any background
you at least get the opportunity to see if it's a career you would want to
pursue, and if not at least give you more insight into how technology works
and make you a more well rounded citizen.

------
Animats
When you get to the end of the article, it turns out that they're building the
next generation of Visual Basic.

That's not a fundamentally bad idea. It's also interesting that they focus on
modeling and simulation. That's what Alan Kay thought personal computers were
going to be for. But all we got is the VisiCalc/Lotus/Excel world. That's
useful, but limited.

The problem with visual programming languages has usually been that they don't
scale. You end up with a huge collection of lines and boxes. (For a good
example, find a game implemented with Blender's game engine and open up the
wiring diagram.) They have a chance of solving that problem, because program
interconnection has made some progress since the days of Hypercard and UNIX
pipes.

There are a lot of line-and-box programming systems in domain-specific areas.
LabView, for industrial and research control systems, is one of the most
successful. But no one has yet solved the scaling problem. On larger problems,
things just get too tangled.

~~~
LoSboccacc
problem is, the hard part is not coding, the hard part is transforming
requirements and workflows into logical structure a computer can understand.

that's the bottleneck, whatever the language.

the new literacy would be not just to see a lego construction and understand
the pieces involved, but to see the final construction and to be able to
recover the build instructions by sheer mind gymnastic.

~~~
chii
> the hard part is transforming requirements and workflows into logical
> structure

that's like saying for painting a picture, the hard part is knowing where to
put the paint. The act of slashing paint on canvas itself is trivial.

I think the real problem is that there hasn't been any proper primitives
created - primitives that can be linked together to produce what looks like
another primitive. I guess the non-physicalness isn't helping, because lego
works really well as a building primitive.

~~~
pjc50
_primitives that can be linked together to produce what looks like another
primitive_

This was the design intent behind UNIX pipes; text processing through
composable programs.

I'd go in the other direction and say the problem is too many primitives; it's
easy to spend all your time just evaluating possible solution components.

------
dschiptsov
Oh, this thread again.)

There is almost no relation between knowing a language (vocabulary and
grammar) and the ability to write, say, 1984 or Zen and Art of Motorcycle
Maintenance. It requires a different set of skills (explained, btw, in the
Pirsig's book).

The "new literacy" is, basically, a "model extraction" \- ability to
understand the principles form the emerged phenomena on the go. It is about
learning new skills on the go - you need to perform some data analysis - well,
just pick up the required skills (it is not that hard, by the way).

Again, coding is not programming. These two are different skills. Programming
is an engineering discipline. Coding is a translation skill. To be a
translator one have to know the languages, but this is not nearly enough to be
a writer (an inventor). A typist, who is literate enough to be able to make a
carbon copy of someone's else fine poetry is usually incapable to write her
own (neither are the guys who study literature).

To put it another way - "to know C" is not enough to write nginx or redis. It
is not about languages (well, almost - a language that fits the task best is a
requirement), the way a "good idea" could be expressed in any language.

~~~
calinet6
+1 for reading Zen and the Art of Motorcycle Maintenance on this topic. He
delves into great depth on the intersection of technology and humanity and the
way people look at both. It is incredibly thought provoking.

------
rjbwork
I agree wholeheartedly.

We have some QA folks at work. Our best is a former database programmer from
way back in the day, and she has a REALLY good "systems way of thinking" and
has a mental model of how things work and are united conceptually. This
ability, her "systems way of thinking" sets her far and away above every other
QA person I've ever worked with.

Being able to come up with a mental model of a system and encode it, either in
code or as a document or description is truly valuable in today's increasingly
complex and nuanced world.

------
TeMPOraL
I have to partially disagree with Chris here on two aspects.

First of all, programming indeed seems to be a fundamental thing, on the level
of reading, writing and arithmetics. It gives you new classes of mental tools
that allow you to think thoughts previously unthinkable.

People sometimes say it's very arrogant of some programmers to think they have
something important to say in fields of biology, physics, philosophy, etc. But
it's not arrogance. There are important insights in CS shining light on every
other branch of science that are often noticed by people related to
programming and CS fields because no one else is trained to think in this
fundamental new way.

But I strongly agree with Chris on one thing here - this is _not_ what you get
in those "Teach Children to Code" programs. Those will teach you how to become
a frontend developer in a year and earn good money, which honestly doesn't
require you to think _at all_. It's a trained-monkey level thing. They took
what was supposed to be an idea about education and turned it into something
that's about money and career.

I think Bret Victor did the best summary of why current "teach kids to code"
movement is just total bullshit.

[http://worrydream.com/MeanwhileAtCodeOrg/](http://worrydream.com/MeanwhileAtCodeOrg/)

Second - modeling. I agree with the sentiment that it's modeling that's (one
of) fundamental thing(s). But it can't just be any modeling. Because typical
"modeling" of today is that diagram your chief marketer drew on a whiteboard
that conveys exactly zero knowledge (or even negative knowledge, if you count
in confusion it caused). Typical "modeling" gets you UML diagrams, which we
all know are most useful as padding at the bottom of the trash can, so there's
something to absorb coffee from the cup that you just have thrown away.

The modeling that programming is about is careful and very precise expression
of concepts. It's like that saying goes - "if you want to really understand
something, teach it to someone; but if you want to _really, really_ comprehend
it, teach a computer to do it". Computers are unforgiving - either you exactly
understand what you're doing and can express it precisely, or it doesn't work.
There's no room for error or hand-waving around difficult concepts that people
do when explaining things to one another.

So modeling may be the new literacy, but this must be _careful and precise_
modeling.

~~~
TuringTest
The modeling that programming is about is careful and very precise expression
of concepts. It's like that saying goes - "if you want to really understand
something, teach it to someone; but if you want to really, really comprehend
it, teach a computer to do it".

This is all well and true for _scientific_ modelling, where you want to
achieve an exact depiction of how nature works. But for more social undertakes
I believe that level of exactness is overkill and brings unnecessary
complexity.

After all, society members have been able to collaborate in numerous projects
that don't need that level of accuracy, well before (and after) the widespread
adoption of scientific reasoning. Most social activities simply don't need
such precision and can advance with an amount of ambiguity and implicit
knowledge, with which a computer would choke.

In such environments, people could still benefit from modelling through
computers in a way focused not in precision, but in semi-automation of routine
tasks.

Where computer programs need that every possible case is taken into account in
the model and handled with precission, a system that handled well the common
cases and delegated outliers and exceptions to human supervision could greatly
improve those social enterprises without requiring that those involved learn
how to express their thoughts with scientific meticulousness.

Alas, modern programming languages are not adequate to support that semi-
structured way to modelling, but I think we are closer than ever to build a
tool that can allow end users to build domain-specific abstractions without
learning to create imperative programs or learn how computers work internally
- the ideas to make this happen are floating around with strength for some
time.

~~~
TeMPOraL
> _This is all well and true for scientific modelling, where you want to
> achieve an exact depiction of how nature works. But for more social
> undertakes I believe that level of exactness is overkill and brings
> unnecessary complexity. (...) Most social activities simply don 't need such
> precision and can advance with an amount of ambiguity and implicit
> knowledge, with which a computer would choke._

This reminds me of a common misconception that computers are about precision
as opposed to ambiguity. It's not true - computers handle ambiguity well, but
force you to be precise about what is ambiguous and in what way ;). We've
invented probability theory to deal with uncertainity in a proper manner.

Of course, most social activities work fine with handwaving anything we're not
sure or don't understand - but well, humans do have this skill and it's not
going away. What programming does is it complements that skill with an ability
to be precise about uncertainity when you need to.

> _Alas, modern programming languages are not adequate to support that semi-
> structured way to modelling, but I think we are closer than ever to build a
> tool that can allow end users to build domain-specific abstractions without
> learning to create imperative programs or learn how computers work
> internally - the ideas to make this happen are floating around with strength
> for some time._

I agree, though I don't think we can get there without teaching people the
essence of programming. Syntax peculiarities don't really matter, but the
basic ideas are so fundamental, they're probably more fundamental to reality
than physics. I believe you need to have an intuitive grasp on computation to
be effective even with that semi-structured modelling - because not everything
we know from today's programming is working around machine-imposed
constraints; some of it is actually touching the very fabric of reality.

~~~
TuringTest

      I agree, though I don't think we can get there without 
      teaching people the essence of programming. 
    

That's probably true. Though what is "the essence of programming" IMHO is
quite different from what most developers think when they talk about "teaching
programming" to the general public; it should have little to do with how to
represent computations in available computer hardware, and everything to do
with building domain-specific languages that represent interesting concepts -
for people who don't like computers nor want to understand how they're built.

As others have pointed out in this thread, what is truly essential is the
nature of modelling, i.e. building abstractions from constituent parts, either
in bottom-up or top-down fashion. And as the original article says, an
essential property is being able to build working parts of the system without
needing to complete the whole of it before execution.

    
    
      I believe you need to have an intuitive grasp on
      computation to be effective even with that 
      semi-structured modelling
    

True, but again what developers usually think of computation (building a tree-
like program that is executed at runtime with a specific dataset) is not what
is needed by the general public.

Research in End-User Development, watching real people use experimental IDEs
for non-programmers, have found that systems based on rewrite rules are easy
to grasp.

Also image-based environments like Smalltalk and "live" programming -where the
whole system is seen as a single collection of data and always-running code-
that reacts to changes instantly is also simpler to understand than the
standard write-compile-execute cycle, and better adapted to exploratory
programming.

~~~
TeMPOraL
I agree with everything you wrote. Those essential skills have little to do
with what we as programmers do every day at work. Also people seem to
rediscover them in many different ways - look at things that are made in
Minecraft or Dwarf Fortress, for example. There's lot of application of those
concepts in something that doesn't involve writing code directly.

> _Also image-based environments like Smalltalk and "live" programming -where
> the whole system is seen as a single collection of data and always-running
> code- that reacts to changes instantly is also simpler to understand than
> the standard write-compile-execute cycle, and better adapted to exploratory
> programming._

As someone in love with Lisp, I endorse this message.

~~~
lispm
> simpler to understand than the standard write-compile-execute cycle

well, you'll hear different things about that. Some say the exact opposite,
since understanding the program then depends on the large amount of state of a
running system. In contrast, the write-compile-execute-cycle is more
controlled, since the state building is being controlled as part of starting
the program.

~~~
TuringTest
_> understanding the program then depends on the large amount of state of a
running system_

Fair enough. But a system based on declarative functional language should
largely avoid that problem, as all state has to be made explicit, and all
interactions with state are represented locally.

------
cm2187
I think that coding is the last chapter of a computer litteracy education.

Kids should learn to: \- type with a keyboard \- understand how a computer
works: cpu, ram, disks, etc \- understand softwares, OS, security \-
understand internet, html, ssl certificates \- use office/office style
softwares \- basic programming skills in an easy language

Computers are here to stay and will be an everyday technology like cars and
electricity. Kids have to learn thermodynamics and electricity at school not
because they will all become physicists or engineers, but because they need a
basic understanding of what they will be exposed to their whole life.

------
Terr_
"No... but it might be the new __numeracy __. "

Especially with all the tools people have to do raw calculations for them
(hardware or software calculators, spreadsheet, equation solvers) the coding
"benefit for people who won't continue it professionally" is similar to math
education.

In both cases, the takeaway involves establishing certain critical-thinking
skills, for creating mental models of a real or desired thing, trying to break
that model down into solvable chunks, recognizing chunks you already know how
to solve, and building upwards again.

~~~
TeMPOraL
Indeed. You don't learn arithmetics to do the work calculators are better
suited for, you learn it to understand the concept of quantities and their
behaviour. You don't learn calculus to solve integrals by hand, you do it to
get a feel of how dynamic and interdependent systems behave. And similarly,
the takeaway from general programming education should be additional mental
tools enabling you to think new thoughts and understand all kinds of systems
better.

~~~
cm2187
I think computer science has more to do with engineering than science. Like
learning Latin, learning computer science has some side benefits in term of
learning rigor, logic, etc. But that should not be a primary motivation.

------
nickstefan12
> There are a number of tools that already help us do this - from Matlab to
> Quartz Composer - but Excel is unquestionably the king. Through Excel we can
> model any system that we can represent as numbers on a grid, which it turns
> out, is a lot of them. We have modeled everything from entire businesses to
> markets to family vacations. Millions of people are able to use spreadsheets
> to model aspects of their lives and it could be argued that, outside of the
> Internet, it's the single most important tool available to us on a computer.
> It gains this power by providing a simple and intuitive set of tools for
> shaping just one material: a grid of numbers. If we want to work with more
> than that, however, we have to code.

The idea that the entire average joe population needs more than excel has
never sounded quite right to me. Anything closer to "real" programming and I
think we're asking people to devote too much of their time to something that
looks like software developing. I Just honesty think not everyone has the
demeanor to enjoy programming. It's a very introverted, abstract, high focus,
and high patience endevour.

~~~
TuringTest
Indeed, Excel is close to perfect for the purpose of building data
abstractions in an intuitive way. The only part I find lacking is for building
_behavior_ abstractions which allowed users to build semi-automated workflows
by changing views of data on the fly; to change presentation, Excel still
requires you change languages and resort to imperative programming in Visual
Basic, much like Hypercard.

A tool that combined Excel's functional data-flow programming with Hypercard's
representation of state (as a stack of panels that change depending on the
execution of small attached functions) would IMHO provide a general
programming tool for end users.

~~~
collyw
Excel is easy to model in an intuitive way, but it end up being very poor
models that come out of it, as it is basically a two dimensional grid. So the
first two dimensions you are modelling will come out well, but once you need
to start adding extra information in, then you have color coding, new fonts,
and all sort of hacks to overcome the limitations of excel, when in reality
you ought to be using a proper database by that stage.

~~~
TuringTest
That's right, and this is why a better tool is needed. In the end Excel can't
support arbitrary levels of abstraction.

IMO this is not because the base model is a grid (after all, "proper
databases" also follow that table model) but because you can't create new
tables _on the fly_ and treat them as new objects independent of their
structure. Once you build a data type as fields laid out as columns, all the
operations on that data (mainly filters and search) need to be operated by
hand.

You can't properly express in Excel something like "there are three
collections of employees, and I can create a '' function that works on any of
the three". If you have separate tables with the same structure, you need to
replicate the same operations on each independent table; the only way to build
reusable code is with Visual Basic macros, which falls outside the spreadsheet
declarative model.

But if you could create new functions with Excel formulas (like style handling
or business processes) and apply them to any arbitrary table having the
adequate structure, I think you could have robust abstractions within the
spreadsheet context itself - from a theoretical level, the storage model of
spreadsheets is no different from that of relational databases.

~~~
cm2187
I cannot agree more.

Apple's stab at Excel with Calcs is the way Excel should always have been. A
blank sheet to which you can add tables or charts, not a single grid. You only
need to add an index by which you can query these tables (instead of
VLOOKUPs), and you have something as simple and flexible as a spreadsheet and
as powerful as a database.

Microsoft seem to be keen to observe and take inspiration in what is done
outside, but somehow the office team seems to be an exception. Apart from re-
shuffling around the buttons, I can hardly tell the difference between Excel
2000 and Excel 2013.

~~~
TuringTest
To be fair, Excel internals must be too brittle to allow for more extreme
redesigns; they've been piling up layer upon layer of technological changes
for three decades, and they need to keep it working without crashing too much.

I don't know Apple's Calcs, but Microsoft has built the PowerPivot extension
that largely works as a modern, parallel version of Excel embedded within the
same window. If you need to work on Excel with large datasets and/or complex
relations, it may pay off to learn this extension.

~~~
cm2187
The Visual Studio team overcame a similar problem with a complete rewrite. I
think the problem is more about breaking the compatibility, many add-ins rely
to a very old COM interface. But I think people wouldn't mind a breaking
change if it comes with really new and powerful capabilities. In fact it would
provide an incentive to upgrade. And it can run side by side with old-style
spreadsheets that preserve compatibility.

The problem is not so much large datasets, for which there are better tools
than Excel. It has more to do with doing more advanced thing conceptually.

For instance, what about adding a table to a sheet (Apple Calcs style),
specifying a name and some inputs cells, and one output cell or range, and
then being able to use that table as a function anywhere else in the workbook.
I can already solve these types of problems with a UDF, but think about users
who do not know how to code. Also, having the logic of a function in excel
formula format makes it easily auditable by a non-programmer.

And also what about manipulating data in memory instead of having everything
in big sheets and having to link every cell with each other, or having nested
tables in a cell (or a reference to a table in memory or in another sheet).

And this is Excel only. Word and PowerPoint should really have a mark-up
language side by side with the visual representation. That would make it so
much easier to manage metadata (object names, linking a piece of text to an
external source, working with templates, etc).

------
ntoshev
The author explained a very useful analogy (reading : comprehension = writing
: composition = coding : modelling) but didn't push it as far as he should.
The important thing about coding as modelling is that the results are not just
external to the author's head, they are _formal_ models that automatically
infer or do things. The other way to do that - in one's head and via his
actions - simply doesn't scale beyond a point. Historically the ways people
scale such models are human organisations. That's why IT is so exciting today:
not only it helps an individual think, it helps groups organize at scale that
wasn't practical before because of the friction inherent in implementing
formal models in people's heads.

------
facepalm
Personally, I wish there was a "everybody should know how to design" movement.
Then instead of coding tutorials I don't need, there would be tutorials for
designing available. There are some articles about typography, but it seems
very hard to learn graphics design in general (on your own).

I feel much more held back by my lack of design skills. And I think it's much
more important to being successful in life. It starts with presenting yourself
(design your CV, website, letters, mails, ideas, power point presentations).

But even if you want to create an internet startup: the backbone technology is
pretty much interchangeable. Java/Ruby/badly strung together bash
scripts/whatever. The visuals and UI matter much more.

~~~
TeMPOraL
That's not what the "learn to code" movement was supposed to be about (though
that's what it is about now). What you're suggesting now is again "how to get
rich", but in the marketing version instead of webdev one ;). I get why
learning how to sell yourself well is important for being (financially)
successful, but it does not make you smarter, which was the original point.

~~~
facepalm
Ok I missed that - they seriously want everyone to learn to code because it
would make them smarter? No offense, but I think that sounds so arrogant and
misguided I am speechless (not meaning you, I mean the movement).

There are plenty of other human activities that also require and train
intelligence. I would like to see some actual research on why programming
supposedly is more effective in making people smart than other things.

And then personally I would say people should learn some basic maths before
learning programming. That would help even more, for example to avoid
financial breakdown.

I really thought the movement started because people saw so many "I became a
billionaire by programming" stories in the media, and felt that without
programming people would end up poor. But for example with design it is much
easier to make money on the internet. Just throw together something nice about
a current meme and sell a T-Shirt. I don't know how much work designing a
T-Shirt is, but I am pretty sure it is less than coding a startup that makes
money. Especially, since for a website or app that makes money you'll also
need good design, so it is a strict subset of "sell a T-Shirt".

~~~
TeMPOraL
> _Ok I missed that - they seriously want everyone to learn to code because it
> would make them smarter?_

No, of course not. That was the idea of initial proponents, but it ended up
being "coding is important because it will make your rich" instead.

> _No offense, but I think that sounds so arrogant and misguided I am
> speechless (not meaning you, I mean the movement)._

> _There are plenty of other human activities that also require and train
> intelligence. I would like to see some actual research on why programming
> supposedly is more effective in making people smart than other things._

I'm arguing for that in the top-level comment. Understanding programming gives
you another mental tool you can use for thinking, just like arithmetics or
calculus. It's a way of thinking that is both relatively new and important
thanks to the problems we're facing in the modern world.

~~~
facepalm
I'm a big fan of programming. Just saying that there are lots of other
candidates for "everybody should learn x" that would also make sense.

I think programming should be taught in school anyway.

~~~
TeMPOraL
I agree. There are a lot of things we should be learning (understanding of
finance would be one thing, optimization maths would be another IMO, and maybe
if people well taught to understand the behaviour of exponentially growing
systems (like self-replicating ones), we wouldn't have so strong an anti-
vaxxer movement now).

My point is, I believe programming has very fundamental insights and new
models of thinking that are not really related to the syntax of particular
language. Insights that let you think of things in terms of computational
processes and use that thinking to make stuff do itself. I definitely don't
think everyone should be a developer. Just that everyone could use those
insights in the complex world we live in today.

------
humbertomn
Not everyone needs to be coding since they are 10 and end end up as a top
software engineer in some hot tech startup.

But I definitely agree that basic programming and database skills would be
beneficial to almost everyone following any professional career.

Take my mom as an example: she's a very skilled doctor working with kidney
transplant in Brazil. There are lots of software programs written to help
them, but she's always ahead of time and trying to do some magic with the
massive data she has access to, playing with graphs and spreadsheets.... and I
sometimes (little time) help her to put some little tool up..

I can only imagine where her ideas would be if she had basic programming
skills...

------
logicallee
In front of you is an apparatus that can do a _trillion_ operations for you in
the time it takes your microwave to bring a cup of water to a boil.[1]

But whereas entering how long you want your microwave to heat its contents is
trivial, programming your CPU and GPU to do _anything at all_ makes you about
as qualified as someone who holds an undergraduate degree in the field of
computing[2]. Like a priest at a time when hardly anyone could read and write,
and being lettered itself was a distinction, anyone who can get their computer
to do _anything at all_ (i.e. to program it) has a rarified ability.

Why is the analogy with literacy a good one: _because you must communicate
your intentions to the computer in writing._ That is how you program. Yes, we
have frameworks and models and API's and all sorts of helpful protocols and
formulae to help you communicate with your PC and give you a mental framework.

But at the end of the day, you are asking a machine to do something. And
you're doing so in writing. The rest is literally formalities.

[1] assuming dual-core desktop CPU stepping up to 2.7 GHz and mobile-class GPU
or better; iPad 4 or iPhone 5S GPU capable of 76 GLFOPS or better; 700 watt
microwave capable of boiling 1 cup of water in 1 minute and 30 seconds.

[2] CS undergraduate degree does not guarantee that a candidate can program
their PC.

------
lohengramm
All this discussion remembers me of Brian Kernighan [1] mentioning that Dennis
Ritchie was also a good writer (besides a good programmer). Also, Jamie
Zawinski (jwz), somewhere in the book Coders at Work [2], while questioned by
the author, points out a feeling of mental connection between programming and
writing.

I am with those guys in the sense that programming is just like writing
anything else. Even in the most trivial cases, you actually think (or could
have done it) before putting down a word or two. And you often come back to
erase and make it better. So, teaching how to program is also teach how to
"build models".

[1] [http://youtu.be/uxtKwJZbYr0](http://youtu.be/uxtKwJZbYr0) [2]
[http://www.codersatwork.com/](http://www.codersatwork.com/)

~~~
seanmcdirmid
Writing is much more difficult than programming. With programming, I just have
to get the program to work, the computer checks my BS by not doing the right
thing; I can't lie to it. With writing, I can easily delude myself and it
takes extra mental effort or external review to check prose.

~~~
lohengramm
You can use the computer to check whether you are doing the right thing by
trying it out, but the computer will not tell you whether your program is
organized in the best possible way, whether it is to be considered beautiful
or not, or even, sometimes, whether it is efficient enough. To achieve all
these points you really have to think, and it is just like building anything
else, from texts to mechanical devices.

Of course, its not abstract modeling; there is a necessary amount of technical
knowledge to it, but so there is with anything else.

~~~
seanmcdirmid
You are in a dance with the computer, there is a reliable feedback loop if you
want to test or do perf, there is a truth to it. But with writing, you might
not get any feedback at all, or very little. Building things is quite
different from communicating.

------
Nursie
The world runs on software now.

Gaining a basic insight into what's going on, at a relatively early age, is
important if we want people to gain an understanding of the world around them.
Not everyone has to become an expert, but a modern education system at least
ought to introduce people to it.

------
dkarapetyan
Teaching systems thinking is hard. Even higher institutions of education
haven't figured out how to teach it properly and they are in the business of
teaching stuff. Sprinkling computational magic dust over it will not help.

~~~
TeMPOraL
Computational magic dust has this magic(!) feature that you can't pretend you
understand anymore - if you're stupid about your model, it just won't work,
period. Machines are unforgiving, and they only give you absolutely honest
feedback.

~~~
quikoa
On a syntax/grammar level the compiler is very strict. For plenty of
interesting problems you can often get away with stupid/buggy models. Not that
it's usually a good idea...

~~~
TeMPOraL
Well, it usually quickly comes around to bite you in the ass. That's the cool
thing about computers - quick and honest feedback.

------
itsbits
There are lot of guys who don't code. And there are lot of guys who code but
dont exactly know what are they coding. If you remove all these combinations,
Coding literacy is very less.

------
dtrain3000
Yes. And you're talking about design, in the sense that modeling is a form of
design, and also the design of computers and the supporting OS's we have
today.

To put the above into perspective, imagine how you would design the entire
computing environment for the common man if you could start over and design it
from scratch.

Much of the literacy barrier is due to the fact that our systems are hangovers
from 25 or 50 years ago.

------
stefanix
Good article. I am not sure the difference between modeling and
coding/programming needs to be made as there is not really any significant
coding without modeling.

It's a bit like saying pilots are airplane takeoff/landing operators because
enroute flying is the trivial part.

------
thebouv
Improving the nation's overall STEM skills is more important than just trying
to focus on programming. Programming is not the hard part -- planning,
deducing, structuring, hypothesizing, analyzing and so on.

Programming is just one way to apply those skills.

~~~
nightski
Sure but any STEM major is going to be interacting with computers to a
significant degree. It helps significantly to understand them. Maybe not to
the same level as a developer on HN, but at least to know how software works
and the fundamentals of programming/controlling the machine.

------
patsplat
It's the new middle management.

------
parasubvert
Interesting. These sorts of headlines bug me, in that they reject computation
itself as a novel medium of expression or externalizations of mental models.

I think modeling is very important, but Chris seems confused on how to reason
about education. The core message, that we want children with higher levels of
cognition than mere factual knowledge, is good, but rather obvious. His core
conclusion that we don't want a generation of people caring about code has
nothing to do with this, and is very misguided. This basically rejects
computation as an expressive medium outright in favor of the usual writing and
mathematics ("writers and accountants"), rather than recognizing computation's
new role in society and new jobs that leverage it (business analyst with his
Excel macros, quantitative analyst or data scientist with his combination of
statistics and scripting, software engineers, test engineers, architects).

It's almost like Chris took Bloom's taxonomy (not actually a taxonomy, but
useful)
[http://en.m.wikipedia.org/wiki/Bloom's_taxonomy](http://en.m.wikipedia.org/wiki/Bloom's_taxonomy)
of cognition and decided that the foundational element - knowledge - basic
reading, writing, coding, math, and facts - is irrelevant. This is not
irrelevant, it is the foundation on which we build comprehension, then
application, then analysis, synthesis, and evaluation. This he calls
specification, exploration, validation, and debugging. Good luck teaching
someone how to apply a model, let along synthesize one, when they can't do the
basics of expression. This gets into the philosophy of education, and perhaps
this article is just a reflection of the current trend away from rote
learning, but this is an active debate, not settled science. This trend may
lead to some bizarre outcomes: I see 15 year olds that can't read a wall clock
or understand basic techniques around fractions, though they can describe and
do basic reasoning about them.

Secondly, I believe coding itself is a fundamentally new area of knowledge,
and every debate about "coding is the new literacy" really comes down to
whether you believe this or reject it. Rather than convince you, all I can do
is quote from the preface of SICP
[http://mitpress.mit.edu/sicp/front/node3.html](http://mitpress.mit.edu/sicp/front/node3.html),
one of the great examples of computing pedagogy we have:

'Underlying our approach to this subject is our conviction that "computer
science" is not a science and that its significance has little to do with
computers. The computer revolution is a revolution in the way we think and in
the way we express what we think. The essence of this change is the emergence
of what might best be called procedural epistemology ­ the study of the
structure of knowledge from an imperative point of view, as opposed to the
more declarative point of view taken by classical mathematical subjects.
Mathematics provides a framework for dealing precisely with notions of "what
is." Computation provides a framework for dealing precisely with notions of
"how to."'

Yes, modeling is important - it's a a higher level of cognitive reasoning. We
still should teach kids to code.

