Most beginners in programming eventually end up with the same ingratiating message: „Programming is easy, everyone can do it”, with some threatening message that people doing the gatekeeping should stop doing that. I’m here to tell you that that is not true. Programming is hard, programming is not for everyone, and for the time being everyone might be able to do it, but most definitely most should not. Like most of the empty, shallow, positive messages coming with an automatic defense against refute, in this case talking about this gatekeeping thing that simply doesn’t happen. Well, until now. I’m the gatekeeper now.
Programming is accessible
When silly people say that programming is easy, everyone can do it, it’s really actually about how accessible the programming field is. If you have the basic utility of access to Internet resolved, it’s quite easy to access resources, to learn things. No other science is as accessible as computer science, and most of its proceeds happen out in the open - computer science thrives on the internet, and although there are corners that do actual gatekeeping, most of content is freely accessible and thrives on this accessibility. You can download compilers, editors, IDEs, even, you can access documentation, discuss with people about issues, and so on. It’s a big community, welcoming and open in ways that no other science ever was in the history of mankind.
And indeed, you don’t need to know a lot, there are things that can be done in the literal first 30 minutes of your contact with the programming field. Programming is accessible in ways that no other science is.
But just because one can access something easily that doesn’t make it easy. Just because I can mix three things in an omelette that doesn’t make me a top chef. I can cook a few things but I never said that cooking is easy - cooking is hard work, patience to details, and requires a lot of knowledge and experience.
Programming is a peculiar combination of creativity and hard science; and nobody ever said that creativity is „easy”. Some things come easy to some people, some things don’t.
Some programming things are easy
Now, there’s no doubt about it: there are some things that are easy. There are things that you can do and at the end of a day, you might have a skeleton of a blog application, for example. One can make (with guidance) a professional looking web-page in the first hours of learning HTML. It’s easy to ask something and find a solution on StackOverflow, one can easily copy and paste a solution into their webpages.
There is a ton of tutorials for beginners - even for complete beginners, some of them created by beginners. Programming is nothing if not a welcoming place for beginners. Beginners walk a very fertile ground.
What is easy, however, is different from person to person. Things that I find incredibly difficult, others find incredibly easy. Things that I find easy, others are overwhelmed by. There’s no consensus of what is easy to whom, but there are, for everyone, easy things, depending on the learning path they followed. However.
Most programming things are hard
Here’s the truth: if one starts doing anything more complex than a simple web page, or a simple demo program, things become difficult, and the more pieces are put together, the more complex and overwhelming the task becomes. And that’s what every „programming is easy” bullshitter doesn’t say. Solving programming puzzles are hard especially when they’re not meant to be puzzles.
In fact, if treated properly, most programming things are hard, even things that might seem simple. That is because you have complex pieces that you have to put together and to make them work. And the hardest part is when one has to write the complex pieces from scratch. Things only seem easy because you have people with 5, 10, 20 years of experience doing things that are easy to them because they did them many times before, because they made all the possible mistakes or thought about them and made sure they don’t fall in those traps.
But there is no programmer that hasn’t spent a full day on a bug that was fixed by something silly, like adding a
; character, or changing a
< to a
<=. Nobody tells you, as a beginner, about those times when the world is unfair, and you hit a library bug, or a limiting hardware bug. That being said…
Imposture and the positivity racket
How many times have you heard about the imposter syndrome? If you’re hearing about the „programming is easy” speech, you probably heard about it, a lot of times from the very same people. The imposter syndrome is, theoretically, when one feels not competent enough to do the job they are being paid for, and their success is undeserved; but you hear about it when people actually hit those seemingly unproductive bottlenecks, when they have to fix or polish their own work, or they cannot find a fast answer on Stack Overflow. Mostly, I hear about imposters in the programming field when the balloon pops, when they can no longer keep up with the untennable standards they created for themselves, when they cannot rush at the speed they are used to. (I have my own beef with the imposter syndrome, but there’s another time for that)
The positivity, the „it’s easy” racket doesn’t tell you a thing about the moments when things are incredibly hard, when diligent work and steady effort is required. When there are no answers that others can give you, and it’s all between you and other people’s code, or, worse, your code. It’s those moments where you have to rethink entire architectures because some things just will not hold the test of water.
I said that the programming field is a fertile ground for beginners, and it is. But what’s fertile for grain is fertile for weeds too, even moreso. And we need to talk about these people, taking advantage of the fertile ground. And where there’s plenty of beginners, there’s plenty of people taking advantage of them.
There are many ways this happens; some of them are not even aware that they do it, they are just instinctive hustler that oversell their own skills. Usually you see them: two years of experience in software development, writing books and giving advice, sometimes at a hefty price. You see them at conferences, or with articles promoted, or with other types of media, sometimes playing the diversity card, at other times the beginner card, pushing their way in and taking advantage of credulous mass of beginners.
And one doesn’t need to be a complete liar to present a deceitful image of the field. All you need to do is play with people’s sentiments. For example, you tell them something wrong that people want to hear. You have to find the keywords that will flatter the most your audience - „programming” is one of them because programming is quite a fuzzy thing, but the label of „programmer” is one quite sought for, just like the label „senior” is sought for by people who want to be seniors in their early 20s. So you need to find the label that flatters the audience, and apply it in an unmistakeable way to your audience. And that’s how you end up with „programming is easy” (it’s not), or „HTML is a programming language” (it’s not), or „programming is all about mastering Google/StackOverflow searching”.
To emphasize your point, you then expose the enemy. „Don’t let anybody tell you otherwise” is a simple, yet effective way of enlisting the audience in a you-against-the-world mindset. Gatekeepers is also a good word to use, as the discourse around privilege and people keeping things away from the audience is catchy. They are keeping you down, they are injust, they are lying to you about difficulty, they are making you do the hard, boring work. This is a technique that applies to more than just programming, it’s a simple technique for manipulating mobs, as long as there are enemies there’s an easy thing to rally the audience against them. But regardless of this technique, the main point is to be vague in the content of your communication, so that it’s complicated to refute that communication.
Let’s look at my examples. „Programming is easy” took me so far 1385 words, and it’s not done yet. „HTML is a programming language” is somewhat more complicated, because of the shifting meaning of „programming”. The pure technical truth about HTML is that it’s not programming in the real sense, but it’s a markup presentation language. It’s an incomplete description of how a webpage looks like and what it contains. HTML is a necessary tool in any web-related project, but HTML is not used in isolation, and it’s not where you do the programming. But if someone tells you that HTML is a programming language, their defense is usually about you gatekeeping the meaning of „programming”, but they are rarely interested in diving in the real meaning of their own words. As I said, „programming” is a label, and like any glory-labels, this one makes people, especially the incompetent, act very defensively (see my own defense here).
The illusion of „I can do what you do”
Now, the trickier example is the „programming is all about mastering Google/SO searching”. Because that is true and wrong at the same time. Mastering searching the web is a very important skill of a modern developer. I come from a world where this was not the case, where Google did not exist, and, instead, one had to look through documentation and read sometimes hundreds of pages to get an answer on how something should behave. If the documentation existed; if not, there was the only solution of trying, failing, and trying again. Now, however, there is no try, in a very Yoda-esque change of circumstances. There are full toolkits, libraries, or programming languages (and even commercial offerings of that) that rely strictly on you searching the answer for their problem. The documentation is not meant for users to read, it’s for search engines to index and for people to use a search engine on that. But most of the current day tools rely heavily on the answers site Stack Overflow.
In fact, the public’s reliance on Stack Overflow is probably the scariest thing that happened to the programming community in the past 10 years. Stack Overflow is a huge crutch that stops you from walking on your own, because it’s too darn easy to look for the answer there. And when people stop thinking for themselves, they end up writing things that don’t make sense.
But mastering Google/SO searching is a must. I, for one, find myself often searching for very basic things, like how to write a
for loop in <insert language here>. But that’s not because I don’t know how to write a
for loop, but because I’m switching between many languages in a very short timeframe, and I’m looking for the best option to iterate through a collection (not always a
for loop, mind you), or the proper syntax (which each language changes only slightly, making things confusing). So while a beginner might say: sure, not even an experienced developer can remember all these things, the reasons why I look for the same things that a beginner looks for are quite different.
If, as a beginner, you look at what experienced developers do, it looks easy. It looks like anyone can do what they do. It looks unimpressive. There is a myth of the super-programmers that do things in a different way. Hollywood paints them as hyper-fast typists breaking the speed of light, because the only way to easily portray how good a character is at something is to make them look faster than any human could possibly be (as an aside, Hollywood would portray the best person to count ten seconds as the person who finishes in five). The point is that it looks easy, but it isn’t. Because what is missing on the beginner’s side is the experience, the perspective over things, the focus on the real important things. For a beginner, the syntax of a loop is the main obstacle in achieving the ability to count to ten, for an experienced developer the syntax is the thing that slows them from applying an operation to an collection of filtered data.
„Programming is easy” holds people down
The reason this posts exist is the following tweet (and this article written in Romanian, but I’ll focus on the English source):
I understand the intent of this post and know it’s not malicious, however, learning to code is difficult and this “anyone can code” // “coding isn’t hard” dialogue made me feel dumb as hell when I was new. https://t.co/l0ajMn4SG8— Ashley Willis (@ashleymcnamara) February 15, 2021
„Anyone can code” // „coding isn’t hard” dialogue made me feel dumb as hell when I was new.
People feel dumb when they have to trace back on their own creation and fix it, improve it, make it work against real-world scenarios that sometimes you didn’t envision when first writing your code. Positivity doesn’t help you when you actually need help. The only thing it can do is offer you courage, but what do you do with unsubstantiated courage? How fast will the positivity and unsubstantiated claims will succumb to the grim realities of the programming job.
The original poster, that this tweet was a response to, said something on the line of „people think I’m smart because I’m a programmer” and „it’s about googling and fixing our own bugs”. But programming is really not about that, and this exaggerated, limited view tells me that her experience in software development is quite reduced. The scary part? she is building a site called „thecodinginterview.com”, making her a top source for advice for beginners. And don’t get me started on how immoral this „coding interview” racket is.
Positivity is infallible because positivity was never put to test; and it’s completely absent when shit really hits the fan. The mistakes are all yours, because „anyone can code” and „coding isn’t hard”. When you have to face your mistakes, you’re alone, no positivity bullshit can fix that.
„Programming is hard” doesn’t have to be scary
Some people insist that lying to beginners about how hard programming really is would scare them. I’m not sure when the fact that something is hard stopped people really interested in pursuing something. After all, most of our popular culture is about some heroes doing the hard thing. I feel that this is part of the same culture that coddles the minds of people making anything that is not immediate not worth the effort. But when I started programming nobody told me that programming is easy. Instead, my expectation was that it’s hard.
I know that there is an obsession with overachieving, with mastering programming, with being a senior at 22. I refrained from pursuing such fool’s errands. Instead, I knew that programming was hard, and achieving what I want might be impossible. In a sense, it is; I learned programming so I can write my own games and I haven’t done that more than a quarter of century later. But that gave me clarity about the scope of my undertaking.
What I’m saying should not discourage beginners. It should just prepare them for what’s ahead. So if you want to tell a beginner something like this: „when it comes to programming, some things are easy, and some things are hard. If you’re patient enough, in time, the hard things will be exciting, and the easy things will become harder”.
But don’t tell them that programming is easy. It’s not.