Back to series
· 10 min read

The History of Programming Languages


1. Why Do We Need to Understand the History of Programming Languages?

Programming languages did not start out with the syntax, type systems, and runtime environments they have today.

Early computers could only execute machine instructions composed of 0s and 1s, and programmers had to work directly with the hardware architecture. As computer applications kept expanding and software grew larger and more complex, writing machine instructions directly could no longer meet development needs.

The development of programming languages has essentially been about solving several long-standing problems:

  1. Reducing programming complexity: lessening developers' direct dependence on low-level hardware details.
  2. Improving development efficiency: expressing program logic through abstractions closer to human thought.
  3. Enhancing program reliability: reducing errors through type systems, modularization, memory management, and other mechanisms.
  4. Increasing program portability: reducing a program's dependence on specific hardware and operating systems.
  5. Managing software complexity: supporting layered, modular, and collaborative development of large software systems.

Understanding this background helps explain why modern programming languages have taken different design directions.


2. The First Stage: Machine Language (1940s)

1. What Is Machine Language?

Machine language is the set of instructions that a computer processor can directly recognize and execute.

It consists of binary encodings, and different processor architectures have different machine instruction sets.

For example, an abstract machine instruction might look like this:

10110000 01100001

Its actual meaning depends on the processor architecture, the instruction set, and the instruction encoding rules.

Machine language corresponds directly to the CPU's instruction execution capability and is the lowest-level form of program expression between software and hardware.

2. Characteristics of Machine Language

  • Direct execution: the CPU can directly decode and execute machine instructions.
  • Hardware-dependent: machine instructions usually differ across CPU architectures.
  • Difficult to express: programmers need to understand instruction encoding, registers, and memory layout.
  • High maintenance cost: program logic is hard to read, modify, and reuse.
  • Low development efficiency: even simple computational tasks may require a large number of low-level instructions.

3. Why Is Machine Language Hard-Pressed to Meet Software Development Needs?

Suppose you need to perform a simple integer addition:

result = a + b

In a high-level language, a single expression is enough to describe it.

But in machine language, developers must consider:

  • where the data is stored;
  • which registers to use;
  • how to read the operands;
  • which instructions to use to perform the operation;
  • how to save the computation result;
  • how to handle issues such as data types and overflow.

Developers have to deal with business logic and hardware execution details at the same time.

As programs grow larger, this approach becomes very difficult to sustain.


3. The Second Stage: Assembly Language (Late 1940s to 1950s)

1. The Emergence of Assembly Language

To reduce the difficulty of writing binary machine instructions directly, assembly language gradually emerged.

Assembly language uses mnemonics to represent machine instructions, allowing programmers to write low-level programs in a more understandable textual form.

For example:

MOV AX, 10
MOV BX, 20
ADD AX, BX

This code expresses:

  1. Put the value 10 into the AX register;
  2. Put the value 20 into the BX register;
  3. Add the values in the two registers and store the result in AX.

The instruction form here is an x86-style example; assembly syntax and instruction sets differ across processor architectures.

2. How Does Assembly Language Work?

Assembly language cannot be executed directly by the CPU; it must be converted into machine instructions by an assembler.

flowchart TD
    A["Write assembly source code"] --> B["Assembler"]
    B --> C["Generate machine instructions"]
    C --> D["Load into memory"]
    D --> E["CPU executes"]

    style A fill:#E8F1FF,stroke:#3973C6,color:#1D3557
    style B fill:#EAF7EF,stroke:#3A9560,color:#245B3A
    style C fill:#FFF4DF,stroke:#C58A28,color:#765015
    style D fill:#F1EAFE,stroke:#8055B5,color:#49316D
    style E fill:#E8F1FF,stroke:#3973C6,color:#1D3557

3. What Changes Did Assembly Language Bring?

Compared with machine language, assembly language offered several important improvements:

  • Using mnemonics instead of binary instruction encodings.
  • Using labels to represent positions in the program.
  • Supporting symbolic variables and address expressions.
  • Reducing duplicated code through mechanisms such as macros.
  • Improving the readability and writing efficiency of low-level programs.

But assembly language is still highly hardware-dependent.

For example, an x86 assembly program usually cannot run directly on an ARM processor. Different architectures may have different registers, instruction sets, and addressing modes.

4. The Historical Significance of Assembly Language

Assembly language was an important step in the development of programming abstraction.

It did not change the underlying execution mechanism of computers; rather, it changed the way programmers described instructions.

This is an important idea in the development of programming languages:

