[singlepic=15816,700,437]

[singlepic=15462]

什么是 PB？抱歉，各位苹科科的爱好者们，我说的不是 PowerBook；抱歉，各位化学爱好者们，我说的也不是铅。这里想说的是 PetaByte (也就是 1000 TB，或 1,000,000 GB)的纪元来临时的挑战。1 PB 的纪元？现在就想这个做啥？毕竟现在硬盘主流连 1TB 都还不到不是吗？从数据储存的角度来看，这样说是没错，七月号的 Wired 杂志上举了几个很生动的例子告诉我们，其实要用光 1000TB 的容量还蛮困难的：

• 现在出去买一台玩家级的新电脑，容量大约是 1TB（或者，小姜库存的*哔*片也大约这个数）。
• 每周上传到社交网站 Facebook 上的照片总量是 20TB。
• 哈柏太空望远镜从发射以来产生的总数据量大约是 120TB
• 大型强子碰撞器每周产生的数据量大约是 330TB。
• 美国国家气候中心所以收集下来的资料总量约是 460TB。
• Youtube 上所有的影片的总量约是 530TB（比想象中小？）。
• Ancestry.com（一个家族追根数据库）加上内附的 1790-2000 人口普查数据大约是 600 TB。

看吧！PB 的事还是留给后代子孙去烦恼好了，看起来要一次用掉 1PB 还早呢！是啦，要变出 1PB 的数据看起来是有困难，但从数据处理的角度来说，1PB 只是 Google 服务器每 72 分钟处理的数据量而已。虽然从数据储存的角度来看，我们还处在 TB 时代，但已经有很多预兆告诉我们，下一个量级单位带来的会是完全不同的一组新挑战。小姜在后面想了五个可能：

PB 时代的第一大挑战是什么？就是数据的过滤。就算人类已经有产生 PB 级数据量的能力，但事实是我们并没有把这些数据全部有效地存取的技术。因此选择哪些数据更有价值，就成为了很重要的课题。之前就有提过的大型强子碰撞器， 事实上因为是在观测为时非常短的现象，因此每秒大约要拍下十亿张的照片，才能确保不漏掉什么重要的事情。如果全部的数据都要保留的话，每秒钟就必须储存 10PB 左右的数据 — 也就是说每秒钟会塞满 10,000 颗 1TB 容量的硬盘。这是一个靠现有技术绝对不可能办到的事情，所以必须靠硬件和软件的过滤，找出每秒大约 100 个值得关注的事。即使如此，一年仍将产生约 15PB 的数据，或 15,000 颗 1TB 的硬盘，藏在这些数据里头的，有黑洞、异次元、平行宇宙，还有两三个诺贝尔奖吧？

第二个挑战，是资料的分析。 分析和过滤不一样，过滤是试图减少数据量，但分析却是变出更多的资料来。一个例子是选举结果的预测 — 一个仔细想想并没有意义，但无论候选人、选举人还是媒体都乐此不疲的游戏。美国在 2004 年时，候选人 Howard Dean 收集了 100GB 的资料来分析，当时被认为是一个很恐怖的大数据库。今年的总统选举，Catalist 公司收集了一个 15TB 的超大数据库，详细分析每个人的性别、婚姻、年龄、种族、收入等各种资料，并且从中获得判断一个人会投给共和党还是民主党的重要信息。依照同样的比例增加 下去，下一次美国总统选举时的资料量和分析结果肯定会达到数 PB 之谱，届时对数据探勘、分析所需的运算资源的要求会非常可怕，或许非要用 Cloud Computing 的方式才能运算的地步。嘿嘿，或许到时候预测系统都比你自已清楚你会投给谁…

第三个挑战，是数据的呈现。 这是一个比较抽象的关念，举个例子来说好了，目前的数码相机分辨率都高达 10mp 或更多，但一般人用的屏幕就算是最常见的高档屏幕分辨率（1920×1200）事实上才 2.3mp 而已。那多的那些资料不就可惜了？Wikipedia 现在就有点这种感觉，很多很好的文章和内容因为不容易取得，很难发挥它应有的真正价值。

第四个挑战，是数据的传输。 之前在网络上看过一个很有趣的问题：将 1PB 的资料从美国西岸送到中国，是用传输的快，还是用帆船把整个服务器运过去快？一点简单的数学告诉我们，要在合理的时间范围内把数据传完…就假设三个月 好了。要在三个月内把 1PB 的数据传完，传输送率要大约 1Gb/s 才行。这个数字不是特别的不可能（学术单位间常常有这么大量数据来往），但绝对不是一般民众能负担得起的。以目前的技术来说，如果你要传 1PB 的超高画质*哔*片给在美国的朋友的话，绝对是用海运的比较快…

最后，第五个挑战，是数据的搜寻。 拜 Google 大神所赐，这或许是我们最不须要要担心的一环了。但 Google 的强大也仅限于公开的网络而已，自已电脑上的档案要能分类清楚依然是很困难的一件事。Windows Vista 本来想要加入的 WinFS 档案系统和随之而来的关连式档案架构似乎带来了一线曙光，但最后我们还是被卡在树状结构的 NTFS 里。当个人电脑数据量也到 1PB 的时候，嗯，真难想象到时候会是个怎么样的恶梦。

个人电脑容量跨越 1GB 门坎是多久以前？好像差不多是十年前左右，所以如果发展方向不变的话，再十年我们就会进入全面 PB 的时代。但在那之前，就们就已经有够多要担心的事了：在上面的五个问题当中，小姜最担心的是数据的传输，因为传输频宽的建立要时间和金钱的投入。要能够顺 利地提升到下一个阶段，现在就要开始做准备啰！

信息技术或者说计算机技术在发展过程当中遇到了若干个瓶颈，我之前在《SMP in Linux》一文中提到过这些瓶颈以及解决方法。现在看起来，CPU多核和众核已经成了趋势，在Intel的驱动下普及应该不会有太大问题，硬盘也开始以难以置信的速度迅速扩张，希捷一年出货硬盘1.83亿块， 每秒钟近6块。看起来，网络速度已经成最近相当一段时间内的最大瓶颈。正如小姜提到的，1PB的资料从美国西岸送到中国，是用传输的快，还是用帆船把整个服务器运过去快？这个问题现实中我真的是天天面对着。
我的DreamHost硬盘很大很大，2TB大，而传输速度实在不敢恭维，在中国，我需要先把数据传到一个骨干网服务器上，然后挂着传到美国的服务器。即便这样，一个月我也只传了几十GB数据而已。
纵然技术迅速发展，无良的ISP依然收着难以置信的价格，甚至奥运村也不放过。与美国日本韩国相比，我们的宽带速度甚至连人家小灵通上网速度都不如。
我有一个梦想，睡在凉爽的骨干机房里，享用着100MB直接连接到骨干网的网速，该有多爽~

第十名：巴贝奇分析机

[singlepic=15178]

查尔斯·巴贝奇(Charles Babbage, 1792-1871)生前为英国皇家学会会员、剑桥大学数学教授。他最早提出人类制造出通用计算机理念，用以代替大脑计算复杂的数学问题。由于还没有没有电子技术应用，巴贝奇设想就架构在当时日趋成熟的机械技术上面。巴贝奇将他设想的通用计算机命名为“分析机”，希望它能自动解算有100个变量的复杂算题，速度达到每秒钟运算一次。

巴贝奇天才般地提出了类似于现代电脑五大部件的逻辑结构，也为后世通用处理器诞生奠定了坚实的基础。英国政府曾资助巴贝奇的研究工作，但后来停止对他的援助。1822年,巴贝奇终于研制出了一台可工作的模型机。近年来，科学界已经普遍确认巴贝奇在信息科学领域的鼻祖地位。1991年，英国肯圣顿(Kensington)科学博物馆根据巴贝奇当年留下来的图纸重新建造了一台差分机。图为后人完成的巴贝奇分析机。

第九名：ENIAC

[singlepic=15189]

1946年2月14日，世界上第一台真正意义上的电子计算机ENIAC在美国宾夕法尼亚大学诞生。该机器使用了18800个真空管，长50英尺，宽30英尺，占地1500平方英尺，重量达30吨。ENIAC真空管的损耗率相当高，几乎每15分钟就可能烧掉一支真空管。不仅如此，ENIAC也是位耗电大户。据说ENIAC每次一开机，整个费城西区的电灯亮度都会随之降低。

第八名：IBM System/360

[singlepic=15181]

1964年4月7日，IBM推出了划时代的System/360大型电脑，它是世界上首台指令集可兼容计算机。在此之前，计算机厂商要针对每种主机量身定做操作系统；而System/360的问世，则让单一操作系统可适用于整系列的计算机。 IBM System/360同时还和多项世界第一联系在了一起，如协助美国太空总署建立阿波罗11号资料库、完成太空人登陆月球计划、建立银行跨行交易系统以及航空业界最大的在线票务系统等重大事件。

第七名：Datapoint 2200

[singlepic=15182]

Datapoint 2200是1970年全球首批投放市场的终端用户电脑之一。该产品制造商为Computer Terminal Corp.(CTC),但该公司如今已不复存在。但Datapoint 2200的很多基本理念仍保留在我们今天所使用的个人电脑当中。如CTC曾向当时尚为创业公司的英特尔提出建议：尽量采用单一芯片，以减少机器的发热量。凭借此建议，英特尔一步步登上了PC处理器领域霸主的地位。

第六名：施乐(Xerox)PARC Alto

[singlepic=15183]

1973年4月，施乐帕罗奥多研究中心(Xerox PARC)推出了Alto，它是首台把计算机所有元素结合到一起的图形界面操作系统。Alto使用3键鼠标、位运算显示器、图形窗口和以太网络连接。 Alto能与另一台Alto计算机和激光打印机连成网络，这又是施乐PARC的一项重大发明。如今回头一看，正是这些技术组合在一起构成了信息革命的基础。

第五名：TRS-80

[singlepic=15184]

TRS-80于1977年推出，制造商为Tandy公司。该产品推出后，首先被放在 Radio Shack连锁店中出售。Radio Shack当时认为，如果首批进货销路不好，公司就留下来当作收银机使用。但由于该机器并不是针对计算机迷，TRS-80销量远远超出了预期。而TRS- 80销量大增后，又衍生出全球首轮第三方个人软件市场。

第四名：Apple II

[singlepic=15185]

