File::Find
find(subref, dirlist);
File::Copy
copy("sourcefile", "destinationfile")
诊断信息
use diagnostics;
终于看不下去 Java 了，重新拾起我的 C++ ―― 最强大的计算机语言 ^^
2007年8月21日的草稿，现在才发。
2007年10月19日星期五
File operation
可移植的文件系统操作
File::Find
find(subref, dirlist);
File::Find
find(subref, dirlist);
2007年9月14日星期五
Doctor Bjarne.Stroustrup
C++ 之父 B.Stroustrup言论（译者：孟岩，来自侯捷老师主页）节选，转载至此作为备份
以下蓝色为提问，黑色为回答。红色 为译注，紫色为侯捷个人认为宜再斟酌之处。
浅蓝色是侯捷个人阅读时的神秘标记。
选择书籍时，务必注意该书是不是从一开始就讲授标准C++，并且矢志不渝地使用标准库机制。例如，从输入中读取一个字符串应该是这样的：
string s; // Standard C++ style
cin >> s;
而不是这样的：
char s[MAX]; /* Standard C style */
scanf("%s",s);
去看看那些扎实的C++程序员们推荐的书吧。记住，没有哪本书对所有人来说都是最好的。另外，要写地道的C++程序，而避免用C++的语法写传统风格的程序，新瓶装旧酒没多大意义。（遗憾的是，目前在市面上的中文C++教材中，符合B. S的这个标准的可以说一本都没有，大家只好到网上找一些英文的资料来学习了。--译者）
在访谈即将结束时，或许我该再次表明态度：C++仍然是我喜爱的语言，在写代码时你会发现没有那种语言能像它那样在如此广泛的应用领域和平台上同时达成如此的高效与精致。
以下蓝色为提问，黑色为回答。红色 为译注，紫色为侯捷个人认为宜再斟酌之处。
浅蓝色是侯捷个人阅读时的神秘标记。
1. 我如何开始学习C++？
这取决于你的基础和学习动机。如果你是个初学者，我想你最好找个有经验的程序员来帮助你，要不然你在学习和实践中不 可避免的犯下的种种错误会大大地打击你的积极性。另外，即使你的编译器配备了充足的文档资料，一本C++书籍也永远是必不可少的，毕竟文档资料不是学习编 程思想的好教材。选择书籍时，务必注意该书是不是从一开始就讲授标准C++，并且矢志不渝地使用标准库机制。例如，从输入中读取一个字符串应该是这样的：
string s; // Standard C++ style
cin >> s;
而不是这样的：
char s[MAX]; /* Standard C style */
scanf("%s",s);
去看看那些扎实的C++程序员们推荐的书吧。记住，没有哪本书对所有人来说都是最好的。另外，要写地道的C++程序，而避免用C++的语法写传统风格的程序，新瓶装旧酒没多大意义。（遗憾的是，目前在市面上的中文C++教材中，符合B. S的这个标准的可以说一本都没有，大家只好到网上找一些英文的资料来学习了。--译者）
2. 怎样改进我的C++程序？
不好说。这取决于你是怎麽使用该语言的。大多数人低估了抽象类和模板的价值，反过来却肆无忌惮地使用造型机制(cast)和宏。这方面可以看看我的文章和书。抽象类和和模板的作用当然是提供一种方便的手段建构单根的类层次或者重用函数，但更重要的是，它们作为接口提供了简洁的 逻辑性的服务表示机制。3. 如果不必和C兼容，你所创造的语言是不是就会是Java?
不是，差得远。如果人们非要拿C++和Java来作比较，我建议他们去阅读The Design and Evolution of C++，看看C++为什麽是今天这个样子，用我在设计C++时遵从的原则来检验这两种语言。这些原则与SUN的Java开发小组所持的理念显然是不同的。 除了表面语法的相似性之外，C++与Java是截然不同的语言。在很多方面，Java更像Smalltalk（译者按：我学习Java时用的是Sun的培训教材，里面清楚地写道：Java在设计上采用了与C++相似的语法，与Smalltalk相似的语义。所以可以说Java与C++是貌合神离，与Smalltalk才是心有灵犀）。Java语言相对简单，这部分是一种错觉，部份是因为这种语言还不完整。 随 时间的推移，Java在体积和复杂程度上都会大大增长。在体积上它会增长两到三倍，而且会出现一些实现相关的扩展或者库。这是一条每个成功的商业语言都必须走过的发展之路。随便分析一种你认为在很大范围内取得了成功的语言，我知道肯定是无有例外者，而且实际上这非常有道理。
上边这段话是在Java 1.1推出之前写的。我确信Java需要类似模板的机制，并且需要增强对於固有类型的支持。 简单地说，就是为了基本的完整性也应该做这些工作。另外还需要做很多小的改动，大部份是扩展。1998年秋，我从James Gosling（Java语言的创始人--译者）那 里得到一份建议书，说是要在Java中增加固有类型 操作符重载以及数学计算支持。还有一篇论文，是数学分析领域的世界级大师，伯克利大学的W. Kahan教授所写的How Java's Floating-Point Hurts Everyone Everywhere（"且看Java的浮点运算如何危害了普天下的芸芸众生"--译者），揭露了Java的一些秘密。
我 发现在电视和出版物中关於Java的鼓吹是不准确的，而且气势汹汹，让人讨厌。大肆叫嚣凡是非Java的代码都是垃圾，这是对程序员的侮辱；建议把所有的 保留代码都用Java重写，这是丧心病狂，既不现实也不负责任。Sun和他的追随者似乎觉得为了对付微软罪恶的"帝国时代"，就必须如此自吹自擂。但是侮 辱和欺诈只会把那些喜欢使用不同编程语言的程序员逼到微软阵营里去。
Java并非平台无关，它本身就是平台。跟Windows一样，它也是一个专有的商业平台。也就是说，你可以为Windows/Intel编写代码，也可以为Java/JVM编写代码，在任何一种情况下，你都是在为一个属於某个公司的平台写代码，这些代码都是与该公司的商业利益扯在一起的。 当然你可以使用任何一种语言，结合操作系统的机制来编写可供JVM执行的程序，但是JVM之类的东西是强烈地偏向于Java语言的。它一点也不像是通用的 公平的 语言中立的VM/OS。
私下里，我会坚持使用可移植的C++作大部份工作，用不同的语言作余下的工作。
（"Java is not platform-independent, it is the platform"，B. S的这句评语对於C++用户有 很大的影响，译者在国外的几个新闻组里看到，有些C++高手甚至把这句话作为自己的签名档，以表明对Java的态度和誓死捍卫C++的决心。实际上有很多 程序员不光是把自己喜爱的语言当成一种工具，更当成一种信仰。--译者）
4. 您怎麽看待C#语言？
就C#语言本身我没什麽好说的。想让我相信这个世界还需要另外一个专有的语言可不是一件容易的事，而且这个语言还是专门针对某一个专有操作系统的，这就更让我难以接受。直截了当地说，我不是一个专有语言的痴迷者，而是一个开放的正式标准的拥护者。
5. 在做小项目时，C优于C++吗？
我认为非也。除了由於缺乏好的C++编译器而导致的问题之外，我从没有看到哪个项目用C会比用C++更合适。（不过现在C++编译器导致的问题还是不可忽略的，当你看到同样功能的C++程序可执行代码体积比C大一倍而且速度慢得多时，会对此有所感触的。--译者）
6. 您预期C++做哪些增强，会不会删掉一些东西？
很不幸，虽然有一些东西很应该扔掉，但恐怕很难真的删掉任何东西。第一个应该抛弃的东西就是C风格的造型机制和类型截断转换。就算不禁止，编译器的作者们至少也应该对这种行为给与强烈的警告。我希望能用类似vector的东西彻底取代数组，但这显然是不可能的。不过如果程序员们能主动使用vector来代替数组，就会立刻受益匪浅。关键是你不必再使用C++中最复杂难缠的技巧了，现在有优秀得多的替代方案。
至於主要的特性，我没想去掉任何东西。特别是那些把C++与C区别开来的主要特性恐怕没法风平浪静的被抛掉。通常问这些问题的人是希望我挑出诸如多继承 异常 模板等机制来接受批判。所以在这我想大声讲清楚，我认为多继承机制对於静态类型语言实现继承性来说是必需的，异常机制是在大系统中对付错误的正确方法，模板机制是进行类型安全的 精致的和高效的程序设计的灵丹妙药 。我们可以在小的细节上对於这些机制挑挑刺，但在大的方面，这些基本的概念都必须坚持。
现在我们仍在学习标准C++，也正在标准所提供的特性基础上发展出更新的 更有趣的编程技术。特别是人们刚刚开始使用STL和异常机制，还有很多高效强大的技术鲜为人知，所以大可不必急匆匆的跑去增加什麽新的机制。
我认为当前的重点是提供很多新的 比以前更加精致的 更有用的库，这方面潜力巨大。例如，如果有一个能被广泛使用的 更精致的支持 并发程序设计的库，那将是一大福音--C风格的线程库（例如Pthread--译者）实在不够好。我们也就可以与各种其他的系统，例如SQL以及不同的组件模型更好地契合起来。数值计算领域的人们在这方面好像已经走在了前面，类似像Blitz++ POOMA MTL之类的高效而精致的库的开发已经取得了非凡的成就。 （译 者在Internet上造访了Blitz++和POOMA的主页，前者是一个高性能数学库，据称其性能与Fortran 77不相上下，同时又支持大量的C++特性。我想凡是对於数值计算领域有所了解的人都知道这有多麽伟大的意义。POOMA则是一个专门研究C++并行数学 算法的项目，它的前景更加不可限量。译者非常认同B. S的这个观念。--译者）
有了足够的经验之後，我们就能更好的决定应该对标准做些什麽调整。
7. 有没有计划往标准C++里增加一些新的特性以支持分布式计算？
没有，我也不认为有这个必要。用更好的库就差不多能解决问题了。最多，为了支持这类的库，我们可能会增加一些低级的原操作和规则
8. 未来C++有没有可能定一个可移植的二进制接口？
如果你说的"可移植"是指跨硬件和块操作系统的可移植，我想回答是不会。我们当然可以设计一个解释器或者虚拟机（如同Java的做法--译者），但这样一来，由於无法以最优的方式访问系统资源，C++的能力就会受到削弱，。我真正希望在不远的将来能够看见的东西是platform ABIs （ABI， Application Binary Interface） 。例如，有人正在努力为Intel新的IA64体系定义C++ ABI，我想这些努力会得到用户们的巨大支持。能够把不同编译器产生的代码编译在一起将会是一项十分有意义的事情。
9. 在不少流行领域，C++正在渐渐失去光芒，因为它要求人们花很大的精力去对付一些很基本的工作，比如管理内存（因为没有垃圾收集机制），管理模块之间的依 赖性（因为没有包机制），管理组件的版本。C++缺乏一些现代语言已经视为标准的特性。比如传言中最酷的Java语言就特别重视这些问题。那麽在解决这些 问题是否会导致C++的发展背离其根本宗旨呢？C++应该怎样发展以保证我们在这种语言上的投资能有合理的回报，而不是被迫去重新使用另一种语言？
我倒还没有注意到C++比以前用的少了。相反，我看到的指标表明C+的使用还在稳定地增长 。只不过这种基数很大的稳定增长以及在标准性 移植性和库方面的不断提高并没有造成什麽具有欺骗性的新闻效应而已。我认为你所说的"失去光芒"只不过是市场推销和新闻意义上的现象。
如果你需要垃圾收集机制的话，你可以在C++应用程序中插入一个垃圾收集器。有不少自由的和商业的垃圾收集器已经在重要的实践中被证明是很出色的。
如果你不想使用垃圾收集机制，也没关系。你可以使用标准容器类，它们大大减少了对於显式分配和回收内存的需要。这样，使用现代的库和现代的编程风格，你能够避免大部份的内存管理问题。
同样的技术还能够用来避免一般资源的管理问题。并不是只有内存才会泄漏，线程句柄 文件 互斥锁 网络连接等都是重要的资源，为了建立可靠的系统，这些资源必须被正确的管理。 如果你觉得有了垃圾收集机制就可以解决所有的资源管理问题，那麽你最好赶快从美梦中醒来。
C++提供了很多机制来管理一般性的资源。关键的手段--"Resource Acquisition is Initialization"(这是著名的RAII惯用法，阅读原文时会经常遇到，其意义是说将所有的资源分配申请放在对象初始化过程中进行，而将资源释放动作放在对象销毁过程中――译者) 可以使用函数对象来管理生存期问题。语言中关於对象的局部构造和异常机制对这项技术提供了支持。
某些语言的狂热支持者总是用讽刺漫画的笔法描述C++，然而C++实际上要好得多。特别是我觉得很多其他的特性已经泛滥不堪了，在C++中，通常这些特性能够很容易的被模拟出来。相反的，新的语言在推广的过程中总是不断地增加新的特性，这就是为什麽从一种语言诞生到被广泛使用，其体积通常会增加个两三倍。
目前，最为个人和组织，对於C++的最好投资就是去更好地理解标准C++和现代的C++设计编程技术。大多数人使用C++的方式实际上停留80年代中期的水平，甚至比那更陈旧。
至於模块依赖性问题，我的观点是，在编程语言的工作和系统的工作之间应该有一个明显的界线，依赖关系应该尽可能地与编程语言分开，而由系统来支持。
我不认为组建版本的问题应该由编程语言来解决，这是一个系统范畴里的问题，在语言里应该通过提供相应的库来解决。C++有这样的机制。
解决这样的问题不会使C++偏离轨道。但是给C++增加很多特殊的特性就会使C++偏离轨道，而且在保持可移植性和平台独立性方面也会是一个倒退。
10. 标准C++推出有段时间了，Java也大踏步地往前走而且取得了显着的进步，您现在怎麽比较Java与C++？您觉得Java想要变成像C++一样"好" 的语言还需要做些什麽？您举的C++从Java身上学到了什麽经验吗？有没有什麽Java的特性您认为是可以被C++吸纳的？
我不比较语言。做好这项工作是十分困难的，而且很少具有专业水准。
我认为C++的进步会是主要以它的用户在使用中遇到的问题以及其自身逻辑为基础。当然，其他语言中的某些思想也会被考虑，但不能被简单的移花接木过来。你必须审视那些机制在技术上和思想上的背景，并且找到在C++中支持这些技术的最佳方案。
有 时最好的选择是综合使用几种语言。毕竟没有任何一种语言是放之四海而皆优的。C++现在是，将来也继续会是在广泛应用领域中最好的语言之一。但是，我们不 能被拉下水，不能把所有可能的特性都加到C++里面来向大众献媚。我认为Java和C++现在和将来都会是十分不同的语言，语法相似，但背後的对象模型明 显不同。
对於我来说，一个很重要的区别是C++有一个ISO标准，而Java则是一个专有语言。
11. 在Java刚刚出现的那几年，有很多欺骗性的言论说它将会是终极语言，会取代C++。您觉得在过去两三年里Java对C++的追随者们有什麽影响？
到现在关於Java的不实之辞也还随处可见。暂且不提Java在过去5年间的创纪录的发展，狂热的大众似乎认为 Java将最终取代的不仅仅是C++，而且还有所有其他的编程语言。但在另一方面，C++的使用仍在继续增长。我不认为Java对於C++的影响已经使得 人们转而把本来打算用来创造更好的C++工具库的资源调过去开发Java工具库。Java对於学习编程的人来说没有太多的新东西，所以对於C++的定义也 没什麽影响。在那个领域，Java还得努力追赶。例如，我认为为Sun迟早会往Java里加入类似模板的机制。
人们应该认识到C++和Java的目标是何等的不同。 以C++的设计理念来衡量Java，或是以Java的设计理念来衡量C++，得出的结论都不会很好。在访谈即将结束时，或许我该再次表明态度：C++仍然是我喜爱的语言，在写代码时你会发现没有那种语言能像它那样在如此广泛的应用领域和平台上同时达成如此的高效与精致。
2007年8月21日星期二
Difference between Java versions. etc.
学校的课本介绍的是 1.3版本的 JDK，现在用的是 1.6版本的 JDK，发现一些区别(不知道是不是课本上写错了)。
// version 1.3
String str = new String("Java string");
str.concat("-test");
// str 现在的值是 Java string-test
// version 1.6
String str = new String("Java string");
str.concat("-test");
// str 现在的值是 Java string
在 BBS 上又发现了 Tie::File 模块，可以像操作 array 一样操作文件，真的很方便 :)
#! /usr/bin/perl
use warnings;
use strict;
{
no strict; # Tie::File 需取消 strict
use Tie::File;
my @msc;
tie @msc, Tie::File, ' MSC' or die $!;
# ---- 删除以 = 开头的行 ----
my $line_counter = 0;
for (@msc) {
if ( /^=/) { splice(@msc, $line_counter, 1) }
$line_counter++;
}
untie @msc;
}
又发掘了 vim 的一项强大功能，文档查找。shift+k 可以在指定的文档中查找当前关键字，而且可以设定编辑不同类型的文件时查找不同的文档。 Cool
autocmd FileType perl set keywordprg=perldoc\ -f
// version 1.3
String str = new String("Java string");
str.concat("-test");
// str 现在的值是 Java string-test
// version 1.6
String str = new String("Java string");
str.concat("-test");
// str 现在的值是 Java string
在 BBS 上又发现了 Tie::File 模块，可以像操作 array 一样操作文件，真的很方便 :)
#! /usr/bin/perl
use warnings;
use strict;
{
no strict; # Tie::File 需取消 strict
use Tie::File;
my @msc;
tie @msc, Tie::File, ' MSC' or die $!;
# ---- 删除以 = 开头的行 ----
my $line_counter = 0;
for (@msc) {
if ( /^=/) { splice(@msc, $line_counter, 1) }
$line_counter++;
}
untie @msc;
}
又发掘了 vim 的一项强大功能，文档查找。shift+k 可以在指定的文档中查找当前关键字，而且可以设定编辑不同类型的文件时查找不同的文档。 Cool
autocmd FileType perl set keywordprg=perldoc\ -f
2007年8月7日星期二
Big Prime number
HOHO~ 大数版本的 big_prime_judge ，使用了 Math::BigInt 模块。办公室的计算机 CPU 是 Celeron D 3G Hz ，计算超过 14 位的数就非常慢。文档中说使用 Math::BigInt::GMP 会快一些，但是我喜欢用标准库和纯 perl 的东西 ^^ ，何况如果需要计算更大的数值就要用 C++ 写了。
用 big_prime_judge 判断 100个 16位十进制数在 PIII 上耗时 9小时56分钟， 判断 100个 17位十进制数算了 20个小时，还没算出来的时候停电了 m( _ _ )m 下次没事的时候看看 java 的速度怎么样。
PIII 机器：
Pentium III(Coppermine 864.793Hz cache size: 256KB)
RAM: 192 MB
OS: Fedora Core 4 (kernel 2.6.11)
use Math::BigInt ;
sub big_prime_judge {
my $n = $_[0];
return 1 if ($n == 2);
return 1 if ($n == 3);
return 1 if ($n == 5);
return 1 if ($n == 7);
return 0 if ($n == 1);
return 0 if ($n->copy->is_even());
return 0 if ($n->copy->bmod(5) == 0 );
my $factor = $n->copy->bsqrt() + 1;
my $i = Math::BigInt->new(' 3');
for (; $i<=$factor ; $i+=2)
{ return 0 if ($n->copy->bmod($i->copy()) == 0) }
return 1;
}
用 big_prime_judge 判断 100个 16位十进制数在 PIII 上耗时 9小时56分钟， 判断 100个 17位十进制数算了 20个小时，还没算出来的时候停电了 m( _ _ )m 下次没事的时候看看 java 的速度怎么样。
PIII 机器：
Pentium III(Coppermine 864.793Hz cache size: 256KB)
RAM: 192 MB
OS: Fedora Core 4 (kernel 2.6.11)
use Math::BigInt ;
sub big_prime_judge {
my $n = $_[0];
return 1 if ($n == 2);
return 1 if ($n == 3);
return 1 if ($n == 5);
return 1 if ($n == 7);
return 0 if ($n == 1);
return 0 if ($n->copy->is_even());
return 0 if ($n->copy->bmod(5) == 0 );
my $factor = $n->copy->bsqrt() + 1;
my $i = Math::BigInt->new(' 3');
for (; $i<=$factor ; $i+=2)
{ return 0 if ($n->copy->bmod($i->copy()) == 0) }
return 1;
}
2007年8月6日星期一
Perl Java
javascript 看着有点晕，把大学时候的 java 课本翻来出来，还是用 java 吧。还好，总算是学过的，语法用起来还挺轻松。通过两年前的 C++ 学习，我已经深得 OO 之精华 ^_^ 。
晚上把 java 书上的一个例子用 perl 写了一遍，竟然提示编译错误，上下看几遍才发现漏了几个 perl 的变量前缀。汗，看来头脑里已经出现语言混乱的情况了。
晚上把 java 书上的一个例子用 perl 写了一遍，竟然提示编译错误，上下看几遍才发现漏了几个 perl 的变量前缀。汗，看来头脑里已经出现语言混乱的情况了。
2007年8月2日星期四
IBM Power6
IBM 公布了 Power6 处理器详细的信息。IBM Power6 的频率高达 4.7GHz！而且是64位的双核心产品，速度远高过前辈Power5一倍左右，但是依然只损耗相同的电量。
IBM 利用先进的65nm制程技术打造出这颗Power6处理器，并由7.9亿晶体管所搭成，拥有8MB L2 Cache，为了能跟上处理器速度，还拥有300GB/s的频宽。
家里现在的计算机是 AMD 3800+ 64bit 双核，2GHz 主频，比起 Power6 来还差远了。HOHo 什么时候 PC 上的处理器能像 Power6 这么强劲就爽了，不过应该不用太长时间，也就是 1、2 年的事。
下面这幅图是 IBM 的工程师在检查 Power6 处理器
IBM 利用先进的65nm制程技术打造出这颗Power6处理器，并由7.9亿晶体管所搭成，拥有8MB L2 Cache，为了能跟上处理器速度，还拥有300GB/s的频宽。
家里现在的计算机是 AMD 3800+ 64bit 双核，2GHz 主频，比起 Power6 来还差远了。HOHo 什么时候 PC 上的处理器能像 Power6 这么强劲就爽了，不过应该不用太长时间，也就是 1、2 年的事。
下面这幅图是 IBM 的工程师在检查 Power6 处理器
2007年7月30日星期一
Goldbach Conjecture
验证哥德巴赫猜想：
my $n;
for (my $k=9999999000; $k<9999999999; $k +=2) {
$n = goldbach($k);
print "$k -> $n ", $k - $n , "\n";
}
# 由外部代码负责校验传给函数的参数正确：不小于6的偶数。
sub goldbach {
my $number = $_[0];
for (my $i=3; $i<=($number/2); $i+= 2) {
next unless (prime_judge($i));
return $i if (prime_judge($number - $i));
}
return 0;
}
sub prime_judge {
my $n = $_[0];
return 1 if ($n == 2);
return 0 unless ($n % 2);
my $factor = int(sqrt($n)) + 1;
for (my $i=3; $i<=$factor; $i+=2)
{ return 0 unless ($n % $i) }
return 1;
}
my $n;
for (my $k=9999999000; $k<9999999999; $k +=2) {
$n = goldbach($k);
print "$k -> $n ", $k - $n , "\n";
}
# 由外部代码负责校验传给函数的参数正确：不小于6的偶数。
sub goldbach {
my $number = $_[0];
for (my $i=3; $i<=($number/2); $i+= 2) {
next unless (prime_judge($i));
return $i if (prime_judge($number - $i));
}
return 0;
}
sub prime_judge {
my $n = $_[0];
return 1 if ($n == 2);
return 0 unless ($n % 2);
my $factor = int(sqrt($n)) + 1;
for (my $i=3; $i<=$factor; $i+=2)
{ return 0 unless ($n % $i) }
return 1;
}
Max common divisor
两个正整数最大公约数的欧几里德算法：
sub max_common_divisor {
my($m, $n) = @_;
my $residue = 0;
while (1) {
$residue = $m % $n;
return $n unless ($residue);
$m = $n;
$n = $residue;
}
}
sub max_common_divisor {
my($m, $n) = @_;
my $residue = 0;
while (1) {
$residue = $m % $n;
return $n unless ($residue);
$m = $n;
$n = $residue;
}
}
2007年7月29日星期日
Prime number
判断一个整数是否素数。刚才在网上搜了一下，竟然发现有人在到处找什么一百万以内、一亿以内的素数表，纳闷ing...，几行代码不就出来了么？还找个什么劲。
sub prime_judge {
my $n = $_[0];
return 1 if ($n == 2); # 2 是唯一的偶数素数
return 0 unless ($n % 2); # 其它偶数为非素数
my $factor = int(sqrt($n)) + 1;
for (my $i=3; $i<=$factor; $i+=2)
{ return 0 unless ($n % $i) }
return 1;
}
sub prime_judge {
my $n = $_[0];
return 1 if ($n == 2); # 2 是唯一的偶数素数
return 0 unless ($n % 2); # 其它偶数为非素数
my $factor = int(sqrt($n)) + 1;
for (my $i=3; $i<=$factor; $i+=2)
{ return 0 unless ($n % $i) }
return 1;
}
2007年7月28日星期六
LaTeX note
看了 CTeX 的 LaTeX 入门视频教程，复习一下 LaTeX 最基本的知识。原来我的文档标题、作者、日期信息都是写在导言区的，现在才知道也可以写在文档环境中(\begin{document} 后面)，而且写在文档环境中应该在语法上更符合逻辑。
\makebox[ width][pos]{ text} TEXT
参数 width 是指盒子的宽度，参数 pos 接受一个字符，决定 text 的排列：c-居中、l-靠左、r-靠右、s-将文本均匀分布到整个盒子中。若盒子的宽度小于 text 的宽度，则 text 多出的部分就会与后继的文字 TEXT 重叠。
for example: \makebox[1cm][c]{测试 makebox 指令} 重叠部分
\framebox 和 \makebox 完成同样的功能，只是 \framebox 将在包含的文字周围画一个矩形框。
若文档中有中文字符，需要引用 color 宏包时，应将 color 宏包的引用指令写在 \begin{CJK}{GBK}{fs}后面，否则可能造成编译错误。即：
\begin{CJK}{GBK}{fs}
\usepackage{color}
指令 \textcolor{color}{text} 为text着色，
指令 \colorbox{color}{text} 为text加底色
\makebox[ width][pos]{ text} TEXT
参数 width 是指盒子的宽度，参数 pos 接受一个字符，决定 text 的排列：c-居中、l-靠左、r-靠右、s-将文本均匀分布到整个盒子中。若盒子的宽度小于 text 的宽度，则 text 多出的部分就会与后继的文字 TEXT 重叠。
for example: \makebox[1cm][c]{测试 makebox 指令} 重叠部分
\framebox 和 \makebox 完成同样的功能，只是 \framebox 将在包含的文字周围画一个矩形框。
若文档中有中文字符，需要引用 color 宏包时，应将 color 宏包的引用指令写在 \begin{CJK}{GBK}{fs}后面，否则可能造成编译错误。即：
\begin{CJK}{GBK}{fs}
\usepackage{color}
指令 \textcolor{color}{text} 为text着色，
指令 \colorbox{color}{text} 为text加底色
2007年7月24日星期二
Customize LaTeX
创建新的命令：
自定义宏包：
写一个宏包的基本工作就是把原本很长的文档导言写入一个分离的文件中，这个文件的扩展名是 .sty ，并且在这个文件的开头要使用一个特殊命令 \Providespackage{ package name} ，它用于告诉 LaTeX 宏包的名称，从而允许 LaTeX 在你尝试重复引入同一个宏包的时候给出错误提示。
- \newcommand{name}[num]{ definition} 第一个参数 name 是想要创建的命令名称，参数 definition 是命令的定义，参数 num 是可选的，用于指定命令所需的参数数目，最多可有 9 个参数，若省略此项，则不接受参数。创建的新命令不能与已有的命令重名
- \renewcommand 与上个命令语法相同，但可用于更改已有命令的定义。
- \providecommand 与上面的语法相同，当创建的新命令与已有命令重名时，新命令被忽略
- \newenvironment{name}[num]{ before}{after} 在参数 before 中提供的内容将在被命令包含的文本之前处理，而在参数 after 中提供的内容将恰好在 \end{name} 的前面处理。
- \renewenvironment{name}[num]{ before}{after} 与上面语法相同，但允许重新定义已有的环境。
自定义宏包：
写一个宏包的基本工作就是把原本很长的文档导言写入一个分离的文件中，这个文件的扩展名是 .sty ，并且在这个文件的开头要使用一个特殊命令 \Providespackage{ package name} ，它用于告诉 LaTeX 宏包的名称，从而允许 LaTeX 在你尝试重复引入同一个宏包的时候给出错误提示。
2007年7月17日星期二
Google vs. China
这篇 blog 的标题本来是 "Google vs. baidu" ，想了想改成现在的名字，因为 Google 在中国市场面对的不仅仅是 baidu 。
近几天在 ChinaUnix bbs 和国内几个网站的新闻上攻击 Goolge 的评论和新闻突然多了起来，说 Google 的中文搜索质量不好、服务不好、做流氓软件搞软件捆绑等等。
Google 作为一个成功的企业到中国开拓市场，虽然有着强大的资金、技术支持，但也遇到了特殊的困难：
我现在常用的 Google 服务： 搜索引擎(几乎离不开的)、picasaweb(网络图册)、blogger(blog服务)、Gmail(邮件)、igoogle(个性化主页)、Google 日历、Google 工具条、Google 桌面，另外 Google 实验室还提供了许多实用有趣的工具，例如 Google 趋势、机器翻译等。
一个电视节目把 Google 搜索引擎出现之前的互联网时期称为"互联网的黑暗时代"，一点都不过分。Google 模式的搜索引擎在互联网上起到的作用，每一个使用 Internet 的人都应该有深切体会。
blogger 提供了强大的 blog 服务，自由的、可完全定制的模板，可以方便地通过 email 发布日志(同时起到了备份的效果) 。可惜 blogspot 在国内登录不了，只能通过 ftp 转发。
加上 Gmail 我用过 8个(有7个是国内的)免费邮件服务，Gmail 是唯一不在邮件内容中添加广告的。
igoogle 可以在简洁的 Google 搜索首页添加各种个性化的、有趣实用的工具。我在上面添加了收藏夹，嘿嘿，再也不用为重装系统丢了收藏夹郁闷了，而且在任何一台机器上都可以用。
现在许多软件中都捆绑了 Google 工具条，但是把 Google 工具条定义为流氓软件纯属恶意攻击。首先，Google 工具条在安装前有明确的提示和选项，用户可以选择不安装它，而且不会对捆绑了 Google 工具条的软件造成任何影响。其次，在需要卸载 Google 工具条的时候，可以方便地彻底卸载它。更何况对于使用 Google 搜索的用户来说，它确实是一个非常方面实用的小工具。这样的软件能称为流氓软件么？
为什么像 IE 那样流氓的捆绑方式、像中文网址那样流氓的强制安装都没多少人质疑，却有人不遗余力地攻击 Google 工具条，是不是另有隐情？
还有非常重要的一点就是：Google 对于不同操作系统，尤其是 Unix-like 的系统兼容性非常好。指望国内公司开发 Linux 应用看来是够呛。Google DeskTop 已经出了 for Linux 版本，希望 Linux 下的 Google 应用越来越丰富，越来越好。
近几天在 ChinaUnix bbs 和国内几个网站的新闻上攻击 Goolge 的评论和新闻突然多了起来，说 Google 的中文搜索质量不好、服务不好、做流氓软件搞软件捆绑等等。
Google 作为一个成功的企业到中国开拓市场，虽然有着强大的资金、技术支持，但也遇到了特殊的困难：
- 本土化人才，虽然 Google在美国和其它国家获得了巨大的成功，但基本上它以前的搜索主要是面向英语和其它一些西方语言的，做中文搜索，还需要有好的了解中文和中国文化的技术专家；
- 中国特色，Google 本来坚守的"Don't be evil"信条在进军中国市场的途中受到严峻的挑战。Googlepages 被封了，blogger 被封了，搜索结果被过滤了
我现在常用的 Google 服务： 搜索引擎(几乎离不开的)、picasaweb(网络图册)、blogger(blog服务)、Gmail(邮件)、igoogle(个性化主页)、Google 日历、Google 工具条、Google 桌面，另外 Google 实验室还提供了许多实用有趣的工具，例如 Google 趋势、机器翻译等。
一个电视节目把 Google 搜索引擎出现之前的互联网时期称为"互联网的黑暗时代"，一点都不过分。Google 模式的搜索引擎在互联网上起到的作用，每一个使用 Internet 的人都应该有深切体会。
blogger 提供了强大的 blog 服务，自由的、可完全定制的模板，可以方便地通过 email 发布日志(同时起到了备份的效果) 。可惜 blogspot 在国内登录不了，只能通过 ftp 转发。
加上 Gmail 我用过 8个(有7个是国内的)免费邮件服务，Gmail 是唯一不在邮件内容中添加广告的。
igoogle 可以在简洁的 Google 搜索首页添加各种个性化的、有趣实用的工具。我在上面添加了收藏夹，嘿嘿，再也不用为重装系统丢了收藏夹郁闷了，而且在任何一台机器上都可以用。
现在许多软件中都捆绑了 Google 工具条，但是把 Google 工具条定义为流氓软件纯属恶意攻击。首先，Google 工具条在安装前有明确的提示和选项，用户可以选择不安装它，而且不会对捆绑了 Google 工具条的软件造成任何影响。其次，在需要卸载 Google 工具条的时候，可以方便地彻底卸载它。更何况对于使用 Google 搜索的用户来说，它确实是一个非常方面实用的小工具。这样的软件能称为流氓软件么？
为什么像 IE 那样流氓的捆绑方式、像中文网址那样流氓的强制安装都没多少人质疑，却有人不遗余力地攻击 Google 工具条，是不是另有隐情？
还有非常重要的一点就是：Google 对于不同操作系统，尤其是 Unix-like 的系统兼容性非常好。指望国内公司开发 Linux 应用看来是够呛。Google DeskTop 已经出了 for Linux 版本，希望 Linux 下的 Google 应用越来越丰富，越来越好。
2007年7月16日星期一
emule_Perl_JavaScript_etc.
公司封了 bt 的端口，现在改用 emule 了，HOHO~ 从软件授权来看我还是比较喜欢 emule ，但似乎在国内从资源方面来说，还是 bt 要丰富一些。
Perl 现在对我来说有几个问题：
论坛上看到有人用 javascript 写程序，挺好玩，一直对 java 没有好感，感觉 java 太复杂了(主要是 JVM 安装太麻烦，资源占用也比较大)，所以也没有认真看 javascript，虽然知道它们不是一回事，但名字也看着不爽。为了考虑改进我的 blog 模板，弥补一下 Perl 的部分空白，从网上下载了一部"JavaScript权威指南第四版"，是扫描版的，代码部分很模糊。
Perl 现在对我来说有几个问题：
- 发布不方便，尤其需要用到标准发布版以外的模块时。在 windows 上用 PPM 安装，需要连接 Internet ，如果编译安装，windows 本身又没有 C/C++ 编译器，要另外安装(windows垃圾点之一)。
- 编写图形界面的程序不方便
- 操作 windows 系统不太方便，这也是 windows 造成的问题。
论坛上看到有人用 javascript 写程序，挺好玩，一直对 java 没有好感，感觉 java 太复杂了(主要是 JVM 安装太麻烦，资源占用也比较大)，所以也没有认真看 javascript，虽然知道它们不是一回事，但名字也看着不爽。为了考虑改进我的 blog 模板，弥补一下 Perl 的部分空白，从网上下载了一部"JavaScript权威指南第四版"，是扫描版的，代码部分很模糊。
2007年7月10日星期二
Multi-processes
使用 fork() 时需要注意的问题：
1. 记录 fork 出的子进程 id，收割进程时验证
2. parent process 和 child process 有各自独立的进程空间
3. 使用 exit 结束 child process
4. 已没有需要回收的 child process 时 wait() 返回 -1
下面是测试局域网中机器联网状态的程序(使用 icmp 扫描，可接收到反馈则认为已联网)。
#! /usr/bin/perl
use warnings;
use strict;
my $host_prefix = '192.168.0.';
my @hosts;
for ( 80 .. 200) {
my $host = $host_prefix . " $_";
push(@hosts, $host);
}
my $number_of_process = 20;
my %counter_process;
use Net::Ping;
my $p = Net::Ping->new('icmp', 2);
for my $h (@hosts) {
if (keys(%counter_process) > $number_of_process)
{ reap_process(\%counter_process) }
if (my $process = fork)
{ $counter_process{$process} = $h }
elsif (defined($process)) {
if ($p->ping($h)) { print "$h is alive\n" }
else { print "$h is not alive \n" }
exit 0;
} else { die "Something wrong at this $! " }
}
$p->close;
1 while (reap_process(\%counter_process ));
# functions definition -----------------
sub reap_process {
my $process_hash = $_[0];
my $pid = wait;
return 0 if ( $pid == -1);
delete($process_hash->{$pid}) or warn(" Cannot see $pid\n");
1; # if reap a child
}
1. 记录 fork 出的子进程 id，收割进程时验证
2. parent process 和 child process 有各自独立的进程空间
3. 使用 exit 结束 child process
4. 已没有需要回收的 child process 时 wait() 返回 -1
下面是测试局域网中机器联网状态的程序(使用 icmp 扫描，可接收到反馈则认为已联网)。
#! /usr/bin/perl
use warnings;
use strict;
my $host_prefix = '192.168.0.';
my @hosts;
for ( 80 .. 200) {
my $host = $host_prefix . " $_";
push(@hosts, $host);
}
my $number_of_process = 20;
my %counter_process;
use Net::Ping;
my $p = Net::Ping->new('icmp', 2);
for my $h (@hosts) {
if (keys(%counter_process) > $number_of_process)
{ reap_process(\%counter_process) }
if (my $process = fork)
{ $counter_process{$process} = $h }
elsif (defined($process)) {
if ($p->ping($h)) { print "$h is alive\n" }
else { print "$h is not alive \n" }
exit 0;
} else { die "Something wrong at this $! " }
}
$p->close;
1 while (reap_process(\%counter_process ));
# functions definition -----------------
sub reap_process {
my $process_hash = $_[0];
my $pid = wait;
return 0 if ( $pid == -1);
delete($process_hash->{$pid}) or warn(" Cannot see $pid\n");
1; # if reap a child
}
2007年7月4日星期三
Echo's story
记得在 BASH 中的 echo 命令么？在希腊神话中，Echo 是一位最漂亮的仙女，也是一位最不幸的女神。Zeus(众神之王宙斯)爱上了 Echo，Hera(Zeus的lp赫拉)便迁怒于 Echo，罚她永远不能说自己的话，只能重复别人对她说过的话。
然而 Echo 爱上了 Narcissus。他是一位英俊而高傲的美男子，每一个见过他的姑娘都会深深爱上他，可 Narcissus 却对她们不屑一顾。
Echo 对他最为痴情，但她却不能对 Narcissus 倾吐衷肠，只能像影子一样追随着他。无情的 Narcissus 对 Echo 很反感，竟对她说："你别梦想我会为你着迷！"可怜的 Echo 只能不断重复："我为你着迷！我为你着迷！……" Narcissus 却拂袖而去。
羞愧万分的 Echo 躲进山洞，终日少言寡语，形销骨立，直到整个玉体全部消失，只留下她的声音，在山洞里日复一日地重复着别人说的话。
Echo 这个词也因此进入英语中，有回音、回声、重复、随声附和之意。残酷无情的 Narcissus 也因爱恋自己在水中的倒影，最终憔悴而死，化成一朵水仙花。Narcissus 和水仙花也成为自恋的象征。
然而 Echo 爱上了 Narcissus。他是一位英俊而高傲的美男子，每一个见过他的姑娘都会深深爱上他，可 Narcissus 却对她们不屑一顾。
Echo 对他最为痴情，但她却不能对 Narcissus 倾吐衷肠，只能像影子一样追随着他。无情的 Narcissus 对 Echo 很反感，竟对她说："你别梦想我会为你着迷！"可怜的 Echo 只能不断重复："我为你着迷！我为你着迷！……" Narcissus 却拂袖而去。
羞愧万分的 Echo 躲进山洞，终日少言寡语，形销骨立，直到整个玉体全部消失，只留下她的声音，在山洞里日复一日地重复着别人说的话。
Echo 这个词也因此进入英语中，有回音、回声、重复、随声附和之意。残酷无情的 Narcissus 也因爱恋自己在水中的倒影，最终憔悴而死，化成一朵水仙花。Narcissus 和水仙花也成为自恋的象征。
Area of Squares
#! /usr/bin/perl
use warnings;
use strict;
=problem
author: redspid@gmail.com
计算下图中所有正方形的面积之和
_____________
|__|__|__|__|__| 00 01 02 03 04 05
|__|__|__|__|__| 10 11 12 13 14 15
|__|__|__|__|__| 20 21 22 23 24 25
|__|__|__|__|__| 30 31 32 33 34 35
|__|__|__|__|__| 40 41 42 43 44 45
|__|__|__|__|__| 50 51 52 53 54 55
=cut
# 开启整数环境。使用整数环境后，
# 可计算大正方形的最大边长减小，因整数数值范围比浮点数小
# 但计算速度有所提升。
# dprofpp 测试结果显示：
# 大正方形边长为 120个单位时速度约提升 5% 。
# 大正方形边长越大，速度提升越明显。
use integer;
my $n = 20; # 大正方形边长
my $area = 0;
for my $row (0 .. $n- 1) {
for my $col (0 .. $n- 1) {
my $m = $row > $col ? $n-$row : $n-$col;
if ( $m == 1) { $area += 1 }
else { for my $i (1 .. $m ) { $area += $i *$i } }
}
}
print $area, "\n";
use warnings;
use strict;
=problem
author: redspid@gmail.com
计算下图中所有正方形的面积之和
_____________
|__|__|__|__|__| 00 01 02 03 04 05
|__|__|__|__|__| 10 11 12 13 14 15
|__|__|__|__|__| 20 21 22 23 24 25
|__|__|__|__|__| 30 31 32 33 34 35
|__|__|__|__|__| 40 41 42 43 44 45
|__|__|__|__|__| 50 51 52 53 54 55
=cut
# 开启整数环境。使用整数环境后，
# 可计算大正方形的最大边长减小，因整数数值范围比浮点数小
# 但计算速度有所提升。
# dprofpp 测试结果显示：
# 大正方形边长为 120个单位时速度约提升 5% 。
# 大正方形边长越大，速度提升越明显。
use integer;
my $n = 20; # 大正方形边长
my $area = 0;
for my $row (0 .. $n- 1) {
for my $col (0 .. $n- 1) {
my $m = $row > $col ? $n-$row : $n-$col;
if ( $m == 1) { $area += 1 }
else { for my $i (1 .. $m ) { $area += $i *$i } }
}
}
print $area, "\n";
2007年6月27日星期三
O'Reilly radar
http://radar.oreilly.com Oreilly 雷达 -- 技术类 Blog
这是你能够阅读到 Tim O'Reilly(著名的 O'Reilly 出版公司的创始人)和其它人讨论有关于网络、编程、开放源代码运动、知识产权、政策、Web 2.0 和其它前沿科技的地方。 每一篇 blog 还有语音阅读，可以练习英语听力 :)
这是你能够阅读到 Tim O'Reilly(著名的 O'Reilly 出版公司的创始人)和其它人讨论有关于网络、编程、开放源代码运动、知识产权、政策、Web 2.0 和其它前沿科技的地方。 每一篇 blog 还有语音阅读，可以练习英语听力 :)
O'Reilly Media,Inc. 是世界上在 UNIX、X、Internet 和其他开放系统图书领域具有领导地位的出版公司，同时是联机出版的先锋。尤其是在自由软件和开放源代码软件图书上占据着绝对领先的位置。
从最畅销的《The Whole Internet User's Guide & Catalog》（被纽约公共图书馆评为二十世纪最重要的50本书之一）到 GNN（最早的Internet门户和商业网站），再到 WebSite（第一个 桌面 PC 的 Web 服务器软件），O'Reilly Meida,Inc .一直处于 Internet 发展的最前沿。
我通过阅读 O'Reilly 出版的图书，学习了 Perl、MySQL、CSS 。O'Reilly 的图书作者大部分都是所在领域的专家、学者，更多是有实际经验的工程师，他们了解所有的技术实现细节，了解读者的需求。如果对计算机某个领域有兴趣，毫无疑问，O'Reilly 的图书是最好的向导。只是现在出版的很多书籍都没有中文版本，不过没关系，看原著吧，专家和工程师们已经用最朴实简洁的表达描绘了我们想知道和应该知道的一切。 :)
many jokes :)
"我看不清太远的东西，"病人对眼科医生说。
"请跟我来，"医生把病人带到外面，用手指着天上的太阳，问道，"你看那是什么？"
"太阳。"病人回答。
"那你还想看多远！"
----------------------------------
有一位病人来找精神科医师.
病人: 我一直觉得我是一只鸟.
医生: 喔.那很严重喔.从什么时候开始的?
病人: 从我还是一只小鸟的时候.
----------------------------------
有两个神经病患，从病院里逃出来。两人跑啊跑，爬到一棵树上。其中一个人从树上跳下来滚啊滚的，然後抬起头对上面的人说：喂------你怎么还不下来啊---------？
上面的那个人回答他：不---行---啊------我还没有熟透-----------
-----------------------------------
精神病人甲问乙说："你看我最近完成的这本小说怎么样"？
乙看了看回答："不错不错，不过，就是人物多了点儿。"
这时，精神病院的护士进来说："你们把电话号码本给我放回去！"
-----------------------------------
两位精神病人A君B君同时康复，他们的主治医生对他们说："如果你们其中的一个人犯病了，另外一个人就要马上把他送会医院。
"突然一天，医生的电话铃响了起来，
原来是A君："不得了了，B君从今天早上开始爬在我家的厕所里，非说他是我的马桶。
""快，快把他送来啊！"
A君沉默片刻："那……我不就没马桶了吗？"
---------------------------------
有一个神经病院，那里住着很多神经病。一天，那里的院长为了观察一下患者们恢复的情况，想了一个办法。
就对这些患者说：你们都过来。
说着在墙上画了一个门， 说："今天，你们谁把这个门打开就可以回家了。"
精神病者们一听，便一拥而上，把那画的门围了起来。
院长觉得很失望，这时他发现有一个患者还坐在原来的位置没动，觉得还行，
就上前问到："你为什么不去开门？"
他看了看院长,偷偷的说："我这有钥匙。"
"请跟我来，"医生把病人带到外面，用手指着天上的太阳，问道，"你看那是什么？"
"太阳。"病人回答。
"那你还想看多远！"
----------------------------------
有一位病人来找精神科医师.
病人: 我一直觉得我是一只鸟.
医生: 喔.那很严重喔.从什么时候开始的?
病人: 从我还是一只小鸟的时候.
----------------------------------
有两个神经病患，从病院里逃出来。两人跑啊跑，爬到一棵树上。其中一个人从树上跳下来滚啊滚的，然後抬起头对上面的人说：喂------你怎么还不下来啊---------？
上面的那个人回答他：不---行---啊------我还没有熟透-----------
-----------------------------------
精神病人甲问乙说："你看我最近完成的这本小说怎么样"？
乙看了看回答："不错不错，不过，就是人物多了点儿。"
这时，精神病院的护士进来说："你们把电话号码本给我放回去！"
-----------------------------------
两位精神病人A君B君同时康复，他们的主治医生对他们说："如果你们其中的一个人犯病了，另外一个人就要马上把他送会医院。
"突然一天，医生的电话铃响了起来，
原来是A君："不得了了，B君从今天早上开始爬在我家的厕所里，非说他是我的马桶。
""快，快把他送来啊！"
A君沉默片刻："那……我不就没马桶了吗？"
---------------------------------
有一个神经病院，那里住着很多神经病。一天，那里的院长为了观察一下患者们恢复的情况，想了一个办法。
就对这些患者说：你们都过来。
说着在墙上画了一个门， 说："今天，你们谁把这个门打开就可以回家了。"
精神病者们一听，便一拥而上，把那画的门围了起来。
院长觉得很失望，这时他发现有一个患者还坐在原来的位置没动，觉得还行，
就上前问到："你为什么不去开门？"
他看了看院长,偷偷的说："我这有钥匙。"
2007年6月21日星期四
a joke
From ChinaUnix bbs:
前几天我正在办公室用电脑打公文时.... 老板走到我身边，一看到电脑萤幕之后竟然大摇其头。
然后老板又说：“我说啊，虽然电脑是你打报告而批准买给你的，但你也不能这样嘛！年轻人~”
于是在老板的坚决要求下.... 我很无奈，
只好把桌面上 ....
打的时候还在发抖~~
前几天我正在办公室用电脑打公文时.... 老板走到我身边，一看到电脑萤幕之后竟然大摇其头。
然后老板又说：“我说啊，虽然电脑是你打报告而批准买给你的，但你也不能这样嘛！年轻人~”
于是在老板的坚决要求下.... 我很无奈，
只好把桌面上 ....
打的时候还在发抖~~
2007年6月15日星期五
Traversing Contents in Perl
#! /usr/bin/perl
# 从一个目录开始，递归遍历此目录下的所有目录
use warnings;
use strict;
sub do_something {
open(FILE, '>', 'text_file.txt') or die $!;
print FILE 'Traversing Contents';
close FILE;
}
sub traversing {
chdir($_[0]);
my @files = glob('*');
for my $f (@files) {
if (-d $f) {
over_d($f);
do_something(); # 此行在开始的目录下不执行
chdir('..');
}
}
}
# main
traversing('./'); # 从当前目录开始, let's go :)
# 从一个目录开始，递归遍历此目录下的所有目录
use warnings;
use strict;
sub do_something {
open(FILE, '>', 'text_file.txt') or die $!;
print FILE 'Traversing Contents';
close FILE;
}
sub traversing {
chdir($_[0]);
my @files = glob('*');
for my $f (@files) {
if (-d $f) {
over_d($f);
do_something(); # 此行在开始的目录下不执行
chdir('..');
}
}
}
# main
traversing('./'); # 从当前目录开始, let's go :)
IBM - Blue Gene
2006年11月，在刚公布的全球超级计算机500强榜单中，基于IBM Power技术的超级计算机数量的大量增加帮助 IBM 在全球超级计算机500强榜单上继续保持排名第一。IBM的系统在全球最强大的500台超级计算机中占据了237台，同时占据了总处理能力的49.6%。
IBM 与美国能源部国家核安全管理局共同开发并安装在 Lawrence Livermore 国家实验室中的 IBM Blue Gene/L 系统在排行榜上名列第一，其连续计算性能高达每秒钟 280.6Teraflop(或每秒数万亿次浮点运算)。另外，基于 IBM BladeCenter JS21刀片服务器并安装在巴塞罗那超级计算中心的 IBM 超级计算机 MareNostrum 重新夺得欧洲最强大超级计算机的称号。
与今年6月公布的上一次榜单相比，基于 Power 架构的系统的数量从83个增加到91个，IBM 在不同计算平台上的优势进一步推进了 IBM 业界的领先地位。与上次榜单相比，Blue Gene 系统的数量从24个增加到了28个，而基于 AMD Opteron 的 IBM 集群系统的数量从31个增加到了55个。
自2006年 6月公布上次全球超级计算机500强榜单以来，IBM BladeCenter 系统的数量从132个增加到145个。在11月公布的榜单中，基于 IBM BladeCenter 技术的系统提供了超过636Teraflop的总性能。IBM BladeCenter 系统通过将服务器、存储、网络和软件全部融合在一个系统之中，为客户提供了一种创新和高密度的计算解决方案。
IBM 深度计算部门副总裁Dave Turek表示："IBM 继续保持了在超级计算领域的领先地位，这同我们能够为客户提供当前业界最广泛的高性能计算解决方案系列是分不开的。IBM 的系统在很多情况下都是通过与我们客户的合作来完成设计和部署的，这些系统正在拓展科学发现的边界，并帮助我们的商业客户展现虚拟世界和高级仿真并推动实现深入创新。"
同 Lawrence Livermore 国家实验室的 Blue Gene/L 系统共同进入500强前5名的超级计算机包括 IBM 自己的性能达到91.29Teraflop的 Blue Gene/L Watson 系统、Lawrence Livermore 国家实验室的现在性能达到75.76Teraflop的 ASC Purple 超级计算机，以及巴塞罗那超级计算中心的 MareNostrum 超级计算机，这台使用全新JS21刀片服务器升级的超级计算机性能达到了62.63Teraflop， 比以前增加了一倍。其中，Blue Gene/L 系统和 Purple 系统都是属于美国国家核安全管理局高级仿真和计算(ASC)计划的系统，专门用于确保在无需进行地下核试验的情况下保证美国核武器库的安全性、保密性和可靠性。
在这次公布的全球超级计算机500强榜单上，超级计算机的计算性能总和达到3.527Petaflop，而 IBM 技术提供了其中超过1.75Petaflop的处理能力，比差距最小的竞争对手多出1Petaflop以上。IBM的系统在榜单上最强的10席中占据了4 席。另外，IBM 还在前100席中占据了44席。
全球超级计算机500强中有关IBM的重点内容：
在全球最强大的超级计算机前5名中占据了4个，它们是：Blue Gene/L系统(美国能源部/NNSA/LLNL，处理能力280.6Teraflop)、Watson 研究中心的 Blue Gene/W 系统、Lawrence Livermore 国家实验室的 ASC Purple 超级计算机，以及巴塞罗那超级计算中心的 MareNostrum JS21集群；
在全球超级计算机500强榜单中占据237个，占总数的47.4%；
在3527 Teraflop的已安装总处理能力中占据了1750 Teraflop的处理能力，占总处理能力的49.6%；
在前10名超级计算机中占据4个，是所占数量最多的单独厂商；
在前20名超级计算机中所占数量最多，达到6个，占30%；
在前100名超级计算机中所占数量最多，达到44个，占44%；
在全部361个集群系统中所占数量最多，达到171个，占47.3%；
美国速度最快的计算机――Lawrence Livermore 国家实验室的 Blue Gene/L 系统；
欧洲速度最快的计算机――巴塞罗那超级计算中心的 MareNostrum JS21集群。
另外，IBM 的4个全新 Blue Gene 系统也在这次全球超级计算机500强榜单上首次露面，其中一个系统安装在哈佛大学。
自2004 年11月 IBM 宣布以商业形式提供 IBM System Blue Gene 解决方案(该研究项目的商业版本)以来，全球超级计算机500强榜单上已经创纪录地出现了28个 Blue Gene 系统。基于 IBM Power 架构并经过专门优化的 IBM System Blue Gene 解决方案在提供处理大量数据所需的带宽、可扩展性和能力的同时，其功耗和占地空间仅相当于当今速度最快系统的一小部分。目前，IBM 与其合作伙伴正在开发一系列不断增长的高性能计算(HPC)应用，包括基于 Blue Gene 的生命科学、金融建模、流体力学、量子化学、分子力学，天文学、空间研究和气候建模等解决方案。
IBM 与美国能源部国家核安全管理局共同开发并安装在 Lawrence Livermore 国家实验室中的 IBM Blue Gene/L 系统在排行榜上名列第一，其连续计算性能高达每秒钟 280.6Teraflop(或每秒数万亿次浮点运算)。另外，基于 IBM BladeCenter JS21刀片服务器并安装在巴塞罗那超级计算中心的 IBM 超级计算机 MareNostrum 重新夺得欧洲最强大超级计算机的称号。
与今年6月公布的上一次榜单相比，基于 Power 架构的系统的数量从83个增加到91个，IBM 在不同计算平台上的优势进一步推进了 IBM 业界的领先地位。与上次榜单相比，Blue Gene 系统的数量从24个增加到了28个，而基于 AMD Opteron 的 IBM 集群系统的数量从31个增加到了55个。
自2006年 6月公布上次全球超级计算机500强榜单以来，IBM BladeCenter 系统的数量从132个增加到145个。在11月公布的榜单中，基于 IBM BladeCenter 技术的系统提供了超过636Teraflop的总性能。IBM BladeCenter 系统通过将服务器、存储、网络和软件全部融合在一个系统之中，为客户提供了一种创新和高密度的计算解决方案。
IBM 深度计算部门副总裁Dave Turek表示："IBM 继续保持了在超级计算领域的领先地位，这同我们能够为客户提供当前业界最广泛的高性能计算解决方案系列是分不开的。IBM 的系统在很多情况下都是通过与我们客户的合作来完成设计和部署的，这些系统正在拓展科学发现的边界，并帮助我们的商业客户展现虚拟世界和高级仿真并推动实现深入创新。"
同 Lawrence Livermore 国家实验室的 Blue Gene/L 系统共同进入500强前5名的超级计算机包括 IBM 自己的性能达到91.29Teraflop的 Blue Gene/L Watson 系统、Lawrence Livermore 国家实验室的现在性能达到75.76Teraflop的 ASC Purple 超级计算机，以及巴塞罗那超级计算中心的 MareNostrum 超级计算机，这台使用全新JS21刀片服务器升级的超级计算机性能达到了62.63Teraflop， 比以前增加了一倍。其中，Blue Gene/L 系统和 Purple 系统都是属于美国国家核安全管理局高级仿真和计算(ASC)计划的系统，专门用于确保在无需进行地下核试验的情况下保证美国核武器库的安全性、保密性和可靠性。
在这次公布的全球超级计算机500强榜单上，超级计算机的计算性能总和达到3.527Petaflop，而 IBM 技术提供了其中超过1.75Petaflop的处理能力，比差距最小的竞争对手多出1Petaflop以上。IBM的系统在榜单上最强的10席中占据了4 席。另外，IBM 还在前100席中占据了44席。
全球超级计算机500强中有关IBM的重点内容：
在全球最强大的超级计算机前5名中占据了4个，它们是：Blue Gene/L系统(美国能源部/NNSA/LLNL，处理能力280.6Teraflop)、Watson 研究中心的 Blue Gene/W 系统、Lawrence Livermore 国家实验室的 ASC Purple 超级计算机，以及巴塞罗那超级计算中心的 MareNostrum JS21集群；
在全球超级计算机500强榜单中占据237个，占总数的47.4%；
在3527 Teraflop的已安装总处理能力中占据了1750 Teraflop的处理能力，占总处理能力的49.6%；
在前10名超级计算机中占据4个，是所占数量最多的单独厂商；
在前20名超级计算机中所占数量最多，达到6个，占30%；
在前100名超级计算机中所占数量最多，达到44个，占44%；
在全部361个集群系统中所占数量最多，达到171个，占47.3%；
美国速度最快的计算机――Lawrence Livermore 国家实验室的 Blue Gene/L 系统；
欧洲速度最快的计算机――巴塞罗那超级计算中心的 MareNostrum JS21集群。
另外，IBM 的4个全新 Blue Gene 系统也在这次全球超级计算机500强榜单上首次露面，其中一个系统安装在哈佛大学。
自2004 年11月 IBM 宣布以商业形式提供 IBM System Blue Gene 解决方案(该研究项目的商业版本)以来，全球超级计算机500强榜单上已经创纪录地出现了28个 Blue Gene 系统。基于 IBM Power 架构并经过专门优化的 IBM System Blue Gene 解决方案在提供处理大量数据所需的带宽、可扩展性和能力的同时，其功耗和占地空间仅相当于当今速度最快系统的一小部分。目前，IBM 与其合作伙伴正在开发一系列不断增长的高性能计算(HPC)应用，包括基于 Blue Gene 的生命科学、金融建模、流体力学、量子化学、分子力学，天文学、空间研究和气候建模等解决方案。
Speed up the programes
判断数组是否为空，几种方法的效率比较：
Total Elapsed Time User+System Time
if($a[0]) 1 1
if(exists($a[0])) 1.23 1.22
if($#a) 2.03 2.02
if(@a) 2.10 2.09
Total Elapsed Time User+System Time
if($a[0]) 1 1
if(exists($a[0])) 1.23 1.22
if($#a) 2.03 2.02
if(@a) 2.10 2.09
System Watch & Management
uname -a 系统版本信息等
ps aux 当前进程
nice 进程优先级
renice 调整系统中已存在的进程优先级
fuser 使用某资源的进程
lsof 进程使用的资源
pidof 查看 PID
dmesg 核心启动信息
netstat 网络状态
ps aux 当前进程
nice 进程优先级
renice 调整系统中已存在的进程优先级
fuser 使用某资源的进程
lsof 进程使用的资源
pidof 查看 PID
dmesg 核心启动信息
netstat 网络状态
Input method
使用中文输入法的经历：应该是从 智能ABC 开始(用了5、6年)，全拼一开始就被我抛弃了，但是全拼输入法的字库比 ABC 全一点，有些字需要用全拼才能输入，所以电脑上一般都保留 智能ABC 和 全拼 两种输入法。在同事的推荐下改用 紫光拼音v6(大约用了两个月)，又在杨经理的推荐下转到 搜狗拼音。刚用紫光的时候感觉比 ABC 强多了，现在又感觉 搜狗 比紫光强多了，呵呵。
不久前 Google 盗用 搜狗 输入法词库的事情炒得沸沸扬扬，我相信 Google 的技术做出更好的输入法应该不是难事，但就目前而言，似乎 搜狗输入法 更胜一筹。
安装程序大小 google 8.9M，搜狗 7.7M；皮肤：搜狗可换，google不可换；输入效率和组词的准确率据网上评论(我现在还没用过google输入法) google输入法也没有太大的优势，所以暂时观望，等待 google 中文输入法的下个版本。
不久前 Google 盗用 搜狗 输入法词库的事情炒得沸沸扬扬，我相信 Google 的技术做出更好的输入法应该不是难事，但就目前而言，似乎 搜狗输入法 更胜一筹。
安装程序大小 google 8.9M，搜狗 7.7M；皮肤：搜狗可换，google不可换；输入效率和组词的准确率据网上评论(我现在还没用过google输入法) google输入法也没有太大的优势，所以暂时观望，等待 google 中文输入法的下个版本。
Google search
谷歌搜索遥遥领先 成功背后的秘密
2007.06.04 from:新浪科技 马丁
搜索是重中之重
随着企业规模不断扩大，谷歌开始向多个领域进军，包括网络地图、数字图书馆、视频共享以及桌面软件等等。但是，谷歌的重中之重仍然是搜索引擎。通过谷歌搜索引擎，用户可以在浩如烟海的大量信息中找到自己需要的内容。正因为有了出色的搜索引擎，谷歌才成为了访问量最大、利润最为丰厚、甚至最为强大的互联网公司。
不过，搜索引擎给谷歌招致的抱怨也最多。每天都有数百万用户在使用谷歌搜索引擎之后感到失望，因为他们无法找到自己需要的旅馆、医药处方、或者人物背景。谷歌经常能帮助用户找到想要的东西，但并非总能做到这一点。基于这一原因，阿米特・辛格哈尔(Amit Singhal)和其它数百名工程师一直致力于改进谷歌搜索引擎，希望能缩小"经常"和"总是"之间的差距。
互联网的生命之源
辛格哈尔是谷歌搜索引擎排名算法的大师。这一算法主要用于确定哪些网页是用户问题的最佳答案，它是谷歌核心团队――搜索质量部门的重要组成部分。长期来来，该部门一直是个谜，谷歌很少允许团队成员抛头露面。谷歌对辛格哈尔及其团队的评价非常高，将他们视为公司最为根本的竞争优势。谷歌认为，要想抵御来自雅虎和微软的强势入侵，就必须降低让用户失望的频度。而在这一过程中，搜索质量部门发挥着不可替代的作用。
Federated Media首席执行官约翰・巴特勒(John Battelle)表示："谷歌创建的核心价值就是排名算法。"数据显示，网络商店有四分之一到二分之一的访问者来自于搜索引擎；很多用户都无视媒体网站的网页，而是通过谷歌直接访问所需的特定页面。他说："从上述事实可以看出，谷歌已经成为了互联网的'生命之源'，谁也离不开它。"
用户无法看到搜索引擎背后的算法和艺术，但事实上，谷歌搜索质量团队每周都要对搜索引擎算法做数次改进。在他们的努力下，谷歌搜索引擎可以更加有效地理解用户的真实意图。例如，有些人搜索"苹果"是为了了解同水果相关的信息，有些人则在研究苹果公司的Mac或iPod。尽管搜索内容相同，但用户的意图却有着天壤之别。辛格哈尔表示："过去几年里，搜索已经由'给我输入的东西'转变为'给我想要的东西'。"
不为人知的内幕
辛格哈尔今年39岁，是一名印度人，于2000年加盟谷歌。他目前是一名谷歌研究员，这是谷歌专门为精英工程师设立的职位。不久前，一名《纽约时报》的记者获准采访了辛格哈尔和其它搜索质量团队成员。尽管谷歌对很多问题都讳忌莫深，但这名记者仍然获得了很多以前不为人知的内幕。
在谷歌不断改进搜索引擎的过程中，面临的最大挑战是日渐庞大的规模。目前，谷歌已经成为全球访问量最大的网站，支持112种语言，将数百亿个网页纳入索引，每天处理数亿次搜索请求。更为糟糕的是，很多网页创建的目的就是吸引眼球，里面充斥了大量的广告、色情内容和财务欺骗信息。因此，用户希望谷歌能在搜索结果中排除这些无用网页，帮助他们找到最相关的信息。
谷歌搜索质量团队主管尤迪・马恩伯(Udi Manber)表示："用户的期望值非常高。当我们刚刚推出搜索服务时，如果用户能通过搜索引擎找到想要的东西，就会感到是一个奇迹。现在的情况则完全不同，如果用户在前三个搜索结果页面中找不到想要的东西，就认为搜索引擎存在问题。"
谷歌搜索业务充分展现了其打破常规的管理模式。谷歌拥有数百名工程师，其中包括来自学术机构的顶级搜索专家，这些人通常被松散地组织在一起，从事自己感兴趣的项目。但在搜索引擎方面，谷歌会仔细、严格地检查工程师的独立成果，以确保新的搜索算法带来的好处多于坏处。大多数情况下，改进和质量控制都涉及平衡的艺术。马恩伯表示："改进总会同时带来正面和负面的效应，我们必须衡量哪一种影响更大。只有正面效果，没有负面效果的改进不存在。"
搜索团队大揭秘
谷歌搜索质量团队在谷歌办公园区的Building 43工作。由于公司联合创始人拉里・佩奇(Larry Page)向往太空旅行，一个与"太空船一号"同样大小的复制品占据了Building 43的休息室。这一复制品也随时提醒参观者，谷歌就像火箭一样迅速升起。辛格哈尔和其它三名顶级工程师的办公室就坐落于Building 43的顶层，在他办公桌附近的黑板上，到处涂满了图表、问题和数学公式，当然还有用户对谷歌引擎提出的各种意见。
谷歌的所有员工都可以使用"Buganizer"系统报告搜索问题，而辛格哈尔正是负责解决问题的人。辛格哈尔的同事马特・卡兹(Matt Cutts)表示："辛格哈尔收到他人提出的问题之后，总是视若珍宝，并努力通过修正算法解决问题。"有些时候，用户或其它谷歌员工提出的问题需要立即得到解决。例如，如果不久前通过谷歌搜索"法国大革命"，就会出现大量与法国总统大选相关的信息，而不是打倒法国国王路易十六的那场革命。谷歌搜索质量团队很快改变了网页的权值，从而解决了这一问题。
当然，有时会出现更为复杂的问题。2005年，谷歌产品经理比尔・布罗格(Bill Brougher)指出，当用户搜索"teak patio Palo Alto"时，并不会返回这家名叫"Teak Patio"的本地商店。辛格哈尔随即启动了一项名为"Debug"的内部计划，检查计算机系统对每一个查询和网页的评价。
辛格哈尔最终发现，Theteakpatio.com之所以没有在搜索结果中显现，主要因为谷歌搜索算法并没有赋予来自Palo Alto的其它网站足够的权值。收到投诉后的两个月内，辛格哈尔及其团队改进了搜索算法，从而解决了相关问题。不过，辛格哈尔并不能匆忙地解决所有问题，因为搜索引擎的每一次调整都会影响到很多网站。因此，他将很多问题都记在黑板上，如果同样的问题再次出现，他就会调整其优先级。
人才是成功根本
为了提高搜索引擎的质量，谷歌一直致力于从研究实验室和大学招募人才。例如，辛格哈尔就来自于AT&T实验室；马恩伯最初曾经在亚利桑那大学担任计算机教员，随后加盟雅虎担任首席科学家，之后还曾运营过亚马逊搜索部门。他去年从亚马逊加盟谷歌，很快就发现谷歌搜索引擎遥遥领先于学术实验室和其它企业竞争对手。他回忆道："加入谷歌后的前三个月里，我经常会说，'我有一个想法'。但他们总是告诉我，'已经有人提出过这个想法，它无法发挥作用'。"
谷歌搜索质量团队的分工非常明确：辛格哈尔等工程师主要负责用户输入关键字后的系统处理；一部分人主要负责改进搜索结果，例如优化网站描述，让用户更容易了解一个网站的内容；以马恩伯为首的其它成员则主要负责维护庞大的网页索引。在早期阶段，谷歌每六到八周创建一个新索引，而现在该公司每隔几天就要重新核对很多网页。
在编辑索引的过程中，谷歌主要考虑每一个网页的PageRank。PageRank是谷歌联合创始人佩奇和塞吉・布林(Sergey Brin)的重要发明，它主要用于标识其它网站链接到特定网页的次数。网页的PageRank越高，在搜索结果中的排名也就越高。辛格哈尔已经开发出一个更为精确的系统来为网页排名，它涉及了200多种信息，PageRank只是其中之一。
要完全了解谷歌搜索引擎所采用的技术是一项不可能完成的任务，因为这是谷歌赖以成功的根本，同时也是其它竞争对手梦寐以求的东西。只从搜索结果来看，很多时候并不能看出谷歌搜索引擎与竞争对手的差异。但搜索专家丹尼・沙利文(Danny Sullivan)认为，谷歌仍然领先于竞争对手。巴特勒也表示："人们仍然认为谷歌是搜索的黄金标准。"
2007.06.04 from:新浪科技 马丁
搜索是重中之重
随着企业规模不断扩大，谷歌开始向多个领域进军，包括网络地图、数字图书馆、视频共享以及桌面软件等等。但是，谷歌的重中之重仍然是搜索引擎。通过谷歌搜索引擎，用户可以在浩如烟海的大量信息中找到自己需要的内容。正因为有了出色的搜索引擎，谷歌才成为了访问量最大、利润最为丰厚、甚至最为强大的互联网公司。
不过，搜索引擎给谷歌招致的抱怨也最多。每天都有数百万用户在使用谷歌搜索引擎之后感到失望，因为他们无法找到自己需要的旅馆、医药处方、或者人物背景。谷歌经常能帮助用户找到想要的东西，但并非总能做到这一点。基于这一原因，阿米特・辛格哈尔(Amit Singhal)和其它数百名工程师一直致力于改进谷歌搜索引擎，希望能缩小"经常"和"总是"之间的差距。
互联网的生命之源
辛格哈尔是谷歌搜索引擎排名算法的大师。这一算法主要用于确定哪些网页是用户问题的最佳答案，它是谷歌核心团队――搜索质量部门的重要组成部分。长期来来，该部门一直是个谜，谷歌很少允许团队成员抛头露面。谷歌对辛格哈尔及其团队的评价非常高，将他们视为公司最为根本的竞争优势。谷歌认为，要想抵御来自雅虎和微软的强势入侵，就必须降低让用户失望的频度。而在这一过程中，搜索质量部门发挥着不可替代的作用。
Federated Media首席执行官约翰・巴特勒(John Battelle)表示："谷歌创建的核心价值就是排名算法。"数据显示，网络商店有四分之一到二分之一的访问者来自于搜索引擎；很多用户都无视媒体网站的网页，而是通过谷歌直接访问所需的特定页面。他说："从上述事实可以看出，谷歌已经成为了互联网的'生命之源'，谁也离不开它。"
用户无法看到搜索引擎背后的算法和艺术，但事实上，谷歌搜索质量团队每周都要对搜索引擎算法做数次改进。在他们的努力下，谷歌搜索引擎可以更加有效地理解用户的真实意图。例如，有些人搜索"苹果"是为了了解同水果相关的信息，有些人则在研究苹果公司的Mac或iPod。尽管搜索内容相同，但用户的意图却有着天壤之别。辛格哈尔表示："过去几年里，搜索已经由'给我输入的东西'转变为'给我想要的东西'。"
不为人知的内幕
辛格哈尔今年39岁，是一名印度人，于2000年加盟谷歌。他目前是一名谷歌研究员，这是谷歌专门为精英工程师设立的职位。不久前，一名《纽约时报》的记者获准采访了辛格哈尔和其它搜索质量团队成员。尽管谷歌对很多问题都讳忌莫深，但这名记者仍然获得了很多以前不为人知的内幕。
在谷歌不断改进搜索引擎的过程中，面临的最大挑战是日渐庞大的规模。目前，谷歌已经成为全球访问量最大的网站，支持112种语言，将数百亿个网页纳入索引，每天处理数亿次搜索请求。更为糟糕的是，很多网页创建的目的就是吸引眼球，里面充斥了大量的广告、色情内容和财务欺骗信息。因此，用户希望谷歌能在搜索结果中排除这些无用网页，帮助他们找到最相关的信息。
谷歌搜索质量团队主管尤迪・马恩伯(Udi Manber)表示："用户的期望值非常高。当我们刚刚推出搜索服务时，如果用户能通过搜索引擎找到想要的东西，就会感到是一个奇迹。现在的情况则完全不同，如果用户在前三个搜索结果页面中找不到想要的东西，就认为搜索引擎存在问题。"
谷歌搜索业务充分展现了其打破常规的管理模式。谷歌拥有数百名工程师，其中包括来自学术机构的顶级搜索专家，这些人通常被松散地组织在一起，从事自己感兴趣的项目。但在搜索引擎方面，谷歌会仔细、严格地检查工程师的独立成果，以确保新的搜索算法带来的好处多于坏处。大多数情况下，改进和质量控制都涉及平衡的艺术。马恩伯表示："改进总会同时带来正面和负面的效应，我们必须衡量哪一种影响更大。只有正面效果，没有负面效果的改进不存在。"
搜索团队大揭秘
谷歌搜索质量团队在谷歌办公园区的Building 43工作。由于公司联合创始人拉里・佩奇(Larry Page)向往太空旅行，一个与"太空船一号"同样大小的复制品占据了Building 43的休息室。这一复制品也随时提醒参观者，谷歌就像火箭一样迅速升起。辛格哈尔和其它三名顶级工程师的办公室就坐落于Building 43的顶层，在他办公桌附近的黑板上，到处涂满了图表、问题和数学公式，当然还有用户对谷歌引擎提出的各种意见。
谷歌的所有员工都可以使用"Buganizer"系统报告搜索问题，而辛格哈尔正是负责解决问题的人。辛格哈尔的同事马特・卡兹(Matt Cutts)表示："辛格哈尔收到他人提出的问题之后，总是视若珍宝，并努力通过修正算法解决问题。"有些时候，用户或其它谷歌员工提出的问题需要立即得到解决。例如，如果不久前通过谷歌搜索"法国大革命"，就会出现大量与法国总统大选相关的信息，而不是打倒法国国王路易十六的那场革命。谷歌搜索质量团队很快改变了网页的权值，从而解决了这一问题。
当然，有时会出现更为复杂的问题。2005年，谷歌产品经理比尔・布罗格(Bill Brougher)指出，当用户搜索"teak patio Palo Alto"时，并不会返回这家名叫"Teak Patio"的本地商店。辛格哈尔随即启动了一项名为"Debug"的内部计划，检查计算机系统对每一个查询和网页的评价。
辛格哈尔最终发现，Theteakpatio.com之所以没有在搜索结果中显现，主要因为谷歌搜索算法并没有赋予来自Palo Alto的其它网站足够的权值。收到投诉后的两个月内，辛格哈尔及其团队改进了搜索算法，从而解决了相关问题。不过，辛格哈尔并不能匆忙地解决所有问题，因为搜索引擎的每一次调整都会影响到很多网站。因此，他将很多问题都记在黑板上，如果同样的问题再次出现，他就会调整其优先级。
人才是成功根本
为了提高搜索引擎的质量，谷歌一直致力于从研究实验室和大学招募人才。例如，辛格哈尔就来自于AT&T实验室；马恩伯最初曾经在亚利桑那大学担任计算机教员，随后加盟雅虎担任首席科学家，之后还曾运营过亚马逊搜索部门。他去年从亚马逊加盟谷歌，很快就发现谷歌搜索引擎遥遥领先于学术实验室和其它企业竞争对手。他回忆道："加入谷歌后的前三个月里，我经常会说，'我有一个想法'。但他们总是告诉我，'已经有人提出过这个想法，它无法发挥作用'。"
谷歌搜索质量团队的分工非常明确：辛格哈尔等工程师主要负责用户输入关键字后的系统处理；一部分人主要负责改进搜索结果，例如优化网站描述，让用户更容易了解一个网站的内容；以马恩伯为首的其它成员则主要负责维护庞大的网页索引。在早期阶段，谷歌每六到八周创建一个新索引，而现在该公司每隔几天就要重新核对很多网页。
在编辑索引的过程中，谷歌主要考虑每一个网页的PageRank。PageRank是谷歌联合创始人佩奇和塞吉・布林(Sergey Brin)的重要发明，它主要用于标识其它网站链接到特定网页的次数。网页的PageRank越高，在搜索结果中的排名也就越高。辛格哈尔已经开发出一个更为精确的系统来为网页排名，它涉及了200多种信息，PageRank只是其中之一。
要完全了解谷歌搜索引擎所采用的技术是一项不可能完成的任务，因为这是谷歌赖以成功的根本，同时也是其它竞争对手梦寐以求的东西。只从搜索结果来看，很多时候并不能看出谷歌搜索引擎与竞争对手的差异。但搜索专家丹尼・沙利文(Danny Sullivan)认为，谷歌仍然领先于竞争对手。巴特勒也表示："人们仍然认为谷歌是搜索的黄金标准。"
Do many things, like pings
From redspid.blog.163.com
2007年 06月06日 19:42
Perl 多进程的例子，收藏先。
作 者：Randal L. Schwartz
As a Unix system administrator, I'm often faced with those little mundane tasks that seem so trivial to me but so important to the community I'm supporting. Little things like ``hey, is that host up and responding to pings?''. Such tasks generally have a very repetitive nature to them, and scripting them seems to be the only way to have time to concentrate on the tasks that really need my attention.
作为一个 Unix 系统管理员，我经常会面对一些单调乏味的任务，虽然这对我来说是小菜一碟，但是对于我所支持的社区来说却显得比较重要了（比如很简单的事情"嘿！那台主机在工作吗？回应我的 ping 请求吗？"）。这类任务通常都具有重复性，所以为了让我们能把精力集中在该集中的地方，写个脚本搞定这些琐事似乎就是唯一的方法了。
Let's look at the specific task of pinging a number of hosts on a subnet. Now, there are tools to do this quickly (like nmap), and there are even Perl modules to perform the ping (as in Net::Ping), but I wanted to focus on something familar that can be launched from Perl as an external process, and the system ping command seems mighty appropriate for that.
让我们看看这个在子网内 ping 大量主机的典型任务。现在有一些工具（像 nmap）可以很快地完成这个任务，而且甚至还有 Perl 模块来实现 ping（比如 Net::Ping),但我还是想把目光集中在一些能在 Perl 中作为额外进程运行的我们所熟悉的工具上,这样看来，系统所带的 ping 命令似乎比较适合。
First, let's look at how to ping one host, on my BSD-ish system:
首先，让我们看看如何 ping 一台主机，在我的 BSD 类系统中：
sub ping_a_host {
my $host = shift;
`ping -i 1 -c 1 $host 2>/dev/null` =~ /0 packets rec/ ? 0 : 1;
}
Here, I'm firing up a subshell to execute the ping -i 1 -c 1 command, which on my system requests ping have a 1-second timeout, and selects (as Sean Connery's character said in The Hunt for Red October so eloquently) ``one ping only''. Your ping parameters may vary: check your manpage.
这里，我们创建了一个子进程来执行 ping -i 1 -c 1 命令，这个命令只会 ping 目标主机一次，而且设置了超时时间为1秒。并选择（像肖恩-康纳利在《追击红色十月》里演的那个角色一样非常意味深长地说）"只 ping 一次"。你系统上的 ping 所需的参数可能有不同，请查看你的 man 说明。
The output is scanned for the string 0 packets rec, which if absent means we got a good ping. So if the match is found, we return 0 (the ping was bad), otherwise we'll return 1. The ping command spits out some diagnostics on standard error, which we'll toss using Bourne-shell syntax.
程序会在命令执行完所得到的输出中搜索 "0 packets rec" 这个字串，如果没有找到这个字串，说明 ping 成功了（目标主机有回应）。所以，如果我们找到了这个字串，那么返回 0（ping 失败了），否则我们返回 1。由于 ping 命令会向标准错误端输出一些诊断信息，所以我们把这些信息丢到 /dev/null 中去。
Note that the value of $host is not checked here for sanity. We certainly wouldn't want to accept a random command-line parameter or (gasp) a web form value here without some serious validation. However, as we use this in our program, all of the values will be internally generated, so we've got some degree of safety.
注意，这里没有对 $host 的值进行正确性检查。我们可不想接收一些事先没有经过验证的任意命令行参数，或者是通过网络表单传递来的值。不过，程序里所有值我们都将在程序内部生成，所以这已经是一层安全保障了。
So to scan a particular subnet, looking for hosts that are alive, we would add to that subroutine something like:
为了 ping 一个特定的子网看看有哪些主机存活，我们可以为上面的子程序添加如下的代码：
print "ping $_ is ", ping_a_host($_), "\n"
for map "10.0.1.$_", 1..254;
Now, this routine completes very quickly for hosts that are alive, but is slow-as-molasses for hosts that aren't present, because the TCP protocol demands that the host have a chance to respond.
现在，当主机存活时， ping 这一步很快就会完成，但如果主机不在（或者没有回应），那这一步就会非常慢了（由于 TCP 协议要求主机可以有一定的响应延迟的原因）。
So how can we speed that up? This is not a CPU-intensive loop: practically the entire time is waiting for some remote host to respond. We'll leave the ping_a_host subroutine alone, because that's not where we have a problem: it's doing its job as fast as it can. What we need to do is to do more of them at a time.
那么我们如何让程序加速呢？这并不是一个占用 CPU 很厉害的循环：实际上整个时间都花费在等待远程主机的回应上了。我们不管这个 ping_a_host 子程序，因为这并不是问题的所在：他正全速工作呢。我们需要的是在同一时间能做更多这样的任务。
One first approach is to fork a separate process for each host we want to ping. We'll then sit back in a wait loop. As each child process completes, we'll note its exit status, and when there are no more kids, we'll spit out a report.
其中一个首要的途径是为我们想 ping 的每一个主机 fork 出一个独立的进程。然后我们将返回到一个等待的循环中。当所有的子进程都完成的时候，我们会留意他们的退出状态，并且当子进程都结束后，再给出一个结果报告。
So, first, we'll define the host list for the task:
那么，首先，我们得先定义所需的主机列表：
my @hosts = map "10.0.1.$_", "001".."010";
The numbers here are padded to three digits so that they sort as strings in a numeric sequence, a cheap but effective trick. Note also that I'm only selecting the first 10 hosts this time. I'll explain that shortly.
这些主机的最后部分被填充成三位，这样就能让这组字符串按照数字顺序来排序，简单而有效的技巧。注意我只选了子网中的前10台主机，后面我会解释原因。
Next, we'll want a hash to keep track of the kids:
下一步，我们将利用一个散列（hash)来跟踪子进程：
my %pid_to_host;
The keys of this hash will be the child process ID (PID), and the value will be the corresponding host that the child is processing. Next, we'll want to loop over the host list, firing up a child for each:
子进程的进程号（PID）将成为这个散列的关键字，而其键值就是该子进程正在处理的相对应的主机地址。下一步，我们将遍历整个主机列表，为其中的每一个主机创建一个子进程：
for (@hosts) {
if (my $pid = fork) {
## parent does...
$pid_to_host{$pid} = $_;
warn "$pid is processing $_\n";
} else { # child does
## child does...
exit !ping_a_host($_);
}
As each host is placed into $_, we'll fork. The result of fork is a child process running in parallel with the parent process. These processes are distinguished only by the return value of fork, which is 0 in the child, but the child's PID in the parent. So, if we get back a non-zero value, we're the parent, and we'll store the PID into the hash, along with the host that particular child is processing. If we're the child, then we'll call the ping_a_host routine, and arrange for our exit status to be good (0) if that routine gives a thumbs up.
在上面的代码中，所有的主机都会在 for 循环中依次传递给变量 $_ ,然后我们将进行 fork。调用 fork 函数后，我们将得到一个和父进程并行运行的子进程。它们之间的区别仅仅在于 fork 的返回值（fork 会返回两个值），如果返回值为 0,那说明在子进程中，父进程中 fork 的返回值就是子进程的 PID(进程号）。所以，如果我们得到一个非零的返回值，那么我们就在父进程中，在该进程中我们将会把子进程的 PID 及与工作中的该进程相应的主机 ip 保存到散列中。假如我们在子进程中，那么我们将会调用 ping_a_host 程序，并且当这个程序正常退出的时候，我们把退出状态码置为 0 (表示工作正常的）。
The warn in the loop is merely for diagnostic purposes so that you can see what's happening. In a production program, I'd certainly remove that.
这个循环中的 warn 仅仅用来输出诊断信息，这样你就可以知道程序正在干什么。当程序作为成品的时候，我会把这行去掉。
At the end of this loop, we'll have a number of processes. Far too many, in fact. For each host to check, we'll have two processes running: the shell forked by the backquotes, and the ping process itself. Perl has to fork a shell because I needed that child to have its standard error output redirected. If I could have gotten the redirection out of those backquotes somehow, we'd have only one child process per host, not two.
在这次循环的最后，我们将会有很多个进程。事实上太多了。对于每个要检查的主机，我们将耗费两个进程：一个是反引号调用系统命令分出的 shell 进程，一个是 ping 这个进程本身。Perl 之所以得分出一个 shell 进程是因为我们需要把这个子进程的标准错误输出转向（不会在屏幕上显示出来）。假如我们能用某种方式避免使用反引号调用的输出转向，那么我们就能只分出一个进程而不是两个了。
Launching 20 processes to check 10 hosts will start pushing us up against the typical per-user process limit. And now you can see why I didn't do all 254 hosts at once!
创建20个进程去检查10台主机将使我们面临经典的每用户进程数限制的问题（校者注：unix 下可以通过 ulimit -u 命令查到这个进程限制）。现在你应该明白我为什么先前只选前10台而不是一次性把254台主机都放进来的原因（会产生 508 个子进程！）。
Now it's time to wait for the results. A simple ``wait'' loop will reap the children as fast as they complete their task. First, we'll declare a hash to hold the results:
现在是时候等待返回结果了。用一个简单的 "wait" 循环就能在子进程完成任务之后尽快地收割它们。首先，我们得声明一个散列来保存结果：
my %host_result;
The key will be the host, and the value will be 1 if the child said it was pingable, otherwise 0.
主机地址将成为该散列的关键字，而其对应的键值将是 1（当子进程说那台主机可以 ping 到）或者 0（ping 不到）
while (keys %pid_to_host) {
my $pid = wait;
last if $pid < 0;
my $host = delete $pid_to_host{$pid}
or warn("Why did I see $pid ($?)\n"), next;
warn "reaping $pid for $host\n";
$host_result{$host} = $? ? 0 : 1;
}
As long as we've got kids (indicated by the ever decreasing size of the %pid_to_host hash), we'll wait for them. The child process ID comes back from wait, which we'll stick into $pid. At this point, the exit status of that particular child is in $?. If the return value of wait is negative, then we don't have any more kids. This is an unexpected result, which we could check later by noticing that %pid_to_host is not yet empty, or we could have simply died here.
当有子进程存在的时候（由大小递减的散列 %pid_to_host 所指示），我们将会等待它们直到它们完结。wait 函数会返回子进程的进程号，我们把它保存至 $pid。此时，指定的子进程的退出状态保存在特殊变量 $? 中。假如 wait 返回值是负数，那说明我们没有子进程了。这不是我们所期待的结果，我们可以通过检查散列 %pid_to_host 是否非空来确认，或者简单的就在此处结束。
Next, we'll use the %pid_to_host hash to map the PID into the host for which it was processing. Again, we might have accidentally reaped a completed child which wasn't one of ours, so defensive programming requires checking for that. This won't happen unless other parts of this program are also forking children somehow, but I'm a cautious programmer most of the time.
接下来，我们将利用散列 %pid_to_host 将进程号映射到正在处理的主机。也许我们会偶然地将一个已完成的不属于我们的子进程收割掉，所以我们要对其进行检查。当我们没有在这个程序的其他地方以某种方式分出子进程的时候，就不会产生这种情况，虽然我们这个程序满足这个要求，但大多数时候我是个谨慎的程序员（所以我在程序中加入了对这种情况进行检查的代码）。
Finally, we'll take the exit status in $?, and map it into the appropriate good/bad value for the result hash.
最后，我们将参照特殊变量 $? 中的退出状态码把 ping 结果的 好/坏 值保存至结果散列。
When this loop completes, we have no more kids performing tasks, and it's time to show the result:
当这个循环结束，就没有子进程在处理任务了，现在是时候显示结果了：
for (sort keys %host_result) {
print "$_ is ", ($host_result{$_} ? "good" : "bad"), "\n";
}
For each key of the result table, we'll say whether the result was good or bad.
以上的代码打印出每台主机 ping 的结果。
Putting this all together makes a nice little demo of forking 20 kids to check 10 hosts, but it won't scale to 254 hosts, because that would require more process slots than we typically have (or want to use, actually). What we need to do is perform the forking gradually, so that we never have more than 20 kids at a time. One naive approach is to chunk the data into bite-size bits:
把上面所有的代码凑到一起就成了一个分出20个子进程来检查10台主机的漂亮的演示程序，但是它却不适合有254台主机的情况，还记得前面提到的每用户进程限制吗？那怎么办呢？我们可以循序渐进地分出子进程的嘛，这样我们就可以保证同时不会有超过20个子进程存在。一个笨办法就是把数据（这里指主机列表）分割成几个部分：
my @all_hosts = ...;
my %host_results;
while (my @hosts = splice @all_hosts, 0, 10) {
... process @hosts, adding into %host_results ...
}
... show results ...
Here, most of the code above gets wrapped into an outer loop which hands 10 hosts at a time to be processed, using splice to peel them off of the master list. While this strategy certainly solves the ``no more than 10 at a time'' condition, each batch of 10 has to wait for the slowest of the 10 to complete.
以上的代码在用 splice 函数将 @all_hosts 每次分成10份付给 @hosts，然后针对 @hosts 来进行多进程的处理，这样，用一个外层的 while 循环（相对于那个多进程处理的循环）来保证同时只处理主机总列表中的10台主机。这种策略的确能解决"同时不多于10台主机"的问题，但是实际上每一批 10台主机都要等前面的10台主机处理完后才能继续，这样显然太慢了。
A better way would be to fork until we hit the limit of active children, then wait for one child to finish before we need to fork again. First, we'll need to factor out ``waiting for a kid'' into a subroutine so we can call it in two different places: while forking a new task, and at the end to reap all the remaining children:
一种更好的方法就是如果正在运行的子进程数量没有达到设定的极限值，就继续 fork，否则就等待某个子进程完成然后再 fork。首先，我们需要把"等待某个子进程"写成一个子程序以方便我们在两个不同的地方调用：当为新任务创建子进程以及在最后收割所有仍然存在的子进程的时候。
sub wait_for_a_kid {
my $pid = wait;
return 0 if $pid < 0;
my $host = delete $pid_to_host{$pid}
or warn("Why did I see $pid ($?)\n"), next;
warn "reaping $pid for $host\n";
$host_result{$host} = $? ? 0 : 1;
1;
}
Note that we're accessing %pid_to_host and %host_result directly here, so those variables must be in scope before the subroutine definition. The subroutine now returns 1 if a kid was reaped, and 0 otherwise. The final reap loop now becomes:
注意我们这里是直接的访问散列 %pid_to_host 和 %host_result 的。所以它们必须已经在这个子程序定义之前定义了。当一个子进程被顺利收割时，该子程序返回1,否则返回0。程序最后的收割循环（译者注：这个收割循环会持续到所有的子进程全部被收割为止，这样是为了避免僵进程导致进程泄漏，关于僵进程和进程泄漏的概念，请自行查找有关资料）现在变成了：
## final reap:
1 while wait_for_a_kid();
At this point, the program functions identically to the prior one, except that I've refactored the kid reaping. The magic happens next. We'll put wait_for_a_kid in the middle of the forking loop as well, just before we're about to fork, conditionally if the number of kids is already at the maximum we chose:
到这步，除了我重新写的这个子进程收割程序，这个程序的功能就和先前的那个一样了。接下来将发生一些魔术般的事情,呵呵。我们将把 wait_for_a_kid 子程序放到创建子进程的那个循环中，调用 fork 之前,在子进程数达到设定的极限值时调用该子程序。
for (@hosts) {
wait_for_a_kid() if keys %pid_to_host >= 10;
...
Ahh. That does it. We can now crank @hosts back up to our 254 items. As we fire off the first 10, this new statement has no effect. But when it comes time for the 11th, we'll wait until at least one of the other 10 to complete first. So, at no time do we have more than 10 hosts active (using 20 child processes for reasons explained earlier). The entire program is given here in case you want to see it all in context:
啊哈！现在我们可以把 @hosts 中主机的数量增加到254台了。当在为前10台主机创建子进程的时候，这条新加的表达式并不起什么作用，但是，当为第11台主机创建子进程的时候，它就会一直等待直到至少有一台主机已经处理完毕才继续。这样，我们就不会在同一时间处理超过10台主机了（处理10台机会使用20个子进程，原因前面说过了）。下面就是完整的程序：
sub ping_a_host {
my $host = shift;
`ping -i 1 -c 1 $host 2>/dev/null` =~ /0 packets rec/ ? 0 : 1;
}
my %pid_to_host;
my %host_result;
sub wait_for_a_kid {
my $pid = wait;
return 0 if $pid < 0;
my $host = delete $pid_to_host{$pid}
or warn("Why did I see $pid ($?)\n"), next;
warn "reaping $pid for $host\n";
$host_result{$host} = $? ? 0 : 1;
1;
}
my @hosts = map "10.0.1.$_", "001".."254";
for (@hosts) {
wait_for_a_kid() if keys %pid_to_host > 10;
if (my $pid = fork) {
## parent does...
$pid_to_host{$pid} = $_;
warn "$pid is processing $_\n";
} else { # child does
## child does...
exit !ping_a_host($_);
}
}
## final reap:
1 while wait_for_a_kid();
for (sort keys %host_result) {
print "$_ is ", ($host_result{$_} ? "good" : "bad"), "\n";
}
As a working program, this does pretty good, although it could be made a bit more robust, and is very specific to the particular ping program on my machine. If you don't want to write this pattern of code into each program that wants to do parallel things, look at Parallel::Fork Manager in the CPAN, which does pretty much the same thing with a friendly interface.
虽然这个程序还可以进一步的完善以使它更强健，但现在他工作得很好，比起单单用我系统上的 ping 命令，用这个程序来完成任务就显得有效多了。如果你不想每次一涉及并行处理的事情就套用上面的代码，那么可以试试 CPAN 上的 Parallel::Fork Manager 模块，它也能够漂亮的实现到相同的效果，不过更妙的是它拥有一个更友好的接口。
One improvement to this program might be to pre-fork and re-use the children, using some sort of IPC (pipes or sockets) to communicate additional tasks to perform as each task completes, but I've run out of space to talk about that here. Until next time, enjoy!
预创建进程以及子进程重用（在每个任务完成的时候利用一些进程间通信（IPC）的方式（管道或者套接字）来与接下来的任务进行通讯）可以作为该程序的一个改进，但是这已经超出了本文的范围。okay, 希望你能喜欢这篇文章，下次再见！
―――――――――――――-
在 Parallel::Fork Manager 模块文档里摘一个实例给懒惰的 Perl 程序员 :) 这个例子会创建 30 个子进程来并行下载不同的链接。这要比亲自动手调用 fork 简单多了。
use LWP::Simple;
use Parallel::ForkManager;
...
@links=(
["http://www.foo.bar/rulez.data","rulez_data.txt"],
["http://new.host/more_data.doc","more_data.doc"],
...
);
...
# 同时使用 30 个进程
my $pm = new Parallel::ForkManager(30);
foreach my $linkarray (@links) {
$pm->start and next; # 开始 fork
my ($link,$fn) = @$linkarray;
warn "Cannot get $fn from $link"
if getstore($link,$fn) != RC_OK;
$pm->finish; # do the exit in the child process
}
$pm->wait_all_children;
First you need to instantiate the Fork Manager with the "new" constructor. You must specify the maximum number of processes to be created. If you specify 0, then NO fork will be done; this is good for debugging purposes.
首先通过 new 来初始化一个 Fork Manager 对象，同时必须标明最大进程数。如果使用 0 的话就可以避免 fork 来达到调试程序的作用。
Next, use $pm->start to do the fork. $pm returns 0 for the child process, and child pid for the parent process (see also "fork()" in perlfunc(1p)). The "and next" skips the internal loop in the parent process. NOTE: $pm->start dies if the fork fails.
然后使用 $pm->start 来开始 fork。 $pm 在子进程时返回 0 ,父进程时返回子进程的进程号（具体请参阅 Perl 的 fork 文档）。"and next" 用来跳过父进程。注意：如果 fork 失败的话， $pm->start 就提示错误，程序结束。
$pm->finish terminates the child process (assuming a fork was done in the "start").
$pm->finish 结束子程序（假设我们一开始使用了 start 来 fork）
NOTE: You cannot use $pm->start if you are already in the child process. If you want to manage another set of subprocesses in the child process, you must instantiate another Parallel::Fork Manager object!
注意：在子进程中不能使用 $pm->start。 如果你想在子进程中使用另外一组子进程，你必须再初始化一个 Parallel::Fork Manager 对象。
2007年 06月06日 19:42
Perl 多进程的例子，收藏先。
作 者：Randal L. Schwartz
As a Unix system administrator, I'm often faced with those little mundane tasks that seem so trivial to me but so important to the community I'm supporting. Little things like ``hey, is that host up and responding to pings?''. Such tasks generally have a very repetitive nature to them, and scripting them seems to be the only way to have time to concentrate on the tasks that really need my attention.
作为一个 Unix 系统管理员，我经常会面对一些单调乏味的任务，虽然这对我来说是小菜一碟，但是对于我所支持的社区来说却显得比较重要了（比如很简单的事情"嘿！那台主机在工作吗？回应我的 ping 请求吗？"）。这类任务通常都具有重复性，所以为了让我们能把精力集中在该集中的地方，写个脚本搞定这些琐事似乎就是唯一的方法了。
Let's look at the specific task of pinging a number of hosts on a subnet. Now, there are tools to do this quickly (like nmap), and there are even Perl modules to perform the ping (as in Net::Ping), but I wanted to focus on something familar that can be launched from Perl as an external process, and the system ping command seems mighty appropriate for that.
让我们看看这个在子网内 ping 大量主机的典型任务。现在有一些工具（像 nmap）可以很快地完成这个任务，而且甚至还有 Perl 模块来实现 ping（比如 Net::Ping),但我还是想把目光集中在一些能在 Perl 中作为额外进程运行的我们所熟悉的工具上,这样看来，系统所带的 ping 命令似乎比较适合。
First, let's look at how to ping one host, on my BSD-ish system:
首先，让我们看看如何 ping 一台主机，在我的 BSD 类系统中：
sub ping_a_host {
my $host = shift;
`ping -i 1 -c 1 $host 2>/dev/null` =~ /0 packets rec/ ? 0 : 1;
}
Here, I'm firing up a subshell to execute the ping -i 1 -c 1 command, which on my system requests ping have a 1-second timeout, and selects (as Sean Connery's character said in The Hunt for Red October so eloquently) ``one ping only''. Your ping parameters may vary: check your manpage.
这里，我们创建了一个子进程来执行 ping -i 1 -c 1 命令，这个命令只会 ping 目标主机一次，而且设置了超时时间为1秒。并选择（像肖恩-康纳利在《追击红色十月》里演的那个角色一样非常意味深长地说）"只 ping 一次"。你系统上的 ping 所需的参数可能有不同，请查看你的 man 说明。
The output is scanned for the string 0 packets rec, which if absent means we got a good ping. So if the match is found, we return 0 (the ping was bad), otherwise we'll return 1. The ping command spits out some diagnostics on standard error, which we'll toss using Bourne-shell syntax.
程序会在命令执行完所得到的输出中搜索 "0 packets rec" 这个字串，如果没有找到这个字串，说明 ping 成功了（目标主机有回应）。所以，如果我们找到了这个字串，那么返回 0（ping 失败了），否则我们返回 1。由于 ping 命令会向标准错误端输出一些诊断信息，所以我们把这些信息丢到 /dev/null 中去。
Note that the value of $host is not checked here for sanity. We certainly wouldn't want to accept a random command-line parameter or (gasp) a web form value here without some serious validation. However, as we use this in our program, all of the values will be internally generated, so we've got some degree of safety.
注意，这里没有对 $host 的值进行正确性检查。我们可不想接收一些事先没有经过验证的任意命令行参数，或者是通过网络表单传递来的值。不过，程序里所有值我们都将在程序内部生成，所以这已经是一层安全保障了。
So to scan a particular subnet, looking for hosts that are alive, we would add to that subroutine something like:
为了 ping 一个特定的子网看看有哪些主机存活，我们可以为上面的子程序添加如下的代码：
print "ping $_ is ", ping_a_host($_), "\n"
for map "10.0.1.$_", 1..254;
Now, this routine completes very quickly for hosts that are alive, but is slow-as-molasses for hosts that aren't present, because the TCP protocol demands that the host have a chance to respond.
现在，当主机存活时， ping 这一步很快就会完成，但如果主机不在（或者没有回应），那这一步就会非常慢了（由于 TCP 协议要求主机可以有一定的响应延迟的原因）。
So how can we speed that up? This is not a CPU-intensive loop: practically the entire time is waiting for some remote host to respond. We'll leave the ping_a_host subroutine alone, because that's not where we have a problem: it's doing its job as fast as it can. What we need to do is to do more of them at a time.
那么我们如何让程序加速呢？这并不是一个占用 CPU 很厉害的循环：实际上整个时间都花费在等待远程主机的回应上了。我们不管这个 ping_a_host 子程序，因为这并不是问题的所在：他正全速工作呢。我们需要的是在同一时间能做更多这样的任务。
One first approach is to fork a separate process for each host we want to ping. We'll then sit back in a wait loop. As each child process completes, we'll note its exit status, and when there are no more kids, we'll spit out a report.
其中一个首要的途径是为我们想 ping 的每一个主机 fork 出一个独立的进程。然后我们将返回到一个等待的循环中。当所有的子进程都完成的时候，我们会留意他们的退出状态，并且当子进程都结束后，再给出一个结果报告。
So, first, we'll define the host list for the task:
那么，首先，我们得先定义所需的主机列表：
my @hosts = map "10.0.1.$_", "001".."010";
The numbers here are padded to three digits so that they sort as strings in a numeric sequence, a cheap but effective trick. Note also that I'm only selecting the first 10 hosts this time. I'll explain that shortly.
这些主机的最后部分被填充成三位，这样就能让这组字符串按照数字顺序来排序，简单而有效的技巧。注意我只选了子网中的前10台主机，后面我会解释原因。
Next, we'll want a hash to keep track of the kids:
下一步，我们将利用一个散列（hash)来跟踪子进程：
my %pid_to_host;
The keys of this hash will be the child process ID (PID), and the value will be the corresponding host that the child is processing. Next, we'll want to loop over the host list, firing up a child for each:
子进程的进程号（PID）将成为这个散列的关键字，而其键值就是该子进程正在处理的相对应的主机地址。下一步，我们将遍历整个主机列表，为其中的每一个主机创建一个子进程：
for (@hosts) {
if (my $pid = fork) {
## parent does...
$pid_to_host{$pid} = $_;
warn "$pid is processing $_\n";
} else { # child does
## child does...
exit !ping_a_host($_);
}
As each host is placed into $_, we'll fork. The result of fork is a child process running in parallel with the parent process. These processes are distinguished only by the return value of fork, which is 0 in the child, but the child's PID in the parent. So, if we get back a non-zero value, we're the parent, and we'll store the PID into the hash, along with the host that particular child is processing. If we're the child, then we'll call the ping_a_host routine, and arrange for our exit status to be good (0) if that routine gives a thumbs up.
在上面的代码中，所有的主机都会在 for 循环中依次传递给变量 $_ ,然后我们将进行 fork。调用 fork 函数后，我们将得到一个和父进程并行运行的子进程。它们之间的区别仅仅在于 fork 的返回值（fork 会返回两个值），如果返回值为 0,那说明在子进程中，父进程中 fork 的返回值就是子进程的 PID(进程号）。所以，如果我们得到一个非零的返回值，那么我们就在父进程中，在该进程中我们将会把子进程的 PID 及与工作中的该进程相应的主机 ip 保存到散列中。假如我们在子进程中，那么我们将会调用 ping_a_host 程序，并且当这个程序正常退出的时候，我们把退出状态码置为 0 (表示工作正常的）。
The warn in the loop is merely for diagnostic purposes so that you can see what's happening. In a production program, I'd certainly remove that.
这个循环中的 warn 仅仅用来输出诊断信息，这样你就可以知道程序正在干什么。当程序作为成品的时候，我会把这行去掉。
At the end of this loop, we'll have a number of processes. Far too many, in fact. For each host to check, we'll have two processes running: the shell forked by the backquotes, and the ping process itself. Perl has to fork a shell because I needed that child to have its standard error output redirected. If I could have gotten the redirection out of those backquotes somehow, we'd have only one child process per host, not two.
在这次循环的最后，我们将会有很多个进程。事实上太多了。对于每个要检查的主机，我们将耗费两个进程：一个是反引号调用系统命令分出的 shell 进程，一个是 ping 这个进程本身。Perl 之所以得分出一个 shell 进程是因为我们需要把这个子进程的标准错误输出转向（不会在屏幕上显示出来）。假如我们能用某种方式避免使用反引号调用的输出转向，那么我们就能只分出一个进程而不是两个了。
Launching 20 processes to check 10 hosts will start pushing us up against the typical per-user process limit. And now you can see why I didn't do all 254 hosts at once!
创建20个进程去检查10台主机将使我们面临经典的每用户进程数限制的问题（校者注：unix 下可以通过 ulimit -u 命令查到这个进程限制）。现在你应该明白我为什么先前只选前10台而不是一次性把254台主机都放进来的原因（会产生 508 个子进程！）。
Now it's time to wait for the results. A simple ``wait'' loop will reap the children as fast as they complete their task. First, we'll declare a hash to hold the results:
现在是时候等待返回结果了。用一个简单的 "wait" 循环就能在子进程完成任务之后尽快地收割它们。首先，我们得声明一个散列来保存结果：
my %host_result;
The key will be the host, and the value will be 1 if the child said it was pingable, otherwise 0.
主机地址将成为该散列的关键字，而其对应的键值将是 1（当子进程说那台主机可以 ping 到）或者 0（ping 不到）
while (keys %pid_to_host) {
my $pid = wait;
last if $pid < 0;
my $host = delete $pid_to_host{$pid}
or warn("Why did I see $pid ($?)\n"), next;
warn "reaping $pid for $host\n";
$host_result{$host} = $? ? 0 : 1;
}
As long as we've got kids (indicated by the ever decreasing size of the %pid_to_host hash), we'll wait for them. The child process ID comes back from wait, which we'll stick into $pid. At this point, the exit status of that particular child is in $?. If the return value of wait is negative, then we don't have any more kids. This is an unexpected result, which we could check later by noticing that %pid_to_host is not yet empty, or we could have simply died here.
当有子进程存在的时候（由大小递减的散列 %pid_to_host 所指示），我们将会等待它们直到它们完结。wait 函数会返回子进程的进程号，我们把它保存至 $pid。此时，指定的子进程的退出状态保存在特殊变量 $? 中。假如 wait 返回值是负数，那说明我们没有子进程了。这不是我们所期待的结果，我们可以通过检查散列 %pid_to_host 是否非空来确认，或者简单的就在此处结束。
Next, we'll use the %pid_to_host hash to map the PID into the host for which it was processing. Again, we might have accidentally reaped a completed child which wasn't one of ours, so defensive programming requires checking for that. This won't happen unless other parts of this program are also forking children somehow, but I'm a cautious programmer most of the time.
接下来，我们将利用散列 %pid_to_host 将进程号映射到正在处理的主机。也许我们会偶然地将一个已完成的不属于我们的子进程收割掉，所以我们要对其进行检查。当我们没有在这个程序的其他地方以某种方式分出子进程的时候，就不会产生这种情况，虽然我们这个程序满足这个要求，但大多数时候我是个谨慎的程序员（所以我在程序中加入了对这种情况进行检查的代码）。
Finally, we'll take the exit status in $?, and map it into the appropriate good/bad value for the result hash.
最后，我们将参照特殊变量 $? 中的退出状态码把 ping 结果的 好/坏 值保存至结果散列。
When this loop completes, we have no more kids performing tasks, and it's time to show the result:
当这个循环结束，就没有子进程在处理任务了，现在是时候显示结果了：
for (sort keys %host_result) {
print "$_ is ", ($host_result{$_} ? "good" : "bad"), "\n";
}
For each key of the result table, we'll say whether the result was good or bad.
以上的代码打印出每台主机 ping 的结果。
Putting this all together makes a nice little demo of forking 20 kids to check 10 hosts, but it won't scale to 254 hosts, because that would require more process slots than we typically have (or want to use, actually). What we need to do is perform the forking gradually, so that we never have more than 20 kids at a time. One naive approach is to chunk the data into bite-size bits:
把上面所有的代码凑到一起就成了一个分出20个子进程来检查10台主机的漂亮的演示程序，但是它却不适合有254台主机的情况，还记得前面提到的每用户进程限制吗？那怎么办呢？我们可以循序渐进地分出子进程的嘛，这样我们就可以保证同时不会有超过20个子进程存在。一个笨办法就是把数据（这里指主机列表）分割成几个部分：
my @all_hosts = ...;
my %host_results;
while (my @hosts = splice @all_hosts, 0, 10) {
... process @hosts, adding into %host_results ...
}
... show results ...
Here, most of the code above gets wrapped into an outer loop which hands 10 hosts at a time to be processed, using splice to peel them off of the master list. While this strategy certainly solves the ``no more than 10 at a time'' condition, each batch of 10 has to wait for the slowest of the 10 to complete.
以上的代码在用 splice 函数将 @all_hosts 每次分成10份付给 @hosts，然后针对 @hosts 来进行多进程的处理，这样，用一个外层的 while 循环（相对于那个多进程处理的循环）来保证同时只处理主机总列表中的10台主机。这种策略的确能解决"同时不多于10台主机"的问题，但是实际上每一批 10台主机都要等前面的10台主机处理完后才能继续，这样显然太慢了。
A better way would be to fork until we hit the limit of active children, then wait for one child to finish before we need to fork again. First, we'll need to factor out ``waiting for a kid'' into a subroutine so we can call it in two different places: while forking a new task, and at the end to reap all the remaining children:
一种更好的方法就是如果正在运行的子进程数量没有达到设定的极限值，就继续 fork，否则就等待某个子进程完成然后再 fork。首先，我们需要把"等待某个子进程"写成一个子程序以方便我们在两个不同的地方调用：当为新任务创建子进程以及在最后收割所有仍然存在的子进程的时候。
sub wait_for_a_kid {
my $pid = wait;
return 0 if $pid < 0;
my $host = delete $pid_to_host{$pid}
or warn("Why did I see $pid ($?)\n"), next;
warn "reaping $pid for $host\n";
$host_result{$host} = $? ? 0 : 1;
1;
}
Note that we're accessing %pid_to_host and %host_result directly here, so those variables must be in scope before the subroutine definition. The subroutine now returns 1 if a kid was reaped, and 0 otherwise. The final reap loop now becomes:
注意我们这里是直接的访问散列 %pid_to_host 和 %host_result 的。所以它们必须已经在这个子程序定义之前定义了。当一个子进程被顺利收割时，该子程序返回1,否则返回0。程序最后的收割循环（译者注：这个收割循环会持续到所有的子进程全部被收割为止，这样是为了避免僵进程导致进程泄漏，关于僵进程和进程泄漏的概念，请自行查找有关资料）现在变成了：
## final reap:
1 while wait_for_a_kid();
At this point, the program functions identically to the prior one, except that I've refactored the kid reaping. The magic happens next. We'll put wait_for_a_kid in the middle of the forking loop as well, just before we're about to fork, conditionally if the number of kids is already at the maximum we chose:
到这步，除了我重新写的这个子进程收割程序，这个程序的功能就和先前的那个一样了。接下来将发生一些魔术般的事情,呵呵。我们将把 wait_for_a_kid 子程序放到创建子进程的那个循环中，调用 fork 之前,在子进程数达到设定的极限值时调用该子程序。
for (@hosts) {
wait_for_a_kid() if keys %pid_to_host >= 10;
...
Ahh. That does it. We can now crank @hosts back up to our 254 items. As we fire off the first 10, this new statement has no effect. But when it comes time for the 11th, we'll wait until at least one of the other 10 to complete first. So, at no time do we have more than 10 hosts active (using 20 child processes for reasons explained earlier). The entire program is given here in case you want to see it all in context:
啊哈！现在我们可以把 @hosts 中主机的数量增加到254台了。当在为前10台主机创建子进程的时候，这条新加的表达式并不起什么作用，但是，当为第11台主机创建子进程的时候，它就会一直等待直到至少有一台主机已经处理完毕才继续。这样，我们就不会在同一时间处理超过10台主机了（处理10台机会使用20个子进程，原因前面说过了）。下面就是完整的程序：
sub ping_a_host {
my $host = shift;
`ping -i 1 -c 1 $host 2>/dev/null` =~ /0 packets rec/ ? 0 : 1;
}
my %pid_to_host;
my %host_result;
sub wait_for_a_kid {
my $pid = wait;
return 0 if $pid < 0;
my $host = delete $pid_to_host{$pid}
or warn("Why did I see $pid ($?)\n"), next;
warn "reaping $pid for $host\n";
$host_result{$host} = $? ? 0 : 1;
1;
}
my @hosts = map "10.0.1.$_", "001".."254";
for (@hosts) {
wait_for_a_kid() if keys %pid_to_host > 10;
if (my $pid = fork) {
## parent does...
$pid_to_host{$pid} = $_;
warn "$pid is processing $_\n";
} else { # child does
## child does...
exit !ping_a_host($_);
}
}
## final reap:
1 while wait_for_a_kid();
for (sort keys %host_result) {
print "$_ is ", ($host_result{$_} ? "good" : "bad"), "\n";
}
As a working program, this does pretty good, although it could be made a bit more robust, and is very specific to the particular ping program on my machine. If you don't want to write this pattern of code into each program that wants to do parallel things, look at Parallel::Fork Manager in the CPAN, which does pretty much the same thing with a friendly interface.
虽然这个程序还可以进一步的完善以使它更强健，但现在他工作得很好，比起单单用我系统上的 ping 命令，用这个程序来完成任务就显得有效多了。如果你不想每次一涉及并行处理的事情就套用上面的代码，那么可以试试 CPAN 上的 Parallel::Fork Manager 模块，它也能够漂亮的实现到相同的效果，不过更妙的是它拥有一个更友好的接口。
One improvement to this program might be to pre-fork and re-use the children, using some sort of IPC (pipes or sockets) to communicate additional tasks to perform as each task completes, but I've run out of space to talk about that here. Until next time, enjoy!
预创建进程以及子进程重用（在每个任务完成的时候利用一些进程间通信（IPC）的方式（管道或者套接字）来与接下来的任务进行通讯）可以作为该程序的一个改进，但是这已经超出了本文的范围。okay, 希望你能喜欢这篇文章，下次再见！
―――――――――――――-
在 Parallel::Fork Manager 模块文档里摘一个实例给懒惰的 Perl 程序员 :) 这个例子会创建 30 个子进程来并行下载不同的链接。这要比亲自动手调用 fork 简单多了。
use LWP::Simple;
use Parallel::ForkManager;
...
@links=(
["http://www.foo.bar/rulez.data","rulez_data.txt"],
["http://new.host/more_data.doc","more_data.doc"],
...
);
...
# 同时使用 30 个进程
my $pm = new Parallel::ForkManager(30);
foreach my $linkarray (@links) {
$pm->start and next; # 开始 fork
my ($link,$fn) = @$linkarray;
warn "Cannot get $fn from $link"
if getstore($link,$fn) != RC_OK;
$pm->finish; # do the exit in the child process
}
$pm->wait_all_children;
First you need to instantiate the Fork Manager with the "new" constructor. You must specify the maximum number of processes to be created. If you specify 0, then NO fork will be done; this is good for debugging purposes.
首先通过 new 来初始化一个 Fork Manager 对象，同时必须标明最大进程数。如果使用 0 的话就可以避免 fork 来达到调试程序的作用。
Next, use $pm->start to do the fork. $pm returns 0 for the child process, and child pid for the parent process (see also "fork()" in perlfunc(1p)). The "and next" skips the internal loop in the parent process. NOTE: $pm->start dies if the fork fails.
然后使用 $pm->start 来开始 fork。 $pm 在子进程时返回 0 ,父进程时返回子进程的进程号（具体请参阅 Perl 的 fork 文档）。"and next" 用来跳过父进程。注意：如果 fork 失败的话， $pm->start 就提示错误，程序结束。
$pm->finish terminates the child process (assuming a fork was done in the "start").
$pm->finish 结束子程序（假设我们一开始使用了 start 来 fork）
NOTE: You cannot use $pm->start if you are already in the child process. If you want to manage another set of subprocesses in the child process, you must instantiate another Parallel::Fork Manager object!
注意：在子进程中不能使用 $pm->start。 如果你想在子进程中使用另外一组子进程，你必须再初始化一个 Parallel::Fork Manager 对象。
2007年6月13日星期三
Rich format blog
知道怎么通过 email 发布非纯文本格式的 blog 了，需要发送 html 格式的邮件。
我一直使用 GOOGLE 的搜索引擎，效果非常好，也就是搜索音频时才用百度。现在正式加入 GOOGLE fans 的行列 o(∩_∩)o... 。电子邮件用 Gmail，网络相册用 picasaweb ，网络日志用 blogger，包括自定义的 GOOGLE 页面 igoogle，GOOGLE 日历，功能确实强大。只是网络连接速度比国内网站要慢许多，这也难怪，中国的防火墙太厚了，连 blogger 都要通过 ftp 转发，想不通为什么要拦截 blogger。我想，这也是影响 GOOGLE 在中国业务发展的重要因素。但是国内几个所谓大网站提供的服务兼容性实在是太糟糕了，尤其是对非 windows 系统和非 ie 浏览器的兼容性。
中国的 Linux、Unix 用户太少了，目前国内的计算机应用大都处在超初级阶段，整天就是 word、excel、ppt，把计算机当成打字机、复印机来用，暴殄天物啊。专业计算机教育实践环节太少，程序不是读书读出来的，就像书法、美术一样，更重要的是写、练。学习算法仅仅把书本上的例子看懂了是没用的，把书收起来，自己写代码，一定要是可以运行的代码，让计算机给出最终的判断结果，这样才算是把这个算法掌握了。其实计算机科学(主要指软件方面)是理论与实践高度一致的科学，通过实际操作是理解、掌握理论知识的最佳途径。
Vim 7
与旧版本相比，在 Vim 7 中新增了多项重要的特性。
使用拼写检查功能:
Vim 7 内置了一项拼写检查功能，使用该功能可以检查出所拼写词语的错误。在默认情况下，这项功能是没有开启的。若是使用 GVim
的话，可通过"Tools -> Spelling -> Spell check on"菜单命令开启。Vim
一旦发现拼写错误的词语，则以红色的波浪线标记。而使用以下命令可以执行拼写检查功能的相关操作：
:set spell 开启拼写检查功能
:set nospell 关闭拼写检查功能
:]s 移到下一个拼写错误的单词
:[s 作用与上一命令类似，但它是从相反方向进行搜索
z= 显示一个有关拼写错误单词的列表，可从中选择
zg 告诉拼写检查器该单词是拼写正确的
zw 与上一命令相反，告诉拼写检查器该单词是拼写错误的
使用括弧高亮显示功能:
此特性在编码时非常具有帮助。对于如"{"、"}"之类的配对括弧，Vim 7 将高亮显示它们。如果不喜欢，可以使用":NoMatchParen"命令禁用该功能。
使用自动补完功能:
这是一个非常酷的特性。当你在写代码的时候，可以使用该功能帮助你自动完成标记、关键字等等。此功能支持 C、(X)HTML（包含
CSS）、JavaScript、PHP、Python、Ruby、SQL、XML 等语言。在插入模式中，连续按"[Ctrl+x]
[Ctrl+o]"组合键可以打开该功能。你可以从弹出的列表框中进行选择。
http://linuxhelp.blogspot.com/2006/09/visual-walk-through-of-couple-of-new.html
2007年6月12日星期二
Upgrade documents
From my.opera.com/redspider
尖括号(<>)的神奇特点：如果没有指定文件名，则其从标准输入流中自动打开和关闭一系列文件进行读入。但如果 $^I
中有字符串，这个字符串则会成为备份文件的扩展名。
(下面的代码通过给 @ARGV 赋值，模拟标准输入得到的文件名)
$^I = '.bak';# 备份文件后缀名
@ARGV = glob('*.txt');# 模拟命令行参数获得的文件名 :)
# 逐个打开从命令行获得的文件，更新内容
# 源文件以 $^I 定义的后缀名备份
while (<>) {
s/author/author: redspider/g;
print;# 默认输出自动被重定向至文件
}
# 删除备份文件
my @bakfiles = glob('*.bak');
for (@bakfiles) { unlink($_) }
RHCE note: shell scripts, configuration files
From redspid.blog.163.com
2007年 06月05日 00:55
2007年 06月05日 00:55
常用 Shell script:
/etc/rc.sysinit 系统初始化脚本
/etc/rc.local 用户自定义启动脚本
/etc/profile bash shell 登录脚本之一
使用 useradd 增加账号的默认设定在 /etc/login.defs 中
系统日志:
/var/log/dmesg 核心启动日志，用 dmesg 命令查看
/var/log/messages 系统报错日志
/var/log/maillog 邮件系统日志
/var/log/xferlog FTP 服务用日志
/var/log/secure 安全信息，系统登录与网络连接信息
/var/log/wtmp 登录记录
2007年6月11日星期一
RHCE Note
From redspid.blog.163.com
2007年 06月03日 23:28
Opera Blog 还是登录不上，好多重要的笔记都在上面，备份确实很重要。能访问 Opera Blog 的时候要把东西都转过来。
六一还行哈，honey_jing 应该比较满意吧，嘿嘿...
是时候好好复习提高一下 Linux 了，准备 RHCE !
登录用的虚拟控制台可根据需要增减，配置文件为 /etc/inittab
file 指令从系统配置文件 /usr/share/magic 中读取相应的文件规范
ls 指令标识文件颜色的定义在文件 /etc/DIR_COLORS 中
umask 在 /etc/profile 中设置
主机名配置在文件 /etc/sysconfig/network 中
Bash 中常用快捷键:
Ctrl + s ，Ctrl +q 暂停/恢复屏幕输出
Ctrl + l 清屏，相当于 clear
Ctrl + a 光标移至行首
Ctrl + e 光标移至行尾
Ctrl + k 删除光标至行尾的内容
Ctrl + u 删除整行
2007年 06月03日 23:28
Opera Blog 还是登录不上，好多重要的笔记都在上面，备份确实很重要。能访问 Opera Blog 的时候要把东西都转过来。
六一还行哈，honey_jing 应该比较满意吧，嘿嘿...
是时候好好复习提高一下 Linux 了，准备 RHCE !
登录用的虚拟控制台可根据需要增减，配置文件为 /etc/inittab
file 指令从系统配置文件 /usr/share/magic 中读取相应的文件规范
ls 指令标识文件颜色的定义在文件 /etc/DIR_COLORS 中
umask 在 /etc/profile 中设置
主机名配置在文件 /etc/sysconfig/network 中
Bash 中常用快捷键:
Ctrl + s ，Ctrl +q 暂停/恢复屏幕输出
Ctrl + l 清屏，相当于 clear
Ctrl + a 光标移至行首
Ctrl + e 光标移至行尾
Ctrl + k 删除光标至行尾的内容
Ctrl + u 删除整行
New starting
这一篇沿用 163 blog 上的标题，因为意义特殊哈 :)
From redspid.blog.163.com
From redspid.blog.163.com
2007/05/25 一个新的开始哈 ^^
(25日 开始，26日 honey_jing说表现不错，但要继续努力 嘿嘿)。
这也是163上的第一篇 BLOG，http://my.opera.com/redspid 这几天不知道为什么不能登录。我需要重开一个稳定点的
BLOG，以前的也要备份一下，好多精典呢。
Honey jing:
When you're lost and the light is fading
the wind blows cold and you can't find your way back home
remember that the darkest hour is just before the dawn
Sometimes a leap of fauth is all it takes
cause only love can see the path to set you free
just close your eyes, look inside, and let your heart believe
there's been a force so strong beside you all alone
you'll know it when your dream comes true
there's something only love can do
in your quest for a new horizon
set your course find a star to light your way
although the task may seen sometimes to be more than you can bear
one thing you need to know you are not alone
If you believe in miracles then you can be the one
to shine you light and show the world
There's nothing love can't overcome
There's something only love can do
First blog on blogger
http://my.opera.com/redspider 有一个月登录不上去了，在 http://redspid.blog.163.com 上记了几篇笔记。才发现 Google 也有 Blog，嘿嘿，太好了，一会就把 163 上的转过来。
我还是比较信任美国的技术，事实不容置疑啊。 :)
我还是比较信任美国的技术，事实不容置疑啊。 :)
订阅：
博文 (Atom)