Reduce the cost for humans to understand and control computers through higher-level forms of expression.


4. The Third Stage: The Birth of High-Level Programming Languages (1950s)

1. Why Are High-Level Languages Needed?

Although assembly language is easier to use than machine language, programmers still have to deal directly with registers, memory addresses, and processor instructions.

With the development of scientific computing, business management, and engineering applications, computer programs needed to express increasingly complex logic.

Developers began to want to write programs in ways closer to mathematical expression and human thinking.

High-level programming languages developed from this.

High-level languages typically provide:

  • Variables and data types;
  • Expressions and operators;
  • Conditional statements;
  • Loop structures;
  • Functions and procedures;
  • Data structures;
  • Higher-level program abstraction.

For example:

int a = 10;
int b = 20;
int result = a + b;

Programmers no longer need to directly specify which register should be used to perform the addition.

The compiler is responsible for translating the high-level language into a form the target machine can execute.

2. Early Important High-Level Languages

FORTRAN (1957)

FORTRAN was an early high-level programming language with significant influence, developed by a team at IBM.

Its name comes from Formula Translation, and it was mainly aimed at scientific computing and numerical computation.

Typical applications include:

  • Numerical analysis;
  • Engineering computation;
  • Scientific simulation;
  • High-performance computing.

FORTRAN's important contribution was proving that high-level languages could effectively support complex scientific computing tasks while maintaining relatively high execution efficiency.

LISP (1958)

LISP was proposed by John McCarthy and was an important early language in the fields of artificial intelligence and symbolic computation.

Its core features include:

  • Based on symbolic expressions;
  • Uses lists as an important data structure;
  • Supports recursion;
  • Supports functions as data;
  • Has strong metaprogramming capabilities.

LISP had a profound influence on functional programming, symbolic computation, and artificial intelligence research.

COBOL (1959)

COBOL is a programming language oriented toward commercial data processing.

It emphasizes syntax close to English, and is mainly used in:

  • Enterprise business systems;
  • Financial management;
  • Banking systems;
  • Large-scale transaction processing.

COBOL has had a long-lasting influence in the field of commercial computing and still exists in some mission-critical business systems today.

ALGOL (1958–1960s)

ALGOL is an important language family in the history of algorithm description and programming language design.

Its influence on subsequent languages includes:

  • Block structure;
  • Ideas related to lexical scoping;
  • Structured programming;
  • Formal syntax description.

ALGOL's design ideas influenced the development of later languages such as Pascal and C.

3. The Core Changes Brought by High-Level Languages

The most important contribution of high-level languages is not merely more readable syntax, but the introduction of stronger abstraction capabilities.

For example, programmers can directly describe:

for i in range(10):
    print(i)

without needing to manually write the low-level jump instructions required for a loop.

High-level languages gradually shifted programmers' focus from hardware execution details to algorithms, data, and business logic.


V. The Fourth Stage: Structured Programming and Systems Programming Languages (1960s–1970s)

As software grew continuously in scale, the heavy use of jump statements in early program design gradually exposed problems.

Program logic became complex, control flow was difficult to trace, and code maintenance costs grew ever higher.

During this period, programming languages began to place greater emphasis on program structure, modularity, and low-level resource control.

1. Structured Programming

Structured programming emphasizes organizing programs using clear control structures.

Its core structures typically include:

  • Sequential structure;
  • Selection structure;
  • Loop structure.

For example:

if (score >= 60) {
    printf("Pass");
} else {
    printf("Fail");
}

Structured programming reduced the complexity of program control flow, making programs easier to understand, test, and maintain.

2. Pascal (1970)

Pascal was designed by Niklaus Wirth, emphasizing structured programming and strong pedagogical value for language teaching.

Its important features include:

  • Strict data types;
  • Clear program structure;
  • Procedures and functions;
  • User-defined data types;
  • Support for structured programming.

Pascal had a significant influence on early computer education and programming methodology.

3. The C Language (1972)

The C language was developed by Dennis Ritchie at Bell Labs and is closely tied to the development of the Unix operating system.

C combines a relatively high level of expressive power with strong low-level control capabilities.

Core features include:

  • Static typing;
  • Pointers;
  • Manual memory management;
  • Structs;
  • Functions;
  • Memory operation capabilities close to hardware;
  • Typically high execution efficiency after compilation.

The significance of C lies in providing a language for systems software development that balances portability with low-level control.

Typical applications include:

  • Operating systems;
  • Compilers;
  • Embedded systems;
  • Drivers;
  • Network protocol implementations;
  • Low-level database components.