Apple II于1977年推出，它是继Apple I的市场逐渐低迷之后的后续产品。Apple II吸取了Apple I存在的诸多不足，并由苹果联合创始人史蒂夫-沃兹尼亚克(Steve Wozniak)对其进行了重新设计。。Apple II更多体现出其游戏型电脑而非家用电脑的特点。Apple II表达了苹果这样一种理念：无论是新入门的电脑用户还是熟练的技术人员，也无论是电脑黑客还是商务用户，当他们在使用苹果电脑时，都能够获得轻松如意的感觉。

第三名：IBM PC

[singlepic=15186]

IBM PC机于1981年推出。该产品处理器是Intel 8088，运行速度为4.77MHz，其主板上配有64KB内存，并可扩展至640KB。由于它采用开放式结构，1982就出现了兼容机。IBM PC的重大历史意义在于：确定了硬件和软件的业界标准，从而使PC产业出现了“井喷”式的规模化增长。如今全球范围内大规模PC产业的形成，其源头就来自于IBM PC机。

第二名：苹果麦金托什机(Macintosh)

[singlepic=15187]

1984年1月24日，苹果发布了全新Macintosh(通常简称为Mac)个人电脑，它是全球首台采用图形用户界面的个人电脑，与当时采用DOS命令行、纯文本用户界面的IBM PC形成了鲜明对比。正是Macintosh的出现，引发了一场计算机世界的革命。Macintosh推出后，微软立即投入巨资研究开发Windows系统。1995年微软发布Windows 95后，普通PC用户已能享受到与Macintosh相当的图形用户界面。

目前广大普通计算机用户所熟悉的窗口、鼠标、桌面、点击、下拉菜单，甚至连桌面上的“垃圾桶”，其实都可以追溯到1984年的苹果Macintosh机。

第一名：IBM走鹃(Roadrunner)

[singlepic=15188]

走鹃超级计算机前不久刚刚组装成功，其造价高达1.33亿美元，它由IBM和洛斯阿拉莫斯 (Los Alamos)国家实验室技术人员共同开发和组装。走鹃提供给美国军方使用，其运算速度达到了1.026 petaflop，即每秒钟可进行1026万亿次浮点运算，为目前全球运行速度最快的超级计算机。走鹃投入使用后，将主要用于运算分析美国军方的机密军事数据，如核武器及其他军事战略数据等，并模仿核战争爆发后对人类生存环境的破坏情况，然后据此得出相应分析结论。

1. 矩阵乘法最优算法
1.1 矩阵与计算机科学
数学的重要性显而易见。数学是各种科学的基础，计算机也不例外。对于计算机学科起着关键性作用的数学分支主要是离散数学，因为计算机处理的数据还是二进制的离散量，对于连续量的处理还处在模拟的阶段。
此外，计算机科学中大量分支涉比如系统结构和计算机网络等等，都需要一定的逻辑学和图论作为其研究的支撑。作为离散数学的核心，矩阵的重要性不言而喻。众多的复杂计算机模型都可以用简单的矩阵来表示，而矩阵的运算也经常代表着重要的计算机物理含义。本文研究的搜索引擎排名评价体系就是其中之一。

1.2 矩阵乘法的理论下界
设A是一个m行n列矩阵

[singlepic=14397,,center]

B是另一个n行q列矩阵

[singlepic=14400,,center]

矩阵A和B的乘积是一个m行q列矩阵

[singlepic=14401,,center]

其中

[singlepic=14402,,center]

从定义出发计算矩阵的乘积，需要n次乘法运算和n-1次加减运算，得到的是计算矩阵乘法的计算复杂度的上界。当m、n和q被认为是同阶的数的时候，算法复杂度是O(n^3)。
两个矩阵相乘的任何可能的算法，运算次数至少不低于矩阵与向量相乘（当q=1时退化的情况）。此时，需要mn次乘法运算和m(m-1)次加减运算，当m和n同阶时，算法复杂度是O(n^2)。
由此可以得出结论，正确的矩阵相乘算法，其复杂度介于O(n^3)与O(n^2)。

1.3 几个典型的矩阵乘法算法
1.3.1 Winograd矩阵乘法算法
S. Winograd于1967年提出了一个矩阵乘法算法，其核心思想是修改向量内积计算方法，对重复计算部分进行预处理，然后将计算结果多次使用，从而达到简化计算的目的。
Winograd矩阵乘法算法实质是增加约50%的加减法代价以换取减少约50%乘法运算，但是其算法复杂度仍然是O(n^3)，并没有降低算法复杂性的阶。
1.3.2 Strassen矩阵乘法算法
Strassen算法是另外一个矩阵乘法算法，这个算法突破了O(n^3)的计算复杂度阶，由V. Strassen在1969年提出。
Strassen算法主要用于方阵的计算。Strassen观察了简单2阶方阵乘法的计算特点，使用7次乘法计算就能算出结果，而不是平常的8次，从而降低了整个算法计算复杂度阶。
Strassen算法的计算复杂度是O(n^(log2 7) )=O(n^2.31 )。

1.4 一个最优矩阵乘法算法
1989年，我的研究生导师蒋昌俊教授提出了一个新的矩阵乘法算法，称为凝聚算法。凝聚算法把矩阵相乘的计算复杂度降到了理论下界O(n^2)。
凝聚算法从非负整数矩阵出发，即当A和B的元素都是非负整数时，可以通过设置足够大的x和y，分别通过求x的m-1次多项式和y的q-1次多项式的值，把矩阵A的各列的元素和矩阵B的各行的元素凝聚在一起，分别得到n维向量[a1,a2,…,an]和[b1,b2,…,bn]，其中ak和bk分别是矩阵A的第k列元素和矩阵B的第k行元素的“凝聚”结果。通过向量的内积运算，又可以将上述两个向量的各个分量进一步凝聚成一个整数c。最后，以y为除数作q-1次整数求余运算，就把整数c散列成q个整数c1,c2,…,cq，再把ck对x作m-1次整除求余运算，又将ck散列成m个数，就得到了积矩阵C的第k列元素c1k,c2k,…,cmk。算法的关键之处在于设置x和y为足够大的整数，以便使整除求余的散列能够正确地反映前面通过多项式求值和向量内积运算的凝聚效果。

第一步：对x和y的取值是算法的关键，如果x和y的取值不合理，将得不到正确的反散列。

[singlepic=14403,,center]

第二步：对从1到n的k，用Horner方法计算：

[singlepic=14404,,center]

第三步：c=a1b1+a2b2+⋯+anbn

第四步：作除法，依次求商d1,d2,…,d(q-2)，rq和余数r1,r2,…,r(q-1)，使得：

[singlepic=14405,,center]

第五步：
对从1到q的j作除法，依次求商kj1,kj2,…,k(j(m-2))，rjm和余数rj1,rj2,…,r(j(m-1))，使得

[singlepic=14406,,center]

for i=1 to m do
for j=1 to q do
cij=r(j(m-i1+))
repeat
repeat

整个计算过程中各种操作的数量是

• 比较：mn+nq-2
• 乘法：mn+mq+nq
• 除法：mq-1
• 加减：mn+mq+nq-n

当m、n和q被认为同阶时，凝聚算法计算过程中有2n^2-2次比较运算，3n^2次乘法运算，n^2-1次除法运算和3n^2-n次加减运算，计算复杂度为O(n^2)。

2. 矩阵乘法最优算法在搜索引擎排名中的应用
2.1 一种互联网结构建模
万维网（World Wide Web，WWW）是指在因特网上以超文本为基础形成的信息网。万维网为用户提供了一个可以浏览的图形化界面，用户通过它可以查阅Internet上的信息资源。WWW是通过互联网获取信息的一种应用，我们所浏览的网站就是WWW的具体表现形式，但其本身并不就是互联网，万维网只是互联网的组成部分之一。互联网常用的服务包括：WWW、Email、FTP、Usenet、IM等。
在“谁发明了浏览器” 文中介绍了蒂姆-伯纳斯－李（Tim Berners-Lee）于1990年发明了首个网页浏览器－－World Wide Web。在1991年蒂姆-伯纳斯-李建立世界上第一个网站，它于1991年8月6日上网，它解释了万维网是什么，如何使用网页浏览器和如何建立一个网页服务器等等。综合各种资料，1991年8月6日被认为是是万维网诞生的日子。
WWW的基础是超文本和链接，链接也使得一个一个网站被相互链接起来，成为了全球规模的巨大网络。链接分为两种，一种称为内部链接，指从一个网站某个网页，链接到同一网站的另一个网页的链接；另一种称为外部链接，指从一个网站某个网页，链接到另一个网站的某个网页的链接。实际当中考虑的链接是外部链接，因为外部链接反映了整个互联网的拓扑关系。
搜索引擎是一种互联网应用，搜索引擎是自动从Internet搜集信息，经过一定整理以后，提供给用户进行查询的系统。英特网上的信息浩瀚万千，而且毫无秩序，所有的信息像汪洋上的一个个小岛，链接是这些小岛之间纵横交错的桥梁，而搜索引擎，则为你绘制一幅一目了然的信息地图，供你随时查阅。
对于搜索引擎来说，网站及其链接关系可以用图来描述。

[singlepic=14407,,center]

图1 八个网站相互链接的例子

通过邻接矩阵A可以描述整个网络的拓扑结构。邻接矩阵A定义为

[singlepic=14398,,center]

我们认为，一个网站本身是存在指向本身的链接的，因此aii=1。
图1中的示例的邻接矩阵为

[singlepic=14399,,center]

2.2 互联网站价值评价标准
用户通过搜索引擎找到他们所需要的网站和页面，而搜索引擎也被用户寄予厚望，希望能够在排在最前面的搜索结果中得到他们觉得最有价值的目标页面。
互联网络是一个开放的系统，如何去衡量信息的可靠性呢？当然，CNN或者人民日报谈论一个问题，和一个普通博客谈论一个问题，当然是不一样的。即，信息是有权值的。
为每一个网站人工去赋一个权值明显是不现实的。互联网站数目超过了1亿个，而且每个网站不停地在更新，一个固定的权值也是不合适的。
Google设计了PageRank算法。PageRank是一个动态的评价体系，能够动态地对网站和网页提供的信息的重要程度进行评估，并据此作为一项标准，排序用户搜索结果。
一般人们认为，可靠的信息来自于新闻网站、大公司和百科全书。这些网站被人工选出，赋予最高的PageRank权值。然后根据这些网站的外部链接，将自己的PageRank递减地传递下去，被这些网站链接的网站获得了第二级的PageRank，如此传递下去，就可以链接到每一个网站（除了那些没有意义的信息孤岛网站）。
如果我们得到了整个互联网的邻接矩阵A，那么我们可以通过计算A^k，得到经过k次链接后，哪些网站得到了传递过来的PageRank。

