Home

 › 

Technology

 › 

Discover the 8 Oldest Programming Languages Ever Used

Ruby Vs. Python

Discover the 8 Oldest Programming Languages Ever Used

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
hardware computer chip processor
Low-level languages interact closely with a computer’s hardware.

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
Short Code was developed to be used with the UNIVAC I electronic computer.
William Schmitt implemented Short Code on the UNIVAC I computer.

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
Manchester University Campus Large Old Building Red Brick Roof with Trees and Blue Sky
Autocode was developed at the University of Manchester.

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
Cobol inscription against laptop and code background. Technology concept.
FLOW-MATIC was pivotal in 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
Lisp Programming Language
Although not used much today, IPL was influential in the development of 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
IBM
FORTRAN was one of many programming languages developed by IBM.

“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
largest server companies
COMTRAN can be thought of as IBM’s business equivalent of FORTRAN.

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
Computer programming often shortened to programming is a process for original formulation of computing problem to executable computer programs such as analysis, developing, algorithms and verification
ALGOL is short for “Algorithmic Language”.

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

RankLanguageYear Developed
#1Assembly Language1947
#2Short Code1949
#3Autocode1952
#4FLOW-MATIC1955–1959
#5IPL1956
#6FORTRAN1957
#7COMTRAN1957
#8ALGOL 581958

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.

Frequently Asked Questions

What is the oldest programming language to be used?

The oldest programming language ever used can be considered to be “Assembly Language”, which was developed by Kathleen Booth in 1947. This type of language was adopted by the Electronic Delay Storage Automatic Calculator in 1949, albeit in a mnemonic format.

Are the oldest programming languages still used today?

Some of the programming languages mentioned here are still used to this day, such as COMTRAN, FORTRAN, COBOL, and Assembly Language. However, their use is fairly limited and mostly applicable to niche situations.

Who is Grace Hopper?

Grace Hopper was a computer scientist from the U.S., and later, a naval admiral. She is most well known for developing the first compiler to be used to translate a programming language, as well as playing a major role in developing COBOL. For this reason, she’s often called the “mother of COBOL”.

How did FLOW-MATIC influence COBOL?

Elements from FLOW-MATIC that were incorporated into COBOL include English-like syntax, data-level programming, an orientation towards business computing, and sentence structure.

What is a low-level programming language?

Low-level programming languages are those that closely resemble machine code and aren’t very abstract in comparison. As such, they’re less intuitive for programmers to understand and use. This complexity can make errors more likely but also gives the programmer direct control over the hardware. This control is crucial in high-security systems, cryptographic algorithms, and real-time operations. Assembly languages are examples of low-level programming languages.

What is a high-level programming language?

High-level programming languages are intended to be more legible by humans and have a higher degree of abstraction from the hardware. This way, programmers can write more user-friendly code that resembles human language. Most modern languages used today are high-level languages, as they provide more portability and are more intuitive. Examples of high-level languages include Python, Java, C++, C#, and JavaScript.

To top