Learning a Foreign Language vs. Learning to Code: What’s the Difference?

When the Journey Begins

I’ve heard it a million times: “I could never learn another language, my brain just isn’t wired up for it.” Hmm… allow me to state the obvious: Once upon a time, you actually didn’t know how to speak English. It took a long time to learn, but you got there in the end. If you really, really wanted to, and you were really serious about it, I’m quite sure you could do it all over again. You could learn French or Spanish, Russian, Chinese, or Elvish. Simple as that. And to take on another myth – I don’t think it’s much easier to do it as a child. It literally takes them years, whereas after 12 months of applying yourself to learning any language, you can normally get quite far, reaching a level that exceeds ‘survival’. This is much more than a toddler is capable of.

I spent six years in the military as a language specialist. When I first signed up, English was the only language I had a firm grasp of. After nearly two years of intense training, I could listen, speak, read, and write in an operationally critical language like a pro. It wasn’t because I was some kind of linguistic genius; it was because I had the motivation, patience, and will to learn. It also helped that I was being paid – literally speaking, I was a pro.

One day while on the job, I was looking at my computer screen. Perhaps by accident or some weird twist of fate, I right-clicked the mouse and then selected ‘inspect’. Suddenly, I was washed up in a torrent of cryptic technical language, with only the faintest idea of what any of it meant. The thought came to me that while we are all so dependent on these machines and the computer languages with which they speak to each other, so few of us really have any real depth of understanding of what goes on beneath the surface. The digital world is like an unseen realm surrounding us all, and most of the time, its inner workings remain completely out of sight. At this very point in time, guided by my curiosity, it was as if I were being summoned on some sort of quest.

After some reconnaissance of the field, I’d figured out a few basic facts: there’s hardware and there’s software, and each one relies on the other to work. There are networks, and quite often these networks are insecure. There are also operating systems, the place where hardware meets software, and on top of this, applications are built. Then came my biggest revelation of all – if you learn a programming language, you can build these applications and get computers to do what you want them to! If your code is strong enough, you can build things that will be used by other people.

And with all the enthusiasm that the Hobbits had when leaving the Shire, once again, I found myself starting out from the beginning, a lot like where I was when I first started my language training in the Army – ‘Week 1, Day 1’. Motivation and curiosity will only take us so far, and this is the harsh truth that the Hobbits learned when they finally leave the familiar comfort of the Shire. They realise that the road ahead is a long one, often lonely and sometimes dangerous. They begin to wonder if they should have even set off in the first place. There have been several occasions when, overwhelmed by the challenge of a particular programming task, I wanted to throw my computer against the wall and scream, “I will never be able to learn a programming language, my brain just isn’t wired up for it.” Sound familiar?

What’s the Difference?

So with my origin story out of the way, I want to let you in on a little secret: learning a new language and learning to code are basically the same thing. They both require the same skills: patience, persistence, and a willingness to make mistakes. They are both very intimidating at first because there is a steep learning curve to climb before you feel you have any solid grasp. And they both carry you on the same emotional journey: moments of frustration, moments of triumph, and moments when you want to curl up in the foetal position and cry.

But there is one big distinction – we humans are by nature social creatures, whereas computers are categorically not. Our brains have evolved for communication with each other, whereas computers are wired up to understand only two things: yes or no, one or zero – binary code.

Here is some evidence of this in practice – people are very helpful and forgiving, no matter how brutally you butcher their language. More often than not, they will try their very best to help you communicate in their language. In my experience, they actually feel quite flattered that you are making an effort.

For example, if you are in a restaurant in Spain and you try saying ‘dos cervezas por favor’ in your best Sean Bean Yorkshire accent, whoever is taking your order will interpret what you’re asking. They will intuitively understand the context and will try their best to help you achieve the outcome that you’re looking for (2 beers).

On the other hand…

“Computers are like old testament gods. Lots of rules and no mercy.” – Joseph Campbell

And that’s that. In the image above, we can see that the Python interpreter is perfectly happy to just sit there and not fulfil your request, idly looking back at you with a blinking cursor in a state of complete indifference.