2.3 矩阵乘法最优算法在搜索引擎排名中的应用
互联网邻接矩阵是一个超级规模的矩阵，超过1亿维。在这里，我们探讨一下做一次相乘，凝聚算法能够带来的性能提升。
假设：互联网站数目n=1×10^8个，超级计算机（例如2008年6月9日IBM公司的“走鹃”）每秒进行运算1×10^15次。

• Winograd算法(1967)：2n^3+3n^2-4n+1，2×10^9秒=63.4年
• Strassen算法(1969)：6n^2.31-6n^2，18059秒=5小时
• 凝聚算法(1989)：9n^2-n-3，90秒

由此可见，如果能够将凝聚算法应用在搜索引擎领域，会带来巨大的性能提升。

3. 参考资料
[1]. 矩阵乘法的一个最佳算法. 蒋昌俊, 吴哲辉, 1989, 科学通报第4期, 251-254
[2]. “矩阵乘法的一个最佳算法”一文的进一步研究. 蒋昌俊, 吴哲辉, 1994, Vol. 11, No. 2, 149-153

查看本文PDF版本：凝聚算法在搜索引擎应用设想

分治技术的基本思想与特点
分治技术的基本思想是将一个规模为n的问题分解为k个规模较小的子问题，这些子问题互相独立且与原问题相同。递归地解这些子问题，然后将各子问题的解合并得到原问题的解。
分治法所能解决的问题一般具有以下几个特征：

• 该问题的规模缩小到一定的程度就可以容易地解决；
• 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质；
• 利用该问题分解出的子问题的解可以合并为该问题的解；
• 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。

分支-限界技术的基本思想
分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。
问题的解空间树是表示问题解空间的一棵有序树，常见的有子集树和排列树。在搜索问题的解空间树时，分支限界法与回溯法对当前扩展结点所使用的扩展方式不同。
在分支限界法中，每一个活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，那些导致不可行解或导致非最优解的儿子结点被舍弃，其余儿子结点被子加入活结点表中。此后，从活结点表中取下一结点成为当前扩展结点，并重复上述结点扩展过程。这个过程一直持续到找到所求的解或活结点表为空时为止。

贪心技术的基本思想与特点
贪心技术的基本思想是从问题的某一个初始解出发逐步逼近给定的目标，以尽可能快的地求得更好的解。当达到某算法中的某一步不能再继续前进时，算法停止。
该技术的特点是：

1. 不能保证求得的最后解是最佳的；
2. 不能用来求最大或最小解问题；
3. 只能求满足某些约束条件的可行解的范围。

在一般（非0/1）背包问题中，选择什么样的度量标准包，才能使该问题获得最优解？并以该度量为标准，给出背包问题的贪心算法。
在一般背包中，度量物品放入优先顺序的标准是该物品的单位重量的价值度。其用贪心算法描述为：

1. 将物品按其单位重量的价值由高至低排序。
2. 选择单位重量价值最高的物品放入背包中，直至背包满或该类物品已全部放入。
3. 若背包未满，重复2的过程。

利用回溯技术，给出n-皇后问题的解法，并画出4-皇后问题的深度优先搜索树
启发式搜索9宫问题
写出矩阵相乘的凝聚算法，并分析其各种基本运算的次数与算法的复杂性
设n=3，(W1,W2,W3)=(3,4,5)，(P1,P2,P3)=(2,4,8)，M=9，用动态规划法求解0/1背包问题
设f(i, j)表示背包容量为j，可选择放入的物品为i、i+1、……时背包可入物品价值的最优解，则f(1,9)为所求问题的解，并且
1) f(i,j)=max{f(i+1,j),f(i+1,j-wi)+vi}, 当j>=Wi
2) f(i,j)=f(i+1,j), 当j
f(3,0)=f(3,1)=…=f(3,4)=0，f(3,5)=f(3,6)=…=f(3,9)=8
当y<4时，f(2,y)=f(3,y)=0。
当y=4时，f(2,y)=max{f(3,4),f(3,4-4)+4}=4。
当4
当y=9时，f(2,y)=max{f(3,9),f(3,9-4)+4}=max{8,8+4}=12。
所以f(1,9)=max{f(2,9),f(2,9-3)+2}=max{12,8+2}=12，此时选择的物品是2和3。

另一届题目

1. 写出求解汉诺塔问题的递归过程，并用树结构画出n=3时的递归调用过程，说明汉诺塔问题的算法时间复杂度。
2. 有集合s=｛2,5,6,8,7,3,4,1}用分治技术求s中的最大元素和最小元素。设|s|=n,T(n)表示求出s中最大和最小元素需要进行比较的次数，写出T的解析表达式，并证明T(n)=(3/2)*n-2。
3. 利用凝聚技术写出的矩阵乘法算法，并分析算法的时间开销，证明算法的正确性。

凝聚算法两篇原始论文：

• 矩阵乘法的一个最佳算法
• “矩阵乘法的一个最佳算法”一文的进一步研究

我做的事情，基本上算是从根本架起了一个Microsoft…操作系统，域，数据库，服务器…

就目前的状态看，我还是挺适合做一个网管和系统管理员的。我比较冷静，耐得住寂寞，诚实，可靠，关键是比较勤快。这一点只要看过我管理的机房的人都应该会有深刻的理解。
很多事情，看起来规模宏大，步骤复杂，我能够一连几天做那些枯燥无比的事情却不觉得一点点寂寞。遇到这些事情的时候，只要开始想一些事情，不知不觉沧海桑田。
其实我是个很怕很怕寂寞的人啊！
命中注定一些事情就会发生吧。

在我的笔记本上，一共有3GB内存，我开出1GB作为Ramdisk，并且把页面文件、系统和浏览器临时文件都映射到该Ramdisk上。效果明显，系统运行速度有了可以感觉到的进步。

假设我的Ramdisk是E:\，下面讲讲设置方法：

• 系统临时文件：我的电脑-属性-高级-环境变量-TEMP和TMP都设置成E:\Temp
• 页面文件：我的电脑-属性-高级-性能-设置-虚拟内存-更改-选中原来的C盘，点下面的无分页文件，然后选中E盘，选中自定义大小，然后分配一定大小的页面文件，这个值不用太大，也不要太小，建议1GB左右，不过我只开了1GB的Ramdisk，所以这里写的512MB-768MB。
• FireFox页面Cache：Firefox地址栏输入about:config，回车打开。在下面列表中右键新建字符串，名为：browser.cache.disk.parent_directory，值为：E:\Browser Cache
• IE临时文件：工具-Internet选项-设置-移动文件夹，设置成E:\Browser Cache

RamDisk下载

2. C++
C++是不能绕开的一门语言. C++是一种思想, 不学C++不知道Java或者C#的好. 苦其心志是必要的, 虽然我对于C++依然反感的很… 太复杂太混乱太危险了. 不过, 我同样认为, 对于计算机系学生来说, 经过自己的体验知道C++为什么太复杂太混乱太危险是很有必要的. 此外, C++应该是你从TC转向Visual Studio 2005的跳板. C++是一门系统编程语言, 不适合用来写应用程序.

3. HTML/XML/CSS
必须精通的技术. 迟早一天, 所有程序都被XML化. 目前的趋势是WPF已经把应用程序界面表示XML化, DBMS也以支持XML作为重要的大版本特性. 何况, 计算机专业要想挣钱, 网站是必须要做的… 之于CSS, 初学者就不要经历我们走过的那些阴沟了吧. 听W3C的没错. 说起来我做网页也有10个年头了, 初中就开始写HTML, 完全是看HTML标准成长起来的一代人, 那时候还幼稚的很, 当发现可以用表格组织网页框架结构的时候, 欣喜若狂, 自认是个天才, 四处找人想分享经验, 才发现高处不胜寒. 如今, Div+CSS已经变成了我标准的工作语言, FrontPage和Dreamweaver则是早就早就不用了的古董了. UltraEdit是我的最爱.

4. JavaScript/AJAX
如果想走网站这条路, 精通JavaScript是必要的. JavaScript是一门类C语言, 学起来比较轻松, 而且因为JavaScript出了名的难以调试, 可以锻炼程序调试技术. JavaScript技术路线走下去就是大红大紫的Ajax了. 其实没什么, JavaScript和DOM戏法而已.

5. 对Visual Basic的态度
我不建议学习Visual Basic. 将VB纳入.NET框架实际上是一个失误. 从那一刻起, VB就已经死去. 计算机系的态度是, 各科课程设计不能使用VB编写.

6. ASP或PHP
网站路线必经之路. 因为ASP是类VB的, 所以我觉得不太值得为了ASP学VB. 因此, 类C的PHP更有价值, 而且PHP这么多年还活得好好的. 有必要把PHP作为轻量级的后台编程语言.

7. Database
MySQL和SQL Server以及Oracle最好都学习一下. 重点是前两个. Oracle实在是用不起. 占用资源太大, 不适合在自己机器上做试验. MySQL是PHP支持最好的数据库, 走网站路线的建议选择.

8. WWW和Hosting
网站路线的人不可避免的要接触域名系统和托管之类的事情. 这其实是一门学问, 书上很少讲, 却是很大很深的学问. 主要包括, 域名系统, 域名怎么解析, A记录, CNAME, MX记录是怎么回事; DNS怎么工作; 什么是虚拟主机等等. 注册一个属于自己的域名, 会对你将来找工作有很大的作用的. 用网站技术建立自己的个人主页, 然后才能搞明白Google好在哪里(Apps), 什么是SEO(又是一门大学问).

9. Java和C#
Java是一头大象了. Servlet, Swing, JSF, JSP… 名称太多太多了点… 还是C#干净点… 选择那条路, 与其说是技术问题, 不如说是政治问题, 我觉得C#好一点, 必经Sun终归要被并购掉… 微软语言的成败, 不是有语言特性决定, 而是微软平台的成败决定. 因此, C#也有风险. Java路线的话, 后面有网站后台的Servlet和JSP, C#路线则是ASP.NET. 不学PHP也无所谓. 就是主机贵一些.

