面向对象编程简史

注：本文为 “面向对象编程简史” 相关文章合辑。

英文引文，机翻未校。

Brief history of Object-Oriented Programming

面向对象编程简史

Tue, May 14, 2024

Throughout its history, object-oriented programming (OOP) has undergone significant evolution. From its early concepts to becoming one of the most popular and widely used methodologies in the computer industry.
纵观其历史，面向对象编程 （OOP） 经历了重大发展。从早期的概念到成为计算机行业最流行和广泛使用的方法之一。

We couldn’t do a course on object-oriented programming without at least briefly looking at its history. As well as acknowledging the people involved in its development.
如果不简要地了解一下面向对象编程的历史，我们就无法开设面向对象编程的课程。以及感谢参与其发展的人。

Origins of Object-Oriented Programming

面向对象编程的起源

1960s

1960 年代

The first concepts related to object-oriented programming began to emerge in the 1960s with the creation of the Simula language.
与面向对象编程相关的第一个概念在 1960 年代随着 Simula 语言的创建而开始出现。

Developed by Ole-Johan Dahl and Kristen Nygaard at the Norwegian Computing Center (Norsk Regnesentral), Simula was originally created for performing simulations.
Simula 由挪威计算中心 （Norsk Regnesentral） 的 Ole-Johan Dahl 和 Kristen Nygaard 开发，最初是为执行仿真而创建的。

Simula 67 was the version of Simula that introduced concepts such as classes, objects, and inheritance. Although it was not known by the name “object-oriented” at that time, these fundamental concepts laid the groundwork for future developments.
Simula 67 是 Simula 的版本，它引入了类、对象和继承等概念。虽然当时还没有 “面向对象 ”这个名字，但这些基本概念为未来的发展奠定了基础。

1970s

1970 年代

In the 1970s, Alan Kay, a researcher at Xerox PARC, coined the term “object-oriented” to describe a programming approach based on the simulation of biological systems. Kay developed the Smalltalk programming language, which became a significant influence on the later development of object-oriented programming.
在 1970 年代，Xerox PARC 的研究员 Alan Kay 创造了“面向对象”一词来描述基于生物系统模拟的编程方法。Kay 开发了 Smalltalk 编程语言，该语言对后来面向对象编程的发展产生了重大影响。

Smalltalk was the first programming language to fully implement the object-oriented paradigm as we know it today. Smalltalk introduced a series of revolutionary ideas, including message sending between objects, encapsulation, and dynamic inheritance.
Smalltalk 是第一个完全实现我们今天所知道的面向对象范式的编程语言。Smalltalk 引入了一系列革命性的思想，包括对象之间的消息发送、封装和动态继承。

Evolution and Popularization

进化与普及

1980s

1980 年代

The 1980s witnessed the growth and popularization of object-oriented programming. Bjarne Stroustrup at AT&T Bell Labs developed C++, a language that evolved from C with the addition of object-oriented features.
1980 年代见证了面向对象编程的增长和普及。AT&T 贝尔实验室的 Bjarne Stroustrup 开发了 C++，这是一种从 C 演变而来的语言，增加了面向对象的功能。

C++ incorporated classes and objects, as well as constructors, destructors, and operator overloading. Its compatibility with C and its ability to handle both low-level and high-level programming made C++ a popular language in the software industry.
C++ 合并了类和对象，以及构造函数、析构函数和运算符重载。它与 C 的兼容性以及处理低级和高级编程的能力使 C++ 成为软件行业的流行语言。

In the same decade, Brad Cox and Tom Love developed Objective-C, combining the object-oriented capabilities of Smalltalk with the C programming language. Objective-C became the main language for software development on Apple platforms for many years.
在同一十年中，Brad Cox 和 Tom Love 开发了 Objective-C，将 Smalltalk 的面向对象功能与 C 编程语言相结合。多年来，Objective-C 成为 Apple 平台上软件开发的主要语言。

Many other languages went on to adopt the object-oriented programming paradigm. For example, Ada, initially developed by the U.S. Department of Defense, also incorporated object-oriented features in its 1995 revision (Ada 95).
许多其他语言继续采用面向对象的编程范式。例如，最初由美国国防部开发的 Ada 在其 1995 年修订版 （Ada 95） 中也加入了面向对象的功能。

1990s

1990 年代

In the 1990s, Java became one of the most influential programming languages in the realm of object-oriented programming. Developed by Sun Microsystems (now part of Oracle) and designed by James Gosling and his team, Java combined the syntax of C++ with an object-oriented architecture.
在 1990 年代，Java 成为面向对象编程领域最具影响力的编程语言之一。Java 由 Sun Microsystems（现在是 Oracle 的一部分）开发，由 James Gosling 和他的团队设计，将 C++ 的语法与面向对象的体系结构相结合。

From the same era emerged Python, a language that has currently gained significant popularity, created by Guido van Rossum. Although it was not originally designed as a pure object-oriented programming language, it did include the concept from its earliest versions. Over time, it has evolved to enhance OOP support, adapted to its own needs.
从同一时代出现了 Python，这是一种目前广受欢迎的语言，由 Guido van Rossum 创建。尽管它最初不是作为纯粹的面向对象的编程语言设计的，但它确实包含了最早版本的概念。随着时间的推移，它已经发展到增强 OOP 支持，以适应自己的需求。

Modernity

现代

2000s

2000 年代

C# (❤️), developed by Microsoft as part of its .NET platform, was released in the early 2000s. Influenced by C++ and, very strongly by JavaScript, C# has been adopted as the main language for development on the .NET platform, including desktop, web, and mobile applications.
C# （） ❤️ 由 Microsoft 开发，作为其 .NET 平台的一部分，于 2000 年代初发布。受 C++ 和 JavaScript 的强烈影响，C# 已被用作 .NET 平台（包括桌面、Web 和移动应用程序）上开发的主要语言。

