We all know about Moor’s law. Computational power grows exponentially as well as opportunities to write software. The share of the human population who knows programming grows as well, but not nearly as fast. It is a problem. Why do I think so? Let’s explore.

What is knowledge

Knowledge, as I use the term, is the information that humanity has recorded in a medium and improved over time.


This is the best definition I could find, and it fits the purpose of this article very well. Let’s study it piece by piece.

information – there is a ton of information in the world, but not all of it we consider knowledge. But knowledge is definitely some sort of information.

recorded in a medium – you can question that this is a requirement for knowledge. Let’s say you went to the forest, tried some lovely red berries, and got sick. You’ve just acquired some experience. But your knowledge will die with you unless you record it somewhere to share with others. In a sense, when you’ve received your knowledge, humanity did not get anything from it. So on a global scale, it is not knowledge.

improved over time– this is what distinguishes information from knowledge. If you saw a new meme on the internet, chances are it will disappear in a week, and everybody will forget about it. Was it information? For sure. Was it knowledge? Probably not. Because it was not important enough for humanity to iterate and improve, we do not consider it knowledge. The other important thing to note is that you cannot improve something over time unless it is “recorded in a medium.”

Literacy is a knowledge booster

The ability to read and write is what significantly boosted the creation of knowledge. Before literacy kicked in, people passed knowledge mostly verbally, using stories that sometimes lived through many generations. However, verbal language is hardly a suitable medium for storing information. Literacy made it possible to persist knowledge in writing, thus enabling future generations to use this knowledge and iterate on it.

It is obvious nowadays, that literacy is essential. It is enforced in education systems in most countries in the world (believe it or not, there are countries like Afghanistan where the literacy rate is 28.1% – this is the share of population older than 15 years who can read or write).

Literacy emerged and disappeared many times throughout history. Script developed at least five times in human history independently. It has to be super important. Otherwise, multiple civilizations had not developed it independently.

For a long time, religion was driving literacy adoption. It had some successes, but there was a very recent socio-economic event that really made an impact.

In 1800 around 40 percent of males and 60 percent of females in England and Wales were illiterate; by 1900 illiteracy for both sexes had dropped to around 3 percent.


What happened is during the industrial revolution, a lot of manual labor was automated. The demand for skilled workers skyrocketed. New technology expanded so rapidly that it required people to learn how to use it very fast. It did not make sense to wait for hundreds of generations for people to adopt new things slowly. You had to read the manual of the machine to operate it.

So Britain did a radical thing for the time – they went all-in on education. Over just a century, the illiterate rate dropped dramatically. This was necessary; otherwise, most people would be simply left with no job to do. This is an important milestone in the industrial revolution that shaped the world.

Programming is a knowledge booster on steroids

Does the code represent knowledge? Let’s check.

  1. Is it information? Yes. You write symbols that mean something in your code editor. It is information.
  2. Is it recorded in a medium? Yes. The best medium of all times – a digital medium of transistors. We have recently started to use it for written knowledge as well, and it is fantastic. You can copy information and share it with zero marginal cost. You can store it indefinitely. Amazing.
  3. Is it improved over time? Yes. I don’t know about you, but I rarely write code from scratch. My software is born from snippets of code that other people wrote. If Google suddenly stops working, I will be 10x less productive at work.

Now that we have established that code represents knowledge let’s explore why programming is an order of magnitude more powerful as a knowledge booster than just the ability to read and write.

The sentence in the English language has a fixed amount of information (or entropy). English words may have different meanings in different contexts, but the number of contexts is finite.

Code is “executable” while, for example, the English language is not. It means that it represents an instruction to the machine which can do something. You can instruct the computer to output an infinite sequence of numbers with a fixed amount of characters in the code. If I ask you to write the number Pi, how many sheets of paper do you need? Infinite. You cannot write it because you have a finite lifespan. However, you can write Pi as an algorithm in a very concise way:

from decimal import Decimal, getcontext
print sum(1/Decimal(16)**k * 
          (Decimal(4)/(8*k+1) - 
           Decimal(2)/(8*k+4) - 
           Decimal(1)/(8*k+5) -
           Decimal(1)/(8*k+6)) for k in range(100))

The code above is a Python code that computes the first 100 digits of Pi.

You can read more on the theoretical implication of the “executable” quality of code in this book.

The code is much better at representing algorithms than a plain language. Imagine a sequence of steps that are required to find a genetic disease in a particular DNA sample. It’s pretty damn hard to explain precisely how the algorithm works, including all details of implementation. Only the actual software that does the search represent this knowledge. And this knowledge could be passed to the next generation of engineers who could improve it or use the ideas to develop algorithms for finding new diseases.

Hopefully, by now, you agree that the ability to write and read code is a powerful knowledge booster. It has the potential to become an order of magnitude more powerful than literacy. As with literacy, it will take time. However, we can speed the process up. In the next section, I will introduce the top three things we need to do.

Adopting programming at scale


We need to teach the basics of programming at schools. Education is a powerful reinforcement loop. Over a couple of generations, you can completely transform society with the right education. Advances in online education made it possible for people to access all kinds of free resources, but this is not enough. We need to establish the subject of software engineering (at least basics) as one of the fundamental skills. Governments need to enforce this.

Unification of languages

Humanity iterated over languages quite a lot. There is no shortage of dead languages. There are also too many “active” languages so that no one can learn all of them.

When people speak different languages, it slows down progress, because it affects communication. So by natural forces, languages converge. First, the dialects converged within a single geographical area. Now we see similar convergence on the global scale – the English language is considered “the international language.” Almost all the knowledge is either created in English or translated into English.

The same thing is going to happen with a programming language. We are still very early, so it may seem like an impossible task. However, nothing, in theory, says that we need multiple programming languages. What we need is simply a Turing-complete language (which most of the existing ones are). Everything else is mostly syntax details. We need to keep iterating, and soon it will emerge. Progress happens very fast. Even though the first commercially available programming language was developed in 1956, less than a century ago, we already have a bunch of “dead” languages.

Democratization of programing

Tools for developers need to become more user-friendly. Long gone are days when to input an instruction into the machine, you need to wear a scientist’s white coat. It’s much easier to create software now, but it’s still not ready for mass adoption. I have a few specific things we can improve in tools for developers:

  1. Smart use of GUI elements. I’m not talking about using GUI instead of programming language, but rather add an option of representing a piece of code as a GUI element. There are great concepts you can find in this talk.
  2. Merge design and implementation stages. Most developers have to model how the code should work in their heads while writing it. It’s super hard. As an engineer, you need to instantly see the result of your work while designing your software.
  3. Make existing code searchable. Tools for developers are just learning how to incorporate the code written by other people to help an engineer. We need to index this knowledge and make it more available. Also, we should have more “marketplaces of code,” where people can share their code with a broad audience.

In conclusion

I believe the widespread adoption of programming skills is just a matter of time. It can take significant time if we don’t put our efforts into making it happen. If you don’t believe in such an adoption – you can just sit and wait to see what’s going to happen. But trying to make an impact on our future is a more fun way to spend the time.

If you enjoyed this article, we have more. I’m the co-founder of https://www.seamlesscloud.io/, and our team of 3 engineers writes from time to time on different topics related to software engineering. You can read more of our blog here.

Categories: Thoughts