10. 操作系统
这也是一个政治问题… Windows 2003/2008是肯定要会玩的, 必经和XP/Vista那么近似, 如何在机器上架设Web服务器, 安装动态语言, 架设DBMS是基本功. 因此, 需要精通IIS/Apache/Tomcat. Linux肯定要学. 哪个发行版本我不在乎, 基本Shell命令要烂熟于心.

11. 计算机硬件
有了这些, 可以出去打工赚点小钱, 出去打工, 为自己配一台好电脑吧. 搞清楚CPU阵营, 显卡阵营, 主板阵营, 硬盘品种, 怎么超频. 组成原理, 系统结构, 汇编语言是要好好学的. 为了你将来的水平成长.

12. 设计模式
编程到这里, 基本已经饱受不恰当的系统设计折磨之苦了. 看看设计模式, 看看代码大全, 让自己变成一个爱干净的人, 代码里没有意义的空行甚至空格也不要有. 注释, 用英文写起来啦. 这是, 你就是别人眼里的高手了.

13. 算法
为了生存, 为了面试, 算法是必须精通的一步. 算法导论是一个不错的选择, 别问我英文版好还是中文版好, 都买下来, 随着MIT视频教程, 仔仔细细拿出一年时间来, 学好算法.

差不多了. 毕业吧.

工程技术中的大多数问题, 如果你能够把问题描述清楚, 问题基本也就解决了. 只要拿描述去问Google就行. 此其二.

PlaceHolder的艺术

软件系统设计是一门艺术, 设计师要在项目实现之前把项目想清楚, 模块化. 这个过程可以借助很多工具, 我觉得最好的工具其实就是Windows Explorer, 项目目录建好了, 模块也基本出来了. 实现部分, 无非是麻烦而已. 因此, 软件系统设计其实就是PlaceHolder的艺术.

没错, 我就是忠实的Fixedsys爱好者~

初识Fixedsys, 绝对是一年级的时候使用VC++ 6.0的遗念. 那个时候还不懂什么TrueType, 像素, 等宽字体之类的事情, 只是觉得VC++ 6.0编辑窗口的字体看起来比较爽, 看多了爽多了就离不开了, 转到Visual Studio 2003的时候真的叫一个不适应啊, 宋体怎么显示代码… 后来发现VS可以设置字体… T_T

于是乎, 所有的编译器, 都被我设置成了Fixedsys, 目前在用的几种都是这样, Visual Studio 2008, Eclipse, UltraEdit和NetBeans一样不能少…

看看桀骜不驯的Eclipse变成了什么样子~

可惜, 到了Linux上就没有了… 不过, 今天发现一个好东西, TrueType的Fixedsys, 这个东东可以在Linux上用, 同样可以在只支持TrueType的Java程序上(如NetBeans)用.

这里是下载链接 fixedsys500c.zip

达到最佳效果的字体大小设置:
You´ll often find that font size 11 gives the best results
When using Java try font size 15 (Windows) or 14 (Linux?).

http://fixedsys.moviecorner.de/index.php?p=download&l=1

• 1. 服务器/数据库 管理员
  我喜欢把自己能够控制的区域整理得干干净净. 多年以来, 我自己的机器从来不会有哪个文件夹放在错误的地方, 每个硬盘分区都有它专门的用处, 根目录不超过10个文件夹, 更不会有文件在根文件夹… 在同济网几年来维护服务器, 这些癖好成就了一个干干净净的服务器. 数据文件结构井井有条, 性能稳定.
• 2. Technology Lead of UI
  这个职位是我的学长, 现在微软亚洲研究院的JTH的工作, 由Min Wang总结的一个叫法, 真的, 跟像Xiangwei, Xiao Yang, Yiwen, Jun Wang, Chiqing这样的专业UI一起工作是件非常爽, 非常舒服, 非常高效的事情.
• 3. 系统设计师
  跟MSRA的PM Peng Xu学习的结果就是对系统设计的另一番认识. 写程序写多了, 对于系统设计的认识就有更加深刻的理解. 现在写程序比原来效率高多了, 究其原因, 是出色的系统设计使然, 计算机是一门综合的科学, 在我心目中, 设计模式这门学问的位置达到了空前的高度.
• 4. 程序员
  当一个普通程序员也不错的. 我办事比较快, 一般充当救火队员的角色, 在MSRA的工作总结下来每天的编码量最少300, 最多达到1000+. 更加欣慰的是听到我的Mentor Haidong说, 我做事情很快, 编码质量也不错.

同济大学学生会是个很差的组织, 但是却有一个impressive的Logo和一句很有深度的Slogan, 我觉得用在这里很合适.

自觉觉人

现在的学生, 最缺少的就是自觉. 最多余的就是一颗FQ心. 哎呀, 扯多了. Coding去.

High School/Junior High 10 PRINT “HELLO WORLD”
20 END
First year in College program Hello(input, output)
begin
writeln(‘Hello World’)
end.
Senior year in College (defun hello
(print
(cons ‘Hello (list ‘World))))
New professional #include
void main(void)
{
char *message[] = {“Hello “, “World”};
int i;for(i = 0; i < 2; ++i)
printf(“%s”, message[i]);
printf(“\n”);
}
Seasoned professional #include
#include

class string
{
private:
int size;
char *ptr;

public:
string() : size(0), ptr(new char(‘\0′)) {}

string(const string &s) : size(s.size)
{
ptr = new char[size + 1];
strcpy(ptr, s.ptr);
}

~string()
{
delete [] ptr;
}

friend ostream &operator <<(ostream &, const string &);
string &operator=(const char *);
};

ostream &operator<<(ostream &stream, const string &s)
{
return(stream << s.ptr);
}

string &string::operator=(const char *chrs)
{
if (this != &chrs)
{
delete [] ptr;
size = strlen(chrs);
ptr = new char[size + 1];
strcpy(ptr, chrs);
}
return(*this);
}

int main()
{
string str;

str = “Hello World”;
cout << str << endl;

return(0);
}
Master Programmer [
uuid(2573F8F4-CFEE-101A-9A9F-00AA00342820)
]
library LHello
{
// bring in the master library
importlib(“actimp.tlb”);
importlib(“actexp.tlb”);

// bring in my interfaces
#include “pshlo.idl”

[
uuid(2573F8F5-CFEE-101A-9A9F-00AA00342820)
]
cotype THello
{
interface IHello;
interface IPersistFile;
};
};

[
exe,
uuid(2573F890-CFEE-101A-9A9F-00AA00342820)
]
module CHelloLib
{

// some code related header files
importheader();
importheader();
importheader();
importheader(“pshlo.h”);
importheader(“shlo.hxx”);
importheader(“mycls.hxx”);

// needed typelibs
importlib(“actimp.tlb”);
importlib(“actexp.tlb”);
importlib(“thlo.tlb”);

[
uuid(2573F891-CFEE-101A-9A9F-00AA00342820),
aggregatable
]
coclass CHello
{
cotype THello;
};
};

#include “ipfix.hxx”

extern HANDLE hEvent;

class CHello : public CHelloBase
{
public:
IPFIX(CLSID_CHello);

CHello(IUnknown *pUnk);
~CHello();

HRESULT __stdcall PrintSz(LPWSTR pwszString);

private:
static int cObjRef;
};

#include
#include
#include
#include
#include “thlo.h”
#include “pshlo.h”
#include “shlo.hxx”
#include “mycls.hxx”

int CHello::cObjRef = 0;

CHello::CHello(IUnknown *pUnk) : CHelloBase(pUnk)
{
cObjRef++;
return;
}

HRESULT __stdcall CHello::PrintSz(LPWSTR pwszString)
{
printf(“%ws\n”, pwszString);
return(ResultFromScode(S_OK));
}

CHello::~CHello(void)
{

// when the object count goes to zero, stop the server
cObjRef–;
if( cObjRef == 0 )
PulseEvent(hEvent);

return;
}

#include
#include
#include “pshlo.h”
#include “shlo.hxx”
#include “mycls.hxx”

HANDLE hEvent;

int _cdecl main(
int argc,
char * argv[]
) {
ULONG ulRef;
DWORD dwRegistration;
CHelloCF *pCF = new CHelloCF();

hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

// Initialize the OLE libraries
CoInitializeEx(NULL, COINIT_MULTITHREADED);

CoRegisterClassObject(CLSID_CHello, pCF, CLSCTX_LOCAL_SERVER,
REGCLS_MULTIPLEUSE, &dwRegistration);

// wait on an event to stop
WaitForSingleObject(hEvent, INFINITE);

// revoke and release the class object
CoRevokeClassObject(dwRegistration);
ulRef = pCF->Release();

// Tell OLE we are going away.
CoUninitialize();

return(0); }

extern CLSID CLSID_CHello;
extern UUID LIBID_CHelloLib;

CLSID CLSID_CHello = { /* 2573F891-CFEE-101A-9A9F-00AA00342820 */
0x2573F891,
0xCFEE,
0x101A,
{ 0x9A, 0x9F, 0×00, 0xAA, 0×00, 0×34, 0×28, 0×20 }
};

UUID LIBID_CHelloLib = { /* 2573F890-CFEE-101A-9A9F-00AA00342820 */
0x2573F890,
0xCFEE,
0x101A,
{ 0x9A, 0x9F, 0×00, 0xAA, 0×00, 0×34, 0×28, 0×20 }
};

#include
#include
#include
#include
#include
#include “pshlo.h”
#include “shlo.hxx”
#include “clsid.h”

