I just heard that John Backus died last saturday.
John Backus was one of the most influential people in the development of what we now know as software engineering. In the early days of his career, there was no such thing as a programming language: there was just the raw machine language of the hardware. Backus was the first person
to come up with the idea of designing a different language, one which was easier for
humans to read and write than machine code, and having the machine do the translation.
For those of us in the field today, the idea of not having a human-readable language is almost unimaginable. But in the days when Backus got started, the idea was not just revolutionary – it was downright controversial. Even just using what we would call an assembler today was considered a bad idea by many programmers of the time.
Just to give you a sense of what that means: An assembler is a tool that lets
you write programs in the basic instructions of the machine; only instead of having to write the instructions in numeric forms, they’d let you write them as words – it’s the difference between
writing something like “2E 03 F1 79” and “ADD R3, (A1)+9”. Many of the early programmers believed that writing the latter form was harmful – because when you’re writing in non-numeric form, you
aren’t as aware of some details like exactly how the instructions are aligning in memory. So
the idea of moving even farther away from the machine code, so that you didn’t even know
exactly what sequence of instructions your code would be translated into was considered
But Backus beat the so-called common wisdom of the time. He and his team developed
Fortran, and showed that not only did the compiler match the performance of
hand-written code for most systems, but it often beat the performance of hand-written code for anything but extremely small hand-optimized code segments; and it created a dramatic
improvement in productivity: programmers could get their work done much more quickly, with
fewer bugs, by writing in a higher level language.
Just designing the first programming language ever wasn’t enough for John Backus. Once the first Fortran compiler hit the world, he led his team into the area of figuring out how to describe and process programming languages. With Peter Naur, he developed what we now call BNF grammars – that is, Backus-Naur Form grammars, which are a formal tool for describing the syntactic structure of a programming languages; and he and his team worked out how to use those grammars as a guide to
the translation of code from the human readable syntax of languages like Fortran and Cobol to the
pure binary used by the machine.
In later years, Backus devoted his time to trying to build better languages for expressing
programs. He became an outspoken advocate for the idea of functional programming, designing his own
language and programming called FP. FP was never a huge success,
but there are still a few people working on FP-derived languages, and they’re a very interesting
idea. I’ll probably write a little something about FP later this week.
John Backus won the Turing award in 1977, and used his Turing Award lecture as an opportunity to push the idea of non-imperative programming. The written article that accompanied his lecture remains one of the classic documents describing why people should look at functional and non-imperative programming languages.
Backus is also the guy who hired Fran Allen, this years Turing Award winner.
I never met him, which is something I’ll always be disappointed about. I’ve known quite a few people who worked for him, but I’m too young to have had the opportunity meet him.
Backus will be remembered in the Computer Science community. His name ranks with some of the true greats – I would go so far as to include him in a list with people like John von Neumann and Alan Turing as the greatest influences on the development of computer science as a discipline.