Linux提供了丰富的帮助手册，当你需要查看某个命令的参数时不必到处上网查找，只要man一下即可。
Linux的man手册共有以下几个章节：

1、Standard commands （标准命令）
2、System calls （系统调用）
3、Library functions （库函数）
4、Special devices （设备说明）
5、File formats （文件格式）
6、Games and toys （游戏和娱乐）
7、Miscellaneous （杂项）
8、Administrative Commands （管理员命令）

例如：我们输入 man ls，它会在最左上角显示“LS（1）”，在这里，“LS”表示手册名称，而“（1）”表示该手册位于第一节章，同样，我们输入“man ifconfig”它会在最左上角显示“IFCONFIG（8）”。也可以这样输入命令：“man [章节号] 手册名称”。

man是按照手册的章节号的顺序进行搜索的，比如：

man sleep

只会显示sleep命令的手册,如果想查看库函数sleep，就要输入:

man 3 sleep

ubuntu默认是没有安装c语言的库函数man手册的

1.添加库函数手册
ubuntu默认是没有安装c语言的库函数man手册的，所以你在man perror 和sendto之类的函数时会显示没有相关文档的问题，这个问题让我郁闷了我好久。解决方法：
sudo apt-get install manpages-dev
2.让man显示中文
ubuntu源里面已经包含了中文的man包，所以不用从其他地方down了，直接
sudo apt-get install manpages-zh
但是这样man默认显示的还不是中文，还需要以下两步
a.把中文man包转换成utf8格式的
新建一个脚本文件
gedit t.sh
把下面内容添加进去
#!/bin/bashcd /usr/share/man/zh_CN/for k in *docd $kfor i in *.gzdo j=`echo ${i%.gz}` gunzip $i iconv -f gb18030 -t utf8 $j >tmp mv tmp $j gzip $jdonecd ..done
然后
sudo ./t
b.修改man默认的语言
sudo gedit /etc/manpath.config 把里面的所有的 /usr/share/man 改成 /usr/share/man/zh_CN
保存后退出，然后你再试一下man ls
3.让没有中文帮助的显示英文
做 完上面第二部还不够，这时你再man 一下一些c语言函数（不要用printf，socket之类比较有名的函数，这些已经有中文帮助了）的时候就会发现竟然没有帮助，而刚才明明在第一步已经 安装了啊。这是因为你上面 把/usr/share/man 改成 /usr/share/man/zh_CN的操作使man只在中文帮助中搜索，如果没有就直接放弃，因此还需要以下操作，才能让man在没有中文帮助的时 候自动显示英文的帮助，如果英文的也没有，哪就真的没有了。
sudo gedit /etc/manpath.config
然后搜索你刚才改过的地方，然后在其后面添加同样的一行，只是后面的目录还用原来的/usr/share/man，比如在修改后的
MANPATH_MAP /bin /usr/share/man/zh_CN
再添加一行
MANPATH_MAP /bin /usr/share/man

原文地址 http://blog.chinaunix.net/u2/78601/showart_1917085.html TAG man ubuttu gnuc库

我通读过 MINIX，TCP/IP，BSD,LINUX, PL1的源码，我拿过中国高级程序员证书，SUN 的JAVA证书，精通VC和UNIX，对缓冲区溢出，病毒，
DDK等均有研究，所以我想我有资格对你们说几句话。

(如果我提到的一些计算机名词和人名，你们居然不知道，那只能证明你们的无知，和不配称为黑客。)

如果是真正的黑客，他会知道  

1.发明TCP/IP的是美国人 。

2. LINUX的作者，linus大侠现在也在美国工作 。

3. OPEN SOURCE的开创人 STALLMAN 也是美国人，他提倡软件不分国界的自由的精神 。

4. FREE BSD 的作者是美国人，他的SOURCE 让真正的黑客受惠

5.世界级软件科学大师 tanabaom，也是美国的客座教授，他的minix, ameba和教材教育了全世界几代黑客。

提到这些，不是崇美，不是恐美，只想证明：

1.很多大师级的美国黑客，他们的理念恰恰是自由、开放、无国界；他们的自由软件，开放源码，是与政治无关的，是超越国界的，给全世界
人们带来福音。

2.真正的黑客精神，如stallman所说，是要让人类超越计算机，成为计算机的主宰，从而成为自由的。

所有的中国黑客和红客，我的同胞们：

当你们正通过下载美国人写的黑客工具，来攻击美国网络，并且乐此不疲，以为这就是爱国行动的时候，是否想过：

此时此刻，印度的软件人士，正在努力提高软件技术，他们的软件水平、软件产业已经超越了中国；难道我们不应该痛苦地承认这个现实，
并且奋起直追吗？

中国发明了火药，但是缺少研究精神，结果是被西方人研究改进了以后打中国，这样的教训还少吗？

中国向来不缺爱国热情，但是我们缺少对科技的认真研究精神，知耻而后勇的追赶精神。难道我们不愿意承认这一点吗？

从战术上来说，过早暴露自己的实力是不聪明的；冒昧地问一句，如果真的战争爆发了，您的黑客技术完全掌握好了吗，您已经为那一天的
到来在进行技术储备吗？

您有没有想向那些真正为中国科技做出杰出贡献的科学家如钱学森学习呢？

所有的中国黑客和红客，我的同胞们：

请把你们的聪明才智用到真正提高你们的水平，对国家的强大有帮助的地方吧：

如果您愿意对国家有所贡献：

1.中国的863计划中有一个重点研究项目： 并行计算，分布计算，向量计算。您愿意研究它吗？

2. 作为现代通讯技术的一个根本数学基础，大合数的快速因子分解，还是一个难题。您愿意研究它吗？

如果您想提高技术，对中国的软件技术有所贡献：

1.研究 VC，JAVA

2.研究数据结构，去考高级程序员

3. 研究操作系统，读minix source code

4. 研究tcp/ip, rfc文档

5. 通读linux, 才算达到黑客境界

6. 学习 UML，ROSE，软件工程，达到系统分析员水平。

如果您对提高中国的科技有兴趣，去研究生物基因，材料技术(纳米技术)，计算机技术，航天技术……

我的同胞们，我愿大声呐喊：

一个真正的民族主义者，不是义和团，不是太平天国，不是闭关锁国，不是盲目仇外，不是不敢正视自己民族和文化的丑陋和缺点。

真正的民族主义者是成熟的、清醒的、理智的、务实的民族主义。真正的民族主义者不是种族主义者，不是极端份子，不是战争狂人。

真正的民族主义者以追求本民族――中华民族的利益最大化为目标、准则、信念。判断一个人是不是真正的民族主义者，判断标准很简单：
看他是给本民族的整体利益带来好处，还是损害民族利益。真正的民族主义者最务实，因为他知道坚持原则，同时又懂得策略。让我们成为
真正的顶尖黑客！让我们成为真正的民族主义者!

1.先打开一个文件;

2.然后打开视图，如何打开呢？这是最重要的一步。按Ctrl+F10；

3.打开视图后选择Show Line Numbers；

4.这样行号就出来了，图我就不截了。

3.用记事本打开刚才保存的那个配置 文件（扩展文件名：*.epf），按"ctrl + F"，输入"content_assist_autoactivation_triggers_php"（或者可能 是：contentAssistAutoactivationTriggersPHP），找到刚才字符串。把"$\:>"（这是默认值，即＝号后面 的值）修改为"$\:>abcdefghijklmnopqrstuvwxyz("（即代码中输入上述所有符号后都会自动代码提示），然后保存，退 出记事本。

4.  打开Eclipse的 File -> Import 然后在打开的窗口里展开 General -> Perferences，点击NEXT，选中刚才修改过的配置文件，Finish。
5. 重启Eclipse就可以用了.

解决办法：

1、打开php.ini。找到 upload_max_filesize 、 memory_limit 、 post_max_size 这三个参数！
(在默认的情况下,php只允许最大的上传数据为2M,也就是2048KB,而极限的最大使用内存memory_limit也仅为128M，Post的最大也为2M)

2、按您的服务器的实际性能配置进行如下改动：（注意：以下是按我的服务器性能有硬件配置进行的更改..）

upload_max_filesize = 8M (上传最大极限设定为8M,这个应该足够一般的文件WEB上传了)
memory_limit = 512M (因为服务器的内存为2GB,所以这里加到512M不过份吧，呵)
post_max_size = 8M (Post数据最大也设置为8MB,这个跟upload_max一样)

3、改完之后，我再重新执行导入命令后：
Import has been successfully finished, 399 queries executed.
(显示导入成功,有多少个请求处理成功…)

（备注：改完后当你在到phpMyadmin的导入命令行时，虽然(有时候可能会仍然显示为:最大限制:2048KB/Max: 2,048KiB);但实际上你已经可以导入不超过8M的数据库gzip导出的备份文件了! 另，改完php.ini后，别忘了重启一下web服务或者是服务器哟！重启后升效!）

在黑客世界里，当提出一个技术问题时，你能得到怎样的回答？这取决于挖出答案的难度，同样取决于你提问的方法。本指南旨在帮助你提高发问技巧，以获取你最想要的答案。

首先你必须明白，黑客们只偏爱艰巨的任务，或者能激发他们思维的好问题。如若不然，我们还来干吗？如果你有值得我们反复咀嚼玩味的好问题，我们自会对 你感激不尽。好问题是激励，是厚礼，可以提高我们的理解力，而且通常会暴露我们以前从没意识到或者思考过的问题。对黑客而言，“问得好！”是发自内心的大 力称赞。

尽管黑客们有蔑视简单问题和不友善的坏名声，有时看起来似乎我们对新手，对知识贫乏者怀有敌意，但其实不是那样的。

我们不想掩饰对这样一些人的蔑视--他们不愿思考，或者在发问前不去完成他们应该做的事。这种人只会谋杀时间--他们只愿索取，从不付出，无端消耗我 们的时间，而我们本可以把时间用在更有趣的问题或者更值得回答的人身上。 我们称这样的人为“失败者”（由于历史原因，我们有时把它拼作“lusers”）。

我们在很大程度上属于志愿者，从繁忙的生活中抽出时间来解惑答疑，而且时常被提问淹没。所以我们无情的滤掉一些话题，特别是抛弃那些看起来象失败者的家伙，以便更高效的利用时间来回答胜利者的问题。

如果你觉得我们过于傲慢的态度让你不爽，让你委屈，不妨设身处地想想。我们并没有要求你向我们屈服--事实上，我们中的大多数人最喜欢公平交易不过 了，只要你付出小小努力来满足最起码的要求，我们就会欢迎你加入到我们的文化中来。但让我们帮助那些不愿意帮助自己的人是没有意义的。如果你不能接受这种 “歧视”，我们建议你花点钱找家商业公司签个技术支持协议得了，别向黑客乞求帮助。

如果你决定向我们求助，当然不希望被视为失败者，更不愿成为失败者中的一员。立刻得到有效答案的最好方法，就是象胜利者那样提问 —— 聪明、自信、有解决问题的思路，只是偶尔在特定的问题上需要获得一点帮助。

（欢迎对本指南提出改进意见。任何建议请E-mail至esr@thyrsus.com，然而 请注意，本文并非网络礼节的通用指南，我通常会拒绝无助于在技术论坛得到有用答案的建议。） （当然，如果你写中文，最好还是寄DHGrand@hotmail.com;-）

