Uncle Bob - The Long Reach of Code

The episode opens on the obvious 2020 question: GPT-3 has just shipped from OpenAI and appears able to write basic methods — a palindrome, say — because it was trained on a great many GitHub repositories. Does that mean the future of programming is automation? Robert Martin's answer is a flat no, and the reason is not modesty about machine learning but a claim about what programming is.

To replicate programming, you would need a machine that programs the way a human does — which means human sentience. And we are very, very far from that kind of machine. Why sentience? Because someone has to specify how the program will work, and that specification is in fact the program. No other specification suffices.

A business user produces a rough specification and then depends on the human intuition and intelligence of programmers to fill in all the horrible little blanks the business person omitted. Programmers, he says, are detail managers; they deal with all the mess. They are the ones who handle the fact that text files sometimes end lines with a newline and sometimes with a backslash sequence, for reasons going back fifty years to teletypes, Unix and DOS.

They write the dumb little if statements for bizarre exceptions that no business person wants to think about. A deep learning system that could handle all of that would be a HAL 9000 — something with human intelligence — and we are so far from that that the prospect of a machine taking all the programming jobs does not concern him in the slightest.

Dwarkesh reframes the question: not replacement but symbiosis — development environments so advanced that you work with the machine rather than on it. Martin's answer is that this has been the entire history of programming. The first programs were written in binary: Turing, working on the Automatic Computing Engine, wrote in binary because there were no languages. Then came the assembler, and the enormous relief of writing in symbolic form instead of doing horrible binary arithmetic.

Then John Backus and the Fortran specification in 1953 — a huge advantage over assembly. ALGOL followed quickly. By 1966 Ole-Johan Dahl and Kristian Nygaard invented objects, twenty years after Turing was writing binary. C arrived in 1968, C++ twelve years after that. Then in the late nineties the tools themselves got wild: IntelliSense, refactoring tools, inspectors, duplicate finders. A modern IDE is a treasure trove that lets a programmer do immensely more complex things than before.

He hopes machine learning keeps making the tools more powerful — but it will never remove the need for the programmer to be there and supervise them. His analogy is the pilot with a beautiful autopilot that can fly the whole route: he watches it like a hawk, because it is a machine and will do the wrong thing at exactly the wrong time. Every time it is supposed to do something, he makes sure it does. He is still in charge; it is not.