The History of Programming

Are you a student of history? If so, then you may know when the Magna Carta was signed, or who fought at the Battle of Waterloo. But how sharp are your mind and memory when it comes to the history of programming? Personally, it’s something that I wanted to learn more about – especially since it can sometimes feel like we’re living in the Matrix and surrounded by code, code and more code. And so, I did some digging on the evolution of programming and the history of storage and memory across the years, and here’s what I found:

Pre-1940

The first electric computer (which bears zero resemblance to what we use today) was created in the 1940s, but it’s interesting to note that a few geniuses were toying with the concept long before that. Way back in 1837, a mathematician named Charles Babbage (rumor has it that his homeboys called him “C-BAB”) imagined the first analytical machine. Sadly, he never finished it, but his son (C-BAB2?) put it together in 1910. That baby was a pure steampunk creation in the literal sense – it used gears and steam. How badass is that? And so, we owe an eternal debt to the Babbages for creating the first programmable “computer”.

The 1940s

In the 1940s, programming languages were simple and complex at the same time. And so their inventors realized that limited memory was a problem. Users (if we can call them users) had to optimize machines by doing some manual work, which made them pretty much useless on a mass scale. Here’s a list of the programming greatest hits from the 1940s:

• 1943: Plankalkül developed by the Germans
• 1943 to 1946: ENIAC built by the Moore School of the University of Pennsylvania
• 1948: Manchester Small-Scale Experimental Machine (the world's first stored-program computer)
• 1949: C10 language

The 1950s

The 50s is when things really shifted into high gear and a lot of new languages emerged – including three massive ones that are still known today (though in a very modified form): FORTRAN, LISP and COBOL. Here’s an overview of some of the languages that were born in the 50s:

• 1951: Regional Assembly Language
• 1952: Autocode
• 1954: IPL (forerunner to LISP)
• 1955: FLOW-MATIC (led to COBOL)
• 1957: FORTRAN (First compiler)
• 1957: COMTRAN (precursor to COBOL)
• 1958: LISP
• 1958: ALGOL 58
• 1959: FACT(forerunner to COBOL)
• 1959: COBOL
• 1959: RPG

The 1960s

In the 1960s, while hippies were finding themselves, geeks were programming. Here’s a snapshot of what emerged, including some languages that you may never have heard of:

• 1960: ALGOL 60
• 1960: COBOL 61
• 1962: APL
• 1962: Fortran IV
• 1962: SNOBOL
• 1963:CPL (forerunner to C)
• 1964: PL/I
• 1964: BASIC
• 1966: Fortran 66
• 1967: BCPL (forerunner to C)

The 1970s

In the 1970s, two seminal moments in the history of geekology occurred: Star Wars, and the ancestors of today’s languages. Here’s a look at the latter, with some added detail for 3 of the biggest and most important: Smalltalk, C and Prolog.

• 1970: Pascal
• 1970: DIBOL-8
• 1972: Smalltalk (This is an object-oriented, dynamically-typed, reflective programming language.)
• 1972: C (One of the first languages of system programming was developed by the famous Dennis Ritchie; along with the less famous Ken Thompson, Ritchie also developed Unix.)
• 1972: Prolog (This is a general-purpose logic programming language associated with AI and computational linguistics.)
• 1974: SQL
• 1977: Commodore BASIC

The 1980s

Rather than inventing new languages, a lot of time and effort in the 80s was spent innovating and refining existing languages (e.g. combining object-oriented and system programming to create C++). Here’s a look at some of the most important languages to emerge from the 1980s:

• 1980: C++ (as C with classes, renamed in 1983)
• 1983: Ada
• 1984: Common Lisp
• 1984: MATLAB
• 1984: Objective-C
• 1985: Eiffel
• 1986: Erlang
• 1987: Perl
• 1988: Tcl
• 1988: Wolfram Language (as part of Mathematica – was re-named in 2013)
• 1989: FL (Backus)

The 1990s

The 90s – aka the dawn of the “Internet Age” – was the beginning of the Internet as we know it, and many old ideas were combined, modified and developed to increase reliability, versatility, efficiency and productivity. Here’s a look at what programmers were busy doing while the rest of the world was busy watching Beverly Hills, 90210 for some inexplicable reason:

• 1990: Haskell
• 1991: Python
• 1991: Visual Basic
• 1993: Ruby
• 1993: Lua
• 1993: R
• 1994: CLOS (part of ANSI Common Lisp)
• 1995: Ada 95
• 1995: Java (became very popular due to integration with the Netscape browser)
• 1995: Delphi (Object Pascal)
• 1995: JavaScript
• 1995: PHP
• 1997: Rebol
• 1998: ActionScript

The 21st Century

We’re in 2000, humans have successfully survived the Y2K problem, but what should we do next? Create new technologies, of course! So far, here are the most important programming languages of the 21st century:

• 2000: C#
• 2001: D
• 2003: Apache Groovy
• 2003: Scala
• 2005: F#
• 2006: Windows PowerShell
• 2007: Clojure
• 2009: Go
• 2010: Rust
• 2011: Dart
• 2012: TypeScript
• 2012: Julia
• 2014: Swift

This Is Just the Beginning

Now, even if you were a contestant on Jeopardy! and you could run the table because the category was, “The History of Computer Programming,” there’s a good chance that some of these languages were new to you – or at least you hadn’t thought about them in a long, long time. But really, this is just the beginning. Here are the 10 most used programming languages according to the PYPL PopularitY of Programming Language Index:

1. Java (1995)
2. Python (1991)
3. PHP (1995)
4. C# (2001)
5. JavaScript (1995)
6. C (1972)
7. C++ (1980)
8. Objective-C (1986)
9. R (1993)
10. Swift (2014)

If you really want to dive into this topic, there’s a great page that tracks trending languages – you can find it right here.

What About You?

Here at Devolutions, we primarily use C, C#, Typescript (Angular), Objective-C, Java and JavaScript. What languages do you use in your work? Please comment below and enlighten us!