History of programming languages facts for kids

The history of programming languages tells us how people have created ways to talk to computers, from early machines to today's apps. At first, these languages were very complex, using lots of math symbols and hard-to-understand rules. But over time, scientists made "high-level" languages. These languages use words and symbols that are much easier for humans to understand, making it simpler to give instructions to computers.

The very first high-level programming language was called Plankalkül. It was made by Konrad Zuse between 1942 and 1945. The first high-level language that could be turned into computer code by a special program (a compiler) was created by Corrado Böhm in 1951. The first language sold for businesses was FORTRAN, which stands for FORmula TRANslation. It was developed in 1956 by a team at IBM led by John Backus.

How Programming Languages Began

Between 1842 and 1849, a brilliant mathematician named Ada Lovelace translated a paper about Charles Babbage's new machine, the Analytical Engine. She added her own notes, which included a detailed plan for how the machine could calculate special numbers called Bernoulli numbers. Many historians believe this was the world's first published computer program!

Machines like the Jacquard Loom (used for weaving patterns) and Charles Babbage's Difference Engine used punched cards. These cards told the machines what steps to perform. Early computer codes were very specific to their tasks. For example, Alonzo Church found a way to write down mathematical rules, and the Turing machine was a simple idea of how a machine could follow instructions on a tape.

The First Real Programming Languages

In the 1940s, the first modern computers that ran on electricity were built. These computers were slow and didn't have much memory. This meant programmers had to write code in a very basic language called assembly language. It took a lot of effort to program this way.

One of the first ideas for a high-level language was Plankalkül, created by Konrad Zuse for his Z1 computer between 1942 and 1945. However, it wasn't actually built at that time.

The first programming languages that truly worked to give instructions to a computer appeared in the early 1950s. John Mauchly's Short Code, suggested in 1949, was one of the first high-level languages for electronic computers. Unlike basic machine code, Short Code used understandable math expressions. But it had to be translated into machine code every time it ran, which made it slow.

In the early 1950s, Alick Glennie developed Autocode at the University of Manchester. This was likely the first programming language that used a compiler to turn its code into machine code. Later versions, like the "Mark 1 Autocode" and EDSAC 2 Autocode, improved on this idea, making programs run more efficiently.

In 1954, FORTRAN was invented at IBM by a team led by John Backus. It was the first widely used high-level language that actually worked, not just a design on paper. At first, people were unsure about FORTRAN because it had bugs and was slow to develop. But as computers got better, FORTRAN became known for being very fast. Today, it's still used for powerful computers and for testing the world's fastest supercomputers.

Another early language was FLOW-MATIC, created by Grace Hopper in the US between 1955 and 1959. Hopper noticed that business people didn't like using math symbols in their programs. So, she and her team designed a language that used English words. FLOW-MATIC was a big influence on the design of COBOL, another important business language.

Other languages still used today include LISP (1958), invented by John McCarthy, and COBOL (1959). A big step in the late 1950s was the creation of ALGOL 60. This language introduced new ideas:

• Nested blocks: You could group parts of code together without making them separate, named procedures.
• Lexical scoping: Blocks of code could have their own private variables and functions, hidden from other parts of the program.
• Formal description: A special math-like way called Backus–Naur form (BNF) was used to describe the language's rules. Almost all programming languages since then have used something similar to BNF.

ALGOL 60 was very important and influenced many later languages. Its ideas continued with ALGOL 68, which tried to be even more precise. However, ALGOL 68 was very complex, and some parts were hard to use. This led Niklaus Wirth to create the simpler Pascal language.

Logos

Fortran

Lisp

Simula

Here are some important languages developed during this time:

New Ways of Programming

Logos

Scheme

C

Smalltalk

From the late 1960s to the late 1970s, many new programming languages appeared. Most of the main ways of thinking about programming, called "paradigms," were invented during this time:

• Speakeasy (1964) was an early system for "object-oriented programming" (OOPS). It was like later math programs such as MATLAB.
• Simula (late 1960s) was the first language designed to support object-oriented programming. This is a way of organizing code around "objects" that contain both data and actions.
• FORTH (1969) was a unique language designed by Charles Moore.
• C (1969-1973) was developed by Dennis Ritchie and Ken Thompson at Bell Labs. It became very important for writing operating systems.
• Smalltalk (mid-1970s) was a complete new design for an object-oriented language.
• Prolog (1972) was the first "logic programming" language. It lets you program by stating facts and rules.
• ML (1973) was a "functional programming" language. It focused on using functions and had a smart way of checking for errors.

Each of these languages led to many others. Most modern languages have roots in at least one of them.

During the 1960s and 1970s, there was a big discussion about "structured programming." This basically meant programming without using the `goto` command, which jumps to different parts of the code. Many programmers believed that using `goto` was bad style. Some languages were even designed without `goto` to force programmers to use structured methods.

To make programs compile faster, some languages like Pascal were designed so that smaller parts of the program had to be defined before the main part.

Some notable languages developed in this period include:

The 1980s: Better Systems and Modules

Logos

MATLAB

Erlang

Tcl

C++

Perl