4. Why Has C Had Such a Far-Reaching Influence?

C was not the earliest high-level language, but it established a very important ecosystem in the field of systems software.

Its influence is mainly reflected in:

  1. A large amount of Unix operating system code was written in C.
  2. C developed a relatively stable language standard and compiler ecosystem.
  3. A large number of subsequent languages borrowed C-style syntax.
  4. C promoted portable development of operating systems, compilers, and low-level software.

The emergence of C meant that high-level languages were no longer limited to business logic or scientific computing, but could also take on a large number of low-level systems development tasks.


VI. The Fifth Stage: The Rise of Object-Oriented Programming (1960s–1990s)

As software systems became increasingly complex, relying solely on functions and procedures to organize code gradually became insufficient to meet the maintenance needs of large-scale software.

Object-Oriented Programming (OOP) thus became an important program design philosophy.

1. The Emergence of Object-Oriented Thinking

Object-oriented thinking emphasizes organizing data together with the behavior that operates on that data.

It attempts to describe complex systems from the perspective of objects and their relationships.

The core concepts of object-oriented programming include:

  • Encapsulation: Organizing data and the methods that operate on it together, while controlling internal implementation details.
  • Inheritance: Reusing and extending the behavior of existing types through type hierarchies.
  • Polymorphism: Allowing different types to provide different implementations through a unified interface.
  • Abstraction: Extracting the stable and important characteristics of objects and systems.

2. Smalltalk (1970s)

Smalltalk is an important language in the history of object-oriented programming.

It emphasized objects, message passing, and dynamic interaction, and had a major influence on later object-oriented languages and graphical user interface design.

One of Smalltalk's design ideas is that a running program consists of objects interacting with one another.

3. C++ (1980s)

C++ was developed by Bjarne Stroustrup on the basis of the C language.

While retaining C's low-level control capabilities, it introduced object-oriented programming, generic programming, and other capabilities.

Core features include:

  • Classes and objects;
  • Inheritance and polymorphism;
  • Templates;
  • Operator overloading;
  • RAII;
  • Exception handling;
  • Resource lifetime management.

C++ gradually became an important language for high-performance systems development.

Typical applications include:

  • Game engines;
  • Browser engines;
  • Databases;
  • Operating system components;
  • Graphics rendering;
  • High-performance computing.

4. Java (1995)

Java was introduced by Sun Microsystems, and its original design goals were closely tied to cross-platform software development.

Important design ideas of Java include:

  • Object-oriented;
  • Static typing;
  • Automatic memory management;
  • Bytecode;
  • Virtual machine;
  • Cross-platform execution.

Java programs are usually first compiled to bytecode and then executed by the Java Virtual Machine (JVM).

flowchart TD
    A["Java source code"] --> B["Java compiler javac"]
    B --> C["Bytecode Class file"]
    C --> D["Java Virtual Machine JVM"]
    D --> E["Interpreted execution or JIT compilation"]
    E --> F["Processor executes machine instructions"]

    style A fill:#E8F1FF,stroke:#3973C6,color:#1D3557
    style B fill:#EAF7EF,stroke:#3A9560,color:#245B3A
    style C fill:#FFF4DF,stroke:#C58A28,color:#765015
    style D fill:#F1EAFE,stroke:#8055B5,color:#49316D
    style E fill:#EAF7EF,stroke:#3A9560,color:#245B3A
    style F fill:#E8F1FF,stroke:#3973C6,color:#1D3557

Java's important contribution was combining the virtual machine, bytecode, and runtime environment into a mature cross-platform development system.

5. The Impact of Object-Oriented Programming

Object-oriented programming drove software engineering to develop from process organization toward object and module organization.

But note:

Object-oriented programming is a programming paradigm and is not equivalent to any particular programming language.

Languages such as C++, Java, Python, and C# all support object-oriented programming to varying degrees, but their object models and type systems are not the same.


VII. The Sixth Stage: The Development of Scripting and Dynamic Languages (1990s)

With the growth of the internet, desktop applications, and automation needs, programming languages began to place greater emphasis on development efficiency, dynamic expressiveness, and rapid iteration.

Scripting languages and dynamic languages became widely used during this period.

1. Python (1991)

Python was created by Guido van Rossum.

It emphasizes code readability and development efficiency, and provides concise syntax along with a rich standard library.

