编程语言的历史(推荐学习)

来自：https://codedocs.org/what-is/history-of-programming-languages

编程语言的历史

History of programming languages

For a detailed timeline of events, see Timeline of programming languages.

For the ACM conference series, see History of Programming Languages

 

　　The history of programming languages spans from documentation of early mechanical computers to modern tools for software development. Early programming languages were highly specialized, relying on mathematical notation and similarly obscure syntax.Throughout the 20th century, research in compiler theory led to the creation of high-level programming languages, which use a more accessible syntax to communicate instructions.

　　编程语言的历史跨越了从早期机械计算机的文档到用于软件开发的现代工具。早期的编程语言是高度专业化的，依赖于数学符号和同样晦涩的语法。在整个 20 世纪，对编译器理论的研究导致了高级编程语言的创建，这些语言使用更易于访问的语法来传达指令。

　　The first high-level programming language was Plankalkül, created by Konrad Zuse between 1942 and 1945.The first high-level language to have an associated compiler was created by Corrado Böhm in 1951, for his PhD thesis. The first commercially available language was FORTRAN (FORmula TRANslation), developed in 1956 (first manual appeared in 1956, but first developed in 1954) by a team led by John Backus at IBM.

　　第一种高级编程语言是 Plankalkül，由 Konrad Zuse 在 1942 年至 1945 年间创建。^[2]第一种具有相关编译器的高级语言是 Corrado Böhm 于 1951 年为他的博士论文创建的。第一个商业可用的语言是FORTRAN （FORmula TRANslation），由IBM的 John Backus 领导的团队于 1956 年开发（第一本手册出现于 1956 年，但首次开发于 1954 年）。

Early history(早期历史)

　　During 1842–1849, Ada Lovelace translated the memoir of Italian mathematician Luigi Menabrea about Charles Babbage's newest proposed machine: the Analytical Engine; she supplemented the memoir with notes that specified in detail a method for calculating Bernoulli numbers with the engine, recognized by most of historians as the world's first published computer program.

　　1842-1849 年间，艾达·洛夫莱斯翻译了意大利数学家路易吉·梅纳布雷亚关于查尔斯·巴贝奇最新提出的机器：分析机的回忆录；她在回忆录中补充了一些注释，详细说明了用引擎计算伯努利数的方法，大多数历史学家都认为这是世界上第一个出版的计算机程序。

　　The first computer codes were specialized for their applications: e.g., Alonzo Church was able to express the lambda calculus in a formulaic way and the Turing machine was an abstraction of the operation of a tape-marking machine.

　　第一个计算机代码专门用于它们的应用：例如，Alonzo Church能够以公式化的方式表达lambda 演算，而图灵机是磁带打标机操作的抽象。

        Jacquard Looms and Charles Babbage's Difference Engine both had simple languages for describing the actions that these machines should perform hence they were the creators of the first programming language.

　　Jacquard Looms和 Charles Babbage 的差异引擎都有简单的语言来描述这些机器应该执行的操作，因此它们是第一种编程语言的创造者。

First programming languages(第一种编程语言)

　　In the 1940s, the first recognizably modern electrically powered computers were created. The limited speed and memory capacity forced programmers to write hand-tuned assembly language programs. It was eventually realized that programming in assembly language(汇编语言) required a great deal of intellectual effort.

　　1940 年代，第一台公认的现代电动计算机问世。有限的速度和内存容量迫使程序员编写可手动调整的汇编语言程序。最终人们意识到，用汇编语言进行编程需要大量的智力努力。

 

　　An early proposal for a high-level programming language was Plankalkül, developed by Konrad Zuse for his Z1 computer between 1943 and 1945 but not implemented at the time.

　　高级编程语言的早期提议是 Plankalkül，由 Konrad Zuse 在 1943 年至 1945 年间为他的 Z1 计算机开发，但当时尚未实施。

　　The first functioning programming languages designed to communicate instructions to a computer were written in the early 1950s. John Mauchly's Short Code, proposed in 1949, was one of the first high-level languages ever developed for an electronic computer.^[6] Unlike machine code, Short Code statements represented mathematical expressions in understandable form. However, the program had to be translated into machine code every time it ran, making the process much slower than running the equivalent machine code.

