The first decade of programming: Speaking in tongues

Part Two of Chapter One in a very personal history of programming

Speaking in tongues

In 1957, FORTRAN (FORmula TRANslation) made it possible for people to write programs by composing with human logic instead of needing to remember difficult opcodes.

The way human readable (and relatable) programming languages work is by taking a concept, such as printing out something, which as we saw just above takes a dozen lines of assembly code, and abstracting⁶ that concept into one reserved word. Reserved words are not the same as binary or hexadecimal words. Reserved words are human language code words that represent whole sentences in computer words. In the case of FORTRAN the reserved word that replaces most of the assembly program above is “write”.

A special program called a compiler expands “write” into the sixteen lines of assembly language, and other reserved words into their respective assembly language equivalents.

As we shall soon see, many early programmers didn’t like compilers. They did not trust them to do as good a job as a human. In the very beginning there may well have been merit to that, but over the years, humans transferred a lot more of their “smarts” into compilers. Also, as computer capacity got larger, the programs got a lot larger and more complex. It would be almost impossible for a modern programmer to beat a compiler, and nobody really tries.

But in the old days, even when using a compiler programmers were still “close” to the metal. They usually knew what the compiler was doing, what “choices” it would make when it “saw” certain patterns in the human readable language. Good programmers would write their human readable code in specific ways meant to force the compiler into “doing the right thing”.

Here is the “Hello World” program in FORTRAN:

1 implicit none2 write ( *, ‘(a)’ ) ‘ Hello, world!’3 stop4 end

As you can see, writing in FORTRAN reduced the number of programming statements required. On the average by a factor of twenty.

The increase in programming productivity was an order-of-magnitude because the longer or more complex a program is, the more significant the productivity gain becomes. The examples I give you are very short. With a larger program (tens or hundreds of thousands of lines) the difference is much more dramatic. Writing five hundred lines instead of ten thousand lines is a lot bigger productivity improvement than writing four lines instead of sixteen.

A few years earlier, Grace Hopper had created a language for business use called FLOW-MATIC, based on her belief that people should be able to program a computer using plain English and have the computer convert the English words into machine instructions for itself. Few people have heard of FLOW-MATIC, but many people have heard of COBOL (COmmon Business Oriented Language) which was based in very large part upon FLOW-MATIC and was considered by many to be more human readable than FORTRAN.

1 IDENTIFICATION DIVISION.2 PROGRAM-ID. HELLO-WORLD.3 * simple hello world program4 PROCEDURE DIVISION.5 DISPLAY ‘Hello world!’.6 STOP RUN.

It must be said that COBOL programs are disliked by many programmers for being extremely wordy, which could be considered a productivity decrease.

The MIT Jargon File⁷ has this to say:

COBOL fingers /koh’bol fing’grz/ n. Reported from Sweden, a (hypothetical) disease one might get from coding in COBOL. The language requires code verbose beyond all reason (see candygrammar); thus it is alleged that programming too much in COBOL causes one’s fingers to wear down to stubs by the endless typing. “I refuse to type in all that source code again; it would give me COBOL fingers!”

Nevertheless, making programming accessible to a greater number of people constituted a productivity improvement on the whole, and it was still a lot less code than assembly.

In the late fifties two other influential languages came into being at the same time, LISP, which is sometimes still used today for AI (Artificial Intelligence) programming, and ALGOL (ALGOrithmic Language).

Just about every language in common use today is a descendant of not FORTRAN or COBOL, but of ALGOL (sometimes with a little LISP influence thrown in for good measure). But those descendants would only start to appear twenty years later, the next decade belonged to the computer manufacturers and the electrical engineers. They would improve programming productivity not through languages, but through hardware and operating systems.

“Here is a language so far ahead of its time, that it was not only an improvement on its predecessors, but also on nearly all its successors.”⁸

~ Sir Charles Antony Richard Hoare Turing award winning computer scientist speaking about ALGOL

<- Previous article in series

Next article in series ->

[1] I will provide am in depth explanation of what abstraction means in computing later on, in Chapter Four.

[2] “The Jargon File is a glossary and usage dictionary of computer programmer slang. The original Jargon File was a collection of terms from technical cultures such as the MIT AI Lab, the Stanford AI Lab (SAIL) and others of the old ARPANET AI/LISP/PDP-10 communities, including Bolt, Beranek and Newman, Carnegie Mellon University, and Worcester Polytechnic Institute“. https://en.wikipedia.org/wiki/Jargon_File

The whole text is available at http://catb.org/jargon/html/index.html. I read it with religious fervor when I was in my larval stage. You can look up larval stage in the Jargon File.

[3] C. A. R. Hoare. 1973. Hints on Programming Language Design. Technical Report. Stanford University, Stanford, CA, USA.

This article is an excerpt from my upcoming book The Chaos Factory which explains why most companies and government can’t write software that “just works”, and how it can be fixed.