This article was derived from an interview by Lex Fridman, of Brian Kernighan, professor of computer science at Princeton University and co-author of the C programming language. During a section of the interview Fridman asks Kernighan to “take on the impossible task” of giving a brief history of programming languages. Kernighan’s answer is reproduced below (with some edits for structure and clarity). Should I write here on this site some extended history of programming languages in the future, I’ll link to it in this preface. For now, this is a nice, pithy overview for people who are curious about programming’s history, from the mouth of someone directly involved in that history. Fair warning: understanding Kernighan’s account might require some basic familiarity with the basics and history of programming. The 1940s You could say programming languages started in the late 1940s. People used to program computers by basically putting in 0s and 1s, using something like switches on a console, or holes in papers tapes – something like that. It was extremely tedious work. The first programming languages were relatively crude assembly languages that saw people write programs that would convert mnemonics like ADD into whatever bit pattern corresponded to an ADD instruction. They would do the clerical work of figuring out where things were, so you could put a name on a location in a program and the assembler would figure out where that corresponded to when the thing was all put together and dropped into memory. The 1950s Early on, in the late 40s and very early 50s, there were assemblers written for the various machines that people used. Tony Brooker developed the Autocode, which was a flavor of assembly language (or a little bit “higher” in some ways). This replaced a language Alan Turing wrote in which you would input 0s and 1s – but you would put them in backwards order because that’s how the hardware worked. Assembly languages populated the early 1950s, and so every different flavor of computer has its own assembly language. The EDSAC had its assembly language, as did the Manchester computer, and the IBM 704…so everybody had their own assembly language. To be able to write programs in a given machine, you had to know it intimately. If you were to write an assembly language program for one kind of machine, and then you say “I’d like this is in a different machine”, you had to start over. In the late 50s, people realized you could move up a level in creating languages that were closer to the way that people might think about how to write code. There were arguably three or four in that time period: Fortran, which came from IBM and was formula translation, meant to make it easier to do scientific and engineering computation; COBOL, which is the common business-oriented language that Grace Hopper and others worked on, aimed at business kinds of tasks; ALGOL, which was mostly meant to describe algorithmic computations; BASIC, which you can argue is among these programming languages, albeit somewhat later. All of these languages moved a level up, and so they were closer to what people might think of as they were trying to write a program. They were focused on different domains. Fortran and COBOL are still used today. The deal, so to speak, with these languages was that as you moved up that “level”, you then had a language that was not tied to a particular kind of hardware. This meant two things: it meant that you only had to write a program once, and that could in fact write a program yourself – you didn’t have to hire a programmer to do it for you. If you wrote it yourself it might not be as good as the one you could get from a programmer, but it could do the job. These languages democratized and made the ability to write code much more broadly available. The 1960s & 1970s In the late 60s and early 70s, system programming languages arose, of which the C programming language is the survivor. System programming languages are programming languages that would take on things like text editors, or assemblers, or compilers, or operating systems themselves. They were much more in touch with the actual machine in the sense that you could deal with memory in a controlled way, as well as different data types, and ways to structure and organize data. Beyond, To The Present After these languages, object-oriented languages came about, because when writing programs in a language like C, at some point scale becomes an issue, and it becomes to difficult to keep track of the pieces. C++ comes from the object-oriented tradition. From there, there was an “explosion of languages” (to borrow Lex’s description).