　　第一种设计用于向计算机传达指令的功能性编程语言是在 1950 年代初编写的。John Mauchly 的短代码于 1949 年提出，是有史以来最早为电子计算机开发的高级语言之一。与机器代码不同，短代码语句以可理解的形式表示数学表达式。然而，程序每次运行时都必须翻译成机器码，这使得该过程比运行同等机器码慢得多。

 

　　In the early 1950s, Alick Glennie developed Autocode, possibly the first compiled programming language, at the University of Manchester. In 1954, a second iteration of the language, known as the "Mark 1 Autocode," was developed for the Mark 1 by R. A. Brooker. Brooker also developed an autocode for the Ferranti Mercury in the 1950s in conjunction with the University of Manchester. The version for the EDSAC 2 was devised by Douglas Hartree of University of Cambridge Mathematical Laboratory in 1961. Known as EDSAC 2 Autocode, it was a straight development from Mercury Autocode adapted for local circumstances and was noted for its object code optimization and source-language diagnostics which were advanced for the time. A contemporary but separate thread of development, Atlas Autocode was developed for the University of Manchester Atlas 1 machine.

　　1950 年代初期，Alick Glennie 在曼彻斯特大学开发了 Autocode，这可能是第一个编译的编程语言。1954 年，RA Brooker 为 Mark 1 开发了该语言的第二次迭代，称为“Mark 1 Autocode”。Brooker 还在 1950 年代与曼彻斯特大学合作开发了 Ferranti Mercury 的自动代码。EDSAC 2 的版本由剑桥大学数学实验室的 Douglas Hartree 于 1961 年设计。被称为 EDSAC 2 Autocode，它是 Mercury Autocode 的直接开发，适用于当地情况，并以其目标代码优化和源语言而闻名当时先进的诊断技术。当代但独立的发展线索。

 

　　In 1954, FORTRAN was invented at IBM by a team led by John Backus; it was the first widely used high-level general purpose programming language to have a functional implementation, as opposed to just a design on paper.When FORTRAN was first introduced, it was viewed with skepticism due to bugs, delays in development, and the comparative efficiency of "hand-coded" programs written in assembly. However, in a hardware market that was rapidly evolving; the language eventually became known for its efficiency. It is still a popular language for high-performance computing and is used for programs that benchmark and rank the world's fastest supercomputers.

　　1954 年，由 John Backus 领导的团队在 IBM 发明了FORTRAN ；它是第一个广泛使用的具有功能实现的高级通用编程语言，而不仅仅是纸上的设计。首次引入 FORTRAN 时，由于错误、开发延迟以及用汇编编写的“手工编码”程序的相对效率，人们对其持怀疑态度。然而，在一个快速发展的硬件市场中；该语言最终因其效率而闻名。它仍然是一种流行的高性能计算语言，并用于对世界上最快的超级计算机进行基准测试和排名的程序。

 

　　Another early programming language was devised by Grace Hopper in the US, called FLOW-MATIC. It was developed for the UNIVAC I at Remington Rand during the period from 1955 until 1959. Hopper found that business data processing customers were uncomfortable with mathematical notation, and in early 1955, she and her team wrote a specification for an English programming language and implemented a prototype. The FLOW-MATIC compiler became publicly available in early 1958 and was substantially complete in 1959.Flow-Matic was a major influence in the design of COBOL, since only it and its direct descendant AIMACO were in actual use at the time.

　　另一种早期的编程语言是由美国的 Grace Hopper 设计的，称为FLOW-MATIC。它是在 1955 年至 1959 年期间为雷明顿兰德公司的UNIVAC I开发的。Hopper发现业务数据处理客户对数学符号感到不舒服，因此在 1955 年初，她和她的团队编写了一个英语编程语言规范并实施一个原型。 FLOW-MATIC 编译器于 1958 年初公开可用，并在 1959 年基本完成。Flow-Matic 对COBOL的设计产生了重大影响，因为只有它及其直接后代 AIMACO 在实际使用中时间。

　　Other languages still in use today include LISP (1958), invented by John McCarthy and COBOL (1959), created by the Short Range Committee. Another milestone in the late 1950s was the publication, by a committee of American and European computer scientists, of "a new language for algorithms"; the ALGOL 60 Report (the "ALGOrithmic Language"). This report consolidated many ideas circulating at the time and featured three key language innovations:

