The first programming language

This edition of Backlog is special because it’s the first (and probably the only one for years) to be published on Christmas. Consider this email my gift to you, who follows this project that means so much to me. Thank you so much for the support 💙

To start with, there would be no devs without something we could write to turn our thoughts into something useful a computer can run. We need a way, a language, to tell the computer what we want to do, and that’s how we got the idea of creating programming languages.

But how did these languages come about? What’s the story behind them? And, more importantly, who created the first genuinely useful programming language?

Before answering that, we need to look at the context of how programming languages evolved. This didn’t happen overnight – it took over 200 years to get where we are today.

Where it all started#

Before any computer or calculating machine, and more than 100 years before Alan Turing, a French weaver named Joseph Marie Jacquard changed the way looms worked. In 1804, he created and patented the famous Jacquard loom, designed to create complex patterns automatically.¹

The Jacquard loom was fully programmable through punched paper cards. Each card represented one row of the design, and the machine could be attached to any existing loom. That made producing fabrics with more complex patterns simpler and cheaper, changing the textile industry of the time.

Even though the Jacquard loom was a simple application of a DSL (Domain Specific Language, a language designed for one specific purpose), his work inspired the development of more complex languages, ones that could be interpreted by different kinds of machines.

Ada Lovelace and note G#

Thirty-six years after Jacquard patented his loom,² in 1840, professor Charles Babbage was invited to give a seminar in Turin, Italy, about the progress of his most ambitious project: the analytical engine (a topic for a future Backlog). That seminar was the only public presentation Babbage ever gave about the revolutionary machine he was building.

During the talk, an engineer named Luigi Menabrea – who would later become prime minister of Italy – took detailed notes to understand how the complex model worked, a model that would later be known as the world’s first mechanical computer (even though it was never built).

Babbage had an important friend and mentee: Ada Lovelace. Since 1833, he and Ada, a brilliant mathematician and daughter of the poet Lord Byron, had exchanged letters and notes about their research and mathematical progress. After a conversation with Charles Wheatstone, Ada was given the suggestion of translating Luigi Menabrea’s notes into English as a way to contribute to the work. When she finished the translation, Babbage suggested she add her own thoughts as appendices, which Ada simply called “notes”.

Ada put together seven notes, named A through G, detailing how the analytical engine worked. In the last one, note G, she described an algorithm to calculate the Bernoulli numbers, designed to run exclusively on Babbage’s machine. That algorithm – and that note – is widely recognized as the first computer program ever written, making Ada Lovelace the first programmer in history.

Ada’s notes were three times longer than Luigi Menabrea’s original article. Beyond describing the algorithm (only in the last note, G), Ada detailed how the whole analytical engine worked, explaining how it differed from the earlier machine, the difference engine. In note C, she introduced revolutionary concepts such as loops, control flow (if, else) and functions – the first time these ideas ever appeared in history.³

And she did all that without ever having even seen the machine itself (which was never fully built) or used any part of it. And here we are today complaining when we can’t use an API without documentation…

Plankalkül, almost there…#

The world of computing stayed pretty much the same for about 100 years. But between 1943 and 1948, a German scientist named Konrad Zuse (pronounced “Zuza”) started noticing a big problem: no existing computing language was Turing-complete, which made them unsuitable for his Z1 to Z3 computers.⁴

Zuse’s computers started out as mechanical calculating machines, similar to Babbage’s ideas. But by the third version (the Z3), he built something revolutionary: a fully digital and programmable computer. Now all that was missing was a language his computer could understand…

Why not build your own language? That’s exactly what Zuse did. He drew on mathematical concepts, including propositional calculus – a complex field of mathematics – to develop a programming model.

However, since implementing propositional calculus directly on a computer would be extremely hard (and it wasn’t Turing-complete), Zuse decided to design his own language, called Plankalkül.

Plankalkül is widely recognized as the first high-level programming language, because it abstracted away much of the computer’s internal workings. With it, engineers didn’t have to deal directly with repetitive tasks like writing loops by hand.

Even though it was a fully established language in theory, Plankalkül was never implemented on Zuse’s computers, like the Z3, despite being developed afterwards. The Z3 itself was programmed using punched tape made of movie film, read by electromechanical relays into a 1408-bit memory (64 words of 22 bits each).⁵

Instead, his main motivation was to offer a more efficient and structured way to program, allowing for more sophisticated and “easy to understand” programs.⁶

I’d like to explain how this “simpler” language works, but honestly, I couldn’t understand a thing (Zuse was much smarter than me). So I’ll leave you with the basics:

• The language has only one primitive type, called S0, which represents a bit, that is, a boolean value. A bit can be 0 or… L (yes, that’s right, why use 1?). So the number 2 (10 in binary) would be written as L0.
• Every other type is composite, built from arrays or tuples of bits. For example, a sequence of 8 bits would be written as 8 x S0.
• Variables are always local, there’s no global scope.
• There’s no support for recursion, goto statements or references – only direct values.
• It supports control structures like if, else, for and while.
• Composite types are always arrays or tuples, no more complex variations.
• Uppercase letters, like V, Z, C and R, identify variables, outputs, registers and constants.