2010s and Beyond

2010 年代及以后

JavaScript, initially developed in the mid-1990s by Brendan Eich at Netscape, has rapidly evolved to incorporate object-oriented capabilities.
JavaScript 最初由 Netscape 的 Brendan Eich 于 1990 年代中期开发，现已迅速发展为包含面向对象的功能。

With the introduction of ES6 (ECMAScript 2015), JavaScript became much more object-oriented, with support for classes and inheritance, increasing its use in frontend and backend web development.
随着 ES6 （ECMAScript 2015） 的推出，JavaScript 变得更加面向对象，支持类和继承，增加了它在前端和后端 Web 开发中的使用。

Present and Future

现在和未来

As of today, Object-Oriented Programming remains the most important paradigm in software development. Its ability to model real-world concepts and its focus on code reuse remains unassailable.
截至今天，面向对象编程仍然是软件开发中最重要的范式。它对现实世界概念进行建模的能力和对代码重用的关注仍然无懈可击。

However, OOP is in constant evolution. This must be the case, as needs and technologies also change. In programming, there are no “written rules” or absolute truths. We learn the best path as we go.
然而，OOP 在不断发展。这是必须的，因为需求和技术也会发生变化。在编程中，没有 “成文规则” 或绝对真理。我们边走边学。

Thus, aspects such as the best architecture for complex applications can be debated. Some traditional design patterns have fallen out of favor in favor of more modern and flexible approaches.
因此，可以讨论复杂应用程序的最佳架构等方面。一些传统的设计模式已经失宠，取而代之的是更现代、更灵活的方法。

On the other hand, various programming languages such as Go, Rust, or Dart are constantly emerging and/or gaining popularity. These languages often adopt innovative approaches that challenge established conventions, leading to the exploration of new ways to apply the object-oriented paradigm.
另一方面，各种编程语言，如 Go、Rust 或 Dart 不断出现和/或越来越受欢迎。这些语言通常采用挑战既定惯例的创新方法，从而探索应用面向对象范例的新方法。

Despite these changes, and this need for continuous adaptation and integration of new ideas and technologies, what you can be sure of is that in the future OOP will continue to be the fundamental paradigm of software development for many years to come.
尽管发生了这些变化，并且需要不断适应和集成新的想法和技术，但您可以确定的是，在未来的许多年里，OOP 将继续成为软件开发的基本范式。

面向对象开发方法

醉心编码 于 2011-04-25 11:29:00 发布

面向对象程序设计（Object-oriented programming，缩写：OOP）是种具有对象概念的编程典范，同时也是一种程序开发的抽象方针。它可能包含数据、特性、代码与方法。

对象则指的是类（class）的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性，对象里的程序可以访问及经常修改对象相关连的数据。在面向对象程序编程里，计算机程序会被设计成彼此相关的对象。

1、Booch 方法

Booch 最先描述了面向对象的软件开发方法的基础问题，指出面向对象开发是一种根本不同于传统的功能分解的设计方法。面向对象的软件分解更接近人对客观事务的理解，而功能分解只通过问题空间的转换来获得。

2、Coad 方法

Coad 方法是 1989 年 Coad 和 Yourdon 提出的面向对象开发方法。该方法的主要优点是通过多年来大系统开发的经验与面向对象概念的有机结合，在对象、结构、属性和操作的认定方面，提出了一套系统的原则。该方法完成了从需求角度进一步进行类和类层次结构的认定。尽管 Coad 方法没有引入类和类层次结构的术语，但事实上已经在分类结构、属性、操作、消息关联等概念中体现了类和类层次结构的特征。

3、OMT 方法

OMT 方法是 1991 年由 James Rumbaugh 等 5 人提出来的，其经典著作为 “面向对象的建模与设计”。

该方法是一种新兴的面向对象的开发方法，开发工作的基础是对真实世界的对象建模，然后围绕这些对象使用分析模型来进行独立于语言的设计，面向对象的建模和设计促进了对需求的理解，有利于开发得更清晰、更容易维护的软件系统。该方法为大多数应用领域的软件开发提供了一种实际的、高效的保证，努力寻求一种问题求解的实际方法。

4、UML 语言

软件工程领域在 1995 年～1997 年取得了前所未有的进展，其成果超过软件工程领域过去 15 年的成就总和，其中最重要的成果之一就是统一建模语言 (UML，Unified Modeling Language) 的出现。UML 将是面向对象技术领域内占主导地位的标准建模语言。

UML 不仅统一了 Booch 方法、OMT 方法、OOSE 方法的表示方法，而且对其作了进一步的发展，最终统一为大众接受的标准建模语言。UML 是一种定义良好、易于表达、功能强大且普遍适用的建模语言。它融入了软件工程领域的新思想、新方法和新技术。它的作用域不限于支持面向对象的分析与设计，还支持从需求分析开始的软件开发全过程。

面向对象程序设计的由来

つつつつつつ 2019-11-14 20:34

一、概述

1.1 1940 年以前：面向机器

最早的程序设计都是采用机器语言来编写的，直接使用二进制码来表示机器能够识别和执行的指令和数 据。简单来说，就是直接编写 0 和 1 的序列来代表程序语言。例如：使用 0000 代表 加载 (LOAD),0001 代表 存储 (STORE) 等。
机器语言由机器直接执行，速度快，但一个很明显的缺点就是：写起来实在是太困难了，一旦你发现自己写错了，改起来更蛋疼！这样直接导致程序编写效率十分低下，编写程序花费的时间往往是实际运行时间的几十倍或几百倍。

有一个关于机器语言和比尔盖茨的笑话，是说比尔盖茨拿着绣花针在一张光盘上戳，把 Windows 给戳出 来了！但如果真的让你去戳，不要说 Windows, 连一个简单的 “Hello world” 都要让人戳到眼睛冒烟！