　　今天仍在使用的其他语言包括由 John McCarthy 发明的LISP (1958) 和由 Short Range Committee 创建的COBOL (1959)。1950 年代后期的另一个里程碑是由美国和欧洲计算机科学家组成的委员会发表的“一种新的算法语言”；ALGOL 60 报告（“ ALGO算法语言”）。这份报告整合了当时流传的许多想法，并重点介绍了三个关键的语言创新：

• nested block structure: code sequences and associated declarations could be grouped into blocks without having to be turned into separate, explicitly named procedures;
  
  嵌套块结构：代码序列和相关声明可以被组合成块，而不必变成单独的、显式命名的过程；
  
  
• lexical scoping: a block could have its own private variables, procedures and functions, invisible to code outside that block, that is, information hiding.
  
  词法作用域：一个块可以有它自己的私有变量、过程和函数，对于该块之外的代码是不可见的，即信息隐藏。

　　  Another innovation, related to this, was in how the language was described:

　　 与此相关的另一项创新是语言的描述方式：

• a mathematically exact notation, Backus–Naur form (BNF), was used to describe the language's syntax. Nearly all subsequent programming languages have used a variant of BNF to describe the context-free portion of their syntax.
  
  
• 一种数学上精确的符号，Backus-Naur 形式 (BNF)，用于描述该语言的语法。几乎所有后续的编程语言都使用 BNF 的变体来描述其语法的上下文无关部分。

　　Algol 60 was particularly influential in the design of later languages, some of which soon became more popular. The Burroughs large systems were designed to be programmed in an extended subset of Algol.

　　Algol 60 在后来的语言设计中特别有影响力，其中一些很快变得更流行。Burroughs 大型系统被设计为在Algol 的扩展子集中进行编程。

　　Algol's key ideas were continued, producing ALGOL 68:

　　Algol 的关键思想得到延续，产生了ALGOL 68：

• syntax and semantics became even more orthogonal, with anonymous routines, a recursive typing system with higher-order functions, etc.;
  语法和语义变得更加正交，具有匿名例程、具有高阶函数的递归类型系统等；
• not only the context-free part, but the full language syntax and semantics were defined formally, in terms of Van Wijngaarden grammar, a formalism designed specifically for this purpose.
  不仅是与上下文无关的部分，而且整个语言的语法和语义都是根据 Van Wijngaarden 语法正式定义的，这是一种专门为此目的设计的形式主义。

　　Algol 68's many little-used language features (for example, concurrent and parallel blocks) and its complex system of syntactic shortcuts and automatic type coercions made it unpopular with implementers and gained it a reputation of being difficult. Niklaus Wirth actually walked out of the design committee to create the simpler Pascal language.
　　Algol 68 的许多很少使用的语言特性（例如并发和并行块）及其复杂的句法快捷方式和自动类型强制系统使其不受实现者的欢迎，并获得了“难”的名声。Niklaus Wirth实际上退出了设计委员会，以创建更简单的Pascal语言。

　　Some notable languages that were developed in this period include:
　　在此期间开发的一些著名语言包括：

1951 – Regional Assembly Language 1952 – Autocode 1954 – IPL (forerunner to LISP (LISP 的前身) ) 1955 – FLOW-MATIC (led to COBOL) 1957 – FORTRAN (first compiler 第一个编译器) 1957 – COMTRAN (precursor to COBOL) 1958 – LISP 1958 – ALGOL 58 1959 – FACT (forerunner to COBOL) 1959 – COBOL

1959 – RPG 1962 – APL 1962 – Simula 1962 – SNOBOL 1963 – CPL (forerunner to C) 1964 – Speakeasy 1964 – BASIC 1964 – PL/I 1966 – JOSS 1966 – MUMPS 1967 – BCPL (forerunner to C)

Fortran

　Establishing fundamental paradigms(创立基本范式)

　　The period from the late 1960s to the late 1970s brought a major flowering of programming languages. Most of the major language paradigms now in use were invented in this period:^{[original research?]}

　　 从 1960 年代后期到 1970 年代后期，编程语言大放异彩。现在使用的大多数主要语言范式都是在这个时期发明的：^{[原创研究？]}

