返回专栏
· 14 分钟阅读

编程语言的发展历史


一、为什么需要了解编程语言的发展历史?

编程语言并不是一开始就拥有今天这样的语法、类型系统和运行时环境。

早期计算机只能执行由 0 和 1 组成的机器指令,程序员需要直接面对硬件架构。随着计算机应用场景不断扩大,软件规模和复杂度持续增长,直接编写机器指令已经无法满足开发需求。

编程语言的发展,本质上是在解决几个长期存在的问题:

  1. 降低编程复杂度:减少开发人员对底层硬件细节的直接依赖。
  2. 提高开发效率:使用更接近人类思维的抽象表达程序逻辑。
  3. 提升程序可靠性:通过类型系统、模块化、内存管理等机制减少错误。
  4. 增强程序可移植性:降低程序对特定硬件和操作系统的依赖。
  5. 管理软件复杂度:支持大型软件系统的分层、模块化和协作开发。

理解这些背景,有助于理解为什么现代编程语言会出现不同的设计方向。


二、第一阶段:机器语言(1940 年代)

1. 什么是机器语言?

机器语言是计算机处理器能够直接识别和执行的指令集合。

它由二进制编码构成,不同的处理器架构拥有不同的机器指令集。

例如,一段抽象的机器指令可能表现为:

10110000 01100001

实际含义取决于处理器架构、指令集以及指令编码规则。

机器语言直接对应 CPU 的指令执行能力,是软件与硬件之间最底层的程序表达形式。

2. 机器语言的特点

  • 直接执行:CPU 可以直接解码和执行机器指令。
  • 硬件相关:不同 CPU 架构的机器指令通常不同。
  • 表达困难:程序员需要理解指令编码、寄存器和内存布局。
  • 维护成本高:程序逻辑难以阅读、修改和复用。
  • 开发效率低:即使简单的计算任务,也可能需要大量底层指令。

3. 为什么机器语言难以满足软件开发需求?

假设需要完成一个简单的整数加法:

result = a + b

在高级语言中,只需要一条表达式就可以描述。

但在机器语言中,开发人员必须考虑:

  • 数据存储在哪里;
  • 使用哪些寄存器;
  • 如何读取操作数;
  • 使用什么指令完成运算;
  • 如何保存计算结果;
  • 如何处理数据类型和溢出等问题。

开发人员需要同时处理业务逻辑和硬件执行细节。

随着程序规模扩大,这种方式很难继续使用。


三、第二阶段:汇编语言(1940 年代末至 1950 年代)

1. 汇编语言的出现

为了减少直接编写二进制机器指令的困难,汇编语言逐渐出现。

汇编语言使用助记符表示机器指令,让程序员可以使用更容易理解的文本形式编写底层程序。

例如:

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

这段代码表达了:

  1. 将数值 10 放入 AX 寄存器;
  2. 将数值 20 放入 BX 寄存器;
  3. 将两个寄存器中的数值相加,结果保存到 AX。

这里的指令形式是 x86 风格的示例,不同处理器架构的汇编语法和指令集存在差异。

2. 汇编语言如何工作?

汇编语言不能直接被 CPU 执行,需要通过汇编器转换为机器指令。

flowchart TD
    A["编写汇编源代码"] --> B["汇编器"]
    B --> C["生成机器指令"]
    C --> D["加载到内存"]
    D --> E["CPU 执行"]

    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. 汇编语言带来了什么改变?

与机器语言相比,汇编语言有几个重要改进:

  • 使用助记符代替二进制指令编码。
  • 使用标签表示程序中的位置。
  • 支持符号化的变量和地址表达。
  • 通过宏等机制减少重复代码。
  • 提高底层程序的可读性和编写效率。

但汇编语言仍然高度依赖硬件。

例如,x86 汇编程序通常不能直接在 ARM 处理器上运行。不同架构的寄存器、指令集、寻址方式都可能不同。

4. 汇编语言的历史意义

汇编语言是编程抽象发展中的重要一步。

它并没有改变计算机的底层执行机制,而是改变了程序员描述指令的方式。

这是编程语言发展过程中的一个重要思想:

通过更高层次的表达方式,降低人类理解和控制计算机的成本。


四、第三阶段:高级编程语言的诞生(1950 年代)

