Like most areas of technology and computer science, programming has come a long way since its inception. Such a long way that modern coding bears little resemblance to its origins. Observing a modern-day programmer trying to communicate with one from the 1950s would be like watching two people speak different languages. In most cases, that’s exactly what they’d be trying to do!
You may be surprised to learn that what would be considered the first programming language to be used came about in 1947. Yes, you read that right. Of course, these very old languages looked a lot different from C, C++, Python, Java, and other modern languages that we’re used to today. This is due in large part to compiler development, which made coding syntax a lot more accessible. Arguably, this makes the efforts that preceded what we now know as programming languages all the more impressive. Without further ado, let’s get going with our list of the 8 oldest programming languages ever used.
#1: Assembly Language
- Year of development: 1947
- Developed by: Kathleen Booth
- Uses: Real-time programming, cryptographic algorithms, high-security control
Assembly languages are low-level languages where instructions closely mimic the machine code that a computer runs on. They’re designed to communicate as directly with the hardware as possible. Kathleen Booth developed the first example of such a language in 1947. This type of programming language is named as such because the code must be converted into executable code by a type of program called an “assembler”.
Assembly language was first adopted at a wider level by the Electronic Delay Storage Automatic Calculator in 1949; however, this was in a mnemonic format, i.e., based on abbreviations of English words. In this way, the instructions given were much simpler than those of the language created by Booth and legible by humans. Today, assembly languages still have some niche uses, such as in real-time programming, working with older processors, high-security circumstances, and cryptographic algorithms.
#2: Short Code
- Year of development: 1949
- Developed by: J. Mauchly, W. F. Schmitt, A. B. Tonik, and J. R. Logan
- Uses: Early electronic computers
J. Mauchly initially proposed Short Code in 1949 under the name “Brief Code”. However, the language was implemented by William Schmitt in the same year for the UNIVAC I computer. As such, it can be considered the first programming language developed for use with electronic computers.
It’s first implementation wasn’t exactly “short” as far as time is concerned, since programmers had to manually change the mathematical expressions into binary code. This simplified the programming process, but the overall execution time was much longer than using machine code. Grace Hopper would be responsible for eliminating much of this manual labor, as she wrote the first compiler a couple of years later.
#3: Autocode
- Year of development: 1952
- Developed by: Alick Glennie
- Uses: Early electronic computers
Many early languages were actually grouped under the umbrella term “Autocode”, with the first being developed by Alick Glennie in 1952. Although Hopper wrote a compiler for Short Code in the previous year, Autocode is often considered as being the first compiled language, as it could be directly translated into machine code.
Today, the term is mostly used to refer to any language derived from those used with the Manchester Mark 1. This was a stored-program computer developed at the University of Manchester in England that was first operational in 1949. Glennie developed his Autocode language for use with this computer. However, in the 1960s, the term was used for any high-level language that used a compiler.
#4: FLOW-MATIC
- Year of development: 1955–1959
- Developed by: Grace Hopper
- Uses: UNIVAC electronic computer, influenced the development of COBOL
Motivated by the difficulty she faced in educating businessmen on mathematical concepts, Hopper sought to develop a programming language that used English-like expressions. FLOW-MATIC first became available to the public in 1958 and was intended for use with the UNIVAC I. This was a computer aimed at business applications and the first of its kind.
FLOW-MATIC would heavily influence the development of COBOL, a language designed for business that’s still being used today. Elements of FLOW-MATIC that were incorporated into COBOL include English-like expressions, data-level programming, sentence structure, and the definition of input and output files.
#5: IPL
- Year of development: 1956
- Developed by: Allen Newell, Cliff Shaw, and Herbert Simon
- Uses: List processing, precursor to LISP
IPL, or “Information Processing Language”, was created through the collaborative efforts of Allen Newell, Cliff Shaw, and Herbert Simon. The main idea behind the language was to help programs carry out simple problem-solving tasks. These features included dynamic memory allocation, data types, functions as arguments, recursion, and lists. As well as being the forerunner of list processing, IPL was used in many early applications of artificial intelligence, i.e., the General Problem Solver and Logic Theory Machine.
Although the first version of IPL, IPL-I, was never implemented, subsequent versions would be used by IBM. The language was influential in the development of LISP, which offered benefits such as a more intuitive syntax and garbage collection that was done automatically.
#6: FORTRAN
- Year of development: 1957
- Developed by: John Backus, IBM
- Uses: Scientific computing, the basis for BASIC and ALGOL
“Formula Translation”, or FORTRAN, was created by John Backus (through IBM) for use in complex statistical and scientific projects. It has stood the test of time as the most universally used programming language and still finds applications today.
Although compiler languages had been developed earlier, FORTRAN set itself apart by enabling code to be written in English-like syntax and by its efficient compilation process. As such, it’s a highly regarded and reliable language that’s popular in computationally intensive disciplines. FORTRAN is so efficient that it’s often used to benchmark the fastest supercomputers in the world. A drawback is that input and output operations aren’t handled well. This weakness, coupled with the rapidly increasing demand for business computing solutions (which rely heavily on such operations), led to the development of COBOL in 1959.
#7: COMTRAN
- Year of development: 1957
- Developed by: Bob Berner, IBM
- Uses: Business programming, precursor to COBOL
For all the benefits of FORTRAN, the language couldn’t be relied upon for business computing. This led to the development of a more business-oriented language by IBM, known as COMTRAN (or “Commercial Translator”). COMTRAN is notable for being the first programming language to implement something known as a “picture clause”. This clause is a string of characters, with each part representing a portion of data as well as how it should be formatted. For example, the clause “9(7)” represents “9999999”.
Nowadays, COMTRAN is an outdated language; however, it’s significant for being a forerunner to the COBOL language. COMTRAN still finds some uses, mostly in relatively simple business computing operations such as human resources and accounting. Since it could not handle sophisticated errors and exceptions, COMTRAN wasn’t suitable for more complicated systems.
#8: ALGOL 58
- Year of development: 1958
- Developed by: Friedrich Bauer, Hermann Bottenbruch, Heinz Rutishauser, Klaus Samelson, John Backus, Charles Katz, Alan Perlis, and Joseph Wegstein
- Uses: Scientific computing, influenced many modern programming languages
The name “ALGOL” may seem a little enigmatic at first, but the logic behind it is pretty simple. ALGOL comes from “Algorithmic Language”, and was initially designed to be a universal programming language. Proposals for a universal language culminated in a joint meeting between members of the U.S.-based Association for Computing Machinery (ACM) and the Germany-based “Society of Applied Mathematics and Mechanics” (GAMM). During the meeting, the name “IAL” (for “International Algebraic Language”) was devised, but this was later changed to ALGOL for pronunciation’s sake.
Unfortunately, the usage of ALGOL 58 was quite limited. This was due in part because it competed with FORTRAN and also because it didn’t include any protocols for input and output. ALGOL 58 did find some use in scientific avenues, but it’s mostly remembered for paving the way to more compact languages, such as Pascal, Java, and C.
The Oldest Programming Languages Ever Used: Summary
| Rank | Language | Year Developed |
|---|---|---|
| #1 | Assembly Language | 1947 |
| #2 | Short Code | 1949 |
| #3 | Autocode | 1952 |
| #4 | FLOW-MATIC | 1955–1959 |
| #5 | IPL | 1956 |
| #6 | FORTRAN | 1957 |
| #7 | COMTRAN | 1957 |
| #8 | ALGOL 58 | 1958 |
The Oldest Programming Languages Ever Used: Wrapping Up
To summarize, programming languages have been around ever since the invention of computers (and even some time before that). While most old languages had limited usage, many of them heavily influenced the more commonly used languages that would follow. The earliest languages tended to have a rather singular focus, as opposed to modern-day languages, which are usually designed to tackle lots of different tasks. As the field of computing continues to develop at an exciting pace, we’re sure to see the introduction of languages once thought to be only theoretical.
The image featured at the top of this post is ©G-Stock Studio/Shutterstock.com.