• Speakeasy, developed in 1964 at Argonne National Laboratory (ANL) by Stanley Cohen, is an OOPS (object-oriented programming system, much like the later MATLAB, IDL and Mathematica) numerical package. Speakeasy has a clear Fortran foundation syntax. It first addressed efficient physics computation internally at ANL, was modified for research use (as "Modeleasy") for the Federal Reserve Board in the early 1970s and then was made available commercially; Speakeasy and Modeleasy are still in use currently.
  Speakeasy 由 Stanley Cohen 于 1964 年在阿贡国家实验室 (是是美国政府最早建立的国家实验室，全称Argonne National Laboratory，简称ANL) 开发，Speakeasy 是一个 OOPS（面向对象编程系统，很像后来的MATLAB、 IDL和Mathematica）数值包。Speakeasy 具有清晰的Fortran基础语法。它首先在 ANL(美国阿贡实验室) 内部解决了高效的物理计算，在 1970 年代初为联邦储备委员会的研究用途（作为“Modeleasy”）进行了修改，然后在商业上可用；Speakeasy 和 Modeleasy 目前仍在使用中。
• 
  
   

  Scheme
• Simula, invented in the late 1960s by Nygaard and Dahl as a superset of Algol 60, was the first language designed to support object-oriented programming.
  Simula由Nygaard和Dahl在 1960 年代后期作为 Algol 60 的超集发明，是第一种旨在支持面向对象编程的语言。
• C, an early systems programming language, was developed by Dennis Ritchie and Ken Thompson at Bell Labs between 1969 and 1973.
  C是一种早期的系统编程语言，由Dennis Ritchie和Ken Thompson在1969 年至 1973 年间在贝尔实验室开发。
• Smalltalk (mid-1970s) provided a complete ground-up design of an object-oriented language.
• Smalltalk（1970 年代中期）提供了面向对象语言的完整基础设计。
• Prolog, designed in 1972 by Colmerauer, Roussel, and Kowalski, was the first logic programming language.
  Prolog由 Colmerauer、Roussel 和 Kowalski 于 1972 年设计，是第一个逻辑编程语言。
• ML built a polymorphic type system (invented by Robin Milner in 1973) on top of Lisp,^[15] pioneering statically typed functional programming languages.
  ML在 Lisp 之上构建了一个多态类型系统（由 Robin Milner 于 1973 年发明）， ^[15]开创了静态类型的 函数式编程语言。

　　Each of these languages spawned an entire family of descendants, and most modern languages count at least one of them in their ancestry.
　　这些语言中的每一种都产生了一个完整的后代家族，而大多数现代语言在其祖先中至少有一种。

　　The 1960s and 1970s also saw considerable debate over the merits of "structured programming", which essentially meant programming without the use of "goto". A significant fraction of programmers believed that, even in languages that provide "goto", it is bad programming style to use it except in rare circumstances. This debate was closely related to language design: some languages did not include a "goto" at all, which forced structured programming on the programmer or tutor.

　　在 1960 年代和 1970 年代，关于“结构化编程”的优点也出现了相当大的争论，这本质上是指不使用“ goto ”的编程。很大一部分程序员认为，即使在提供“goto”的语言中，使用它也是一种糟糕的编程风格，除非在极少数情况下。这场争论与语言设计密切相关：一些语言根本不包含“goto”，这迫使程序员或导师进行结构化编程。

　　To provide even faster compile times, some languages were structured for "one-pass compilers" which expect subordinate routines to be defined first, as with Pascal, where the main routine, or driver function, is the final section of the program listing.

　　为了提供更快的编译时间，一些语言是为“一次性编译器”构建的，这些编译器期望首先定义从属例程，如Pascal，其中主例程或驱动程序函数是程序列表的最后一部分。

　　Some notable languages that were developed in this period include:

　　在此期间开发的一些著名语言包括：

 

1967 – BCPL (forerunner to B) 1968 – Logo 1969 – B (forerunner to C) 1970 – Pascal 1970 – Forth 1972 – C

1972 – Smalltalk 1972 – Prolog 1973 – ML 1975 – Scheme 1978 – SQL (a query language, later extended)

 

　　1980s: consolidation, modules, performance(整合、模块、性能)

