难忘2008-磨砺与灾难

今天是二〇〇〇八的最后一天， 我身在深圳的一间还有1个月就到期的出租房内， 身边的摆设有一台刚刚买的二手9成新自行车； 一台黑色伊莱克斯咖啡机；电脑桌上摆着一罐喝了一半的蜂蜜、一个自己用水溶C100饮料做的笔筒还有一本我想看却一直没看完的TAOCP， 自己坐在一间买了还没洗过但是还很干净的床单上，在一台联想-(减号) IBM 的笔记本上用短粗的手指打下这些文字。

这个开头有些烦人的冗长，也许正是在纪念2008之前给人的心理准备吧， 很多人都没有预料到这一年会有这么多事情发生。说明8这个数字也不是什么时候都是吉利的， 就是在这个会发的年份里， 有太多的人破产到一无所有。 就是这个被人们赋予无限希望的2008， 却成为多灾多难的一个代表。

今年发生了太多太多的大事，今天在这个浅薄的帖子中就不讨论这些了， 有些不重要的我们讨论的再多也会有一天想不起， 而那些刻苦铭心的事即使我们不愿提及，却能够从几个回眸之间了解全部所想。你一定猜到了我想说什么---- 5 1 2 ~_^~_~^_^^&&,时隔半年多了， 你那里的大地还在颤抖， 抖的人心里发毛。 今天坐在沙发上听到有一些隆隆的声音， 竖起耳朵仔细听，忽然想起了那一天在教室里面相同的情景， 和仓惶之间的逃跑。以及接下来的那几天， 讨厌的雨和颤抖的大楼我们从地板上一跃而起还有在晃完之后又回去。学校的操场上的露营还有已经各奔东西兄弟们的促膝长谈。 还记得在一个暴雨的夜晚，去女生宿舍宿舍里面和你一起出来避难的那次， 可爱的同学们抱着被子满布学校的露宿， 和那宿舍一楼大厅睡满人的壮观场景。 最重要的是在那些患难的日子里面体验到的真情。想起这些就觉得自己幸福多了， 因为我们现在还有吃还有穿不冷也不饿， 明天还能打着飞的去见面。 还能硬着头皮多请假，尽管在一个小时前我还在满腹的抱怨， 但是想着这些我觉得幸福多了。

2008还有一件事情就是大事-我工作了。想起在匆匆的离开学校， 匆匆的和你告别， 想起闲散的北京的几日游...一直想到现在。。。 还记得第一天到深圳有杨熙两口子（第一个领证的，NB）当向导， 还是吃了个狗屎， 公司竟然没有接的人。 这是我对赛龙的一次印象 ，绝对深刻， 而且深圳这个城市和我的想象只有一点可以符合， 那就是物价确实很贵。 其他诸如祖国的特区之类的没有特别的感觉， 也不过那样而已，同时也觉得深圳有些铜钱味道的俗气。 刚到公司就感觉到自己选错地方了， 这种感觉直到现在还没有减小-杂乱的前台， 到处都是乱放的东西， 狭小的办公空间， 和精神有些呆滞的人们。 而自己呢， 也被啥都不懂的HR分到了自己从来不愿意去的一个部门，同时暂时住在一间被用作办公室的毛坯房里面， 这样持续了一个星期。 一个星期之后， 我提出了换部门， 那个Bob（这个人的名字和我实习的时候那个经理一样）-当时我的上级还想说服我留下， 在第二天， 我写了一份很正式、诚恳的E-mail给他之后， 他同意让我转到当初选的部门。

那以后， 我就在我住的毛坯房里面上班了， 吃住都在那里了， 晚上还有一个很大的空调斥候着， 不亦乐乎。。。不过最终我还是找到了一个住处， 就是现在的住处-一件很小， 却很精致的房间。
就这样开始了， 开始一个做自己喜欢的职业-写程序的人（而不是这份工作）。

其实， 最最最重要的， 就是明天，就是PHR。

Without You, noting really make sense.

分享一首歌Plain White T's - Hey There Delilah

许愿

许个愿, 希望我们可以更加丰富， 希望我们可以更加深度， 希望我们的生活都丰富多彩。

金正日：身正不怕影斜（图）

作者： http://hexieshangan.blog.163.com/blog/static/89918497200810553251966

About Prelink & Enable prelink in Unbuntu

What is Prelinking?

Prelinking is a process that allows you to speed up the process of dynamic linking. What it does is, through a process of magic that is incredibly complex, but basically it speeds up the relocation process, in loading shared libraries.. by setting preferred load addresses.

What is he talking about, you ask? Well, here's how it goes. Dynamically linked libraries (often referred to as DSO's or in the windows world DLLs) are libraries which are loaded at runtime. The advantage of shared libraries versus static libraries is, that it reduces the size of executables, since each program doesn't need its libraries built in, but will dynamically locate and use it at run time. This adds some overhead, because the address space of the library, instead of being known in advance, has to be mapped at runtime. Another advantage of shared libraries is that due to the magic of copy-on-write, you can save memory when you have multiple programs sharing the same library (though it's not as simple as that.. it is pretty complicated)

Pre-linking sets preferred address space for the libraries to be loaded at. Note they are _preferred_ spaces, and if that address space is not available, then it will use relocation to load it dynamically.. hence pre-linking is not 100% foolproof.

What do I need to prelink?

To prelink, you need at least:
- glibc 2.3.1 or greater
- libelf or elfutils 0.7, though 0.8 is preferred. Latest version as of this writing is 0.84
- Your shared libraries have to be compiled with -fPIC
- the prelink program from ftp://people.redhat.com/jakub/prelink

HOWTO: Enable prelink


Prelink is in universe. I use it on my Ubuntu system without issues, but do google about Prelink and do your research before trying it out.

How to enable prelink:

1. Activate Ubuntu universe sources. The procedure is well-documented by Ubuntu.
2. use apt-get or synaptic to install prelink.
3. Open /etc/default/prelink with your favorite editor, as sudo/root.
4. Change PRELINKING=unknown from unknown to yes.
5. Adjust the other options if you know what the heck you're doing. Defaults work well.
6. To start the first prelink (the longest one!), run sudo /etc/cron.daily/prelink

In the future, prelink performs a quick prelink (a less-than-1-minute procedure on most systems) daily, usually at midnight. Every 14 days, or whatever you changed it to be, a full prelink will run.

If you just did a major apt-get upgrade that changed systemwide libraries (i.e. libc6, glibc, major gnome/X libs, etc etc etc) and experience cryptic errors about libs, rerun step 6.

To undo prelink, change step 4 from yes to no, then rerun step 6.


WARNING:
An amd64 users in another thread (http://ubuntuforums.org/showpost.php...3&postcount=16) reports having experienced trouble with AMD64 prelinking. I have NOT tried prelinking on anything other than an i386!

移植 tslib 到Android 的注意事项

tslib是这样的结构， tslib只是一个上层， 他主要是调用它的那些插件来处理从驱动那里得到的点，
插件的顺序是你的 ts.conf 里面的插件的顺序。
昨天发现能够从/dev/input/event1里面读出东西来， 却不能够用ts_test来响应，原来是驱动送上来的点不符合规则， （更搞笑的是他还没意识到这点， 坚持说自己是对的）， 我用的插件是 input 插件， 找到问题以后就好办了， 改configure.ac里面， 给自己加一个插件， 就叫ac97吧， 然后创建文件 tslib_src/plugins/ac97-raw.c ， 把你“特殊”的驱动加进去就可以了。

测试的时候， 发现很慢， 奇怪驱动送上来的点是很快的啊， 结果发现是因为我在读入每个点之后都打印了调试信息， 所以导致tslib的延迟， 如果你的系统也存在同样的问题， 最好去掉debug试一试， 毕竟终端是比较慢的设备。

其实把tslib放入Android里面首先要解决的问题是Android的编译系统， 你要把tslib， 和那些你用到的插件们都编译成动态库的形式， 可以参考其他库的Android.mk文件来编写， 还有就是你要把ts_test, ts_calebrate编译成可执行文件， 同样是编写Android.mk。

因为Android是从/dev/input/event0读入鼠标事件， 我们的想法就是不要去改动他的代码， 在后台运行一个daemon， 它就是把 /dev/input/event1中读出来的坐标（经过校准的），inject到event0里面， 这样一来就可以不修改Android的代码， 而加入我们的东西。
我在想， 要不要把tslib的东西checkin到Android的baseline中呢。 这是一个好想法。 毕竟不是所有人都用电容触摸屏的。

移植进入Android里面可能会有这样的问题， 就是点击触摸屏和键盘会没有反应， 其实这是因为电源管理相关的东西导致的， 如果你也遇到同样的问题， 那么请屏蔽掉 _android_src_/hardware/libhardware/power.c中的函数（关键是最后一个函数， 函数名我忘了呵呵）。

PS：fprintf到stderr上严重影响性能， 用打log调试确实不是一个好的方法， 在tiny loop和相应用户事件的地方不要大量的打log， 这也是为什么让我体会到了Android中的logger设备的优点啊。

苍白

早上起来， 睁开眼睛。 发觉自己如同关在一个烤炉里散失这水分。原来是没有开窗户。 外面传来工地和机械的嘈杂声， 想着昨天一夜之间我失去了什么。 想着那些话， 那些现在已经开始的话，

后脑有些镇痛， 大概是熬夜加刺激的原因， 看着房间里面的家具， 竟然和昨天完全不一样， 于是也重新拾起了被我遗弃已久的博客。

我醒着吗？ 感觉它们都是一个个静物，我变成了素描画。除了我没有定格， 其他的东西都已经和我没有关系，黑白色。尽管他们有很多都已经不是原来的颜色， 但是现在看到的都是黑白色。 不，只有白色的色调变化而已。

有风轻轻吹入房间， 原来是我已经打开了窗户， 管着的房门也因为风的缘故发出一些响声， 奇怪， 这些都是我熟悉的。 为何如此陌生了。

一个， 两个脚直接踏在地板上，  也许以前不经常这么做吧， 或许我发觉了我的身体或者说皮囊已经开始和我的灵魂有些偏移， 重影有些错位， 就像没有印刷好的一张照片。 去看看小可，也许会让我好些。

对了， 我很无知， 原来这个季节已经没有台风了。  所以计划赶不上变化。

我才发觉， 有许多我没有关注的事情， 尤其是她的细微感受。

“世界非常安静
需要深呼吸 才能呼吸”

无趣，即使对于android

对android了解的越多， 当初的兴趣就慢慢的没那么浓厚了。 感觉差距很大啊， 鸿沟一样。 而我们还在用着陈旧的方法，低级的手段， 做这样的开发让我感觉很累。 很无趣。 让人感觉不到希望。

这行， 我算了解很多了。

要想办法转行了。

android eabi lib

Android SDK里面所带的二进制库生成全部是EABI兼容的， 那么什么是EABI？ 对
我们有什么意义呢？

1.这里现介绍一下什么是EABI（Embedded Application Binary Interface）

EABI最早是从powerPC 在 UNIX V5 的ABI（Application Binary
Interface）的补充的基础上构建的， 他的木表示减少内存使用和优化执
行速度， 而且这些都是特别针对于嵌入式系统软件的。
EABI规定了一下几个内容：
* 文件的格式
* 数据类型和对齐
* 寄存器用法的规定
* 堆栈布局和组织
* 函数参数传递顺序
* 小数据区域(data area)的用法和组织

2. 对我们有什么意义呢？
EABI兼容的二进制库除了在速度上有所优化以外， 它还保证了一样东
西。
就是让软件开发着可以混合使用EABI兼容的不同厂商之间的二进制库，
只要他们是EABI兼容的， 并且开发者的软件也是用EABI兼容的编译起编
译的， 就可以正确的一起使用。

这样， 我们就可以在不能拿到代码， 或者是专门为本平台编译过的二进
制库的情况下来使用这些二进制库。

就近来讲， 就是Android SDK 里面带的.so文件， 有一些我们可以不必
要拿到代码，或者重新编译。 但是为了能够正确的使用这些库。 可能还
是需要一些支持工作。 比如这些库和驱动之间的接口之类的。

[转贴] Pointers to C++ Member Functions

这篇文章很好的讲述了指向成员函数的指针怎么用， 后面对性能做了分析很精彩。

A tutorial on a useful yet poorly understood language feature, useful as a cache or to enable a different sort of polymorphism.

Michael D. Crawford
crawford@goingware.com

Copyright © 2002 Michael D. Crawford.

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.

Abstract

Pointers to Member Functions are one of C++'s more rarely used features, and are often not well understood even by experienced developers. This is understandable, as their syntax is necessarily rather clumsy and obscure.

While they do not have wide applicability, sometimes member function pointers are useful to solve certain problems, and when they do apply they are often the perfect choice, both for improved performance and to make the code sensible. They work very well to cache the result of a frequently made decision, and to implement a different sort of polymorphism.

I discuss what member function pointers are, how to declare and use them, and give some examples of problems that they solve very well.

Contents

• Abstract
• Introduction
• Member Function Pointers Are Not Just Simple Addresses
• Caching the Outcome of a Decision
• The Performance of Member Function Pointers
• Details About Using Member Function Pointers
• A Different Sort of Polymorphism

Introduction

I don't have any hard numbers on how frequently member function pointers are used. While Ido see others mention them sometimes in Usenet and mailing list posts, I have yet to find someoneelse use one in code I have worked with, so my impression is that they are not commonly applied.

Member function pointers are important because they provide an efficient way to cache the outcome of a decision over which member function to call. They can save time, and in some cases, provide a design alternative that avoids the need to implement such decision caching through memory allocation. I will return to this further on.

Member function pointers allow one to call one of several of an object's member functions indirectly. Each of the functions whose "address" is stored must share the same signature.

I put "address" in quotes because the information stored in a member function pointer is not simply the memory address of the start of the member function's code; conceptually it is an offset into the list of functions declared by the class, and in the case of virtual functions will include a real offset into the vtbl, or table of virtual function pointers.

Member function pointers cannot be dereferenced (have their function called) directly by themselves. They must be called on behalf of some object, that then provides the "this" pointer for use by the member functions.

To illustrate how to declare and call a member function pointer, I will start by giving an example ofdeclaring and dereferencing an ordinary pointer to a non-member function. You declare a functionpointer by giving the prototype of a function it can point to, with the name of the function replacedby (*pointerName). Regular function pointers share the same syntax between C and C++:

void Foo( int anInt, double aDouble );void Bar(){        void (*funcPtr)( int, double ) = &Foo;        (*funcPtr)( 1, 2.0 );}

For regular function pointers, it is optional to use the address-of operator & when taking the address of a function, but it is required for taking the address of member functions. g++ will compile source that leaves it out, but emits a warning.

To declare a pointer to member function, you give the prototype of a function it can point to, as before, but the name of this function is replaced by a construction that scopes the pointer - you give it the name of the class whose member functions it can point to, as (ClassName::*pointerName). Note that a given member function pointer can only point to functions that are members of the class it was declared with. It cannot be applied to an object of a different class even if it has member functions with the same signature.

You dereference a member function pointer by using .* or ->*, supplying a reference or pointer to an object on the left, as appropriate, and the function pointer on the right.

Here is a simple example:

class Foo{       

public:

              double One( long inVal );

              double Two( long inVal );

};

void main( int argc, char **argv )

{	

   double (Foo::*funcPtr)( long ) = &Foo::One; 	

      Foo aFoo;

	double result =(aFoo.*funcPtr)( 2 );

 return 0;

}

Declaring a member function pointer is clumsy at best and is hard to get right until you have used them for a while. Rather than declaring them using the full prototype each time, it is helpful to use a typedef as I show in the example below.

Member Function Pointers Are Not Just Simple Addresses

Most C and C++ programmers know that it is bad style to assume that a pointer is the same size as an int, although this may often be the case. What is less well known is that pointers of different types may not be the same size as each other. For example, in 16-bit x86 programming near pointers and far pointers may have different sizes, where the far pointers consist of the segment and offset together, while near pointers just have the offset. Member function pointers are generally small structures, that encode information about a function's virtualness, multiple inheritance and so on.

In the case of the example shown below, compiled with g++ 2.95.2 on a PowerPC G3 Mac OS X iBook, I found that the size of the member function pointer I created was eight bytes.

This can result in surprises to the user. For example, Microsoft Visual C++ 6 allows the programmer to make an optimization (which is apparently enabled by default) which can cause member function pointers that are intended to be the same type but are declared in different circumstances to have different sizes. Using the wrong setting for your project may result in an apparently gross code generation bug, because a member function pointer returned by a function that supplies them may have a different size than the recipient function expects, causing bogus data to be overwritten on the stack.

There is an item in VC++'s settings labeled "representation" that has a choice between "best case always" and "most general always". If you work with member function pointers in Visual C++, check the documentation for what these settings do and select the right one; if in doubt, select "most general always".

Caching the Outcome of a Decision

One of the best uses for member function pointers is caching the outcome of a decision over which ofseveral member functions should be called in a particular circumstance. If a decision is always going to yield the same result, then it may be faster and even cleaner to make the decision just once ahead of time, then store the outcome in the form of a member function pointer. This is especially advantageous when the decision will be made repeatedly in a loop.

Here is an admittedly silly (but hopefully clear) example, that shows a member function pointer being used to store the outcome of a decision. It also illustrates the use of typedef:

#include 

#include 

class Test{

 public:

 Test( long inVal )

 : mVal( inVal )

{}

 long TimesOne() const;

 long TimesTwo() const;

 long TimesThree() const;

 private:	

	long mVal;

};



typedef long (Test::*Multiplier)() const;

int main( int argc, char **argv )

{

 using std::cerr;

 using std::endl;

 using std::cout;

 if ( argc != 3 ){

 cerr  << "Usage: PtrTest value factor"  << endl;

 return 1;

 }

 Multiplier funcPtr;

 switch( atol( argv[ 2 ] ) ){

 case 1:

 funcPtr = &Test::TimesOne;

 break;

 case 2:			

funcPtr = &Test::TimesTwo;

 break;		

case 3:			

funcPtr = &Test::TimesThree;

 break;		

default:			

cerr << "PtrTest: factor must range from 1 to 3"  << endl;			

return 1;	

}	

cout  << "sizeof( funcPtr )="  << sizeof( funcPtr )  << endl;

 Test myTest( atol( argv[ 1 ] ) );

 cout << "result="  << (myTest.*funcPtr)()  < return 0;

}

long Test::TimesOne() const{

 return mVal;

}

long Test::TimesTwo() const{

 return 2 * mVal;

}

long Test::TimesThree() const{

 return 3 * mVal;

}

Now I present an example that does not perform as well as it could because performs a switch decision many times inside a loop, always reaching the same decision. It is a good candidate to refactor by using a pointer to member function. Again it is a silly example but I wanted to be very clear:

#include class Test{

 public:	

	Test( long inFactor )	

		: mFactor( inFactor ){}

 long TimesOne( long inToMultiply ) const;

 long TimesTwo( long inToMultiply ) const;

 long TimesThree( long inToMultiply ) const;	

	long MultiplyIt( long inToMultiply ) const;

 private:	

	long mFactor;};

