刚看到了一篇非常好的文章，其中包括了计算机科学、计算机专业的大学课程等内
容，引人深思。

原文URL
http://www.ruanyifeng.com/blog/2008/12/the_perils_of_javaschools.html

转载原文：

========================================================================


    Java 语言学校的危险性（译文）
    <http://www.ruanyifeng.com/blog/2008/12/the_perils_of_javaschools.html>

from 阮一峰的网络日志
<http://www.google.com/reader/view/feed/http%3A%2F%2Ffeeds.feedburner.com%2Fruanyifeng>

下面的文章是/More Joel on Software/
<http://www.ruanyifeng.com/blog/2008/10/i_will_translate_more_joel_on_software.html>
一书的第8篇。

我觉得翻译难度很大，整整两个工作日，每天8小时以上，才译出了5000字。除了
Joel大量使用俚语，另一个原因是原文涉及“编程原理”，好多东西我根本不懂。希
望懂的朋友帮我看看，译文有没有错误，包括我写的注解。

====================

*JAVA语言学校的危险性*

作者：Joel Spolsky

译者：阮一峰

原文： http://www.joelonsoftware.com/articles/ThePerilsofJavaSchools.html

发表日期 2005年12月29日，星期四

如今的孩子变懒了。

多吃一点苦，又会怎么样呢？

我一定是变老了，才会这样喋喋不休地抱怨和感叹“如今的孩子”。为什么他们不再
愿意、或者说不再能够做艰苦的工作呢。

当我还是孩子的时候，学习编程需要用到穿孔卡片（punched cards）。那时可没
有任何类似“退格”键（Backspace key）这样的现代化功能，如果你出错了，就没
有办法更正，只好扔掉出错的卡片，从头再来。

回想1991年，我开始面试程序员的时候。我一般会出一些编程题，允许用任何编程
语言解题。在99%的情况下，面试者选择C语言。

如今，面试者一般会选择Java语言。

说到这里，不要误会我的意思。Java语言本身作为一种开发工具，并没有什么错。

等一等，我要做个更正。我只是在本篇特定的文章中，不会提到Java语言作为一种
开发工具，有什么不好的地方。事实上，它有许许多多不好的地方，不过这些只有
另找时间来谈了。

我在这篇文章中，真正想要说的是，总的来看，Java不是一种非常难的编程语言，
无法用来区分优秀程序员和普通程序员。它可能很适合用来完成工作，但是这个不
是今天的主题。我甚至想说，Java语言不够难，其实是它的特色，不能算缺点。但
是不管怎样，它就是有这个问题。

如果我听上去像是妄下论断，那么我想说一点我自己的微不足道的经历。大学计算
机系的课程里，传统上有两个知识点，许多人从来都没有真正搞懂过的，那就是指
针（pointers）和递归（recursion）。

你进大学后，一开始总要上一门“数据结构”课（data structure）, 然后会有线性
链表（linked list）、哈希表（hash table），以及其他诸如此类的课程。这些
课会大量使用“指针”。它们经常起到一种优胜劣汰的作用。因为这些课程非常难，
那些学不会的人，就表明他们的能力不足以达到计算机科学学士学位的要求，只能
选择放弃这个专业。这是一件好事，因为如果你连指针很觉得很难，那么等学到后
面，要你证明不动点定理（fixed point theory）的时候，你该怎么办呢？

有些孩子读高中的时候，就能用BASIC语言在Apple II型个人电脑上，写出漂亮的
乒乓球游戏。等他们进了大学，都会去选修计算机科学101课程，那门课讲的就是
数据结构。当他们接触到指针那些玩意以后，就一下子完全傻眼了，后面的事情你
都可以想像，他们就去改学政治学，因为看上去法学院是一个更好的出路[1]。关
于计算机系的淘汰率，我见过各式各样的数字，通常在40%到70%之间。校方一般会
觉得，学生拿不到学位很可惜，我则视其为必要的筛选，淘汰那些没有兴趣编程或
者没有能力编程的人。

对于许多计算机系的青年学生来说，另一门有难度的课程是有关函数式编程
（functional programming）的课程，其中就包括递归程序设计（recursive
programming）。MIT将这些课程的标准提得很高，还专门设立了一门必修课（课程
代号6.001[2]），它的教材（Structure and Interpretation of Computer
Programs，作者为Harold Abelson和Gerald Jay Sussman Abelson，MIT出版社
1996年版）被几十所、甚至几百所著名高校的计算系机采用，充当事实上的计算机
科学导论课程。（你能在网上找到这本教材的旧版本，应该读一下。）

这些课程难得惊人。在第一堂课，你就要学完Scheme语言[3]的几乎所有内容，你
还会遇到一个不动点函数（fixed-point function），它的自变量本身就是另一个
函数。我读的这门导论课，是宾夕法尼亚大学的CSE 121课程，真是读得苦不堪
言。我注意到很多学生，也许是大部分的学生，都无法完成这门课。课程的内容实
在太难了。我给教授写了一封长长的声泪俱下的 Email，控诉这门课不是给人学
的。宾夕法尼亚大学里一定有人听到了我的呼声（或者听到了其他抱怨者的呼
声），因为如今这门课讲授的计算机语言是 Java。

我现在觉得，他们还不如没有听见呢。

这就是争议所在。许多年来，像当年的我一样懒惰的计算机系本科生不停地抱怨，
再加上计算机业界也在抱怨毕业生不够用，这一切终于造成了重大恶果。过去十年
中，大量本来堪称完美的好学校，都百分之百转向了Java语言的怀抱。这真是好得
没话说了，那些用“grep”命令[4]过滤简历的企业招聘主管，大概会很喜欢这样。
最妙不可言的是，Java语言中没有什么太难的地方，不会真的淘汰什么人，你搞不
懂指针或者递归也没关系。所以，计算系的淘汰率就降低了，学生人数上升了，经
费预算变大了，可谓皆大欢喜。

学习Java语言的孩子是幸运的，因为当他们用到以指针为基础的哈希表时，他们永
远也不会遇到古怪的“段错误”[5]（segfault）。他们永远不会因为无法将数据塞
进有限的内存空间，而急得发疯。他们也永远不用苦苦思索，为什么在一个纯函数
的程序中，一个变量的值一会保持不变，一会又变个不停！多么自相矛盾啊！

他们不需要怎么动脑筋，就可以在专业上得到4.0的绩点。

我是不是有点太苛刻了？就像电视里的“四个约克郡男人”[6]（Four
Yorkshiremen）那样，成了老古板？就在这里吹嘘我是多么刻苦，完成了所有那些
高难度的课程？

我再告诉你一件事。1900年的时候，拉丁语和希腊语都是大学里的必修课，原因不
是因为它们有什么特别的作用，而是因为它们有点被看成是受过高等教育的人士的
标志。在某种程度上，我的观点同拉丁语支持者的观点没有不同（下面的四点理由
都是如此）：“（拉丁语）训练你的思维，锻炼你的记忆。分析拉丁语的句法结
构，是思考能力的最佳练习，是真正对智力的挑战，能够很好地培养逻辑能力。”
以上出自Scott Barker之口（http://www.promotelatin.org/whylatin.htm）。但
是，今天我找不到一所大学，还把拉丁语作为必修课。指针和递归不正像计算机科
学中的拉丁语和希腊语吗？

说到这里，我坦率地承认，当今的软件代码中90%都不需要使用指针。事实上，如
果在正式产品中使用指针，这将是十分危险的。好的，这一点没有异议。与此同
时，函数式编程在实际开发中用到的也不多。这一点我也同意。