The 1980s were years of relative consolidation in imperative languages. Rather than inventing new paradigms, all of these movements elaborated upon the ideas invented in the previous decade. C++ combined object-oriented and systems programming. The United States government standardized Ada, a systems programming language intended for use by defense contractors. In Japan and elsewhere, vast sums were spent investigating so-called fifth-generation programming languages that incorporated logic programming constructs. The functional languages community moved to standardize ML and Lisp. Research in Miranda, a functional language with lazy evaluation, began to take hold in this decade. 　　1980 年代是命令式语言相对整合的年代。所有这些运动都没有发明新的范式，而是详细阐述了前十年发明的想法。C++ 结合了面向对象和系统编程。美国政府对Ada进行了标准化，这是一种供国防承包商使用的系统编程语言。在日本和其他地方，大量资金用于研究包含逻辑编程结构的所谓第五代编程语言。函数式语言社区开始将 ML 和 Lisp 标准化。Miranda是一种具有惰性求值的函数式语言的研究，在这十年中开始占据一席之地。 　　One important new trend in language design was an increased focus on programming for large-scale systems through the use of modules, or large-scale organizational units of code. Modula, Ada, and ML all developed notable module systems in the 1980s. Module systems were often wedded to generic programming constructs---generics being, in essence, parametrized modules[citation needed] (see also polymorphism in object-oriented programming). 　　语言设计的一个重要新趋势是通过使用模块或大规模代码组织单元来增加对大规模系统编程的关注。Modula、Ada 和 ML 都在 1980 年代开发了著名的模块系统。模块系统通常与泛型编程结构结合在一起——泛型本质上是参数化模块[需要引用]（另请参见面向对象编程中的多态性）。 　　Although major new paradigms for imperative programming languages did not appear, many researchers expanded on the ideas of prior languages and adapted them to new contexts. For example, the languages of the Argus and Emerald systems adapted object-oriented programming to distributed systems. 　　尽管没有出现命令式编程语言的主要新范式，但许多研究人员扩展了先前语言的思想并将它们适应新的环境。例如，Argus 和 Emerald 系统的语言使面向对象编程适应了分布式系统。 　　The 1980s also brought advances in programming language implementation. The RISC movement in computer architecture postulated that hardware should be designed for compilers rather than for human assembly programmers. Aided by processor speed improvements that enabled increasingly aggressive compilation techniques, the RISC movement sparked greater interest in compilation technology for high-level languages. 　　1980 年代也带来了编程语言实现的进步。计算机体系结构中的 RISC 运动假设硬件应该是为编译器设计的，而不是为人类汇编程序员设计的。得益于处理器速度的提高，使得编译技术越来越激进，RISC 运动激发了人们对高级语言编译技术的更大兴趣。 　　Language technology continued along these lines well into the 1990s. 　　语言技术沿着这些路线一直延续到 1990 年代。

MATLAB   Erlang   Tcl

 

　　Some notable languages that were developed in this period include:
　　在此期间开发的一些著名(编程)语言包括：

1980 – C++ (as C with classes, renamed in 1983) 1983 – Ada 1984 – Common Lisp 1984 – MATLAB 1984 – dBase III, dBase III Plus (Clipper and FoxPro as FoxBASE, later developing into Visual FoxPro) 1985 – Eiffel 1986 – Objective-C

1986 – LabVIEW (Visual Programming Language) 1986 – Erlang 1987 – Perl 1988 – Tcl 1988 – Wolfram Language (as part of Mathematica, only got a separate name in June 2013) 1989 – FL (Backus)

1990s: the Internet age（互联网时代）

The rapid growth of the Internet in the mid-1990s was the next major historic event in programming languages. By opening up a radically new platform for computer systems, the Internet created an opportunity for new languages to be adopted. In particular, the JavaScript programming language rose to popularity because of its early integration with the Netscape Navigator web browser. Various other scripting languages achieved widespread use in developing customized applications for web servers such as PHP. The 1990s saw no fundamental novelty in imperative languages, but much recombination and maturation of old ideas. This era began the spread of functional languages. A big driving philosophy was programmer productivity. Many "rapid application development" (RAD) languages emerged, which usually came with an IDE, garbage collection, and were descendants of older languages. All such languages were object-oriented. These included Object Pascal, Visual Basic, and Java. Java in particular received much attention. 　　1990 年代中期 Internet 的快速发展是编程语言的下一个重大历史事件。通过为计算机系统开辟一个全新的平台，互联网为采用新语言创造了机会。特别是，JavaScript编程语言因其与 Netscape Navigator 网络浏览器的早期集成而变得流行起来。各种其他脚本语言在为 Web 服务器（如 PHP）开发定制应用程序时得到了广泛的应用。在 1990 年代，命令式语言没有基本的新颖性，而是对旧思想的大量重组和成熟。这个时代开始了函数式语言的传播。一个重要的驱动理念是程序员的生产力。出现了许多“快速应用程序开发”（RAD）语言，它们通常带有IDE，垃圾收集，是旧语言的后代。所有这些语言都是面向对象的。其中包括Object Pascal、Visual Basic和Java。Java 尤其受到关注。 　　More radical and innovative than the RAD languages were the new scripting languages. These did not directly descend from other languages and featured new syntaxes and more liberal incorporation of features. Many consider these scripting languages to be more productive than even the RAD languages, but often because of choices that make small programs simpler but large programs more difficult to write and maintain.[citation needed] Nevertheless, scripting languages came to be the most prominent ones used in connection with the Web. 　　比 RAD 语言更激进和创新的是新的脚本语言。这些并不是直接来自其他语言，而是具有新的语法和更自由的特性结合。许多人认为这些脚本语言甚至比 RAD 语言更有效率，但通常是因为这些选择使小程序更简单，但大程序更难编写和维护。[需要引用]然而，脚本语言成为与 Web 相关的最突出的语言。