= 提问之前 =

在通过电邮、新闻组或者聊天室提出技术问题前，检查你有没有做到：

1. 通读手册，试着自己找答案。
2. 在FAQ里找答案（一份维护得好的FAQ可以包罗万象:）。
3. 在网上搜索（个人推荐google~~~）。
4. 向你身边精于此道的朋友打听。

当你提出问题的时候，首先要说明在此之前你干了些什么；这将有助于树立你的形象：你不是一个妄图不劳而获的乞讨者，不愿浪费别人的时间。如果提问者能从答案中学到东西，我们更乐于回答他的问题。

周全的思考，准备好你的问题，草率的发问只能得到草率的回答，或者根本得不到任何答案。越表现出在寻求帮助前为解决问题付出的努力，你越能得到实质性的帮助。

小心别问错了问题。如果你的问题基于错误的假设，普通黑客（J. Random Hacker）通常会用无意义的字面解释来答复你，心里想着“蠢问题...”，希望着你会从问题的回答（而非你想得到的答案）中汲取教训。

决不要自以为够资格得到答案，你没这种资格。毕竟你没有为这种服务支付任何报酬。你要自己去“挣”回一个答案，靠提出一个有内涵的，有趣的，有思维激励作用的问题--一个对社区的经验有潜在贡献的问题，而不仅仅是被动的从他人处索要知识--去挣到这个答案。

另一方面，表明你愿意在找答案的过程中做点什么，是一个非常好的开端。“谁能给点提示？”、“我这个例子里缺了什么？”以及“我应该检查什么地方？”比“请把确切的过程贴出来”更容易得到答复。因为你显得只要有人指点正确的方向，你就有完成它的能力和决心。

= 怎样提问 =

- 谨慎选择论坛
小心选择提问的场合。如果象下面描述的那样，你很可能被忽略掉或者被看作失败者：

1. 在风马牛不相及的论坛贴出你的问题
2. 在探讨高级技巧的论坛张贴非常初级的问题；反之亦然
3. 在太多的不同新闻组交叉张贴

- 用辞贴切，语法正确，拼写无误
我们从经验中发现，粗心的写作者通常也是马虎的思考者（我敢打包票）。 回答粗心大意者的问题很不值得，我们宁愿把时间耗在别处。

正确的拼写，标点符号和大小写很重要。
更一般的说，如果你的提问写得象个半文盲，你很有可能被忽视。

如果你在使用非母语的论坛提问，你可以犯点拼写和语法上的小错--但决不能在思考上马虎（没错，我们能弄清两者的分别）

- 使用含义丰富，描述准确的标题
在邮件列表或者新闻组中，大约50字以内的主题标题是抓住资深专家注意力 的黄金时机。别用喋喋不休的“帮帮忙”（更别说“救命啊！！！！！”这 样让人反感的话）来浪费这个机会。不要妄想用你的痛苦程度来打动我们， 别用空格代替问题的描述，哪怕是极其简短的描述。

蠢问题： 救命啊！我的膝上机不能正常显示了！
聪明问题： XFree86 4.1下鼠标光标变形，Fooware MV1005的显示芯片。

如果你在回复中提出问题，记得要修改内容标题，表明里面有一个问题。一个看起来象“Re：测试”或者“Re：新bug”的问题很难引起足够重视。另外，引用并删减前文的内容，给新来的读者留下线索。

- 精确描述，信息量大

1. 谨慎明确的描述症状。
2. 提供问题发生的环境（机器配置、操作系统、应用程序以及别的什么）。
3. 说明你在提问前是怎样去研究和理解这个问题的。
4. 说明你在提问前采取了什么步骤去解决它。
5. 罗列最近做过什么可能有影响的硬件、软件变更。

尽量想象一个黑客会怎样反问你，在提问的时候预先给他答案。

Simon Tatham写过一篇名为《如何有效的报告Bug》的出色短文。强力推荐你也读一读。

- 话不在多
你需要提供精确有效的信息。这并不是要求你简单的把成吨的出错代码或者数据完全转储摘录到你的提问中。如果你有庞大而复杂的测试条件，尽量把它剪裁得越小越好。

这样做的用处至少有三点。第一，表现出你为简化问题付出了努力，这可以使你得 到回答的机会增加；第二，简化问题使你得到有用答案的机会增加；第三，在提炼 你的bug报告的过程中，也许你自己就能找出问题所在或作出更正。

- 只说症状，不说猜想
告诉黑客们你认为问题是怎样引起的没什么帮助。（如果你的推断如此有效，还用向别人求助吗？），因此要确信你原原本本告诉了他们问题的症状，不要加进你自己的理解和推论。让黑客们来诊断吧。

蠢问题： 我在内核编译中一次又一次遇到SIG11错误，我怀疑某条飞线搭在主板的走线上了，这种情况应该怎样检查最好？
聪明问题： 我自制的一套K6/233系统，主板是FIC-PA2007 （VIA Apollo VP2芯片组），256MB Corsair PC133 SDRAM，在内核编译中频频产生SIG11错误，从开机20分钟以后就有这种情况，开机 前20分钟内从没发生过。重启也没有用，但是关机一晚上就又能工作20分钟。所有 内存都换过了，没有效果。相关部分的典型编译记录如下...。

- 按时间顺序列出症状
对找出问题最有帮助的线索，往往就是问题发生前的一系列操作，因此，你的说明 应该包含操作步骤，以及电脑的反应，直到问题产生。

如果你的说明很长（超过四个段落），在开头简述问题会有所帮助，接下来按时间顺序详述。这样黑客们就知道该在你的说明中找什么。

- 明白你想问什么
漫无边际的提问近乎无休无止的时间黑洞。最能给你有用答案的人也正是最忙的人（他们忙是因为要亲自完成大部分工作）。这样的人对无节制的时间黑洞不太感冒，因此也可以说他们对漫无边际的提问不大感冒。

如果你明确表述需要回答者做什么（提供建议，发送一段代码，检查你的补丁或是别的），就最有可能得到有用的答案。这会定出一个时间和精力的上限，便于 回答者集中精力来帮你，这很凑效。要理解专家们生活的世界，要把专业技能想象为充裕的资源，而回复的时间则是贫乏的资源。解决你的问题需要的时间越少，越 能从忙碌的专家口中掏出答案。

因此，优化问题的结构，尽量减少专家们解决它所需要的时间，会有很大的帮助--这通常和简化问题有所区别。因此，问“我想更好的理解X，能给点提示 吗？”通常比问“你能解释一下X吗？”更好。如果你的代码不能工作，问问它有什么地方不对，比要求别人替你修改要明智得多。

- 别问应该自己解决的问题
黑客们总是善于分辨哪些问题应该由你自己解决；因为我们中的大多数都曾自己解决这类问题。同样，这些问题得由你来搞定，你会从中学到东西。你可以要求给点提示，但别要求得到完整的解决方案。

- 去除无意义的疑问
别用无意义的话结束提问，例如“有人能帮我吗？”或者“有答案吗？”。 首先：如果你对问题的描述不很合适，这样问更是画蛇添足。其次：由于这 样问是画蛇添足，黑客们会很厌烦你--而且通常会用逻辑上正确的回答来表 示他们的蔑视，例如：“没错，有人能帮你”或者“不，没答案”。

- 谦逊绝没有害处，而且常帮大忙
彬　　彬有礼，多用“请”和“先道个谢了”。让大家都知道你对他们花费时间义务提供帮助心存感激。然而，如果你有很多问题无法解决，礼貌将会增加你得到有用答案的机会。

（我们注意到，自从本指南发布后，从资深黑客处得到的唯一严重缺陷反馈，就是对预先道谢这一条。一些黑客觉得“先谢了”的言外之意是过后就不会再感谢任何人了。我们的建议是：都道谢。）

- 问题解决后，加个简短说明
问题解决后，向所有帮助过你的人发个说明，让他们知道问题是怎样解决的，并再一次向他们表示感谢。如果问题在新闻组或者邮件列表中引起了广泛关注，应 该在那里贴一个补充说明。补充说明不必很长或是很深入；简单的一句“你好，原来是网线出了问题！谢谢大家--Bill”比什么也不说要强。事实上，除非结 论真的很有技术含量，否则简短可爱的小结比长篇学术论文更好。说明问题是怎样解决的，但大可不必将解决问题的过程复述一遍。除了表示礼貌和反馈信息以外， 这种补充有助于他人在邮件列表/新闻组/论坛中搜索对你有过帮助的完整解决方案，这可能对他们也很有用。最后（至少？），这种补充有助于所有提供过帮助的 人从中得到满足感。如果你自己不是老手或者黑客，那就相信我们，这种感觉对于那些你向他们求助的导师或者专家而言，是非常重要的。问题久拖未决会让人灰 心；黑客们渴望看到问题被解决。好人有好报，满足他们的渴望，你会在下次贴出新问题时尝到甜头。

- 还是不懂
如果你不是很理解答案，别立刻要求对方解释。象你以前试着自己解决问题时那样（利用手册，FAQ，网络，身边的高手），去理解它。如果你真的需要对方 解释，记得表现出你已经学到了点什么。比方说，如果我回答你：“看来似乎是zEntry被阻塞了；你应该先清除它。”，然后：一个很糟的后续问题： “zEntry是什么？” 聪明的问法应该是这样：“哦~~~我看过帮助了但是只有-z和-p两个参数中提到了zEntry而且还都没有清楚的解释:<你是指这两个中的哪一个 吗？还是我看漏了什么？”

= 三思而后问 =

以下是几个经典蠢问题，以及黑客在拒绝回答时的心中所想：

问题：我能在哪找到X程序？
问题：我的程序/配置/SQL申明没有用
问题：我的Windows有问题，你能帮我吗？
问题：我在安装Linux（或者X）时有问题，你能帮我吗？
问题：我怎么才能破解root帐号/窃取OP特权/读别人的邮件呢？

提问：我能在哪找到X程序？
回答：就在我找到它的地方啊蠢货--搜索引擎的那一头。天呐！还有人不会用Google吗？

提问：我的程序（配置、SQL申明）没有用
回答：这不算是问题吧，我对找出你的真正问题没兴趣--如果要我问你二十个问题才找得出来的话--我有更有意思的事要做呢。

在看到这类问题的时候，我的反应通常不外如下三种：

1. 你还有什么要补充的吗？
2. 真糟糕，希望你能搞定。
3. 这跟我有什么鸟相关？

提问：我的Windows有问题，你能帮我吗？
回答：能啊，扔掉萎软的垃圾，换Linux吧。

提问：我在安装Linux（或者X）时有问题，你能帮我吗？
回答：不能，我只有亲自在你的电脑上动手才能找到毛病。还是去找你当地的Linux用户组寻求手把手的指导吧（你能在这儿找到用户组的清单）。

提问：我怎么才能破解root帐号/窃取OP特权/读别人的邮件呢？
回答：想要这样做，说明你是个卑鄙小人；想找个黑客帮你，说明你是个白痴！

= 好问题，坏问题 =