int _cdecl main(
int argc,
char * argv[]
) {
HRESULT hRslt;
IHello *pHello;
ULONG ulCnt;
IMoniker * pmk;
WCHAR wcsT[_MAX_PATH];
WCHAR wcsPath[2 * _MAX_PATH];

// get object path
wcsPath[0] = ‘\0′;
wcsT[0] = ‘\0′;
if( argc > 1) {
mbstowcs(wcsPath, argv[1], strlen(argv[1]) + 1);
wcsupr(wcsPath);
}
else {
fprintf(stderr, “Object path must be specified\n”);
return(1);
}

// get print string
if(argc > 2)
mbstowcs(wcsT, argv[2], strlen(argv[2]) + 1);
else
wcscpy(wcsT, L”Hello World”);

printf(“Linking to object %ws\n”, wcsPath);
printf(“Text String %ws\n”, wcsT);

// Initialize the OLE libraries
hRslt = CoInitializeEx(NULL, COINIT_MULTITHREADED);

if(SUCCEEDED(hRslt)) {

hRslt = CreateFileMoniker(wcsPath, &pmk);
if(SUCCEEDED(hRslt))
hRslt = BindMoniker(pmk, 0, IID_IHello, (void **)&pHello);

if(SUCCEEDED(hRslt)) {

// print a string out
pHello->PrintSz(wcsT);

Sleep(2000);
ulCnt = pHello->Release();
}
else
printf(“Failure to connect, status: %lx”, hRslt);

// Tell OLE we are going away.
CoUninitialize();
}

return(0);
}
Apprentice Hacker #!/usr/local/bin/perl
$msg=”Hello, world.\n”;
if ($#ARGV >= 0) {
while(defined($arg=shift(@ARGV))) {
$outfilename = $arg;
open(FILE, “>” . $outfilename) || die “Can’t write $arg: $!\n”;
print (FILE $msg);
close(FILE) || die “Can’t close $arg: $!\n”;
}
} else {
print ($msg);
}
1;
Experienced Hacker #include
#define S “Hello, World\n”
main(){exit(printf(S) == strlen(S) ? 0 : 1);}
Seasoned Hacker % cc -o a.out ~/src/misc/hw/hw.c
% a.out
Guru Hacker % cat
Hello, world.
^D
New Manager 10 PRINT “HELLO WORLD”
20 END
Middle Manager mail -s “Hello, world.” bob@b12
Bob, could you please write me a program that prints “Hello,
world.”?
I need it by tomorrow.
^D
Senior Manager % zmail jim
I need a “Hello, world.” program by this afternoon.
Chief Executive % letter
letter: Command not found.
% mail
To: ^X ^F ^C
% help mail
help: Command not found.
% damn!
!: Event unrecognized
% logout

中文原文: http://www.cnbeta.com/articles/38875.htm
英文原文: http://sunsite.nus.edu.sg/pub/humour/prog-evolve.html

回来又做了一上午性能优化和一下午BUG修正（丢失了一些数据），估计修正到明天中午，同济网服务器应该可以以一个崭新的面貌迎接下面的5年~真希望能像jth和payaqa两位前辈一样，装个机器稳定跑3年。

放个机房照片，左上角插着我的光驱的就是同济网服务器~进机房是我从小到大一直的梦想…终于实现了，原来，机房里这么冷啊…

留个纪念吧，下次见，还不知道什么时候呢。

唉，梦想啊。我没有买吃买喝的欲望，但我需要钱，买我的三台电脑…

可用于对VC++、C++ Builder、Delphi、VB、C/C++、ASM、Java等程序源码进行详细的统计，可以非常准确的分析出程序中代码行、注释行和空白行的行数。程序会自动根据你选择的文件类型选择相应的统计方式，并将所有文件的分析结果进行汇总，便于方便直观的对程序代码量进行全面的统计。本软件是绿色软件，不需要安装，展开到任意目录，直接运行即可。

下载链接:counter.zip

做的工作基本上是两个。我所在的交通事业部是做高速公路软件和信息化的，什么都做，从路灯路标控制到电气甚至土木建筑。我做的第一个是给他们开发的一个用于路上显示设备的控制软件做个硬件模拟器，通过模拟器可以不使用硬件设备进行软件测试。基于SOCKET通讯的，显示相应图形图像，模拟故障和返回。第二个是一个SQL Server的存储过程，用在广州的路上，将一年以前的数据备份到一个文件然后删除，保持数据库的整洁。写一个Windows服务使得这个备份操作能够在指定的时间自动执行，无需用户操作和干预。

“MFC”: Microsoft Fundation classes 微软基础类库
　　大家都知道，使用SDK编程方式往往有很多每次都重复的固定不变的一些代码，为了提高编程的效率，减少上千个API带给开发人员巨大的精神压力，微软开发出了这么一个类库，注意，这个类库与操作系统本身无任何关系，它只是对API进行了一个面向对象的封装，当然，还给出了一系列编程的框架。使用SDK的方法，使用Visual Studio，通过调用Windows API，MFC你也可以做得出来。MFC把一些固定不变的代码已经写好了，只在编译时候链上，所以我们的代码里看不到WinMain(),而事实上整个程序的运行，和SDK的方式无任何区别，初学者请记住这一点。另，补充一点个人感想，MFC的初衷，带给开发人员更多的便利，我觉得并不太成功。学习MFC所费的力气和最终的所得，并不太成正比。

“API”：Application Programming Interface，应用程序接口
　　这个词的出现频率很高，从某种意义上来说，也可以看作是SDK的一个子集。这也是做给程序员的程序，不过一般指用导出函数的方式提供服务的函数库，不包括类库和组件。

