Bits and Behavior
Published in

Bits and Behavior

Why learn to code?

Over the past several years, calls for everyone to learn to code have been almost deafening. Bill Gates encouraged us, Mark Zuckerburg challenged us, and even learned himself. Even President Obama asked everyone in America to learn, calling for $4 billion to bring access to computing education to every child in America:

President Obama calls for CS for all.

What I find fascinating by this increasingly prevalent message is not the message itself—“learn to code” is fairly vague—but the arguments behind the call to action. After all, trying to explain why anyone should learn anything in particular is no simple task.

Take algebra, for example. It seems like an unquestionably useful skill, right? Everyone in America learns it, so there must be some reason. Well, what’s the reason? Not everyone uses it in their life. Those who do use it probably could have learned when their work demanded it, or it was necessary for getting a job. It causes a lot of grief to high school students and, at the advanced level, is even a barrier to graduate and later participation in STEM fields. Some might argue that learning algebra leads to better general problem solving skills, or certain kind of precision of thought, but there’s little evidence of this either. In fact, most evidence on learning suggests that we’re good at what we explicitly practice, and that there’s little transfer between the things that we practice, except when those skills are nearly identical in nature. This doesn’t mean that teaching algebra is worthless, but rather that the arguments for teaching algebra are unclear.

Arguments for learning to code

This brings us to code. Why learn to code? There have been many arguments put forth for debate, but little coherent debate.

Perhaps the most prevalent is to prepare youth for jobs. This is the argument that uses, it’s the argument Obama used, framing it as “skill necessary for economic opportunity and social mobility,” and its the argument that state policy makers continue to use to justify funding for CS teacher training, certification, and hiring. It works politically, because jobs-related arguments mobilize policy makers, because the public likes jobs (at least the abstract idea of their children having them). Of course, it’s an argument fraught with problems. There may be a shortage of software developers now, but will that shortage last long enough for a 5th grader to capitalize on it in 12 years? Who knows. Is one CS class in high school enough to get a job? No. Is learning to code enough to get a job? That depends on what it means to “know how to code,” which is itself, an ill-defined idea that researchers like myself are only beginning to understand.

A related argument is that people should learn to code to get a job. This argument actually makes sense: if you want to develop software for a living, you should definitely learn to code. The organizations that use this one the most are companies like coding bootcamps and online coding tutorials. They make the sensible case that companies are looking for people with software development skills, and learning to code is one way to acquire these skills. As I noted above (and as we found in a soon to be published study), “coding” skills aren’t really enough to get a job, but they are a start.

Another common argument is that coding is a literacy that is essential for understanding our increasingly computational world. David Rushkoff made this argument in his book Program or be Programmed, suggesting that to be an informed citizen, it is critical to understand how software, and transitively, software designers, can manipulate our behavior, violate our privacy, and infringe upon our rights. The CSForAll consortium, which emerged from Obama’s call, makes a similar argument, seeking to empower youth to “be creators in the digital economy, not just consumers, and to be active citizens in our technology-driven world.” Professor Amy Bruckman made a related argument, suggesting that citizens need insight into how software is developed so they can expect and enforce professional ethics in the development of software; without this knowledge, people can find themselves with no ability to maintain or plan to maintain the software that others build for them. As someone who studies how people understand software, I actually find all of these arguments quite persuasive, but I don’t find them to be a convincing argument for learning to code. Knowledge about how companies design, test, support, and maintain software is different from knowledge of how use programming languages, APIs, technology stacks, and tools.

Mark Guzdial made an interesting argument that the broad acquisition of coding skills may increase economic productivity. The argument is that empowering each citizen with the ability to automate tasks such as data analysis, decision making, and other activities, may make humanity more productive individually, leading to an overall increase in economic productivity, which tends to result in higher standards of living. The flaw in this argument is the assumption that any one body of knowledge about coding would be sufficiently relevant for everyone that it would help everyone be more productive. That teacher that wants to automate grading might need to learn data flow programming in Excel, while the engineer might need to learn Python or R, and the politician might not need to learn anything. Trying to devise some form of universal education that would serve this massive long tail of tasks is non-trivial from an education perspective. And if you try to support the argument outside of an education system, it means creating a broad diversity of informal learning materials (which would be great, as I argue below).

Arguments against learning to code