最后，我举一些例子来说明，怎样聪明的提问；同一个问题的两种问法被放在一起，一种是愚蠢的，另一种才是明智的。

蠢问题：我可以在哪儿找到关于Foonly Flurbamatic的资料？
// 这种问法无非想得到“STFW”这样的回答。

聪明问题：我用Google搜索过“Foonly Flurbamatic 2600”，但是没找到有用的结果。谁知道上哪儿去找对这种设备编程的资料？
// 这个问题已经STFW过了，看起来他真的遇到了麻烦。

蠢问题：我从FOO项目找来的源码没法编译。它怎么这么烂？
// 他觉得都是别人的错，这个傲慢自大的家伙

聪明问题：FOO项目代码在Nulix 6.2版下无法编译通过。我读过了FAQ，但里面没有提到跟Nulix有关的问题。这是我编译过程的记录，我有什么做得不对的地方吗？
// 他讲明了环境，也读过了FAQ，还指明了错误，并且他没有把问题的责任推到别人头上，这个家伙值得留意。

蠢问题：我的主板有问题了，谁来帮我？
// 普通黑客对这类问题的回答通常是：“好的，还要帮你拍拍背和换尿布吗？” ，然后按下删除键。

聪明问题：我在S2464主板上试过了X、Y和Z，但没什么作用，我又试了A、B和C。请注意当我尝试C时的奇怪现象。显然边带传输中出现了收缩，但结果出人意料。在多处理器主板上引起边带泄漏的通常原因是什么？谁有好主意接下来我该做些什么测试才能找出问题？
// 这个家伙，从另一个角度来看，值得去回答他。他表现出了解决问题的能力，而不是坐等天上掉答案。

在最后一个问题中，注意“告诉我答案”和“给我启示，指出我还应该做什么诊断工作”之间微妙而又重要的区别。事实上，后一个问题源自于2001年8月 在Linux内核邮件列表上的一个真实的提问。我（Eric）就是那个提出问题的人。我在Tyan S2464主板上观察到了这种无法解释的锁定现象，列表成员们提供了解决那一问题的重要信息。

通过我的提问方法，我给了大家值得玩味的东西；我让人们很容易参与并且被吸引进来。我显示了自己具备和他们同等的能力，邀请他们与我共同探讨。我告诉 他们我所走过的弯路，以避免他们再浪费时间，这是一种对他人时间价值的尊重。后来，当我向每个人表示感谢，并且赞赏这套程序（指邮件列表中的讨论 --译者注）运作得非常出色的时候，一个Linux内核邮件列（lkml）成员表示，问题得到解决并非由于我是这个列表中的“名人”，而是因为我用了正确 的方式来提问。我们黑客从某种角度来说是拥有丰富知识但缺乏人情味的家伙；我相信他是对的，如果我象个乞讨者那样提问，不论我是谁，一定会惹恼某些人或者 被他们忽视。他建议我记下这件事，给编写这个指南的人一些指导。

= 找不到答案怎么办 =

如果仍得不到答案，请不要以为我们觉得无法帮助你。有时只是看到你问题的人不知道答案罢了。没有回应不代表你被忽视，虽然不可否认这种差别很难区分。

总的说来，简单的重复张贴问题是个很糟的想法。这将被视为无意义的喧闹。

你可以通过其它渠道获得帮助，这些渠道通常更适合初学者的需要。有许多网上的以及本地的用户组，由狂热的软件爱好者（即使他们可能从没亲自写过任何软件）组成。通常人们组建这样的团体来互相帮助并帮助新手。

另外，你可以向很多商业公司寻求帮助，不论公司大还是小（Red Hat 和LinuxCare 就是两个最常见的例子）。别为要付费才能获得帮助而感到沮丧！毕竟，假使你的汽车发动机汽缸密封圈爆掉了--完全可能如此--你还得把它送到修车铺，并且 为维修付费。就算软件没花费你一分钱，你也不能强求技术支持总是免费的。

对大众化的软件，就象Linux之类而言，每个开发者至少会有上万名用户。根本不可能由一个人来处理来自上万名用户的求助电话。要知道，即使你要为帮 助付费，同你必须购买同类软件相比，你所付出的也是微不足道的（通常封闭源代码软件的技术支持费用比开放源代码软件要高得多，且内容也不那么丰富）。

<esr@thyrsus.com>

Rick Moen

<respond-auto@linuxmafia.com>

Copyright © 2001-2006 Eric S. Raymond and Rick Moen

Table of Contents:

Translations
Disclaimer
Introduction
Before You Ask
When You Ask

Choose your forum carefully
Web and IRC forums directed towards new users often give the quickest response
As a second step, use project mailing lists
Use meaningful, specific subject headers
Make it easy to reply
Write in clear, grammatical, correctly-spelled language
Send questions in accessible, standard formats
Be precise and informative about your problem
Volume is not precision
Don't claim you've found a bug
Grovelling is no substitute for doing your homework
Describe the problem's symptoms, not your guesses
Describe your problem's symptoms in chronological order
Describe the goal, not the step
Don't ask people to reply by private e-mail
Be explicit about your question
Don't post homework questions
Prune pointless queries
Don't flag your question as "Urgent", even if it's for you
Courtesy never hurts, and sometimes helps
Follow up with a brief note on the solution

How to Interpret Answers

RTFM and STFW: How to tell you've seriously screwed up
If you don't understand...
Dealing with rudeness

On Not Reacting Like A Loser
Questions Not to Ask
Good and Bad Questions
If You Can't Get an Answer
How to Answer Questions in a Helpful Way
Related Resources
Special Note for FAQ List Maintainers and Webmasters
Acknowledgements

Translations

Translations: Bahasa Indonesian Brazilian-Portuguese Chinese Czech Danish Estonian Finnish French German Hebrew Hungarian Italian Japanese Polish Russian Serbian Spanish Swedish Turkish . If you want to copy, mirror, translate, or excerpt this essay's master copy, please see Eric's copying policy (which I, Rick Moen, endorse — this local copy, used for pending revisions intended to be re-merged, and to indulge my preference for Commonwealth spelling and for sundry pedantic usages, exists pursuant to my copyright title to our joint work, and may not be mirrored).

There are quite a few authorised (i.e., compliant with the copying policy) translations and mirrors, as well as a large number of unauthorised mirrors (either altered, outdated, or both). The latter are not OK.
Disclaimer

Many project Web sites link to this document in their sections on how to get help. That's fine, it's the use we intended — but, if you're a webmaster creating such a link for your project page, please display prominently near the link a notice that we are not your project's help desk!

We've learned the hard way that, without such a notice, we will repeatedly be pestered by idiots who think having published this document makes it our job to solve all the world's technical problems.

If you're reading this document because you need help, and you walk away with the impression you can get it directly from the authors, you are one of those idiots. Don't ask us questions: We'll just ignore you. We're here to show you how to get help from people who actually know about the software or hardware you're dealing with — but, 99% of the time, that will not be us. Unless you're certain one of the authors is expert in what you're dealing with, leave us alone and everybody will be happier.
Introduction

In the world of hackers, the kind of answers you get to your technical questions depends as much on the way you ask the questions as on the difficulty of developing the answer. This guide will teach you how to ask questions in a way more likely to get you a satisfactory answer.

Now that use of open source has become widespread, you can often get as good answers from other, more experienced users as from hackers. This is a Good Thing; users tend to be just a little bit more tolerant of the kind of failures new users often have. Still, treating experienced users like hackers, in the ways we recommend here, will generally be the most effective way to get useful answers out of them, too.

The first thing to understand is that hackers actually like hard problems, and good, thought-provoking questions about them. If we didn't, we wouldn't be here. If you give us an interesting question to chew on, we'll be grateful to you; good questions are a stimulus and a gift. Good questions help us develop our understanding, and often reveal problems we might not have noticed or thought about otherwise. Among hackers, "Good question!" is a strong and sincere compliment.

Despite this, hackers have a reputation for meeting simple questions with what looks like hostility or arrogance. It sometimes looks like we're reflexively rude to new users and the ignorant. However, this isn't really true.

What we are, unapologetically, is hostile to people who seem to be unwilling to think or to do their own homework before asking questions. People like that are time sinks: They take without giving back, and they waste time we could have spent on another question more interesting and another person more worthy of an answer. We call people like this "losers" (and, for historical reasons, sometimes spell it "lusers").

We realise there are many people who just want to use the software we write, who have no interest in learning technical details. For most people, a computer is merely a tool, a means to an end; they have more important things to do and lives to live. We acknowledge that, and don't expect everyone to take an interest in the technical matters that fascinate us. Nevertheless, our style of answering questions is tuned for people who do take such an interest and are willing to be active participants in problem-solving. That's not going to change. Nor should it; if it did, we would become less effective at the things we do best.

We're (largely) volunteers. We take time out of busy lives to answer questions, and at times we're overwhelmed with them. So we filter, ruthlessly. In particular, we throw away questions from people who appear to be losers, in order to spend our question-answering time more efficiently, on winners.

If you find this attitude obnoxious, condescending, or arrogant, check your assumptions. We're not asking you to genuflect to us — in fact, most of us would love nothing more than to deal with you as an equal, and welcome you into our culture, if you put in the effort required to make that possible. It's simply not efficient for us to try to help people who're not willing to help themselves. It's OK to be ignorant; it's not OK to play stupid.

So, while it isn't necessary to already be technically competent, to get attention from us, it is necessary to demonstrate the kind of attitude that leads to competence — alert, thoughtful, observant, willing to be an active partner in developing a solution. If you can't live with this sort of discrimination, we suggest you pay somebody for a commercial support contract, instead of asking hackers to personally donate help to you.

If you decide to come to us for help, you don't want to be one of the losers. You don't want to seem like one, either. The best way to get a rapid and responsive answer is to ask it like a person with smarts, confidence, and clues who just happens to need help on one particular problem.

(Improvements to this guide are welcome. You can e-mail suggestions to esr@thyrsus.com or rick@linuxmafia.com. Note, however, that this document is not intended to be a general guide to netiquette, and we will generally reject suggestions not specifically related to eliciting useful answers in a technical forum.)
Before You Ask

Before asking a technical question by e-mail, or in a newsgroup, or on a Web site chat board, do the following:

1.

Try to find an answer by searching the Web.
2.

Try to find an answer by reading the manual.
3.

Try to find an answer by reading a FAQ.
4.

Try to find an answer by inspection or experimentation.
5.

Try to find an answer by asking a skilled friend.
6.

If you're a programmer, try to find an answer by reading the source code.

When you ask your question, mention having done these things first; this will help establish that you're not being a lazy sponge and wasting people's time. Better yet, display what you've learned from doing these things. We like answering questions for people who've demonstrated they can learn from the answers.

Use tactics like doing a Google search on the text of your error message (searching Google Groups, as well as Web pages). This might well take you straight to fix documentation or a mailing list thread answering your question. Even if it doesn't, saying "I googled on the following phrase but didn't get anything promising" is a good thing to include in e-mail or news posting requesting help.

Take your time. Do not expect to be able to solve a complicated problem with a few seconds of Googling. Read and understand the FAQs, sit back, relax, and give the problem some thought before approaching experts. Trust us, they will be able to tell from your questions how much reading and thinking you did, and will be more willing to help if you come prepared. Don't instantly fire your whole arsenal of questions, just because your first search turned up no answers (or too many).