Haskell   Lua   PHP   Rebol

 

Some notable languages that were developed in this period include:

　　在此期间开发的一些著名（编程）语言包括：

1990 – Haskell 1990 – Python 1991 – Visual Basic 1993 – Lua 1993 – R 1994 – CLOS (part of ANSI Common Lisp)

1995 – Ruby 1995 – Ada 95                                                     1995 – Java 1995 – Delphi (Object Pascal) 1995 – JavaScript 1995 – PHP 1997 – Rebol

Current trends(当前趋势)

Programming language evolution continues, in both industry and research. Some of the recent trends have included:
在工业和研究领域，编程语言的发展仍在继续。最近的一些趋势包括：

Increasing support for functional programming in mainstream languages used commercially, including pure functional programming for making code easier to reason about and easier to parallelise (at both micro- and macro- levels) 增加对商业上使用的主流语言的函数式编程的支持，包括纯函数式编程，以使代码更易于推理和更易于并行化（在微观和宏观层面） Constructs to support concurrent and distributed programming. 支持并发和分布式编程的构造 Mechanisms for adding security and reliability verification to the language: extended static checking, dependent typing, information flow control, static thread safety. 为语言添加安全性和可靠性验证的机制：扩展静态检查、依赖类型、信息流控制、静态线程安全。 Alternative mechanisms for composability and modularity: mixins, traits, typeclasses, delegates, aspects. 可组合性和模块化的替代机制：mixins、traits、typeclasses、delegate、方面。 Component-oriented software development. 面向组件的软件开发。 Metaprogramming, reflection or access to the abstract syntax tree 元编程、反射或访问抽象语法树 AOP or Aspect Oriented Programming allowing developers to insert code in another module or class at "join points" Domain specific languages and code generation XML for graphical interface (XUL, XAML) AOP 或面向方面的编程允许开发人员在“连接点”处插入另一个模块或类中的代码 领域特定语言和代码生成 用于图形界面的 XML（XUL、XAML） Increased interest in distribution and mobility. 对分配和流动性的兴趣增加。 Integration with databases, including XML and relational databases. 与数据库集成，包括XML和关系数据库。 Open source as a developmental philosophy for languages, including the GNU Compiler Collection and languages such as Python, Ruby, and Scala. 开源作为一种语言的发展理念，包括 GNU 编译器集合和Python、Ruby和Scala等语言。 More interest in visual programming languages like Scratch, LabVIEW and PWCT 对Scratch、LabVIEW和 PWCT等可视化编程语言更感兴趣 Massively parallel languages for coding 2000 processor GPU graphics processing units and supercomputer arrays including OpenCL 用于编码 2000 个处理器 GPU 图形处理单元和超级计算机阵列（包括OpenCL ）的大规模并行语言对（尚未实现的）量子计算编程语言的早期研究 Early research into (as-yet-unimplementable) quantum computing programming languages 应用人工智能技术生成代码的早期研究，例如使用 GPT-3 [16] Early research in applying Artificial Intelligence techniques to generate code like using GPT-3[16]

D Programming Language   Groovy   PowerShell   Rust   Scratch

Some notable languages developed during this period include:^{[17][18]
在此期间开发的一些著名语言包括：[17] [18]}

2000 – ActionScript 2001 – C# 2001 – D 2002 – Scratch 2003 – Groovy                                                2003 – Scala 2005 – F# 2006 – PowerShell 2007 – Clojure