Main features:

  • Dynamic typing;
  • Automatic memory management;
  • Multi-paradigm programming;
  • A rich ecosystem of third-party libraries;
  • Interpreted execution and a bytecode mechanism;
  • A powerful ecosystem.

Python's application areas include:

  • Web development;
  • Automated operations;
  • Data analysis;
  • Scientific computing;
  • Artificial intelligence;
  • Machine learning.

Python's development shows that development efficiency and ecosystem can become important components of a programming language's competitiveness.

2. JavaScript (1995)

JavaScript was originally developed by Brendan Eich at Netscape and was first used for browser-side interaction.

As web technology developed, JavaScript gradually became the core language of web front-end development.

Its main features include:

  • Dynamic typing;
  • Functions as first-class citizens;
  • Prototypal inheritance;
  • Event-driven;
  • Asynchronous programming;
  • Support for multiple programming paradigms.

Later, the arrival of Node.js brought JavaScript into the field of server-side development.

JavaScript's development enabled a single language to cover browsers, servers, and some desktop and mobile development scenarios.

3. PHP (1995)

PHP was initially aimed at dynamic web page development and later gradually evolved into a general-purpose server-side scripting language.

It had a significant influence in early web development and the content management system space.

Typical applications include:

  • Dynamic websites;
  • Web backend;
  • Content management systems;
  • E-commerce systems.

4. Ruby (1995)

Ruby was designed by Yukihiro Matsumoto.

It emphasizes developer experience, object orientation, and expressiveness.

The Ruby on Rails framework further promoted Ruby's use in web application development.

5. Main Value of Dynamic Languages

Dynamic languages generally handle more type information and object behavior at runtime, reducing explicit declarations in some development phases.

They have clear advantages in rapid development, script automation, and application-layer development.

However, dynamic languages do not mean the absence of a type system, nor do they mean that type checking is completely unnecessary.

For example, Python and JavaScript both have clear type rules; it is just that many type checks occur at runtime.


VIII. Seventh Stage: Maturation of Enterprise-Level Languages and Virtual Machine Ecosystems (2000s)

Entering the 2000s, enterprise software, internet services, and large-scale distributed systems developed rapidly.

Programming languages began to focus more on engineering, runtime performance, development efficiency, and ecosystems.

1. C# (2000)

C# was introduced by Microsoft and is an important language on the .NET platform.

It absorbed some design ideas from languages such as C++ and Java and provides modern language features.

Core features include:

  • Static typing;
  • Object-oriented;
  • Generics;
  • Delegates and events;
  • LINQ;
  • Asynchronous programming;
  • Automatic memory management;
  • .NET runtime support.

C# is widely used in:

  • Enterprise applications;
  • Web backend;
  • Windows desktop software;
  • Game development;
  • Cloud services.

2. Scala (2004)

Scala combines object-oriented programming and functional programming and runs on the JVM.

Its important features include:

  • Static typing;
  • Type inference;
  • Higher-order functions;
  • Pattern matching;
  • Immutable data structures;
  • Combination of object-oriented and functional programming.

Scala has some influence in data processing, distributed computing, and the JVM ecosystem.

3. Go (2009)

Go was developed by Google and emphasizes simplicity, compilation efficiency, and concurrent programming capabilities.

Its core features include:

  • Static typing;
  • Compiled;
  • Garbage collection;
  • Goroutine;
  • Channel;
  • Interfaces;
  • Concise language design.

Go's concurrency model reduces the complexity of developing concurrent services.

Typical applications include:

  • Cloud-native infrastructure;
  • Microservices;
  • Network services;
  • Container platforms;
  • DevOps tools.

4. Core Changes in This Stage

Language design in this period focused more on a complete engineering system.

The language itself was no longer the only point of competition; compilers, virtual machines, standard libraries, build tools, package managers, and development frameworks jointly determined the development experience.


IX. Eighth Stage: Safety, Type Systems, and Modern Systems Languages (2010s)

As software systems expanded in scale, memory safety, concurrency safety, and code reliability became important issues.

Modern programming languages began to place greater emphasis on reducing program errors at the language level.

1. Rust (2010s)

Rust is a systems programming language that emphasizes memory safety and performance.

Its important designs include:

  • Ownership;
  • Borrowing;
  • Lifetime;
  • Pattern matching;
  • Powerful type system;
  • Zero-cost abstractions;
  • Memory management without a traditional garbage collector.

Rust's ownership system checks resource usage rules at compile time, helping avoid many memory safety issues.

For example:

fn main() {
    let s = String::from("hello");
    let r = &s;

    println!("{}", r);
}