“GDI”：Graphic Device Interface，图形设备接口
　　这个是Win32程序下最常用的显示方式，与DirectX、OpenGL处于同一级。在DOS要显示一些东东可不是容易的事，最简单的是调用一些C的图形库函数来实现显示，不过一般也就是些画线，填色，输出几个文字，效果很弱（所以DOS程序界面一般都不怎么样，且实现起来不是一般的复杂），要复杂一点的动画/图片显示什么的，经常要用到的就是硬件中断，调用一些显卡自身的子程序(固化在显卡内的）来做。因为每一个显卡都不同，所以DOS的游戏兼容常常由于显卡的差异而很糟糕。到Windows下大家就幸福多了，Windows将硬件这一层屏蔽起来，用一个表格（Device Context）来代表一个显示，我们要做的就是在这个表格上填好相关参数，然后画上我们想画的东东，然后操作系统会依照这个表格（DC），把相应的显示内容（一般是一块显示内存）传送到指定显卡的指定的显存，再由显卡传给显示屏。我们不再需要与不同的显卡打交通，这是一个十分伟大的胜利！GDI中最常用的是双缓存技术，就是说你可以在内存中创建（也就是复制）一个DC，只不过在这个DC中显示的不再被传送到显示器上。有什么用呢？因为它的各参数是与当前屏幕DC一致的（COPY嘛 ，当然是这个结果），所以它的显示内容可以完整无失真地传送到屏幕DC上。我们通常在内存DC上画图，譬如画一圆，再画一条直线，画完后一次性地传送到屏幕DC上，这样对用户来说屏幕只刷新了一次，可以解决你画一点内容屏幕即刷新一次导致的闪烁问题。当然，双缓冲甚至多缓冲还有很多别的用处，那就要靠自己揣摩了。

“DirectX”
　　通常简称为DX（读音：低叉）这是个很吸引人眼球的名词，读起来就很上口：）。Windows为我们作了许多屏蔽底层硬件的工作，其中DX是最知名的技术之一。操作系统要与各类硬件打交道，特别是多媒体相关的，譬如显卡、声卡、手柄输入、多媒体流的网络传输等等，这些事情如果都自己来弄的话，那就太要命了（这些一般都涉及系统底层，自己也很难做出来）。而DX则正是这么一套操作系统提供的隔离多媒体硬件与程序员的间质，DX自身一般并不实现处理的能力，它是一个标准，要求硬件来满足，好比DX提供一个函数名，硬件来实现函数内容一样。通过它我们可以非常简单而快速地调用硬件提供的各类服务。它主要包括DirectDraw(通过直接访问显示硬件来提供快速的图象处理能力),DirectSound(提供了软硬件的低延迟声音混频和回放，以及直接访问音频设备的能力),DirectPlay (它明确的提供了通用环境连接能力来简化你应用程序之间的通讯服务),Direct3D(DirectDraw的3D版），DirectInput（简化你的应用程序访问鼠标、键盘和操纵杆设备的能力），DX5.0之后又增加了一些(如DirectShow)，不再详述。DX一个重要的特点就是你可以通过它直接访问硬件而无需知道硬件的具体细节。譬如DirectDraw,就能够越过内存而直接访问显存，这样的速度将比GDI快很多，不在一个数量级上。补充一点：DX是以组件的方式提供的，而不是通常的导出API的形式。DX SDK的最新版本是9.0

“COM”：component object model，组件对象模型，一般简称组件
　　这是微软为了解决代码重用的一个重要机制。重用代码的最简单办法是源代码重用，把写好的函数和类加到自己当前的代码中,编译即可。简单是简单，敝病却显然的多。另一个常用的方法是单独做成模块，以DLL的形式分发，DLL导出函数或者类，客户程序用动态/静态链接的方法将其加载，这显然比前一种源代码的方法好一些，难度也不大，最为常用。但DLL也有一些不足，最根本的，它不是二进制兼容，DLL版本升级一次就需要与客户程序代码重链接一次，有些时候这几乎是不可能的任务。为了更好地让编程像“搭积木”一样简单，让模块可以完美地配合，完美地替换，COM产生了。COM不是类库，不是代码，不是操作系统的服务，而是一套编程模型，理论上来说，它与语言无关，与操作系统无关，unix下同样可以做COM。COM是一种程序结构模型标准，你做的DLL或EXE在结构上满足这么一个标准，那这个DLL或EXE就是一个组件，它将在该平台上成为二进制兼容。COM主要利用了注册表来登记本模块的信息。客户程序调用时首先查注册表，找到所需组件的位置（这实现了位置透明），然后就用Loadlibrary把它加载进来，这和普通调用没有本质区别，区别在于由于组件特殊的实现方法使得整个过程中用户程序都不知道组件的位置，组件的类的实例化过程，如何销毁，不能直接访问组件的任何实现细节，用户只与组件的几个public接口打交道。这将实现真正的模块之间的独立。对用户程序而言，对于目标组件的认识，除了接口，一无所知。在接口不变的情况下，组件可任 意替换而客户程序不作任何改动，无需编译，仅这一点，在中大型程序的模块集成的过程中就将节约相当多的时间。

“STL”：Standard Template Library,标准模板库
　　这是最早由Alexander Stepanov和Meng Lee（蛮像中国人的名字）完成，于1994年提交给ANSI/ISO 标准C++委员会并通过而成为标准C++的一部分。望文生义即可知这是一个代码库标准，不是语法标准。简单地说，STL是以C++中的模板语法为基础建立起来的一套包含基础数据结构和算法的代码库。STL的特点是实现了“类型参数化”，即STL的代码中可处理任意自定义类型的对象，如果不使用模板技术的话，这是一件相当困难的事。也因为这个原因，在最新的java及C#语法中均加入了对模板语法的支持，可见其重要性。另外一个有关STL重要的话题是GP（Generic Programming),泛型。这是与面向对象相并列的另外的一个编程模型，它以模板为基础，弱化了实体类型的差异，简化了编程时问题抽象的模型，提供了更好的封装性和弹性，对于繁杂的面向对象编程毫无疑问是一种解脱，至少是精神上的。GP并不是用来取代面向对象的，而是作为一个有益的补充体，是面向对象很好的合作伙伴。ＧＰ是最近几年软件架构的一个研究热点，但国内真正的应用似乎并不多见，这项技术本身还基本处于研究前沿。<<Modern C++ Design>>一书对C++中的GP应用有很好的诠释，而这本书对脑细胞的杀伤力之大，也是其它C++书藉望尘莫及的。想知道C++的代码技巧可以做到怎样的出神入化吗？不妨看看这本书。

“ATL”：Active Template Library，活动模板库
　　这在VC编程下应该算是比较高级的话题了，它集COM和模板技术于一身，带来了极方便的组件编写方法和极高的学习门槛。可以说，进入ATL领域就算是进入了中级以上的编程领域。ATL是为组件而生，它的目的是为了让程序员更方便地编写组件（纯用C++写一个最简单的组件实现一个“Hello　World”对初学者来说都是要命的），同时它使用模板技术来类似于MFC一样建立了一个开发COM的框架代码库(模板库），使用该框架及模板库可以相对方便地进行组件开发。ATL中的一个特点就是你自己的类将成为ＡＴＬ代码库中某些类的父类，这是一件很有趣的事（这也是模板技术的一个特点）。

“HANDLE”: 句柄
　　这是一个中文翻译很古怪的字，对初学者来说是百思不得其解的东东。这其实等价于void*（顺便提一下，初学者往往对VC代码中各种古怪的符号、类型标记/宏等百思不得其解，其实它们大多来自基本类型的#define或者typedef,请将光标移到这些符号上（譬如HANDLE），然后按下F12，编译器自会把你带到它的声明处，反复使用几次，你终会见到它的原貌，然后长吁一口气：原来不过如此而已。没用过的初学者请牢记：F12）。很多初学者总想知道一个HANDLE代表一个什么对象，我的建议是不要去理解为某对象，而就是理解为访问某一个对象的入口，事实上HANDLE大多数时候是一个整数索引（标志该对象在操作系统的某表中的位置,就好像一个数组的下标一样），Windows系统核心中主要是几张大表，这样一个整数索引就是标记目标在这个表中的位置，供操作系统访问时查询用。偶而它的确是指向某对象的指针，有时它还携带一些额外辅助信息。总之，我们不要去直接访问它，把访问HANDLE的任务交给操作系统好了，除非你还嫌写程序不累：）。

“DLL”: Dynamic Link Library 动态链接库
　　DLL的一个特点就是可以动态加载（顾名思义），即在主程序（我更喜欢称为客户程序）需要该模块时才由操作系统加载到内存。毕竟一个大型应用程序我们经常使用到的功能并不多，这样一些不常用的功能模块（DLL）在程序运行时一般将不被载入，可极大节省内存开销。DLL同时也是目前最常用的分发模块的方法，便于彼此协作。程序中对DLL的调用主要有两种方法：1 针对使用DEF文件导出函数的DLL，使用API函数LoadLibrary（“DLLModuleName” ）加载，然后使用GetProcAddress（）得到函数指针，进而调用 2 直接将类、函数等导出，客户程序使用同一份头文件声明，加入对应的lib链接库，即可在客户程序中直接使用DLL中的类或函数，无需LoadLibrary。

“Process”: 进程
　　进程是一个动态的概念,包括从进程的创建申请,PCB(Process Control Block进程控制块,一般操作系统实现为一个表格(struct))的创建,地址空间的内存分配,模块代码载入并执行,执行完以后进行撤销,整个过程被称为”进程”。在Win32下，一个进程有4G的逻辑空间。但我们也常把它作为静态概念来使用，在Win32下，一个EXE的执行就是一个进程(如果它内部又开了新进程，另当别论）。

“Thread”: 线程
　　为了更有效的提高CPU的利用率，更好地实现多任务并发，微软将进程进行进一步分割，实现了CPU任务调度的新对像：线程。一个进程拥有至少一个线程。我们在实现多任务并发的时候通常是建立一个新线程（建立线程的系统开销要小于进程），线程以我们自己的一个函数作为入口,函数执行完毕自动撤销（当然你也可以在执行过程中强制结束该线程）。顺便提一下，在UNIX下并没有线程这个概念，想来是因为UNIX主要是以多进程的并发服务为主（所以它更适合于做服务器），系统运行时通常已经有了太多的进程，所以没有必要再对进程进行细化，因为这样做甚至会降低系统效率（CPU调度不过来）,当然，这是我个人的猜想：）

“C语言”
　　到目前为止，C语言应该是传播最为广泛的语言，特别在UNIX的世界里依然扮演着主角的位置，在其余如硬件开发，嵌入式系统（如手机）皆有十分突出的表现，即便在win32平台下SDK的开发中也有一席之地。更主要的是它是大多数国内（国外我不敢说）程序员的启蒙语言，通过它许多人才领会了程序的思维。C最大的特点就是快，除了汇编以外效率可以达到最高，而它的灵活性，对硬件的直访性也完全符合程序员自由的天性。如果说学习别的技术尚有犹豫和徘徊，那么学C只有一句话：相信我，没错的！也有许多人主张可以直接学习面向对象语言，我不太同意。面向对象语言对机器模型的抽象十分容易让程序员迷糊，心中难以建立准确的程序运行时的模型。毕竟我们是程序员，不是用户，我们不能把所有的问题都想当然地交给编译器和操作系统去解决，它们也解决不了。至少学习一门面向过程的语言，才能知其所以然。

C++
　　这是贝尔实验室的又一杰作，同时，也伤透了全球太多程序员的心,脑细胞杀伤力十分之大。C++比大多数初学者想像的都要复杂得多，它基本包括：一个类化了的C语言，模板，标准模板库.很多初学者掌握的C++仅仅只是一个类化了的C语言的一个子集（不相信的话，你不妨看一看<<Modern C++ Design>>中的C++代码，看看能理解多少）。更麻烦的是使用C++不得不谈到面向对象的编程风格，这同样比初学者想像的难很多，要有打持久战的准备。而最让我这类C++爱好者忧心的还是它目前在Win平台中的前景,在.net平台上很难找出不用C#而使用C++写新代码的理由：（ 。而它的复杂性和目前许多诸如java/C#及一些动态语言(python/ruby)比起来，开发效率显然的低，大有退出上层应用程序开发的趋势。这么一个包含了最多范式的近乎完美的语言，我实在不想放弃。我唯有祈祷在未来C++的路可以走得更远更好一些。

源代码版本控制
　　这是软件开发中一个十分重要的工程手段，几乎是必须的一个Process(过程)。很多作坊式的开发团队在采用软件工程的一些方法的时候，第一个要进行改进或增加的，往往就是这个过程。对初学者学习而言，建议在开始进行实践小项目的阶段即进行源代码版本控制，因为这在以后的工作中，是一定会用到的。　　

源代码版本控制的基本原理如下：
　　在服务器端建立该项目的数据库，并保存你选定的项目源文件的第一个版本。客户端任一用户要获得某源文件的修改权利，需进行check out操作。之后客户端一般每完成一个无编译错误的版本想保存的时候，进行check in操作，将当前版本保存在服务器端上并成为最新版本（注意，不是覆盖以前的哟）。任一客户端可以方便地得到服务器上的文件的任意版本（如果有权限的话）。一般还实现了一个重要的功能是版本比较，任一客户端可以利用版本控制工具对某文件的不同版本进行版本比较，它会标记出不同版本的同名文件的不同点，可以轻易地看出版本内容的演化，这一招很常用。 下面介绍一下我接触过的三种版本控制工具（也是国内用得比较多的）：

　　VSS: Visual Sourcesafe
　　这是微软Visual Studio自带的源代码版本控制工具，它最大的特点就是易安装（与Visual Studio集成在一起，装VC/VB的时候就顺便搞定，不用别外费工夫），使用简单（服务器端设置相对容易，一般个人稍加摸索就可以轻松搞定，客户端更是只管check in/out），基本功能完善，版本比较很直观（我喜欢）。它的特点是某人check out了某版本以后，别人将无法对此版本check out,也就是说同一时间只有一个可以修改某一个文件，这样就避免了不同的人对同一文件的修改造成彼此冲突（注：可通过设置服务器端实现多人check out,但几乎不会这样做，因为那样就失去了VSS的一个最重要的功能）。另，VSS可集成于VS环境，但根据我的经验，直接在VC里对版本的check操作，常常不生效，所以最好还是到VSS程序里去进行check操作。补充：单机上也可以使用VSS，这样的好处是在对当前某些文件进行了误操作或大规模地误修改之后，可以恢复到最近的无错误的版本，最大程度地挽回损失。VSS实际应用较普遍，如果你是走Visual Studio路线的话，一定要用一下。

CVS: Concurrent Versions System
　　这个也是一个大名鼎鼎的开源的版本控制工具，主要活跃在UNIX世界。CVS我使用不多，一般而言好像功能比较偏向于命令行方式（UNIX下开发很多人也都使用着命令行方式）。当然，Windows下面也实现了几个版本的CVS，也可以集成于VS，好像还有一个可以挂接在IE上的，我没试过。著名的开源项目管理网站sf.net也是用的CVS，如果你要和全世界的程序员一起协作开发，CVS是必须要安装的。在JAVA的世界里，也是以CVS为主。

Rational Clearcase
　　这个工具就比较上档次了，Rational公司(现在是IBM）的出品，价格昂贵。我最初参加工作的时候用过一小段时间，简单谈一下。这个工具的特点是复杂，安装及设置就十分复杂，我的印像中客户端甚至不得不加入到NT域里面去，导致我在本机的权限都不够，安装新程序都很麻烦，很郁闷（不知道是不是我们公司的相关人员安装设置错了，想来应该是这样，但其复杂性可见一斑）。对使用而言，它有一个功能挺有用的，就是它能够根据你每次check的版本号，自动生成版本树（一个树状图表），你可以清晰地看到版本的演化过程。所以严格地说，像CVS/Clearcase这样的才真正称得上“版本”控制，VSS还太勉强。Clearcase的功能十分强大，我不详述了（我还不想出书），较适于大型软件公司实施软件配置管理时采用。虽然它的名气十分之响亮，但我不知道国内有多少公司在真正使用正版的Clearcase这样的工具，想来应该是十分之少。

OpenGL
　　OpenGL至今颇有一点英雄落寞的味道，这一套标准是实现得如此之好，以至于曾经一度成为游戏界面华丽的标准。它的低落也是一个必然，毕竟在微软的强力打压下鲜有不挫败的。但它曾经能够给微软带来如此的压力，至今也依然在工业界被广泛使用，大多数游戏/显卡依然保留着对它的支持（CS里我喜欢的还是OpenGL)。而它的性能在某些方面与D3D比较，依然占着上风。不幸的是DirectX在不停地向前发展，而它，几乎止步不前了，前景并不光明。OpenGL目前在工业领域应用较为广泛，它的优秀的矢量图的操作性能，华丽的色彩，在专业的图形图像处理领域表现突出。游戏中使用相对以前而言则是越来越少。新近听说微软的最新操作系统Vista对OpenGL进行了极大的打压，不但性能上折扣，支持的版本也只到1.4(最新版本好像是2.0)，不知道最后如何收场，拭目以待。

DirectDraw & D3D
　　大凡像样的2维Windows游戏，几乎都是采用此技术来实现显示的。DirectDraw有两种模式：全屏和窗口。其中全屏应用更多一些。在全屏下，DirectDraw有一个十分著名的“换页”技术，即在两个显示页面之间用“交换”来实现显示刷新，这个速度十分地快，只是一个显存内一个指针的交换，比你用BitBlt复制一屏的像素快太多太多，游戏的高效的动画效果大多源于此技术。
DirectDraw主要用于娱乐领域和一些实时显示要求较高的场合，如医疗图像。D3D是目前大多三维游戏的标准采用，我没钻研过，不敢多言。它的效果嘛，玩玩游戏就知道了：）

UML:Unified Modeling Language，多译为统一建模语言
　　这个语言是一种图形语言，主要是作为设计时建模的一种标准的图形模型，便于程序员与程序员、程序员与客户、设计员与代码员之间的沟通，同时它也帮助设计人员将头脑中的基于程序代码的对程序功能的理解形成文档，便于理清头绪，进行下一步编码的工作。换言之，设计过程的产品，可以表现为一些文本文档，或者一些框架代码，或者一些伪代码，但比较标准通用的，是表现为一堆UML图。UML包括动态图和静态图两大类，其中静态图中的类图最为常用。很多人初学时不知道该怎么做设计，写小软件时常常没有设计过程，其实很简单，把软件的类图画出来就好了。学做设计时未必要找一个像Together或者Rational Rose一样的巨无霸。用一些简单的可以做UML图的工具就好，专门用来画UML图的小工具很多,网上容易找。补充一点：画UML图不要面面俱到，不要什么都画，突出重点方便理解就好，甚至使用不规范的记号也不要紧（当UML的功能是草稿的时候）。

RTTI: Runtime Type Information 运行时类型信息
　　在程序中，当我们得到某一个对象的实例或者指针时，大多数时候并不能直接肯定它的类型（都是继承以及类型转换惹的祸），这个时候，依靠VC4.0或更高版本的编译器提供的RTTI支持，调用库函数typeid()即可在运行时获取这个对象的“类型信息”，在一些动态处理中“类型信息”很重要,获取了类型信息以后，你就可以有十分把握地调用该类型的相关操作，或者类型转换，或动态生成。因其重要性，在JAVA和.net库中借助单根继承和“虚拟机”对此有了更优雅的做法，每一个自object继承的类天然就有了表述自己类型信息的能力（继承的好处），并且容易扩展，现在你需要类型信息的时候，大可直接ask那个对象：tell me, what type are you?它就会告诉你答案。

debug & release 调试 & 发行
　　大家都知道，debug是调试版，release是发行版，区别在于debug版生成的程序中包含大量供调试用的场景代码（不是真正运行需要的），而release一般去掉了这些信息，并进行了某些代码优化，所以release版的程序会比debug版的程序小很多，运行速度也快一些。同时，debug版为了便于调试，往往会对调试使用的诊断代码加上DEBUG一类的宏，使得在release下不对这些代码进行编译。正由于两种版本编译使用的源代码的差异（以及release糟糕的优化），常常使得两种版本运行时产生截然不同的效果，一个正常一个崩溃是大多数人都遇到过的。导致问题的可能性很多，注意事项详见各论坛的诸多精华贴。另，同一个程序如果DLL之间的链接使用了不同版本（譬如EXE是release版，dll是debug版），有时会无法正常运行，所以我一般的做法是每一个DLL针对不同版本使用两个DEF文件，编译生成不同名的两个文件（debug版文件名后加d)，调用时各个版本针对自己的版本调用，这在一定程度上可避免混乱。另，release也是可调试的，在工程设置里把调试信息打开即可。
XP:eXtreme Programming 极限编程

　　这是近几年才时兴起来的开发模型,国内大致是01/02年开始有所宣传。

　　它主要是针对中小型开发团队在开发时间要求紧、需求不稳定的中小项目（大多数软件项目都是这个情况）时使用。它打破了传统软件工程的框架，非常新巧。譬如整个开发过程中文档很少，大量使用“卡片 （如CRC卡片）”来描述开发计划和内容；没有真正意义上的软件功能规格说明书，取而代之的是一系列可测试的用例；没有独立的设计和测试阶段，它们总是在迭代中增量反复进行；设计：尽可能小和简单；一般没有代码复审（code review),大家共同拥有代码。而它的最显著的一个外在特征是它常使用“成对开发”，即一台机器前坐两个开发人员，共同开发（一个看，一个写），这乍听起来真是蛮有趣的：）,它的基本出发点是认为成对开发的效率在一定条件下要高于两个人独立开发的和。不要觉得天方夜谭，在很多项目中，这种做法的有效性已经被证实。

　　XP的特点可以用“快、小、灵”来概括，它和传统瀑布模型（自顶向下）的区别在于它使用迭代增量（设计->代码->测试->设计->代码…)的方式。想法很简单：没有什么目标是可以一开始就容易确定的。用爬山来做一下比喻的话，传统的是在山下研究地图，选好一条路线，然后沿着此路前进，XP则是走一走，停一停，看一看，对下一步的方向作出新的选择，在很多时候，这样做会让你选择到更好的捷径。

ICONIX:
　　这个字相信很多人都没见过，我也不知道是什么字拼起来的，作为开拓眼界，我还是提一下吧。这是一种界于XP和RUP（Rational Unified Process)之间的开发模型，换言之，它比XP“大”，比“RUP”要小。它采用了UML的一个子集，特点是用例驱动，保持良好的进度跟踪能力。它的目标是用最短的时间来把用例变成代码。具体来说，这种开发模型相对精简的XP而言，更加强调用例的建立、分析和代码化，用例是其中心地位。