Prepare your question. Think it through. Hasty-sounding questions get hasty answers, or none at all. The more you do to demonstrate having put thought and effort into solving your problem before seeking help, the more likely you are to actually get help.

Beware of asking the wrong question. If you ask one that is based on faulty assumptions, J. Random Hacker is quite likely to reply with a uselessly literal answer, while thinking "Stupid question...", and hoping the experience of getting what you asked for, rather than what you needed, will teach you a lesson.

Never assume you're entitled to an answer. You're not; you aren't, after all, paying for the service. You will earn an answer, if you earn it, by asking a substantial, interesting, and thought-provoking question — implicitly contributing to the experience of the community, rather than merely passively demanding knowledge from others.

On the other hand, making clear your ability and willingness to help the solution-development process is a very good start. "Would someone provide a pointer?", "What is my example missing?", and "What site should I have checked?" are more likely to get answered than "Please post the exact procedure I should use", because you're stressing genuine willingness to complete the process, if someone can just point you in the right direction.
When You Ask
Choose your forum carefully

Be sensitive in choosing where you ask your question. You're likely to be ignored, or written off as a loser, if you:

*

post your question to a forum where it's off topic
*

post a very elementary question to a forum where advanced technical questions are expected, or vice-versa
*

cross-post to too many different newsgroups
*

post a personal e-mail to somebody who is neither a personal acquaintance nor personally responsible for solving your problem

Hackers blow off inappropriately targeted questions, in order to try to protect their communications channels from being drowned in irrelevance. You don't want this to happen to you.

The first step, therefore, is to find the right forum. Again, Google and other Web-searching methods are your friend. Use them to find the project Web page most closely associated with the hardware or software giving you difficulties. Usually, it will have links to a FAQ (Frequently Asked Questions) list, and to project mailing lists and their archives. These mailing lists are the final places to go for help, if your own efforts (including reading those FAQs you found) don't find you a solution. The project page may also describe a bug-reporting procedure, or have a link to one; if so, follow it.

Shooting off an e-mail to a person or forum you're unfamiliar with is risky at best. For example, don't assume the author of an informative Web page wants to be your free consultant. Don't make optimistic guesses about whether your question will be welcome: If you're unsure, send it elsewhere, or refrain from sending it at all.

When selecting a Web forum, newsgroup, or mailing list, don't trust the name by itself too far; look for a FAQ or charter to verify your question being on-topic. Read some of the back traffic, before posting, so you'll get a feel for how things are done, there. In fact, do a keyword search for words relating to your problem, on the newsgroup or mailing list archives, before you post. It may find you an answer, and, if not, it will help you formulate a better question.

Don't shotgun-blast all available help channels at once; that's like yelling, and irritates people. Step through them.

Know what your topic is! One of the classic mistakes is asking questions about the Unix or Windows programming interface in a forum devoted to a language or library or tool portable across both. If you don't understand why this is a blunder, you'd be best off not asking any questions at all, until you get it.

In general, questions to a well-selected public forum are more likely to get useful answers than are equivalent questions to a private one. There are multiple reasons: One is simply the size of the pool of potential respondents. Another is the size of the audience; hackers would rather answer questions that educate many people than questions serving only a few.

Understandably, skilled hackers and authors of popular software are already receiving more than their fair share of mis-targeted messages. By adding to the flood, you could in extreme cases even be the straw that breaks the camel's back — quite a few times, contributors to popular projects have withdrawn their support because collateral damage in the form of useless e-mail traffic to their personal accounts became unbearable.
Web and IRC forums directed towards new users often give the quickest response

Your local user group, or your Linux distribution, may advertise a Web forum or IRC channel where new users can get help. (In non-English-speaking countries, new-user forums are still more likely to be mailing lists.) These are good first places, to ask, especially if you think you may have tripped over a relatively simple or common problem. An advertised IRC channel is an open invitation to ask questions there, and often get answers in real time.

In fact, if you got the program that is giving you problems from a Linux distribution (as common today), it may be better to ask in the distro's forum/list before trying the program's project forum/list. The project's hackers may just say, use our build.

Before posting to any Web forum, check if it has a Search feature. If it does, try a couple of keyword searches for something like your problem; it just might help. If you did a general Web search before (as you should have), search the forum anyway; your Web-wide search engine might not have all of this forum indexed recently.

There is an increasing tendency for projects to do user support over a Web forum or IRC channel, with e-mail reserved more for development traffic. So, look for those channels first, when seeking project-specific help.
As a second step, use project mailing lists

When a project has a development mailing list, write to the mailing list, not to individual developers, even if you believe you know who can best answer your question. Check the documentation of the project and its homepage for the address of a project mailing list, and use it. There are several good reasons for this policy:

*

Any question good enough to be asked of one developer will also be of value to the whole group. Contrariwise, if you suspect your question is too dumb for a mailing list, it's not an excuse to harass individual developers.
*

Asking questions on the list distributes load between developers. Individual developers (especially the project leader) may be too busy to answer your questions.
*

Most mailing lists are archived, and the archives are indexed by search engines. Somebody could find your question and the answer on the Web, instead of asking it again in the list.
*

If certain questions are seen being asked often, developers can use that information to improve the documentation or the software itself, to be less confusing. If those questions are asked in private, nobody has a complete picture of what questions are asked most often.

If a project has both a "user" and a "developer" (or "hacker") mailing list or Web forum, and you're not hacking on the code, ask in the "user" list/forum. Don't assume you will be welcome on the developer list, where they're likely to experience your question as noise disrupting their developer traffic.

However, if you're sure your question is non-trivial, and you get no answer in the "user" list/forum for several days, try the "developer" one. You would be well advised to lurk there for a few days, before posting, to learn the local folkways. (Actually, this is good advice on any private or semi-private list.)

If you can't find a project's mailing list address, but see only the project maintainer's address, go ahead and e-mail the maintainer. However, even in that case, don't assume the mailing list doesn't exist. Mention in your e-mail your unfruitful attempt to find an appropriate mailing list. Also mention that you don't object to having your message forwarded to other people. (Many people think private e-mail should remain private, even if nothing in it is secret. By allowing forwarding, you give correspondents a choice in handling your mail.)
Use meaningful, specific subject headers

On mailing lists, newsgroups, or Web forums, the subject header is your golden opportunity to attract qualified experts' attention, in around 50 characters or fewer. Don't waste it on babble like "Please help me" (let alone "PLEASE HELP ME!!!!"; messages with such subjects get discarded, by reflex). Don't try to impress us with the depth of your anguish; use the space for a super-concise problem description, instead.

One good convention for subject headers, used by many tech support organizations, is "object - deviation". The "object" part specifies what thing, or group of things, is having a problem. The "deviation" part describes observed deviation from expected behaviour.

Stupid:

HELP! Video doesn't work properly on my laptop!
Smart:

X.org 6.8.1 misshapen mouse cursor, Fooware MV1005 vid. chipset
Smarter:

X.org 6.8.1 mouse cursor on Fooware MV1005 vid. chipset - is misshapen

The process of writing an "object-deviation" description will help you organise your thinking about the problem in more detail. What is affected? Just the mouse cursor, or other graphics, too? Is this specific to the X.org version of X? To version 6.8.1? Is this specific to Fooware video chipsets? To model MV1005? A hacker who sees the result can immediately understand what you're having a problem with and the problem you're having, at a glance.

If you ask a question in a reply, be sure to change the subject line to indicate you're asking a question. A Subject line resembling "Re: test" or "Re: new bug" is less likely to attract useful amounts of attention. Also, pare quotations of previous messages, to the minimum consistent with cluing in new readers.

Don't simply hit Reply on an existing list message, to start an entirely new thread: This will limit your audience. Some e-mail readers, like mutt, allow the user to sort by thread, and then hide messages in a thread by folding the thread. Such users will never see your message.

Changing the subject isn't sufficient. Mutt, and probably other e-mail readers, looks at other information in the e-mail's headers to assign it to a thread, not the subject line. Instead, start an entirely new e-mail.

On Web forums, the rules of good practice are slightly different, because messages are usually much more tightly bound to specific discussion threads, and often invisible outside those threads. Changing the subject when asking a question in reply is not essential. Not all forums even allow separate subject lines on replies, and nearly nobody reads them when they do. However, asking a question in a reply is a dubious practice in itself, because it will be seen only by those who're watching this thread. So, unless you're sure you want to ask the people currently active in the thread, start a new one.
Make it easy to reply

Finishing your query with "Please send your reply to..." makes it quite unlikely you'll get an answer. If you can't be bothered taking even the few seconds required to set up a correct Reply-To header in your e-mail agent, we can't be bothered to take even a few seconds to think about your problem. If your e-mail program doesn't permit this, get a better e-mail program. If your operating system doesn't support any e-mail programs permitting this, get a better operating system.

In Web forums, asking for a reply by e-mail is outright rude, unless you believe the information may be sensitive (and somebody will, for some unknown reason, let you but not the whole forum know it). If you want an e-mail copy when somebody replies in the thread, request that the Web forum send it; this feature is supported almost everywhere, under options like watch this thread, send e-mail on answers, etc.
Write in clear, grammatical, correctly-spelled language

We've found by experience that careless, sloppy writers are usually also careless, sloppy thinkers and coders (often enough to bet on, anyway). Answering questions for careless, sloppy thinkers is not rewarding; we'd rather spend our time elsewhere.

So, expressing your question clearly and well is important. If you can't be bothered to do that, we can't be bothered to pay attention. Spend the extra effort to polish your language. It doesn't have to be stiff or formal — in fact, hacker culture values informal, slangy, and humorous language used with precision. However, it has to be precise; there has to be some indication that you're thinking and paying attention.

Spell, punctuate, and capitalise correctly. Don't confuse "its" with "it's", "loose" with "lose", or "discrete" with "discreet". Don't TYPE IN ALL CAPS; this is read as shouting, and considered rude. (All-smalls is only slightly less annoying, as it's difficult to read. Alan Cox can get away with it; you can't.)

More generally, if you write like a semi-literate boob, you'll very likely be ignored. Writing like a l33t script kiddie hax0r is the absolute kiss of death, and guarantees you'll receive nothing but stony silence (or, at best, a heaping helping of scorn and sarcasm), in return.

If you're asking questions in a forum not in your native language, you'll get a limited amount of slack for spelling and grammar errors — but no extra slack at all for laziness (and yes, we can usually spot the difference). Also, unless you know what your respondent's languages are, write in English. Busy hackers tend to simply flush questions in languages they don't understand, and English is the Internet's working language. By writing in English, you minimise the chance of your question being discarded unread.
Send questions in accessible, standard formats

If you make your question artificially hard to read, it's more likely to be passed over in favor of one that isn't. So:

*

