某些编程功能是何时以何种语言引入的?

发布于 2024-07-25 18:31:21 字数 537 浏览 4 评论 0原文

编程已经取得了长足的进步。 我还比较年轻(第一台计算机:C64),因此我认为编程中的许多东西是理所当然的,这些东西显然是在某个时候引入的,并且促进了现在常见的编程方式。

下面是一个(绝不是完整的)功能列表,我很想知道它们是用哪种语言以及何时引入的:

  • 函数简介
  • 编译语言
  • 解释语言
  • 条件和条件 循环结构
  • 数组
  • 字典(哈希表)
  • 允许多线程
  • 函数式编程(函数作为数据)
  • 面向对象(我们需要更具体吗?也许继承比接口更早存在?)
  • 泛型
  • 面向方面编程
  • 元编程

如果你可以尝试用一些参考资料来支持你的陈述。 如果您觉得我错过了一个重要的编程语言功能,其介绍也应该受到赞赏,请对此问题发表评论,以便可以将其添加到列表中。

更新: 我认为编程语言不能引入任何在汇编程序中不可能的东西,我宁愿寻找那些使“凡人”可以使用某些功能的语言。

Programming has come a long way. I am still relatively young (first Computer: C64), hence I take many things in programming for granted that were obviously introduced at some point and facilitated ways of programming that are now commonplace.

What follows is a (by no means complete) list of features, where I would love to know in which language and when they were introduced:

  • introduction of functions
  • compiled language
  • interpreted language
  • conditional & loop structures
  • the array
  • the dictionary (Hashtable)
  • allowance of multi-threading
  • functional programming (functions as data)
  • object orientation (do we need to be more specific? maybe inheritance was there earlier than interfaces?)
  • generics
  • aspect-oriented programming
  • meta-programming

If you can, try to back up your statement with some reference. If you feel I have missed an important programming language feature whose introduction should also be appreciated, please comment on this question such that it can be added to the list.