I imagine all of this made perfect sense in Zuse’s head (because it makes none in mine), but unfortunately the war and the collapse of Nazi Germany interrupted his work.

Under Allied occupation, he was forbidden from continuing to build computers, and focused his efforts on creating languages, but the language was never implemented at the time. The first working implementation of Plankalkül only happened in 1975, when Joachin Hohmann used it in his academic dissertation.

Despite never being implemented originally, Zuse’s publication had significant impact on the development of later languages, like ALGOL and APL, which we already talked about in edition #2.

Now yes, the mother of ALL languages#

Up to this point, most languages were built in a fairly artisanal way: their creators basically structured everything they knew about computing into a working system. Some of those languages, like the APT used on the M70 we saw in the other edition, were so specific that they even required special keyboards, full of unique symbols – very different from what we use today.

But that started to change in 1954 with the arrival of FORTRAN (short for FORmula TRANslation), the first commercially successful programming language. Developed by a team led by John Backus at IBM, FORTRAN brought a practical and efficient approach that changed the way people programmed.

Behind these revolutionary languages was a huge technical challenge: getting computers to understand them.

Compilers#

Between Zuse’s invention in 1943 and 1954, any code written for a computer had to be translated directly into machine instructions specific to that hardware. It was like writing an exclusive program for each processor, using a language only that processor understood – often made up of mathematical symbols.

In 1950, a revolutionary invention appeared: the compiler. It made possible a group of languages called Autocode, which at the time were described as “code systems”. The term autocoders referred to a family of compiled languages, where the same set of instructions could be translated into machine code for different computers. In other words, you could write the code once and compile it for several machines, something unheard of until then.

The first of these languages, believe it or not, was also called Autocode. It was created in 1952 by Alick Glennie, along with its own compiler. That language is considered the first compiled language in history, even though it saw little use outside the Manchester Mark I computers.

This evolution brought a radical change: now you could write code using a single system, where only the compiler had to be adjusted for each machine. That hugely simplified the development of new programming languages and opened the way for even bigger progress in the field.

The story of FORTRAN#

At the end of 1953, John Backus presented a bold proposal to his bosses at IBM: create a more practical and efficient alternative to Assembly for programming the IBM 704 mainframe. The idea was to make everyone’s life easier, letting them focus more on the problem and less on the machine instructions.

The main thing the new language had to solve was making it simpler to put mathematical equations into computers, building on studies from 1952 that proved it was possible to convert equations directly into code.

FORTRAN had a clear goal: translate math into code. Hence its name, short for FORmula TRANslator.

The first specification of the language was completed in 1954, under the title “The IBM Mathematical Formula Translating System”. In 1957, the first FORTRAN compiler was built, and it produced machine code fast enough to convince most programmers that a high-level language could be a viable alternative – even with the various early bugs.⁷

After 1958, FORTRAN got a reliable compiler and quickly became widely used on most IBM mainframes, establishing itself as the main programming language of the era. Its success was so big that by 1963 there were already more than 40 FORTRAN compilers.

FORTRAN was especially popular among scientists who needed to do heavy, precise calculations with long numbers. Because of that, the language kept being improved and, to this day, it’s recognized as one of the fastest languages in the world for numerical processing.

The initial version of FORTRAN had 32 keywords (Golang, for example, has 25) and supported:

• Switch
• Go to
• Tape or block I/O
• Arithmetic

When it was created, there were no disks or screens, most programs were still done on punched cards, so developers had a “form” where they could write, erase and test the code before transferring it to a final card.

And on those punched cards, there were specific columns reserved for control use, for example:

• A C in the first column turned the whole card into a comment
• Columns 1 to 5 were labels, used to jump back in constructs like GO and IF
• Column 6 was for saying whether the card was a continuation of the previous one
• 7 to 72 was where we wrote the programs
• 73 to 80 were ignored because the IBM 704 only read 72 columns, so they were often used for annotations or identification, like the order of the cards and so on.⁸

Evolutions#

After the initial version, FORTRAN kept evolving – and still does. It’s the oldest programming language still in active use, with its most recent version released in 2023. The first major update, FORTRAN II, brought a significant step forward: support for procedural programming, allowing subroutines and modularizing code more efficiently.

The initial version of FORTRAN had no functions or routines, all the code had to be replicated and copied, but in version II you could use the keywords SUBROUTINE, FUNCTION and END to create a routine, plus CALL and RETURN. But the early versions still didn’t support recursion.

Then came FORTRAN III, which introduced the ability to write assembly directly alongside FORTRAN code. That version, though, was never released as a commercial product. Instead, IBM released FORTRAN IV in 1961, bringing significant changes. The main one was removing dependencies specific to IBM machines, like the READ INPUT TAPE instruction, allowing FORTRAN to be used on computers other than IBM’s.