RUP：Rational Unified Process
　　前面已经提到了，相信你已经感觉出它是一个丰富的软件开发模型。这是由IBM提出来的软件工程模型，它使用完整的UML图，对开发的各阶段（需求、设计、代码、测试、维护）均有十分完善而复杂的标准，就不详述了。RUP本质上是迭代式开发，在每一次迭代中均完成以下四个阶段：初始阶段（inception)、详述阶段（elaboration）、构建阶段（construction）、转换阶段（transition）。

CMM:Capability Maturity Model 软件成熟度模型
　　这是卡内基*梅隆大学软件工程研究所（我的专业正是软件工程，所以这也成为我心目中的圣地）的一大力作，一度曾形成了席卷全球软件开发的CMM浪潮。CMM分为五级，大多数软件企业都处于第一级，而得到第五级认证的全球也没有多少，国内去除掉挂羊头卖狗肉的，也是寥若星辰（嗯，比星辰是寥多了）。所以CMM实施一般是从第二级开始，能做到第三级的都是颇有实力的软件公司了。CMM是以Process（过程）为中心的模型，从二级始每一级都有几个Key Process(关键过程），每一个KP又分为若干Key Active(关键活动）。CMM的实施一般不能越级实施，并且每一级的实施通常都要一年以上，所以要达到较高等级是一级很困难的事。另，CMM不仅可用于较大规模公司，同样也可实施于小公司，小项目组（这是很多人所不知道的）。实施视具体情况等级之间可交叉，譬如实施时采用二级的某些KP再加上三级甚至四级的KP，但你只有实施了所有二级的KP，你才能也只能通过二级认证，即便你采用了某些四级的KP。CMM最新发展成果是CMMI（Integration),这主要是新考虑了软件与非纯软件因素的关系（譬如系统），以及团队之间的协作问题。CMM在国内的发展似乎有点走向ISO同样的道路，这实在不是一个好消息。

Callback Function: 回调函数
　　在侯sir的<<深入浅出>>中一开始就提出了这个概念,大概的提法是说回调函数是操作系统调用而你永远不要去调用的函数。这个提法让初学者有点望而生畏，以为是一种多么高深而难以领会的系统底层的核心技术。其实不然，这个技术本质很简单，而且很常用。它实质就是函数指针的基本运用（如果不知道什么是函数指针的话，翻翻书）。在一个模块中，有时想让一部分功能由其它模块实现，譬如说一个做显示的模块，它只想实现显示的资源配备，画面的刷新，缩放等控制功能，而把画具体实体（譬如圆、多边形，都可以有很多种不同效率的实现方法）的代码由别的模块来实现，怎么办呢？用函数指针。在自己的类中放一个画圆的函数指针，使用时由外部为这个函数指针赋值（其实就是指向了一个外部的函数），在自己的代码中直接调用这个函数指针来画就可以了（本模块完全不知道外部模块是怎么画圆的）。那个外部的函数在这里就是回调函数！

　　在很多系统API中就使用了这种函数回调的方法，让我们开发的代码实现可以嵌入到API的代码实现当中，其实我们就是传了一个函数地址给它而已。换句话说，这些API搭好了某些运行的代码框架，我们来为它具体实现。

XML: Extensible Markup Language 可扩充标记语言
　　也许你还在为选择.net和j2ee而徘徊不前，如果是这样的话，不妨先着手学一下它们所共通的一个基础：XML。有了HTML为什么我们还要XML？很简单，HTML重在表现文本/图片以及一些多媒体内容，它很难表达数据，因为它的标记是固定的，而数据类型千千万，根本无法描述。.net和j2ee都要解决一个信息传输格式标准化的难题，这个格式要能承载文本/数据，最好还能描述程序接口，同时又应该像HTML一样简单，具有通用性，能够在HTTP下很好的运作。在这种要求下，XML产生了。它的特点正如其名，和HTTP一样，它也是一种标记语言，但是它的标记不是固定的，是可自定义（也就可无限扩展）的，这些自定义标记能够很好的描述数据类型以及对应的数据内容（乍看起来很像数据库表的定义）。除此以外，XML还可以描述程序接口，所以XML可以方便地与网络程序构件（COM、EJB等）直接交互。由于它也是一种ASCII文本流，所以与当前的HTTP兼容，在当前的internet上畅通无阻（这很重要）。有了以上功能，XML就名副其实地成为了新一代互联网技术的标准信息载体，在.net和j2ee的网络架构中，各种“构件”的信息交互都交给了XML，可谓任重而道远。

　　XML我自己没怎么写过，单就学习上的经验而言，感觉语法上比HTML更琐碎一些，小细节更多，没那么容易速成：） 好在根本同源，有HTML基础甚至WEB开发基础的，学起来也很轻松。

Java2:
　　这是近几年最吸引大众焦点的语言,在Web开发,网络平台,移动开发的世界里发光发热。你可以不用java,但你不可以不了解java，毕竟这是一个极大且丰富的软件开发领域。有些没使用过java的VS阵营里的人可能还不明白java2里的那个2是什么意思，容我先解释一下。Java最初正式推出1.0时，并没有受到如此多的好评，受到颇多责难，于是它不断地推出新版本来完善自己，其中变化显著的一个版本是1.2(我没记错吧），Java的每一个新版本除了语法上的更新，还有一明显的标志，那就是JDK（Java Development Kit,就是Java自带的一套SDK）的更新，版本1.2以后的java为了在宣传上与以前的java相区别，便被称为java2。目前用得比较多的jdk是1.3/1.4 ,最新的JDK是1.5(代号tiger)。java开发的IDE国内主要以JBuilder为主，另外就是在开源领域如雷贯耳的Eclipse,而sun也力推自己的开源java IDE：Netbeans（从sun的网站上可下载，免费）。Java运行是虚拟机机制，相当于在操作系统上增加了一个软操作系统，源码被编译成一种字节中间码，由虚拟机解释执行，只要有对应的虚拟机，java程序就可以在该操作系统上运行，这就是java号称的一次编译，到处运行的由来。而附带而来的不可避免的性能问题也让Java难以成为桌面程序开发的主流。补充一下：对初学者学习而言最好的Java IDE我推荐使用JCreator,这是一个C++写成的IDE，几MB的大小，比Eclipse快十倍以上的启动速度，对初学者带来极大的便利。

J2EE:
　　Java实际上又被分为3类：J2EE/J2SE/J2ME,不同类分别对应不同的JDK，J2EE针对企业平台开发，J2SE是标准版，J2ME针对移动平台开发。J2EE现在实在是热得烫手，我前不久翻了一下程序员早期的杂志，发现在第一期创刊号里（2001.1)已经有了j2EE方面的讨论，现在已经是2004.6了，你对它的认知又多了多少？J2EE不是一种单纯的技术，而是一种体系架构以及组成该架构的诸多标准。企业平台开发和桌面/简单Web数据库开发有很大的不同，它的程序规模往往很大（不是一个或者几个EXE可以搞定的），用到的往往是海量的数据库和海量的通信，并且常常是不可中断的，这些特殊性都使得企业平台开发更多地去关注架构的问题。而我们写一个熟悉的java客户端程序，或者消息处理中间件，又或者数据库处理程序，都只是这样一个架构里的一小部分。J2EE是很宠大的，所以请不要写了几个EJB(这是java世界里的构件，概念上大概是类似于COM）的例子程序就感觉自己精通j2EE。

　　J2EE中传递消息时往往引入了一个被称作消息管理器的中间件，在服务器端使用EJB的容器来管理和调用EJB。在J2EE中一个重要的概念是Transaction(事务）处理，事务的概念最早广泛应用于数据库技术。这实际上是一个封装了很多操作的单元，它的作用是中间任何一个操作失败，可以自动依次整体撤销，所以一个transaction就是操作成功/失败的最小单元，不存在一个transaction只成功了部分操作的情况。

在企业服务平台开发中比较知名的有一个叫BEA公司（这是一家不错的公司，应该知道它的名字），它的产品是Weblogic。

.net
　　.net是微软为下一个十年准备的技术，你呢？.net也是一种平台技术，而不是单一技术。它主要分为.net运行时平台（对应java的虚拟机）和.net类库（对应java的jdk)。目前只有Windows2003是天然集成了.net运行时平台的操作系统，所以如是你写的.net程序想要在别的操作系统上运行，该操作系统必须先安装.net平台，这是一件蛮烦人的事，也是为什么到目前为止，还没有太多的人改用.net来写程序（尽管可极大提高开发效率）。希望Longhorn的出现可以扭转这一现状。那我们就终于可以和MFC这样过时的框架类库说再见了，一大快事。

.net采用了很多最新的技术和思想，对走VS路线的人来说（特别是有COM概念的），学起来相对轻松且很过瘾，前人推荐的“.net框架程序设计“和”.net本质论“都是很好的书。当然，看它们之前你最好基本掌握一门.net语言，譬如C#，掌握语言对我们来说是最easy的。

//名字空间对象
var net=new Object();
//未初始化状态
net.UNINITIALIZED=0;
//装载中
net.LOADING=1;
//已装载
net.LOADED=2;
//已中止
net.INTERACTIVE=3;
//已完成
net.COMPELETE=4;
//HTTP完成
net.HTTP_OK=200;

//构造函数
//method:请求方式，GET或POST
//url:请求的url
//onload:请求完成后执行的回调函数，将传入参数this
//onerror:错误后执行的回调函数，将传入参数this
net.AjaxRequest=function(method,url,asyn,onload,onerror)
{
//初始化传入的构造变量
this.url=url;
this.onload=onload;
this.method=method;
this.asyn=asyn;
this.onerror=(onerror)?onerror:this.DefaultError;
//XMLHttpRequest对象
this.xmlHttp=null;
//开始请求
this.StartRequest();
}

//获取XMLHttpRequest对象
net.AjaxRequest.prototype.GetXmlHttp=function()
{
if (window.ActiveXObject)
{
this.xmlHttp = new ActiveXObject(“Microsoft.XMLHTTP”);
}
else if (window.XMLHttpRequest)
{
this.xmlHttp = new XMLHttpRequest();
}
}

//请求状态变化处理函数
net.AjaxRequest.prototype.onReadyState=function()
{
//取得这一时刻的XMLHttpRequest对象副本
var xmlhttp=this.xmlHttp;
var ready=xmlhttp.readyState;
//判断是否请求完成
if(ready==net.COMPELETE)
{
//判断请求结果
var status=xmlhttp.status;
if(status==net.HTTP_OK||status==0)
{
//执行客户的自定义请求完成处理函数
this.onload.call(this);
}
else
{
//执行错误处理函数
this.onerror.call(this);
}
}
}

//开始请求
net.AjaxRequest.prototype.StartRequest=function()
{
//获取XMLHttpRequest对象
this.GetXmlHttp();
//如果获取XMLHttpRequest对象成功
if(this.xmlHttp)
{
try
{
//获取自身的一个副本
var loader=this;
//设置状态变化回调函数
this.xmlHttp.onreadystatechange = function()
{
//请求状态变化处理函数，传入this
loader.onReadyState.call(loader);
}
//打开连接，开始请求
this.xmlHttp.open(this.method,this.url,this.asyn);
//模拟浏览器
this.xmlHttp.setRequestHeader(“Content-Type”,“application/x-www-form-urlencoded”);
//发送请求
this.xmlHttp.send(null);
}
catch(err)
{
//错误处理
this.onerror.call(this);
}
}
}

//默认错误处理函数
net.AjaxRequest.prototype.DefaultError=function()
{
alert(“发生错误!”+“\nreadyState:”+this.xmlHttp.readyStatus+“\nstate:”+this.xmlHttp.status+“\nheaders:”+this.xmlHttp.getAllResponseHeaders());
}

function AddURLParam(sURL,sParamName,sParamValue)
{
sURL+=((sURL.indexOf(“?”)==-1?“?”:“&”));
sURL+=encodeURIComponent(sParamName)+“=”+encodeURIComponent(sParamValue);
return sURL;
}

function Change(target,content)
{
if(!target||!content)
{
DefaultError(“无目标”);
}
else
{
SetInnerHTML(document.getElementById(target),content);
}
}

function SetInnerHTML(el, htmlCode)
{
var ua = navigator.userAgent.toLowerCase();
if(ua.indexOf(‘msie’) >= 0 && ua.indexOf(‘opera’) < 0)
{
htmlCode = ‘<div style=”display:none”>for IE</div>’ + htmlCode;
htmlCode = htmlCode.replace(/<script([^>]*)>/gi,‘<script$1 defer>’);
el.innerHTML = ”;
el.innerHTML = htmlCode;
el.removeChild(el.firstChild);
}
else
{
var el_next = el.nextSibling;
var el_parent = el.parentNode;
el_parent.removeChild(el);
el.innerHTML = htmlCode;
if (el_next)
{
el_parent.insertBefore(el, el_next);
}
else
{
el_parent.appendChild(el);
}
}
}

测试用例:

index.html

<html>
<head>
<title>Test Zoc Ajax 0.1.0</title>
</head>
<body>
<script language=“JavaScript” type=“text/javascript” src=“inc/AjaxRequest.js”></script>
<div id=“zone”>Loading…</div>

<script language=“JavaScript” type=“text/javascript”>
var ajax=new net.AjaxRequest(“GET”,“test.htm?time=”+new Date(),true,loaded);
function loaded()
{
Change(“zone”,this.xmlHttp.responseText);
}
</script>

</body>
</html>

test.htm

This is a test string.