2008 – Nim 2009 – Go 2010 – Rust 2011 – Dart 2011 – Kotlin 2011 – Elixir 2012 – Julia 2012 – TypeScript 2014 – Swift

　　Other new programming languages include Red, Crystal, Elm, Hack, Haxe, Zig, Reason and Ballerina.

　　Prominent people(杰出人士)

Anders Hejlsberg

Yukihiro Matsumoto

Grace M. Hopper

Bjarne Stroustrup

Niklaus Wirth

 

　　一些帮助开发编程语言的关键人物:

• Alan Cooper, developer of Visual Basic. (Alan Cooper开发了VB)
• Alan Kay, pioneering work on object-oriented programming, and originator of Smalltalk.
• Anders Hejlsberg,    developer of Turbo Pascal, Delphi, C#, and TypeScript.
• Arthur Whitney,        developer of A+, k, and q.
• Bertrand Meyer        inventor of Eiffel.
• Bjarne Stroustrup,    developer of C++. (C++之父Bjarne Stroustrup创造了C++)
• Brian Kernighan,      co-author of the first book on the C programming language with Dennis Ritchie, coauthor of the AWK and AMPL programming languages.
• Chuck Moore,           inventor of Forth, the first concatenative programming language, and a prominent name in stack machine 　　microprocessor design.
• Chris Lattner,            creator of Swift and LLVM.
• Cleve Moler,              creator of MATLAB.
• Dennis Ritchie,          inventor of C. Unix Operating System, Plan 9 Operating System.
• Douglas McIlroy, influenced and designed such languages as SNOBOL, TRAC, PL/I, ALTRAN, TMG and C++.
• Grace Hopper, first to use the term compiler and developer of FLOW-MATIC, influenced development of COBOL. Popularized machine-independent programming languages and the term "debugging".
• Guido van Rossum,  creator of Python.
• James Gosling,         lead developer of Java and its precursor, Oak.
• Jean Ichbiah, chief    designer of Ada, Ada 83.
• Jean-Yves Girard,     co-inventor of the polymorphic lambda calculus (System F).
• Jeff Bezanson, main  designer, and one of the core developers of Julia.
• Jeffrey Snover, 　　  inventor of PowerShell.
• Joe Armstrong,          creator of Erlang.
• John Backus,             inventor of Fortran and cooperated in the design of ALGOL 58 and ALGOL 60.
• John C. Reynolds,     co-inventor of the polymorphic lambda calculus (System F).
• John McCarthy,          inventor of LISP.
• John von Neumann,   originator of the operating system concept.
• Graydon Hoare,         inventor of Rust.
• Ken Thompson,          inventor of B, Go, Inferno (operating system) and Unix Operating System co-author.
• Kenneth E. Iverson,    developer of APL, and co-developer of J along with Roger Hui.
• Konrad Zuse,              designed the first high-level programming language, Plankalkül (which influenced ALGOL 58^[19]).
• Kristen Nygaard,         pioneered object-oriented programming, co-invented Simula.
• Larry Wall,                   creator of the Perl programming language (see Perl and Raku).
• Martin Odersky,           creator of Scala, and previously a contributor to the design of Java.
• Martin Richards           developed the BCPL programming language, forerunner of the B and C languages.
• Nathaniel Rochester,   inventor of first assembler (IBM 701).
• Niklaus Wirth,              inventor of Pascal, Modula and Oberon.
• Ole-Johan Dahl,          pioneered object-oriented programming, co-invented Simula.
• Rasmus Lerdorf,          creator of PHP.
• Rich Hickey,                 creator of Clojure.
• Jean Paoli,                   co-creater of XML
• Robert Gentleman,      co-creator of R.
• Robert Griesemer,       co-creator of Go.
• Robin Milner,                inventor of ML, and sharing credit for Hindley–Milner polymorphic type inference.
• Rob Pike,                     co-creator of Go, Inferno (operating system) and Plan 9 (operating system) Operating System co-author.
• Ross Ihaka,                  co-creator of R.
• Stanley Cohen,             inventor of Speakeasy, which was created with an OOPS, object-oriented programming system, the first instance, in 1964.
• Stephen Wolfram,         creator of Mathematica.
• Brad Cox,                      co-creator of Objective-C.
• Walter Bright,                 creator of D.
• Yukihiro Matsumoto,      creator of Ruby.
• Ryan Dahl,                     creator of Node.js.

