As I watched this excellent video from CGP Grey arguing that in the near future most jobs will be done by machines, I felt a little relieved. Many professions, from truck drivers to doctors, will disappear or change dramatically in the very near future, creating a whole new generation of Neo-Luddites. However, as it seems, future computer programs will spare their creators: programmers. After all, to create self-driving cars, medical diagnostic systems, butcher robots you need programmers, right?

Wrong.

What is programming?

Programming is the discipline of translating ideas (businesses, law, games, mathematical problems, etc) into code that machines can execute and other humans can read. After all a programmer is a middleman, a person who understands the problem and understands the machines and, therefore, can translate between the two. No less, no more.

Great programmers understand the domain of the problem as deeply as they understand the platform they program for. Innovation happens in that sweet intersection of mastering the domain and the technology. That is why (among other things) software products meant for programmers (GitHub, Visual Studio, AWS, etc) tend to be great and government products (Healthcare.gov, FBI’s Sentinel, etc) tend to be lousy and expensive.

Everyone is programming

Middlemen ought to be cut out eventually.

This has already been happening in the past decades to some extent. Higher level programming languages and information available online lowered the barrier of entry into programming to nearly zero. Scratch, a kid-friendly programming platform from MIT has millions of users and over 10M projects which puts it in the same league with GitHub. An average programmer today requires much less understanding of computer architecture and algorithms than his colleagues 20 years ago. Lowered barrier of entry and increased productivity should result in a more competitive job market for programmers, but we don’t see it because the increasing demand offsets this by far.

This revolution, however, seems to have stalled recently. Our most important tools, the programming languages have not changed much in the recent past. Most new and popular languages (like Go or Rust) bring incremental improvements to existing paradigms and lack revolutionary features. The most popular languages today are Java (1995), C (1973) and C++ (1983). The industry is instead focused on developing supporting tools and methodologies to increase productivity. To see how much we have failed to innovate I strongly recommend Bret Victor’s talk, The Future of Programming.

What does this mean?

The S-curve

Technological development looks like this: SSSSSSSSSSSSSS

To be a little more clear:

For instance, IBM’s first word processor program (FORMAT) used cumbersome punch cards as input. In the same time, the most advanced typewriters came with exchangeable font faces, automatic character repetition and the ability to print mathematical formulas. Yet no one uses typewriters anymore. Word processors eventually caught up and typewriters went obsolete.

I’m convinced that we are in a similar technological plateau when it comes to programming languages and a new era is approaching.

Programmer-free programming languages

To completely cut out programmers (the middlemen) from the system we need programming platforms that “understand” the problems themselves with no need to write code.

The idea is not new at all. In 1963, Ivan Sutherland’s Sketchpad demonstrated a system that solved problems given several defined constraints. Prolog (1972), a declarative programming language was created to solve problems given a set of logical rules. It has failed to be a programmer-free programming language and it is not widely used anymore, but it didn’t disapper completely. For instance it powers (among other languages) IBM’s famous Watson supercomputer.

A great candidate for a programmer-free programming language is a natural language, like English. From binary code to assembly, from C to Python, programming languages tend to get similar to natural languages. As a general best practice, programmers today try to get their code as close to plain English as possible so that other programmers and their future self can understand it. What are the limits of that convergence?

NLP

Today’s natural language processing (NLP) systems are capable of understanding roles of words in a text and their relation to each other. Here’s an example output from Stanford’s CoreNLP:

Notice that the program is able to recognize co-references to the same person just by analyzing the text and can identify roles of words.

Let’s see something more interesting, for example, a simple business rule:

Notice how CoreNLP recognized conditions (if - buy) and subjects (buy - iPhones). How difficult is it to translate this into a computer program now?

There are more and more news articles written by bots. Recently companies like Apple, Google, Microsoft and Amazon have developed consumer products built on speech recognition and natural language processing. This will further accelerate research in this area.

If you want to experiment with natural language processing yourself I highly recommend NLTK for Python.

Genetic programming

Another interesting area of research is genetic algorithms. Using a process similar to natural selection, genetic algorithms solve problems by breeding the fittest solution. Applications range from designing jet engines to playing Super Mario.

A developer named Kory Becker wrote a program that generates Brainfuck code to solve simple problems. Of course, the utility of this software is very limited, but this is just the beginning. As he demonstrated, more complex problems require more computing power to figure out the fittest program.

The following code, for example, is entirely written by the program and prints hello.

The field is called genetic programming and, of course, it isn’t new either:

There is the genetical or evolutionary search by which a combination
of genes is looked for, the criterion being the survival
value. (Alan Turing, “Intelligent Machinery”, 1948)

Combining NLP and GP we can build systems that understand constraints written in natural language and implement a program that solves problems within those constraints.

Enjoy while it lasts

I am confident that not all programming jobs will be replaced by robots, at least not very soon. There are programming tasks that require highly optimized code or use of advanced algorithms. In other cases, the domain is too complex. However, I’m also confident that a very large number of programmers will be replaceable by programs in the following years to come. My prediction is that this will decrease the demand for flesh and blood programmers so much that it will offset the increasing demand for software creation and end the era of highly paid programmers. This, of course, doesn’t mean that there won’t be any “programming” done. It’s just that people from the problem domain (scientists, business owners, game designers, students, product managers) will write the “program” themselves without a need of someone talking to them and the machine simultaneously.

Does this make you sad? It shouldn’t. After all we are so much luckier than truck drivers or doctors; we have the chance to actively participate in this revolution.