由于机器语言实在是太难编写了，于是就发展出了汇编语言。汇编语言亦称符号语言，用助记符代替机器 指令的操作码，用地址符号 (Symbol) 或标号 (Label) 代替指令或操作数的地址，。汇编语言由于是采用 了助记符号来编写程序，比用机器语言的二进制代码编程要方便些，在一定程度上简化了编程过程。例如 使用 LOAD 来代替 0000, 使用 STORE 来代替 0001。

即使汇编语言相比机器语言提升了可读性，但其本质上还是一种面向机器的语言，编写同样困难，也很容 易出错。相信很多计算机毕业的学生至今都对学校的汇编课程中的练习程序心有余悸。

1.2 脱离机器第一步：面向过程

面向机器的语言通常情况下被认为是一种 “低级语言”, 为了解决面向机器的语言存在的问题，计算机科 学的前辈们又创建了面向过程的语言。面向过程的语言被认为是一种 “高级语言”, 相比面向机器的语言 来说，面向过程的语言已经不再关注机器本身的操作指令、存储等方面，而是关注如何一步一步的解决具体的问题，即：解决问题的过程，这应该也是面向过程说法的来由。

相比面向机器的思想来说，面向过程是一次思想上的飞跃，将程序员从复杂的机器操作和运行的细节中解 放出来，转而关注具体需要解决的问题；面向过程的语言也不再需要和具体的机器绑定，从而具备了移植 性和通用性；面向过程的语言本身也更加容易编写和维护。这些因素叠加起来，大大减轻了程序员的负担，提升了程序员的工作效率，从而促进了软件行业的快速发展。

典型的面向过程的语言有：COBOL、FORTRAN、BASIC、C 语言等。

1.3 第一次软件危机：结构化程序设计

根本原因就是一些面向过程语言中的 goto 语句导致的面条式代码，极大的限制了程序的规模。结构化程序设计（英语：Structured programming），一种编程范型。它采用子程序（函数就是一种子程序）、代码区块、for 循环以及 while 循环等结构，来替换传统的 goto。希望借此来改善计算机程序的明晰性、质量以及开发时间，并且避免写出面条式代码。

随着计算机硬件的飞速发展，以及应用复杂度越来越高，软件规模越来越大，原有的程序开发方式已经越 来越不能满足需求了。1960 年代中期开始爆发了第一次软件危机，典型表现有软件质量低下、项目无法 如期完成、项目严重超支等，因为软件而导致的重大事故时有发生。例如 1963 年美国的水手一号火箭发射失败事故，就是因为一行 FORTRAN 代码 错误导致的。

软件危机最典型的例子莫过于 IBM 的 System/360 的操作系统开发。佛瑞德・布鲁克斯 (Frederick P. Brooks, Jr.) 作为项目主管，率领 2000 多个程序员夜以继日的工作，共计花费了 5000 人一年的工作量，写出将 近 100 万行的源码，总共投入 5 亿美元，是美国的 “曼哈顿” 原子弹计划投入的 1/4。尽管投入如此巨大，但项目进度却一再延迟，软件质量也得不到保障。布鲁克斯后来基于这个项目经验而总结的《人月神话》 一书，成了史上最畅销的软件工程书籍。
为了解决问题，在 1968、1969 年连续召开两次著名的 NATO 会议，会议正式创造了 “软件危机” 一词，并提出了针对性的解决方法 “软件工程”。虽然 “软件工程” 提出之后也曾被视为软件领域的银弹，但后 来事实证明，软件工程同样无法解决软件危机。

差不多同一时间，“结构化程序设计” 作为另外一种解决软件危机的方案被提出来了。 Edsger Dijkstra 于 1968 发表了著名的《GOTO 有害论》的论文，引起了长达数年的论战，并由此产生了结构化程序设计方 法。同时，第一个结构化的程序语言 Pascal 也在此时诞生，并迅速流行起来。
结构化程序设计的主要特点是抛弃 goto 语句，采取 “自顶向下、逐步细化、模块化” 的指导思想。结构 化程序设计本质上还是一种面向过程的设计思想，但通过 “自顶向下、逐步细化、模块化” 的方法，将软 件的复杂度控制在一定范围内，从而从整体上降低了软件开发的复杂度。结构化程序方法成为了 1970 年 代软件开发的潮流。
科学研究证明，人脑存在人类短期记忆一般一次只能记住 5-9 个事物，这就是著名的 7± 2 原理。结构化 程序设计是面向过程设计思想的一个改进，使得软件开发更加符合人类思维的 7±2 特点。

1.4 第二次软件危机：面向对象程序设计

结构化编程的风靡在一定程度上缓解了软件危机，然而好景不长，随着硬件的快速发展，业务需求越来越
复杂，以及编程应用领域越来越广泛，第二次软件危机很快就到来了。
第二次软件危机的根本原因还是在于软件生产力远远跟不上硬件和业务的发展，相比第一次软件危机主要 体现在 “复杂性”, 第二次软件危机主要体现在 “可扩展性”、“可维护性” 上面。传统的面向过程 (包括 结构化程序设计) 方法已经越来越不能适应快速多变的业务需求了，软件领域迫切希望找到新的银弹来解 决软件危机，在这种背景下，面向对象的思想开始流行起来。
面向对象的思想并不是在第二次软件危机后才出现的，早在 1967 年的 Simula 语言中就开始提出来了，但 第二次软件危机促进了面向对象的发展。 面向对象真正开始流行是在 1980s 年代，主要得益于 C++ 的功 劳，后来的 Java、C# 把面向对象推向了新的高峰。到现在为止，面向对象已经成为了主流的开发思想。
虽然面向对象开始也被当做解决软件危机的银弹，但事实证明，和软件工程一样，面向对象也不是银弹，而只是一种新的软件方法而已。
虽然面向对象并不是解决软件危机的银弹，但和面向过程相比，面向对象的思想更加贴近人类思维的特点，更加脱离机器思维，是一次软件设计思想上的飞跃。