　　也看看

ACM SIGPLAN History of Programming Languages Conference History of compiler writing History of computing hardware

Programming language Timeline of computing Timeline of programming languages List of programming languages List of programmers

　　参考

1. ^ Hopper (1978) p. 16.
2. ^ Knuth, Donald E.; Pardo, Luis Trabb. "Early development of programming languages". Encyclopedia of Computer Science and Technology. Marcel Dekker. 7: 419–493.
3. ^ Corrado Böhm's PhD thesis
4. ^ J. Fuegi and J. Francis (October–December 2003), "Lovelace & Babbage and the creation of the 1843 'notes'", Annals of the History of Computing, 25 (4): 16–26, doi:10.1109/MAHC.2003.1253887
5. ^ In 1998 and 2000 compilers were created for the language as a historical exercise. Rojas, Raúl, et al. (2000). "Plankalkül: The First High-Level Programming Language and its Implementation". Institut frame Informatik, Freie Universität Berlin, Technical Report B-3/2000. (full text)
6. ^ Sebesta, W.S. (2006). Concepts of Programming Languages. p. 44. ISBN 978-0-321-33025-3.
7. ^ "Fortran creator John Backus dies - Tech and gadgets- NBC News". NBC News. 2007-03-20. Retrieved 2010-04-25.
8. ^ "CSC-302 99S : Class 02: A Brief History of Programming Languages". Math.grin.edu. Archived from the original on 2010-07-15. Retrieved 2010-04-25.
9. ^ Padua, David (Feb 2000). "The FORTRAN I Compiler" (PDF). Computing in Science and Engineering. 2 (1): 70–75. doi:10.1109/5992.814661. Retrieved 7 November 2019.
10. ^ Eugene Loh (18 June 2010). "The Ideal HPC Programming Language". Queue. Association of Computing Machines. 8 (6).
11. ^ "HPL - A Portable Implementation of the High-Performance Linpack Benchmark for Distributed-Memory Computers". Retrieved 2015-02-21.
12. ^ Hopper (1978) p. 16.
13. ^ Sammet (1969) p. 316
14. ^ Sammet (1978) p. 204.
15. ^ Gordon, Michael J. C. (1996). "From LCF to HOL: a short history" (PDF). p. 3. Retrieved 2015-05-04. Edinburgh LCF, including the ML interpreter, was implemented in Lisp.
16. ^ Manjoo, Farhad (July 29, 2020). "How Do You Know a Human Wrote This?". The New York Times. ISSN 0362-4331. Retrieved August 4, 2020.
17. ^ TIOBE (25 May 2018). "TIOBE Index, Top 100 programming languages according to TIOBE Index". www.tiobe.com. TIOBE_index.
18. ^ "GitHub's Octoverse 2018". Archived from the original on 2019-03-22.
19. ^ Rojas, Raúl; Hashagen, Ulf (2002). The First Computers: History and Architectures. MIT Press. p. 292. ISBN 978-0262681377. Retrieved October 25, 2013.

更多阅读

• Rosen, Saul, (editor), Programming Systems and Languages, McGraw-Hill, 1967.
• Sammet, Jean E., Programming Languages: History and Fundamentals, Prentice-Hall, 1969.
• Sammet, Jean E. (July 1972). "Programming Languages: History and Future". Communications of the ACM. 15 (7): 601–610. doi:10.1145/361454.361485. S2CID 2003242.
• Richard L. Wexelblat (ed.): History of Programming Languages, Academic Press 1981.
• Thomas J. Bergin and Richard G. Gibson (eds.): History of Programming Languages, Addison Wesley, 1996.

外部链接

• History and evolution of programming languages
• Graph of programming language history

By: Wikipedia.org
Edited: 2021-06-18 18:22:40
Source: Wikipedia.org


其它参考列表

　Hopper, Grace (1978). Keynote Address, History of Programming Languages I. ACM. pp. 16–20. ISBN 0-12-745040-8

     翻译: 格蕾丝·霍珀 (1978)。主题演讲，编程语言的历史 I。ACM。第 16-20 页。国际标准书号 0-12-745040-8

　　https://dl.acm.org/profile/99659389464
　　https://dl.acm.org/doi/book/10.1145/800025
　　https://doi.org/10.1145/800025
　　https://www.sciencedirect.com/book/9780127450407/history-of-programming-languages?via=ihub=