Five Questions about Language Design
May 2001 (These are some notes I made for a panel discussion on programming language design at MIT on May 10, 2001.) 1.
2001 年 5 月（这些是我为 2001 年 5 月 10 日在麻省理工学院编程语言设计小组讨论所做的一些笔记。） 1.
Programming Languages Are for People.
编程语言是为人服务的。
Programming languages are how people talk to computers.
编程语言是人们与计算机交谈的方式。
The computer would be just as happy speaking any language that was unambiguous.
计算机会同样乐意说任何明确的语言。
The reason we have high level languages is because people can't deal with machine language.
我们之所以拥有高级语言，是因为人们无法处理机器语言。
The point of programming
编程要点
languages is to prevent our poor frail human brains from being overwhelmed by a mass of detail.
语言的目的是防止我们可怜脆弱的大脑被大量细节淹没。
Architects know that some kinds of design problems are more personal than others.
建筑师知道某些类型的设计问题比其他问题更加个人化。
One of the cleanest, most abstract design problems is designing bridges.
最干净、最抽象的设计问题之一是设计桥梁。
There your job is largely a matter of spanning a given distance with the least material.
在那里，你的工作主要是用最少的材料跨越给定的距离。
The other end of the spectrum is designing chairs.
光谱的另一端是设计椅子。
Chair designers have to spend their
椅子设计师必须花费他们的精力
time thinking about human butts.
是时候想想人类的屁股了。
Software varies in the same way.
软件也以同样的方式变化。
Designing algorithms for routing data through a network is a nice, abstract problem, like designing bridges.
设计通过网络路由数据的算法是一个很好的抽象问题，就像设计桥梁一样。
Whereas designing programming languages is like designing chairs: it's all about dealing with human weaknesses.
设计编程语言就像设计椅子：都是为了解决人类的弱点。
Most of us hate to acknowledge this.
我们大多数人都不愿承认这一点。
Designing systems of great mathematical elegance sounds a lot more appealing to most of us
设计具有数学优雅性的系统对我们大多数人来说听起来更有吸引力
than pandering to human weaknesses.
而不是迎合人性的弱点。
And there is a role for mathematical elegance: some kinds of elegance make programs easier to understand.
数学优雅有一个作用：某些类型的优雅使程序更容易理解。
But elegance is not an end in itself.
但优雅本身并不是目的。
And when I say languages have to be designed to suit human weaknesses, I don't mean that languages have to be designed for bad programmers.
当我说语言的设计必须适应人类的弱点时，我并不是说语言必须为糟糕的程序员设计。
In fact I think you ought to design for the best programmers , but even the best programmers have limitations.
事实上，我认为你应该为最好的程序员进行设计，但即使是最好的程序员也有局限性。
I don't think anyone
我认为没有人
would like programming in a language where all the variables were the letter x with integer subscripts.
希望使用一种所有变量都是带有整数下标的字母 x 的语言进行编程。
2.
2.
Design for Yourself and Your Friends.
为您自己和您的朋友设计。
If you look at the history of programming languages, a lot of the best ones were languages designed for their own authors to use, and a lot of the worst ones were designed for other people to use.
如果你回顾一下编程语言的历史，就会发现很多最好的语言都是为自己的作者使用而设计的，而很多最差的语言则是为其他人使用而设计的。
When languages are designed for other people, it's always a specific
当语言是为其他人设计的时，它总是特定的
group of other people: people not as smart as the language designer.
一群其他人：不如语言设计者聪明的人。
So you get a language that talks down to you.
所以你会得到一种对你说话的语言。
Cobol is the most extreme case, but a lot of languages are pervaded by this spirit.
Cobol 是最极端的例子，但很多语言都弥漫着这种精神。
It has nothing to do with how abstract the language is.
这与语言的抽象程度无关。
C is pretty low-level, but it was designed for its authors to use, and that's why hackers like it.
C 是相当低级的，但它是为它的作者使用而设计的，这就是黑客喜欢它的原因。
The argument for designing languages for bad programmers is that
为糟糕的程序员设计语言的论点是
there are more bad programmers than good programmers.
糟糕的程序员比优秀的程序员多。
That may be so.
也许是这样。
But those few good programmers write a disproportionately large percentage of the software.
但这些少数优秀的程序员编写了相当大比例的软件。
I'm interested in the question, how do you design a language that the very best hackers will like?
我对这个问题很感兴趣，如何设计一种最优秀的黑客会喜欢的语言？
I happen to think this is identical to the question, how do you design a good programming language?, but even if it isn't, it is at least an interesting
我碰巧认为这与“如何设计一种好的编程语言？”的问题相同，但即使不是，它至少是一个有趣的
question.
问题。
3.
3.
Give the Programmer as Much Control as Possible.
给程序员尽可能多的控制权。
Many languages (especially the ones designed for other people) have the attitude of a governess: they try to prevent you from doing things that they think aren't good for you.
许多语言（尤其是为其他人设计的语言）都具有家庭教师的态度：它们试图阻止您做他们认为对您不利的事情。
I like the opposite approach: give the programmer as much control as you can.
我喜欢相反的方法：给程序员尽可能多的控制权。
When I first learned Lisp, what I liked most about it was that it considered me an equal partner.
当我第一次学习 Lisp 时，我最喜欢它的是它认为我是一个平等的伙伴。
In the other languages
在其他语言中
I had learned up till then, there was the language and there was my program, written in the language, and the two were very separate.
直到那时我才知道，有语言，有我的程序，用该语言编写，两者是非常分开的。
But in Lisp the functions and macros I wrote were just like those that made up the language itself.
但在 Lisp 中，我编写的函数和宏就像构成语言本身的函数和宏一样。
I could rewrite the language if I wanted.
如果我愿意，我可以重写该语言。
It had the same appeal as open-source software.
它具有与开源软件相同的吸引力。
4.
4.
Aim for Brevity.
力求简洁。
Brevity is underestimated and even scorned.
简洁被低估，甚至被蔑视。
But if you look into the hearts of hackers, you'll see that they
但如果你深入探究黑客的内心，你就会发现他们
really love it.
真的很喜欢它。
How many times have you heard hackers speak fondly of how in, say, APL, they could do amazing things with just a couple lines of code?
您有多少次听到黑客津津有味地说，在 APL 中，他们只需几行代码就可以做出惊人的事情？
I think anything that really smart people really love is worth paying attention to.
我认为任何真正聪明的人真正喜欢的事情都值得关注。
I think almost anything you can do to make programs shorter is good.
我认为几乎任何能让程序变得更短的事情都是好的。
There should be lots of library functions; anything that can be implicit should be; the syntax should be terse to a fault; even the names of things
应该有很多库函数；任何可以隐含的东西都应该是；语法应该简洁到错误；甚至事物的名称
should be short.
应该很短。
And it's not only programs that should be short.
不仅仅是程序应该短。
The manual should be thin as well.
手册也应该很薄。
A good part of manuals is taken up with clarifications and reservations and warnings and special cases.
手册的很大一部分内容都是澄清、保留、警告和特殊情况。
If you force yourself to shorten the manual, in the best case you do it by fixing the things in the language that required so much explanation.
如果您强迫自己缩短手册，最好的情况是用需要大量解释的语言来修复内容。
5.
5.
Admit What Hacking Is.
承认什么是黑客攻击。
A lot of people wish that hacking was
很多人希望黑客能够
mathematics, or at least something like a natural science.
数学，或者至少是一门自然科学之类的东西。
I think hacking is more like architecture.
我认为黑客更像是建筑。
Architecture is related to physics, in the sense that architects have to design buildings that don't fall down, but the actual goal of architects is to make great buildings, not to make discoveries about statics.
建筑与物理学有关，从某种意义上说，建筑师必须设计不会倒塌的建筑物，但建筑师的实际目标是建造伟大的建筑，而不是发现静力学。
What hackers like to do is make great programs.
黑客喜欢做的就是编写出色的程序。
And I think, at least in our own minds, we have to remember that it's
我认为，至少在我们自己看来，我们必须记住，这是
an admirable thing to write great programs, even when this work doesn't translate easily into the conventional intellectual currency of research papers.
编写伟大的程序是一件令人钦佩的事情，即使这项工作不能轻易转化为研究论文的传统知识货币。
Intellectually, it is just as worthwhile to design a language programmers will love as it is to design a horrible one that embodies some idea you can publish a paper about.
从理智上讲，设计一种程序员会喜欢的语言与设计一种可怕的语言一样值得，因为它体现了你可以发表论文的一些想法。
1.
1.
How to Organize Big Libraries?
大型图书馆如何组织？
Libraries are becoming an increasingly important component of programming languages.
库正在成为编程语言中越来越重要的组成部分。
They're
他们是
also getting bigger, and this can be dangerous.
也变得更大，这可能是危险的。
If it takes longer to find the library function that will do what you want than it would take to write it yourself, then all that code is doing nothing but make your manual thick.
如果找到能够完成您想要的操作的库函数比您自己编写它花费的时间更长，那么所有这些代码除了使您的手册变得厚重之外什么也没做。
(The Symbolics manuals were a case in point.) So I think we will have to work on ways to organize libraries.
（符号手册就是一个很好的例子。）所以我认为我们必须研究组织库的方法。
The ideal would be to design them so that the programmer could guess what library call would do the right thing.
理想的情况是设计它们，以便程序员可以猜测哪个库调用会做正确的事情。
2.
2.
Are People Really Scared of Prefix Syntax?
人们真的害怕前缀语法吗？
This is an open problem in the sense that I have wondered about it for years and still don't know the answer.
这是一个悬而未决的问题，我多年来一直在思考这个问题，但仍然不知道答案。
Prefix syntax seems perfectly natural to me, except possibly for math.
前缀语法对我来说似乎非常自然，除了数学之外。
But it could be that a lot of Lisp's unpopularity is simply due to having an unfamiliar syntax.
但 Lisp 不受欢迎的大部分原因可能只是因为其语法不熟悉。
Whether to do anything about it, if it is true, is another question.
如果这是真的，是否采取行动是另一个问题。
3.
3.
What Do You Need for Server-Based Software?
您需要什么基于服务器的软件？
I think a lot of the most exciting new applications that get written in the next twenty years will be Web-based applications, meaning programs that sit on the server and talk to you through a Web browser.
我认为未来二十年中编写的许多最令人兴奋的新应用程序将是基于 Web 的应用程序，这意味着位于服务器上并通过 Web 浏览器与您通信的程序。
And to write these kinds of programs we may need some new things.
为了编写这些类型的程序，我们可能需要一些新的东西。
One thing we'll need is support for the new way that server-based apps get released.
我们需要的一件事是支持发布基于服务器的应用程序的新方式。
Instead of having one or two big releases a year, like desktop software, server-based apps get released as a
基于服务器的应用程序不是像桌面软件那样每年发布一两个重大版本，而是作为
series of small changes.
一系列的小变化。
You may have as many as five or ten releases a day.
您每天可能会发布多达五个或十个版本。
And as a rule everyone will always use the latest version.
通常每个人都会使用最新版本。
You know how you can design programs to be debuggable?
您知道如何设计可调试的程序吗？
Well, server-based software likewise has to be designed to be changeable.
那么，基于服务器的软件同样必须设计为可更改的。
You have to be able to change it easily, or at least to know what is a small change and what is a momentous one.
你必须能够轻松地改变它，或者至少知道什么是小改变，什么是重大改变。
Another thing that might turn out to be useful for server based
另一件事可能对基于服务器的有用
software, surprisingly, is continuations.
令人惊讶的是，软件是延续。
In Web-based software you can use something like continuation-passing style to get the effect of subroutines in the inherently stateless world of a Web session.
在基于 Web 的软件中，您可以使用诸如连续传递样式之类的方法来在 Web 会话的固有无状态世界中获得子例程的效果。
Maybe it would be worthwhile having actual continuations, if it was not too expensive.
如果不是太贵的话，也许有实际的延续是值得的。
4.
4.
What New Abstractions Are Left to Discover?
还有哪些新的抽象有待发现？
I'm not sure how reasonable a hope this is, but one thing I would really love to
我不确定这个希望有多合理，但我真的很乐意做一件事
do, personally, is discover a new abstraction-- something that would make as much of a difference as having first class functions or recursion or even keyword parameters.
就我个人而言，要做的就是发现一个新的抽象——它与拥有第一类函数或递归甚至关键字参数一样具有重要意义。
This may be an impossible dream.
这或许是一个不可能实现的梦想。
These things don't get discovered that often.
这些事情并不经常被发现。
But I am always looking.
但我一直在寻找。
1.
1.
You Can Use Whatever Language You Want.
您可以使用任何您想要的语言。
Writing application programs used to mean writing desktop software.
过去，编写应用程序就是编写桌面软件。
And in desktop
并且在桌面上
software there is a big bias toward writing the application in the same language as the operating system.
在软件方面，人们倾向于使用与操作系统相同的语言来编写应用程序。
And so ten years ago, writing software pretty much meant writing software in C.
所以十年前，编写软件几乎意味着用 C 语言编写软件。
Eventually a tradition evolved: application programs must not be written in unusual languages.
最终形成了一个传统：应用程序不能用不寻常的语言编写。
And this tradition had so long to develop that nontechnical people like managers and venture capitalists also learned it.
这种传统发展了很长时间，以至于经理和风险投资家等非技术人员也学会了它。
Server-based software blows away this whole model.
基于服务器的软件颠覆了整个模型。
With server-based software you can use any language you want.
使用基于服务器的软件，您可以使用任何您想要的语言。
Almost nobody understands this yet (especially not managers and venture capitalists).
几乎没有人理解这一点（尤其是管理者和风险投资家）。
A few hackers understand it, and that's why we even hear about new, indy languages like Perl and Python.
一些黑客理解它，这就是为什么我们甚至听说 Perl 和 Python 等新的独立语言。
We're not hearing about Perl and Python because people are using them to write Windows apps.
我们没有听说过 Perl 和 Python，因为人们正在使用它们来编写 Windows 应用程序。
What this means for us, as people interested in designing programming
这对于我们这些对设计编程感兴趣的人来说意味着什么
languages, is that there is now potentially an actual audience for our work.
语言，我们的作品现在有潜在的实际受众。
2.
2.
Speed Comes from Profilers.
速度来自分析器。
Language designers, or at least language implementors, like to write compilers that generate fast code.
语言设计者，或者至少是语言实现者，喜欢编写生成快速代码的编译器。
But I don't think this is what makes languages fast for users.
但我不认为这就是让语言对用户来说更快的原因。
Knuth pointed out long ago that speed only matters in a few critical bottlenecks.
高德纳很久以前就指出，速度只在少数关键瓶颈中起作用。
And anyone who's tried it knows that you can't guess
任何尝试过的人都知道你无法猜测
where these bottlenecks are.
这些瓶颈在哪里。
Profilers are the answer.
探查器就是答案。
Language designers are solving the wrong problem.
语言设计者正在解决错误的问题。
Users don't need benchmarks to run fast.
用户不需要基准测试来快速运行。
What they need is a language that can show them what parts of their own programs need to be rewritten.
他们需要的是一种能够向他们展示自己的程序的哪些部分需要重写的语言。
That's where speed comes from in practice.
这就是实践中速度的来源。
So maybe it would be a net win if language implementors took half the time they would have spent doing compiler optimizations and spent it writing a
因此，如果语言实现者花费一半的时间来进行编译器优化并花在编写一个
good profiler instead.
相反，好的分析器。
3.
3.
You Need an Application to Drive the Design of a Language.
您需要一个应用程序来驱动语言的设计。
This may not be an absolute rule, but it seems like the best languages all evolved together with some application they were being used to write.
这可能不是绝对规则，但似乎最好的语言都与它们用来编写的某些应用程序一起发展。
C was written by people who needed it for systems programming.
C 是由需要它进行系统编程的人编写的。
Lisp was developed partly to do symbolic differentiation, and McCarthy was so eager to get started that he was writing differentiation
Lisp 的开发部分是为了进行符号微分，麦卡锡非常渴望开始，以至于他正在编写微分
programs even in the first paper on Lisp, in 1960.
甚至在 1960 年第一篇关于 Lisp 的论文中也提到了这一点。
It's especially good if your application solves some new problem.
如果您的应用程序解决了一些新问题，那就特别好。
That will tend to drive your language to have new features that programmers need.
这往往会促使您的语言具有程序员需要的新功能。
I personally am interested in writing a language that will be good for writing server-based applications.
我个人有兴趣编写一种适合编写基于服务器的应用程序的语言。
[During the panel, Guy Steele also made this point, with the additional suggestion that the application should not consist of
[在小组讨论中，Guy Steele 也提出了这一点，并额外建议申请不应包含
writing the compiler for your language, unless your language happens to be intended for writing compilers.] 4.
为您的语言编写编译器，除非您的语言恰好是为了编写编译器而设计的。] 4.
A Language Has to Be Good for Writing Throwaway Programs.
一种语言必须适合编写一次性程序。
You know what a throwaway program is: something you write quickly for some limited task.
您知道什么是一次性程序：您为某些有限的任务快速编写的程序。
I think if you looked around you'd find that a lot of big, serious programs started as throwaway programs.
我想如果你环顾四周，你会发现很多大型、严肃的程序都是从一次性程序开始的。
I would not be surprised if most programs started as throwaway
如果大多数程序一开始都是一次性的，我不会感到惊讶
programs.
程序。
And so if you want to make a language that's good for writing software in general, it has to be good for writing throwaway programs, because that is the larval stage of most software.
因此，如果你想创造一种适合编写一般软件的语言，它必须适合编写一次性程序，因为这是大多数软件的幼虫阶段。
5.
5.
Syntax Is Connected to Semantics.
语法与语义相关。
It's traditional to think of syntax and semantics as being completely separate.
传统上认为语法和语义是完全分开的。
This will sound shocking, but it may be that they aren't.
这听起来令人震惊，但事实可能并非如此。
I think that what you want in your language may be related
我认为你想要的语言可能是相关的
to how you express it.
取决于你如何表达它。
I was talking recently to Robert Morris, and he pointed out that operator overloading is a bigger win in languages with infix syntax.
我最近与 Robert Morris 交谈，他指出运算符重载在具有中缀语法的语言中是一个更大的胜利。
In a language with prefix syntax, any function you define is effectively an operator.
在具有前缀语法的语言中，您定义的任何函数实际上都是运算符。
If you want to define a plus for a new type of number you've made up, you can just define a new function to add them.
如果您想为您编写的新类型的数字定义一个加号，您只需定义一个新函数来将它们相加即可。
If you do that in a language with infix syntax,
如果您使用具有中缀语法的语言来执行此操作，
there's a big difference in appearance between the use of an overloaded operator and a function call.
重载运算符和函数调用的使用在外观上有很大差异。
1.
1.
New Programming Languages.
新的编程语言。
Back in the 1970s it was fashionable to design new programming languages.
早在 20 世纪 70 年代，设计新的编程语言就很流行。
Recently it hasn't been.
最近却没有了。
But I think server-based software will make new languages fashionable again.
但我认为基于服务器的软件将使新语言再次流行。
With server-based software, you can use any language you want, so if someone does design a language that
使用基于服务器的软件，您可以使用任何您想要的语言，因此如果有人设计了一种语言
actually seems better than others that are available, there will be people who take a risk and use it.
实际上看起来比其他可用的更好，会有人冒险并使用它。
2.
2.
Time-Sharing.
分时。
Richard Kelsey gave this as an idea whose time has come again in the last panel, and I completely agree with him.
理查德·凯尔西（Richard Kelsey）提出了这个想法，在上一个小组中，这个想法再次出现，我完全同意他的观点。
My guess (and Microsoft's guess, it seems) is that much computing will move from the desktop onto remote servers.
我的猜测（似乎也是微软的猜测）是，大量计算将从桌面转移到远程服务器上。
In other words, time-sharing is back.
换句话说，分时又回来了。
And I think there will need to be support
我认为需要支持
for it at the language level.
在语言层面上。
For example, I know that Richard and Jonathan Rees have done a lot of work implementing process scheduling within Scheme 48.
例如，我知道 Richard 和 Jonathan Rees 在方案 48 中实现进程调度方面做了很多工作。
3.
3.
Efficiency.
效率。
Recently it was starting to seem that computers were finally fast enough.
最近，计算机似乎终于足够快了。
More and more we were starting to hear about byte code, which implies to me at least that we feel we have cycles to spare.
我们越来越多地开始听说字节码，这至少对我来说意味着我们觉得我们有空闲的周期。
But I don't think we will, with server-based
但我认为我们不会，基于服务器
software.
软件。
Someone is going to have to pay for the servers that the software runs on, and the number of users they can support per machine will be the divisor of their capital cost.
有人将不得不为运行该软件的服务器付费，并且每台机器可以支持的用户数量将是其资本成本的除数。
So I think efficiency will matter, at least in computational bottlenecks.
所以我认为效率很重要，至少在计算瓶颈方面。
It will be especially important to do i/o fast, because server-based applications do a lot of i/o.
快速执行 I/O 尤为重要，因为基于服务器的应用程序会执行大量 I/O。
It may turn out that byte code is not a win, in the end.
最终，字节码可能并不是胜利。
Sun and
太阳和
Microsoft seem to be facing off in a kind of a battle of the byte codes at the moment.
微软目前似乎正面临着一场字节码之战。
But they're doing it because byte code is a convenient place to insert themselves into the process, not because byte code is in itself a good idea.
但他们这样做是因为字节码是将自己插入到进程中的一个方便的地方，而不是因为字节码本身就是一个好主意。
It may turn out that this whole battleground gets bypassed.
事实可能是，整个战场都被绕过了。
That would be kind of amusing.
那会很有趣。
1.
1.
Clients.
客户。
This is just a guess, but my guess is that the winning model for most applications will be purely server-based.
这只是一个猜测，但我的猜测是，大多数应用程序的获胜模型将是纯粹基于服务器的。
Designing software that works on the assumption that everyone will have your client is like designing a society on the assumption that everyone will just be honest.
设计一个假设每个人都会有你的客户的软件就像设计一个假设每个人都会诚实的社会一样。
It would certainly be convenient, but you have to assume it will never happen.
这肯定会很方便，但你必须假设它永远不会发生。
I think there will be a proliferation of devices that have some kind of Web access, and all you'll be able to assume about them is that they can support simple html and forms.
我认为具有某种 Web 访问功能的设备将会激增，您只能假设它们可以支持简单的 html 和表单。
Will you have a
你会拥有一个
browser on your cell phone?
你手机上的浏览器？
Will there be a phone in your palm pilot?
您的掌上电脑中会有电话吗？
Will your blackberry get a bigger screen?
你的黑莓手机会配备更大的屏幕吗？
Will you be able to browse the Web on your gameboy?
您可以在您的游戏机上浏览网页吗？
Your watch?
你的手表？
I don't know.
我不知道。
And I don't have to know if I bet on everything just being on the server.
而且我不必知道我是否将所有赌注都押在服务器上。
It's just so much more robust to have all the brains on the server .
将所有的大脑都放在服务器上会更加健壮。
2.
2.
Object-Oriented Programming.
面向对象的编程。
I realize this is a controversial one, but I don't think object-oriented programming
我意识到这是一个有争议的问题，但我不认为面向对象编程
is such a big deal.
是一件大事。
I think it is a fine model for certain kinds of applications that need that specific kind of data structure, like window systems, simulations, and cad programs.
我认为对于需要特定类型数据结构的某些类型的应用程序（例如窗口系统、模拟和 CAD 程序）来说，这是一个很好的模型。
But I don't see why it ought to be the model for all programming.
但我不明白为什么它应该成为所有编程的模型。
I think part of the reason people in big companies like object-oriented programming is because it yields a lot of what looks like work.
我认为大公司的人们喜欢面向对象编程的部分原因是它产生了很多看起来像工作的东西。
Something that might naturally be represented as, say, a list of
可以自然地表示为，例如，列表的东西
integers, can now be represented as a class with all kinds of scaffolding and hustle and bustle.
整数，现在可以表示为具有各种脚手架和喧嚣的类。
Another attraction of object-oriented programming is that methods give you some of the effect of first class functions.
面向对象编程的另一个吸引力是方法为您提供了一些一流函数的效果。
But this is old news to Lisp programmers.
但这对于 Lisp 程序员来说已经是老新闻了。
When you have actual first class functions, you can just use them in whatever way is appropriate to the task at hand, instead of forcing everything into a mold of classes and methods.
当您拥有实际的一流函数时，您可以以适合手头任务的任何方式使用它们，而不是将所有内容强制放入类和方法的模型中。
What this means for language design, I think, is that you shouldn't build object-oriented programming in too deeply.
我认为，这对于语言设计意味着你不应该太深入地构建面向对象的编程。
Maybe the answer is to offer more general, underlying stuff, and let people design whatever object systems they want as libraries.
也许答案是提供更通用、更底层的东西，让人们设计他们想要的任何对象系统作为库。
3.
3.
Design by Committee.
由委员会设计。
Having your language designed by a committee is a big pitfall, and not just for the reasons everyone knows about.
让委员会设计你的语言是一个很大的陷阱，不仅仅是因为每个人都知道的原因。
Everyone knows that committees tend to yield lumpy, inconsistent designs.
大家都知道，委员会往往会产生笨拙、不一致的设计。
But I think a greater danger is that they won't take risks.
但我认为更大的危险是他们不愿意冒险。
When one person is in charge he can take risks that a committee would never agree on.
当一个人负责时，他可以承担委员会永远不会同意的风险。
Is it necessary to take risks to design a good language though?
设计一门好的语言是否有必要冒风险呢？
Many people might suspect that language design is something where you should stick fairly close to the conventional wisdom.
许多人可能怀疑语言设计应该非常接近传统智慧。
I bet this isn't true.
我敢打赌这不是真的。
In everything else people do, reward is proportionate to risk.
在人们所做的其他事情中，回报与风险成正比。