但是，对于某些最激动人心的编程任务来说，指针仍然是非常重要的。比如说，如
果不用指针，你根本没办法开发Linux的内核。如果你不是真正地理解了指针，你
连一行Linux的代码也看不懂，说实话，任何操作系统的代码你都看不懂。

如果你不懂函数式编程，你就无法创造出MapReduce[7]，正是这种算法使得Google
的可扩展性（scalable）达到如此巨大的规模。单词“Map”（映射）和“Reduce”
（化简）分别来自Lisp语言和函数式编程。回想起来，在类似6.001这样的编程课
程中，都有提到纯粹的函数式编程没有副作用，因此可以直接用于并行计算
（parallelizable）。任何人只要还记得这些内容，那么MapRuduce对他来说就是
显而易见的。发明MapReduce的公司是Google，而不是微软，这个简单的事实说出
了原因，为什么微软至今还在追赶，还在试图提供最基本的搜索服务，而Google已
经转向了下一个阶段，开发世界上最大的并行式超级计算机――Skynet[8]的H次方的
H次方的H次方的H次方的H次方的H次方。我觉得，微软并没有完全明白，在这一波
竞争中它落后多远。

除了上面那些直接就能想到的重要性，指针和递归的真正价值，在于那种你在学习
它们的过程中，所得到的思维深度，以及你因为害怕在这些课程中被淘汰，所产生
的心理抗压能力，它们都是在建造大型系统的过程中必不可少的。指针和递归要求
一定水平的推理能力、抽象思考能力，以及最重要的，在若干个不同的抽象层次
上，同时审视同一个问题的能力。因此，是否真正理解指针和递归，与是否是一个
优秀程序员直接相关。

如果计算机系的课程都与Java语言有关，那么对于那些在智力上无法应付复杂概念
的学生，就没有东西可以真的淘汰他们。作为一个雇主，我发现那些 100%Java教
学的计算机系，已经培养出了相当一大批毕业生，这些学生只能勉强完成难度日益
降低的课程作业，只会用Java语言编写简单的记账程序，如果你让他们编写一个更
难的东西，他们就束手无策了。他们的智力不足以成为程序员。这些学生永远也通
不过MIT的6.001课程，或者耶鲁大学的CS 323课程。坦率地说，为什么在一个雇主
的心目中，MIT或者耶鲁大学计算机系的学位的份量，要重于杜克大学，这就是原
因之一。因为杜克大学最近已经全部转为用Java语言教学。宾夕法尼亚大学的情况
也很类似，当初CSE 121课程中的Scheme语言和ML语言，几乎将我和我的同学折磨
至死，如今已经全部被Java语言替代。我的意思不是说，我不想雇佣来自杜克大学
或者宾夕法尼亚大学的聪明学生，我真的愿意雇佣他们，只是对于我来说，确定他
们是否真的聪明，如今变得难多了。以前，我能够分辨出谁是聪明学生，因为他们
可以在一分钟内看懂一个递归算法，或者可以迅速在计算机上实现一个线性链表操
作函数，所用的时间同黑板上写一遍差不多。但是对于Java语言学校的毕业生，看
着他们面对上述问题苦苦思索、做不出来的样子，我分辨不出这到底是因为学校里
没教，还是因为他们不具备编写优秀软件作品的素质。Paul Graham将这一类程序
员称为“Blub程序员”[9]（www.paulgraham.com/avg.html
<http://www.paulgraham.com/avg.html>）。

Java语言学校无法淘汰那些永远也成不了优秀程序员的学生，这已经是很糟糕的事
情了。但是，学校可以无可厚非地辩解，这不是校方的错。整个软件行业，或者说
至少是其中那些使用grep命令过滤简历的招聘经理，确实是在一直叫嚷，要求学校
使用Java语言教学。

但是，即使如此，Java语言学校的教学也还是失败的，因为学校没有成功训练好学
生的头脑，没有使他们变得足够熟练、敏捷、灵活，能够做出高质量的软件设计
（我不是指面向对象式的“设计”，那种编程只不过是要求你花上无数个小时，重写
你的代码，使它们能够满足面向对象编程的等级制继承式结构，或者说要求你思考
到底对象之间是“has-a”从属关系，还是“is-a”继承关系，这种“伪问题”将你搞得
烦躁不安）。你需要的是那种能够在多个抽象层次上，同时思考问题的训练。这种
思考能力正是设计出优秀软件架构所必需的。

你也许想知道，在教学中，面向对象编程（object-oriented programming，缩写
OOP）是否是指针和递归的优质替代品，是不是也能起到淘汰作用。简单的回答
是：“不”。我在这里不讨论OOP的优点，我只指出OOP不够难，无法淘汰平庸的程序
员。大多数时候，OOP教学的主要内容就是记住一堆专有名词，比如“封装”
（encapsulation）和“继承 ”（inheritance）”，然后再做一堆多选题小测验，考
你是不是明白“多态”（polymorphism）和“重载”（overloading）的区别。这同历
史课上，要求你记住重要的日期和人名，难度差不多。OOP不构成对智力的太大挑
战，吓不跑一年级新生。据说，如果你没学好OOP，你的程序依然可以运行，只是
维护起来有点难。但是如果你没学好指针，你的程序就会输出一行段错误信息，而
且你对什么地方出错了毫无想法，然后你只好停下来，深吸一口气，真正开始努力
在两个不同的抽象层次上，同时思考你的程序是如何运行的。

顺便说一句，我有充分理由在这里说，那些使用grep命令过滤简历的招聘经理真是
荒谬可笑。我从来没有见过哪个能用Scheme语言、 Haskell语言和C语言中的指针
编程的人，竟然不能在二天里面学会Java语言，并且写出的Java程序，质量竟然不
能胜过那些有5年Java编程经验的人士。不过，人力资源部里那些平庸的懒汉，是
无法指望他们听进去这些话的。

再说，计算机系承担的发扬光大计算机科学的使命该怎么办呢？计算机系毕竟不是
职业学校啊！训练学生如何在这个行业里工作，不应该是计算机系的任务。这应该
是社区高校和政府就业培训计划的任务，那些地方会教给你工作技能。计算机系给
予学生的，理应是他们日后生活所需要的基础知识，而不是为学生第一周上班做准
备。对不对？

还有，计算机科学是由证明（递归）、算法（递归）、语言（λ演算[10]）、操作
系统（指针）、编译器（λ演算）所组成的。所以，这就是说那些不教 C语言、不
教Scheme语言、只教Java语言的学校，实际上根本不是在教授计算机科学。虽然对
于真实世界来说，有些概念可能毫无用处，比如函数的科里化（function
currying）[11]，但是这些知识显然是进入计算机科学研究生院的前提。我不明
白，计算机系课程设置委员会中的教授为什么会同意，将课程的难度下降到如此低
的地步，以至于他们既无法培养出合格的程序员，甚至也无法培养出合格的能够得
到哲学博士PhD学位[12]、进而能够申请教职、与他们竞争工作岗位的研究生。
噢，且慢，我说错了。也许我明白原因了。

实际上，如果你回顾和研究学术界在“Java大迁移”（Great Java Shift）中的争
论，你会注意到，最大的议题是Java语言是否还不够简单，不适合作为一种教学语言。