二、详细发展历史

2.1 1940 之前：

霍列瑞斯式的打孔机 (pantograph)，用于 1890 年的人口普查。第一个编程语言比现代的计算机还早诞生。首先，这种语言是种编码 (en:code)。

于 1801 年发明的提花织布机 (或称甲卡提花织布机)，运用打孔卡上的坑洞来代表缝纫织布机的手臂动作，以便自动化产生装饰的图案。

爱达・勒芙蕾丝在 1842 年至 1843 年间花费了九个月，将意大利数学家 Luigi Menabrea 关于查尔斯・巴贝奇新发表机器分析机的回忆录翻译完成。她于那篇文章后面附加了一个用分析机计算伯努利数方法的细节，被部分历史学家认为是世界上第一个电脑程序。

Herman Hollerith 在观察列车长对乘客票根在特定位置打洞的方式后，意识到他可以把信息编码记载到打孔卡上，随后根据这项发现使用打孔卡来编码并纪录 1890 年的人口统计数据。第一个计算机代码是针对他们的应用面设计的。在 20 世纪的前十年主要是用十进制来算数，后来人们发现不只是用文字，也可以用数字来表现逻辑。举例来说，阿隆佐・邱奇曾以公式化 (formulaic) 的方式表达 λ 演算。图灵机是一种纸带标记 (tape-marking) 机器 (就像电话公司用的那种) 操作方法抽象化后的集合。图灵机这种通过有限数字 (finite number) 呈现机器的方式，奠定了程序如同冯・诺伊曼结构计算机中的数据一样地存储的基础。但不同于 λ 演算，图灵机的代码并没有办法成为高级编程语言的基石，这是是因为它主要的用途是分析算法的复杂度。

就像许多历史上的 “第一次” 一样，第一个现代编程语言也很难界定。最一开始是因为硬件限制而限定了语言，打孔卡允许 80 行 (column) 的长度，但某几行必须用来记录卡片的顺序。FORTRAN 则纳入了一些与英文字词相同的关键字，像是 “IF”、“GOTO”(原字词为 go to)，以及 “CONTINUE”。之后采用磁鼓 (magnetic drum) 作为存储器使用，也代表计算机程序也必须插入 (interleave) 到磁鼓的转动 (rotation) 中。和现今比较起来，这也让编程语言必须更加依赖硬件 (hardware-dependent)。

对部分的人认为必须在 “编程语言” 的状态确立之前，根据能力 (power) 以及可读性 (human-readability) 的程度来决定历史上第一个编程语言是什么语言。提花织布机和查尔斯・巴贝奇所制作的差分机 (en:Difference Engine) 都具备在大量限制下，简单描述机器应运行行为的语言。也有种并非设计给人类运用的受限特定领域语言 (en:domain-specific language)，是将打孔卡运用到自动演奏钢琴 (en:player piano) 上。

2.2 1940 年代：

最早被确认的现代化、电力引导 (electrically powered) 的计算机约在 1940 年代被创造出来。程序员在有限的速度及存储器容量限制之下，撰写人工调整 (hand tuned) 过的汇编语言程序。而且很快就发现到使用汇编语言的这种撰写方式需要花费大量的脑力 (intellectual effort) 而且很容易出错 (error-prone)。
康拉德・楚泽于 1948 年发表了他所设计的 Plankalkül 编程语言的论文 [1]。但是在他有生之年却未能将该语言实现，而他原本的贡献也被其他的发展所孤立。
在这段期间被开发出来的重要语言包括有：

• 1943 - Plankalkül (Konrad Zuse)
• 1943 - ENIAC coding system
• 1949 - C-10

2.3 1950 与 1960 年代：

有三个现代编程语言于 1950 年代被设计出来，这三者所派生的语言直到今日仍旧广泛地被采用：

• Fortran (1955)，名称取自 “FORmula TRANslator”(公式翻译器)，由约翰・巴科斯等人所发明；
• LISP，名称取自 “LISt Processor”(枚举处理器)，由约翰・麦卡锡等人所发明；
• COBOL，名称取自 “COmmon Business Oriented Language”(通用商业导向语言)，由被葛丽丝・霍普深刻影响的 Short Range Committee 所发明。

另一个 1950 年代晚期的里程碑是由美国与欧洲计算机学者针对 “算法的新语言” 所组成的委员会出版的 ALGOL 60 报告 (名称取自 “ALGOrithmic Language”(算法语言))。这份报告强化了当时许多关于计算的想法，并提出了两个语言上的创新功能：

• 嵌套区块结构：可以将有意义的代码片段组群成一个区块 (block)，而非转成分散且特定命名的程序。
• 词汇范围 (lexical scoping)：区块可以有区块外部无法通过名称访问，属于区块本身的变量、程序以及函数。

另一个创新则是关于语言的描述方式：
一种名为巴科斯 - 诺尔范式 (BNF) 的数学化精确符号被用于描述语言的语法。之后的编程语言几乎全部都采用类似 BNF 的方式来描述程序语法中上下文无关的部分。

Algol 60 对之后语言的设计上带来了特殊的影响，部分的语言很快的就被广泛采用。后续为了开发 Algol 的扩充子集合，设计了一个名为 Burroughs (en:Burroughs large systems) 的大型系统。
延续 Algol 的关键构想所产生的成果就是 ALGOL 68：

• 语法跟语义变的更加正交 (orthogonal)，采用匿名的历程 (routines)，采用高级 (higher-order) 功能的递归式输入 (typing) 系统等等。
• 整个语言及语义的部分都通过为了描述语言而特别设计的 Van Wijngaarden grammar 来进行正式的定义，而不仅止于上下文无关的部分。