1. 为什么需要高级语言?

汇编语言虽然比机器语言容易使用,但程序员仍然需要直接面对寄存器、内存地址和处理器指令。

随着科学计算、商业管理和工程应用的发展,计算机程序需要表达越来越复杂的逻辑。

开发人员开始希望使用更加接近数学表达和人类思维的方式编写程序。

高级编程语言由此发展起来。

高级语言通常提供:

  • 变量和数据类型;
  • 表达式和运算符;
  • 条件判断;
  • 循环结构;
  • 函数和过程;
  • 数据结构;
  • 更高层次的程序抽象。

例如:

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

程序员不再需要直接指定使用哪个寄存器完成加法。

编译器负责将高级语言转换为目标机器能够执行的形式。

2. 早期重要高级语言

FORTRAN(1957 年)

FORTRAN 是早期具有重要影响力的高级编程语言,由 IBM 团队开发。

它的名称来自 Formula Translation,主要面向科学计算和数值计算。

典型应用包括:

  • 数值分析;
  • 工程计算;
  • 科学模拟;
  • 高性能计算。

FORTRAN 的重要贡献在于证明了高级语言能够有效支持复杂的科学计算任务,同时保持较高的执行效率。

LISP(1958 年)

LISP 由 John McCarthy 提出,是人工智能和符号计算领域的重要早期语言。

它的核心特点包括:

  • 基于符号表达式;
  • 以列表作为重要的数据结构;
  • 支持递归;
  • 支持函数作为数据;
  • 具有较强的元编程能力。

LISP 对函数式编程、符号计算和人工智能研究产生了深远影响。

COBOL(1959 年)

COBOL 是面向商业数据处理的编程语言。

它强调接近英语的语法表达,主要应用于:

  • 企业业务系统;
  • 财务管理;
  • 银行系统;
  • 大规模事务处理。

COBOL 在商业计算领域具有长期影响,至今仍存在于部分关键业务系统中。

ALGOL(1958—1960 年代)

ALGOL 是算法描述和程序语言设计史上的重要语言家族。

它对后续语言的影响包括:

  • 块结构;
  • 词法作用域相关思想;
  • 结构化程序设计;
  • 形式化语法描述。

ALGOL 的设计思想影响了 Pascal、C 等后续语言的发展。

3. 高级语言的核心变化

高级语言最重要的贡献,并不只是语法更容易阅读,而是引入了更强的抽象能力。

例如,程序员可以直接描述:

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

而不需要手动编写循环所需的底层跳转指令。

高级语言将程序员的关注点从硬件执行细节逐步转移到算法、数据和业务逻辑上。


五、第四阶段:结构化编程与系统编程语言(1960—1970 年代)

随着软件规模不断扩大,早期程序设计中大量使用跳转语句的方式逐渐暴露出问题。

程序逻辑复杂、控制流难以追踪,代码维护成本越来越高。

这一时期,编程语言开始更加重视程序结构、模块化和底层资源控制。

1. 结构化程序设计

结构化程序设计强调使用清晰的控制结构组织程序。

其核心结构通常包括:

  • 顺序结构;
  • 选择结构;
  • 循环结构。

例如:

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

结构化程序设计降低了程序控制流的复杂度,使程序更容易理解、测试和维护。

2. Pascal(1970 年)

Pascal 由 Niklaus Wirth 设计,强调结构化程序设计和良好的语言教学价值。

它的重要特点包括:

  • 严格的数据类型;
  • 清晰的程序结构;
  • 过程和函数;
  • 用户自定义数据类型;
  • 对结构化程序设计的支持。

Pascal 对早期计算机教育和程序设计方法产生了重要影响。

3. C 语言(1972 年)

C 语言由 Dennis Ritchie 在贝尔实验室开发,与 Unix 操作系统的发展密切相关。

C 语言兼具较高层次的表达能力和较强的底层控制能力。

核心特点包括:

  • 静态类型;
  • 指针;
  • 手动内存管理;
  • 结构体;
  • 函数;
  • 接近硬件的内存操作能力;
  • 编译后通常具有较高的执行效率。

C 语言的重要意义在于,它为系统软件开发提供了一种兼顾可移植性与底层控制能力的语言。