long Test::MultiplyIt( long inToMultiply ) const{

 switch( mFactor ){

 // decision made repeatedly that always yields the same result		



case 1:			

return TimesOne( inToMultiply );			

break;		

case 2:	

		return TimesTwo( inToMultiply );		

break;		

case 3:			

return TimesThree( inToMultiply );		

	break;		

default:			

throw std::exception();	

}

}

void MultiplyThem( long inFactor )

{	

Test myTest( 2 );	

	long product;	// Call a function that makes the same decision many times	



for ( long i = 0; i < 1000000; ++i )		

product = myTest.MultiplyIt( i );

}

In most cases where an identical decision is made inside a loop, it is better to refactor the code so that thedecision is outside the loop, and the loop is repeated in each branch of the loop (or packaged inside a subroutine):

void Foo( long value ){	for ( long i = 0; i < 1000000; ++i ){	

	switch( value ){	

	// BAD CODE: always reaches the same decision		

		case 1:				//...			

	break;			case 2:			

	//...				break;			

case 3:				//...				

break;		}

 }

}

Instead we place the switch outside the loop:

void Foo( long value ){	switch( value ){	

	// BETTER CODE: decision made only once	

	case 1:		

	for ( long i = 0; i < 1000000; ++i ){	

			//...			

}			

break;		

case 2:			

for ( long i = 0; i < 1000000; ++i ){			

	//...		

	}		

	break;		

//...

 }

}

If you want to avoid repeating the loop implementations and each branch of the decision has similar code, you can place them inside subroutines.

Member function pointers are the best solution when it is not practical to refactor this way. Onereason might be that the loop and the decision are in code that belongs to different classes, and you do not want to expose the implementation of the class that makes the decision. Here is the MultiplyIt code above, refactored to use a pointer to member function:

#include class Test{	public:		Test( long inFactor );		long TimesOne( long inToMultiply ) const;		long TimesTwo( long inToMultiply ) const;		long TimesThree( long inToMultiply ) const;		long MultiplyIt( long inToMultiply ) const;	private:		typedef long (Test::*Multiplier)( long inToMultiply ) const;		long       mFactor;		Multiplier mMultFuncPtr;		static Multiplier GetFunctionPointer( long inFactor );};Test::Test( long inFactor )	: mFactor( inFactor ),	  mMultFuncPtr( GetFunctionPointer( mFactor ) ){	return;}Test::Multiplier Test::GetFunctionPointer( long inFactor ){	switch ( inFactor ){	// Decision only made once!		case 1:			return &Test::TimesOne;			break;		case 2:			 return &Test::TimesTwo;			break;		case 3:			 return &Test::TimesThree;			break;			default:			throw std::exception();	}}			long Test::MultiplyIt( long inToMultiply ) const{	// Using cached decision result	return (this->*mMultFuncPtr)( inToMultiply );	}void MultiplyThem( long inFactor ){	Test myTest( 2 );		long product;	for ( long i = 0; i < product =" myTest.MultiplyIt(">

The Performance of Member Function Pointers

Unfortunately, calling a member function by dereferencing a member function is more complicated than simply doing a subroutine jump off a register. The pointers are actually small structures and a little bit of work is required to find the actual address of the subroutine to jump to.

I'm afraid I do not have the g++ source code at hand or I could show you the implementation. I know that in tracing through calls via member function pointers in Metrowerks CodeWarrior for Windows, I found that a call would run a small piece of assembly code provided by CodeWarrior's library. This is pretty fast code, and will run very fast in a tight loop if it stays in the CPU's L1 cache, but it is not as fast as a simple compare and conditional branch.

If the decision your code is making repeatedly is very quick to run, it may not be to your advantage to use a member function pointer. A simple if statement that compares two numeric values, or checks the value of a bool, or possibly a switch statement whose alternatives are all contained in a small range (so it is easy for the compiler to build a jump table) may be quicker than dereferencing a member function pointer.

However, if the decision is complicated or lengthy to arrive at, like string comparison or searching some data structure, then using a pointer to member function may be a big win.

Details About Using Member Function Pointers

You may understand the reasons for implementing pointers to member functions as structures if you see that they can be assigned to the addresses of routines with different kinds of implementations, as long as they have the same calling convention:

class Different{	public:		inline void InlineMember();		virtual void VirtualMember();		void OrdinaryMember();		static void StaticMember();		typedef void (Different::*FuncPtr)();};void Test(){	Different::FuncPtr ptr = &Different::InlineMember;	ptr = &Different::VirtualMember;	ptr = &Different::OrdinaryMember;}