Algol 68 一些较少被使用到的语言功能 (如同步与并行区块)、语法快捷方式的复杂系统，以及类型自动强制转换 (coercions)，使得实现者兴趣缺缺，也让 Algol 68 获得了很难用 (diffcult) 的名声。尼克劳斯・维尔特就干脆离开该设计委员会，另外再开发出更简单的 Pascal 语言。
在这段期间被开发出来的重要语言包括有：

• 1951 - Regional Assembly Language
• 1952 - Autocode
• 1954 - FORTRAN
• 1954 - IPL (LISP 的先驱)
• 1955 - FLOW-MATIC (COBOL 的先驱)
• 1957 - COMTRAN (COBOL 的先驱)
• 1958 - LISP
• 1958 - ALGOL 58
• 1959 - FACT (COBOL 的先驱)
• 1959 - COBOL
• 1962 - APL
• 1962 - Simula
• 1962 - SNOBOL
• 1963 - CPL (C 的先驱)
• 1964 - BASIC
• 1964 - PL/I
• 1967 - BCPL (C 的先驱)

2.4 1967-1978：确立了基础范式

1960 年代晚期至 1970 年代晚期的期间中，编程语言的发展也有了重大的成果。大多数现在所使用的主要语言范式都是在这段期间中发明的：

• Simula，于 1960 年代晚期由奈加特与 Dahl 以 Algol 60 超集合的方式发展，同时也是第一个设计支持面向对象进行开发的编程语言。
• C，于 1969 至 1973 年间由贝尔实验室的研究人员丹尼斯・里奇与肯・汤普逊所开发，是一种早期的系统程序设计 (en:system programming) 语言。
• Smalltalk，于 1970 年代中期所开发，是一个完全从零开始 (ground-up) 设计的面向对象编程语言。
• Prolog，于 1972 年由 Colmerauer、Roussel，以及 Kowalski 所设计，是第一个逻辑程序语言。
• ML，于 1973 年由罗宾・米尔纳所发明，是一个基于 Lisp 所建构的多态 (polymorphic) 类型系统，同时也是静态类型函数编程语言的先驱。

这些语言都各自演展出自己的家族分支，现今多数现代编程语言的祖先都可以追溯他们其中至少一个以上。
在 1960 年代以及 1970 年代中结构化程序设计的优点也带来许多的争议，特别是在程序开发的过程中完全不使用 GOTO。这项争议跟语言本身的设计非常有关系：某些语言并没有包含 GOTO，这也强迫程序员必须结构化地编写程序。尽管这个争议在当时吵翻了天，但几乎所有的程序员都同意就算语言本身有提供 GOTO 的功能，在除了少数罕见的情况下去使用 GOTO 是种不良的程序风格。结果是之后世代的编程语言设计者发觉到结构化编程语言的争议实在既乏味又令人眼花撩乱。
在这段期间被开发出来的重要语言包括有：

• 1968 - Logo
• 1970 - Pascal
• 1970 - Forth
• 1972 - C 语言
• 1972 - Smalltalk
• 1972 - Prolog
• 1973 - ML
• 1975 - Scheme
• 1978 - SQL (起先只是一种查询语言，扩充之后也具备了程序结构)

2.5 1980 年代：增强、模块、性能

1980 年代的编程语言与之前相较显得更为强大。C++ 合并了面向对象以及系统程序设计。美国政府标准化一种名为 Ada 的系统编程语言并提供给国防承包商使用。日本以及其他地方运用了大量的资金对采用逻辑编程语言结构的第五代语言进行研究。函数编程语言社区则把焦点转移到标准化 ML 及 Lisp 身上。这些活动都不是在开发新的范式，而是在将上个世代发明的构想进一步发扬光大。
然而，在语言设计上有个重大的新趋势，就是研究运用模块或大型组织化的程序单元来进行大型系统的开发。Modula、Ada，以及 ML 都在 1980 年代发展出值得注意的模块化系统。模块化系统常拘泥于采用泛型程序设计结构：泛型存在 (generics being)、本质 (essence)，参数化模块 (parameterized modules)。(参阅多态)
尽管没有出现新的主要编程语言范式，许多研究人员仍就扩充之前语言的构想并将它们运用到新的内容上。举例来说，Argus 以及 Emerald 系统的语言配合面向对象语言运用到分布式系统上。
1980 年代的编程语言实现情况也有所进展。计算机系统结构中 RISC 的进展假定硬件应当为编译器设计，而非身为人类的汇编语言程序员。借由中央处理器速度增快的帮助，编译技术也越来越积极，RISC 的进展对高级语言编译技术带来不小的关注。
语言技术持续这些发展并迈入了 1990 年代。
在这段期间被开发出来的重要语言包括有：

• 1980 - Ada
• 1983 - C++ (就像有类别的 C)
• 1984 - Common Lisp
• 1985 - Eiffel
• 1986 - Erlang
• 1987 - Perl
• 1988 - Tcl
• 1989 - FL (Backus)

2.6 1990 年代：互联网时代

1990 年代未见到有什么重大的创新，大多都是以前构想的重组或变化。这段期间主要在推动的哲学是提升程序员的生产力。许多 “快速应用程序开发” (RAD) 语言也应运而生，这些语言大多都有相应的集成开发环境、垃圾回收等机制，且大多是先前语言的派生语言。这类型的语言也大多是面向对象的编程语言，包含有 Object Pascal、Visual Basic，以及 C#。Java 则是更加保守的语言，也具备垃圾回收机制。与其他类似语言相比，也受到更多的观注。新的脚本语言则比 RAD 语言更新更好。这种语言并非直接从其他语言派生，而且新的语法更加开放地 (liberal) 与功能契合。虽然脚本语言比 RAD 语言来的更有生产力，但大多会有因为小程序较为简单，但是大型程序则难以使用脚本语言撰写并维护的顾虑。尽管如此，脚本语言还是网络层面的应用上大放异彩。
在这段期间被开发出来的重要语言包括有：