But maybe the most important step was FORTRAN 66. That version was the first to go through an official standardization process, very much like what later happened with JavaScript. The specification was written by the American National Standards Institute (ANSI) and a committee called BEMA. Based largely on FORTRAN IV, it brought several important features:

• Subroutines and functions
• New primitive types INTEGER, REAL, DOUBLE PRECISION, COMPLEX and LOGICAL
• The DATA keyword for specifying initial values
• GO TO , IF, DO and many others

11 years later, FORTRAN 77 is what we have as the beginning of what we use today as a programming language, including changes like:

• The use of structured IF with END IF instead of GO TO and CONTINUE
• The first use of quotes for text, since it was now possible to write on terminals
• Adding PROGRAM to name programs

An interesting bit of trivia about FORTRAN is how it handled comments and empty lines. Any line starting with the letter C was read as a comment. However, the FORTRAN compiler read every line of the program in sequence – including empty lines, which often caused errors. To avoid trouble, it was common to use an empty comment to separate one line from another.

FORTRAN kept evolving, but it was only 13 years later that a major revision appeared: FORTRAN 90. That version is one of the most commonly used to this day, because it brought significant changes you probably didn’t even notice right away, but that made programmers’ lives much easier:

• Text didn’t have to be indented 6 characters in before any statement⁹

• Keywords could be lowercase
• Variable names up to 31 letters (before it was only 6)
• Inline comments instead of taking up the whole line
• Now you could operate on arrays as a whole
• Recursion
• Modules to group procedures and data together and make them available for importing into other programs, the first concept of a “package”
  • Here we also get encapsulation, with private functions and parts of a module
• Overloads
• SELECT CASE, which is the first version of a switch
• …

Now FORTRAN programs look a lot like what we write today, check out a hello world:

1
program helloworld
2
     print *, "Hello, World!"
3
end program helloworld

After these versions, we still have FORTRAN 95 through 2023, which implemented many changes right up to today, making FORTRAN extremely useful even now.

FORTRAN today#

FORTRAN is still widely used in critical and legacy systems, like aviation, mainframes and applications that demand extremely fast computation. Its relevance is especially in scenarios that require high performance when processing large volumes of data.

The language is a common choice in areas like fluid mechanics simulations, space and terrestrial modeling, and calculating ocean temperatures. Thanks to its efficiency in heavy numerical calculations, FORTRAN is still heavily used in fields that depend on scientific simulations and high-precision engineering.

FORTRAN code itself went through several changes until it ended up looking a lot like what we understand as programming code, for example, below we have a program to calculate the average of the numbers read:

1
program average
2

3
    ! Read in some numbers and take the average
4
    ! As written, if there are no data points, an average of zero is returned
5
    ! While this may not be desired behavior, it keeps this example simple
6

7
    implicit none
8

9
    real, allocatable :: points(:)
10
    integer           :: number_of_points
11
    real              :: average_points, positive_average, negative_average
12
    average_points   = 0.
13
    positive_average = 0.
14
    negative_average = 0.
15
    write (*,*) "Input number of points to average:"
16
    read  (*,*) number_of_points
17

18
    allocate (points(number_of_points))
19

20
    write (*,*) "Enter the points to average:"
21
    read  (*,*) points
22

23
    ! Take the average by summing points and dividing by number_of_points
24
    if (number_of_points > 0) average_points = sum(points) / number_of_points
25

26
    ! Now form average over positive and negative points only
27
    if (count(points > 0.) > 0) positive_average = sum(points, points > 0.) / count(points > 0.)
28
    if (count(points < 0.) > 0) negative_average = sum(points, points < 0.) / count(points < 0.)
29

30
    ! Print result to terminal stdout unit 6
31
    write (*,'(a,g12.4)') 'Average = ', average_points
32
    write (*,'(a,g12.4)') 'Average of positive points = ', positive_average
33
    write (*,'(a,g12.4)') 'Average of negative points = ', negative_average
34
    deallocate (points) ! free memory
35

36
end program average

There are still repositories today containing FORTRAN code, like in games, and the language is still widely used.

Legacy#

FORTRAN was the first high-level language to be widely distributed and everything we use today is either identical to or based on some kind of implementation FORTRAN brought. Foundational languages like COBOL, BASIC and ALGOL were heavily influenced by FORTRAN and, in turn, influenced other languages like B, C and everything that came after.

I was recently at the National Museum of Computing in Bletchley Park (see it on my instagram) and there they have a really cool wall of every programming language that ever existed on an interactive map. You can get to that map here and, who knows, print it out to decorate your house:

That’s the end of this edition of Backlog! I hope you enjoyed learning more about what the very first language was and how it worked as much as I did!

A hug and merry Christmas!

See you in the next edition!