Send plain text e-mail, not HTML. (It's not hard to turn off HTML.)
*

MIME attachments are usually OK, but only if they're real content (such as an attached source file or patch), and not merely boilerplate generated by your e-mail client (such as another copy of your message).
*

Don't send e-mail in which entire paragraphs are single multiply-wrapped lines. (This makes it too difficult to reply to just part of the message.) Assume your respondents will be reading e-mail on 80-character-wide text displays, and set your line wrap accordingly, to something less than 80.
*

However, do not wrap data (such as log file dumps or session transcripts) at any fixed column width. Data should be included as-is, so respondents can have confidence they're seeing what you saw.
*

Don't send MIME Quoted-Printable encoding to an English-language forum. This encoding can be necessary when posting in a language ASCII doesn't cover, but many e-mail agents don't support it. When they break, all those =20 glyphs scattered through the text are ugly and distracting — or may actively sabotage the semantics of your text.
*

Never, ever expect hackers to be able to read closed proprietary document formats like Microsoft Word or Excel. Most hackers react to these about as well as you would to having a pile of steaming pig manure dumped on your doorstep. Even when they can cope, they resent having to do so.
*

If you're sending e-mail from a Windows machine, turn off Microsoft's stupid "Smart Quotes" feature. This is so you'll avoid sprinkling garbage characters through your e-mail.
*

In Web forums, do not abuse smiley and HTML features (when they're present). A smiley or two is usually OK, but coloured fancy text tends to make people think you're lame. Seriously overusing smileys and colour and fonts will make you come off like a giggly teenage girl, which is not generally a good idea unless you're more interested in sex than in answers.

If you're using a graphical-user-interface e-mail client, (such as Netscape Messenger, MS Outlook, or their ilk), beware that it may violate these rules when used with its default settings. Most such clients have a menu-based "View Source" command. Use this on something in your sent-mail folder, verifying sending of plain text without unnecessary attached crud.
Be precise and informative about your problem

*

Describe the symptoms of your problem or bug carefully and clearly.
*

Describe the environment in which it occurs (machine, OS, application, whatever). Provide your vendor's distribution and release level (e.g.: "Fedora Core 2", "Slackware 9.1" etc.).
*

Describe the research you did to try and understand the problem before you asked the question.
*

Describe the diagnostic steps you took to try and pin down the problem yourself, before you asked the question.
*

Describe any possibly relevant recent changes to your computer or software configuration.

Do the best you can to anticipate the questions a hacker will ask, and answer them in advance in your request for help.

Simon Tatham has written an excellent essay entitled How to Report Bugs Effectively. I strongly recommend you read it.
Volume is not precision

You need to be precise and informative. This end is not served by simply dumping huge volumes of code or data into a help request. If you have a large, complicated test case that breaks a program, try to trim it and make it as small as possible.

This is useful for at least three reasons. One: Being seen to invest effort in simplifying the question makes it more likely you'll get an answer, Two: Simplifying the question makes it more likely you'll get a useful answer. Three: In the process of refining your bug report, you may develop a fix or workaround, yourself.
Don't claim you've found a bug

When you're having problems with a piece of software, don't claim you've found a bug, unless you're very, very sure of your ground. Hint: Unless you can provide a source-code patch fixing the problem, or a regression test against a previous version that demonstrates incorrect behaviour, you're probably not sure enough. This applies to Web pages and documentation, too; if you've found a documentation bug, you should supply replacement text and a note as to which pages it should go on.

Remember, many other users aren't experiencing your problem. Otherwise, you would have learned about it while reading the documentation and searching the Web. (You did do that before complaining, didn't you?) This means that very probably it's you who're doing something wrong, not the software.

The people who wrote the software work very hard to make it work as well as possible. If you claim you've found a bug, you'll be implying they did something wrong, and will almost always offend them — even if you're correct. It's especially undiplomatic to yell "bug" in the Subject line.

When asking your question, write as though you assume you're doing something wrong, even if you're privately pretty sure you've found an actual bug. If there really is a bug, you'll hear about it in the answer. Play it so the maintainers will want to apologise to you if the bug is real, rather than so you'll owe them an apology if you've messed up.
Grovelling is no substitute for doing your homework

Some people who get that they shouldn't behave rudely or arrogantly, demanding an answer, retreat to the opposite extreme, of grovelling. ("I know I'm just a pathetic new user, but...".) This is distracting, and unhelpful. It's especially annoying when it's coupled with vagueness about the actual problem.

Don't waste your time, or ours, on crude primate politics. Instead, present the background facts and your question as clearly as you can. That is a better way to position yourself than by grovelling.

Sometimes, Web forums have separate places for new-user questions. If you feel you do have a new-user question, just go there. However, don't grovel there, either.
Describe the problem's symptoms, not your guesses

It's not useful to tell hackers what you think is causing your problem. (If your diagnostic theories were such hot stuff, would you be consulting others for help?) So, make sure you're telling them the raw symptoms of what goes wrong, rather than your interpretations and theories. Let them do the interpretation and diagnosis.

Stupid:

I'm getting back-to-back SIG11 errors on kernel compiles, and suspect a hairline crack on one of the motherboard traces. What's the best way to check for those?
Smart:

My home-built K6/233 on an FIC-PA2007 motherboard (VIA Apollo VP2 chipset) with 256MB Corsair PC133 SDRAM starts getting frequent SIG11 errors about 20 minutes after power-on during kernel compiles, but never in the first 20 minutes. Rebooting doesn't restart the clock; powering down overnight does. Swapping out all RAM didn't help. The relevant part of a typical compile session log follows.

Since the preceding point seems to be a tough one for many people to grasp, here's a phrase to remind you: "All diagnosticians are from Missouri." That US state's official motto is "Show me" (earned in 1899, when Congressman Willard D. Vandiver said "I come from a country that raises corn and cotton and cockleburs and Democrats, and frothy eloquence neither convinces nor satisfies me. I'm from Missouri. You've got to show me.") In diagnosticians' case, it's not a matter of skepticism, but rather a literal, functional need to see whatever is as close as possible to the same raw evidence that you see, rather than your surmises and summaries. Show us.
Describe your problem's symptoms in chronological order

The clues most useful in figuring out something that went wrong often lie in the events immediately prior. So, your account should describe precisely what you did, and what the machine did, leading up to the blowup. In the case of command-line processes, having a session log (e.g., using the script utility) and quoting the relevant twenty or so lines is very useful.

If the program that blew up on you has diagnostic options (such as -v for verbose), check for options useful in adding debugging information to the transcript.

If your account ends up being long (more than about four paragraphs), it might be useful to succinctly state the problem up top, and then follow with the chronological tale. That way, hackers will know what to watch for, in reading your account.
Describe the goal, not the step

If you're trying to find out how to do something (as opposed to reporting a bug), begin by describing the goal. Only then, describe the particular step towards it, on which you're blocked.

Often, people seeking technical help have a high-level goal in mind, and get stuck on what they think is one particular path towards the goal. They come for help with the step, but don't realise the path is wrong. It can take substantial effort to get past this.

Stupid:

How do I get the color-picker on the FooDraw program to take a hexadecimal RGB value?
Smart:

I'm trying to replace the color table on an image with values of my choosing. Right now, the only way I can see to do this is by editing each table slot, but I can't get FooDraw's color picker to take a hexadecimal RGB value.

The second version if the question is smart. It allows answers suggesting tools better suited to the task.
Don't ask people to reply by private e-mail

Hackers believe solving problems should be a public, transparent process, during which the first try at an answer can and should be corrected, if someone more knowledgeable notices incomplete or incorrect data. Also, helpers get some of their reward for being respondents from being seen to be competent and knowledgeable by their peers.

When you ask for a private reply, you're disrupting both the process and the reward. Don't do this. It's the respondent's choice whether to reply privately — and, if he or she does, it's usually because he/she thinks the question is too ill-formed or obvious to be interesting to others.

There is one limited exception to this rule. If you think the question may attract a number of similar answers, then the magic words are "e-mail me and I'll summarise answers for the group". It is courteous to try and save the mailing list or newsgroup a flood of substantially identical postings — but you must keep the promise to summarise.
Be explicit about your question

Open-ended questions tend to be perceived as open-ended time sinks. Those people most likely to be able to give useful answers are also the busiest (if only because they take on the most work themselves). People like that are allergic to open-ended time sinks; thus, they tend to be allergic to open-ended questions.

You're more likely to get a useful response if you're explicit about what you want respondents to do (provide pointers, send code, check your patch, whatever). This will focus their effort, and implicitly put an upper bound on the time and energy a respondent must allocate for helping you. This is good.

To understand the world experts live in, think of expertise as an abundant resource, and time to respond as a scarce one. The less time commitment you implicitly request, the more likely you are to get an answer from someone really good and really busy.

So, it's useful to frame your question to minimise the time commitment required for an expert to field it — but this is often not the same thing as simplifying the question. Thus, for example, "Would you give me a pointer to a good explanation of X?" is usually a smarter question than "Would you explain X, please?". If you have some malfunctioning code, it's usually smarter to ask what's wrong with it than to request someone to fix it.
Don't post homework questions

Hackers are good at spotting homework questions; most of us have done them ourselves. Those questions are for you to work out, so you'll learn from the experience. It is OK to ask for hints, but not for entire solutions.

If you suspect you've been passed a homework question, but can't solve it anyway, try asking in a user group forum or (as a last resort) in a "user" list/forum of a project. While the hackers will spot it, some of the advanced users may at least give you a hint.
Prune pointless queries

Resist the temptation to close your request for help with semantically-null questions like "Can anyone help me?" or "Is there an answer?" First: If you've written your problem description halfway competently, such tacked-on questions are at best superfluous. Second: Because they are superfluous, hackers find them annoying — and are likely to return logically impeccable but dismissive answers like "Yes, you can be helped" and "No, there is no help for you."

In general, asking yes-or-no questions is a good thing to avoid unless you want a yes-or-no answer.
Don't flag your question as "Urgent", even if it is for you

That's your problem, not ours. Claiming urgency is very likely to be counter-productive: Most hackers will simply delete such messages as rude and selfish attempts to elicit immediate and special attention.

There is one semi-exception: It can be worth mentioning if you're using the program in some high-profile place, one hackers will get excited about; in such a case, if you're under time pressure, and you say so politely, people may get interested enough to answer faster.

This is a very risky thing to do, however, because the hackers' metric for what is exciting probably differ from yours. Posting from the International Space Station would qualify, for example, but posting on behalf of a feel-good charitable or political cause would almost certainly not. In fact, posting "Urgent: Help me save the fuzzy baby seals!" will reliably get you shunned or flamed, even by hackers who think fuzzy baby seals are important.

If you find this mysterious, re-read the rest of this HOWTO repeatedly, until you understand it, before posting anything at all.
Courtesy never hurts, and sometimes helps

Be courteous: Use "Please" and "Thanks for your attention" or "Thanks for your consideration". Make it clear you appreciate time spent helping you for free.

To be honest, this isn't as important as (and cannot substitute for) being grammatical, clear, precise, and descriptive, avoiding proprietary formats, etc.; hackers in general would rather get somewhat brusque but technically sharp bug reports than polite vagueness. (If this puzzles you, remember that we value a question by what it teaches us.)

However, if you have your technical ducks in a row, politeness does increase your chances of getting a useful answer.

(We must note that the only serious objection we've received from veteran hackers to this HOWTO concerns our previous recommendation to use "Thanks in advance". Some hackers feel this connotes an intention not to thank anybody afterwards. Our recommendation is to either say "Thanks in advance" first and thank respondents afterwards, or express courtesy in a different way, such as by saying "Thanks for your attention" or "Thanks for your consideration".)
Follow up with a brief note on the solution

Send a note after the problem has been solved, to all who helped you: Let them know how it came out, and thank them again for their help. If the problem attracted general interest in a mailing list or newsgroup, it's appropriate to post the followup there.

Optimally, the reply should be within the thread started by the original question post, and should have 'FIXED', 'RESOLVED', or an equally obvious tag in the subject line. On mailing lists with fast turnaround, a potential respondent who sees a thread about "Problem X" ending with "Problem X - FIXED" knows not to waste time even reading the thread (unless he/she personally finds Problem X interesting), and therefore can use that time solving a different problem.

Your followup needn't be long and involved; a simple "Howdy — it was a failed network cable! Thanks, everyone. - Bill" would be better than nothing. In fact, a short and sweet summary is better than a long dissertation, unless the solution has real technical depth. Say what action solved the problem, but you need not replay the whole troubleshooting sequence.

For problems with some depth, it's appropriate to post a summary of the troubleshooting history. Describe your final problem statement. Describe what worked as a solution, and indicate avoidable blind alleys. Name the names of people who helped you; you'll make friends that way.

Besides being courteous and informative, this sort of followup will help others searching the mailing-list / newsgroup / forum archives to know exactly which solution helped you, and thus may also help them.

Last, and not least, this sort of followup helps everybody who assisted feel a satisfying sense of closure, about the problem. If you aren't a techie or hacker, yourself, trust us: This feeling is very important to the gurus and experts you tapped for help. Problem narratives trailing off into unresolved nothingness are frustrating things; hackers itch to see them resolved. The goodwill scratching that itch earns you will be very, very helpful to you, next time you need to pose a question.

Consider how you might be able to prevent others from having the same problem in the future. Ask yourself if a documentation or FAQ patch would help. If the answer is yes, send your patch to the maintainer.

Among hackers, this sort of behaviour is actually more important than conventional politeness. It's how you get a reputation for playing well with others, which can be a very valuable asset.
How To Interpret Answers
RTFM and STFW: How To Tell You've Seriously Screwed Up

There is an ancient and hallowed tradition: If you get a reply reading "RTFM", the person who sent it thinks you should have Read the Fucking Manual. He/she is almost certainly right. Go read it.

RTFM has a younger relative. If you get a reply that reads "STFW", the person who sent it thinks you should have Searched the Fucking Web. He/she is almost certainly right. Go search it. (The milder version of this is when you're told Google is your friend!)

In Web forums, you may also be advised to search the forum archives. In fact, someone may even be so kind as to provide a pointer to the previous thread, where this problem was solved. However, don't rely on this consideration; do your archive-searching before asking.

Often, the person sending either of these replies has the manual or the Web page with the information you need open, and is looking at it, as he or she types. These replies mean your respondent thinks (a) the information you need is easy to find, and (b) you will learn more if you seek out the information than if it's spoon-fed to you.

You shouldn't be offended by this; by hacker standards, he or she's showing you a rough kind of respect simply by not ignoring you. You should instead thank that person for grandmotherly kindness.
If you don't understand...

If you don't understand the answer, don't immediately bounce back a demand for clarification. Use the same tools you focussed on your original question (manuals, FAQs, the Web, skilled friends), to understand the answer. Then, if you still need to ask for clarification, exhibit what you've learned.

For example, suppose I tell you: "It sounds like you've a stuck zentry; you'll need to clear it." Then: Here's a bad followup question: "What's a zentry?" Here's a good followup question: "OK, I read the man page; zentries are only mentioned under the -z and -p switches. Neither of them says anything about clearing zentries. Is it one of these, or am I missing something here?"
Dealing with rudeness

Much of what looks like rudeness in hacker circles is not intended to give offence. Rather, it's the product of the direct, cut-through-the-bullshit communications style natural to people who're more concerned about solving problems than about making others feel warm and fuzzy.

When you perceive rudeness, try to react calmly. If someone really is acting out, very likely, a senior person on the list or newsgroup or forum will call him or her on it. If that doesn't happen, and you lose your temper, very likely the person you lose it against was behaving within hacker community norms, and you'll be considered at fault. This will hurt your chances of getting the information or help you want.

On the other hand, you'll occasionally run across quite gratuitous rudeness and posturing. The flip-side of the above is that it's acceptable form to slam real offenders quite hard, dissecting their misbehaviour with a sharp verbal scalpel. Be very, very sure of your ground, before you try this, however. The line between correcting an incivility and starting a pointless flamewar is thin enough that hackers themselves not infrequently blunder across it; if you're a new user or outsider, your chances of avoiding such a blunder are low. If you're after information rather than entertainment, it's better to keep your fingers off the keyboard than risk this.

(Some people assert that many hackers have a mild form of autism or Asperger's Syndrome, and are actually missing some of the brain circuitry lubricating 'normal' human social interaction. This may or may not be true. If you're not a hacker, yourself, it may help you cope with our eccentricities if you think of us as brain-damaged. Go right ahead. We won't care; we like being whatever we are, and generally have a healthy skepticism about clinical labels.)

In the next section, we'll talk about a different issue; the kind of "rudeness" you'll see when you misbehave.
On Not Reacting Like a Loser

Odds are you'll screw up a few times, on hacker community forums — in ways detailed in this article, or similar. And you'll be told exactly how you screwed up, possibly with colourful asides. In public.

When this happens, the worst thing you can do is whine about the experience, claim to have been verbally assaulted, demand apologies, scream, hold your breath, threaten lawsuits, complain to people's employers, leave the toilet seat up, etc. Instead, here's what you do:

Get over it. It's normal. In fact, it's healthy and appropriate.

Community standards do not maintain themselves: They're maintained by people actively applying them, visibly, in public. Don't whine that all criticism should have been conveyed via private e-mail: That's not how it works. Nor is it useful to insist you've been personally insulted when someone comments that one of your claims was wrong, or that his/her views differ. Those are loser attitudes.

There have been hacker forums where, out of some misguided sense of hyper-courtesy, participants are banned from posting any fault-finding with another's posts, and told "Don't say anything if you're unwilling to help the user." The resulting departure of clueful participants to elsewhere causes them to descend into meaningless babble, and become useless as technical forums.

Exaggeratedly "friendly" (in that fashion) or useful: Pick one.

Remember: When that hacker tells you you've screwed up, and (no matter how gruffly) tells you not to do it again, he/she's acting out of concern for (1) you and (2) his/her community. It would be much easier for him/her to ignore you and filter you out of his/her life. If you can't manage to be grateful, at least have a little dignity; don't whine, and don't expect to be treated like a fragile doll just because you're a newcomer with a theatrically hypersensitive soul and delusions of entitlement.
Questions Not to Ask

Here are some classic stupid questions, and what hackers are thinking when they don't answer them.

Q: Where can I find program or resource X?
Q: How can I use X to do Y?
Q: How can I configure my shell prompt?
Q: Can I convert an AcmeCorp document into a TeX file using the Bass-o-matic file converter?
Q: My {program, configuration, SQL statement} doesn't work
Q: I'm having problems with my Windows machine. Can you help?
Q: My program doesn't work. I think system facility X is broken.
Q: I'm having problems installing Linux or X. Can you help?
Q: How can I crack root/steal channel-ops privileges/read someone's e-mail?

Q:

Where can I find program or resource X?
A:

The same place I'd find it, fool — at the other end of a Web search. Ghod, doesn't everybody know how to use Google, yet?
Q:

How can I use X to do Y?
A:

If what you want is to do Y, you should ask that question without pre-supposing use of a method that may not be appropriate. Questions of this form often indicate a person not merely ignorant about X, but also confused about what problem Y they're solving and too fixated on the details of their particular situation. It is generally best to ignore such people, until they define their problems better.
Q:

How can I configure my shell prompt?
A:

If you're smart enough to ask this question, you're smart enough to RTFM and find out yourself.
Q:

Can I convert an AcmeCorp document into a TeX file using the Bass-o-matic file converter?
A:

Try it and see. If you did that, you'd (a) learn the answer, and (b) stop wasting my time.
Q:

My {program, configuration, SQL statement} doesn't work
A:

This isn't a question, and I'm not interested in playing Twenty Questions to pry your actual question out of you — I have better things to do. On seeing something like this, my reaction is normally of one of the following:

*

do you have anything else to add to that?
*

oh, too bad; I hope you get it fixed.
*

and this has exactly what to do with me?

Q:

I'm having problems with my Windows machine. Can you help?
A:

Yes. Throw out that Microsoft trash and install an open-source operating system like Linux or BSD.

Note: you can ask questions related to Windows machines if they are about a program that does have an official Windows build, or interacts with Windows machines (i.e., Samba). Just don't be surprised by the reply that the problem is with Windows and not the program, because Windows is so broken in general that this is very often the case.
Q:

My program doesn't work. I think system facility X is broken.
A:

While it's possible you're the first person to notice an obvious deficiency in system calls and libraries heavily used by hundreds or thousands of people, it's rather more likely you're utterly clueless. Extraordinary claims require extraordinary evidence; when you make a claim like this one, you must back it up with clear and exhaustive documentation of the failure case.
Q:

I'm having problems installing Linux or X. Can you help?
A:

No. I'd need hands-on access to your machine to troubleshoot this. Go ask your local Linux user group for hands-on help. (You can find lists of user groups inside the Linux User Group HOWTO.)

Note: questions about installing Linux may be appropriate if you're on a forum or mailing list about a particular Linux distribution, and the problem is with that distribution; or on local user groups' forums. In this case, be sure to describe the exact details of the failure. However, do careful searching first, with "linux" and all suspicious pieces of hardware.
Q:

How can I crack root / steal channel-ops privileges / read someone's e-mail?
A:

You're a low-life for wanting to do such things, and a moron for asking a hacker to help you.
Good and Bad Questions

Finally, I'm going to illustrate how to ask questions in a smart way by example; pairs of questions about the same problem, one asked in a stupid way and one in a smart way.

Stupid: Where can I find out stuff about the Foonly Flurbamatic?

This question just begs for "STFW" as a reply.
Smart: I used Google to try to find "Foonly Flurbamatic 2600" on the Web, but I got no useful hits. Does anyone know where I can find programming information on this device?

This one has already STFWed, and sounds like he might have a real problem.

Stupid: I can't get the code from project foo to compile. Why is it broken?

The querent assumes somebody else screwed up. Arrogant git....
Smart: The code from project foo doesn't compile under Nulix version 6.2. I've read the FAQ, but it doesn't have anything in it about Nulix-related problems. Here's a transcript of my compilation attempt; is it something I did?

He or she's specified the environment, has read the FAQ, has shown the error, and isn't assuming his/her problems are someone else's fault. This one might be worth some attention.

Stupid: I'm having problems with my motherboard. Can anybody help?

J. Random Hacker's response to this is likely to be "Right. Do you need burping and diapering, too?" followed by a punch of the delete key.
Smart: I tried X, Y, and Z on the S2464 motherboard. When that didn't work, I tried A, B, and C. Note the curious symptom when I tried C. Obviously the florbish is grommicking, but the results aren't what one might expect. What are the usual causes of grommicking on Athlon MP motherboards? Anybody got ideas for more tests I can run, to pin down the problem?

This person, on the other hand, seems worthy of an answer. He/she has exhibited problem-solving intelligence, rather than passively waiting for an answer to drop from on high.

In the last question, notice the subtle but important difference between demanding "Give me an answer" and "Please help me figure out what additional diagnostics I can run, to achieve enlightenment."

In fact, the form of that last question is closely based on a real incident in August 2001 on the Linux-kernel mailing list (lkml). I (Eric) was the one asking the question that time. I was seeing mysterious lockups on a Tyan S2462 motherboard. The list members supplied the critical information I needed to solve them.

By asking the question in the way I did, I gave people something to chew on; I made it easy and attractive for them to get involved. I demonstrated respect for my peers' ability, and invited them to consult with me as a peer. I also demonstrated respect for the value of their time, by telling them the blind alleys I'd already run down.

Afterwards, when I thanked everyone, and remarked how well the process had worked, an lkml member observed that he thought it had worked not because I'm a "name" on that list, but because I asked the question in the proper form.

Hackers are in some ways a very ruthless meritocracy; I'm certain he was right, and that if I had behaved like a sponge I would have been flamed or ignored, no matter who I was. His suggestion of writing up the whole incident as instruction to others led directly to composition of this guide.
If You Can't Get an Answer

If you can't get an answer, please don't take personally that we don't feel we can help you. Sometimes, the members of the asked group may simply not know the answer. No response is not the same as being ignored, though admittedly it's hard to spot the difference from outside.

In general, simply re-posting your question is a bad idea. This will be seen as pointlessly annoying. Have patience: The person with your answer may currently be asleep, in a different time-zone.

There are other sources of help you can go to, often sources better adapted to a novice's needs.

There are many on-line and local user groups who are enthusiasts about the software, even though they may never have written any software themselves. These groups often form so people can help each other, and help new users.

There are also plenty of commercial companies you can contract with for help, both large and small. (Red Hat and SpikeSource are two of the best known; there are many others.) Don't be dismayed at having to pay for a bit of help! After all, if your car engine blows a head gasket, chances are you would take it to a repair shop, and pay to get it fixed. Even if the software didn't cost you anything, you can't expect support to always come for free.

For popular software like Linux, there are at least 10,000 users per developer. It's just not possible for one person to handle the support calls from over 10,000 users. Remember, even if you must pay for support, you're still paying much less than if you'd needed to buy the software as well (and support for closed-source software is usually more expensive and less competent than support for open-source software).
How To Answer Questions in a Helpful Way

Be gentle. Problem-related stress can make people seem rude or stupid, even when they're not.

Reply to a first offender off-line. There is no need of public humiliation for someone who may have made an honest mistake. A real new user may not know how to search archives, or where the FAQ is stored or posted.

If you don't know for sure, say so! A wrong but authoritative-sounding answer is worse than none at all. Don't point anyone down a wrong path simply because it's fun to sound like an expert. Be humble and honest; set a good example for both the querent and your peers.

If you can't help, don't hinder. Don't make jokes about procedures that could trash the user's setup — the poor sap might interpret these as instructions.

Ask probing questions to elicit more details. If you're good at this, the querent will learn something — and so might you. Try to turn the bad question into a good one; remember, we were all new users once.

While just muttering RTFM is sometimes justified, when replying to someone who is just a lazy slob, a pointer to documentation (even just a suggestion to google for a key phrase) is better.

If you're going to answer the question at all, give good value. Don't suggest kludgey workarounds, when somebody is using the wrong tool or approach. Suggest good tools. Re-frame the question.

Help your community learn from the question. When you field a good question, ask yourself "How would the relevant documentation or FAQ have to change, so nobody has to answer this again?" Then, send a patch to the document maintainer.

If you did research to answer the question, demonstrate your skills rather than writing as though you pulled the answer out of your butt. Answering one good question is like feeding a hungry person one meal, but teaching that person research skills by example is teaching him/her to grow food for a lifetime.
Related Resources

If you need instruction in the basics of how personal computers, Unix, and the Internet work, see The Unix and Internet Fundamentals HOWTO.

When you release software or write patches for software, try to follow the guidelines in the Software Release Practice HOWTO.
Special Note for FAQ List Maintainers and Webmasters

Many Web sites, newsgroups, and other on-line forums link to this HOWTO, as a guide for new users. The authors are glad for you to do so. However, please add next to the link in bold type a note about our not being your project's help desk: We get far too many queries from users who assume otherwise.
Acknowledgements

Evelyn Mitchell contributed some stupid questions, and inspired the "How To Give A Good Answer" section.
Revision History
Revision 3.2         10 January 2006         esr & rm
Incorporated Web-forum material from upstream master copy. Restored original link for G.E. Boyd's "How to turn off HTML mail in all common mail clients" article, as Boyd's site has reappeared. Clarified in introductory remarks this local working copy's relation to the master copy at catb.org. Added my e-mail address to Eric's, as a place one may wish to send submissions. Did further work on tightening prose, and fixing small punctuation / usage / grammar markup bugs. Added links to several new translated versions. Removed link to www.linux.org's list of Linux user groups, substituting the much more extensive set of such lists in the Linux User Group HOWTO. Provided links for Google Groups and for "better e-mail program". Replaced Linuxcare with SpikeSource as a Linux service company example. Bowed to the logic of D. Hofstadter's "Person Paper on Purity in Language" concerning the English language's third-person singular. Added "Show me" passage.
Revision 3.1         25 Aug 2004         rm
Changed link for G.E. Boyd's "How to turn off HTML mail in all common mail clients" article, to use a mirror copy since the upstream site has disappeared.
Revision 3.0         16 Dec 2003         rm
Lacking XML copy, corrected XHTML, adding CSS support. Fixed spelling, grammar, punctuation; tightened up phrasing. Corrected copyright notice to (correctly) assert joint copyright, citing both authors' names as owners of the document title rather than just Eric. (Note: This should not be confused with authorship credit, which has correctly shown joint authorship of our project since early in this essay's history.) In response to popular request, moved revision history to the end. Edited out the cloying and condescending pseudo-word "newbie".
Revision 2.9         8 Aug 2003         esr
Minor corrections.
Revision 2.8         21 July 2003         esr
On the value of not grovelling. Describe the task, not the step.
Revision 2.7         15 July 2003         esr
On the value of not grovelling. Describe the task, not the step.
Revision 2.6         29 January 2003         esr
Found a way to bash the stylesheets into putting the version history at the back.
Revision 2.5         21 January 2003         esr
New section on not claiming you've found a bug.
Revision 2.4         17 October 2002         esr
Good form for problem resolution replies.
Revision 2.3         25 September 2002         esr
German translation link added.
Revision 2.2         22 September 2002         esr
More on `Thanks in advance'.
Revision 2.1         27 August 2002         esr
More on how to choose fora appropriately. Revisions to intro.
Revision 2.0         4 August 2002         esr
First XML version. Suggestions from Evelyn Mitchell's presentation. Also took off from her material to write "How To Give Good Answers". Added "Make it easy to reply".
Revision 1.19         20 July 2002         esr
Added the Bass-O-Matic question example and more troubleshooting steps.
Revision 1.18         11 July 2002         esr
Change the subject on request e-mail.
Revision 1.17         21 April 2002         esr
Still more about choosing an appropriate forum.
Revision 1.16         15 March 2002         esr
More about choosing an appropriate forum.
Revision 1.15         11 March 2002         esr
Don't flag your question "Urgent". Don't line-wrap data.
Revision 1.14         4 February 2002         esr
Added links to related resources.
Revision 1.13         1 February 2002         esr
Two new translations. Typo fixes.
Revision 1.12         1 January 2002         esr
Recommend object-deviation format for bug reports. How to verify your e-mail format not being bogus.
Revision 1.11         17 October 2001         esr
More about project mailing lists.
Revision 1.10         5 October 2001         esr
Using project mailing lists.
Revision 1.9         2 October 2001         esr
MIME attachments are OK. How to turn off HTML. Homework questions.
Revision 1.8         28 September 2001         esr
On being specific about your question.
Revision 1.7         21 September 2001         esr
A few tips on e-mail etiquette. Noted objections to "Thanks in advance."
Revision 1.6         14 September 2001         esr
More on how to deal with not getting an answer.
Revision 1.5         13 September 2001         esr
Added "Volume Is Not Precision" and "Dealing with Rudeness".
Revision 1.4         11 September 2001         esr
Minor editorial changes.
Revision 1.3         10 September 2001         esr
Added comments on what to do if you don't like the hacker attitude. Added another archetypal stupid question.
Revision 1.2         9 September 2001         esr
Contributions by Richard Gooch.
Revision 1.1         9 September 2001         esr
Contributions by William Stearns.
Revision 1.0         6 September 2001         esr & rm
Initial version.

原文地址：
http://linuxmafia.com/faq/Essays/smart-questions.html

现在google 支持 mercurial。

mercurial的情况大有改观，它有了一个类似于tortoisesvn的gui工具tortoisehg，这个大大降低了使用的门槛，方便了在windows下工作的用户。

有了tortoisehg这个工具，你会发现，mercurial会比svn更好用。

一些mercurial的资料：

官方网站：http://www.selenic.com/mercurial/

中文使用教程：http://www.selenic.com/mercurial/wiki/index.cgi/ChineseTutorial

chenyufei的使用经验谈：http://my.donews.com/chenyufei/2007/06/24/post-070624-094733-899/

最后，gui图形界面客户端软件tortoisehg下载地址：

http://bitbucket.org/tortoisehg/stable/downloads/

下面简单介绍其用法

1、进入http://www.selenic.com/mercurial/wiki/　选择安装TortoiseHg，这是个用户界面化的Mercurial。

2、安装完成后单击右键会发现多个TortoiseHg的菜单，里面有相关相关操作。另外进入命令行窗口键入hg命令会有相关的提示。

3、假定我们已经有了个Mercurial工作区http://selenic.com/hg/hgweb.cgi, 我们要check out这 个工作区到本地。那么我们可以

Ａ、界面化操作： 右键->TortoiseHg->Clone a Respository ,　“Source Path”里是"http://selenic.com/hg/hgweb.cgi","Destination Path"里是本地文件夹,然后点击"clone"就成了

B、命令窗口: 假设本地文件夹为"localFiles",则执行“hg clonehttp://fxsqe.sfbay.sun.com:7080/hg/hgweb.cgilocalFiles”。

4、版本控制需要确定是谁上传了某一版本，因此我们需要对用户名进行配置，设定好我们的名字。在命令窗口中进入复制出来的工作区，然后执行hg config username命令，在弹出的对话框中写入用户信息，最好遵守规范“用户名<用户邮件>”来填写。

5、工作区更新后，如果想要把更改的结果提交上去则：

A、右键点击对应文件，选择TortoiseHg->synchronize,然后可以在窗口中进行更新(pull),上传(push)和解决冲突项等.

代理设置

Solaris 新建~/.hgrc

[http_proxy]
host=10.8.1.80:8083

[ui]
username= Jacky Chu<ning-zhi.chu@sun.com>

[truested]
users=*
groups=green, staff

CodeBeamer+Mercurial实务操作手册 

1. CodeBeamer/Mercurial整合介绍

版本控制软件(VCS)的Repository(档案库), 在以往都是集中在Server端管理, 这方面的OpenSource代表软件有CVS和SubVersion, 但随着软件版本的变更快速,集中式的Repository其branch管理不易, 在OpenSource的社群, 分布式的版本控制软件(DVCS)逐渐广为opensource项目所使用. 而目前在opensource最热门的分布式版本控制软件则当属Mercurial与Git , 这两个分布式软件各有其支持者, 例如著名的FireFox浏览器, 其项目采用Mercurial, Linux Kernel则采用Git.

分布式版本控制软件, 理论上是可以不用一台专职的Server来执行分布式版本控制软件, 因为每个使用者端就是一台完整的VCS Server, 当要与项目成员的code做整合的时候, 再利用push变更的code与其它团队成员的repository. 所以source code的变更是不用透过集中式的Server来做merge的. 

由于DVCS的特性, 每一个团队成员都是一台独立的VCS Server, 但是软件还是有所谓的Baseline或是Release tag, 为了解决这个问题, 还是要有一台VCS来统合团队成员的所有source code版本变更. CodeBeamer整合了Mercurial即可以扮演这个角色. CodeBeamer+Mercurial的整合有以下好处

• 利用CodeBeamer的Managed Mercurial Repository来管理稳定的source code版本.虽然团队成员有各自修改的branch, 但最终还是要push到CodeBeamer的Managed Repository
• CodeBeamer的Managed Repository方便建立与维护, 例如
• Repository可透过CodeBeamer Web接口来建立
• 使用者账号管理
• E-Mail通知管理
• Source code change set与Issue的整合
• Baseline/Release tag与source code的关联容易.

2. Mercurial在Server端的安装与Apache设定

CodeBeamer从5.3版后才开始支持Managed Mercurial Repository/Mercurial external repository

• Windows平台安装
• Linux平台安装

3. 使用者端软件安装

• 使用者端OS为Windows
• 使用者端OS为Mac
• 使用者端OS为Linux
• 与软件开发工具IDE的整

4. CodeBeamer/Mercurial操作流程
4.1 建立CodeBeamer项目

•    新增项目

•    输入项目名称与项目信息 

选择Finish就可以完成项目建立, 在输入项目信息的接口, 可以看到Source Code, 选择Source Code就可以顺便设定这个项目的SCM设定, 但是本例是先建立项目, 再设定SCM 
4.2 设定项目的SCM的连结

•    到Admin中选SCM, 然后选Mercurial 

•    选择Creat New Managed Repository 

•    输入Repository名称 

•    选择Finish后, CodeBeamer会开始建立与初始化Repository 

•    CodeBeamer建立好Repository后, 会发E-Mail通知 

4.3 将使用者/开发者端新建一个Mercurial Repository

以下Mercurial的操作是使用TortoiseHg为范例
•    到Golbal Settings设定Commit使用者名称 

•    输入Username , 也就是你的codebeamer账号名称 

•    在一个新增的目录建立一个Repository 

•    选择Create 

•    Repository建立完成 

•    Repository建立好后, 在目录中会看到.hg目录与.hgignore档案 

4.4 将Source Code项目新增到建立好的Mercurial Repository

•    将source code放到刚新增Repository的目录 

•    点选source code的目录再用鼠标右键点选HG commit 

•    跟CVS/Subversion操作一样, 新增的目录或是档案要commit到Repository前要先执行Add, 点选要新增的档案后按Add 

•    执行Commit, 并输入commit的信息 

4.5 将使用者/开发者端的Repository push到CodeBeamer的Managed Mercurial Repository

要将使用者端的Repository Push到CodeBeamer的Managed Mercurial Repository前, 要确认使用者在CodeBeamer的项目角色有SCM commit权限
•    在Repository目录, 点选鼠标右键, 然后从TortoiseHg选单选Synchronize, 

•    输入CodeBeamer的Managed Mercurial Repository URL 例如http://ipaddress/hg/myfirsthg myfirsthg是透过CodeBeamer建立的Repository名称, 输入好后按PUSH 

•    输入CodeBeamer登入账号与密码

•    Push成功后, TortoiseHg的显示讯息 

•    到Codebeamer项目的Repository检视Push的log记录 

5. 将commit changeset 与CodeBeamer的Issue关连

假设在CodeBeamer项目中的Task Tracker, 使用者被项目经理指定要处理一个工作, 这个工作需要修改Repository中的档案, 为了让项目经理审核负责这件工程师的产出, CodeBeamer支持了SCMLoop的功能, 让使用者在push changeset时可以将changeset与Task/Issue关连起来. 以下是操作说明
•    假设使用者jeffery被指派了一份工作 

•    jeffery修改了他计算机中的档案 

•    jeffery先将修改后的档案commit到自己的repository, 并在commit讯息中加上工作的代号(ID) 

•    jeffery修改好了, 于是将自己的repository push到CodeBeamer Server中的Managed Mercurial Repository 

•    Push成功后, 关连也产生了 

一、下载地址：
http://wordpress.org/extend/plugins/wp-syntax/

二、支持语言：
abap, actionscript, actionscript3, ada, apache, applescript, aptsources, asm, asp, autoit, bash, blitzbasic, bnf, boo, c, cmac, caddcl, cadlisp, cil, cfdg, cfm, cobol, cpp-qt, cpp, csharp, css, d, delphi, diff, div, dos, dot, eiffel, fortran, freebasic, genero, gettext, glsl, gml, bnuplot, groovy, haskell, html4strict, idl, ini, inno, io, java, java5,javascript, kixtart, klonec, klonecpp, latex, lisp, lotusformulas, lotusscript, lua, m68k, matlab, mirc, mpasm, mxml, mysql, nsis, objc, ocaml-brief, ocaml, oobas, oracle8, pascal, per, pic16, perl, php-brief, php, plsql, povray, powershell, progress, python, qbasic, rails, reg, robots, ruby, sas, scala, scheme, sdlbasic, smalltalk, smarty, sql, tcl, text, thinbasic, tsql, typoscript, vb, vbnet, verilog, vhdl, visualfoxpro, winbatch, xml, xorg_conf, xpp, z80

三、使用方法

代码

其中：LANGUAGE为具体语言的代码，line=1表示显示行号

四、扩展用法
给WordPress编辑器添加一快捷按钮方法：
修改\wp-includes\js\quicktags.js，请点击这里查看

Ubuntu 之所以好用，就是因为它继承了 debian 的 apt 系统，这一点相信您在昨天装系统的教程中已经感受到了。但是 apt 需要依赖网络，昨天我们装好的系统是暂时上不了网的，我们需要先设置一下。

首先，激活服务器的网卡，命令如下：

sudo nano /etc/network/interfaces

在 interfaces 中添加以下内容：

auto eth0
iface eth0 inet static
address 202.113.235.181
netmask 255.255.255.0
gateway 202.113.235.1

这其中，斜体部分标注的 IP 地址是我服务器的设置，您需要根据您的具体情况修改。当然，如果您的服务器使用的是 DHCP 来分配 IP 地址，只需要写上 iface eth0 inet dhcp 就可以了，无需设置 address/netmask/gateway。

然后，修改 resolv.conf 配置 DNS 服务器：

sudo nano /etc/resolv.conf

添加您的 DNS 服务器地址：

nameserver 202.113.16.10
nameserver 202.113.16.11

完成后，重新启动 networking 服务：

sudo /etc/init.d/networking restart

这样应该就可以连通网络了。如果您使用的是 ADSL，可能还需要装上 pppoe 之类的东西，考虑到服务器很少用这样的配置，这里就不讨论了，需要的话可以在网上查找。

安装和设置 OpenSSH Server

Ubuntu 下安装 OpenSSH Server 是无比轻松的一件事情，需要的命令只有一条：

sudo apt-get install openssh-server

随后，Ubuntu 会自动下载并安装 openssh server，并一并解决所有的依赖关系。当您完成这一操作后，您可以找另一台计算机，然后使用一个 SSH 客户端软件（强烈推荐 PuTTy），输入您服务器的 IP 地址。如果一切正常的话，等一会儿就可以连接上了。并且使用现有的用户名和密码应该就可以登录了。

事实上如果没什么特别需求，到这里 OpenSSH Server 就算安装好了。但是进一步设置一下，可以让 OpenSSH 登录时间更短，并且更加安全。这一切都是通过修改 openssh 的配置文件 sshd_config 实现的。

首先，您刚才实验远程登录的时候可能会发现，在输入完用户名后需要等很长一段时间才会提示输入密码。其实这是由于 sshd 需要反查客户端的 dns 信息导致的。我们可以通过禁用这个特性来大幅提高登录的速度。首先，打开 sshd_config 文件：

sudo nano /etc/ssh/sshd_config

找到 GSSAPI options 这一节，将下面两行注释掉：

#GSSAPIAuthentication yes
#GSSAPIDelegateCredentials no

然后重新启动 ssh 服务即可：

sudo /etc/init.d/ssh restart

再登录试试，应该非常快了吧

利用 PuTTy 通过证书认证登录服务器

SSH 服务中，所有的内容都是加密传输的，安全性基本有保证。但是如果能使用证书认证的话，安全性将会更上一层楼，而且经过一定的设置，还能实现证书认证自动登录的效果。

首先修改 sshd_config 文件，开启证书认证选项：

RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile %h/.ssh/authorized_keys

修改完成后重新启动 ssh 服务。

下一步我们需要为 SSH 用户建立私钥和公钥。首先要登录到需要建立密钥的账户下，这里注意退出 root 用户，需要的话用 su 命令切换到其它用户下。然后运行：

ssh-keygen

这里，我们将生成的 key 存放在默认目录下即可。建立的过程中会提示输入 passphrase，这相当于给证书加个密码，也是提高安全性的措施，这样即使证书不小心被人拷走也不怕了。当然如果这个留空的话，后面即可实现 PuTTy 通过证书认证的自动登录。

ssh-keygen 命令会生成两个密钥，首先我们需要将公钥改名留在服务器上：

cd ~/.ssh
mv id_rsa.pub authorized_keys

然后将私钥 id_rsa 从服务器上复制出来，并删除掉服务器上的 id_rsa 文件。

服务器上的设置就做完了，下面的步骤需要在客户端电脑上来做。首先，我们需要将 id_rsa 文件转化为 PuTTy 支持的格式。这里我们需要利用 PuTTyGEN 这个工具：

点击 PuTTyGen 界面中的 Load 按钮，选择 id_rsa 文件，输入 passphrase（如果有的话），然后再点击 Save PrivateKey 按钮，这样 PuTTy 接受的私钥就做好了。

打开 PuTTy，在 Session 中输入服务器的 IP 地址，在 Connection->SSH->Auth 下点击 Browse 按钮，选择刚才生成好的私钥。然后回到 Connection 选项，在 Auto-login username 中输入证书所属的用户名。回到 Session 选项卡，输入个名字点 Save 保存下这个 Session。点击底部的 Open 应该就可以通过证书认证登录到服务器了。如果有 passphrase 的话，登录过程中会要求输入 passphrase，否则将会直接登录到服务器上，非常的方便。