• 1990 - Haskell
• 1991 - Python
• 1991 - Visual Basic
• 1993 - Ruby
• 1993 - Lua
• 1994 - CLOS (part of ANSI Common Lisp)
• 1995 - Java
• 1995 - Delphi (Object Pascal)
• 1995 - JavaScript
• 1995 - PHP
• 1997 - REBOL
• 1999 - D

2.7 现今的趋势

编程语言持续在学术及企业两个层面中发展进化，目前的一些趋势包含有：

• 在语言中增加安全性与可靠性验证机制：额外的堆栈检查、信息流 (information flow) 控制，以及静态线程安全。
• 提供模块化的替代机制：混入 (en:mixin)、委派 (en:delegates)，以及观点导向。
• 组件导向 (component-oriented) 软件开发
• 元编程、反射或是访问抽象语法树 (en:Abstract syntax tree)
• 更重视分布式及移动式的应用。
• 与数据库的集成，包含 XML 及关系数据库。
• 支持使用 Unicode 编写程序，所以源代码不会受到 ASCII 字符集的限制，而可以使用像是非拉丁语系的脚本或延伸标点符号。
• 图形用户界面所使用的 XML (XUL、XAML)。

在这段期间被开发出来的重要语言包括有：

• 2001 - C#
• 2001 - Visual Basic .NET
• 2002 - F#
• 2003 - Scala
• 2003 - Factor
• 2006 - Windows PowerShell
• 2007 - Clojure
• 2009 - Go
• 2014 - Swift (编程语言)

2.8 编程语言发展史上的杰出人物

• 约翰・巴科斯，发明了 Fortran。
• 阿兰・库珀，开发了 Visual Basic。
• 艾兹格・迪杰斯特拉，开创了正确运用编程语言 (proper programming) 的框架。
• 詹姆斯・高斯林，开发了 Oak，该语言为 Java 的先驱。
• 安德斯・海尔斯伯格，开发了 Turbo Pascal、Delphi，以及 C#。
• 葛丽丝・霍普，开发了 Flow-Matic，该语言对 COBOL 造成了影响。
• 肯尼斯・艾佛森，开发了 APL，并与 Roger Hui 合作开发了 J。
• 比尔・乔伊，发明了 vi，BSD Unix 的前期作者，以及 SunOS 的发起人，该操作系统后来改名为 Solaris。
• 艾伦・凯，开创了面向对象编程语言，以及 Smalltalk 的发起人。
• Brian Kernighan，与丹尼斯・里奇合著第一本 C 程序设计语言的书籍，同时也是 AWK 与 AMPL 程序设计语言的共同作者。
• 约翰・麦卡锡，发明了 LISP。
• 约翰・冯・诺伊曼，操作系统概念的发起者。
• 丹尼斯・里奇，发明了 C。
• 比雅尼・斯特劳斯特鲁普，开发了 C++。
• 肯・汤普逊，发明了 Unix。
• 尼克劳斯・维尔特，发明了 Pascal 与 Modula。
• 拉里・沃尔，创造了 Perl 与 Perl 6。
• 吉多・范罗苏姆，创造了 Python。

UML 的起源和发展

原创 chill 重构那座山 2024年06月13日 15:14 广东

前言

随着软件产品的价值提高，企业欲寻找技术以改善软件生产流程、提高质量、降低成本并缩短产品上市时间。这些技术包括组件技术，可视化编程，模式和框架的应用。企业也寻求能管理系统因范围和规模扩大而衍生的复杂性的技术。他们也意识到需要解决周期性的体系结构问题，如物理分布、并发性、复制、安全性、负载平衡和容错性。随着软件体系架构的复杂性持续提高，由此 UML 应运而生。

UML 是什么

UML 是统一建模语言的简称，它是一种由一整套图表组成的标准化建模语言。UML 用于帮助系统开发人员阐明，展示，构建和记录软件系统的产出。UML 代表了一系列在大型而复杂系统建模中被证明是成功的做法，是开发面向对象软件和软件开发过程中非常重要的一部分。UML 主要使用图形符号来表示软件项目的设计，使用 UML 可以帮助项目团队沟通、探索潜在的设计和验证软件的架构设计。

UML 哪里好

Page-Jones 在 Fundamental Object-Oriented Design in UML 一书中总结了 UML 的主要目的，如下：

• 为用户提供现成的、有表现力的可视化建模语言，以便他们开发和交换有意义的模型。
• 为核心概念提供可扩展性 (Extensibility) 和特殊化 (Specialization) 机制。
• 独立于特定的编程语言和开发过程。
• 为了解建模语言提供一个正式的基础。
• 鼓励面向对象工具市场的发展。
• 支持更高层次的开发概念，如协作，框架，模式和组件。
• 整合最佳的工作方法 (Best Practices)。

可以帮助开发团队以一种可视化的方式理解系统的功能需求。有利于开发团队队员之间在各个开发环节间确立沟通的标准，便于系统文档的制定和项目的管理。因为 UML 的简单、直观和标准性，在一个团队中用 UML 来交流比用文字说明的文档要好的多。UML 为非专业编程人士理解软件的功能和构造，提供了一种直白、简单、通俗的方法。使用 UML 可以方便的理解各种框架的设计方式等等各种各样的好处。

从 OMT 说起

OMT（Object Modeling Technique，对象建模技术）是一种面向对象的软件开发方法，它涵盖了面向对象分析（OOA）、面向对象设计（OOD）和面向对象编程（OOP）的各个方面。下面是对这三个概念的简要介绍：

1. 面向对象分析（OOA - Object-Oriented Analysis）

   面向对象分析是一种分析方法，用于识别系统中的对象和类，以及它们之间的关系。OOA 的目的是理解问题域并建立一个概念模型，通常包括：

   • 对象模型：描述系统中的类和对象，以及它们之间的静态关系。
   • 动态模型：描述对象随时间变化的行为，包括状态和事件。
   • 功能模型：描述系统的功能需求和数据流。