我的老天啊，我心里说，他们还在设法让课程变得更简单。为什么不用匙子，干脆
把所有东西一勺勺都喂到学生嘴里呢？让我们再请助教帮他们接管考试，这样一来
就没有学生会改学“美国研究”[13]（American studies）了。如果课程被精心设
计，使得所有内容都比原有内容更容易，那么怎么可能期望任何人从这个地方学到
任何东西呢？看上去似乎有一个工作小组（Java task force）正在开展工作，创
造出一个简化的Java的子集，以便在课堂上教学[14]。这些人的目标是生成一个简
化的文档，小心地不让学生纤弱的思想，接触到任何EJB/J2EE的脏东西[15]。这样
一来，学生的小脑袋就不会因为遇到有点难度的课程，而感到烦恼了，除非那门课
里只要求做一些空前简单的计算机习题。

计算机系如此积极地降低课程难度，有一个理由可以得到最多的赞同，那就是节省
出更多的时间，教授真正的属于计算机科学的概念。但是，前提是不能花费整整两
节课，向学生讲解诸如Java语言中int和Integer有何区别[16]。好的，如果真是这
样，课程6.001就是你的完美选择。你可以先讲 Scheme语言，这种教学语言简单到
聪明学生大约只用10分钟，就能全部学会。然后，你将这个学期剩下的时间，都用
来讲解不动点。

唉。

说了半天，我还是在说要学1和0。

（你学到了1？真幸运啊！我们那时所有人学到的都是0。）

================

注解：

[1] 在美国，法学院的入学者都必须具有本科学位。通常来说，主修政治学的学生
升入法学院的机会最大。

[2] 在麻省理工学院，计算机系的课程代码都是以6开头的，6.001表明这是计算机
系的最基础课程。

[3] Scheme语言是LISP语言的一个变种，诞生于1975年的MIT，以其对函数式编程
的支持而闻名。这种语言在商业领域的应用很少，但是在计算机教育领域内有着广
泛影响。

[4] grep是Unix/Linux环境中用于搜索或者过滤内容的命令。这里指的是，某些招
聘人员仅仅根据一些关键词来过滤简历，比如本文中的Java。

[5] 段错误（segfault）是segmentation fault的缩写，指的是软件中的一类特定
的错误，通常发生在程序试图读取不允许读取的内存地址、或者以非法方式读取内
存的时候。

[6] 《四个约克郡男人》（Four Yorkshiremen）,是英国电视系列喜剧At Last the
1948 Show中的一部，与上个世纪70年代问世。内容是四个约克郡男人竞相吹嘘，
各自的童年是多么困苦，由于内容太夸张，所以显得非常可笑。

[7] MapReduce是一种由Google引入使用的软件框架，用于支持计算机集群环境
下，海量数据（PB级别）的并行计算。

[8] Skynet是美国系列电影《终结者》（Terminator）中一个控制一切、与人类为敌
的超级计算机系统的名称，通常将其看作虚构的人工智能的代表。

[9] Blub程序员（Blub programmers）指的是那些企图用一种语言，解决所有问题
的程序员。Blub是Paul Graham假设的一种高级编程语言。

[10] λ演算（lambda calculus）是一套用于研究函数定义、函数应用和递归的形
式系统，在递归理论和函数式编程中有着广泛的应用。

[11] 函数的科里化（function currying）指的是一种多元函数的消元技巧，将其
变为一系列只有一元的链式函数。它最早是由美国数学家哈斯格尔・科里（Haskell
Curry）提出的，因此而得名。

[12] 在美国，所有基础理论的学科，一律授予的都是哲学博士学位（Doctor of
Philosophy），计算机科学系亦是如此。

[13] 美国研究（American studies）是对美国社会的经济、历史、文化等各个方
面进行研究的一门学科。这里指的是，计算机系学生不会因为课程太难被淘汰，所
以就不用改学相对容易的“美国研究”。

[14] 参见http://www.sigcse.org/topics/javataskforce/java-task-force.pdf。

[15] J2EE是Java2平台企业版（Java 2 Platform,Enterprise Edition），指的是
一整套企业级开发架构。EJB（Enterprise JavaBean）属于J2EE的一部分，是一个
基于组件的企业级开发规范。它们通常被认为是Java中相对较难的部分。

[16] 在Java语言中，int是一种数据类型，表示整数，而Integer是一个适用于面
向对象编程的类，表示整数对象。两者的涵义和性质都不一样。

（完）

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.zeuux.org/pipermail/zeuux-universe/attachments/20081210/290f7b7e/attachment-0001.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: bg2008120701.jpg
Type: image/jpeg
Size: 9519 bytes
Desc: not available
URL: <http://www.zeuux.org/pipermail/zeuux-universe/attachments/20081210/290f7b7e/attachment-0001.jpg>

类似的文章
http://developers.slashdot.org/article.pl?sid=08/01/08/0348239

-Alex