典型应用包括:

  • 操作系统;
  • 编译器;
  • 嵌入式系统;
  • 驱动程序;
  • 网络协议实现;
  • 数据库底层组件。

4. C 语言为什么影响如此深远?

C 语言并不是最早出现的高级语言,但它在系统软件领域建立了非常重要的生态。

其影响主要体现在:

  1. Unix 操作系统的大量代码使用 C 语言编写。
  2. C 语言形成了相对稳定的语言标准和编译器生态。
  3. 后续大量语言借鉴了 C 风格语法。
  4. C 语言推动了操作系统、编译器和底层软件的可移植开发。

C 语言的出现,使高级语言不再只是面向业务逻辑或科学计算,也能够承担大量底层系统开发任务。


六、第五阶段:面向对象编程兴起(1960—1990 年代)

随着软件系统越来越复杂,仅依赖函数和过程组织代码,逐渐难以满足大型软件的维护需求。

面向对象编程(Object-Oriented Programming,OOP)由此成为重要的程序设计思想。

1. 面向对象思想的出现

面向对象思想强调将数据和操作数据的行为组织在一起。

它试图从对象及其关系的角度描述复杂系统。

面向对象编程的核心概念包括:

  • 封装:将数据和操作数据的方法组织在一起,控制内部实现细节。
  • 继承:通过类型层次复用和扩展已有类型的行为。
  • 多态:允许不同类型通过统一接口提供不同实现。
  • 抽象:提取对象和系统中稳定、重要的特征。

2. Smalltalk(1970 年代)

Smalltalk 是面向对象编程历史上的重要语言。

它强调对象、消息传递和动态交互,对后来的面向对象语言及图形用户界面设计产生了重要影响。

Smalltalk 的设计理念之一是:程序运行时由相互交互的对象组成。

3. C++(1980 年代)

C++ 由 Bjarne Stroustrup 在 C 语言基础上发展而来。

它在保留 C 语言底层控制能力的同时,引入了面向对象、泛型编程等能力。

核心特性包括:

  • 类与对象;
  • 继承与多态;
  • 模板;
  • 运算符重载;
  • RAII;
  • 异常处理;
  • 资源生命周期管理。

C++ 逐渐成为高性能系统开发的重要语言。

典型应用包括:

  • 游戏引擎;
  • 浏览器内核;
  • 数据库;
  • 操作系统组件;
  • 图形渲染;
  • 高性能计算。

4. Java(1995 年)

Java 由 Sun Microsystems 推出,最初的设计目标与跨平台软件开发密切相关。

Java 的重要设计思想包括:

  • 面向对象;
  • 静态类型;
  • 自动内存管理;
  • 字节码;
  • 虚拟机;
  • 跨平台运行。

Java 程序通常先编译为字节码,再由 Java 虚拟机(JVM)执行。

flowchart TD
    A["Java 源代码"] --> B["Java 编译器 javac"]
    B --> C["字节码 Class 文件"]
    C --> D["Java 虚拟机 JVM"]
    D --> E["解释执行或 JIT 编译"]
    E --> F["处理器执行机器指令"]

    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 的重要贡献,是将虚拟机、字节码和运行时环境结合起来,形成成熟的跨平台开发体系。

5. 面向对象编程的影响

面向对象编程推动了软件工程从过程组织向对象和模块组织的发展。

但需要注意:

面向对象编程是一种程序设计范式,并不等同于某一种编程语言。

C++、Java、Python、C# 等语言都支持不同程度的面向对象编程,但它们的对象模型和类型系统并不相同。


七、第六阶段:脚本语言与动态语言发展(1990 年代)

随着互联网、桌面应用和自动化需求的发展,编程语言开始更加重视开发效率、动态表达能力和快速迭代。

脚本语言和动态语言在这一时期得到广泛应用。

1. Python(1991 年)

Python 由 Guido van Rossum 创建。

它强调代码可读性和开发效率,提供了简洁的语法以及丰富的标准库。

主要特点:

  • 动态类型;
  • 自动内存管理;
  • 多范式编程;
  • 丰富的第三方库;
  • 解释执行与字节码机制;
  • 强大的生态系统。

Python 的应用领域包括:

  • Web 开发;
  • 自动化运维;
  • 数据分析;
  • 科学计算;
  • 人工智能;
  • 机器学习。