2. 面向对象设计（OOD - Object-Oriented Design）

   面向对象设计是在 OOA 的基础上进一步细化系统的设计。OOD 关注如何将分析阶段得到的概念模型转化为软件架构和组件。这包括：

   • 细化类和对象的设计，包括属性和方法。
   • 确定类的继承关系和接口。
   • 设计系统的架构，包括组件、包和模块。
   • 考虑系统的可扩展性、可维护性和性能。

3. 面向对象编程（OOP - Object-Oriented Programming）

   面向对象编程是一种编程范式，它使用类和对象的概念来组织代码。OOP 的关键特性包括：

   • 封装：将数据（属性）和操作数据的方法结合在一起，隐藏内部实现细节。
   • 继承：允许新类（子类）继承现有类（父类）的属性和方法。
   • 多态：允许不同类的对象对同一消息做出响应，但具体行为会根据对象的实际类而变化。
   • 抽象：通过创建抽象类和接口来定义对象的接口，而不是具体的实现。

OMT 方法将 OOA、OOD 和 OOP 整合在一起，提供了一种从问题域分析到软件实现的连贯方法。通过 OMT，开发者可以创建一个清晰、一致的模型，然后使用面向对象的技术来实现这个模型。随着时间的推移，OMT 的一些概念和技术被统一建模语言（UML）所吸收和发展，UML 现在成为了面向对象软件开发中更为广泛使用的标准。

UML 诞生前夜

计算机有软件和硬件两部分组成，从计算机诞生到现在，硬件技术始终比软件技术的发展速度快。上世纪 60 年代，“软件危机”发生，硬件技术的迅速发展使得计算机价格下降，成了普通人可以用得起的“家用电器”；人们需要更加复杂的软件系统来满足他们工作、生活中的各种需要，但是，当时的软件开发模式很难开发出复杂的软件，即使开发出来，其可靠性、可维护性都是很大的问题。

为了解决“软件危机”，人们提出了“软件工程”的概念，试图将工程化的思想引入到软件业。在这一阶段，诞生了很多的开发方法，其中包括面向对象的开发方法，由于面向对象的各种优点，这种开发方法得到了大家的普遍关注，出现了 Simula、C++ 、Java、 C#等面向对象的语言，也出现了各种面向对象的建模方法：OMT、OOSE、Booch 等。这些建模方法之间各有区别，对于开发人员来讲，如同三门不同的语言，使用不同语言的开发人员不能很好的交流。

公认的面向对象建模语言出现于 20 世纪 70 年代中期。从 1989 年到 1994 年，其数量从不到 10 种增加到了 50 多种。在众多的建模语言中，语言的创造者努力推崇自己的产品，并在实践中不断完善。但是，面向对象方法的用户并不了解不同建模语言的优缺点及相互之间的差异，因而很难根据应用特点选择合适的建模语言，于是爆发了一场“方法大战”。20 世纪 90 年代，一批新方法出现了，其中最引人注目的是 Booch 1993、和 OMT-2 等。

这时，人们期待一种统一的建模语言的诞生，如同建筑设计图一样，符号简单、没有二义性而且更重要的是人人都能够看懂，交流起来很方便，就这样，UML 诞生了，UML 提出了一套 IT 专业人员期待多年的统一的标准建模符号。通过使用 UML，人员能够阅读和交流系统架构和设计规划，就像建筑工人多年来所使用的建筑设计图一样。

UML 创始人们

1、Grady Booch

Grady （IBM fellow）因其在软件架构、软件工程和软件建模方面的杰出贡献而在国际上享有盛名。自 Rational 于 1981 年创建以来，他就一直担任 IBM Rational 的首席科学家。Grady 于 2003 年 3 月荣获 IBM 名士（IBM fellow）的称号。

Booch 方法的力量在于其丰富的符号体系，主要包括：

• 类图（类结构－静态视图）
• 对象图（对象结构－静态视图）
• 状态转移图（类结构－动态视图）
• 时态图（对象结构－动态视图）
• 模块图（模块体系结构）
• 进程图（进程体系结构）
• …

2、Ivar Jacobson

Ivar Jacobson 博士是 Objectory 方法的发明者，也是瑞典 Objectory AB 公司的创始人。Jacobson 博士是两本影响深远的畅销书的主要作者：《面向对象的软件工程―一种用例驱动方法》（1992 年计算机语言生产力奖获得者）和 《对象的优势―采用对象技术的业务过程再工程》。Jacobson 将 use case 模型与其它五种系统模型关联：

• 领域对象模型。use case 模型根据领域来表示。
• 分析模型。use case 模型通过分析来构造。
• 设计模型。use case 模型通过设计来具体化。
• 实现模型。该模型依据具体化的设计来实现 use case 模型。
• 测试模型。用来测试具体化的 use case 模型。

3、James Rumbaugh

James Rumbaugh 博士是享誉全球的软件开发方法学家。Jim 一直是引导 UML 未来开发的领袖，他提出了许多有关 UML 的概念。他与 Rational 的其他软件领袖一起工作在各个领域，比如 Rational 统一过程和实时开发方法学。自从 2003 年 IBM 收购了 Rational 之后，Jim 就一直致力于推动 IBM 建模工具的开发。Rumbaugh 的 OMT 方法将开发过程分为四个阶段：分析->系统设计->对象设计->实现

UML 发展历程

• 1995 年 10 月 UM 0.8（Unified Method）
• 1996 年 6 月和 10 月 UML0.9 和 UML0.91
• 1997 年 11 月发布了新的版本 UML.1.1
• 1998 年发布了 UML 1.2 版本
• 1999 年发布了 UML 1.3 版本
• 2003 年 3 月发布了 UML 1.5 版本
• 2005 年发布了 UML 2.0 版本
• 2006 年发布了 UML 2.1 版本
• 2009 年发布了 UML 2.2 版本
• 2010 年发布了 UML 2.3 版本
• 2011 年发布了 UML 2.4.1 版本
• 2013 年发布了 UML 2.5.版本
• 2017 年发布了 UML 2.5.1 版本