Xia Qingran 写道:
>
>
>
> 刚看到了一篇非常好的文章，其中包括了计算机科学、计算机专业的大学课程等
> 内容，引人深思。
>
> 原文URL
> http://www.ruanyifeng.com/blog/2008/12/the_perils_of_javaschools.html
>
> 转载原文：
>
> ========================================================================
>
>
>     Java 语言学校的危险性（译文）
>     <http://www.ruanyifeng.com/blog/2008/12/the_perils_of_javaschools.html>
>
> from 阮一峰的网络日志
> <http://www.google.com/reader/view/feed/http%3A%2F%2Ffeeds.feedburner.com%2Fruanyifeng>
>
> 下面的文章是/More Joel on Software/
> <http://www.ruanyifeng.com/blog/2008/10/i_will_translate_more_joel_on_software.html>
> 一书的第8篇。
>
> 我觉得翻译难度很大，整整两个工作日，每天8小时以上，才译出了5000字。除
> 了Joel大量使用俚语，另一个原因是原文涉及“编程原理”，好多东西我根本不
> 懂。希望懂的朋友帮我看看，译文有没有错误，包括我写的注解。
>
> ====================
>
> *JAVA语言学校的危险性*
>
> 作者：Joel Spolsky
>
> 译者：阮一峰
>
> 原文： http://www.joelonsoftware.com/articles/ThePerilsofJavaSchools.html
>
> 发表日期 2005年12月29日，星期四
>
> 如今的孩子变懒了。
>
> 多吃一点苦，又会怎么样呢？
>
> 我一定是变老了，才会这样喋喋不休地抱怨和感叹“如今的孩子”。为什么他们不
> 再愿意、或者说不再能够做艰苦的工作呢。
>
> 当我还是孩子的时候，学习编程需要用到穿孔卡片（punched cards）。那时可
> 没有任何类似“退格”键（Backspace key）这样的现代化功能，如果你出错了，
> 就没有办法更正，只好扔掉出错的卡片，从头再来。
>
> 回想1991年，我开始面试程序员的时候。我一般会出一些编程题，允许用任何编
> 程语言解题。在99%的情况下，面试者选择C语言。
>
> 如今，面试者一般会选择Java语言。
>
> 说到这里，不要误会我的意思。Java语言本身作为一种开发工具，并没有什么错。
>
> 等一等，我要做个更正。我只是在本篇特定的文章中，不会提到Java语言作为一
> 种开发工具，有什么不好的地方。事实上，它有许许多多不好的地方，不过这些
> 只有另找时间来谈了。
>
> 我在这篇文章中，真正想要说的是，总的来看，Java不是一种非常难的编程语
> 言，无法用来区分优秀程序员和普通程序员。它可能很适合用来完成工作，但是
> 这个不是今天的主题。我甚至想说，Java语言不够难，其实是它的特色，不能算
> 缺点。但是不管怎样，它就是有这个问题。
>
> 如果我听上去像是妄下论断，那么我想说一点我自己的微不足道的经历。大学计
> 算机系的课程里，传统上有两个知识点，许多人从来都没有真正搞懂过的，那就
> 是指针（pointers）和递归（recursion）。
>
> 你进大学后，一开始总要上一门“数据结构”课（data structure）, 然后会有线
> 性链表（linked list）、哈希表（hash table），以及其他诸如此类的课程。
> 这些课会大量使用“指针”。它们经常起到一种优胜劣汰的作用。因为这些课程非
> 常难，那些学不会的人，就表明他们的能力不足以达到计算机科学学士学位的要
> 求，只能选择放弃这个专业。这是一件好事，因为如果你连指针很觉得很难，那
> 么等学到后面，要你证明不动点定理（fixed point theory）的时候，你该怎么
> 办呢？
>
> 有些孩子读高中的时候，就能用BASIC语言在Apple II型个人电脑上，写出漂亮
> 的乒乓球游戏。等他们进了大学，都会去选修计算机科学101课程，那门课讲的
> 就是数据结构。当他们接触到指针那些玩意以后，就一下子完全傻眼了，后面的
> 事情你都可以想像，他们就去改学政治学，因为看上去法学院是一个更好的出路
> [1]。关于计算机系的淘汰率，我见过各式各样的数字，通常在40%到70%之间。
> 校方一般会觉得，学生拿不到学位很可惜，我则视其为必要的筛选，淘汰那些没
> 有兴趣编程或者没有能力编程的人。
>
> 对于许多计算机系的青年学生来说，另一门有难度的课程是有关函数式编程
> （functional programming）的课程，其中就包括递归程序设计（recursive
> programming）。MIT将这些课程的标准提得很高，还专门设立了一门必修课（课
> 程代号6.001[2]），它的教材（Structure and Interpretation of Computer
> Programs，作者为Harold Abelson和Gerald Jay Sussman Abelson，MIT出版社
> 1996年版）被几十所、甚至几百所著名高校的计算系机采用，充当事实上的计算
> 机科学导论课程。（你能在网上找到这本教材的旧版本，应该读一下。）
>
> 这些课程难得惊人。在第一堂课，你就要学完Scheme语言[3]的几乎所有内容，
> 你还会遇到一个不动点函数（fixed-point function），它的自变量本身就是另
> 一个函数。我读的这门导论课，是宾夕法尼亚大学的CSE 121课程，真是读得苦
> 不堪言。我注意到很多学生，也许是大部分的学生，都无法完成这门课。课程的
> 内容实在太难了。我给教授写了一封长长的声泪俱下的 Email，控诉这门课不是
> 给人学的。宾夕法尼亚大学里一定有人听到了我的呼声（或者听到了其他抱怨者
> 的呼声），因为如今这门课讲授的计算机语言是 Java。
>
> 我现在觉得，他们还不如没有听见呢。
>
> 这就是争议所在。许多年来，像当年的我一样懒惰的计算机系本科生不停地抱
> 怨，再加上计算机业界也在抱怨毕业生不够用，这一切终于造成了重大恶果。过
> 去十年中，大量本来堪称完美的好学校，都百分之百转向了Java语言的怀抱。这
> 真是好得没话说了，那些用“grep”命令[4]过滤简历的企业招聘主管，大概会很
> 喜欢这样。最妙不可言的是，Java语言中没有什么太难的地方，不会真的淘汰什
> 么人，你搞不懂指针或者递归也没关系。所以，计算系的淘汰率就降低了，学生
> 人数上升了，经费预算变大了，可谓皆大欢喜。
>
> 学习Java语言的孩子是幸运的，因为当他们用到以指针为基础的哈希表时，他们
> 永远也不会遇到古怪的“段错误”[5]（segfault）。他们永远不会因为无法将数
> 据塞进有限的内存空间，而急得发疯。他们也永远不用苦苦思索，为什么在一个
> 纯函数的程序中，一个变量的值一会保持不变，一会又变个不停！多么自相矛盾啊！
>
> 他们不需要怎么动脑筋，就可以在专业上得到4.0的绩点。
>
> 我是不是有点太苛刻了？就像电视里的“四个约克郡男人”[6]（Four
> Yorkshiremen）那样，成了老古板？就在这里吹嘘我是多么刻苦，完成了所有那
> 些高难度的课程？
>
> 我再告诉你一件事。1900年的时候，拉丁语和希腊语都是大学里的必修课，原因
> 不是因为它们有什么特别的作用，而是因为它们有点被看成是受过高等教育的人
> 士的标志。在某种程度上，我的观点同拉丁语支持者的观点没有不同（下面的四
> 点理由都是如此）：“（拉丁语）训练你的思维，锻炼你的记忆。分析拉丁语的
> 句法结构，是思考能力的最佳练习，是真正对智力的挑战，能够很好地培养逻辑
> 能力。”以上出自Scott Barker之口（http:
> //www.promotelatin.org/whylatin.htm）。但是，今天我找不到一所大学，还
> 把拉丁语作为必修课。指针和递归不正像计算机科学中的拉丁语和希腊语吗？
>
> 说到这里，我坦率地承认，当今的软件代码中90%都不需要使用指针。事实上，
> 如果在正式产品中使用指针，这将是十分危险的。好的，这一点没有异议。与此
> 同时，函数式编程在实际开发中用到的也不多。这一点我也同意。
>
> 但是，对于某些最激动人心的编程任务来说，指针仍然是非常重要的。比如说，
> 如果不用指针，你根本没办法开发Linux的内核。如果你不是真正地理解了指
> 针，你连一行Linux的代码也看不懂，说实话，任何操作系统的代码你都看不懂。
>
> 如果你不懂函数式编程，你就无法创造出MapReduce[7]，正是这种算法使得
> Google的可扩展性（scalable）达到如此巨大的规模。单词“Map”（映射）和
> “Reduce”（化简）分别来自Lisp语言和函数式编程。回想起来，在类似6.001这
> 样的编程课程中，都有提到纯粹的函数式编程没有副作用，因此可以直接用于并
> 行计算（parallelizable）。任何人只要还记得这些内容，那么MapRuduce对他
> 来说就是显而易见的。发明MapReduce的公司是Google，而不是微软，这个简单
> 的事实说出了原因，为什么微软至今还在追赶，还在试图提供最基本的搜索服
> 务，而Google已经转向了下一个阶段，开发世界上最大的并行式超级计算机――
> Skynet[8]的H次方的H次方的H次方的H次方的H次方的H次方。我觉得，微软并没
> 有完全明白，在这一波竞争中它落后多远。
>
> 除了上面那些直接就能想到的重要性，指针和递归的真正价值，在于那种你在学
> 习它们的过程中，所得到的思维深度，以及你因为害怕在这些课程中被淘汰，所
> 产生的心理抗压能力，它们都是在建造大型系统的过程中必不可少的。指针和递
> 归要求一定水平的推理能力、抽象思考能力，以及最重要的，在若干个不同的抽
> 象层次上，同时审视同一个问题的能力。因此，是否真正理解指针和递归，与是
> 否是一个优秀程序员直接相关。
>
> 如果计算机系的课程都与Java语言有关，那么对于那些在智力上无法应付复杂概
> 念的学生，就没有东西可以真的淘汰他们。作为一个雇主，我发现那些
> 100%Java教学的计算机系，已经培养出了相当一大批毕业生，这些学生只能勉强
> 完成难度日益降低的课程作业，只会用Java语言编写简单的记账程序，如果你让
> 他们编写一个更难的东西，他们就束手无策了。他们的智力不足以成为程序员。
> 这些学生永远也通不过MIT的6.001课程，或者耶鲁大学的CS 323课程。坦率地
> 说，为什么在一个雇主的心目中，MIT或者耶鲁大学计算机系的学位的份量，要
> 重于杜克大学，这就是原因之一。因为杜克大学最近已经全部转为用Java语言教
> 学。宾夕法尼亚大学的情况也很类似，当初CSE 121课程中的Scheme语言和ML语
> 言，几乎将我和我的同学折磨至死，如今已经全部被Java语言替代。我的意思不
> 是说，我不想雇佣来自杜克大学或者宾夕法尼亚大学的聪明学生，我真的愿意雇
> 佣他们，只是对于我来说，确定他们是否真的聪明，如今变得难多了。以前，我
> 能够分辨出谁是聪明学生，因为他们可以在一分钟内看懂一个递归算法，或者可
> 以迅速在计算机上实现一个线性链表操作函数，所用的时间同黑板上写一遍差不
> 多。但是对于Java语言学校的毕业生，看着他们面对上述问题苦苦思索、做不出
> 来的样子，我分辨不出这到底是因为学校里没教，还是因为他们不具备编写优秀
> 软件作品的素质。Paul Graham将这一类程序员称为“Blub程序员”[9]
> （www.paulgraham.com/avg.html <http://www.paulgraham.com/avg.html>）。
>
> Java语言学校无法淘汰那些永远也成不了优秀程序员的学生，这已经是很糟糕的
> 事情了。但是，学校可以无可厚非地辩解，这不是校方的错。整个软件行业，或
> 者说至少是其中那些使用grep命令过滤简历的招聘经理，确实是在一直叫嚷，要
> 求学校使用Java语言教学。
>
> 但是，即使如此，Java语言学校的教学也还是失败的，因为学校没有成功训练好
> 学生的头脑，没有使他们变得足够熟练、敏捷、灵活，能够做出高质量的软件设
> 计（我不是指面向对象式的“设计”，那种编程只不过是要求你花上无数个小时，
> 重写你的代码，使它们能够满足面向对象编程的等级制继承式结构，或者说要求
> 你思考到底对象之间是“has-a”从属关系，还是“is-a”继承关系，这种“伪问题”
> 将你搞得烦躁不安）。你需要的是那种能够在多个抽象层次上，同时思考问题的
> 训练。这种思考能力正是设计出优秀软件架构所必需的。
>
> 你也许想知道，在教学中，面向对象编程（object-oriented programming，缩
> 写OOP）是否是指针和递归的优质替代品，是不是也能起到淘汰作用。简单的回
> 答是：“不”。我在这里不讨论OOP的优点，我只指出OOP不够难，无法淘汰平庸的
> 程序员。大多数时候，OOP教学的主要内容就是记住一堆专有名词，比如“封装”
> （encapsulation）和“继承 ”（inheritance）”，然后再做一堆多选题小测验，
> 考你是不是明白“多态”（polymorphism）和“重载”（overloading）的区别。这
> 同历史课上，要求你记住重要的日期和人名，难度差不多。OOP不构成对智力的
> 太大挑战，吓不跑一年级新生。据说，如果你没学好OOP，你的程序依然可以运
> 行，只是维护起来有点难。但是如果你没学好指针，你的程序就会输出一行段错
> 误信息，而且你对什么地方出错了毫无想法，然后你只好停下来，深吸一口气，
> 真正开始努力在两个不同的抽象层次上，同时思考你的程序是如何运行的。
>
> 顺便说一句，我有充分理由在这里说，那些使用grep命令过滤简历的招聘经理真
> 是荒谬可笑。我从来没有见过哪个能用Scheme语言、 Haskell语言和C语言中的
> 指针编程的人，竟然不能在二天里面学会Java语言，并且写出的Java程序，质量
> 竟然不能胜过那些有5年Java编程经验的人士。不过，人力资源部里那些平庸的
> 懒汉，是无法指望他们听进去这些话的。
>
> 再说，计算机系承担的发扬光大计算机科学的使命该怎么办呢？计算机系毕竟不
> 是职业学校啊！训练学生如何在这个行业里工作，不应该是计算机系的任务。这
> 应该是社区高校和政府就业培训计划的任务，那些地方会教给你工作技能。计算
> 机系给予学生的，理应是他们日后生活所需要的基础知识，而不是为学生第一周
> 上班做准备。对不对？
>
> 还有，计算机科学是由证明（递归）、算法（递归）、语言（λ演算[10]）、操
> 作系统（指针）、编译器（λ演算）所组成的。所以，这就是说那些不教 C语
> 言、不教Scheme语言、只教Java语言的学校，实际上根本不是在教授计算机科
> 学。虽然对于真实世界来说，有些概念可能毫无用处，比如函数的科里化
> （function currying）[11]，但是这些知识显然是进入计算机科学研究生院的
> 前提。我不明白，计算机系课程设置委员会中的教授为什么会同意，将课程的难
> 度下降到如此低的地步，以至于他们既无法培养出合格的程序员，甚至也无法培
> 养出合格的能够得到哲学博士PhD学位[12]、进而能够申请教职、与他们竞争工
> 作岗位的研究生。噢，且慢，我说错了。也许我明白原因了。
>
> 实际上，如果你回顾和研究学术界在“Java大迁移”（Great Java Shift）中的争
> 论，你会注意到，最大的议题是Java语言是否还不够简单，不适合作为一种教学
> 语言。
>
> 我的老天啊，我心里说，他们还在设法让课程变得更简单。为什么不用匙子，干
> 脆把所有东西一勺勺都喂到学生嘴里呢？让我们再请助教帮他们接管考试，这样
> 一来就没有学生会改学“美国研究”[13]（American studies）了。如果课程被精
> 心设计，使得所有内容都比原有内容更容易，那么怎么可能期望任何人从这个地
> 方学到任何东西呢？看上去似乎有一个工作小组（Java task force）正在开展
> 工作，创造出一个简化的Java的子集，以便在课堂上教学[14]。这些人的目标是
> 生成一个简化的文档，小心地不让学生纤弱的思想，接触到任何EJB/J2EE的脏东
> 西[15]。这样一来，学生的小脑袋就不会因为遇到有点难度的课程，而感到烦恼
> 了，除非那门课里只要求做一些空前简单的计算机习题。
>
> 计算机系如此积极地降低课程难度，有一个理由可以得到最多的赞同，那就是节
> 省出更多的时间，教授真正的属于计算机科学的概念。但是，前提是不能花费整
> 整两节课，向学生讲解诸如Java语言中int和Integer有何区别[16]。好的，如果
> 真是这样，课程6.001就是你的完美选择。你可以先讲 Scheme语言，这种教学语
> 言简单到聪明学生大约只用10分钟，就能全部学会。然后，你将这个学期剩下的
> 时间，都用来讲解不动点。
>
> 唉。
>
> 说了半天，我还是在说要学1和0。
>
> （你学到了1？真幸运啊！我们那时所有人学到的都是0。）
>
> ================
>
> 注解：
>
> [1] 在美国，法学院的入学者都必须具有本科学位。通常来说，主修政治学的学
> 生升入法学院的机会最大。
>
> [2] 在麻省理工学院，计算机系的课程代码都是以6开头的，6.001表明这是计算
> 机系的最基础课程。
>
> [3] Scheme语言是LISP语言的一个变种，诞生于1975年的MIT，以其对函数式编
> 程的支持而闻名。这种语言在商业领域的应用很少，但是在计算机教育领域内有
> 着广泛影响。
>
> [4] grep是Unix/Linux环境中用于搜索或者过滤内容的命令。这里指的是，某些
> 招聘人员仅仅根据一些关键词来过滤简历，比如本文中的Java。
>
> [5] 段错误（segfault）是segmentation fault的缩写，指的是软件中的一类特
> 定的错误，通常发生在程序试图读取不允许读取的内存地址、或者以非法方式读
> 取内存的时候。
>
> [6] 《四个约克郡男人》（Four Yorkshiremen）,是英国电视系列喜剧At Last
> the 1948 Show中的一部，与上个世纪70年代问世。内容是四个约克郡男人竞相
> 吹嘘，各自的童年是多么困苦，由于内容太夸张，所以显得非常可笑。
>
> [7] MapReduce是一种由Google引入使用的软件框架，用于支持计算机集群环境
> 下，海量数据（PB级别）的并行计算。
>
> [8] Skynet是美国系列电影《终结者》（Terminator）中一个控制一切、与人类为
> 敌的超级计算机系统的名称，通常将其看作虚构的人工智能的代表。
>
> [9] Blub程序员（Blub programmers）指的是那些企图用一种语言，解决所有问
> 题的程序员。Blub是Paul Graham假设的一种高级编程语言。
>
> [10] λ演算（lambda calculus）是一套用于研究函数定义、函数应用和递归的
> 形式系统，在递归理论和函数式编程中有着广泛的应用。
>
> [11] 函数的科里化（function currying）指的是一种多元函数的消元技巧，将
> 其变为一系列只有一元的链式函数。它最早是由美国数学家哈斯格尔・科里
> （Haskell Curry）提出的，因此而得名。
>
> [12] 在美国，所有基础理论的学科，一律授予的都是哲学博士学位（Doctor of
> Philosophy），计算机科学系亦是如此。
>
> [13] 美国研究（American studies）是对美国社会的经济、历史、文化等各个
> 方面进行研究的一门学科。这里指的是，计算机系学生不会因为课程太难被淘
> 汰，所以就不用改学相对容易的“美国研究”。
>
> [14] 参见http: //www.sigcse.org/topics/javataskforce/java-task-force.pdf。
>
> [15] J2EE是Java2平台企业版（Java 2 Platform,Enterprise Edition），指的
> 是一整套企业级开发架构。EJB（Enterprise JavaBean）属于J2EE的一部分，是
> 一个基于组件的企业级开发规范。它们通常被认为是Java中相对较难的部分。
>
> [16] 在Java语言中，int是一种数据类型，表示整数，而Integer是一个适用于
> 面向对象编程的类，表示整数对象。两者的涵义和性质都不一样。
>
> （完）
>
> ------------------------------------------------------------------------
>
> _______________________________________________
> zeuux-universe mailing list
> zeuux-universe at zeuux.org
> http://www.zeuux.org/mailman/listinfo/zeuux-universe
>
> ZEUUX Project - Free Software, Free Society!
> http://www.zeuux.org
>   

