1966年图灵奖——艾伦·佩利（Alan J. Perlis）

图灵奖

艾伦·杰·佩利（Alan Jay Perlis，1922年4月1日－1990年2月7日），生于美国宾夕法尼亚州匹兹堡，是美国计算机程序设计领域的科学家，首届图灵奖的获得者。 

<span style="font-family:sans-serif;font-size:15px;line-height:22.066667556762695px;background-color:#FFFFFF;">![](http://zt2peilong-wordpress.stor.sinaapp.com/uploads/2014/02/Alan-Perlis.jpg) </span> 

Alan Perlis获得图灵奖的颁奖词如下：

由于其在[高级程序设计](http://zh.wikipedia.org/w/index.php?title=%E9%AB%98%E7%BA%A7%E7%A8%8B%E5%BA%8F%E8%AE%BE%E8%AE%A1&amp;action=edit&amp;redlink=1 "%E9%AB%98%E7%BA%A7%E7%A8%8B%E5%BA%8F%E8%AE%BE%E8%AE%A1&amp;action=edit&amp;redlink=1")技术和[编译器](http://zh.wikipedia.org/wiki/%E7%BC%96%E8%AF%91%E5%99%A8)构造方面的影响。

（_for his influence in the area of advanced programming techniques and compiler construction_）

从获奖词我们看出Alan Perlis最大的贡献就是他的ALGOL语言了。

_下面内容转载自《[程序员](http://www.programmer.com.cn/4752/#more-4752)》。_ 

当我们提起高级语言的先驱，首先想到的总是Dennis Ritchie、Bjarne Stroustrup这些主流语言的设计者，似乎很少会提到Alan Perlis这个名字。但Alan Perlis主持设计的ALGOL，趋势C/C++等语言的鼻祖。

Alan Perlis 1922年出生于美国匹兹堡犹太家庭。21岁时，他获得了卡内基理工学院的化学学士学位，这个学院后来发展为现在美国计算机专业排名第一的卡内基梅隆大学。时逢二战，他弃笔从戎。服役期间，他突然对数学产生了强烈兴趣，并在1950年， 从麻省理工学院获得了数学博士学位。两年后他来到普渡大学，出任普渡大学计算中心首任主任，并将IBM CPC计算机引入了普渡，还为其设计了一个叫作IT（Internal Translator）的编程语言。四年之后，他又一跃当上了卡内基理工学院第一任计算机科学系主任，在卡耐基引入了IBM 650，并将IT语言移植到650上。这些使他在程序语言的设计方面，有了许多经验和体会。当ACM成立程序设计语言委员会时，Perlis坐上了主席的位置。

1958年5月27日，瑞士苏黎世召开了一场8个人的讨论会。这个会议并不隆重。ACM的4名代表和德国应用数学和力学学会（GAMM）的4名代表，索性把地点和双方名称连起来，叫苏黎世ACM-GAMM会议。这场会议的组织者，就是Alan Perlis。他们将要在此讨论并规划一种新型的编程语言，叫作国际代数语言（IAL）。

世界上第一个高级语言Fortran存在一些严重的缺陷。比如说它专门为IBM 704设计的，要依赖特定的机器型号工作，很难向其他机器移植等等。IAL的专家们力求设计一种更好的高级语言。在讨论过程中，Perlis认为 “IAL”这个词很绕口，于是将它改名叫作ALGOL。会议结束后，他们成立了一个工作组，根据讨论的结果，开发ALGOL的编译器。1958年年底，第一套编译器诞生了，按照年份命名为ALGOL 58。1960年，Alan Perlis总结了一些经验之后，再次召集参与ALGOL工作的计算机科学家们在巴黎进行了另一场研讨。这场会议的结果，就是后来的ALGOL 60。

1960年夏天，Dijkstra开发了第一个ALGOL 60的编译器，于是ALGOL系列语言正式登上了计算机科学的舞台。随后，Alan Perlis将它引入了大学的课堂。这是Alan Perlis的另一个重要贡献，因为在那个时代，计算机科学混沌初开，程序设计都只是数值分析的一部分。经过Alan Perlis的努力，人们终于看到计算机科学应该是什么样子。Dijkstra后来说，这是一个伟大的标志，可以说直到这个时候，计算机科学才真正地诞生了。而在接下来的30年里，ALGOL一直是教学和学术界用来描述算法的不二之选。它体现出的许多概念，都被后来的编程语言沿用。包括C、C++和 Pascal在内许多主流语言，都因为继承了ALGOL的许多概念，而被称为“类ALGOL语言”。

Alan Perlis因领导了ALGOL的设计工作，并在早期计算机教育中做出了重要贡献，在1962年当选为美国计算机学会的主席，并在四年后，因为他对高级编程技术及其编译器构造的影响成为历史上首位图灵奖得主。五年后，他跳槽到耶鲁大学，连任多年计算机科学系主任，1977年当选美国工程院院士。1982 年，退休后的Alan Perlis返老还童，写下了名文“Epigrams on Programming”，发表在ACM的SIGPLAN期刊上。其中包含130条编程箴言，可能是被引用最广泛的计算机文章之一。在发表在ACM的 SIGPLAN期刊上，他写下了一系列关于编程的幽默：“如果你给别人讲解程序时，看到对方点头了，那你就拍他一下，他肯定睡觉了。”

Alan Perlis为名著《[计算机程序的构造和解释](http://www.amazon.cn/mn/detailApp/ref=as_li_qf_sp_asin_tl?_encoding=UTF8&amp;tag=vastwork-23&amp;linkCode=as2&amp;asin=B0011AP7RY&amp;camp=536&amp;creative=3200&amp;creativeASIN=B0011AP7RY)》所写的序中写道，**如果说艺术解释了我们的梦想，那么计算机就是以程序的名义执行着它们。**计算机科学中特别重要的一点是保持趣味性，不要局限于眼前，应该不断寻找新方向，扩展计算机的能力。这些话今天听来，依然发人深省。

1990年2月7日，Alan Perlis因心脏病在纽哈芬去世，享年68岁。

_下面内容是Alan Perlis的《Epigrams On Programming》_ 

<!--more-->


Epigrams on Programming


Alan J. Perlis


Yale University

This text has been published in SIGPLAN Notices Vol. 17, No. 9, September 1982, pages 7 - 13. I’m offering it here online until ACM stops me. 

The phenomena surrounding computers are diverse and yield a surprisingly rich base for launching metaphors at individual and group activities. Conversely, classical human endeavors provide an inexhaustible source of metaphor for those of us who are in labor within computation. Such relationships between society and device are not new, but the incredible growth of the computer's influence (both real and implied) lends this symbiotic dependency a vitality like a gangly youth growing out of his clothes within an endless puberty.

The epigrams that follow attempt to capture some of the dimensions of this traffic in imagery that sharpens, focuses, clarifies, enlarges and beclouds our view of this most remarkable of all mans' artifacts, the computer.
  1. One man’s constant is another man’s variable.（一个人的常量是别人的变量）
  2. Functions delay binding: data structures induce binding. Moral: Structure data late in the programming process.（这个翻译不来==）
  3. Syntactic sugar causes cancer of the semicolons.（糖衣语法容易引起分号的问题？）
  4. Every program is a part of some other program and rarely fits.（每一段程序都是另外一段程序的一部分，但总有差别？）
  5. If a program manipulates a large amount of data, it does so in a small number of ways.（一段程序只有使用很少的方法操纵了一大堆的数据？）
  6. Symmetry is a complexity reducing concept (co-routines include sub-routines); seek it everywhere.（追求对称性是一种降低复杂度的方法（和子函数合作），我们要不断的去追求）
  7. It is easier to write an incorrect program than understand a correct one.（写一段错误的程序比理解一段正确的程序容易）
  8. A programming language is low level when its programs require attention to the irrelevant.（如果一种程序语言关注一些不相关的东西，那么它就是低级的）
  9. It is better to have 100 functions operate on one data structure than 10 functions on 10 data structures.（使用100个函数操作一个数据结构比使用是个函数操作10个数据结构好）
  10. Get into a rut early: Do the same processes the same way. Accumulate idioms. Standardize. The only difference (!) between Shakespeare and you was the size of his idiom list - not the size of his vocabulary.（开始积累：使用同样的方法做同样的事，积累常用方法和标准。你和莎士比亚的区别不是在于单词量上的差距，而是在于习语上）
  11. If you have a procedure with 10 parameters, you probably missed some.（如果你需要处理十个参数，你最好忽略掉其中一些）
  12. Recursion is the root of computation since it trades description for time.（递归是计算的根本，应为它更加容易表示清楚，虽然花了更多的时间）
  13. If two people write exactly the same program, each should be put in micro-code and then they certainly won’t be the same.（如果两个人写了完全一样的程序，那么把程序放缩到微代码级别，他们的程序一定是不一样的）
  14. In the long run every program becomes rococo - then rubble.（每个程序长时间运行都会变的很渣）
  15. Everything should be built top-down, except the first time.（每次应该从顶至下的构造，除了第一次）
  16. Every program has (at least) two purposes: the one for which it was written and another for which it wasn’t.（每次写程序都有2个目标：一个是写你想要的功能，另一个是写你不想要的功能）
  17. If a listener nods his head when you’re explaining your program, wake him up.（你向别人讲你的程序，如果他点头了，那么他一定是睡着了）
  18. A program without a loop and a structured variable isn’t worth writing.（一个没有循环和结构化变量的程序是不值得写的）
  19. A language that doesn’t affect the way you think about programming, is not worth knowing.（一个不能影响你思考程序的编程语言是不值得去学习的）
  20. Wherever there is modularity there is the potential for misunderstanding: Hiding information implies a need to check communication.（只有有模块化，那就有误解的可能，隐藏信息基本上都意味着需要交流）
  21. Optimization hinders evolution.（优化阻碍发展）
  22. A good system can’t have a weak command language.（好的系统一定有个强大的控制语言）
  23. To understand a program you must become both the machine and the program.（理解一个程序的最佳方式就是把你自己变成机器和程序）
  24. Perhaps if we wrote programs from childhood on, as adults we’d be able to read them.（如果我们从小就开始写程序，那么当我们成年的时候我们就有能力去读他们了）
  25. One can only display complex information in the mind. Like seeing, movement or flow or alteration of view is more important than the static picture, no matter how lovely.（人只能在脑中展现复杂的信息。就像是远闻不如一见）
  26. There will always be things we wish to say in our programs that in all known languages can only be said poorly.（总是会出现这样的事儿：每个人都认为自己的程序是最好）
  27. Once you understand how to write a program get someone else to write it.（一旦你某一天理解了如何去写程序，就叫另外一个人去写）
  28. Around computers it is difficult to find the correct unit of time to measure progress. Some cathedrals took a century to complete. Can you imagine the grandeur and scope of a program that would take as long?（计算机里很难去找到正确的单位时间去丈量进步）
  29. For systems, the analogue of a face-lift is to add to the control graph an edge that creates a cycle, not just an additional node.（对于一个系统，模拟一个侧面就是在控制图中增加一个边创造一个循环，而不是仅仅增加一个节点）
  30. In programming, everything we do is a special case of something more general - and often we know it too quickly.（在写程序里，我们做的大多数都是一般情况中的个例，我们经常知道的太快了）
  31. Simplicity does not precede complexity, but follows it.（简单的方法不意味着领先复杂的方法，但是还是要做用简单的方法）
  32. Programmers are not to be measured by their ingenuity and their logic but by the completeness of their case analysis.（程序猿的评估方法不是他们的天赋和逻辑，是他们分析问题的完整程度）
  33. The 11th commandment was “Thou Shalt Compute” or “Thou Shalt Not Compute” - I forget which.（我不记得第十一诫里应该是“你应该计算”还是“你不该计算”）
  34. The string is a stark data structure and everywhere it is passed there is much duplication of process. It is a perfect vehicle for hiding information.（字符串是一种很爽的数据结构，无论什么时候都是通过复制操作进行传送的，这简直是隐藏信息的良器）
  35. Everyone can be taught to sculpt: Michelangelo would have had to be taught how not to. So it is with the great programmers.（你可以教任何人雕刻：但是对米开朗基罗来说，他应该被教那些事儿不能去做，这对于好的程序员也是一样的）
  36. The use of a program to prove the 4-color theorem will not change mathematics - it merely demonstrates that the theorem, a challenge for a century, is probably not important to mathematics.（）
  37. The most important computer is the one that rages in our skulls and ever seeks that satisfactory external emulator. The standardization of real computers would be a disaster - and so it probably won’t happen.
  38. Structured Programming supports the law of the excluded muddle.
  39. Re graphics: A picture is worth 10K words - but only those to describe the picture. Hardly any sets of 10K words can be adequately described with pictures.
  40. There are two ways to write error-free programs; only the third one works.
  41. Some programming languages manage to absorb change, but withstand progress.
  42. You can measure a programmer’s perspective by noting his attitude on the continuing vitality of FORTRAN.
  43. In software systems it is often the early bird that makes the worm.
  44. Sometimes I think the only universal in the computing field is the fetch-execute-cycle.
  45. The goal of computation is the emulation of our synthetic abilities, not the understanding of our analytic ones.
  46. Like punning, programming is a play on words.
  47. As Will Rogers would have said, “There is no such thing as a free variable.”
  48. The best book on programming for the layman is “Alice in Wonderland”; but that’s because it’s the best book on anything for the layman.
  49. Giving up on assembly language was the apple in our Garden of Eden: Languages whose use squanders machine cycles are sinful. The LISP machine now permits LISP programmers to abandon bra and fig-leaf.
  50. When we understand knowledge-based systems, it will be as before - except our finger-tips will have been singed.
  51. Bringing computers into the home won’t change either one, but may revitalize the corner saloon.
  52. Systems have sub-systems and sub-systems have sub-systems and so on ad infinitum - which is why we’re always starting over.
  53. So many good ideas are never heard from again once they embark in a voyage on the semantic gulf.
  54. Beware of the Turing tar-pit in which everything is possible but nothing of interest is easy.
  55. A LISP programmer knows the value of everything, but the cost of nothing.
  56. Software is under a constant tension. Being symbolic it is arbitrarily perfectible; but also it is arbitrarily changeable.
  57. It is easier to change the specification to fit the program than vice versa.
  58. Fools ignore complexity. Pragmatists suffer it. Some can avoid it. Geniuses remove it.
  59. In English every word can be verbed. Would that it were so in our programming languages.
  60. Dana Scott is the Church of the Lattice-Way Saints.
  61. In programming, as in everything else, to be in error is to be reborn.
  62. In computing, invariants are ephemeral.
  63. When we write programs that “learn”, it turns out we do and they don’t.
  64. Often it is means that justify ends: Goals advance technique and technique survives even when goal structures crumble.
  65. Make no mistake about it: Computers process numbers - not symbols. We measure our understanding (and control) by the extent to which we can arithmetize an activity.
  66. Making something variable is easy. Controlling duration of constancy is the trick.
  67. Think of all the psychic energy expended in seeking a fundamental distinction between “algorithm” and “program”.
  68. If we believe in data structures, we must believe in independent (hence simultaneous) processing. For why else would we collect items within a structure? Why do we tolerate languages that give us the one without the other?
  69. In a 5 year period we get one superb programming language. Only we can’t control when the 5 year period will begin.
  70. Over the centuries the Indians developed sign language for communicating phenomena of interest. Programmers from different tribes (FORTRAN, LISP, ALGOL, SNOBOL, etc.) could use one that doesn’t require them to carry a blackboard on their ponies.
  71. Documentation is like term insurance: It satisfies because almost no one who subscribes to it depends on its benefits.
  72. An adequate bootstrap is a contradiction in terms.
  73. It is not a language’s weaknesses but its strengths that control the gradient of its change: Alas, a language never escapes its embryonic sac.
  74. It is possible that software is not like anything else, that it is meant to be discarded: that the whole point is to always see it as soap bubble?
  75. Because of its vitality, the computing field is always in desperate need of new cliches: Banality soothes our nerves.
  76. It is the user who should parameterize procedures, not their creators.
  77. The cybernetic exchange between man, computer and algorithm is like a game of musical chairs: The frantic search for balance always leaves one of the three standing ill at ease.
  78. If your computer speaks English it was probably made in Japan.
  79. A year spent in artificial intelligence is enough to make one believe in God.
  80. Prolonged contact with the computer turns mathematicians into clerks and vice versa.
  81. In computing, turning the obvious into the useful is a living definition of the word “frustration”.
  82. We are on the verge: Today our program proved Fermat’s next-to-last theorem!
  83. What is the difference between a Turing machine and the modern computer? It’s the same as that between Hillary’s ascent of Everest and the establishment of a Hilton hotel on its peak.
  84. Motto for a research laboratory: What we work on today, others will first think of tomorrow.
  85. Though the Chinese should adore APL, it’s FORTRAN they put their money on.
  86. We kid ourselves if we think that the ratio of procedure to data in an active data-base system can be made arbitrarily small or even kept small.
  87. We have the mini and the micro computer. In what semantic niche would the pico computer fall?
  88. It is not the computer’s fault that Maxwell’s equations are not adequate to design the electric motor.
  89. One does not learn computing by using a hand calculator, but one can forget arithmetic.
  90. Computation has made the tree flower.
  91. The computer reminds one of Lon Chaney - it is the machine of a thousand faces.
  92. The computer is the ultimate polluter. Its feces are indistinguishable from the food it produces.
  93. When someone says “I want a programming language in which I need only say what I wish done,” give him a lollipop.
  94. Interfaces keep things tidy, but don’t accelerate growth: Functions do.
  95. Don’t have good ideas if you aren’t willing to be responsible for them.
  96. Computers don’t introduce order anywhere as much as they expose opportunities.
  97. When a professor insists computer science is X but not Y, have compassion for his graduate students.
  98. In computing, the mean time to failure keeps getting shorter.
  99. In man-machine symbiosis, it is man who must adjust: The machines can’t.
  100. We will never run out of things to program as long as there is a single program around.
  101. Dealing with failure is easy: Work hard to improve. Success is also easy to handle: You’ve solved the wrong problem. Work hard to improve.
  102. One can’t proceed from the informal to the formal by formal means.
  103. Purely applicative languages are poorly applicable.
  104. The proof of a system’s value is its existence.
  105. You can’t communicate complexity, only an awareness of it.
  106. It’s difficult to extract sense from strings, but they’re the only communication coin we can count on.
  107. The debate rages on: Is PL/I Bactrian or Dromedary?
  108. Whenever two programmers meet to criticize their programs, both are silent.
  109. Think of it! With VLSI we can pack 100 ENIACs in 1 sq.cm.
  110. Editing is a rewording activity.
  111. Why did the Roman Empire collapse? What is the Latin for office automation?
  112. Computer Science is embarrassed by the computer.
  113. The only constructive theory connecting neuroscience and psychology will arise from the study of software.
  114. Within a computer natural language is unnatural.
  115. Most people find the concept of programming obvious, but the doing impossible.
  116. You think you know when you learn, are more sure when you can write, even more when you can teach, but certain when you can program.
  117. It goes against the grain of modern education to teach children to program. What fun is there in making plans, acquiring discipline in organizing thoughts, devoting attention to detail and learning to be self-critical?
  118. If you can imagine a society in which the computer-robot is the only menial, you can imagine anything.
  119. Programming is an unnatural act.
  120. Adapting old programs to fit new machines usually means adapting new machines to behave like old ones.

  121. In seeking the unattainable, simplicity only gets in the way.

    If there are epigrams, there must be meta-epigrams.

  122. Epigrams are interfaces across which appreciation and insight flow.

  123. Epigrams parameterize auras.
  124. Epigrams are macros, since they are executed at read time.
  125. Epigrams crystallize incongruities.
  126. Epigrams retrieve deep semantics from a data base that is all procedure.
  127. Epigrams scorn detail and make a point: They are a superb high-level documentation.
  128. Epigrams are more like vitamins than protein.
  129. Epigrams have extremely low entropy.
  130. The last epigram? Neither eat nor drink them, snuff epigrams.