Python 的发展说明,开发效率和生态系统可以成为编程语言竞争力的重要组成部分。

2. JavaScript(1995 年)

JavaScript 最初由 Brendan Eich 在 Netscape 开发,最早用于浏览器端交互。

随着 Web 技术的发展,JavaScript 逐渐成为 Web 前端开发的核心语言。

其主要特点包括:

  • 动态类型;
  • 函数是一等公民;
  • 原型继承;
  • 事件驱动;
  • 异步编程;
  • 支持多种编程范式。

后来,Node.js 的出现使 JavaScript 进入服务端开发领域。

JavaScript 的发展使一种语言能够覆盖浏览器、服务端和部分桌面、移动端开发场景。

3. PHP(1995 年)

PHP 最初面向动态网页开发,后来逐渐发展为通用服务端脚本语言。

它在早期 Web 开发和内容管理系统领域具有重要影响。

典型应用包括:

  • 动态网站;
  • Web 后端;
  • 内容管理系统;
  • 电商系统。

4. Ruby(1995 年)

Ruby 由 Yukihiro Matsumoto 设计。

它强调开发者体验、面向对象和表达能力。

Ruby on Rails 框架进一步推动了 Ruby 在 Web 应用开发中的应用。

5. 动态语言的主要价值

动态语言通常在运行时处理更多类型信息和对象行为,减少了部分开发阶段的显式声明。

它们在快速开发、脚本自动化和应用层开发中具有明显优势。

但动态语言并不意味着没有类型系统,也不意味着完全不需要类型检查。

例如,Python 和 JavaScript 都有明确的类型规则,只是许多类型检查发生在运行时。


八、第七阶段:企业级语言与虚拟机生态成熟(2000 年代)

进入 2000 年代,企业软件、互联网服务和大型分布式系统迅速发展。

编程语言开始更加关注工程化、运行时性能、开发效率和生态系统。

1. C#(2000 年)

C# 由 Microsoft 推出,是 .NET 平台的重要语言。

它吸收了 C++、Java 等语言的部分设计思想,并提供现代化的语言特性。

核心特点包括:

  • 静态类型;
  • 面向对象;
  • 泛型;
  • 委托与事件;
  • LINQ;
  • 异步编程;
  • 自动内存管理;
  • .NET 运行时支持。

C# 广泛应用于:

  • 企业应用;
  • Web 后端;
  • Windows 桌面软件;
  • 游戏开发;
  • 云服务。

2. Scala(2004 年)

Scala 将面向对象编程和函数式编程结合起来,并运行在 JVM 上。

它的重要特性包括:

  • 静态类型;
  • 类型推断;
  • 高阶函数;
  • 模式匹配;
  • 不可变数据结构;
  • 面向对象与函数式编程结合。

Scala 在数据处理、分布式计算和 JVM 生态中具有一定影响力。

3. Go(2009 年)

Go 由 Google 开发,强调简单性、编译效率和并发编程能力。

其核心特点包括:

  • 静态类型;
  • 编译型;
  • 垃圾回收;
  • Goroutine;
  • Channel;
  • 接口;
  • 简洁的语言设计。

Go 的并发模型降低了开发并发服务的复杂度。

典型应用包括:

  • 云原生基础设施;
  • 微服务;
  • 网络服务;
  • 容器平台;
  • DevOps 工具。

4. 这一阶段的核心变化

这一时期的语言设计更加关注完整的工程体系。

语言本身不再是唯一的竞争点,编译器、虚拟机、标准库、构建工具、包管理器和开发框架共同决定了开发体验。


九、第八阶段:安全性、类型系统与现代系统语言(2010 年代)

随着软件系统规模扩大,内存安全、并发安全和代码可靠性成为重要问题。

现代编程语言开始更加重视在语言层面减少程序错误。

1. Rust(2010 年代)

Rust 是一种强调内存安全和性能的系统编程语言。

它的重要设计包括:

  • 所有权(Ownership);
  • 借用(Borrowing);
  • 生命周期(Lifetime);
  • 模式匹配;
  • 强大的类型系统;
  • 零成本抽象;
  • 无需传统垃圾回收器的内存管理机制。

Rust 的所有权系统在编译阶段检查资源使用规则,帮助避免大量内存安全问题。

例如:

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

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