But one thing we do have is a clue – the error message. And this is the breadcrumb that hints to us the direction we must take to go further. While programming, the thought has often come to mind that working with computers is a lot like being a mouse lost in a maze. We know that there is a piece of cheese at the end of it. We believe that it is possible to get to it, but there are many winding paths between us and the cheese, most of which lead to dead ends. With a little ingenuity and problem-solving, we will get to the cheese, eventually. The next time we try, we will get to the cheese quicker than before, and from these little accomplishments, we can take on bigger challenges – more complicated mazes that lead us to bigger prizes.

Early on, I used to get so frustrated with error messages. Now, I am grateful for them. Not so long ago, there was a time when there were no error messages. When the computer programme didn’t recognise any valid input (as happened in the image above), the programmer had no error messages to guide them. Often, the ‘bug’ in the programme was just as likely to be a literal bug stuck in the machine as an error made within the programme itself.

We Learn New Things in the Same Old Ways

In foreign languages, grasping new grammar is notoriously difficult. It all relates to the idea of ‘syntax’ – the implicit rules that govern the structure and arrangement of words, that when used correctly convey meaning. It is an enormous cognitive challenge firstly just to grasp, and then recognize and apply new elements of foreign grammar.

It’s really the difference between just parroting words and phrases and actual comprehension, when we become a creative agent who can interpret the deeper nuances of meaning and then formulate new verbal constructions of our own. It is difficult to explain how grammar and syntax are different between languages, and there is such an enormous diversity across the spoken languages today that the entire scope of it can’t be pinned down and described completely, although some have tried.  I won’t go much further on this side quest, but one path toward recognizing it would be to think about the following;

-The case systems found across many european languages (we don’t really have these in English)

Again, there are parallels here with computer programming. Learning grammar is a lot like mastering a new programming concept, such as Object-Oriented Programming (OOP), which is one paradigm of programming. I see this as a sort of grammar for computer communication.

When handling data in OOP we typically use variables, classes, and methods. These allow for regularised and predictable behaviours that enable the processing, transformation, and manipulation of data into different structures and formats. Understanding how to work within these structures is not something that comes easily, at least not to me. I felt as though I had to bend my mind into thinking in new pathways and directions that I couldn’t comprehend from the outset, much like I did when learning foreign grammar.

To approach this kind of challenge requires a leap of faith – although the learning curve is steep and perilous, it shall be overcome. In Hobbit terms, this is the most challenging part of the journey – the ascent of Mount Doom. What at first feels strange, foreign, and unfamiliar over time will become not so intimidating. And when you succeed, it will come to feel like second nature- you will return to the Shire.

Building from this, we can see that the process of learning any kind of language is pretty much the same. We go through four stages:

  1. Unconscious incompetence: We don’t know how complicated anything really is before we properly consider it. We are in a state of ignorance, with no guide or map, we are surrounded by the fog of war. This is our default state. We often underestimate how complicated things actually are.
  2. Conscious incompetence: We decide that something is worth our time to understand and realise that we should make the effort to build the skills required to do something new. We begin to appreciate the scope of what is actually required.
  3. Conscious competence: We have begun to acquire some knowledge and practical ability, but to use these skills takes a lot of mental processing to achieve. We are driving in first gear up a very steep hill. We make mistakes at least as often as we get things right.
  4. Unconscious competence: Approaching mastery. When we know just what to do to achieve a goal. We have achieved not just understanding, but practical applied knowledge. At this stage, we probably can’t remember what it was like to not understand what we know now. This might be what makes good teachers so hard to find!

Enjoying the Process

When we decide to take on a new foreign language or programming project, we start out on this same four-stage process again and again. Week 1, Day 1. All over again. But having gone through the process before, our doubts should be quieter, and our confidence greater. That’s because our chance of success is higher too.

You probably never will truly feel genuinely ‘fluent’ in a foreign language. Whenever I’ve been asked if I am, my response has always been ‘yes, but I could always be more fluent’. Something similar is true also with programming. You learn to achieve new things, you become comfortable with the syntax and capabilities of a given language in one paradigm. But out of this doesn’t come fluency, you just go on to build better and more ambitious things. Perhaps the greatest achievement then is to take the complexity of the world as it is, to communicate with people to understand the problems they face, the inadequate systems they have to deal with, and to translate these very real human concerns into the computer programmes that not only solve these problems but allow us to achieve more than we first thought possible- when we were stuck in the mouse maze with no map, surrounded by the fog of war. The journey continues.