2008/12/10 Xia Qingran <qingran在zeuux.org>:
>
> 刚看到了一篇非常好的文章，其中包括了计算机科学、计算机专业的大学课程等内容，引人深思。
>
应该算是有关的OT,,,和学习/IT/世界观,
套用刘鑫的一句话:"一切都是幻觉!"
问题是有些幻觉实在忒真了,以至几乎所有人都相信了,
那么,你从是不从?

> 原文URL
> http://www.ruanyifeng.com/blog/2008/12/the_perils_of_javaschools.html
>
> 转载原文：
>
> ========================================================================
>
>
> Java 语言学校的危险性（译文）
>
> from 阮一峰的网络日志
>
> 下面的文章是More Joel on Software一书的第8篇。
>
> 我觉得翻译难度很大，整整两个工作日，每天8小时以上，才译出了5000字。除了Joel大量使用俚语，另一个原因是原文涉及"编程原理"，好多东
> 西我根本不懂。希望懂的朋友帮我看看，译文有没有错误，包括我写的注解。
>
> ====================
>
> JAVA语言学校的危险性
>
> 作者：Joel Spolsky
>
> 译者：阮一峰
>
> 原文： http://www.joelonsoftware.com/articles/ThePerilsofJavaSchools.html
>
> 发表日期 2005年12月29日，星期四
>
> 如今的孩子变懒了。
>
> 多吃一点苦，又会怎么样呢？
>
> 我一定是变老了，才会这样喋喋不休地抱怨和感叹"如今的孩子"。为什么他们不再愿意、或者说不再能够做艰苦的工作呢。
>
> 当我还是孩子的时候，学习编程需要用到穿孔卡片（punched cards）。那时可没有任何类似"退格"键（Backspace
> key）这样的现代化功能，如果你出错了，就没有办法更正，只好扔掉出错的卡片，从头再来。
>
> 回想1991年，我开始面试程序员的时候。我一般会出一些编程题，允许用任何编程语言解题。在99%的情况下，面试者选择C语言。
>
> 如今，面试者一般会选择Java语言。
>
> 说到这里，不要误会我的意思。Java语言本身作为一种开发工具，并没有什么错。
>
> 等一等，我要做个更正。我只是在本篇特定的文章中，不会提到Java语言作为一种开发工具，有什么不好的地方。事实上，它有许许多多不好的地方，不
> 过这些只有另找时间来谈了。
>
> 我在这篇文章中，真正想要说的是，总的来看，Java不是一种非常难的编程语言，无法用来区分优秀程序员和普通程序员。它可能很适合用来完成工作，
> 但是这个不是今天的主题。我甚至想说，Java语言不够难，其实是它的特色，不能算缺点。但是不管怎样，它就是有这个问题。
>
> 如果我听上去像是妄下论断，那么我想说一点我自己的微不足道的经历。大学计算机系的课程里，传统上有两个知识点，许多人从来都没有真正搞懂过的，那
> 就是指针（pointers）和递归（recursion）。
>
> 你进大学后，一开始总要上一门"数据结构"课（data structure）, 然后会有线性链表（linked list）、哈希表（hash
> table），以及其他诸如此类的课程。这些课会大量使用"指针"。它们经常起到一种优胜劣汰的作用。因为这些课程非常难，那些学不会的人，就表明他们的
> 能力不足以达到计算机科学学士学位的要求，只能选择放弃这个专业。这是一件好事，因为如果你连指针很觉得很难，那么等学到后面，要你证明不动点定理 （fixed
> point theory）的时候，你该怎么办呢？
>
> 有些孩子读高中的时候，就能用BASIC语言在Apple
> II型个人电脑上，写出漂亮的乒乓球游戏。等他们进了大学，都会去选修计算机科学101课程，那门课讲的就是数据结构。当他们接触到指针那些玩意以后，就
> 一下子完全傻眼了，后面的事情你都可以想像，他们就去改学政治学，因为看上去法学院是一个更好的出路[1]。关于计算机系的淘汰率，我见过各式各样的数
> 字，通常在40%到70%之间。校方一般会觉得，学生拿不到学位很可惜，我则视其为必要的筛选，淘汰那些没有兴趣编程或者没有能力编程的人。
>
> 对于许多计算机系的青年学生来说，另一门有难度的课程是有关函数式编程（functional
> programming）的课程，其中就包括递归程序设计（recursive
> programming）。MIT将这些课程的标准提得很高，还专门设立了一门必修课（课程代号6.001[2]），它的教材（Structure and
> Interpretation of Computer Programs，作者为Harold Abelson和Gerald Jay Sussman
> Abelson，MIT出版社1996年版）被几十所、甚至几百所著名高校的计算系机采用，充当事实上的计算机科学导论课程。（你能在网上找到这本教材的
> 旧版本，应该读一下。）
>
> 这些课程难得惊人。在第一堂课，你就要学完Scheme语言[3]的几乎所有内容，你还会遇到一个不动点函数（fixed-point
> function），它的自变量本身就是另一个函数。我读的这门导论课，是宾夕法尼亚大学的CSE
> 121课程，真是读得苦不堪言。我注意到很多学生，也许是大部分的学生，都无法完成这门课。课程的内容实在太难了。我给教授写了一封长长的声泪俱下的
> Email，控诉这门课不是给人学的。宾夕法尼亚大学里一定有人听到了我的呼声（或者听到了其他抱怨者的呼声），因为如今这门课讲授的计算机语言是 Java。
>
> 我现在觉得，他们还不如没有听见呢。
>
> 这就是争议所在。许多年来，像当年的我一样懒惰的计算机系本科生不停地抱怨，再加上计算机业界也在抱怨毕业生不够用，这一切终于造成了重大恶果。过
> 去十年中，大量本来堪称完美的好学校，都百分之百转向了Java语言的怀抱。这真是好得没话说了，那些用"grep"命令[4]过滤简历的企业招聘主管，
> 大概会很喜欢这样。最妙不可言的是，Java语言中没有什么太难的地方，不会真的淘汰什么人，你搞不懂指针或者递归也没关系。所以，计算系的淘汰率就降低
> 了，学生人数上升了，经费预算变大了，可谓皆大欢喜。
>
> 学习Java语言的孩子是幸运的，因为当他们用到以指针为基础的哈希表时，他们永远也不会遇到古怪的"段错误"[5]（segfault）。他们永
> 远不会因为无法将数据塞进有限的内存空间，而急得发疯。他们也永远不用苦苦思索，为什么在一个纯函数的程序中，一个变量的值一会保持不变，一会又变个不
> 停！多么自相矛盾啊！
>
> 他们不需要怎么动脑筋，就可以在专业上得到4.0的绩点。
>
> 我是不是有点太苛刻了？就像电视里的"四个约克郡男人"[6]（Four
> Yorkshiremen）那样，成了老古板？就在这里吹嘘我是多么刻苦，完成了所有那些高难度的课程？
>
> 我再告诉你一件事。1900年的时候，拉丁语和希腊语都是大学里的必修课，原因不是因为它们有什么特别的作用，而是因为它们有点被看成是受过高等教
> 育的人士的标志。在某种程度上，我的观点同拉丁语支持者的观点没有不同（下面的四点理由都是如此）："（拉丁语）训练你的思维，锻炼你的记忆。分析拉丁语
> 的句法结构，是思考能力的最佳练习，是真正对智力的挑战，能够很好地培养逻辑能力。"以上出自Scott
> Barker之口（http://www.promotelatin.org/whylatin.htm）。
> 但是，今天我找不到一所大学，还把拉丁语作为必修课。指针和递归不正像计算机科学中的拉丁语和希腊语吗？
>
> 说到这里，我坦率地承认，当今的软件代码中90%都不需要使用指针。事实上，如果在正式产品中使用指针，这将是十分危险的。好的，这一点没有异议。
> 与此同时，函数式编程在实际开发中用到的也不多。这一点我也同意。
>
> 但是，对于某些最激动人心的编程任务来说，指针仍然是非常重要的。比如说，如果不用指针，你根本没办法开发Linux的内核。如果你不是真正地理解
> 了指针，你连一行Linux的代码也看不懂，说实话，任何操作系统的代码你都看不懂。
>
> 如果你不懂函数式编程，你就无法创造出MapReduce[7]，正是这种算法使得Google的可扩展性（scalable）达到如此巨大的规
> 模。单词"Map"（映射）和"Reduce"（化简）分别来自Lisp语言和函数式编程。回想起来，在类似6.001这样的编程课程中，都有提到纯粹的
> 函数式编程没有副作用，因此可以直接用于并行计算（parallelizable）。任何人只要还记得这些内容，那么MapRuduce对他来说就是显而
> 易见的。发明MapReduce的公司是Google，而不是微软，这个简单的事实说出了原因，为什么微软至今还在追赶，还在试图提供最基本的搜索服务，
> 而Google已经转向了下一个阶段，开发世界上最大的并行式超级计算机——Skynet[8]的H次方的H次方的H次方的H次方的H次方的H次方。我觉
> 得，微软并没有完全明白，在这一波竞争中它落后多远。
>
> 除了上面那些直接就能想到的重要性，指针和递归的真正价值，在于那种你在学习它们的过程中，所得到的思维深度，以及你因为害怕在这些课程中被淘汰，
> 所产生的心理抗压能力，它们都是在建造大型系统的过程中必不可少的。指针和递归要求一定水平的推理能力、抽象思考能力，以及最重要的，在若干个不同的抽象
> 层次上，同时审视同一个问题的能力。因此，是否真正理解指针和递归，与是否是一个优秀程序员直接相关。
>
> 如果计算机系的课程都与Java语言有关，那么对于那些在智力上无法应付复杂概念的学生，就没有东西可以真的淘汰他们。作为一个雇主，我发现那些
> 100%Java教学的计算机系，已经培养出了相当一大批毕业生，这些学生只能勉强完成难度日益降低的课程作业，只会用Java语言编写简单的记账程序，
> 如果你让他们编写一个更难的东西，他们就束手无策了。他们的智力不足以成为程序员。这些学生永远也通不过MIT的6.001课程，或者耶鲁大学的CS
> 323课程。坦率地说，为什么在一个雇主的心目中，MIT或者耶鲁大学计算机系的学位的份量，要重于杜克大学，这就是原因之一。因为杜克大学最近已经全部
> 转为用Java语言教学。宾夕法尼亚大学的情况也很类似，当初CSE
> 121课程中的Scheme语言和ML语言，几乎将我和我的同学折磨至死，如今已经全部被Java语言替代。我的意思不是说，我不想雇佣来自杜克大学或者
> 宾夕法尼亚大学的聪明学生，我真的愿意雇佣他们，只是对于我来说，确定他们是否真的聪明，如今变得难多了。以前，我能够分辨出谁是聪明学生，因为他们可以
> 在一分钟内看懂一个递归算法，或者可以迅速在计算机上实现一个线性链表操作函数，所用的时间同黑板上写一遍差不多。但是对于Java语言学校的毕业生，看
> 着他们面对上述问题苦苦思索、做不出来的样子，我分辨不出这到底是因为学校里没教，还是因为他们不具备编写优秀软件作品的素质。Paul
> Graham将这一类程序员称为"Blub程序员"[9]（www.paulgraham.com/avg.html）。
>
> Java语言学校无法淘汰那些永远也成不了优秀程序员的学生，这已经是很糟糕的事情了。但是，学校可以无可厚非地辩解，这不是校方的错。整个软件行
> 业，或者说至少是其中那些使用grep命令过滤简历的招聘经理，确实是在一直叫嚷，要求学校使用Java语言教学。
>
> 但是，即使如此，Java语言学校的教学也还是失败的，因为学校没有成功训练好学生的头脑，没有使他们变得足够熟练、敏捷、灵活，能够做出高质量的
> 软件设计（我不是指面向对象式的"设计"，那种编程只不过是要求你花上无数个小时，重写你的代码，使它们能够满足面向对象编程的等级制继承式结构，或者说
> 要求你思考到底对象之间是"has-a"从属关系，还是"is-a"继承关系，这种"伪问题"将你搞得烦躁不安）。你需要的是那种能够在多个抽象层次上，
> 同时思考问题的训练。这种思考能力正是设计出优秀软件架构所必需的。
>
> 你也许想知道，在教学中，面向对象编程（object-oriented
> programming，缩写OOP）是否是指针和递归的优质替代品，是不是也能起到淘汰作用。简单的回答是："不"。我在这里不讨论OOP的优点，我只
> 指出OOP不够难，无法淘汰平庸的程序员。大多数时候，OOP教学的主要内容就是记住一堆专有名词，比如"封装"（encapsulation）和"继承
> "（inheritance）"，然后再做一堆多选题小测验，考你是不是明白"多态"（polymorphism）和"重载"（overloading）
> 的区别。这同历史课上，要求你记住重要的日期和人名，难度差不多。OOP不构成对智力的太大挑战，吓不跑一年级新生。据说，如果你没学好OOP，你的程序
> 依然可以运行，只是维护起来有点难。但是如果你没学好指针，你的程序就会输出一行段错误信息，而且你对什么地方出错了毫无想法，然后你只好停下来，深吸一
> 口气，真正开始努力在两个不同的抽象层次上，同时思考你的程序是如何运行的。
>
> 顺便说一句，我有充分理由在这里说，那些使用grep命令过滤简历的招聘经理真是荒谬可笑。我从来没有见过哪个能用Scheme语言、
> Haskell语言和C语言中的指针编程的人，竟然不能在二天里面学会Java语言，并且写出的Java程序，质量竟然不能胜过那些有5年Java编程经
> 验的人士。不过，人力资源部里那些平庸的懒汉，是无法指望他们听进去这些话的。
>
> 再说，计算机系承担的发扬光大计算机科学的使命该怎么办呢？计算机系毕竟不是职业学校啊！训练学生如何在这个行业里工作，不应该是计算机系的任务。
> 这应该是社区高校和政府就业培训计划的任务，那些地方会教给你工作技能。计算机系给予学生的，理应是他们日后生活所需要的基础知识，而不是为学生第一周上
> 班做准备。对不对？
>
> 还有，计算机科学是由证明（递归）、算法（递归）、语言（λ演算[10]）、操作系统（指针）、编译器（λ演算）所组成的。所以，这就是说那些不教
> C语言、不教Scheme语言、只教Java语言的学校，实际上根本不是在教授计算机科学。虽然对于真实世界来说，有些概念可能毫无用处，比如函数的科里
> 化（function
> currying）[11]，但是这些知识显然是进入计算机科学研究生院的前提。我不明白，计算机系课程设置委员会中的教授为什么会同意，将课程的难度下
> 降到如此低的地步，以至于他们既无法培养出合格的程序员，甚至也无法培养出合格的能够得到哲学博士PhD学位[12]、进而能够申请教职、与他们竞争工作
> 岗位的研究生。噢，且慢，我说错了。也许我明白原因了。
>
> 实际上，如果你回顾和研究学术界在"Java大迁移"（Great Java
> Shift）中的争论，你会注意到，最大的议题是Java语言是否还不够简单，不适合作为一种教学语言。
>
> 我的老天啊，我心里说，他们还在设法让课程变得更简单。为什么不用匙子，干脆把所有东西一勺勺都喂到学生嘴里呢？让我们再请助教帮他们接管考试，这
> 样一来就没有学生会改学"美国研究"[13]（American
> studies）了。如果课程被精心设计，使得所有内容都比原有内容更容易，那么怎么可能期望任何人从这个地方学到任何东西呢？看上去似乎有一个工作小组
> （Java task
> force）正在开展工作，创造出一个简化的Java的子集，以便在课堂上教学[14]。这些人的目标是生成一个简化的文档，小心地不让学生纤弱的思想，
> 接触到任何EJB/J2EE的脏东西[15]。这样一来，学生的小脑袋就不会因为遇到有点难度的课程，而感到烦恼了，除非那门课里只要求做一些空前简单的
> 计算机习题。
>
> 计算机系如此积极地降低课程难度，有一个理由可以得到最多的赞同，那就是节省出更多的时间，教授真正的属于计算机科学的概念。但是，前提是不能花费
> 整整两节课，向学生讲解诸如Java语言中int和Integer有何区别[16]。好的，如果真是这样，课程6.001就是你的完美选择。你可以先讲
> Scheme语言，这种教学语言简单到聪明学生大约只用10分钟，就能全部学会。然后，你将这个学期剩下的时间，都用来讲解不动点。
>
> 唉。
>
> 说了半天，我还是在说要学1和0。
>
> （你学到了1？真幸运啊！我们那时所有人学到的都是0。）
>
> ================
>
> 注解：
>
> [1] 在美国，法学院的入学者都必须具有本科学位。通常来说，主修政治学的学生升入法学院的机会最大。
>
> [2] 在麻省理工学院，计算机系的课程代码都是以6开头的，6.001表明这是计算机系的最基础课程。
>
> [3] Scheme语言是LISP语言的一个变种，诞生于1975年的MIT，以其对函数式编程的支持而闻名。这种语言在商业领域的应用很少，但是在计算机教育
> 领域内有着广泛影响。
>
> [4] grep是Unix/Linux环境中用于搜索或者过滤内容的命令。这里指的是，某些招聘人员仅仅根据一些关键词来过滤简历，比如本文中的Java。
>
> [5] 段错误（segfault）是segmentation
> fault的缩写，指的是软件中的一类特定的错误，通常发生在程序试图读取不允许读取的内存地址、或者以非法方式读取内存的时候。
>
> [6] 《四个约克郡男人》（Four Yorkshiremen）,是英国电视系列喜剧At Last the 1948
> Show中的一部，与上个世纪70年代问世。内容是四个约克郡男人竞相吹嘘，各自的童年是多么困苦，由于内容太夸张，所以显得非常可笑。
>
> [7] MapReduce是一种由Google引入使用的软件框架，用于支持计算机集群环境下，海量数据（PB级别）的并行计算。
>
> [8] Skynet是美国系列电影《终结者》（Terminator）中一个控制一切、与人类为敌的超级计算机系统的名称，通常将其看作虚构的人工智能的代表。
>
> [9] Blub程序员（Blub programmers）指的是那些企图用一种语言，解决所有问题的程序员。Blub是Paul
> Graham假设的一种高级编程语言。
>
> [10] λ演算（lambda calculus）是一套用于研究函数定义、函数应用和递归的形式系统，在递归理论和函数式编程中有着广泛的应用。
>
> [11] 函数的科里化（function
> currying）指的是一种多元函数的消元技巧，将其变为一系列只有一元的链式函数。它最早是由美国数学家哈斯格尔·科里（Haskell
> Curry）提出的，因此而得名。
>
> [12] 在美国，所有基础理论的学科，一律授予的都是哲学博士学位（Doctor of Philosophy），计算机科学系亦是如此。
>
> [13] 美国研究（American
> studies）是对美国社会的经济、历史、文化等各个方面进行研究的一门学科。这里指的是，计算机系学生不会因为课程太难被淘汰，所以就不用改学相对容
> 易的"美国研究"。
>
> [14] 参见http://www.sigcse.org/topics/javataskforce/java-task-force.pdf。
>
> [15] J2EE是Java2平台企业版（Java 2 Platform,Enterprise
> Edition），指的是一整套企业级开发架构。EJB（Enterprise
> JavaBean）属于J2EE的一部分，是一个基于组件的企业级开发规范。它们通常被认为是Java中相对较难的部分。
>
> [16] 在Java语言中，int是一种数据类型，表示整数，而Integer是一个适用于面向对象编程的类，表示整数对象。两者的涵义和性质都不一样。
>
> （完）
>



-- 
http://zoomquiet.org'''
过程改进乃是催生可促生靠谱的人的组织!
PE keeps evolving organizations which promoting people be good!'''
[HR]金山软件常年招聘大量Py/C++人才!
https://groups.google.com/group/python-cn/web/ot-py-c
简历直投俺就好;-)