UPDATE:
I suppose that a programming language cannot introduce anything that wouldn't be possible in assembler, I'm rather looking for languages that made a certain feature available to "mere mortals".

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(5

在巴黎塔顶看东京樱花 2024-08-01 18:31:22

据我所知(并在维基百科的帮助下),我将陈述以下内容:

  • 函数 - 早期汇编,使用“跳转到子程序”等指令。
  • 编译语言 - 可以说是 1952 年的 A-0 或 [ FORTRAN](http://en.wikipedia.org/wiki/FORTRAN,1957 年。
  • < strong>解释性语言 - Smalltalk (?) 在 20 世纪 70 年代
  • 。条件和循环结构 - 早期汇编,使用分支/跳转
  • 。 >数组 - 在最早的计算机中使用(1940 年代),作为 FORTRAN 中的语言功能出现。 。请参阅此文
  • 本 -与数组大约在同一时间,因为它仅在数组数据结构之上真正使用基本算法。 作为一个类,可能是 Smalltalk 中的 Dictionary
  • 多线程 - 这也是操作系统/库的一个功能,尽管语言功能当然可以促进多线程编码。 不过,它可能可以追溯到 20 世纪 60 年代/1970 年代,而且我想它可以在 Assemby 中完成。
  • 函数式编程 - LISP 在 20 世纪 50 年代,受到艾伦图灵的< a href="http://en.wikipedia.org/wiki/Lambda_calculus" rel="nofollow noreferrer">lambda 演算。
  • 面向对象 (OOP) - 20 世纪 60 年代的 Simula
  • 泛型 - 20 世纪 70 年代的 CLU
  • 面向方面的编程 - 也许是 2001 年的AspectJ。(有人可能需要纠正我这一点。)
  • 元编程 - 早期汇编,具有自修改代码。

请随时修改/更新任何附加信息。

To the best of my knowledge (and with the help of Wikipedia), I would state the following:

  • Functions - Early Assembly, using instructions such as "jump to subroutine".
  • Compiled language - Arguably A-0 in 1952 or [FORTRAN](http://en.wikipedia.org/wiki/FORTRAN in 1957.
  • Interpreted language - Smalltalk (?) in the 1970s.
  • Conditional & Loop structures - Early Assembly, using branches/jumps.
  • Arrays - Used in the very earliest computers (1940s). Appeared as a language feature in FORTRAN. See this text.
  • Hashtable - Around the same time as arrays, since it only really uses a basic algorithm on top of an array data structure. As a class, perhaps Dictionary in Smalltalk.
  • Multi-threading - This is moreover a feature of the operating system/a library, though language features can of course facilitate multithreaded coding. It probably dates back to the 1960s/1970s, though, and I'd imagine it could be done in Assemby.
  • Functional programming - LISP in the 1950s, inspired by Alan Turing's lambda calculus.
  • Object orientation (OOP) - Simula in the 1960s.
  • Generics - CLU in the 1970s.
  • Aspect-oriented programming - Perhaps AspectJ in 2001. (Someone may need to correct me on this.)
  • Meta-programming - Early Assembly, with self-modifying code.

Please feel free to modify/update this with any additional information.

秋意浓 2024-08-01 18:31:22

您可以在此处使用语言图表:http://www.levenez.com/lang/ 和维基百科寻找答案。 对于初学者来说:自 Fortran 以来,函数、循环和条件就一直存在。 然后,1958 年 Lisp 出现了,我想有些人会说其余的都是那时出现的:)

You could use a language graph here: http://www.levenez.com/lang/ and Wikipedia to find answers. For starters: functions, loops and conditionals are with us since Fortran. And then, in 1958 Lisp arrived, I think some will argue that the rest came then :)

感受沵的脚步 2024-08-01 18:31:22

寻找第一总是会导致头发分叉。 我敢打赌,你提到的任何事情在大受欢迎之前都已经做过好几次了。 尽管如此,这里有一个尝试:

  • 函数——FORTRAN,但不是递归的。 用于递归的 LISP 或 Algol。
  • 编译语言 -- FORTRAN
  • 解释语言 -- LISP
  • 条件和循环结构 -- FORTRAN,但 Algol 给了我们数组结构
  • 编程 -- FORTRAN
  • 字典 -- Snobol,我认为
  • 允许多线程 -- PL/I
  • 函数式编程 -- - LISP 但也许不是强意义上的。
  • 面向对象——Simula,但 Smalltalk 是真正的普及者
  • 泛型——不知道
  • 面向方面——不知道
  • 元编程——也许是 C++,但代码生成代码并不是一个新想法

Finding firsts always leads to hair splitting. I'll bet any of the things you mentioned were done several times over before they hit the big time. Nonetheless, here's an attempt:

  • functions -- FORTRAN, but not recursive. LISP or Algol for recursion.
  • compiled language -- FORTRAN
  • interpreted language -- LISP
  • conditional and loop structures -- FORTRAN, but Algol gave us structure programming
  • the array -- FORTRAN
  • the dictionary -- Snobol, I think
  • allowance of multi-threading -- PL/I
  • functional programming -- LISP but perhaps not in a strong sense.
  • object orientation -- Simula but Smalltalk was the real popularizer
  • generics -- dunno
  • aspect-oriented -- dunno
  • meta-programming -- perhaps C++, but then code generating code isn't a new idea
∞琼窗梦回ˉ 2024-08-01 18:31:22

我想我们可以放心地说“汇编程序”。 大多数(如果不是全部)这些概念已经存在很长时间了。

I think we can safely say "assembler". Most if not all of these concepts have been around for a very long time.

眼眸 2024-08-01 18:31:21

口齿不清。 1958.

或者,

  • 函数介绍 - Alonzo Church 的 lambda 演算,1930

  • 编译语言 - Grace Hopper,1952

  • 解释语言 - Lisp,1958,也许之前的东西。

  • 有条件& 循环结构 - Bletchley Park Bombe 1940 年代(循环运行)。 提花,1801

  • 数组 - 作为带有索引的连续内存块,Bletchley Park 或 Manchester Baby,1940 年代

  • 字典(Hashtable)-?

  • 允许多线程 - Jacquard,1801; Multix 1965

  • 函数式编程(函数作为数据) - Godel,1930 年代

  • 面向对象

    • Simula(Dahl 和 Nygaard 1967),用于具有继承的基于类的 OO
    • CLU(Liskov 1975)迭代器有一个通用接口,并允许具有封装状态和行为的抽象数据类型
    • Smalltalk(Kay,1970 年代末)“一切皆对象”
    • Eifell (Meyer 1986) 的契约设计影响了 Java 的接口
  • 泛型 - 泛型方法(又是 Lisp)还是参数类型(modula???)?

  • 面向方面编程 - common lisp 元对象协议,20 世纪 80 年代末

  • 元编程 - lisp 宏,20 世纪 50 年代或60 年代

Lisp. 1958.

Alternatively,

  • introduction of functions - Alonzo Church's lambda calculus, 1930

  • compiled language - Grace Hopper, 1952

  • interpreted language - Lisp, 1958, maybe something before.

  • conditional & loop structures - Bletchley Park Bombe 1940s ( ran in a loop ). Jacquard, 1801

  • the array - as a contiguous chunk of memory with an index, Bletchley Park or Manchester Baby, 1940s

  • the dictionary (Hashtable) - ?

  • allowance of multi-threading - Jacquard, 1801; Multix 1965

  • functional programming (functions as data) - Godel, 1930s

  • object orientation

    • Simula ( Dahl and Nygaard 1967 ) for class based OO with inheritance
    • CLU ( Liskov 1975 ) iterators had a common interface, and allowed abstract data types with encapsulated state and behaviour
    • Smalltalk ( Kay late 1970s ) 'everything is an object'
    • Eifell ( Meyer 1986 ) design by contract influenced Java's interfaces
  • generics - generic methods ( Lisp again ) or parametric types ( modula??? )?

  • aspect-oriented programming - common lisp meta-object protocol, late 1980s

  • meta-programming - lisp macros, sometime in the 50s or 60s

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文