There are also arguments against people learning to code. One of the classics is that we should leave software development to the experts. The argument here is that people who only know a little about programming will produce software that is less reliable and more defective. This is generally true, but people write code anyway, and there’s no sensible way to stop them. Instead, researchers (like myself) have investigated ways to help people make their software more dependable, even though they know little about software engineering.

Another fun argument against learning to code is that in the future, no one will code. The prediction here is that researchers working on program synthesis will eventually be able to generate any program one might want, supplanting the need for humanity to code, or that machine learning and artificial intelligence will supplant the need for traditional programs entirely, replaced instead by intelligent systems that infer what we want to automate and automate it. If this is true, why encourage anyone to learn, and why create some permanent infrastructure for teaching people to code in K-12 school, let alone college? This is a fun argument, but not a very pragmatic one: if this future comes to pass, we’ll have to question why people should learn anything.

Others have argued that modeling is important, but coding isn’t. The idea here is that the ability to create useful abstractions for reasoning and automation is the powerful part of computing, and that “coding” is just a particular way into that skill. It’s hard to argue with this perspective, because modeling is, in a sense, what makes humanity so powerful. We naturally build representations of the world to support our reasoning. This argument therefore devolves to “be better at being human,” without any practical guidance on how precisely to do that.

My argument

I’m not going to bash all of the arguments above without presenting my own argument. Here it is, in all its simplicity: learn to code…

Because you want to.

That’s the reason to learn anything, of course. It abstracts away all of the reasons that one might want to, whether they be a job, a curiosity, a passion, a desire to create, or even sense of civic duty. There are so many reasons that one might want or need to learn to code—an increasing number of reasons everyday—trying to catalogue them all and blindly apply them to every person seems ridiculous. Because a person wants to learn to code is the only universal reason that accounts for this diversity.

The problem with this argument is not the argument itself, but it’s implications. If anyone in the world wants to learn to code, can they? Not today. Do people want to learn to code? Some, but not many are even aware of it. Few people have access to teachers or classes who can help guide or engage them. Those who have access to computers and the web can find resources, but only if they know those resources exist, and that learning to code is something they might want to do at all. And even if someone can find those resources, there are a million roadblocks that make learning programming languages, libraries, APIs, frameworks, and tools nearly impossible without an infinite reserve of patience, an endless supply of motivation, and access to the right answers at the right time.

People want this skill and they can’t have it. And many people might want this skill, but they don’t know it exists. We don’t need the universal ability to code, we need universal access to learning. Who accesses that learning, how much they learn, and what they do with that knowledge will sort itself out through economic forces, but we must make it available and show why it is interesting and useful to as many people as are willing to listen, just as with every other subject. Many researchers and practitioners of computing education are focused on exactly this.

How then does one argue for either federal or state changes to educational policy? The “jobs” argument can only take us so far. I think we’ll ultimately have to rely on the argument of equal access, and not create new universal required courses, but rather high-quality, concise introductions to computing in required courses, high-quality, scalable electives in schools, high-quality scalable materials online, and high-quality scalable teachers everywhere. Only by focusing on the equitable scaling of effective resources will everyone have a chance to develop and interest and ability… if they want to :)




This is the blog for the Code & Cognition lab, directed by professor Amy J. Ko, Ph.D. at the University of Washington. Here we reflect on our individual and collective struggle to understand computing and harness it for justice. See our work at

Recommended from Medium

Simulation Cloud with E-HPC for the Manufacturing Industry

Use Case of Kubernetes

Professional Illustrate the Specifications before Jumping to Code

Reverse Vowels of a String

Docker Disk Space Management — Tips for Managing Resources

Understanding Monte Carlo Methods Using Swift

MicroChains Telegram FOMO Game. CHAT to WIN!

Setting up a lightweight Kubernetes cluster with K3s and Fedora CoreOS.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Amy J. Ko

Amy J. Ko

Professor of programming + learning + design + justice at the University of Washington Information School. Trans; she/her. #BlackLivesMatter.

More from Medium

My Journey In Tech: A Filipino-American Woman’s Perspective

Hana Gabrielle, a light-skinned Filipina, holds up a sign saying, “Because minority women comprise fewer than 1 in 10 employed scientists and engineers,” for the Women in Computing at Cornell’s (WICC) 2017 Photo Campaign.

Notes on Rousseau’s Contrat social, Part II

Whatcha gonna do with a toxic colleague

Hiker Duo from USA Walks Across Bermuda for Mothers: Pays Gratitude to Rockefellers for Supporting…