Wolfram

The 1980s were a time for making existing programming ideas better, rather than inventing many new ones. For example, C++ combined object-oriented programming with system programming. The US government created Ada for defense projects. In Japan, a lot of money was spent on "fifth-generation" languages that used logic programming.

An important new idea was focusing on "modules." These are large, organized parts of code that make it easier to build big programs. Languages like Modula, Ada, and ML all developed good module systems.

The 1980s also saw improvements in how programming languages were built. New computer designs, called RISC (reduced instruction set computer), helped compilers (programs that turn code into machine instructions) work even better. This made high-level languages more popular.

This trend of improving language technology continued into the 1990s.

Some notable languages developed in this period include:

The 1990s: The Internet Age

Logos

Haskell

Lua

PHP

Rebol

Python

Ruby

Delphi

The fast growth of the Internet in the mid-1990s was a huge event for programming languages. The Internet created a whole new place for computer systems, and new languages became very popular. For example, JavaScript became famous because it was built into the Netscape Navigator web browser. Other "scripting languages" like PHP also became widely used for making websites.

The 1990s didn't bring many totally new ideas for programming languages, but it was a time of combining and improving old ones. "Functional languages" started to spread more. A big goal was to help programmers work faster. Many "rapid application development" (RAD) languages appeared. These often came with special tools to help programmers, like integrated development environments (IDEs) and automatic "garbage collection" (which cleans up computer memory). These RAD languages were all object-oriented. Examples include Object Pascal, Visual Basic, and Java. Java got a lot of attention.

Even more new and different were the "scripting languages." These didn't come directly from older languages and had new rules and features. Many people thought scripting languages helped them build small programs even faster than RAD languages. Scripting languages became very important for the Web.

Some programming languages included other languages to save development time. For example, both Python and Ruby included Tcl to help with GUI (graphical user interface) programming through libraries like Tkinter.

Some notable languages developed in this period include:

What's Happening Now

Logos

D

Groovy

PowerShell

Rust

Scratch

Go

Dart

Swift

Kotlin

TypeScript

C#

Ring

Julia

Zig

Programming languages keep changing and getting better, both in companies and in research. Some of the latest trends include:

• More support for "functional programming" in popular languages. This makes code easier to understand and run multiple tasks at once.
• Tools to help with "concurrent" (doing many things at once) and "distributed" (spread across many computers) programming.
• Ways to make languages more secure and reliable.
• New methods for organizing and reusing code.
• "Metaprogramming," which means programs that can write or change other programs.
• More interest in "visual programming languages" like Scratch, where you drag and drop blocks of code.
• Languages for powerful graphics cards (GPUs) and supercomputers.
• Early research into languages for quantum computing.
• Using artificial intelligence (AI) to help generate code.

Many big tech companies have created their own programming languages to fit their needs and platforms. For example:

• Microsoft introduced C#, F#, TypeScript, and others.
• Google introduced Go, Dart, and Carbon.
• Apple introduced Swift.
• Meta introduced Hack.

Some notable languages developed recently and listed among the top 100 programming languages in February 2024 include:

Other new programming languages include Elm, Ballerina, Red, Crystal, Haxe, V (Vlang), Reason, and Mojo.

Key People in Programming Language History

Some Innovators

Dennis Ritchie

Niklaus Wirth

Grace M. Hopper

Bjarne Stroustrup

Anders Hejlsberg

Guido van Rossum

Yukihiro Matsumoto

James Gosling

Larry Wall

Here are some of the important people who helped create programming languages:

• Ada Lovelace: Published the world's first computer program.
• Alan Kay: A pioneer in object-oriented programming and creator of Smalltalk.
• Anders Hejlsberg: Developed Turbo Pascal, Delphi, C#, and TypeScript.
• Bjarne Stroustrup: Creator of C++.
• Brendan Eich: Developed JavaScript.
• Dennis Ritchie: Inventor of C.
• Grace Hopper: First to use the term "compiler" and developed FLOW-MATIC. She helped make programming languages easier to use and popularized the term "debugging" (finding and fixing errors).
• Guido van Rossum: Creator of Python.
• James Gosling: Lead developer of Java.
• John Backus: Inventor of Fortran.
• John McCarthy: Inventor of LISP.
• Konrad Zuse: Designed the first high-level programming language, Plankalkül.
• Kristen Nygaard: A pioneer in object-oriented programming, co-invented Simula.
• Larry Wall: Creator of the Perl programming language.
• Niklaus Wirth: Inventor of Pascal.
• Ole-Johan Dahl: A pioneer in object-oriented programming, co-invented Simula.
• Rasmus Lerdorf: Creator of PHP.
• Yukihiro Matsumoto: Creator of Ruby.

Images for kids

• 

  Dennis Ritchie

• 

  Niklaus Wirth

• 

  Grace M. Hopper

• 

  Bjarne Stroustrup

• 

  Anders Hejlsberg

• 

  Guido van Rossum

• 

  Yukihiro Matsumoto

• 

  James Gosling

• 

  Larry Wall

See also

In Spanish: Historia de los lenguajes de programación para niños