(You may be surprised to see me creating a pointer to an inline function, but this is perfectly normal. If you do this, the compiler will place a normal subroutine version of the inline's implementation in an object file and give you the address of that, so the function pointer does not really point to an inline function at all.)

However, although a static member function may appear to have the same calling convention, it really does not because it is not passed the this pointer - this is passed to your member functions just like any other parameter, but it is not given explicitly in the member function's prototype. You cannot use pointers to member functions to store the address of a static function (use an ordinary, non-member function pointer for that):

void Fails(){      

Different::FuncPtr ptr = &Different::StaticMember;}



mike% c++ different.cppdifferent.cpp: In function `void Fails()':different.cpp:24: initialization to `void (Different::*)()' from `void (*)()'

Pointers to virtual member functions work just like calling a virtual member function directly - the type whose member function gets called is the dynamic type of the object it is called on behalf of, not the static type of the member function pointer:

#include class Base{	public:		virtual void WhoAmI() const;		typedef void (Base::*WhoPtr)() const;};class Derived: public Base{	public:		virtual void WhoAmI() const;};void Base::WhoAmI() const{	std::cout << "I am the Base" <<>Base::WhoPtr func = &Base::WhoAmI;	Base theBase;	(theBase.*func)();	Derived theDerived;	(theDerived.*func)();	return 0;}

Running the above program yields the following output:

mike% ./virtualI am the BaseI am the Derived

A Different Sort of Polymorphism

Polymorphism in C++ is usually regarded as always implemented in the form of class heirarchies containing virtual member functions.

An object of a derived class can be supplied to create a pointer or reference to what is apparently the base class; a function pointer lookup in the vtbl is done when calling a virtual member function off a pointer or reference, so that the function called will be based on the dynamic type that the pointer or reference denotes - that is, it will be from the actual type of the object that was allocated, rather than the static type that the base class pointer or reference is declared as.

However, the concept of polymorphism can take a more general meaning than that, and I have seen mailing list postings advocating that it should also include the use of templates that allow source code with identical syntax to be applied to objects of unrelated types. This std::vector can be regarded as a polymorphic container that is parameterized by the type supplied as a parameter when a vector object is declared.

Pointers to member functions can be used to implement a different kind of polymorphism. In the regular type, we determine which member function ultimately gets called by allocating objects of different types, that are related members in an inheritance tree. This is implemented by having the vptr that is a hidden member of the object point at the appropriate vtbl.

In this other form you create objects that are always of the same type, but determine which member function gets called by choosing which member function's address gets assigned to a member function pointer. One interesting advantage is that you can change the behaviour of an object during its lifetime without having to allocate a new one of a different type as you would with the regular sort of inheritance-based polymorphism.

[Linux Quality Database][Articles][Top]

懂得承认失败

今天过了很休闲的一天。 虽然失去了与大家玩的机会， 但是却又意外的收获。

先看了本《programming Lua》见识了这个小巧的lisp似的C语言的精巧的语言的威力，同时也对tail recurion有了新的见地。 还有多了些 lambda 的理解。

其实最重要的收获还是， 对性格上的理解。
事情是这样的， 上网查到了书店的关门时间是晚上9：00， 于是在拿起第二本书《梦断代码》的时候，预先估计了一下时间，当时是7：40。 因为第一本书看完了， 想再更宏伟一点， 看完第二本书。 长时间盯着那么近的东西，无论是计算机屏幕还是书本， 我的眼睛都会受不了， 会有眩晕的感觉。看这本书显然没有看第一本书那么快， 因为第一本书相对来说很熟悉， 看得很快。 而第二本书就不同了，很多新鲜的东西，所以看得很慢。

书中讲述Chandler[1]这个项目的发展。看似和人性没什么关系。但是却发现很多共通的地方， 毕竟这些东西都是人做的嘛。

看着看着时间已经到了9：00了， 书店似乎还没有关门的迹象， 可是我的眼睛却有些支撑不住了， 开始有些眩晕。 眼看完不成自己定的任务了。于是在短暂的休息之后， 我和自己说尽快看， 于是看的速度表面上提高了。

Chandler 的进展和我现在的状态有相似之处， 自己给自己设定的期限快到了， 眼看就完不成了， 于是在开始疯狂的提高表面速度。

可是在真正的关门时间到来的时候， 我的第一个想法是， 再快点再快点。 可是书还有100多页。 接下来我意识到了自己的问题：强迫症。
于是， 我放下了书， 放松的走出了书店。相对于看完一本书， 我得到了更多的东西。 有些时候， 你必须不能着急。 就像9：00以后我看过的东西基本上没有在脑子里面留下印象，更别说思考了。 所以， 那种逼迫的情况下做了一些无意义的东西。 这些事可能成为以后的麻烦（当然这件事中不存在）。

更深层一点考虑，结合现在所发生在社会上的一些事。 得出一个结论：学会承认失败。
在已经彻底失败的时候， 还抱有幻想并且歇斯底里往往会使事情更糟。 更好的做法是，痛定思痛， 冷静下来思考错在哪里。有时甚至需要扔掉这个已经错误的尝试， 想改经它可能是一个噩梦（这更符合git的观点）。

软件如此，人生如此。

注记

【1】：Chandler 是一个由Mitch Kapor（莲花软件公司的创始人）领导的"信息管理软件"，如果这个名字听起来有些不着边际，不妨参照Wired 的说法，叫它"Outlook 杀手"  .这个软件的开发在2002年就已经正式了， 但是现在2007年的时候还未完成。一个由像Mitch Kapor 这样的软件行业的传奇人物领导的团队为什么到现在还不能拿出一个相对完整的版本， 不得不让人好奇。

如何成为一名Hacker

摘自大教堂与集市

附录A 如何成为一名Hacker


目录
-----------------
为什么会有这份文档？
什么是黑客？
黑客应有的态度
黑客的基本技能
黑客文化中的地位
黑客和书呆子（Nerd）的联系
风格的意义
其它资源
FAQ（常问问题解答）


为什么会有这份文档？

　　作为《Jargon File》的编辑和一些其他有名的类似性质文章的作者，我经常收到充满热情的网络新手的email提问（确实如此）“我如何才能成为一名出色的黑客？”非 常奇怪的是似乎没有任何的FAQ或者Web形式的文档来说明这个十分重要的问题，因此我写了一份。

　　如果你现在读的是这份文档的离线拷贝，那么请注意当前最新版本（英文版）在 http://www.tuxedo.org/~esr/faqs/hacker-howto.html 可以得到。

　　注意：在这份文档最后有FAQ（常问问题解答）。请在向我提出任何关于这份文档的疑问之前读两遍。

　　目前这份文档有很多翻译版本：保加利亚语，简体中文，繁体中文，丹麦语，荷兰语，法语，德语，匈牙利语，印尼语，日语，朝鲜语，葡萄牙语，俄语及瑞典语。注意由于这份文档时有修正，所以以上翻译版本可能有不同程度的过时。


什么是黑客？

　　《Jargon File》包含了一大堆关于“hacker”这个词的定义，大部分与技术高超和热衷解决问题及超越极限有关。但如果你只想知道如何成为一名黑客，那么只有两件事情确实相关。

　　这可以追溯到几十年前第一台分时小型电脑诞生，ARPAnet实验也刚展开的年代，那时有一个由程序设计专家和网络名人所组成的，具有分享特 点的文化社群。这种文化的成员创造了“hacker”这个名词。黑客们建立了Internet。黑客们发明出了现在使用的UNIX操作系统。黑客们使 Usenet运作起来，黑客们让WWW运转起来。如果你是这个文化的一部分，如果你对这种文化有所贡献，而且这个社群的其它成员也认识你并称你为 hacker，那么你就是一位黑客。

　　黑客精神并不仅仅局限在软件的黑客文化中。有人用黑客态度对待其它事情，如电子学和音乐——事实上，你可以在任何最高级别的科学和艺术活动中 发现它。精于软件的黑客赞赏这些在其他领域的同类并把他们也称作黑客——有人宣称黑客天性是绝对独立于他们工作的特定领域的。但在这份文档中，我们将注意 力集中在软件黑客的技术和态度，以及发明了“黑客”一词的以共享为特征的文化传统之上。

　　有一群人大声嚷嚷着自己是黑客，但他们不是。他们（主要是正值青春的少年）是一些蓄意破坏计算机和电话系统的人。真正的黑客把这些人叫做“骇 客”（cracker），并不屑与之为伍。多数真正的黑客认为骇客们又懒又不负责任，还没什么大本事。专门以破坏别人安全为目的的行为并不能使你成为一名 黑客，正如用铁丝偷开走汽车并不能使你成为一个汽车工程师。不幸的是，很多记者和作家往往错把“骇客”当成黑客；这种做法一直使真正的黑客感到恼火。

　　根本的区别是：黑客搞建设，骇客搞破坏。

　　如果你想成为一名黑客，请接着读下去。如果你想做一个骇客，去读alt.2600新闻组，并在意识到你并不像自己想象的那么聪明后去坐五到十次监狱。关于骇客，我只想说这么多。


黑客应有的态度

　　黑客们解决问题，建设事物，同时他们崇尚自由和无私的双向帮助。要被他人承认是一名黑客，你的行为得体现出你好像具备了这种态度一般。而要想做得好象你具备这种态度一般，你就得切切实实坚持它。

　　但是如果你认为培养黑客态度只是一条在黑客文化圈中得到承认的路子，那就大错特错了。成为具备这些特质的这种人对你自己非常重要——有助于你 学习，及给你提供源源不断的动力。同所有创造性的艺术一样，成为大师的最有效方法就是模仿大师的精神——不仅从智力上，也要从感情上进行模仿。

　　或许，下面这首现代的禅诗很好的阐述了这个意思：

　　　　To follow the path:（沿着这样一条道路：）
　　　　look to the master,（寻找大师，）
　　　　follow the master,（跟随大师，）
　　　　walk with the master,（与大师通行，）
　　　　see through the master,（洞察大师，）
　　　　become the master.（成为大师。）

　　嗯，如果你想成为一名黑客，反复读下面的事情直至你相信它们：

　　1. 世界充满了待解决的迷人问题

　　做一名黑客会有很多乐趣，但却是要费很多气力方能得到的乐趣。这些努力需要动力。成功的运动员从锻炼身体、超越自我极限的愉悦中得到动力。同样，做黑客，你得能从解决问题，磨练技术及锻炼智力中得到基本的乐趣。

　　如果你还不是天生的这类人又想做黑客，你就要设法成为这样的人。否则你会发现，你的黑客热情会被其他分心的事物吞噬掉——如金钱、性和社会上的虚名。

　　（同样你必须对你自己的学习能力建立信心——相信尽管当你对某问题近乎一无所知，但只要你一点一点地试验、学习，最终会掌握并解决它。）

　　2. 一个问题不应该被解决两次

　　聪明的脑袋是宝贵的有限的资源。当世界还充满非常多有待解决的有趣的新问题时，它们不应该被浪费在重新发明轮子这类事情上。

　　作为一名黑客，你必须相信其他黑客的思考时间是宝贵的——因此共享信息，解决问题并发布结果给其他黑客几乎是一种道义，这样其他人就可以去解决新问题而不是不断地忙于对付旧问题。

　　（你不必认为一定要把你所有的发明创造公布出去，但这样做的黑客是赢得大家极度尊敬的人。卖些钱来养家糊口，租房买计算机甚至发大财和黑客价值观也是相容的，只要你别忘记你还是个黑客。）

　　3. 无聊和乏味的工作是罪恶

　　黑客（泛指具有创造力的人们）应该从来不会被愚蠢的重复性劳动所困扰，因为当这种事情发生时就意味着他们没有在做只有他们才能做的事情——解决新问题。这样的浪费伤害每一个人。因此，无聊和乏味的工作不仅仅是令人不舒服而已，而且是罪恶。

　　作为一个黑客，你必须坚信这点并尽可能多地将乏味的工作自动化，不仅为你自己，也为了其他人（尤其是其他黑客们）。

　　（对此有一个明显的例外。黑客有时也做一些在他人看来是重复性或枯燥的工作以进行“脑力休息”，或是为了获得某种技能，或是获得一些除此以外无法获得的特别经验。但这是自愿的——有脑子的人不应该被迫做无聊的活儿。）

　　4. 自由万岁

　　黑客们是天生的反独裁主义者。任何能向你发命令的人能够迫使你停止解决令你着迷的问题，同时，按照独裁者的一般思路，他通常会给出一些极端愚昧的理由。因此，不论何处，任何独裁主义的作法，只要它压迫你和其他黑客，你就要和它斗到底。

　　（这并非向所有权威挑战。儿童需要监护，罪犯要被看管起来。如果服从命令得到某种东西比起用其他方式得到它更节约时间，黑客可以同意接受某种形式的权威。但这是一个有限度的，有意的交易；那种权威想要的个人服从不是你应该同意给予的。）

　　权威喜欢审查和保密。他们不信任自愿的合作和信息的共享——他们只喜欢由他们控制的所谓“合作”。因此，作为一个黑客，你得对审查、保密，以及使用武力或欺骗去压迫有行为能力的人们的做法有一种本能的敌意。同时你要有为此信念斗争的意愿。

　　5. 态度不能替代能力

　　作为一名黑客，你必须培养起这些态度。但只具备这些态度并不能使你成为一名黑客，也不能使你成为一个运动健将和摇滚明星。成为一名黑客需要智力，实践，奉献精神和辛苦工作。

　　因此，你必须学会怀疑，并尊重各种各样的能力。黑客们不会为那些装模做样的人浪费时间，但他们却非常尊重能力——尤其是从事黑客工作的能力，不过任何能力总归是好的。具备很少人能具备的那些方面的能力尤其好，其中具备涉及脑力、技巧和专注方面能力的当然最好。

　　尊敬能力，你就会享受到提高自己能力的乐趣——辛苦的工作和奉献会变成一种高度娱乐而非苦差事。要想成为一名黑客，这一点非常重要。


黑客的基本技能

　　黑客态度重要，但技术更加重要。态度无法替代技术，在你被别的黑客称为黑客之前，有一些基本的技术你必须掌握。

　　这些基本技术随着新技术的出现和老技术的过时也随时间在缓慢改变。例如，过去内容包括使用机器语言编程，而直到最近才包括了HTML。总的来说现在主要包括以下技术：

　　1. 学习如何编程

　　这当然是最基本的黑客技能。如果你还不会任何编程语言，我建议你从Python开始。它设计清晰，文档齐全，合适初学者入门。它是一门很好的 入门语言，并且不仅仅只是个玩具；它非常强大、灵活，也适合做大型项目。我有一篇Python评价详细说明这点。好的教程可以在Python网站得 到。（译者：比较好的中文Python站点可能是http://pythonrecord.51.net。）

　　Java也是好的入门语言。它比Python难得多，但是生成的代码速度也快得多。它同时也是一种优秀的计算机语言，不止是用来入门。

　　但是注意，如果你只会一两门语言，你将不会达到黑客所要求的技术水平，甚至也不能达到一个程序员的水平——你需要学会如何以抽象的方式思考编 程问题，独立于任何语言。要做一名真正的黑客，你需要学会在几天内通过一些手册，结合你现在所知，迅速掌握一门新语言。这意味着你应该学会几种截然不同的 语言。

　　如果要做一些重要的编程工作，你将不得不学习C语言，Unix的核心语言。C++与C非常其他类似；如果你了解其中一种，学习另一种应该不难。但这两种都不适合编程入门者学习。而且事实上，你越避免用C编程，你的工作效率会越高。

　　C非常有效率，节约你的机器资源。不幸的是，C的高效是通过你手动做很多底层的管理（如内存）来达到的。底层代码都是复杂极易出现bug的， 会使你花极多的时间调试。如今的机器速度如此之快，这通常是得不偿失——比较明智的做法是使用一种运行较慢、较低效率，但大幅节省你的时间的语言。因此， 选择Python。

　　其他对黑客而言比较重要的语言包括Perl和LISP。Perl实用，值得一学；它被广泛用于动态网页和系统管理，因此即便你从不用Perl 写程序，至少也应该学会看。许多人使用Perl的理由和我建议你使用Python的理由一样，都是为了避免用C完成那些不需要C高效率的工作。你会需要理 解那些工作的代码的。

　　LISP值得学习的理由不同——最终掌握了它时你会得到丰富的启迪和经验。这些经验会使你在以后的日子里成为一个更好的程序员，即使你实际上很少使用LISP本身。

　　当然，实际上你最好五种都会（Python，Java，C/C++，Perl和LISP）。除了是最重要的黑客语言外，它们还代表了截然不同的编程思路和方法，每种都会让你受益非浅。

　　这里我无法给你完完全全的指导教会你如何编程——这是个复杂的技能。但我可以告诉你，书本和上课也不能作到（最好的黑客中，有许多，也许几乎 都是自学成材的）。你可以从书本上学到语言的特点——只是一些皮毛，但要使书面知识成为自身技能只能通过实践和虚心向他人学习。因此要作到（一）读代码及 （二）写代码。

　　学习如何编程就象学习用优美的自然语言写作一样。最好的做法是读一些大师的名著，试着自己写点东西，再读些，再写点，再读些，再写点……如此往复，直到你的文章达到你体会到的范文的简洁和力量。

　　过去找到适合阅读的好的代码是困难的，因为几乎没有大型程序的源代码能让新手练手。这种状况已经戏剧性地发生变化；开放源代码软件，编程工具和操作系统（全都由黑客写成）现在已经随处可见。让我们在下一个话题中继续讨论……

　　2. 得到一个开放源代码的Unix并学会使用、运行它

　　我假设你已经拥有或者能使用一台个人电脑（今天的孩子们真幸福 :-））。新手们能够朝学习黑客技能迈出的最基本的一步就是得到一份Linux或BSD-Unix的一种，安装在个人电脑上，并运行它。

　　没错，这世界上除了Unix还有其他操作系统。但它们都是以二进制形式发布的——你无法读到它的源代码，也不可能修改它。尝试在运行DOS或Windows或MacOS的机器上学习黑客技术，就象是带着脚镣学跳舞。

　　除此之外，Unix还是Internet的操作系统。你可以学会上网却不知道Unix，但你不了解Unix就无法成为一名Internet黑 客。因此，今天的黑客文化在很大程度上是以Unix为中心的。（这点并不总是真的，一些很早的黑客对此一直很不高兴，但Unix和Internet之间的 联系已是如此之强，甚至连Microsoft也无可奈何。）

　　所以，安装一套UNIX——我个人喜爱LINUX但还有其他种类的（是的，你可以同时安装Linux及DOS/Windows在同一电脑 上）。学习它，使用它，配置它。用它在Internet上冲浪。阅读它的源代码。修改它的源代码。你会得到比在Microsoft操作系统上更好的编程工 具（包括C，LISP，Python及Perl）。你会觉得乐趣无穷，学到在你成为大师之前意识不到的更多的知识。

　　想知道更多关于学习Unix的信息，访问The Loginataka。

　　想知道如何得到一份Linux，访问我在哪里可以获得Linux。（译者：对于中文读者来讲，最简单的方式未过于前往附近的D版/正版光盘店。）

　　你可以在www.bsd.org找到BSD Unix的求助及其他资源。

　　我有写一篇关于Unix和Internet基础的入门文章。

　　（注：如果你是一个新手，我不推荐自己独立安装Linux或者BSD。安装Linux的话，寻求本地Linux用户组的帮助；或联系Open Projects Network。LISC维护着一些IRC频道，在那里你可以获得帮助。）

　　3. 学会如何使用WWW和写HTML

　　黑客文化建造的大多东西都在你看不见的地方发挥着作用，帮助工厂、办公室和大学正常运转，表面上很难看到它对非黑客的普通人的生活的影响。 Web是一个大大的例外。即便政客也同意，这个巨大耀眼的黑客玩具正在改变整个世界。单是这个原因（还有许多其它的），你就需要学习掌握Web。

　　这并不是仅仅意味着如何使用浏览器（谁都会），而是要学会如何写HTML，Web的标记语言。如果你不会编程，写HTML会教你一些有助于学习的思考习惯。因此，先完成一个主页。（网上有很多好的教程；这是一个。）

　　但仅仅拥有一个主页不能使你成为一名黑客。Web里充满了各种网页。大多数是毫无意义的，零信息量垃圾——界面时髦的垃圾，注意，垃圾的水准都类似（更多信息访问The HTML Hell Page）。

　　要想有价值，你的网页必须有内容——它必须有趣或对其它黑客有帮助。这是下一个话题所涉及的……

　　4. 如果你不懂实用性的英语，学习吧

　　作为一个美国人和一个以英语为母语的人，我以前很不情愿提到这点，免得成为一种文化上的帝国主义。但相当多以其他语言为母语的人一直劝我指出这一点，那就是英语是黑客文化和Internet的工作语言，你需要懂得以便在黑客社区顺利工作。

　　这一点千真万确。大概1991年的时候我就了解到许多黑客在技术讨论中使用英语，甚至当他们的母语都相同，英语对他们而言只是第二语言的时 候；据我知道的报导，当前英语有着比其他语言丰富得多的技术词汇，因此是一个对于工作来说相当好的工具。基于类似的原因，英文技术书籍的翻译通常不令人满 意（如果有翻译的话）。

　　Linus Torvalds，一个芬兰人，用英语注释他的代码（很明显这对他来说不是凑巧）。他流利的英语成为他能够管理全球范围的Linux开发人员社区的重要因素。这是一个值得学习的例子。


黑客文化中的地位

　　象大部分不涉及金钱的文化一样，黑客王国靠声誉运转。你设法解决有趣的问题，但它们到底多有趣，你的解法有多好，是要由那些和你具有同样技术水平的人或比你更厉害的人去评判的。

　　相应地，当你在玩黑客游戏时，你得认识到你的分数主要靠其他黑客对你的技术的评价给出（这就是为什么只有在其它黑客称你为黑客时，你才算得上 是一名黑客）。这个事实常会被黑客是一项孤独的工作这一印象所减弱；也会被另一个黑客文化的禁忌所减弱（现在逐渐减弱但仍强大）：拒绝承认自我或外部评估 与一个人的动力有关系。

　　特别地，黑客王国被人类学家们称为一种奉献文化。在这里你不是凭借你对别人的统治来建立地位和名望，也不是靠美貌，或拥有其他人想要的东西，而是靠你的奉献。尤其是奉献你的时间，你的创造和你的技术成果。

　　要获得其他黑客的尊敬，基本上有五种事情你可以干：

　　1. 写开放源代码软件

　　第一个（也是最集中的和传统的）是写些被其他黑客认为有趣或有用的程序，并把程序源代码提供给整个黑客文化使用。

　　（过去我们称之为“free software（自由软件）”，但这却使很多不知free的精确含义的人感到困惑。现在我们很多人，根据搜索引擎网页内容分析至少有2：1的比率，使用“open-source”software（开放源代码软件）这个词）。

　　黑客王国里最受尊敬的偶像是那些写了大型的、好用的、具有广泛用途的软件， 并把它们公布出去，使得每人都在使用他软件的人。

　　2. 帮助测试并调试开放源代码软件

　　黑客也尊敬那些使用、测试开放源代码软件的人。在这个并非完美的世界上，我们不可避免地要花大多数的开发时间在调试阶段。这就是为什么任何有 头脑的开放源代码的作者都会告诉你好的beta测试员（知道如何清楚描述出错症状，很好地定位错误，能忍受快速发布中的bug，并且愿意使用一些简单的诊 断工具）象红宝石一样珍贵。甚至他们中的一个能判断出哪个测试阶段是延长的，哪个是令人精疲力尽的噩梦，哪个只是一个有益的小麻烦。

　　如果你是个新手，试着找一个你感兴趣的正在开发的程序，做一个好的beta测试员。你会自然地从帮着测试，进步到帮着抓臭虫，到最后帮着改程序。你会从中学到很多，并且与未来会帮你的人结下友谊。

　　3. 公布有用的信息

　　另一个好事是收集整理有用有趣的信息做成网页或文档如FAQ列表，且让他们容易获得。

　　主要技术FAQ的维护者受到几乎同其他开放源代码的作者一样多的尊敬。

　　4. 帮助维护基础设施的运转

　　黑客文化（还有Internet的工程方面的发展，就此而言）是靠自愿者运转的。要使Internet能正常工作，就要有大量枯燥的工作不得不去完成——管理邮件列表，新闻组，维护大型软件库，开发RFC和其它技术标准等等。

　　做这类事情的人会得到很多尊敬，因为每人都知道这些事情是十分花时间又不象编程那样好玩。做这些事情需要奉献精神。

　　5. 为黑客文化本身服务

　　最后，你可以为这个文化本身做宣传（例如，象我这样，写一个“如何成为黑客”的正面的教程 :-））（译者：不知道Barret把它翻成中文算不算？）。这并非一定要在你已经在这个圈子呆了很久，因以上四点中的某点而出名，有一定声誉后才能去做。

　　黑客文化没有领袖。精确地说，它确实有些文化英雄、部落长者、历史学家和发言人。若你在这圈内呆的够长，你或许成为其中之一。记住：黑客们不 相信他们的部落长者的自夸的炫耀，因此大举追求这种名誉是危险的。与其奋力追求，不如先摆正自己的位置等它自己到你的手中——那时则要做到谦虚和优雅。


黑客和书呆子（Nerd）的联系

　　同流行的迷思相反，做一名黑客并不一定要你是个书呆子。但它确实有帮助，而且许多黑客事实上是书呆子。做一个深居简出的人有助于你集中精力进行十分重要的事情，如思考和编程。

　　因此，很多黑客都愿意接受“书呆子”这个外号，更有甚者使用更尖刻的“geek（怪人）”一词并引以为豪——这是一种宣布他们独立于主流社会的声明方式。访问The Geek Page参加更多的讨论。

　　如果你能集中足够的精力做好黑客工作同时还能有正常的生活，这很好。现在作到这一点比我在1970年代是新手的时候要容易的多；如今主流文化对技术怪人要友善的多。甚至有越来越多的人意识到黑客通常是很好的恋人和配偶的材料。

　　如果你因为生活上不如意而迷上做黑客，那也没什么——至少你不会分神了。或许以后你会找到自己的另一半。


风格的意义

　　重申一下，作为一名黑客，你必须进入黑客精神之中。当你不在计算机边上时，你仍然有很多对黑客工作有帮助的事情可做。它们并不能替代真正的编程（没有什么能），但很多黑客都那么做，并感到它们与黑客的本质存在某些基本的连系。

　　学会流畅地用母语写作。尽管程序员不能写好文章的错误看法相当普遍，但是有令人惊讶数目的黑客（包括所有我知道的最棒的）都是不错的作家。

　　阅读科幻小说。参加科幻小说讨论会。（一个碰到黑客和未来会成为黑客的人的好方法）

　　学禅，并且/或者练功习武。（精神修炼看来是惊人相似。）

　　练就能分析音乐的听觉，学会鉴赏特别的音乐。学会玩某种乐器，或唱歌。

　　提高对双关语、文字游戏的鉴赏能力。

　　这些事情，你已经做的越多，你就越是天生做黑客的材料。至于为什么偏偏是这些事情，原因并不完全清楚，但它们都涉及用到左－右脑能力的综合，这似乎是关键所在（黑客们既需要清晰的逻辑思维，有时又需要偏离逻辑跳出问题的表象）。

　　最后，还有一些不要去做的事情。

　　不要使用愚蠢的，哗众取宠的ID或昵称。

　　不要卷入Usenet（或其他地方的论坛）的骂战。

　　不要自称为“cyberpunk（网络叛客）”，也不要浪费时间和那些人打交道。

　　不要让你寄出的Email或张贴的帖子充满错误的拼写和乱七八糟的语法。

　　做以上的事情，只会招来嘲笑。黑客们个个记忆超群——你将需要数年的时间让他们忘记你犯下的错误。

　　网名的问题值得深思。将身份隐藏在虚假的名字后是骇客、解密者、d00dz及其他低等生物幼稚愚蠢的行为特点。黑客不会做这些事；他们对他们所作的感到骄傲，而且乐于人们将作品与他们的真名相联系。因此，若你现在用假名，放弃它。在黑客文化里它会令你你失败的。


其它资源

　　Peter Seebach维护着一个非常好的Hacker FAQ，专给那些不懂如何与黑客打交道的经理看的。如果Peter的站点不能访问，下面这个Excite搜索应该有一份拷贝。

　　我也著有“黑客文化简史”。

　　我写了一份“大教堂与市集”，对于Linux及开放源代码文化现象有详细的解释。我也在这个话题上进一步阐述导致的结局——“开拓智域”。

　　Rick Moen写了一份很好的关于如何运转一个Linux用户组的文档。

　　我和Rick Moen合作完成了另一份关于“提问的智慧”的文章，可以让你事半功倍的获得帮助。

　　如果你想知道PC、UNIX及Internet基本概念和工作原理，参考The Unix and Internet Fundamentals HOWTO。

　　当你释放出一个软件或为其打补丁，试着按“软件发行惯例HOWTO”去做。（以上的提到的文章的中文版大多都可以在www.aka.org.cn和www.linuxforum.net找到。）


FAQ（常问问题解答）

问：你能教我做黑客吗？

答：自从第一次发布这份文档，我每周都会收到一些请求，（频繁的话一天几封）要我“教会他们做黑客”。遗憾的是，我没有时间和精力来做这个；我自己的黑客项目，及我作为一个开放源代码倡导者的四处奔波已经占用了我110%的时间。

即便我想教你，黑客也依然基本上是一项自行修炼的的态度和技术。当真正的黑客想帮助你的时候，如果你乞求他们一汤匙一汤匙“喂”你的话，你会发现他们不会尊重你。

先去学一些东西。显示你在尝试，你能靠自己去学习。然后再去向你遇到的黑客请教特殊的问题。

如果你发E-mail给一位黑客寻求他的帮助，这是两件首要记住的事情。第一，写出来的文字显得懒且粗心的人通常非常懒于思考且非常马大哈，不能 成为好黑客——因此注意拼写正确，使用正确的语法及发音，否则你可能会无人理睬。第二，不要试图要求回复到一个ISP帐号，而那个帐号与你的发信地址不 同。这样做的人一般是使用盗用帐号，不会有人有兴趣为虎作伥帮助窃贼的。

问：那么，我要如何开始？

答：对你而言最佳的入门方式也许是去参加LUG（Linux用户组）的聚会。你可以找到在LDP的综合Linux信息页面上找到类似的组织；也许 有一个在你家附近的，而且非常有可能与一所大学或学校挂钩。如果你提出要求，LUG成员兴许会给你一套Linux，当然此后会帮你安装并带你入门。

问：我得什么时候开始学？现在会不会太迟了？

答：你有动力学习的时候就是好时候。大多数人看来都是在15－20岁之间开始感兴趣的，但据我所知，在此年龄段之外的例外也是有的。

问：要学多久才能学会黑客道？

答：这取决于你的聪明程度和努力程度。大多数人只要他们专注，就能在18个月到2年之间学会一套令人尊敬的技能。但是，不要以为就此结束了；如果你是一个真正的黑客，你要用你的余生来学习和完善你的技术。

问：Visual Basic及Delphi是好的入门语言吗？

答：不，因为他们不是可移植的。他们不是那些语言的开放源代码实现，所以你被限制在厂商选择支持的那些平台里。接受这样一种垄断局面不是黑客的态度。

Visual Basic特别糟糕。它是Microsoft的私有语言这个事实就足够让它脸面全无，不像其他的Basic，它是一种设计糟糕的语言会教给你坏的编程习惯。

其中一个坏习惯是会依赖于单一厂商的函数库、控件及开发工具。一般而言，任何不能够支持至少Linux或者一种BSD，或其他第三方操作系统的语言，都是一种不适合应付黑客工作的语言。

问：你能帮我“黑”掉一个站点吗？或者教我怎么黑它？

答：No。任何读完这份FAQ后还问这个问题的人，都是无可救药的蠢材，即使有时间指教我也不会理睬。任何发给我的此类E-mail都会被忽略或被痛骂一顿。

问：我怎么样才能得到别人帐号的密码？

答：这是骇客行为。滚得远远的，白痴。

问：我如何入侵/查看/监视别人的Email？

答：这是骇客行为。在我面前消失，混蛋。

问：我如何才能在IRC聊天室里偷到频道op的特权？

答：这是骇客行为。去S吧，冥顽不灵的家伙。

问：我被黑了。你能帮我避免以后再被攻击吗？

答：不行。目前为止，每次问我这个问题的，都是一些运行Microsoft Windows的菜鸟。不可能有效的保护Windows系统免受骇客攻击；太多缺陷的代码和架构使保护Windows的努力有如隔靴搔痒。唯一可靠的预防 来自转移到Linux或其他设计得至少足够安全的系统。

问：我的Windows软件出现问题了。你能帮我吗？

答：当然。进入DOS方式，然后键入“format c:”。你遇到的任何问题将会在几分钟之内消失。

问：我在哪里能找到可以与之交流的真正的黑客？

答：最佳办法是在你附近找一个Unix或Linux的用户组，参加他们的聚会。（你可以在Metalab的LDP站点找到一些指向用户组的链接。）

我过去曾说过不能在IRC上找到真正的黑客，但我发觉现在情况有所改变。显然一些真正的黑客的社区像GIMP及Perl，也有IRC频道了。）

问：你能推荐一些有关黑客的好书吗？

答：我维护着一份Linux Reading List HOWTO，也许你会觉得有用。Loginataka也很有意思。

关于Python的介绍，请访问在Python站点上的入门资料。

问：成为一名黑客我需要擅长数学吗？

答：不用。黑客道很少使用常规的数学或算术，不过你绝对需要能逻辑性地思考和进行精密的推理。

尤其是你不会用到微积分或电路分析（我们把这些留给电子工程师们 :-））。一些有限数学（包括布尔代数，集合论，组合数学，图论）的背景知识会有帮助。

问：我该从那种语言学起？

答：HTML——如果你还不懂的话。市面上有一大堆的封面精美，宣传得天花乱坠的糟糕的HTML书籍，不幸的是很少有好的。我最喜欢的是HTML: The Definitive Guide。

但HTML不完全是一种编程语言。当你准备开始编程时，我推荐从Python起步。你会听到一大群人推荐Perl，并且Perl依然比Python流行得多，但是难学得多且（以我之见）设计得不是很好。

C确实重要，但它要比Python或Perl难多了。不要尝试先学C。

Windows用户不要满足于Visual Basic。它会教给你坏习惯，而且它不可以移植，只能在Windows下运行。避免它。

问：我需要什么样的机器配置？

答：过去个人电脑能力相当不够并且内存小，结果给黑客的学习过程设置了人为的障碍。不过一段时间以前开始就不是这样了；任何配置比一台Intel 486DX50好的机器都有足够的能力进行开发工作，X，及Internet通讯，同时你现在买的最小的磁盘都大得富足了。（依Barret之见，现在要 至少Pentium 166MMX才够。）

选择用来学习的机器时重要的一点是注意配件是否是Linux兼容的（或BSD兼容，如果你选择学BSD）。同刚才提到的一样，大多数现在的机器都是符合的；唯一的值得注意的区域在于modem和打印机；有些具备为Windows设计的配件的机器不会在Linux下工作。

关于硬件兼容性有一个FAQ；最新版本在这里。

问：我得因此憎恨和反对Microsoft吗？

答：不，你不必如此。不是因为Microsoft不令人讨厌，而是因为黑客文化早在Microsoft出现之前就存在了，且将在 Microsoft成为历史后依然存在。你耗费在憎恨Microsoft的任何力气不如花在爱你的技术上。写好的代码——那会相当有效地打击 Microsoft又不会让你得到恶报应。

问：但开放源代码软件不会使程序员丢饭碗吗？

答：看起来不太可能——目前为止，开放源代码软件产业似乎创造了更多的就业机会而不是减少就业机会。如果写一个程序比起不写来是纯经济收益的话， 那么在写完后，程序员应该得到报酬不管程序是否是开放源代码。并且，无论写出多么“免费自由”的软件，都存在更多对新的，定制的软件的需求。我有这方面更 多的论述，放在开放源代码网站资料中。

问：我要如何开始？哪里有免费的Unix？

答：在本份文档的某个地方我已经提到过何处可以得到最常用的免费Unix。要做一名黑客，你需要自立自强，以及自学能力。现在开始吧……

高质量 必须高质量

开始工作一个多月了， 现在已经逐渐进入轨道， 当然是自己铺的一条轨道。 通向哪里呢， 我也不知道。 边走边折腾吧。

奥运期间得到了两个双休的周末， 所以现在这三周，就成了连轴转。很累。 甚至有一天， 趴在床上， 我一下也不想动。 可是那边还是有牵挂的人啊。 睡了一会爬起来打打精神陪我的人儿去。  生活就这样继续着，其实我比较害怕它进入一个平衡期，因为怕自己逐渐被同化， 满足于现状。 应付他人， 也应付自己。

所以，今天早上很早就起来，因为睡不着了，老是想着这些事。 拾起了很久没碰过的简历，觉得以前自己写的太多了， 应该大删特删才对。 现在都还没达到那种地步的嘛。 投了份简历，没报希望。 不过为自己订了写目标。 还看了《大教堂与集市》、读了ar和atrun的代码。 忽然觉得很充实。 也许，我需要的不是整天晃晃不安， 而是去阅读，填充自己。

目前来说，只有尽全力把自己的工作的部分做好。 不辜负自己。

地震， 从四川出来以后反而比人在当时更害怕地震了。 你去了绵阳，看过你们宿舍和教学楼的破损情况， 触目惊心。 今天你被吓倒了，我多么多么希望就像以前我们在一起那样。 现在这样分开在两地， 我反而很怀念我们一起落难的那段时光。

10.1 快了。 快了。

大教堂与集市中的经典语录

• 当你在开发中碰到死胡同时——当你绞尽脑汁要超越下一个补丁的时候——一般来讲你
  这时该问的不是你的答案对不对，而是你的问题对不对。或许你的问题需要重新定义。
  
• 说明了什么道理？在不损失效率的情况下，不要犹豫把多余的功能扔掉。
• “设计达到完美的时候，不是增加得不能再增加了、而是减少得不能再减少了”。
• 任何一个工具都应该达到预期的用处，但是一个真正优秀的工具会带来预期不到的
  用处。
• 在写任何接口软件的时候，花点功夫尽可能不要干扰数据流——除非用户强迫你，
  永远不要扔掉任何信息！
• 一个安全系统的安全性取决于其秘密的安全性。小心伪秘密。
  
  
• 　我认为项目主持人能否想出杰出灿烂的设计不是很关键，但绝对关键的是，他必须能够
  慧眼识别出他人的优秀设计或想法。
  
• 但是在软件设计里表现聪明和创造力的问题在于它会形成一种坏习惯——当你应该保持
  代码稳固和简单的时候，你开始放任地把它们搞得好玩和复杂。

• 要建设一个开发社区，你需要吸引人群，让他们对你所做的感兴
  趣，并且让他们对自己的工作量舒心。要做到这一点，高超的专业技能会起很大的作用，但
  远远不是故事的全部，你所展现的人格也很重要。

大教堂与集市

经典！ 必读！

http://www.linuxforum.net/forum/showflat.php?Cat=&Board=linuxtalk&Number=654373&page=0&view=collapsed&sb=5&o=0&fpart=

摘抄的一部分

“　在发现继续开发Multics是做白工时，Bell Labs很快的退出了（後来有一家公司Honeywell出售Multics，赔的很惨）。Ken Thompson很喜欢Multics上的作业环境，於是他在实验室里一台报废的DEC PDP-7上胡乱写了一个操作系统， 该系统在设计上有从Multics抄来的也有他自己的构想。他将这个操作系统命名Unix，用来反讽Multics。

　　※译：其实是Ken Thompson写了一个游戏“Star Travel” 没地方跑，就去找一台的报废机器PDP-7来玩。他同事Brian Kernighan嘲笑Ken Thompson说：「你写的系统好逊哦，乾脆叫Unics算了。」（Unics发音与太监的英文eunuches 一样），後来才改为Unix。”

一个用手指波动指针调整的时钟的QT3实现

有一天OPPO的人拿来多普达的手机让我看一个触摸屏拖动指针来调时钟的功能。
看了以后觉得很NB， 不过一直不服， 就在想怎么自己写一个。

昨天看了atan2函数以后就想到了办法，
今天对时钟的稳定性做了调整。
这个程序即使把调整时间的API换成WIN的也不能正常在WIN下工作。 所以这个小程序就不支持win了。 在linux下正常。


这个程序直接：
qmake -project
qmake
make
就可以运行了。
不过要在ROOT权限下运行哦~

有啥BUG发给我哈。


#include <qapplication.h>
#include <qpushbutton.h>
#include <qslider.h>
#include <qlcdnumber.h>
#include <qfont.h>

#include <qpoint.h>
#include <qpainter.h>
#include <qdatetime.h>
#include <qtimer.h>

#include <qvbox.h>
#include <qwidget.h>
#include <cmath>
#include <qcanvas.h>
int degreen(double a) ;

class MyWidget : public QWidget
{
public:
MyWidget( QWidget *parent=0, const char *name=0 );

protected:
void paintEvent (QPaintEvent *);
void mouseMoveEvent (QMouseEvent *e);
void mouseReleaseEvent (QMouseEvent *) ;

private:

double rotate_angle_minute; // minute rotate angle
bool in_move;


};


MyWidget::MyWidget( QWidget *parent, const char *name )
: QWidget( parent, name )
{
bool in_move = false;
QTimer *timer = new QTimer (this);

connect ( timer, SIGNAL(timeout()), this, SLOT(update()));
timer->start(500);

resize(200, 200);
}

int degreen(double a) {
return a * 180 / M_PI;
}

#include <sys/time.h>
#include <time.h>
#include <errno.h>

void adjustTime (int , int min, int )
{
struct timeval cur_val;
struct timezone cur_zone;
int ret;
static int last_min = 0;
int delta = min - last_min;
qDebug("delta: %d", delta);
// ignore too large time adjust
if ( delta < -5 || delta > 10) {
last_min = min;
return;
} else {
delta = min - last_min;
last_min = min;
}

gettimeofday(&cur_val, &cur_zone);

time_t new_time;
new_time = delta * 60;
cur_val.tv_sec += new_time;

ret = settimeofday(&cur_val, &cur_zone);
qDebug( "time add %d seconds, ret is :%d ", (int)new_time, ret);
if (errno != 0)
perror("can't set time");
}

void
MyWidget::mouseMoveEvent( QMouseEvent *e) {
static int count = 0;
if (count++ < 5) // also for let adjust smoothly
return;
else
count = 0;


int angle;
angle = degreen(atan2(100 - e->pos().y() , 100 - e->pos().x() ));

qDebug(" X:%3d Y:%3d angle :%3d -- the minute angle :%d ",
e->pos().x(),
e->pos().y(),
angle,
(int)rotate_angle_minute);
if (!in_move)
angle = rotate_angle_minute; // for avoid minute pin jump
in_move = true;

int current_minute = (angle/ 6);

QString old_time = QTime::currentTime().toString();

adjustTime (0, current_minute - QTime::currentTime().minute(), 0);

QString new_time_str = QTime::currentTime().toString();
qDebug("old time: %s \n", old_time.latin1());
qDebug("new time: %s \n", new_time_str.latin1());
update();
}

void MyWidget::mouseReleaseEvent (QMouseEvent *) {
in_move = false; // just for minute pin don't jump
}


void MyWidget::paintEvent (QPaintEvent *) {
QPointArray hourhand(3);
QPointArray minutehand(3);

hourhand.putPoints (0, 3, 7, 8, -7, 8, 0, -40);
minutehand.putPoints (0, 3, 7, 8, -7, 8, 0, -70);


QPointArray secondhand(3);
secondhand.putPoints(0, 3, 3, 4, -3, -4, 0, -90);

QColor hourColor(127, 0, 127);
QColor minuteColor(0, 127, 127);
QColor secondColor (127, 127, 0);

int side = (width() < height()) ? width() : height() ;
QTime time = QTime::currentTime();

QPainter painter(this);
painter.translate(width() / 2, height() / 2);
painter.scale(side / 200.0, side / 200.0);

painter.setPen(Qt::NoPen);
painter.setBrush(hourColor);

painter.save();
painter.rotate(30.0 * ((time.hour() + time.minute() / 60.0)));
painter.drawConvexPolygon(hourhand);
painter.restore();

painter.setPen(hourColor);

for (int i = 0; i < 12; ++i) {
painter.drawLine(88, 0, 96, 0);
painter.rotate(30.0);
}

painter.setPen(Qt::NoPen);
painter.setBrush(minuteColor);

painter.save();
rotate_angle_minute = ( 6.0 * (time.minute() + time.second() / 60.0));
painter.rotate(rotate_angle_minute);

painter.drawConvexPolygon(minutehand);
painter.restore();

painter.save();
painter.setPen(secondColor);
painter.rotate( 6.0 * (time.second() + time.msec() / 1000));
painter.drawConvexPolygon(secondhand);
painter.restore();

painter.setPen(minuteColor);

for (int j = 0; j < 60; ++j) {
if ((j % 5) != 0)
painter.drawLine(92, 0, 96, 0);
painter.rotate(6.0);
}

}

int main( int argc, char **argv )
{
QApplication a( argc, argv );

MyWidget w;
a.setMainWidget( &w );
w.show();
return a.exec();
}


google 输入法怎么猜测英文

睡觉前想到的逻辑， 在你的输入的一长串字符的时候， 当词库此时找不到最长的匹配词以后， 就会去从英语字典里面查找，而且这个字典可以做的很小， 而且查英文比查中文快多了吧。

为emacs替换编程字体（linux下的编程字体）

一款好的编程字体对于职业程序员来说非常重要， 查了许多著名的帖子， 也实验了许多字体后， 还是用上了 《Code reading》 和《Code Quaility》中的字体 Lucida Sans Typewriter-9 大小比较适合， 而且又不是win下面的专利字体。 所以非常合适。 （这个字体好像是JAVA SDK中带的字体， 也算开源的吧？）
到这里 把这个字体下载下来， 放到你的~/.fonts/目录下（放到这个目录以后只能当前用户来访问，不过在你没有root权限的时候就有用了）
fc-cache -fv
然后CTRL＋ALT＋BACKSPACE重起X以后， 这个字体就生效了。

然后是为emacs替换字体， emacs下面如果在编译的时候没有加上 --with-xft 选项的话， 就只有几个字体选项可以选， 而且那几个字体说实话不怎么的。

所以我们下面就把刚才下载的字体设置为你的默认字体，
在你的 .emacs 文件中加入

(set-default-font "Lucida Sans Typewriter-9")
(set-fontset-font (frame-parameter nil 'font)
'han '("WenQuanYi Zen Hei" . "unicode-bmp"))


第一行就是把你的默认字体换成 Lucida~的 9 号字， 第二行是用来设定字体集的， 具体我也不太清楚， 但是有一点可以确定的是， 你把中间 “WenQuanYi Zen Hei" 这个位置换成 fc-list 中的中文字体可以避免显示中文时出现的好几种字体的现象。 具体参数意思还请知道的告诉我一声， 谢谢了。

这样emacs的字体配置就完成了

Engoy it!

ref: 几种不错的编程用字体
finding the best programmer's font

在emacs中使用git（翻译)

原文地址：http://xtalk.msk.su/~ott/en/writings/emacs-vcs/EmacsGit.html

最近git越来越流行了， 这里就转一篇介绍使用git的文章吧。git在dict.cn的解释是

n. 饭桶，无用的人, a foolish or worthless person

这样的解释有很强的黑色幽默气质。 呵呵。 它是非常优秀的版本控制软件， 一开始是为linux kernel开发的，后来渐渐被很多项目所使用， 它特别适合分布式开发中的软件版本管理。

我们可以用Emacs中的版本控制包-VC或者DVC来使用git，或者是使用git.el和emacs-git. 前者使用VC和DVC的标准接口，后者实现了一些供开发者完全使用git功能的接口。

git.el 包

安装git.el包

安装git.el非常的简单， 它放在git源文件的contrib/emacs子目录下。 主要进入这个目录运行make命令就可以编译它。 同样你也可以运行make install 来安装它，它默认安装在$HOME/share/emacs/site-lisp下， 当然你也可以通过传参数emacslispdir给make来改变目录， 或者把全部文件copy到emacs目录下。

可以通过在.emacs文件中加入来默认启动它。

(require 'git)

Work with git.el 用git.el来工作

在emacs中首先都是通过执行 git-status 命令， 它会询问用户Git仓库（repository)的目录名，并且分析仓库的状态。 分析状态后， 它会创建一个 *git-status*的buffer， 这个buffer用来在文件上执行git命令。 下面的图片是这个buffer的一个示例（图片的底部是diff命令的输出）。 这个buffer内使用的是git-status-mode， 这个mode里定义了许多命令和对应的快捷键（他们有很多快捷键和PCL-CVS包的快捷键相同）。所有的命令只是在这个mode里面有效。

用户可以在这个buffer内容过方向键来查看文件， 或者用命令 git-next-file(n或者SPC）和 git-prev-file(p键)来查看前一个文件或者后一个。 就像emacs的很多命令一样， 用户可以为他们定义数字前缀来改变命令的行为。

默认的， 所有的命令都在光标所在的文件上执行。 当然， 用户也可以通过选择多个文件来让命令执行在多个文件上。 选择主要通过下面的命令和快捷键来执行：m键（git-mark-file）标 记当前文件并且把光标下移一行；M键（git-mark-all）来标记buffer中的所有文件。取消标记用键u（git-unmark-file）或 者DEL键（git-unmark-file-up），两个键的区别是， 第一个键在取消标记光标所在的文件之后往下移动一样， 而后一个命令则往上移动一行。 取消当前buffer中所有的选择标记通过命令git-unmark-all（M-DEL快捷键）来实现。 你还可以通过git-toggle-all-marks（T键）来反选你现在的选择情况。

就像在PCL-CVS中， 用户可以通过命令git-find-file（回车键或者f）来打开当前光标所在的文件。 用过v键(git-view-file）来查看文件。 如果你遇到冲突以后， 可以通过 git-resolve-file（R键）来解决冲突。

你可以通过 git-add-file 命令（a键），或者 git-remove-file （r键）来像代码库里面添加或者删除一个文件。 如果有的文件你已经不需要了，却不想这个删除命令影响到代码库， 你可以把它们放在忽略文件列表中， 通过 git-ingore-file（i键）来执行。 提交代码通过 c键（git-commit-file）， 回滚（reverting）改变通过U键（git-revert-file)。 你可以通过l键（git-log-file）来查看修改日志。

d键是和改变(diff)有关的所有命令的前缀。 他们中最重要的要数 git-diff-file 命令了， 你可以功过=或者 d = 键来调用它。 命令 git-diff-file-base(键 d b）可以用列出当前文件和仓库中的文件的不同的地方。 命令 git-diff-file-idiff （键 d e)可以用emacs中的 idiff 来互动的查看改变。 而命令git-find-file-imerge （键 d E) 允许用户以互动的方式来合并代码。

其他的命令有查看那这个分支（branch）和主分支（main branch）差别 — git-diff-file-merge-head 命令（d h)， 在文件合并之间的相关的版本 — git-diff-file-mine 命令 （d m)， 刷新git状态buffer的命令 git-refresh-status命令（g键），退出git状态buffer命令 git-status-quit (q），从列表中删除处理过的文件 git-remove-handled 命令 （x）， 详细的命令请查看这个mode的帮助（C-h m）。

Emacs的日常生活（转）

robinhOctober 15, 2003

Chapter 1

前言

有 很多很多现成的文章介绍 Emacs 的。大致有那么两种：一种介绍说， Emacs 是一个无比强大的文本编辑器，但是不管谁用了一下都会觉得，这个文本编辑器真是难用了，所有的命令都是组合出来的怪物。甚至 Emacs 自己的帮助文档里面也说，用 Emacs 多的了用户会希望终端的输入设备加上两个脚踏板）；另一种介绍说 Emacs 是一个无比强大的 IDE ，但是对于象我们这样见过 Visual Studio 之类市面的新新人类来说，这“无比强大”大致上和“刀枪不入”是一个档次的广告。

Emacs 在我的概念中到底是个什么样的呢？它是一个环境。 Emacs 可以什么都是，也可以什么都不是，因为环境本身不创造什么。 Emacs 的强大是因为前人已经在这个环境中作了很多尝试，所以你不用从头发明轮子。 Emacs的强大是因为它能够将各种软件统一到同样一个界面底下来，你就可以以相仿的方式，操作各种其实并不相仿的程序。 Emacs的最强大之处在于它本身并不强迫你接受什么，不就是个Lisp程序嘛，不满意的地方你可以改，哪怕你其实不怎么懂Lisp。

以下的文字，说起来有一些混乱，因为我常常引用一些在介绍的同时并没有给出说明的概念。这又有什么关系呢？Lisp不是C++，它并不要求你在真正开始用这个概念之前就已经掌握了它的实际含义。而你真正想到用这个概念的时候，你肯定已经掌握了它。

Chapter 2

Emacs基础

Emacs最好的入门教材，不是 Emacs 自己带的 toturial 。实际上就是这个 tutorial 给好多人非常恶劣的印象， Emacs 是一个操作复杂的变态编辑器。人性化一点的 Emacs 教材，大致有这一些：

1. Sams Teach Yourself Emacs in 24 Hours ，可以从这里下载。
2. 《如何使用Emacs编辑器》，这是已经出了中文版的了，不过不值得推荐，因为是在是太贵太陈旧了。

关 于 Elisp 的入门教材是《GNU Emacs Lisp编程入门》，这本书实际上就是elisp introduction这个info文件的翻译，翻译质量不错，而且纸版的书看起来确实比较舒服。Emacs自带的有一个Elisp手册，真的就只能当 手册用，全无可读性可言。

使用Emacs的技巧在http://www.emacswiki.org 上有很多，常去翻翻很长见识。

因 为 Emacs 是一个单线程的应用程序，所以有可能一个操作占用了太长的时间，让使用者觉得很不爽。实际上很多 Emacs 的使用者，同时都起若干个 Emacs 进程，其中一个专门做一些耗时的操作，比如收信。如果你只愿意起一个进程，并且实在不耐烦等下去，C-g可以直接将进行到一半的操作停止下来。 Emacs 里面所有作到一半的事情，只要 Emacs 没有崩溃，就可以用C-g停止掉。

Emacs 对自己的描述非常完备，C-h可以带你进入 Emacs 的文档世界。常见比如：

1. C-h k可以告诉你按下某一键的时候到底有什么函数被调用；
2. C-h m可以告诉你当前的模式到底有什么特别之处；
3. C-h f可以告诉某一个函数到底有一些什么作用。

习惯这一些你会发现， Emacs 里面查帮助其实比 MSDN 还要方便。

Chapter 3

如何安装Emacs

是 的是的，我知道你会有自己安装 Emacs 的方法。你要是 RedHat 的用户，你肯定是下载 rpm 包回来装；你要是用的 debian ，你多半是apt-get；你要是用 gentoo ，你就 emerge 一把；你要是用 Windows ，你会上网去找安装文件；你要是用BSD的，你多半就去make port了；再大不了你会用 cvs 把最新的 Emacs 代码拉回来，然后在自己的机器上重新编译。

但是，这些方法只能帮助你安装 Emacs 本身。 Emacs 绝不仅仅是一个大大的tar包，或者是一个大大的安装文件能够包括的。你下回来的 Emacs ，相当于是一个Java的虚拟机，你真正面对的，是互联网上elisp资源的汪洋大海。所以我们关心的，其实是怎么安装这些零零碎碎从网络上 download 回来的资源。

Emacs 的软件，一般都是一个压缩包。因为 Emacs 没有象 Python 那样完善的安装机制，所以这个安装过程一般都要看着说明文档自己一步一步来。作为一个 Emacs 平台下的软件，它总得有这样几个组成部分：

1. 有部分是用 elisp 写的，不然的话没法给 Emacs 用；
2. 可能有部分是平台相关的代码，一般都是些可执行的二进制文件或者脚本。
3. 可能还有一些info格式的相关文档。

可执行的二进制文件只要放在$PATH环境变量所包含的目录下，就可以被调用了，这和一般的程序并无区别。

而 elisp写就的 Emacs 软件则稍微有一些不同。你如果想在 Emacs 里面调用一个函数，你得先有这个函数的定义；为了有这个函数的定义，你必须显式地将拥有函数定义的elisp文件载入 Emacs 环境；为了将 elisp文件正确载入 Emacs ， Emacs 会在load-path这个变量所包含的所有目录下寻找同名文件。所以，说到底，安装elisp软件的过程，就是将它拷贝到某一个 load-path目录下，并且在.emacs文件显式载入这个文件的过程。

一 般FAQ上给出的建议，是将自己下回来的elisp包，放在某一个名叫 site-lisp的目录之中。这是个不错的建议，不过问题在于大多数Linux的发布版厂商，习惯把他们自己维护的一些elisp资源包也扔到 site-lisp这个目录里面去，这造成的结果就是，有一天你突然想备份自己的Emacs资源的时候，你突然发现分不清那些是自己想要的，哪些是不小心 让系统装上去的垃圾。

所以，建议你还是在自己的$HOME目录底下建一个专门给Emacs用的目录，名字嘛，可以就叫 emacs。$HOME/emacs这个目录里面至少可以分出两个子目录来，一个是config，我们从此就可以把所有Emacs配置的内容放到这个目录 底下，并且分门别类起来；另一个叫package，里面就可以堆放各种从网络上下载回来的elisp资源。

所有扔到site-lisp目录里面的elisp文件夹，在emacs起动的时候都会自动被加入load-path列表，这是site-lisp/subdirs.el的功劳。我们的package/subdirs.el也要有这个功能。

(defun my-add-subdirs-to-load-path (dir)
(let ((default-directory (concat dir "/")))
 (setq load-path (cons dir load-path))
 (normal-top-level-add-subdirs-to-load-path)))

(my-add-subdirs-to-load-path "~/emacs/packages")

然后在.emacs文件中显式载入这个文件。

(load "~/emacs/packages/subdirs")

Chapter 4

让Emacs变得轻快

Emacs最为人诟病的一点，就是它起动太慢。也难怪，光看可执行文件的尺寸，一个 emacs 差不多就是一个 vim 的5倍了，起动起来能快得了嘛。更何况大多数人都把以前用 vi 的习惯照搬到用 emacs 的情况下面来，每次要编辑一个文件的时候，就起动一个新的 Emacs 进程。您要是也习惯这种 Vi 风格，那您用 Emacs 可就得慢慢等着啦。因为 Emacs 的风格，是所有事情都在 Emacs  里面完成，包括浏览目录，打开文件。当然， Emacs 也不是完全排斥 Vi 风格，至少  Unix 环境下的 Emacs 就自带了一个叫 emacsclient 的程序，是个完全轻量级的东东，让你可以象起动 vi 那样轻松起动 emacs 。还有一个独立的程序，叫 gnuserv 的，更尽一步，支持 Windows 平台下的 Emacs ，而且功能也更多一些。反正是要用，干脆就用个好的吧。

Unix下的gnuserv可以从  http://www-uk.hpl.hp.com/people/ange/gnuserv/ 下载， Windows下的gnuserv建议在  http://www.wyrdrune.com/gnuserv.html 里面找。 gnuserv的安装并不复杂，无非是将几个可执行文件放到%PATH%变量提及的地方，然后将 gnuserv.el 放到 load-path 所包含的目录中去，最后在配置文件中加入两句配置：

(require 'gnuserv)
(gnuserv-start)
这是Emacs安装插件的标准做法。以下还有一些代码，是从David Vanderschel的帖子上抄来的，偶一般将其中的dv-close-client-frame绑定到C-上，估计也会有人喜欢绑定到C-F4上。
 
(defvar dv-initial-frame
 (car (frame-list))
 "Holds initial frame.")

(defun dv-focus-frame (frame)
 "pop to top and give focus"
 (make-frame-visible frame)
 (raise-frame frame)
 (select-frame frame)
 (w32-focus-frame frame))

(defvar dv-mail-frames ()
 "Frames created by dv-do-mailto")

(defun dv-focus-initial-frame ()
 "Make the initial frame visible"
 (dv-focus-frame dv-initial-frame))

(defun dv-do-mailto (arg)
 "For handling mailto URLs via gnudoit"
 (dv-focus-frame (make-frame))
 (message-mail (substring arg 7))
 (delete-other-windows)
 (setq dv-mail-frames
   (cons (selected-frame) dv-mail-frames)))

(defun dv-close-client-frame ()
 "Close frame, kill client buffer."
 (interactive)
 (if (or (not (member (selected-frame) dv-mail-frames))
         (and (> (length (buffer-name)) 4)
              (equal (substring (buffer-name) 0 5)
                     "*mail")
              (not (buffer-modified-p))))
     (kill-buffer (current-buffer)))
 (setq dv-mail-frames
       (delete (selected-frame) dv-mail-frames))
 (if (equal (selected-frame) dv-initial-frame)
     (iconify-frame)
   (delete-frame)))

(defun dv-paste-to-temp ()
 "Load clipboard in a temp buffer"
 (dv-focus-frame (make-frame))
 (switch-to-buffer (generate-new-buffer "temp"))
 (clipboard-yank))
再如果，你和我一样是个win32底下的懒人，那么估计你还需要这个。
 
(defun w32-restore-frame (&optional arg)
   "Restore a minimized frame"
    (interactive)
    (w32-send-sys-command 61728 arg))
(defun w32-maximize-frame (&optional arg)
   "Maximize the current frame"
    (interactive)
    (w32-send-sys-command 61488 arg))
(w32-maximize-frame)
(add-hook 'after-make-frame-functions 'w32-maximize-frame)
这可以使得每一个新打开的frame都自动最大化。

Chapter 5
安排自己的时间
如果你已经是一个善于管理自己时间的人，那么Emacs的这些功能可能就全都没有必要了。不过，如果你和我一样在这个方面拎不清，Emacs 就显得很帮忙了。

以下的内容加入到.emacs文件中，会有不少帮助。
 
(setq display-time-24hr-format t)
(setq display-time-day-and-date t)
(display-time)

(setq todo-file-do "~/emacs/todo/do")
(setq todo-file-done "~/emacs/todo/done")
(setq todo-file-top "~/emacs/todo/top")

(setq diary-file "~/emacs/diary")
(setq diary-mail-addr "you@your.email.address")
(add-hook 'diary-hook 'appt-make-list)
将所有emacs里面用到的文件都放到~/emacs目录中去，偶觉得是个好习惯。

对于大多数预期要做的事情，使用todo模式是最方便的，偶的习惯是访问do文件的时候，作一个bookmark(使用M-x bookmark-set命令)，这样以后访问起来就很方便了。bookmark是Emacs很有用的功能，偶一般就把 list-bookmark绑定到F12上去，随手就能钩着。想起什么事情的时候，随手就切到todo那边去，找一个catalog，用I命令插入一个新的entry；做完了一件事情，随手切到todo那边去，用d或者f就能把entry去掉。每个星期结束的时候，看看done文件，就会有“日子过得好充实阿”酱紫的感叹。

也有的事情没有那么重要，写不成todo的。这个时候就用 appointment 。用 (setq appt-issue-message t)确认打开了约会提醒功能，然后用appt-add命令就可以加入新的约会提醒。比如在电话里和mm吵架了，挂了电话以后，在 Emacs 里面使用M-x appt-add命令加一条记录，估计一下半个小时以后，给mm打个电话赔礼道歉。半个小时以后， Emacs 就会跳出一个小框来提醒说，该打电话了。当然，如果半个小时之内，mm主动打电话回来修好，那就用 M-x appt-delete命令删掉提醒好了。

对于那些周期性比较长的事情，可以用diary。我刚开始用diary的时候，以为diary是用来帮助写日记的，所以试了一下觉得好难用阿。仔细看看，发现diary其实是用来做行程管理的。

单独用 diary 没什么意思的，所以info里面 diary 也是和 calendar 放在一起的。偶把 calendar 绑定到F8上 (global-set-key [(control f8)] 'calendar)。启动calendar会出现一个小窗口，显示当前日历。calendar 模式底下命令很多，但是常用的就那么几个，.命令可以跳回当今天，o命令可以跳到某一个月。g系列命令表示goto，可以跳到指定的某一天，g d 是跳到某年某月某日，g c是跳到某年某星期的星期几，g C可以跳到阴历的某一天。p系列命令表示print，可以按照某格式显示当前日期，比如p C就可以显示当前的阴历日期。偶们现在比较关心的是i系列命令，i d是加入当前这一天的行程安排，d表示的是day，显然依此类推还有m，y，w。

比如mm打个电话来说，星期天要陪她去颐和园。用Emacs记一下吧，免得忘了。打开calendar，跳到星期天上面，i d，陪mm去颐和园。又比如老板说，以后每个星期一都给我交一份报告上来，打开calendar，跳到某个星期一上面，i w，交报告给老板。还有一个常用的，比如mm生日是 9/29，打开calendar，跳到9/29，i a，a代表anniversary，mm生日。养成用diary的习惯以后，经常性的打开calendar，跳到某一天，按一下d，就可以看那一天有哪些安排了。相比之下，h命令对偶来说就很垃圾。

diary文件里面可以写一些更详细的内容，比如直接把一个约会提醒写到diary里面，偶觉得这个不是很方便。diary文件不过是一个纯文本，有什么不满意的话，可以直接去修改，记得打开diary文件的时候，切回基本模式，不然很多东西是看不到啦。

有的更完整一些的模式，比如plan模式，需要额外从网上下载，可以将作出的plan转换成pp的个人主页。不过我是不会用的啦。

Chapter 6
用Emacs写东西
虽然写程序也叫做写东西，可是我们现在要讨论的不是它。我们大部分的时间里写的，是拿到bbs上灌的，是留到以后查的。Emacs有一些不错的特点，可以方便上面说的这些事情。

大部分的时间里，我们要写的文章写成TEX挺困难，因为不是那么有条理；但是直接当纯文本处理，似乎又太没有条理。这种时候，用Emacs 的outline-mode就很合适。outline模式最大的好处是简单：只要在行首放上几个星号“*”，就可以表达文章的条理关系。比如，看《爱丽丝漫游奇境》是做一点摘录，先打开一个新文件C-x C-f；然后打开outline模式M-x outline-mode；再然后呢，第一章的内容，先来一个*吧，写上第一章的题目；第一章的写完了，C-c C-c就可以把前面写的内容都折起来，只留下一个标题，看起来很是清爽。过一段时间想起来翻查的时候，C-x C-f打开文件，还是进入outline-mode，C-c C-o就把所有内容都折起来了，只留下标题，文件里面到底有些什么内容，也都一目了然了。

这样做有一个缺点，就是很容易把所有内容都堆到同一个文件里面，眼看着文件越来越大，很容易就要上兆了。不过Emacs是支持直接编辑压缩文件的，用auto-compression-mode就可以。

另外一个经常让人头疼的问题，就是文章的排版。特别是要拿到bbs 上贴的文章，bbs虽然号称支持自动换行，但是那也只是个聊胜于无的东西，要想给人看，还是得手动换行才行。Emacs可以把一句长长的话自动分成若干行，而且这个效果一般都很让人满意。只要把point移动到需要重新整理的段落之中，M-q，就可以完成排版的工作。如果这样还嫌麻烦，那么做成宏也是个不错的注意。如果文章是自己在写，那么打开 auto-fill-mode，是个不错的注意。auto-fill模式可以在写的同时，帮你做换行的工作。

如果写的东西大部分是英文的，还可以考虑打开flyspell-mode。不过这个东西需要后面有ispell支持。win32底下有一个native的ispell v4，不过用起来挺不爽的：v4是一个已经放弃的版本，这是一；和现有的其他模式搭配也不愉快，这是二。v3里面现成的win32版本有两个，建议装一个 cygwin。 另外也有一个win32 native的，可以从  http://www.fsci.fuk.kindai.ac.jp/ kakuto/win32-ptex/web2c75-e.html  找到，日本人做的，我也没有试过。打开flyspell-mode之后，写东西的过程当中，ispell认为写错了的单词，就会自动高亮，很是显眼。 M-$可以让Emacs提示你写错的单词到底应该怎么拼。win32的Emacs 21还没支持 tooltip，所以有些看起来很炫的功能不能用。不过偶觉得就上面说的几种模式，一般过日子也就足够了。

尝试过 wiki 的同学，也可以试用一下 Emacs 下的 wiki 模式，不过偶以为 wiki 模式不适合给说中文的人用。

Chapter 7
管理自己的地盘
我习惯没事情干的时候，就逛自己的硬盘。相信很多人有和我类似的毛病，上网的时候看到好的文章就存下来，时间一长，硬盘的各个角落里面就堆满了各种各样的html，txt文件。只能常常抽空遍历一下自己的目录，看看又多了一些什么东西。这件事情用cmd.exe可以做，用资源管理器也能做，不行话还有wincmd，totalcmd之类的软件。当然用惯命令行的还是觉得用sh.exe最好。

Emacs既然是个八卦，就会八卦到底，它至少提供了另外两种选择，  eshell 和 dired 。

eshell 看起来就很象一个 shell 了，不过拿它就做一个 shell 那也太委屈它了， eshell 带的 pcomplete 自动补全功能比 bash 之类的shell，还是有差距的。但是eshell的特长在于，可以直接使用 emacs lisp 的函数做命令。比如偶比较喜欢的 (defalias 'vi 'find-file)  （前提是系统里面没有vi的可执行文件），这样在eshell里面，vi一个文件，就会弹出一个新的 emacs buffer 。充分发挥想象力吧。唯一要注意的是， eshell 里面不能用C-c取消一个输入了一半的命令，我的做法一般是C-a C-k，其实也不太麻烦的。

说到自动补全，不知道什么时候开始，突然发现几乎所有的shell，所有的编辑器都支持用tab来做自动补全了。Emacs当然也可以这样设定，不过有的时候，我们还是会怀念用tab来indent，不是吗？用这样一个函数吧：
 
(defun my-indent-or-complete ()
 "如果在词尾，那就hippie-expand，否则就indent"
 (interactive)
 (if (looking-at ">")
     (hippie-expand nil)
   (indent-for-tab-command)
   ))
(global-set-key [(tab)] 'my-indent-or-complete)
hippie-expand虽然已经很不错了，不过我们可以让它更强一点的，
 
(autoload 'senator-try-expand-semantic "senator")
然后再
 
(setq hippie-expand-try-functions-list
     '(
       senator-try-expand-semantic
       try-expand-dabbrev
       ;;........
       ))
当然前提是要装一个semantic，这个以后再说。

Dired看起来就更象一个wincmd。常用的命令也就是v（查看），e （编辑），d（标记删除），x（执行删除）。以前一度，我喜欢再dired里面做el文件的byte compile，只要在需要compile的文件上面按B就可以了，不过现在发现，那样还不如用这样一行命令合算：
 
(byte-recompile-directory "/path/to/somewhere" 0 t)
自动重新编译一个目录下面所有的el文件。Emacs和python不一样， elc 和el执行速度会差的很多，mule-ucs就是一个典型，编译之前启动一次要半分钟，编译之后启动就是一眨眼的事情了。当然编译也是一个很费时的事情。真是的。



Chapter 8
用Emacs写程序
Emacs号称是一个强大的IDE，可是往往被人误解。甚至常常有人以为，让VS.net的热键设置和Emacs一样，VS.net就算可以模仿Emacs了，这个基本上是比天只小一点点的笑话。

还是从写还是吧。

基本上那些常见的编程语言，Emacs都有支持。我们现在说的支持，基本上就限于有一种对应于这种语言的major mode。最常见的就是cc-mode了，甚至还专门拿出来，在sourceforge上做了一个项目的说。cc-mode可以不错的支持各种语法上有些类似c的语言，甚至于idl。

不过， cc-mode 不支持c Sharp 。 google 上能搜到一些给 Emacs 用的 c sharp major mode ，我觉得  http://davh.dk/script上的那个不错；别的大都需要对  Emacs 自带的 cc-mode 做替换，让人觉得很不爽。前面提到的那个，在 Emacs 21.3.xx上可能需要作一点小的修改，大概621行左右的位置，  (c-common-init)改成(c-common-init 'c-mode) ，大致如此。

Python mode需要到http://www.python.org上去下载。

有了这些以后，基本上不愁写程序的时候的语法加亮的问题了。（其实本来也没什么好愁的，毕竟这是最基本的要求）。

有人偏爱ue那样，把当前行高亮的样子，那就先打开M-x hl-line-mode。

有人看到 ThisIsASimpleVarInJava 就觉得郁闷，那就打开 M-x glasses-mode 。

关于补全，上次提到过，hippie-expand加上semantic是现在最好的选择了。dabbrev-expand完全不懂语义的，常常给扩展出一些莫名其妙的内容来，semantic就不一样了。它至少是懂的语义的，expand的结果看起来就合理的多，有的时候甚至能够认出某一个变量的类型来，让我激动了老半天，当然，只是有时候阿。semantic可以从 http://sf.net/projects/cedet上下载。别的还有一些东西，比如jde或者ecb都是建立在semantic的基础上的，写java的话，也可以用jde，比elipse之类当然是要轻的多了。ecb偶没用过。 http://www.xref-tech.com上的xref 支持更出色，不过那就不是自由软件的范畴了。

关于宏，c语言最麻烦的可能是宏了。常常是面对嵌套了若干层的宏，看不出一个所以然来。 这个时候，可以直接用C-c C-e，对已经选定的区域做预处理，预处理的结果会显是在另外的buffer里面。这项工作缺省使用cpp来做，不过只要编译器支持从标注输入读入代码，好像都可以正常工作。另外有一些简单的宏，比如用来做平台选择的，直接用 hide-ifdef-mode就可以摆平，都免去了调用预处理器的麻烦。

关于代码隐藏，其实偶一般只用一个C-c @ C-c，hs-troggle-hiding。基本上能够满足要求了。 不过用之前记得先打开M-x hs-minor-mode。

关于文件，有一个很方便的命令。取个名字叫my-find-related-file。这个命令可以打开当前.c文件中所有include了的文件。
 
(defun my-find-related-file ()
 "Find all related files in this buffer"
 (interactive)
 (save-excursion
   (let ((my-buffer (current-buffer)))
   (goto-char (point-min))
   (while (search-forward-regexp " *# *include" (point-max) t)
     (progn
       (ff-find-other-file)
       (switch-to-buffer my-buffer)
     )))))
还有就是注意，ff-search-directories早一点设定，用过一次ff函数以后，再setq就晚了。 ;-) 以上。

关于查看帮助，有的选的有info和woman。woman可以用来看man能查到的帮助。一般可以把下面这点代码绑定到f1上。
 
(global-set-key [(f1)] (lambda()
                (interactive)
                (let ((woman-topic-at-point t))
                (woman))))
也可以用C-h C-i在info里面查看函数。这些都很简单了。如果你还不满足，那就直接google吧，可以考虑利用browser-url。 ;-)

关于自动排版。自动排版算是一个比较重要的功能，特别是对于那些版式和程序结构没有影响的语言，让代码的排版比较迎合个人的喜好，这个不过分吧。对于整个文件做重排，一般要C-x h选定整个buffer，然后 C-M-重新排版。 这个一般比较耗时间，如果代码文件确实很长的话。折中的做法是在一个代码端开始的地方，就是{处，用C-c C-q，酱紫可以排版一个代码段。排版的风格可以用c-set-style来设定，偶一般用 stroustrup，表达偶对他的仰慕。如果对于具体的某一个设置不满意，可以在不满意的地方用C-c C-s看一下，这里缩进的设置是取决于什么的；然后可以用C-c C-o修改之。

关于移动。程序代码里面移动来移动去，也是一个问题。最直接的办法当然是用鼠标了。不过各种模式里面一般也都会对常见的移动键位做修订，可以自己试一试，找出比较常用的键来。几乎所有的模式都会支持以函数定义为单位移动，这个一般都很好用。

关于tag，Emacs附带的etags可以用来生成TAGS文件。在某个源文件中 M-.，Emacs会询问访问哪一个TAGS文件，这个基本上和vi差不多。更强悍一点的是ebrowser，生成一个BROWSER文件，只要find-file这个文件，就会进入ebrowser的模式，有一点类似于cscope。speedbar在这个时候可以来帮忙，试试看就知道了，不过好不好使就完全是一个见仁见智的问题。上次说到的ecb（sf.net/projects/ecb），也着眼于解决这一类问题，有兴趣试试？

关于grep，Emacs自己没有grep功能（ft）。不过好在grep这个东西不管哪个平台都有，win32底下叫做findstr（ft again）。可以尝试一下 grep，grep-find。 前者是直接把参数传递给grep的，后者是把参数传递给find + grep，两者都会在当前buffer对应文件所在的目录下面进行。反正和直接在console下面玩没什么两样的。

关于diff，ediff模式很不错的。比较爽的做法是在eshell里面用。 ediff a.c.orig a.c。 特别注意的是，ediff的session控制区是一个小窗口，那个小窗口关掉，就算是退出ediff了哦。ediff可以忽略空格的。对应的epatch较之直接用patch的优点就在于，patch完了以后就直接进入 ediff模式，什么地方做了改动一目了然。

关于注释，虽然最简单的做法是用C-c C-c注释掉整块已经选定的区域，但是这种做法不一定是最好的。如果是想将暂时不需要的代码抹掉，还是用#if 0/#endif比较合适，因为我一般用flyspell-prog-mode来检查注释里面有没有单词拼写错误。如果你不想看到代码里面被指出很多拼写错误来，那还是不要滥用C-c C-c的好。

xref 是一个用起来挺不错得 refactory 包，它也可以用来完成大多数例如 symbol 补全一类得工作。唯一让人觉得有点不爽的是，它是一个版权软件，是需要 license 的。 当然，它也提供了免费试用版本下载的；同时也提供了源代码下载，你也可以试着用xref重构它自己的代码。

Chapter 9
编译你的程序
如果Emacs只能拿来写东西，那是不够的。至少，因为Emacs可以通过 M-!直接运行外部程序，所以理论上我们是可以在Emacs里面做一切事情的。嗯，理论上。

写了一点代码以后就会急急忙忙的去考虑该编译一下了。 M-x compile  就可以了。 compile 缺省命令是make -k， Emacs 会在 minibuffer  里面跳出来问，compile的命令到底应该用什么呢？如果把  compilation-read-command 设成nil，它就不会那么罗嗦了。compile使用的命令是由 compile-command ，这个变量可以自己调整。有的IDE习惯每次文件存盘的时候就会做一次编译，比如 eclipse ；如果你也有这样的偏好的话，可以吧 compile 命令放到 after-save-hook 里面去。

编译一切顺利那当然很好了，不过一般都不会是酱紫的。这个时候用 C-x `就可以跳到错误地点。 Emacs是通过对错误信息做正则匹配来找相关信息的，所以让Emacs支持特定某一个编译器是比较容易的。比如为了让 Emacs支持csc，就是csharp的compile，我们只需要：
 
(setq compilation-error-regexp-alist
  (append
;;; tt.cs(5,14): error CS1585: Member modifier 'static' must precede the member type and name
   (cons '("(.*)(([0-9]+),([0-9]+)): (error|warning) CS[0-9]+:" 1 2 3) ())
    compilation-error-regexp-alist
  )
)
注意到其中的1，2，3；分别表示的是文件名，行号，列号。

Compile命令的扩展能力几乎是不受约束的，想得到的，就能支持的到。偶的想象能力比较贫乏，这里留白给更有研究精神的人来补全吧。

Chapter 10
电子邮件

10.1  收邮件，发邮件
邮件系统很早就在Emacs里面占有重要地位了。从最早的 rmail 到 vm 到  gnus ，各种各样的 mail mode ，乱花迷人眼。VM似乎是界面最友好的了，还记得第一次用 xemacs 的时候，那还是4年前，VM就已经支持很好看的图标按钮了。虽然如此，我当时对 xemacs 是如此白痴，还是没法把VM好好的用起来。

不过我转回到Emacs收信也是最近的事情了。要知道能让我从becky转过来，这个诱惑一定要不一般才可以。

gnus就提供了这样的诱惑。这个号称世界上最好的news客户端，也能作一个世界上最好的maillist客户端。如果你不上news，不混maillist，那么gnus的强大对你来说并没有意义，不如早点放弃吧。hehe

设置用gnus收信，或者发信，其实是很容易的。gnus支持多个pop3服务器， Emacs 支持smtp发信认证（需要升级你的 Emacs lisp 部分，21.3.1的还没包括这部分的内容），如果你希望 pop3 收信的时候不删除服务器上的邮件，Emacs现在还不行，你要自己动手去安装一个 epop3.el 的扩展。偶没用装过，因为偶没有这样的需求。在开始M-x gnus之前，记得在.emacs文件里面添上一些东西：
 
(require 'gnus-load)
(setq gnus-startup-file "~/emacs/config/newsrc")
(setq gnus-init-file "~/emacs/config/gnus-config")
把gnus-config从.emacs中分出来的做法比较清楚，因为你以后会经常有改gnus-config的需要的。在gnus-config中需要加上这些内容：
 
(setq gnus-select-method '(nnfolder ""))
(setq gnus-secondary-select-methods '((nntp "news.gnus.org")))
(add-to-list 'gnus-secondary-select-methods '(nntp "perl.org" (nntp-address "nntp.perl.org")))
上面的第一行指明的是gnus对邮件使用的backend，偶觉得nnfloder比较好，你可以先这样用着，反正backend以后还是可以换的，等你熟悉了 gnus以后。然后就可以给secondary-select-methods加各色的news服务器了，
 
(setq mail-sources '(
                    (pop :server "263.net" :user "huxwcn" :password "pighead")
                    (pop :server "knight.6test.edu.cn" :user "huxw" :password "pighead")
                    ))
然后设置 backend 去哪里收信，除了 pop3 ，还支持 imap ，或者本地的  maildir 之类的冬冬，以此类推，还能加很多。还有就是希望你不会naive 的以为上面的密码是真的。

最后，就是发信的设置。
 
(setq smtpmail-auth-credentials '(("smtp.263.net" 25 "huxwcn" nil)))
(setq smtpmail-smtp-server "smtp.263.net")
(setq user-full-name "Robin Hu")
(setq user-mail-address "huxw@knight.6test.edu.cn")
前两行是说发信服务器的位置，后两行是给收信人看的。人家回信就会回到那个user-mail-address 上去。以后会看到这种东西都可以很灵活的修改。

这些都搞定的时候，你就可以尝试开始gnus之旅了。我最后offer一点不好的消息，你要是觉得不爽的话，现在停止尝试gnus还来得及。因为 Emacs不是一个多线程的程序，而gnus也没有打算和别的程序合作，你打开 gnus的时候，Emacs的所有frame都会失去相应一段时间，时间的长短视 gnus把所有的邮件收回来需要的时间而定；如果你在家慢慢拨号的话，而且信有很多的话，这段时间可能会长达15分钟。事实上，news.gnus.org里面的同学似乎都是开了两个Emacs的，一个专门起gnus，另一个干活，酱紫。

好了，如果你连这个也不在乎的话，那就开始吧。M-x gnus。你会什么也看不见。这是因为gnus缺省以为，你收的邮件，都是属于某一个列表的，就好像bbs上的版面一样，你不订阅，就什么也看不见。订阅很容易，用^可以进入*Server Buffer*，在nnfolder上按RET，看到mail.misc以后按u就可以订阅它。 缺省所有没有分类的邮件都会跑到mail.misc里面去。你以后在慢慢改吧。


10.2  删除邮件
如何删除邮件，是GNUS的一个特点。

我们上bbs的时候，帖子怎么处理，不是我们说了算的，而是版主说了算了的。换句话说，帖子的生命周期是不受你掌握的，如果你想保存某一封帖子，你得把它下载到你自己的硬盘上去。gnus认为邮件也是酱紫的。在gnus里面，主动删除邮件是不提倡的，你应该让gnus自己处理邮件，被称为过期（expire）。

在缺省的设置中，你可以在一封邮件上按E，告诉gnus，这封邮件，过期了。 但是过期并不等同于删除，gnus会将这封邮件放入expire的队列中，然后等待一个特定的时间，差不多就是你真的已经忘了这封邮件的时候，gnus悄悄的删除了它。

你也可以采用auto expire模式，gnus会认为，所有你“读”过的信都是过期的，于是那些信都悄悄的自动进了过期队列，等着被删除。你还可以采用total expire模式，gnus会认为，所有你“标记为读”的信，都是过期的，于是那些信也都悄悄的进了过期队列，等着被删除。

这样的做法看起来比较诡异，但是处理邮件列表的时候却让人觉得非常自然。 所有看过就忘的信，不用去管什么时候要删除它，而且这些信在被删除之前，不会主动跳出来骚扰你；如果看到列表中某一个thread，记不起来之前这个thread到底是怎么样的，可以把这个thread没有真正删除的邮件都翻出来，显示一个完整的thread。相当于说，你总能在本地保留这个maillist最近若干天的snapshot。

对于其他信件，处理也是一样的。除非是mm发给你的一万年都不能删除的信件，别的信都可以让它自己悄悄跑进过期队列，悄悄消失。你甚至可以改变那些过期邮件的去向，不删除他们，而是把他们按时期打个包，已备若干年后写回忆录用(joking)。如果你万分肯定，这封信必须当即删除，比如不能给mm看到的别人写给你的情书，那就B del，不过这个情况很少很少，而且会导致gnus一些诡异的行为，以后再说。

罗里罗嗦了很多。expire具体的设置，都和邮件的分类联系在一起，下次再说吧，手累了。 ;-(


10.3  邮件分类
收到很多信的时候，需要分一下类。所有能用的mail客户端都支持对收到的mail做分类，包括gnus。在gnus当中，你可以通过指定的规则，将某一些邮件归成一类；在gnus看来，这样的一类邮件，基本上等同于news 服务器上的一个讨论组。

给邮件分组的工作，是通过设置nnmail-split-methods来实现的。 gnus里面所有的设置名字都很长，容易敲错，一个简单的判别方法，是在变量上面C-h v看看有没有文档。 有文档的至少能够说明这个变量名没有敲错。

我推荐使用nnmail-split-fancy来实现邮件分类，因为从个人经验来看，用fancy分类，至少可以把判别规则写的好看一点。这里先给一个sample。
 
(setq nnmail-split-fancy
     '(|
;;      (: gnus-group-split-fancy)
       (any ".*-?current@(freebsd|FreeBSD).org" "maillist.freebsd.current")
       (any ".*-?ipfw@(freebsd|FreeBSD).org" "maillist.freebsd.ipfw")
       (any "emacs-devel@gnu.org" "maillist.emacs.emacs-devel")
       "mail.misc"))
(setq nnmail-split-methods 'nnmail-split-fancy)
其实就是一些正则表达式。需要注意的是，如果将 nnmail-crosspost设置为nil，那么就不会出现“一稿多投”的情况，也就是说一封邮件在这些判别规则上遇到符合的就会直接break了。还有就是不建议在这里用太复杂的正则表达式，偶曾经试图在一行里面对所有 freebsd的邮件列表进行分类，结果死的挺难看的。

一旦邮件分类了。你应该也期望对不同类别的邮件作出区别对待。林林总总的需要都可以通过设置group parameter完成。对group parameter 的设置可以在gnus里面完成，使用G p或者G c：前者是字符界面的，后者是能跳出一个类似于cunstomize的界面来。也可以通过setq gnus-parameters，在.gnus文件里面手工设定。典型的例子比如：
 
(setq gnus-parameters ;;别写错了名字
     '(
       ("maillist.freebsd.(.*)$"
        (to-list . "1@freebsd.org")
        (posting-style
         (name "Me me me")
         (address "me2@whoami.com")
         (signature "Smile and Retain Smile.")) ;;签名档也可以是文件
        (total-expire . t)
        (expiry-wait . 7)
        (broken-reply-to . t)
        (subscribed . t))
))
注意，这里也可以用正则表达式哦 ;-)

group parameter 中的 to-list ，可以被自动收集起来；酱紫如果你在  nnmail-split-fancy 里面用 gnus-group-split-fancy 来自动分类，免去自己重写一遍分类规则的麻烦。不过设置gnus-parameters，是没办法利用这种能力。

设置好了 group parameter 能够简化很多事情。比如现在在 freebsd 的某个list里面按一下a，收件人地址就自动设成to-list了。很多时候比 bbdb还要方便的多。


10.4  SCORING

Chapter 11
支持中文
何曾几时，中文支持是Emacs的强项。在Emacs里面开一个shell上水木几乎是我唯一的选择。 时代变了，Emacs的中文支持就渐渐的落后了。

Emacs内部有一套表示多国的方法，就是所谓的emacs-mule。我们能够在同一个emacs buffer里面能够同时看中日韩文字，能够同时看到阿拉伯文，能够同时看到德文，丹麦文；这都拜emacs-mule所赐。不幸的是 emacs-mule并没有成为事实上的编码标准。emacs-mule除了emacs自己能够认识以外，其他的编辑器都不支持。所以Emacs必须在和其他文本处理器交互的时候重新编码内部的emacs-mule。这里没有必要谈太多的细节， Emacs是一个self-document的编辑器，上面这些细节都可以在 coding.[ch]和charset.[ch]中找到。

为了能和键盘交互（可以认为键盘是一个文本处理器，Emacs从键盘中读入文本），Emacs将从键盘中读入的文本“解码”为emacs-mule（我们这里说到编码解码，都是从Emacs的角度来看），为了文件能被其他的文本编辑器打开，比如vi，Emacs在存盘的时候将emacs-mule编码为 chinese-iso-8bit。这就是我们平常用到的各种coding system起到的作用。

为了让Emacs支持gbk，我们需要做的，就是让所有的gbk编码字符，都能够在emacs-mule中找到自己的座位。虽然实际上emacs-mule里面所有的座位都已经被人坐满了，我们还是可以假设那些很少有人出现的座位依然是空的。前面给出的chinese-gbk就强占了cns11643-5, 6, 7的座位。这些座位的汉字几乎不可能出现在我们这些人的屏幕上，所以这种做法基本上是可行的。所以如果有一天，你在使用chinese-gbk的时候，又试图用 cns11643的编码来保存，还请你回到这里来想想可能会发生的事情。

因为Emacs已经开始支持unicode了，所以让utf-8或者utf-16编码的 gbk汉字的文件在Emacs中显示并不是麻烦。而且Emacs已经在这里预留了 hook，只需要给一个 translate-table ，那就一切ok了。

让 Emacs 支持从X拷贝过来的gbk汉字，很难直接在 lisp 代码中实现。因为X和 emacs 一样是个历史悠久的软件，所以它同样也有一套自己的多字节编码格式。在 Emacs 中，缺省是采用 compound-text-with-extension 来处理这种编码格式的。从作者当初开发的思路来看，我们让它支持gbk编码，只需要添加一项 ("GBK-0" . chinese-gbk) 到 non-standard-icccm-encodings-alist中去，就可以简单的扩展支持gbk编码了。然而，因为实现上bug，和X本身的问题，这终究只是一个美好的愿望。如果你坚持的话，可以尝试一下这个补丁。注意这个时候就不能再使用 compound-text-with-extensions 作为 selection 的 coding system 了，而应该用chinese-gbk。
--- /home/huxw/src/Resp/emacs/src/xselect.c     2003-04-07 04:35:06.000000000 +0800
+++ xselect.c   2003-05-26 11:17:42.966829744 +0800
@@ -1496,6 +1496,11 @@
     Lisp_Object target_type;  /* for error messages only */
     Atom selection_atom;      /* for error messages only */
{
+       // by huxw start here
+       XTextProperty text_prop;
+       char** local_list;
+       int local_number = 0;
+       // by huxw end here
  Atom actual_type;
  int actual_format;
  unsigned long actual_size;
@@ -1554,12 +1559,70 @@

  /* It's been read.  Now convert it to a lisp object in some semi-rational
     manner.  */
+  //by huxw start here
+  if (XSupportsLocale()) {
+         int local_status;
+
+         text_prop.value = (char*)data;
+         text_prop.encoding = actual_type;
+         text_prop.format = actual_format;
+         text_prop.nitems = actual_size;
+
+         local_status = XmbTextPropertyToTextList(display, &text_prop, &local_list, &local_number);
+         if (local_status < Success || !local_number || !*local_list ) {
+         } else {
+                 xfree((char*)data);
+                 data = strdup(*local_list);
+                 XFreeStringList(local_list);
+         }
+  } else {
+  }
+  //by huxw end here
+
+#if 0
  val = selection_data_to_lisp_data (display, data, bytes,
                                    actual_type, actual_format);
+#else
+       val = selection_data_to_lisp_data (display, data, strlen(data), actual_type, actual_format);
+#endif

  /* Use xfree, not XFree, because x_get_window_property
     calls xmalloc itself.  */
-  xfree ((char *) data);
+
+  // by huxw start here
+//  xfree ((char *) data);
+  if (local_number == 0) { // Xmb is not used or not successed
+         xfree((char*)data);
+  } else {
+         free(data);
+  }
+  // by huxw end here
  return val;
}Windows的国际化一向做的很好，可是Emacs没有打算依赖它。在 Windows里面跑的Emacs看起来很像在X里面跑的Emacs，很像，还是有一些要注意的地方。

Windows 里只定义了 GB2312_CHARSET ，这把Emacs搞糊涂了。如果在 Emacs里面列出可用的所有字体，会发现没有字体是以gbk结尾的，这也使得Emacs无法处理所有gbk编码的汉字，只能显示一个方框代替。处理方法一样简单，只要把 ("gbk" w32-charset-gb2312 . 936) 加到  w32-charset-info-alist 中去就可以了。另外一个问题是Emacs有时无法正确处理字体名称中的中文编码，这种时候很是少见，找出问题之前，绕开就是了。

Windows下的粘贴拷贝并没有额外的编码，所以把  clipboard-coding-system 设成 chinese-gbk 就可以了，没有X底下的困扰。

Emacs的中文支持虽然看起很繁琐，但是它却是最完善的。比如我们知道动感超人的口号是“啊哈{6,8}”，这种正则表达除了在Emacs里面，还能在哪里用呢？

以上所说，都是针对FSF Emacs，而不是XEmacs。XEmacs的X11版本虽然也是用的 mule，但是做法稍有不同。而对于XEmacs的win32版本则根本不支持中文。XEmacs的新版本中会有不小改进，请拭目以待。