1994 年，OMT 的创始人 Jim Rumbaugh 离开了通用电气公司 （General Electric），转投了 Rational，与 Grady Booch 并肩作战。这使得软件世界惊呆的合作，为的是要把二人的想法结合成一个统一的方法（项目名称也就是 “统一方法”）。

1995 年，OOSE 的创建者 Ivar Jacobson 也加入了 Rational，他的想法（特别是有关“用例” (Use Case) 的概念）被整合于统一方法中，成为“统一建模语言”。Rumbaugh，Booch 和 Jacobson 的团队则被称为“三友”

UML 是由 OMT(对象建模技术) 统一而来的符号。

• 对象建模技术 OMT [James Rumbaugh 1991] - 最适合分析和数据密集型信息系统。
• Booch [Grady Booch 1994] - 强项为设计和實作。Grady Booch 曾经为 Ada 语言方面做过广泛的工作，并且一直是该语言面向对象技术发展的主要参与者。尽管 Booch 方法很强大，但是但并未广为接受 （因为他的模型包含着很多云状，序人不整齐的感觉）
• OOSE（面向对象的软件工程[Ivar Jacobson 1992]） - 有一个称为用例的模型。用例是理解整个系统行为的强大技术（OO 传统上很弱的领域）。

在 1996 年间，由 Object Management Group （OMG） 发布的第一个征求建议书 （RFP），成为让这些组织联合起来的催化剂。Rational 与几个愿意为加强 UML 1.0 投入资源的组织建立了 UML 伙伴联盟。那些对 UML 1.0 最有贡献的人包括：

• Digital Equipment Corp
• HP
• I-Logix
• IntelliCorp
• IBM
• ICON Computing
• MCI Systemhouse
• 微软
• 甲骨文
• Rational 软件
• TI
• Unisys 公司

UML 的目标是提供一个标准的符号，可以被所有面向对象的方法使用，并选择和整合前兆符号的最佳元素。UML 可用于广泛的应用程序，它为不同的系统和活动（如分布式系统，分析，系统设计和部署）提供了构造。

UML 1.0 在 1997 年 1 月提交给 OMG。一个有明确定义，表达力强大且通用的建模语言。UML 还包含其他主要方法中不存在的新概念，如扩展机制和约束语言。

UML 也受到其他面向对象符号的影响：

• ellor 和 Shlaer [1998]
• Coad 和 Yourdon [1995]
• Wirfs-Brock [1990]
• Martin 和 Odell [1992]

UML 标准规范

• 最新规范：UML v.2.5.1 [2017 年 12 月]
• 最新规范：UML v.2.5.1 变更 [2017 年 12 月]
• 历史规范：UML 基础建模 ISO 2012 版标准 [2012 年 5 月]
• 历史规范：UML 复杂建模 ISO 2012 版标准 [2012 年 5 月]
• 历史规范：UML 基础建模 v.2.4.1 [2011 年 8 月]
• 历史规范：UML 复杂建模 v.2.4.1 [2011 年 8 月]
• 历史规范：UML 基础建模 v.2.3 [2010 年 5 月]
• 历史规范：UML 复杂建模 v.2.3 [2010 年 5 月]
• 历史规范：UML 基础建模 v.2.2 [2009 年 2 月]
• 历史规范：UML 复杂建模 v.2.2 [2009 年 2 月]
• 历史规范：UML 基础建模 v.2.2 变更 [2009 年 2 月]
• 历史规范：UML 复杂建模 v.2.2 变更 [2009 年 2 月]
• 历史规范：UML 基础建模 v.2.1.2 [2007 年 11 月]
• 历史规范：UML 复杂建模 v.2.1.2 [2007 年 11 月]
• 历史规范：UML 基础建模 v.2.1.2 变更 [2007 年 11 月]
• 历史规范：UML 复杂建模 v.2.1.2 变更 [2007 年 11 月]
• 历史规范：UML 基础建模 v.2.0 [2005 年 7 月]
• 历史规范：UML 复杂建模 v.2.0 [2005 年 7 月]
• 历史规范：UML v.1.5 [2003 年 3 月]
• 历史规范：UML v.1.4.2 ISO 标准 [2005 年 4 月]
• 历史规范：UML v.1.4 [2001 年 9 月]
• 历史规范：UML v.1.3 [2000 年 3 月]

结束语

是的，没看错，从标准规范多年没更新来看，UML 发展已经非常成熟了。它已在软件工程领域得到了广泛的应用，我们应该理解一个成熟的技术不会像新兴技术那样快速发展。UML 是我们开展重构工作的基石，重要且可靠的工具、手段，后续会持续更新 UML 的基础知识和应用。

参考资料:

• 什么是统一建模语言（UML）？
  https://www.visual-paradigm.com/cn/guide/uml-unified-modeling-language/what-is-uml/

• UML 基础-火龙果软件工程
  http://www.uml.org.cn/oobject/OObject.asp

via:

• Brief history of Object-Oriented Programming Tue, May 14, 2024
  https://www.luisllamas.es/en/history-object-oriented-programming/

• 面向对象常见的4种开发方法_面向对象开发方法-CSDN博客 醉心编码 于 2011-04-25 11:29:00 发布
  https://blog.csdn.net/lzyzuixin/article/details/6361122

• 面向对象程序设计的由来(历史故事) - つつつつつつ - 博客园 posted @ 2019-11-14 20:34 つつつつつつ
  https://www.cnblogs.com/Dr-wei/p/11861849.html

• 技术史话 | UML 的起源和发展 原创 chill 重构那座山 2024年06月13日 15:14 广东
  https://mp.weixin.qq.com/s/GB0cPSqxpEipiQT1U1jwKA