<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>马楠 &#124; Journey of Little Horse</title>
	<atom:link href="http://manan.org/feed/" rel="self" type="application/rss+xml" />
	<link>http://manan.org</link>
	<description>发出声音就是寻找自我的开始</description>
	<lastBuildDate>Sun, 13 May 2012 07:34:09 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.3.2</generator>
		<item>
		<title>并查集笔记</title>
		<link>http://manan.org/2012/05/union_find/</link>
		<comments>http://manan.org/2012/05/union_find/#comments</comments>
		<pubDate>Fri, 11 May 2012 16:27:09 +0000</pubDate>
		<dc:creator>Little Horse</dc:creator>
				<category><![CDATA[022.算法]]></category>
		<category><![CDATA[算法]]></category>

		<guid isPermaLink="false">http://manan.org/?p=954</guid>
		<description><![CDATA[<div>最近在读另一本经典的算法教材：<a href="http://book.douban.com/subject/10432347/">Algorithms(4th edition, Robert Sedgewick and Kevin Wayne）</a>，相比其他算法教材，这本书有几个特点：</div>
<div>1.图示非常丰富，阅读起来更有趣，更易懂；</div>
<div>2.给出了测试算法用的不同规模的数据和测试方法，以及展示算法结果所需要的工具。这些工具使得算法的测试、结果展示非常方便、直观。</div>
<div>3.介绍问题时更自然，相比算法导论定义、证明的方式，本书给出算法的应用场景，对需要解决的问题，不断改进算法得到最优结果，逐步改进的思路符合人们研究问题的正常过程，思维不跳跃，使学习过程有逻辑可循。</div>
<div>这本书有一个配套网站，<a href="http://algs4.cs.princeton.edu/home/">http://algs4.cs.princeton.edu/home/</a>，网站上除了提供书的部分内容，程序和数据下载外，还提供了课程的幻灯片和一些算法过程展示视频，效果非常赞。</div>
<div>下面是我对书中1.5节Case Study:Union-Find一节所做的笔记，可以部分反映出这本书的特点。</div>
<div></div>
<div></div>
</br>
<div><strong>问题引入：动态连通性(Dynamic connectivity)</strong></div>
<div>输入是一系列整数对，其中每个整数代表某种类型的对象，我们将整数对p q的含义解释为“p和q连通”。连通是一种等价关系，即满足：</div>
<div align="left">自反性：p和p连通；</div>
<div align="left">对称性：如果p和q连通，那么q和p连通；</div>
<div align="left">传递性：如果p和q连通，q和r连通，那么p和r连通。</div>
<div align="left">等价关系将所有对象分成等价类：如果两个对象连通，则它们属于同一个等价类。</div>
<div>我们的目标是：用程序过滤掉输入序列中不连通的数对。换句话说，当程序读入一对数p q时，只有当根据已经读取的所有数对不能说明p q连通时，才将p q数对输出，否则如果能判断出p q连通，则忽略p q数对，继续读下一对数。</div>
<div>用下图说明问题，图中有10个点，左侧数字为每次读入的连通数对。红色边为根据最新读入的数对产生的新边（即此时应输出这个数对），注意第二幅图当输入8 9时，由于8 9已经连接，因此不在8 9节点中增加新边（即不输出8 9数对）。连通完成后，图中左侧的三列点和右侧两列点分别为等价类。</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_14545330.png" alt="" />   <img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_14566094.png" alt="" /></div>
<div>上面描述的动态连通性问题在几个领域有许多应用，如在网络中：</div>
<div>    1.输入的整数代表网络中的计算机，数对代表网络中的连接。我们的程序用来判断为了让p和q通信，是建立一个新的直接连接，还是可以用已有的连接建立通信路径；</div>
<div>    2.整数代表电子电路中的连接点，数对代表连接各点的线路；</div>
<div>    3.整数代表社交网络中的人，数对代表好友关系。</div>
<div>在这些应用中我们可能需要处理数百万的对象和数十亿的连通关系。</div>
<div><strong>术语</strong></div>
<div>为了便于讨论，用网络术语定义问题。我们称上面的对象为点，称数对为连接，称等价类为连通组件，简称组件。简单起见，假设我们有N个点，每个点用整数命名，从0到N-1。</div>
<div>下图是一个规模大一些的连通性问题实例，从中可以看出连通性问题的困难之处。</div>
<div><img style="width: 425px; height: 333px;" src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_17914780.png" alt="" width="516" height="439" /></div>
<div>图中有625个点，很容易看出左下角的5个点是一个组件，但是并不容易判断任意两点的连通情况。对程序来说任务难度可能更大，因为程序只能处理点的名字和连接，并不能获得图标的几何结构。怎样才能快速判断给定的两个点是否连通呢？</div>
<div><strong>问题精确定义（API）</strong></div>
<div>为了解决问题，第一步工作是给出问题精确的定义。通常我们对一个算法的需求越多，用来实现它的时间和空间就越多，困难也越大。因此需要给出适当的定义。</div>
<div>为了定义问题，用一套API来封装所需要的基本操作：初始化；为两个点增加链接；标识包含一个点的组件；判断两个点是否属于同一组件；给组件计数。我们得到以下API：</div>
[code lang="java"]
//Union-find API
public class UF
UF(int N) //initialize N sites with integer names (0 to N-1)
void union(int p, int q) //add connection between p and q
int find(int p) //component identifier for p (0 to N-1)
boolean connected(int p, int q) //return true if p and q are in the same component
int count()// number of components
[/code]
<div>定义API使得实现一个解决动态连通性问题的算法简化成了实现上述API。</div>
<div>用数组id[]记录每个点所属的组件，一般用一个组件中的某个点作为组件的标识符。初始时，每个点为一个组件，所以对i从0到N-1将id[i]置为i。</div>
<div>并查集API的基本实现如下，算法维护两个实例变量：组件的数目和数组id[]。不同的算法区别在于find()和union()的实现。</div>
[code lang="java"]
public class UF{
    private int[] id;    //组件标识数组
    private int count;    //组件数量

    public UF(int N){
        id = new int[N];
        for(int i = 0; i &#60; N; i++)
            id[i] = i;
        count = N;
    }

    public void union(int p, int q){}
    public int find(int p){}

    public boolean connected(int p, int q){
        return find(p) == find(q);
    }

    public int count(){
        return count;
    }

    public static void main(String[] args){
        int N = StdIn.readInt();
        UF uf = new UF(N);
        while(!StdIn.isEmpty()){
            int p = StdIn.readInt();
            int q = StdIn.readInt();
            if(uf.connected(p, q)) continue;
            uf.union(p, q);
            Stdout.println(p + &#34; &#34; + q);
        }
    }
}
[/code]

<strong>测试方法</strong>
<div>UF类中提供了供测试用的main方法，它读取输入的整数对，如果数对没有连通，就将其连通并输出此数对。</div>
<div>提供了3个不同大小的测试数据集：tinyUF.txt包含10个点的11个连接，mediumUF.txt包含625个点的900个连接，largeUF.txt包含100万个点的200万个连接。数据的形式为：</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_42894268.jpg" alt="" /></div>
<div>每个数据第一行为总点数，剩下各行是各个连通的数对。</div>
<div><strong>算法分析方法</strong></div>
<div>为了分析算法，关注每个算法访问（读或写）数组元素的次数。</div>
<div><strong>算法实现</strong></div>
<div>下面给出三种算法实现，并逐渐提高性能。</div>
<div><strong>（一）Quick-find</strong></div>
<div>第一种方法维持的不变式是：当且仅当id[p]和id[q]相同时，p和q才是连通的。即同一个组件中的点有相同id[]值。这一方法称为quick-find，因为find(p)只返回id[p]，一次访问id[]即可完成。为了维持此不变式，操作union(p, q)时，首先检查p,q是否属于同一组件，如果不属于，则修改p、q组件中点的id[]，使所有id[]项相同。例如：</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_43690310.png" alt="" /></div>
<div>上图中，p=5,q=9，p和q原本属于不同组件，将它们连通时，将p所在组件的标识改为8，使得连个组件标识一致，成为同一组件。</div>
<div>算法实现</div>
[code lang="java"]
pubic int find(int p){
    return id[p];
}

public void union(int q){
    int pID = find(p);
    int qId = find(q);
    if(pID == qID) return;
    for(int i = 0; i &#60; id.length; i++){
        if(id[i] == pID) id[i] = qID;
    }
    count--;
}
[/code]
<div>性能分析：</div>
<div>find()操作很快，因为每次操作只访问id[]一次。但是union()操作每次都需要遍历id[]一遍，因此quick-find算法对大数据量问题不适用。</div>
<div>quick-find算法每次find()操作需一次数组访问，每次union()需要N+3到2N+1次数组访问（每次union()，需要两次find()，测试id[]中所有项，并更改其中1到N-1个项）。</div>
<div>考虑一个动态连通性问题最终得到一个单个组件，需要至少N-1次union()，即至少$$(N+3)(N-1)\sim N^2$$次数组访问，即quick-find是平方阶时间复杂度的算法。对大数据量，如largeUF.txt，quick-find无法解决问题，因此需要更好的算法。</div>
<div><strong>（二）Quick-union</strong></div>
<div>下一个算法考虑加速union()操作，它使用和前一个算法相同的数据结构id[]，但是对id[]的值有不同用法：每个点的id[]项是该点所在的组件中另一个点的名称（可以是该点自己的名字），称这样的连通为链接（link）。</div>
<div>为了实现find()，从给定点开始，沿着它的链接到另一个点，再沿着这个点的链接到又一个点，这样一直继续直到到达根节点，即一个链接到自己的点。</div>
<div>这个算法的不变式是：当且仅当两个点的find()过程到达同一个根，这两个点属于同一个组件。</div>
<div>为了维持此不变式，union(p, q)操作沿着链接分别找到p和q的根，然后通过将其中一个根链接到另一个根，使得其中一个组件重命名，两个组件合成一个，这一算法称为quick-union。在合并根节点时，任意选择是重命名包含p的组件或是包含q的组件。</div>
<div>下图显示了以tinyUF.txt作为测试数据时，quick-union的执行过程：</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_46207886.jpg" alt="" /></div>
<div>quick-union算法的id[]实际上实现了树的森林表示，id[]项是指向父节点的链接，根节点有指向自身的链接。森林中的每棵树是一个组件，根为该组件的标识。</div>
<div>算法实现</div>
[code lang="java"]
pubic int find(int p){
    while(id[p] != p) p = id[p];
    return p;
}
public void union(int q){
    int pRoot = find(p);
    int qRoot = find(q);
    if(pRoot == qRoot) return;
    id[pRoot] = qRoot;
    count--;
}
[/code]
<div>性能分析</div>
<div>quick-union似乎比quick-find快速，因为对每个输入数对，它不需要遍历整个数组，但是具体快了多少？在最优情况下，find()只需要一次数组访问获得组件标识；最坏情况下，find()需要2N+1次数组访问。具体性能依赖于输入的情况。我们在此不进行quick-find和quick-union的比较分析，因为接下来会研究一个更好的算法。在此可以认为，quick-uinon比quick-find有所提高，因为quick-find的union操作总需要线性时间，而quick-union并不总需要（取决于输入）。</div>
<div>find()操作的数组访问为1加上当前点的2倍深度；union()和connected()的数组访问次数是两个find()操作（如两个点属于不同树，union操作需要再加1）。</div>
<div>考虑quick-union的最坏情况，一个最终合为一个组件的动态连通性问题，输入数对的依次是0-1，0-2,0-3等等，N-1个这样的数对后，我们得到N个点组成的一个组件。由quick-uion生成的树高度是N-1，从叶子到根，依次是0,1,...N-1，对0 i数对的union()操作，数组访问次数是2i+2，因此对N-1个数对，数组访问总次数为$$N^2$$阶。</div>
<div><strong>（三）Weighted quick-union</strong></div>
<div>通过简单修改quick-union算法，可以保证quick-union算法的最坏情况不会发生。和quick-union任意的选择第二课树连到第一棵树不同，通过记录每棵树的大小，每次将较小的树连到较大的树上。这个算法称为加权(weighted)quick-union。</div>
<div>下图说明quick-union和weighted quick-union的区别：</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_47119150.jpg" alt="" /></div>
<div>上图可以看出：quick-union的连通策略使得生成的树趋于不平衡，进而使find操作所需时间越来越长；而weighted quick-union 总将小树连向大树，树的平衡性更优，避免性能恶化。</div>
<div>算法实现</div>
[code lang="java"]
public class WeightedQuickUnionUF
{
    private int[] id;
    private int[] sz;
    private int count;

    public WeightedQuickUnionUF(int N){
        count = N;
        id = new int[N];
        sz = new int[N];
        for(int i = 0; i &#60; N; i++){
            id[i] = i;
            sz[i] = 1;
        }
    }

    public int count(){
        return count;
    }

    public boolean connected(int p, int q){
        return find(p) == find(q);
    }

    private int find(int p){
        while(p != id[p]) p = id[p];
        return p;
    }

    public void union(int p , int q){
        int i = find(p);
        int j = find(q);
        if(i == j) return;
        if(sz[i] &#60; sz[j]){
            id[i] = j;
            sz[j] += sz[i];
        }
        else{
            id[j] = i;
            sz[i] += sz[j];
        }
        count--;
    }
}
[/code]
<div>性能分析</div>
<div>命题：由weighted quick-union生成的N个点组成的森林中，任意一点的深度最大为logN。(证明：略，见原书p229）。</div>
<div>推论：对N个点采用weighted quick-union算法，find(),connected()和union()的最坏情况时间复杂度是logN.</div>
<div>下图展示了对100个点规模的动态连通性问题，经过88次union()操作后，quick-union和weighted quick-union的对比：</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_49897762.jpg" alt="" /></div>
<div>从中可以看出，加权后的算法，森林中树的高度明显更低，只有很少的点离树的根较远。</div>
<div><strong>三种算法性能对比</strong></div>
<div>
<table style="width: 100%;" border="1">
<tbody>
<tr>
<td style="width: 25%;">算法</td>
<td style="width: 25%;">union</td>
<td style="width: 25%;">find</td>
</tr>
<tr>
<td style="width: 25%;">quick-find</td>
<td style="width: 25%;">N</td>
<td style="width: 25%;">1</td>
</tr>
<tr>
<td style="width: 25%;">quick-union</td>
<td style="width: 25%;">tree height</td>
<td style="width: 25%;">tree height</td>
</tr>
<tr>
<td style="width: 25%;">weighted quick-union</td>
<td style="width: 25%;">lgN</td>
<td style="width: 25%;">lgN</td>
</tr>
<tr>
<td style="width: 25%;">impossible</td>
<td style="width: 25%;">1</td>
<td style="width: 25%;">1</td>
</tr>
</tbody>
</table>
</div>
<div></div>
<div></div>
<div><strong>总结</strong></div>
<div>Algorithms一书更容易让人体会到学习、使用算法的快乐之处。如果你在《算法导论》的数学证明中有些疲倦时，不妨找来这本书，重拾初学者的乐趣。</div>
<div></div>]]></description>
			<content:encoded><![CDATA[<div>最近在读另一本经典的算法教材：<a href="http://book.douban.com/subject/10432347/">Algorithms(4th edition, Robert Sedgewick and Kevin Wayne）</a>，相比其他算法教材，这本书有几个特点：</div>
<div>1.图示非常丰富，阅读起来更有趣，更易懂；</div>
<div>2.给出了测试算法用的不同规模的数据和测试方法，以及展示算法结果所需要的工具。这些工具使得算法的测试、结果展示非常方便、直观。</div>
<div>3.介绍问题时更自然，相比算法导论定义、证明的方式，本书给出算法的应用场景，对需要解决的问题，不断改进算法得到最优结果，逐步改进的思路符合人们研究问题的正常过程，思维不跳跃，使学习过程有逻辑可循。</div>
<div>这本书有一个配套网站，<a href="http://algs4.cs.princeton.edu/home/">http://algs4.cs.princeton.edu/home/</a>，网站上除了提供书的部分内容，程序和数据下载外，还提供了课程的幻灯片和一些算法过程展示视频，效果非常赞。</div>
<div>下面是我对书中1.5节Case Study:Union-Find一节所做的笔记，可以部分反映出这本书的特点。</div>
<div></div>
<div></div>
<p></br></p>
<div><strong>问题引入：动态连通性(Dynamic connectivity)</strong></div>
<div>输入是一系列整数对，其中每个整数代表某种类型的对象，我们将整数对p q的含义解释为“p和q连通”。连通是一种等价关系，即满足：</div>
<div align="left">自反性：p和p连通；</div>
<div align="left">对称性：如果p和q连通，那么q和p连通；</div>
<div align="left">传递性：如果p和q连通，q和r连通，那么p和r连通。</div>
<div align="left">等价关系将所有对象分成等价类：如果两个对象连通，则它们属于同一个等价类。</div>
<div>我们的目标是：用程序过滤掉输入序列中不连通的数对。换句话说，当程序读入一对数p q时，只有当根据已经读取的所有数对不能说明p q连通时，才将p q数对输出，否则如果能判断出p q连通，则忽略p q数对，继续读下一对数。</div>
<div>用下图说明问题，图中有10个点，左侧数字为每次读入的连通数对。红色边为根据最新读入的数对产生的新边（即此时应输出这个数对），注意第二幅图当输入8 9时，由于8 9已经连接，因此不在8 9节点中增加新边（即不输出8 9数对）。连通完成后，图中左侧的三列点和右侧两列点分别为等价类。</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_14545330.png" alt="" />   <img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_14566094.png" alt="" /></div>
<div>上面描述的动态连通性问题在几个领域有许多应用，如在网络中：</div>
<div>    1.输入的整数代表网络中的计算机，数对代表网络中的连接。我们的程序用来判断为了让p和q通信，是建立一个新的直接连接，还是可以用已有的连接建立通信路径；</div>
<div>    2.整数代表电子电路中的连接点，数对代表连接各点的线路；</div>
<div>    3.整数代表社交网络中的人，数对代表好友关系。</div>
<div>在这些应用中我们可能需要处理数百万的对象和数十亿的连通关系。</div>
<div><strong>术语</strong></div>
<div>为了便于讨论，用网络术语定义问题。我们称上面的对象为点，称数对为连接，称等价类为连通组件，简称组件。简单起见，假设我们有N个点，每个点用整数命名，从0到N-1。</div>
<div>下图是一个规模大一些的连通性问题实例，从中可以看出连通性问题的困难之处。</div>
<div><img style="width: 425px; height: 333px;" src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_17914780.png" alt="" width="516" height="439" /></div>
<div>图中有625个点，很容易看出左下角的5个点是一个组件，但是并不容易判断任意两点的连通情况。对程序来说任务难度可能更大，因为程序只能处理点的名字和连接，并不能获得图标的几何结构。怎样才能快速判断给定的两个点是否连通呢？</div>
<div><strong>问题精确定义（API）</strong></div>
<div>为了解决问题，第一步工作是给出问题精确的定义。通常我们对一个算法的需求越多，用来实现它的时间和空间就越多，困难也越大。因此需要给出适当的定义。</div>
<div>为了定义问题，用一套API来封装所需要的基本操作：初始化；为两个点增加链接；标识包含一个点的组件；判断两个点是否属于同一组件；给组件计数。我们得到以下API：</div>
<pre class="brush: java; title: ; notranslate">
//Union-find API
public class UF
UF(int N) //initialize N sites with integer names (0 to N-1)
void union(int p, int q) //add connection between p and q
int find(int p) //component identifier for p (0 to N-1)
boolean connected(int p, int q) //return true if p and q are in the same component
int count()// number of components
</pre>
<div>定义API使得实现一个解决动态连通性问题的算法简化成了实现上述API。</div>
<div>用数组id[]记录每个点所属的组件，一般用一个组件中的某个点作为组件的标识符。初始时，每个点为一个组件，所以对i从0到N-1将id[i]置为i。</div>
<div>并查集API的基本实现如下，算法维护两个实例变量：组件的数目和数组id[]。不同的算法区别在于find()和union()的实现。</div>
<pre class="brush: java; title: ; notranslate">
public class UF{
    private int[] id;    //组件标识数组
    private int count;    //组件数量

    public UF(int N){
        id = new int[N];
        for(int i = 0; i &lt; N; i++)
            id[i] = i;
        count = N;
    }

    public void union(int p, int q){}
    public int find(int p){}

    public boolean connected(int p, int q){
        return find(p) == find(q);
    }

    public int count(){
        return count;
    }

    public static void main(String[] args){
        int N = StdIn.readInt();
        UF uf = new UF(N);
        while(!StdIn.isEmpty()){
            int p = StdIn.readInt();
            int q = StdIn.readInt();
            if(uf.connected(p, q)) continue;
            uf.union(p, q);
            Stdout.println(p + &quot; &quot; + q);
        }
    }
}
</pre>
<p><strong>测试方法</strong></p>
<div>UF类中提供了供测试用的main方法，它读取输入的整数对，如果数对没有连通，就将其连通并输出此数对。</div>
<div>提供了3个不同大小的测试数据集：tinyUF.txt包含10个点的11个连接，mediumUF.txt包含625个点的900个连接，largeUF.txt包含100万个点的200万个连接。数据的形式为：</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_42894268.jpg" alt="" /></div>
<div>每个数据第一行为总点数，剩下各行是各个连通的数对。</div>
<div><strong>算法分析方法</strong></div>
<div>为了分析算法，关注每个算法访问（读或写）数组元素的次数。</div>
<div><strong>算法实现</strong></div>
<div>下面给出三种算法实现，并逐渐提高性能。</div>
<div><strong>（一）Quick-find</strong></div>
<div>第一种方法维持的不变式是：当且仅当id[p]和id[q]相同时，p和q才是连通的。即同一个组件中的点有相同id[]值。这一方法称为quick-find，因为find(p)只返回id[p]，一次访问id[]即可完成。为了维持此不变式，操作union(p, q)时，首先检查p,q是否属于同一组件，如果不属于，则修改p、q组件中点的id[]，使所有id[]项相同。例如：</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_43690310.png" alt="" /></div>
<div>上图中，p=5,q=9，p和q原本属于不同组件，将它们连通时，将p所在组件的标识改为8，使得连个组件标识一致，成为同一组件。</div>
<div>算法实现</div>
<pre class="brush: java; title: ; notranslate">
pubic int find(int p){
    return id[p];
}

public void union(int q){
    int pID = find(p);
    int qId = find(q);
    if(pID == qID) return;
    for(int i = 0; i &lt; id.length; i++){
        if(id[i] == pID) id[i] = qID;
    }
    count--;
}
</pre>
<div>性能分析：</div>
<div>find()操作很快，因为每次操作只访问id[]一次。但是union()操作每次都需要遍历id[]一遍，因此quick-find算法对大数据量问题不适用。</div>
<div>quick-find算法每次find()操作需一次数组访问，每次union()需要N+3到2N+1次数组访问（每次union()，需要两次find()，测试id[]中所有项，并更改其中1到N-1个项）。</div>
<div>考虑一个动态连通性问题最终得到一个单个组件，需要至少N-1次union()，即至少<span class='MathJax_Preview'><img src='http://manan.org/wp-content/plugins/latex/cache/tex_c3690e65cf761915e5caf2810b6cb72e.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="(N+3)(N-1)\sim N^2" /></span><script type='math/tex'>(N+3)(N-1)\sim N^2</script>次数组访问，即quick-find是平方阶时间复杂度的算法。对大数据量，如largeUF.txt，quick-find无法解决问题，因此需要更好的算法。</div>
<div><strong>（二）Quick-union</strong></div>
<div>下一个算法考虑加速union()操作，它使用和前一个算法相同的数据结构id[]，但是对id[]的值有不同用法：每个点的id[]项是该点所在的组件中另一个点的名称（可以是该点自己的名字），称这样的连通为链接（link）。</div>
<div>为了实现find()，从给定点开始，沿着它的链接到另一个点，再沿着这个点的链接到又一个点，这样一直继续直到到达根节点，即一个链接到自己的点。</div>
<div>这个算法的不变式是：当且仅当两个点的find()过程到达同一个根，这两个点属于同一个组件。</div>
<div>为了维持此不变式，union(p, q)操作沿着链接分别找到p和q的根，然后通过将其中一个根链接到另一个根，使得其中一个组件重命名，两个组件合成一个，这一算法称为quick-union。在合并根节点时，任意选择是重命名包含p的组件或是包含q的组件。</div>
<div>下图显示了以tinyUF.txt作为测试数据时，quick-union的执行过程：</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_46207886.jpg" alt="" /></div>
<div>quick-union算法的id[]实际上实现了树的森林表示，id[]项是指向父节点的链接，根节点有指向自身的链接。森林中的每棵树是一个组件，根为该组件的标识。</div>
<div>算法实现</div>
<pre class="brush: java; title: ; notranslate">
pubic int find(int p){
    while(id[p] != p) p = id[p];
    return p;
}
public void union(int q){
    int pRoot = find(p);
    int qRoot = find(q);
    if(pRoot == qRoot) return;
    id[pRoot] = qRoot;
    count--;
}
</pre>
<div>性能分析</div>
<div>quick-union似乎比quick-find快速，因为对每个输入数对，它不需要遍历整个数组，但是具体快了多少？在最优情况下，find()只需要一次数组访问获得组件标识；最坏情况下，find()需要2N+1次数组访问。具体性能依赖于输入的情况。我们在此不进行quick-find和quick-union的比较分析，因为接下来会研究一个更好的算法。在此可以认为，quick-uinon比quick-find有所提高，因为quick-find的union操作总需要线性时间，而quick-union并不总需要（取决于输入）。</div>
<div>find()操作的数组访问为1加上当前点的2倍深度；union()和connected()的数组访问次数是两个find()操作（如两个点属于不同树，union操作需要再加1）。</div>
<div>考虑quick-union的最坏情况，一个最终合为一个组件的动态连通性问题，输入数对的依次是0-1，0-2,0-3等等，N-1个这样的数对后，我们得到N个点组成的一个组件。由quick-uion生成的树高度是N-1，从叶子到根，依次是0,1,...N-1，对0 i数对的union()操作，数组访问次数是2i+2，因此对N-1个数对，数组访问总次数为<span class='MathJax_Preview'><img src='http://manan.org/wp-content/plugins/latex/cache/tex_ec4ad94a9be87109217fcd9d10ebcd52.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="N^2" /></span><script type='math/tex'>N^2</script>阶。</div>
<div><strong>（三）Weighted quick-union</strong></div>
<div>通过简单修改quick-union算法，可以保证quick-union算法的最坏情况不会发生。和quick-union任意的选择第二课树连到第一棵树不同，通过记录每棵树的大小，每次将较小的树连到较大的树上。这个算法称为加权(weighted)quick-union。</div>
<div>下图说明quick-union和weighted quick-union的区别：</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_47119150.jpg" alt="" /></div>
<div>上图可以看出：quick-union的连通策略使得生成的树趋于不平衡，进而使find操作所需时间越来越长；而weighted quick-union 总将小树连向大树，树的平衡性更优，避免性能恶化。</div>
<div>算法实现</div>
<pre class="brush: java; title: ; notranslate">
public class WeightedQuickUnionUF
{
    private int[] id;
    private int[] sz;
    private int count;

    public WeightedQuickUnionUF(int N){
        count = N;
        id = new int[N];
        sz = new int[N];
        for(int i = 0; i &lt; N; i++){
            id[i] = i;
            sz[i] = 1;
        }
    }

    public int count(){
        return count;
    }

    public boolean connected(int p, int q){
        return find(p) == find(q);
    }

    private int find(int p){
        while(p != id[p]) p = id[p];
        return p;
    }

    public void union(int p , int q){
        int i = find(p);
        int j = find(q);
        if(i == j) return;
        if(sz[i] &lt; sz[j]){
            id[i] = j;
            sz[j] += sz[i];
        }
        else{
            id[j] = i;
            sz[i] += sz[j];
        }
        count--;
    }
}
</pre>
<div>性能分析</div>
<div>命题：由weighted quick-union生成的N个点组成的森林中，任意一点的深度最大为logN。(证明：略，见原书p229）。</div>
<div>推论：对N个点采用weighted quick-union算法，find(),connected()和union()的最坏情况时间复杂度是logN.</div>
<div>下图展示了对100个点规模的动态连通性问题，经过88次union()操作后，quick-union和weighted quick-union的对比：</div>
<div><img src="http://manan.org/wp-content/uploads/2012/05/wpid-becd905a87a443328c61546173ec8a7e_49897762.jpg" alt="" /></div>
<div>从中可以看出，加权后的算法，森林中树的高度明显更低，只有很少的点离树的根较远。</div>
<div><strong>三种算法性能对比</strong></div>
<div>
<table style="width: 100%;" border="1">
<tbody>
<tr>
<td style="width: 25%;">算法</td>
<td style="width: 25%;">union</td>
<td style="width: 25%;">find</td>
</tr>
<tr>
<td style="width: 25%;">quick-find</td>
<td style="width: 25%;">N</td>
<td style="width: 25%;">1</td>
</tr>
<tr>
<td style="width: 25%;">quick-union</td>
<td style="width: 25%;">tree height</td>
<td style="width: 25%;">tree height</td>
</tr>
<tr>
<td style="width: 25%;">weighted quick-union</td>
<td style="width: 25%;">lgN</td>
<td style="width: 25%;">lgN</td>
</tr>
<tr>
<td style="width: 25%;">impossible</td>
<td style="width: 25%;">1</td>
<td style="width: 25%;">1</td>
</tr>
</tbody>
</table>
</div>
<div></div>
<div></div>
<div><strong>总结</strong></div>
<div>Algorithms一书更容易让人体会到学习、使用算法的快乐之处。如果你在《算法导论》的数学证明中有些疲倦时，不妨找来这本书，重拾初学者的乐趣。</div>
<div></div>
<div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://manan.org/2011/09/sorting-algorithm-mind-map/" title="排序算法思维导图总结">排序算法思维导图总结</a></li><li><a href="http://manan.org/2011/09/%e4%b8%ad%e4%bd%8d%e6%95%b0%e5%92%8c%e9%a1%ba%e5%ba%8f%e7%bb%9f%e8%ae%a1%e5%ad%a6/" title="中位数和顺序统计学">中位数和顺序统计学</a></li><li><a href="http://manan.org/2011/09/%e6%a1%b6%e6%8e%92%e5%ba%8f/" title="桶排序">桶排序</a></li><li><a href="http://manan.org/2011/09/radix_sort/" title="基数排序">基数排序</a></li><li><a href="http://manan.org/2011/09/counting_sort/" title="计数排序">计数排序</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://manan.org/2012/05/union_find/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Book note:《比较政治分析》</title>
		<link>http://manan.org/2012/05/book_note_comparative_politics_analysis/</link>
		<comments>http://manan.org/2012/05/book_note_comparative_politics_analysis/#comments</comments>
		<pubDate>Sun, 06 May 2012 07:33:25 +0000</pubDate>
		<dc:creator>Little Horse</dc:creator>
				<category><![CDATA[01.读书]]></category>
		<category><![CDATA[思维导图]]></category>
		<category><![CDATA[读书]]></category>

		<guid isPermaLink="false">http://manan.org/?p=934</guid>
		<description><![CDATA[<a href="http://manan.org/wp-content/uploads/2012/05/比较政治分析-mindmap.png"><img src="http://manan.org/wp-content/uploads/2012/05/比较政治分析-mindmap.png" alt="比较政治分析-mindmap" title="比较政治分析-mindmap" width="1708" height="1721" class="alignnone size-full wp-image-935" /></a>]]></description>
			<content:encoded><![CDATA[<p><a href="http://manan.org/wp-content/uploads/2012/05/比较政治分析-mindmap.png"><img src="http://manan.org/wp-content/uploads/2012/05/比较政治分析-mindmap.png" alt="比较政治分析-mindmap" title="比较政治分析-mindmap" width="1708" height="1721" class="alignnone size-full wp-image-935" /></a></p>
<div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://manan.org/2012/05/book_note_a_short_history_of_chinese_philosophy/" title="Book note:《中国哲学简史》思维导图">Book note:《中国哲学简史》思维导图</a></li><li><a href="http://manan.org/2012/01/book_note_iwoz/" title="Book note：《我是沃兹》">Book note：《我是沃兹》</a></li><li><a href="http://manan.org/2011/12/book_note_hackers_and_painters/" title="Book note:《黑客与画家》">Book note:《黑客与画家》</a></li><li><a href="http://manan.org/2011/10/book_review_top_of_wave/" title="浪潮与基因——读《浪潮之巅》">浪潮与基因——读《浪潮之巅》</a></li><li><a href="http://manan.org/2011/10/book_note_top_of_wave/" title="Book note:《浪潮之巅》">Book note:《浪潮之巅》</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://manan.org/2012/05/book_note_comparative_politics_analysis/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Book note:《中国哲学简史》思维导图</title>
		<link>http://manan.org/2012/05/book_note_a_short_history_of_chinese_philosophy/</link>
		<comments>http://manan.org/2012/05/book_note_a_short_history_of_chinese_philosophy/#comments</comments>
		<pubDate>Wed, 02 May 2012 12:27:42 +0000</pubDate>
		<dc:creator>Little Horse</dc:creator>
				<category><![CDATA[01.读书]]></category>
		<category><![CDATA[读书]]></category>

		<guid isPermaLink="false">http://manan.org/?p=926</guid>
		<description><![CDATA[<a href="http://manan.org/wp-content/uploads/2012/05/中国哲学简史.png"><img class="alignnone size-full wp-image-927" title="中国哲学简史" src="http://manan.org/wp-content/uploads/2012/05/中国哲学简史.png" alt="中国哲学简史思维导图" width="1750" height="1472" /></a>]]></description>
			<content:encoded><![CDATA[<p><a href="http://manan.org/wp-content/uploads/2012/05/中国哲学简史.png"><img class="alignnone size-full wp-image-927" title="中国哲学简史" src="http://manan.org/wp-content/uploads/2012/05/中国哲学简史.png" alt="中国哲学简史思维导图" width="1750" height="1472" /></a></p>
<div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://manan.org/2012/05/book_note_comparative_politics_analysis/" title="Book note:《比较政治分析》">Book note:《比较政治分析》</a></li><li><a href="http://manan.org/2012/01/book_note_iwoz/" title="Book note：《我是沃兹》">Book note：《我是沃兹》</a></li><li><a href="http://manan.org/2011/12/book_note_hackers_and_painters/" title="Book note:《黑客与画家》">Book note:《黑客与画家》</a></li><li><a href="http://manan.org/2011/10/book_review_top_of_wave/" title="浪潮与基因——读《浪潮之巅》">浪潮与基因——读《浪潮之巅》</a></li><li><a href="http://manan.org/2011/10/book_note_top_of_wave/" title="Book note:《浪潮之巅》">Book note:《浪潮之巅》</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://manan.org/2012/05/book_note_a_short_history_of_chinese_philosophy/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>测试相册</title>
		<link>http://manan.org/2012/04/nextgen_gallery_sample/</link>
		<comments>http://manan.org/2012/04/nextgen_gallery_sample/#comments</comments>
		<pubDate>Thu, 19 Apr 2012 04:56:24 +0000</pubDate>
		<dc:creator>Little Horse</dc:creator>
				<category><![CDATA[025.wordpress]]></category>
		<category><![CDATA[WordPress]]></category>

		<guid isPermaLink="false">http://manan.org/?p=915</guid>
		<description><![CDATA[[nggallery id=1]]]></description>
			<content:encoded><![CDATA[
<div class="ngg-galleryoverview" id="ngg-gallery-1-915">

	<!-- Slideshow link -->
	<div class="slideshowlink">
		<a class="slideshowlink" href="http://manan.org/2012/04/nextgen_gallery_sample/?show=slide">
			[Show as slideshow]		</a>
	</div>

	
	<!-- Thumbnails -->
		
	<div id="ngg-image-1" class="ngg-gallery-thumbnail-box"  >
		<div class="ngg-gallery-thumbnail" >
			<a href="http://manan.org/wp-content/gallery/scene/blue.jpg" title=" " class="shutterset_set_1" >
								<img title="blue" alt="blue" src="http://manan.org/wp-content/gallery/scene/thumbs/thumbs_blue.jpg" width="100" height="75" />
							</a>
		</div>
	</div>
	
		
 		
	<div id="ngg-image-2" class="ngg-gallery-thumbnail-box"  >
		<div class="ngg-gallery-thumbnail" >
			<a href="http://manan.org/wp-content/gallery/scene/listening.jpg" title=" " class="shutterset_set_1" >
								<img title="listening" alt="listening" src="http://manan.org/wp-content/gallery/scene/thumbs/thumbs_listening.jpg" width="100" height="75" />
							</a>
		</div>
	</div>
	
		
 		
	<div id="ngg-image-3" class="ngg-gallery-thumbnail-box"  >
		<div class="ngg-gallery-thumbnail" >
			<a href="http://manan.org/wp-content/gallery/scene/p_large_osw6_7e470004086f2d0d.jpg" title=" " class="shutterset_set_1" >
								<img title="p_large_osw6_7e470004086f2d0d" alt="p_large_osw6_7e470004086f2d0d" src="http://manan.org/wp-content/gallery/scene/thumbs/thumbs_p_large_osw6_7e470004086f2d0d.jpg" width="100" height="75" />
							</a>
		</div>
	</div>
	
		
 		
	<div id="ngg-image-4" class="ngg-gallery-thumbnail-box"  >
		<div class="ngg-gallery-thumbnail" >
			<a href="http://manan.org/wp-content/gallery/scene/p_large_r8vw_7cd900010fc92d0d.jpg" title=" " class="shutterset_set_1" >
								<img title="p_large_r8vw_7cd900010fc92d0d" alt="p_large_r8vw_7cd900010fc92d0d" src="http://manan.org/wp-content/gallery/scene/thumbs/thumbs_p_large_r8vw_7cd900010fc92d0d.jpg" width="100" height="75" />
							</a>
		</div>
	</div>
	
		
 	 	
	<!-- Pagination -->
 	<div class='ngg-clear'></div>
 	
</div>


<div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://manan.org/2012/04/about_doc_page/" title="新增文档页面">新增文档页面</a></li><li><a href="http://manan.org/2011/09/test_latex-for-wordpess/" title="测试Latex for WordPess">测试Latex for WordPess</a></li><li><a href="http://manan.org/2010/12/%e5%8d%9a%e5%ae%a2%e8%bf%9b%e5%8c%96%e8%ae%b0%e5%bd%95/" title="博客进化记录">博客进化记录</a></li><li><a href="http://manan.org/2010/11/blog_moving/" title="博客搬家记">博客搬家记</a></li><li><a href="http://manan.org/2010/10/windows-live-writer/" title="测试：从Windows Live Writer发送的第一篇日志">测试：从Windows Live Writer发送的第一篇日志</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://manan.org/2012/04/nextgen_gallery_sample/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>windows下使用makefile示例</title>
		<link>http://manan.org/2012/04/windows_makefile_tutorial/</link>
		<comments>http://manan.org/2012/04/windows_makefile_tutorial/#comments</comments>
		<pubDate>Sun, 15 Apr 2012 15:26:22 +0000</pubDate>
		<dc:creator>Little Horse</dc:creator>
				<category><![CDATA[02.技术]]></category>
		<category><![CDATA[024.软件]]></category>
		<category><![CDATA[编程]]></category>

		<guid isPermaLink="false">http://manan.org/2012/04/windows%e4%b8%8b%e4%bd%bf%e7%94%a8makefile%e7%a4%ba%e4%be%8b/</guid>
		<description><![CDATA[一、环境准备

1.安装MinGW
2.修改环境变量，把%MinGW%/bin添加到path中（%MinGW%为MinGW安装路径）
3.把%MinGW%/bin中的mingw32-make.exe复制，并重命名为make
验证上面三步是否成功：
在cmd窗口中输入，make -v，如果输出make版本信息则安装正确。

二、makefile测试
1.在准备测试的路径（如 C:\Users\James\test）下新建如下两个代码文件：
[code lang="c"]//---------------------------main.c : ---------------------------//
#include &#34;stdio.h&#34;
main()
{
    func();
    printf(&#34;this is main\n&#34;);
    getch();
}[/code]

[code lang="c"]//---------------------------func.c : ---------------------------//
#include &#34;stdio.h&#34;
func()
{
    printf(&#34;this is func\n&#34;);
    getch();
}[/code]

2.新建makefile文件：
[code lang="c"]
test:main.o func.o
    gcc -o test main.o func.o
func.o:func.c
    gcc -c func.c
main.o:main.c
    gcc -c main.c
[/code]

注意：上面的gcc -o和gcc -c前面必须是<strong>TAB</strong>，不是空格，否则运行make时会报错：“makefile:2: *** missing separator. Stop.”。

3.在cmd中切换至当前路径（C:\Users\James\test）下，运行make命令，输入： make 回车。
make命令执行的结果为：
[code lang="c"]C:\Users\James\test&#62;make
gcc -c main.c
gcc -c func.c
gcc -o test main.o func.o[/code]

此时路径下已经编译生成了test.exe，输入test即可看到运行结果。

本文主要参考了[1]，windows下的各版本gcc介绍可以参考[2]，makefile入门可以参考陈皓的《跟我一起写 Makefile》[3].

参考资料
[1]windows下使用makefile编译C语言: <a href="http://blog.csdn.net/zhanghan3/article/details/1334308">http://blog.csdn.net/zhanghan3/article/details/1334308</a>
[2]gcc for Windows开发环境介绍， <a href="http://blog.csdn.net/Mobidogs/article/details/1819084">http://blog.csdn.net/Mobidogs/article/details/1819084</a>
[3]跟我一起写 Makefile,<a href="http://blog.csdn.net/haoel/article/details/2886">http://blog.csdn.net/haoel/article/details/2886</a>]]></description>
			<content:encoded><![CDATA[<p>一、环境准备</p>
<p>1.安装MinGW<br />
2.修改环境变量，把%MinGW%/bin添加到path中（%MinGW%为MinGW安装路径）<br />
3.把%MinGW%/bin中的mingw32-make.exe复制，并重命名为make<br />
验证上面三步是否成功：<br />
在cmd窗口中输入，make -v，如果输出make版本信息则安装正确。</p>
<p>二、makefile测试<br />
1.在准备测试的路径（如 C:\Users\James\test）下新建如下两个代码文件：</p>
<pre class="brush: cpp; title: ; notranslate">//---------------------------main.c : ---------------------------//
#include &quot;stdio.h&quot;
main()
{
    func();
    printf(&quot;this is main\n&quot;);
    getch();
}</pre>
<pre class="brush: cpp; title: ; notranslate">//---------------------------func.c : ---------------------------//
#include &quot;stdio.h&quot;
func()
{
    printf(&quot;this is func\n&quot;);
    getch();
}</pre>
<p>2.新建makefile文件：</p>
<pre class="brush: cpp; title: ; notranslate">
test:main.o func.o
    gcc -o test main.o func.o
func.o:func.c
    gcc -c func.c
main.o:main.c
    gcc -c main.c
</pre>
<p>注意：上面的gcc -o和gcc -c前面必须是<strong>TAB</strong>，不是空格，否则运行make时会报错：“makefile:2: *** missing separator. Stop.”。</p>
<p>3.在cmd中切换至当前路径（C:\Users\James\test）下，运行make命令，输入： make 回车。<br />
make命令执行的结果为：</p>
<pre class="brush: cpp; title: ; notranslate">C:\Users\James\test&gt;make
gcc -c main.c
gcc -c func.c
gcc -o test main.o func.o</pre>
<p>此时路径下已经编译生成了test.exe，输入test即可看到运行结果。</p>
<p>本文主要参考了[1]，windows下的各版本gcc介绍可以参考[2]，makefile入门可以参考陈皓的《跟我一起写 Makefile》[3].</p>
<p>参考资料<br />
[1]windows下使用makefile编译C语言: <a href="http://blog.csdn.net/zhanghan3/article/details/1334308">http://blog.csdn.net/zhanghan3/article/details/1334308</a><br />
[2]gcc for Windows开发环境介绍， <a href="http://blog.csdn.net/Mobidogs/article/details/1819084">http://blog.csdn.net/Mobidogs/article/details/1819084</a><br />
[3]跟我一起写 Makefile,<a href="http://blog.csdn.net/haoel/article/details/2886">http://blog.csdn.net/haoel/article/details/2886</a></p>
<div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://manan.org/2011/12/book_note_hackers_and_painters/" title="Book note:《黑客与画家》">Book note:《黑客与画家》</a></li><li><a href="http://manan.org/2011/11/search_suggestion/" title="用Lucene模糊搜索和ExtJs ComboBox实现搜索建议词效果">用Lucene模糊搜索和ExtJs ComboBox实现搜索建议词效果</a></li><li><a href="http://manan.org/2011/11/extjs_treegrid/" title="ExtJS TreeGrid叶子节点拖拽问题和选择框使用方法">ExtJS TreeGrid叶子节点拖拽问题和选择框使用方法</a></li><li><a href="http://manan.org/2011/09/sorting-algorithm-mind-map/" title="排序算法思维导图总结">排序算法思维导图总结</a></li><li><a href="http://manan.org/2011/09/%e4%b8%ad%e4%bd%8d%e6%95%b0%e5%92%8c%e9%a1%ba%e5%ba%8f%e7%bb%9f%e8%ae%a1%e5%ad%a6/" title="中位数和顺序统计学">中位数和顺序统计学</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://manan.org/2012/04/windows_makefile_tutorial/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>新增文档页面</title>
		<link>http://manan.org/2012/04/about_doc_page/</link>
		<comments>http://manan.org/2012/04/about_doc_page/#comments</comments>
		<pubDate>Sun, 08 Apr 2012 02:27:21 +0000</pubDate>
		<dc:creator>Little Horse</dc:creator>
				<category><![CDATA[025.wordpress]]></category>
		<category><![CDATA[blog]]></category>
		<category><![CDATA[WordPress]]></category>

		<guid isPermaLink="false">http://manan.org/2012/04/%e6%96%b0%e5%a2%9e%e6%96%87%e6%a1%a3%e9%a1%b5%e9%9d%a2/</guid>
		<description><![CDATA[给博客增加了“文档”页面，顺带恢复并修改了“关于”页面。
如果打开文档页面，会跳到一个由org-mode生成的HTML页面中，里面的内容是技术文档和读书笔记。好记性不如烂笔头，设置文档的目的就是督促自己把有用的信息点点滴滴都记录下来，虽然琐碎，但当初为了解决每个问题花费了时间，整理出来以后就有了参考，同时也可以给其他人以借鉴。
其实这样的笔记一直在做，以前在OneNote上，后来在Wiz中。直到我看到org-mode生成的漂亮的HTML页面，才体会到Linux世界的文档工具何其强大。关于笔记软件日后我会写一篇总结的日志，这里不多说了。以后只要是结构化的笔记我都会用org-mode记录，然后发布到这里。
文档的内容会不断更新，越来越丰富，由于记录内容都是正在学习的，肯定有不准确或是走弯路的地方，特此提醒，也欢迎帮我排错。]]></description>
			<content:encoded><![CDATA[<p>给博客增加了“文档”页面，顺带恢复并修改了“关于”页面。<br />
如果打开文档页面，会跳到一个由org-mode生成的HTML页面中，里面的内容是技术文档和读书笔记。好记性不如烂笔头，设置文档的目的就是督促自己把有用的信息点点滴滴都记录下来，虽然琐碎，但当初为了解决每个问题花费了时间，整理出来以后就有了参考，同时也可以给其他人以借鉴。<br />
其实这样的笔记一直在做，以前在OneNote上，后来在Wiz中。直到我看到org-mode生成的漂亮的HTML页面，才体会到Linux世界的文档工具何其强大。关于笔记软件日后我会写一篇总结的日志，这里不多说了。以后只要是结构化的笔记我都会用org-mode记录，然后发布到这里。<br />
文档的内容会不断更新，越来越丰富，由于记录内容都是正在学习的，肯定有不准确或是走弯路的地方，特此提醒，也欢迎帮我排错。</p>
<div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://manan.org/2010/12/%e5%8d%9a%e5%ae%a2%e8%bf%9b%e5%8c%96%e8%ae%b0%e5%bd%95/" title="博客进化记录">博客进化记录</a></li><li><a href="http://manan.org/2010/11/blog_moving/" title="博客搬家记">博客搬家记</a></li><li><a href="http://manan.org/2010/10/windows-live-writer/" title="测试：从Windows Live Writer发送的第一篇日志">测试：从Windows Live Writer发送的第一篇日志</a></li><li><a href="http://manan.org/2010/10/new-change-in-blog-1/" title="博客的新变化（一）：如何建立WordPress博客">博客的新变化（一）：如何建立WordPress博客</a></li><li><a href="http://manan.org/2010/10/new-change-in-blog-4/" title="博客的新变化（四）：更换主题、插件和备份">博客的新变化（四）：更换主题、插件和备份</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://manan.org/2012/04/about_doc_page/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>离乡情怯</title>
		<link>http://manan.org/2012/02/home_sick/</link>
		<comments>http://manan.org/2012/02/home_sick/#comments</comments>
		<pubDate>Tue, 21 Feb 2012 05:38:32 +0000</pubDate>
		<dc:creator>Little Horse</dc:creator>
				<category><![CDATA[05.随笔]]></category>
		<category><![CDATA[成长]]></category>

		<guid isPermaLink="false">http://manan.org/2012/02/%e7%a6%bb%e4%b9%a1%e6%83%85%e6%80%af/</guid>
		<description><![CDATA[春节假期结束了，火车行驶了四十几个小时，把我从寒冷的西北又带到了温暖的南方，从家带向了学校。

下了火车，用了半个小时才买到广州地铁的车票，我背着装满厚衣服的书包，拎着箱子挤进了车厢。背上的书包不时碰到别人，我一边道歉一边取下包，站稳了位置。这时后边有人推我，我知道他要往前走，让出一个位置。一对年纪六十上下的大叔大妈提着大包小包挤了过去，车座上的人连忙让座，他们坐了下来放置好行李。

大叔出了一头的汗，站着的乘客好心，递给他几张纸巾，他接过来擦拭额头上的汗水，同时感叹广州已经有些热的天气，给他纸巾的大姐用广式普通话应答着。我欣慰于广州市民的热情，联想起北京有些公交上售票员对扛着行李的外地人的态度。

终于喘了口气，老两口感叹着进地铁的不易，大约是过验票口时遇到了点困难。

我打量着他们，头发白了一多半，身体还健康，看穿着应该是从小地方来的。他们带着三个捆扎起来的纸箱和两个包，我根据箱包的大小排列组合了几次才得到两个老人提这几件行李的方式。

想必箱子里都是家乡的土特产，而他们应该是来看儿女的吧。

他们的儿女为什么不来接站呢？哪怕上班也要请假来啊，从过惯了的家乡到大城市并不是件容易的事，对两个老人。

我想着他们的儿女，突然想起了我的父母。想起出门前，我对父亲说，爸，我走了；想起在汽车站，我对母亲说，妈，再见。

泪水在眼眶里打转，我赶紧假装是空调的风吹到了脸，一边扭头一边庆幸没人注意到我的窘境。

离开家时似乎坚强，到了这里却开始思乡。

地铁到终点站了，老人家拿好行李，我也重新背起包，各自汇入了城市滚滚的人流中。]]></description>
			<content:encoded><![CDATA[<p>春节假期结束了，火车行驶了四十几个小时，把我从寒冷的西北又带到了温暖的南方，从家带向了学校。</p>
<p>下了火车，用了半个小时才买到广州地铁的车票，我背着装满厚衣服的书包，拎着箱子挤进了车厢。背上的书包不时碰到别人，我一边道歉一边取下包，站稳了位置。这时后边有人推我，我知道他要往前走，让出一个位置。一对年纪六十上下的大叔大妈提着大包小包挤了过去，车座上的人连忙让座，他们坐了下来放置好行李。</p>
<p>大叔出了一头的汗，站着的乘客好心，递给他几张纸巾，他接过来擦拭额头上的汗水，同时感叹广州已经有些热的天气，给他纸巾的大姐用广式普通话应答着。我欣慰于广州市民的热情，联想起北京有些公交上售票员对扛着行李的外地人的态度。</p>
<p>终于喘了口气，老两口感叹着进地铁的不易，大约是过验票口时遇到了点困难。</p>
<p>我打量着他们，头发白了一多半，身体还健康，看穿着应该是从小地方来的。他们带着三个捆扎起来的纸箱和两个包，我根据箱包的大小排列组合了几次才得到两个老人提这几件行李的方式。</p>
<p>想必箱子里都是家乡的土特产，而他们应该是来看儿女的吧。</p>
<p>他们的儿女为什么不来接站呢？哪怕上班也要请假来啊，从过惯了的家乡到大城市并不是件容易的事，对两个老人。</p>
<p>我想着他们的儿女，突然想起了我的父母。想起出门前，我对父亲说，爸，我走了；想起在汽车站，我对母亲说，妈，再见。</p>
<p>泪水在眼眶里打转，我赶紧假装是空调的风吹到了脸，一边扭头一边庆幸没人注意到我的窘境。</p>
<p>离开家时似乎坚强，到了这里却开始思乡。</p>
<p>地铁到终点站了，老人家拿好行李，我也重新背起包，各自汇入了城市滚滚的人流中。</p>
<div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://manan.org/2011/08/bedtime_reading/" title="睡前读书时刻">睡前读书时刻</a></li><li><a href="http://manan.org/2011/04/infj_pullze_and_liberation/" title="INFJ的困惑和解脱">INFJ的困惑和解脱</a></li><li><a href="http://manan.org/2011/02/lecture_how_to_be_first_class_gratuate_student/" title="[讲座]目标始终如一——如何做一流研究生">[讲座]目标始终如一——如何做一流研究生</a></li><li><a href="http://manan.org/2010/12/report_only_the_good_not_the_bad/" title="“报喜不报忧”">“报喜不报忧”</a></li><li><a href="http://manan.org/2010/09/book_note_grow_up/" title="《成长：从校园到职场》书摘">《成长：从校园到职场》书摘</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://manan.org/2012/02/home_sick/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Book note：《我是沃兹》</title>
		<link>http://manan.org/2012/01/book_note_iwoz/</link>
		<comments>http://manan.org/2012/01/book_note_iwoz/#comments</comments>
		<pubDate>Thu, 05 Jan 2012 15:01:46 +0000</pubDate>
		<dc:creator>Little Horse</dc:creator>
				<category><![CDATA[01.读书]]></category>
		<category><![CDATA[读书]]></category>

		<guid isPermaLink="false">http://xiaoma.me/2012/01/book-note%ef%bc%9a%e3%80%8a%e6%88%91%e6%98%af%e6%b2%83%e5%85%b9%e3%80%8b/</guid>
		<description><![CDATA[父亲告诉我的方式是：不要死记硬背零件如何形成电路，而是理解电子流动在哪里才形成有用的电路；不要仅仅阅读线路图或是书上的内容，而要真正心领神会。

因为我已是成年人，有我自己的道德观——深刻关注人民的生活疾苦。我开始寻找生活真谛——如今我仍在这样做——我行事做人只为自己和他人拥有一个快乐的人生。<span style="font-family: 宋体;">
</span>

对政府行为，我所感受的震惊和恶心非笔墨所能形容：他们将我们的人生玩弄于股掌之间，并非如父亲所说，他们关心民众疾苦。

我具有幽默感，对生活我也保持这样的态度，只有快乐会成为我的选择。我认为是否快乐，取决于自己，只是自己。

我相当清楚自己要成为一位设计电脑的工程师，一位编写软件的工程师，一位风趣的工程师，一位愿意教授他人的工程师。

我清楚自己从不想玩社交游戏。即使到22岁，我也如此肯定自己并不想从工程领域调至管理层。我不愿进入管理层，进行政治性的争斗，或是踩着别人的肩膀往上爬。

大多上白班的人都喜欢在回家做些完全不同的事情。有些喜欢在家看电视，但我则喜欢做电子工程。我热衷于此，并以此为乐。

在我心中，道德举足轻重，至今我仍不能真正明白他为何对我撒谎。但是，大家都知道任何人是不同的。

在我心中，欢笑的人生远比掌握管理权重要得多，不过这只是我的观点。我认为快乐是人生中最重要的事，这样的人似乎有点傻傻的，但却是快乐的，这就是我一直以来想要成为的人。

这也是我为何从不会将《突出重围》事件放在心上的原因。即使你不赞同，甚至认为我们的关系出现裂痕，也不必认为我们相互为敌，只是性格不同罢了，而这就是快乐生活的最好方法。

我认为，人们对功能由许多需求，我们不应该限制人们的期望。

因为创建苹果公司，所以我能得到比维持生存更多的钱。我一生中从未打算赚一笔很大的钱。我常被那些为了在生活中创造更多事物的人们的故事所激励。

我记得我父亲那时告诉我，是教育能让我们提升到在生命中想要的高度，也能提升人的价值。

无论到哪儿，我都十分关注孩子——婴儿、幼儿、小孩子、大孩子。我试着跟他们交流，向他们微笑，给他们讲笑话，成为他们的玩伴。我自幼就被灌输这样一个想法：有"坏人"会伤害或绑架孩子，所以我决定成为一个"好人"，任何一个遇到的孩子都可以依靠的"好人"。<span style="font-family: 宋体;">
</span>

我喜欢小孩子们看着我的脸——简直是热爱。
我愿意给像我当时那样的年轻人有价值的建议，那些认为自己"格格不入"的、内心热爱设计和发明以及制造的年轻人，从而改变人们做事的方法。

当你发现你渴望实现你脑子里的主意时，我的建议就是关于这时你该做些什么的。你年轻、没钱，拥有的就是你脑子里的东西。你认为你脑子里的想法是好东西。这些想法就是你成天思考的东西，它们驱动着你。

但是，想发明些东西，与真正发明些东西，仍大有不同。比如，你怎么做这个，你怎样改变这个世界？

第一，你需要相信你自己，不要动摇。

有一些人——我提到的大多数人，尤其是你将要遇到的那些人的思维，通常都是非黑即白型。许多人看事情是从媒体或他们朋友看问题的角度来看的，如果他 们觉得媒体或朋友的观点是正确的话，那么其他人的观点就是错误的。所以，一个新想法——革命性的新产品或产品功能不会被许多人理解，因为他们看问题是用极 其简单的二分法。他们无法理解某样东西，可能是因为他们无法想象它，或者别人已经告诉他们什么是有用的或好的，而在他们听见的这些东西里面，并不曾包括你 的想法。<span style="font-family: 宋体;">
</span>

不要让这些人打消你的积极性。记住，他们只是用符合当时大众文化标准的观点来看问题。他们只看到了那些摆在他们面前的东西。这是种偏见，确切的说，这是一种绝对阻碍发明精神的偏见。

但这个世界不是黑白二分这么简单，中间还有许多灰色过渡。作为一个发明者，你必须看到事情的灰色过渡层次。你应当思想开明，不要人云亦云，根本不要 管大众的想法。你要保持客观，忘记自己听到的各种观点，清扫桌面，像一个科学家那样做实际的研究。你不要想一蹴而就，很快得出结论，然后尽可能地找论据来 证明自己的观点。谁会浪费时间支持一个糟糕的想法呢？顽固地坚持己见是不值得的，不要为此找任何理由。<span style="font-family: 宋体;">
</span>

得到能改变世界的新主意的唯一途径是，跳出现有的其他人的思维局限。你必须跳出其他人已经设置的人为障碍。如果你想想出别人以前从没想过的主意，你就得认识到一个有灰色层次过渡的世界，而不是只生活在黑白两色世界里。

为什么我说工程师像艺术家？工程师经常努力把事情做得更完美，甚至超乎他们的设想。……我们不停的加添代码，像一个画家用笔刷加添色彩，一个作曲家 加添音符。这就是到达完美的途径——努力使每件事完美地组合在一起，以一种前人未曾做过的方式。这使得工程师或其他人成为真正的艺术家。<span style="font-family: 宋体;">
</span>

在我一生中，我看到在每20位工程师中，才有一位能体现这种艺术家完美主义的人。所以让你的工程师工作成为艺术，是一件鲜见的过程，但这是我们应该努力达到的境界。我最近被电影《一往无前》（Walk the Line)所感动。在电影里，制作人告诉约翰尼·卡什，要带着"这首歌能拯救全世界"这样的想法来演奏它。

这总结了我在讨论设计和其他事物中的艺术时追求的许多东西。

如果你是那种罕见的工程师，兼具发明者和艺术家的素质，我将给你一些也许实现起来很难的建议：单独工作。

当你当家做主，决定自己要创造什么、如何去创造、如何协调功能和质量时，它就是你自己的一部分，就像一个你深爱着的孩子，想抚养他成长。你有巨大的动力创造最好的可能的发明——你以一种热情关心着它们，一种其他人命令你创造什么发明时不可能有的热情。<span style="font-family: 宋体;">
</span>

我现在十分自豪。我十分自豪。不仅仅是因为苹果翻身了，还因为它是以一种符合我们早期价值观的方式翻身的。那些价值观包括产品设计如何达到卓越，卓越到人们都对这个产品垂涎三尺。这种价值观也是关于情感的，一种愉快的情感。

如果你像我这么幸运，你将生活在这样一个时代：一次革新即将开始，而你正当年少。如同亨利·福特与汽车产业，我与第一台个人电脑。<span style="font-family: 宋体;">
</span>

我希望你也像我一样幸运。这个世界需要发明者——好的发明者。你可以成为这样的人。如果你热爱你做的事，愿意付出相应的劳动，你将终有所得。你在夜里独自工作，反复思考你想设计与制造的东西，为之花费的每一分钟都是值得的。

我敢肯定的告诉你，你的付出是值得的。]]></description>
			<content:encoded><![CDATA[<p>父亲告诉我的方式是：不要死记硬背零件如何形成电路，而是理解电子流动在哪里才形成有用的电路；不要仅仅阅读线路图或是书上的内容，而要真正心领神会。</p>
<p>因为我已是成年人，有我自己的道德观——深刻关注人民的生活疾苦。我开始寻找生活真谛——如今我仍在这样做——我行事做人只为自己和他人拥有一个快乐的人生。<span style="font-family: 宋体;"><br />
</span></p>
<p>对政府行为，我所感受的震惊和恶心非笔墨所能形容：他们将我们的人生玩弄于股掌之间，并非如父亲所说，他们关心民众疾苦。</p>
<p>我具有幽默感，对生活我也保持这样的态度，只有快乐会成为我的选择。我认为是否快乐，取决于自己，只是自己。</p>
<p>我相当清楚自己要成为一位设计电脑的工程师，一位编写软件的工程师，一位风趣的工程师，一位愿意教授他人的工程师。</p>
<p>我清楚自己从不想玩社交游戏。即使到22岁，我也如此肯定自己并不想从工程领域调至管理层。我不愿进入管理层，进行政治性的争斗，或是踩着别人的肩膀往上爬。</p>
<p>大多上白班的人都喜欢在回家做些完全不同的事情。有些喜欢在家看电视，但我则喜欢做电子工程。我热衷于此，并以此为乐。</p>
<p>在我心中，道德举足轻重，至今我仍不能真正明白他为何对我撒谎。但是，大家都知道任何人是不同的。</p>
<p>在我心中，欢笑的人生远比掌握管理权重要得多，不过这只是我的观点。我认为快乐是人生中最重要的事，这样的人似乎有点傻傻的，但却是快乐的，这就是我一直以来想要成为的人。</p>
<p>这也是我为何从不会将《突出重围》事件放在心上的原因。即使你不赞同，甚至认为我们的关系出现裂痕，也不必认为我们相互为敌，只是性格不同罢了，而这就是快乐生活的最好方法。</p>
<p>我认为，人们对功能由许多需求，我们不应该限制人们的期望。</p>
<p>因为创建苹果公司，所以我能得到比维持生存更多的钱。我一生中从未打算赚一笔很大的钱。我常被那些为了在生活中创造更多事物的人们的故事所激励。</p>
<p>我记得我父亲那时告诉我，是教育能让我们提升到在生命中想要的高度，也能提升人的价值。</p>
<p>无论到哪儿，我都十分关注孩子——婴儿、幼儿、小孩子、大孩子。我试着跟他们交流，向他们微笑，给他们讲笑话，成为他们的玩伴。我自幼就被灌输这样一个想法：有"坏人"会伤害或绑架孩子，所以我决定成为一个"好人"，任何一个遇到的孩子都可以依靠的"好人"。<span style="font-family: 宋体;"><br />
</span></p>
<p>我喜欢小孩子们看着我的脸——简直是热爱。<br />
我愿意给像我当时那样的年轻人有价值的建议，那些认为自己"格格不入"的、内心热爱设计和发明以及制造的年轻人，从而改变人们做事的方法。</p>
<p>当你发现你渴望实现你脑子里的主意时，我的建议就是关于这时你该做些什么的。你年轻、没钱，拥有的就是你脑子里的东西。你认为你脑子里的想法是好东西。这些想法就是你成天思考的东西，它们驱动着你。</p>
<p>但是，想发明些东西，与真正发明些东西，仍大有不同。比如，你怎么做这个，你怎样改变这个世界？</p>
<p>第一，你需要相信你自己，不要动摇。</p>
<p>有一些人——我提到的大多数人，尤其是你将要遇到的那些人的思维，通常都是非黑即白型。许多人看事情是从媒体或他们朋友看问题的角度来看的，如果他 们觉得媒体或朋友的观点是正确的话，那么其他人的观点就是错误的。所以，一个新想法——革命性的新产品或产品功能不会被许多人理解，因为他们看问题是用极 其简单的二分法。他们无法理解某样东西，可能是因为他们无法想象它，或者别人已经告诉他们什么是有用的或好的，而在他们听见的这些东西里面，并不曾包括你 的想法。<span style="font-family: 宋体;"><br />
</span></p>
<p>不要让这些人打消你的积极性。记住，他们只是用符合当时大众文化标准的观点来看问题。他们只看到了那些摆在他们面前的东西。这是种偏见，确切的说，这是一种绝对阻碍发明精神的偏见。</p>
<p>但这个世界不是黑白二分这么简单，中间还有许多灰色过渡。作为一个发明者，你必须看到事情的灰色过渡层次。你应当思想开明，不要人云亦云，根本不要 管大众的想法。你要保持客观，忘记自己听到的各种观点，清扫桌面，像一个科学家那样做实际的研究。你不要想一蹴而就，很快得出结论，然后尽可能地找论据来 证明自己的观点。谁会浪费时间支持一个糟糕的想法呢？顽固地坚持己见是不值得的，不要为此找任何理由。<span style="font-family: 宋体;"><br />
</span></p>
<p>得到能改变世界的新主意的唯一途径是，跳出现有的其他人的思维局限。你必须跳出其他人已经设置的人为障碍。如果你想想出别人以前从没想过的主意，你就得认识到一个有灰色层次过渡的世界，而不是只生活在黑白两色世界里。</p>
<p>为什么我说工程师像艺术家？工程师经常努力把事情做得更完美，甚至超乎他们的设想。……我们不停的加添代码，像一个画家用笔刷加添色彩，一个作曲家 加添音符。这就是到达完美的途径——努力使每件事完美地组合在一起，以一种前人未曾做过的方式。这使得工程师或其他人成为真正的艺术家。<span style="font-family: 宋体;"><br />
</span></p>
<p>在我一生中，我看到在每20位工程师中，才有一位能体现这种艺术家完美主义的人。所以让你的工程师工作成为艺术，是一件鲜见的过程，但这是我们应该努力达到的境界。我最近被电影《一往无前》（Walk the Line)所感动。在电影里，制作人告诉约翰尼·卡什，要带着"这首歌能拯救全世界"这样的想法来演奏它。</p>
<p>这总结了我在讨论设计和其他事物中的艺术时追求的许多东西。</p>
<p>如果你是那种罕见的工程师，兼具发明者和艺术家的素质，我将给你一些也许实现起来很难的建议：单独工作。</p>
<p>当你当家做主，决定自己要创造什么、如何去创造、如何协调功能和质量时，它就是你自己的一部分，就像一个你深爱着的孩子，想抚养他成长。你有巨大的动力创造最好的可能的发明——你以一种热情关心着它们，一种其他人命令你创造什么发明时不可能有的热情。<span style="font-family: 宋体;"><br />
</span></p>
<p>我现在十分自豪。我十分自豪。不仅仅是因为苹果翻身了，还因为它是以一种符合我们早期价值观的方式翻身的。那些价值观包括产品设计如何达到卓越，卓越到人们都对这个产品垂涎三尺。这种价值观也是关于情感的，一种愉快的情感。</p>
<p>如果你像我这么幸运，你将生活在这样一个时代：一次革新即将开始，而你正当年少。如同亨利·福特与汽车产业，我与第一台个人电脑。<span style="font-family: 宋体;"><br />
</span></p>
<p>我希望你也像我一样幸运。这个世界需要发明者——好的发明者。你可以成为这样的人。如果你热爱你做的事，愿意付出相应的劳动，你将终有所得。你在夜里独自工作，反复思考你想设计与制造的东西，为之花费的每一分钟都是值得的。</p>
<p>我敢肯定的告诉你，你的付出是值得的。</p>
<div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://manan.org/2012/05/book_note_comparative_politics_analysis/" title="Book note:《比较政治分析》">Book note:《比较政治分析》</a></li><li><a href="http://manan.org/2012/05/book_note_a_short_history_of_chinese_philosophy/" title="Book note:《中国哲学简史》思维导图">Book note:《中国哲学简史》思维导图</a></li><li><a href="http://manan.org/2011/12/book_note_hackers_and_painters/" title="Book note:《黑客与画家》">Book note:《黑客与画家》</a></li><li><a href="http://manan.org/2011/10/book_review_top_of_wave/" title="浪潮与基因——读《浪潮之巅》">浪潮与基因——读《浪潮之巅》</a></li><li><a href="http://manan.org/2011/10/book_note_top_of_wave/" title="Book note:《浪潮之巅》">Book note:《浪潮之巅》</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://manan.org/2012/01/book_note_iwoz/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Book note:《黑客与画家》</title>
		<link>http://manan.org/2011/12/book_note_hackers_and_painters/</link>
		<comments>http://manan.org/2011/12/book_note_hackers_and_painters/#comments</comments>
		<pubDate>Sun, 25 Dec 2011 07:09:51 +0000</pubDate>
		<dc:creator>Little Horse</dc:creator>
				<category><![CDATA[01.读书]]></category>
		<category><![CDATA[互联网]]></category>
		<category><![CDATA[编程]]></category>
		<category><![CDATA[读书]]></category>
		<category><![CDATA[软件]]></category>

		<guid isPermaLink="false">http://xiaoma.me/2011/12/book-note%e3%80%8a%e9%bb%91%e5%ae%a2%e4%b8%8e%e7%94%bb%e5%ae%b6%e3%80%8bby-paul-graham/</guid>
		<description><![CDATA[<span style="color: #366092;"><strong>序 </strong>
</span>

保罗·格雷厄姆有一套完整的创业哲学，他的创业公式是：

1.搭建原型

2.上线运营

3.收集反馈

4.调整产品

5.成长壮大

他认为一定要特别关注用户需要什么，这样才有办法将一个坏项目转变成好项目。他说："许多伟大的公司，一开始的时候做的都是与后来业务完全不同的事情。乔布斯创建苹果公司后的第一个计划是出售计算机零件，然后让用户自己组装，后来才变成开发苹果电脑。你需要倾听用户的声音，琢磨他们需要什么，然后就去做。"

创始人本身比他的创意更重要。

作者目的：通过这本书让普通读者理解我们所处的这个计算机时代。

作者试图从许许多多不同的方面解释这个时代的内在脉络，揭示它的发展轨迹，帮助你看清我们现在的位置和将来的方向。

想把握这个时代，就必须理解计算机。理解计算机的关键，则是要理解计算机背后的人。

我们的时代是程序员主导的时代，而伟大的程序员就是黑客。

根据理查德·斯托尔曼的说法，黑客行为必须包含三个特点：好玩、高智商、探索精神。
黑客价值观的核心原则可以概括成这样几点：分享、开放、民主、计算机的自由使用、进步。

《黑客与画家》这个书名就是在提示应该把黑客与画家当做同一种人看待。和画家一样，黑客只是怀有一门特殊手艺、有创造天赋的普通人。这个书名还有另外一层含义，即编程时一种艺术创作，黑客就是艺术家，开发软件与画家作画、雕塑家雕刻、建筑师设计房屋并没有本质不同。
<span style="color: #366092;"><strong>1.为什么书呆子不受欢迎</strong>
</span>

校园生活的真正问题是空虚。

学校是一个很奇怪的、人为设计出来的体系，一半像是无菌室，一般像是野蛮洪荒之地。

<span style="color: #366092;"><strong>2.黑客与画家</strong>
</span>

黑客与画家的共同之处，在于他们都是创作者。与作曲家、建筑师、作家一样，黑客和画家都是试图创作出优秀的作品。他们本质上都不是在做研究，虽然在创作过程中，他们可能会发现一些新技术。

创造优美食物的方式往往不是从头做起，而是在现有成果的基础上做一些小小的调整，或者将已有的观点用比较新的方式组合起来。这种类型的工作很难用研究性的论文表达。
如果黑客认识到自己与其他创作者——比如作家和画家——是一类人，这种诱惑对他就不起作用。作家和画家没有"对数学的嫉妒"，他们认为自己在从事与数学完全不相关的事情。我认为，黑客也是如此。
黑客如何才能做自己喜欢的事情？我认为这个问题的解决方法是一个几乎所有创作者都知道的方法：找一份养家糊口的"白天工作"。

几乎所有的创作者在职业生涯早期都有一份"白天工作"。
从画家身上，我们还能借鉴到什么对黑客的启示呢？

画家学习绘画的方法主要是动手去画，黑客学习编程的方法也理应如此。

创作者的另一个学习的途径是通过范例。

开源运动最鲜为人知的优点之一，就是使得学习编程变得更容易了。

你不能盼望先有一个完美的规格设计，然后再动手编程，这样想是不现实的。如果你预先承认规格设计是不完美的，在编程的时候，就可以根据需要当场修改规格，最终会有一个更好的结果。
一幅优秀的作品必须比它应该有的样子更好。

坚持一丝不苟，就能取得优秀的成功。因为那些看不见的细节累加起来，就变得可见了。

就像绘画作品一样，大多数软件是为人类用户准备的。所以，黑客必须像画家一样，时刻考虑到用户的人性需要，这样才能做出伟大的产品。

普通黑客和优秀黑客的所有区别之中，会不会"换位思考"可能是最重要的单个因素。

判断一个人是否具备"换位思考"的能力有一个好方法，那就是看他怎样向没有技术背景的人解释技术问题。

"程序写出来是给人看的，附带能在机器上运行。"
<p style="margin-left: 27pt;">——《计算机程序的结构和解释》</p>
<span style="color: #366092;"><strong>3.不能说的话</strong>
</span>

流行一时的不仅有衣服，还有道德观念。
训练自己去想那些不能想的事情，你获得好处会超过所得到的想法本身。

<span style="color: #366092;"><strong>4.良好的坏习惯</strong><span style="font-family: 宋体;">
</span></span>

不服从管教，其实是黑客之所以成为优秀程序员的原因之一。

只有深入了解当前的技术，黑客才能构想下一代技术。
公民自由使得国家富强.

如果读美国开国元勋的自述,你会发现他们听起来很像黑客。"反抗政府的精神，"杰弗逊写道，"在某些场合是如此珍贵，我希望它永远保持活跃。"<span style="font-family: 宋体;">
</span>

<span style="color: #366092;"><strong>5.另一条路</strong><span style="font-family: 宋体;">
</span></span>

我认为，大量的下一代软件都将采用这个模式。甚至最大的输家——微软公司，看来也明白了，部分软件从桌面消失将是不可避免的。如果软件从桌面移到服务器上，一切将发生根本的变化。
互联网软件运行在服务器上，用户界面就是网页。对于普通用户来说，使用这种新型软件将更容易、更便宜、更机动、更可靠，通常也比桌面软件更强大。

如果互联网软件能够击败桌面软件，一定是赢在更方便这一优势上。无论从用户的角度还是从开发者的角度来看都是如此。

<span style="color: #366092;"><strong><em>用户的胜利</em></strong>
</span>

"你的电脑"这个概念正慢慢成为过去时，取而代之的是"你的数据"。

不会有应用软件与操作系统不兼容的问题了。

适用软件将变得非常普遍、容易。

升级不再对用户形成大的冲击。

他们必须正确地设计软件，使得它能够平滑升级，不让使用者感到困惑。

所有用户都是用同样版本的互联网软件，bug一发现就会立刻得到纠正。

适合团队协作性的应用。

数据更安全。

不容易感染病毒。

大多数windows用户使用桌面软件的时候都感到紧张，会有相当大的心理压力，释放这种压力，对你的产品将是一种巨大的推动。<span style="font-family: 宋体;">
</span>

<span style="color: #366092;"><strong><em>代码之城</em></strong>
</span>

设计桌面软件就像设计一幢大楼，而设计互联网软件就像设计一座城市。

软件、硬件。

硬件需要考虑的地方，不仅仅在于怎么才能避免出现问题，还在于怎样才能最大地发挥它们 的作用。

1995年我们创立viaweb的时候，Java applet被认为是互联网软件的解决方案，。但是我们觉得，applet采用的还是过时的概念，它还是要求下载软件到客户端运行。

不同的语言适合不同的任务，你应该根据不通过场合，挑选最合适的工具。如果你不利用语言的优势，那就会听人对手超过你。

<span style="color: #366092;"><strong><em>软件的发布</em></strong>
</span>

互联网软件带来的最大变化之一，就是软件发布方式的改变。

软件的发布可以分解为一系列的渐进式修改，而不是猛地退出一个大幅变动的版本。

<span style="color: #366092;"><strong><em>软件bug</em></strong>
</span>

有一种编程方法叫做"函数式编程"（functional programming），对于互联网软件很有用，很难用纯粹的"函数式编程"完成整个程序，但是它可以用来编写一些重要的部分使得这些部分易于调试，因为他们不包含"状态"，非常便于不断对代码进行小幅的修改和调试。

实现某个构思，会带来更多的构思。所以，将一个构思束之高阁，不仅意味着延迟它的实现，还意味着延迟所有在是实现过程中激发的构思。

要让软件变得可靠，关键是你要全神贯注，而不是开发得很慢。

效率对互联网软件至关重要。<span style="font-family: 宋体;">
</span>

如果软件效率足够高，每个用户的硬件成本现在可以接近免费。

如果新事物真的有重大改进，那么它总是可以找到生存空间的。

你完全能够在只有三个人的情况下让产品开始运营。

桌面软件迫使用户变成系统管理员，互联网软件则是迫使程序员变成系统管理员：用户的压力变小了，程序员的压力变大了。

由于互联网软件的程序员非常辛苦，所以会使得经济优势根本性地从大公司向创业公司转移。互联网软件要求的那种工作强度和付出，只有当公司是其本人所有时，程序员才愿意提供。

因为互联网软件的创业不需要太多的资本，所以大公司可以与创业公司竞争的优势就所剩无几了。

互联网做起来很辛苦，还有许多特别大的压力，但是它们的唯一作用，就是使得创业公司成功的机会变大。

<span style="color: #366092;"><strong><em>为什么不尝试一下？</em></strong>
</span>

如果你是一个黑客，并且梦想自己创业，可能会有两件事情令你望而却步，不敢真正开始采取行动。一件是你不懂得管理企业，另一件是你害怕竞争。可是实际上，这两件事都没有通电的篱笆。

首先，管理企业其实很简单，只要记住两点就可以了：做出用户喜欢的产品，保证开支小于收入。<span style="font-family: 宋体;">
</span>

开支：勤俭节约；编写一个互联网软件是非常便宜的。

如何做出用户喜欢的产品
<p style="margin-left: 27pt;">从制造简洁的产品开始着手，首先要保证你自己愿意使用。然后，迅速地做出1.0版，并且不断加以改进，整个过程中密切倾听用户的反馈。</p>
<p style="margin-left: 27pt;">无论何时，你都要使用自己的软件。</p>
<p style="margin-left: 27pt;">不要只因为对方的头衔是市场专家、设计师或产品经理，就盲目听从他们的话。如果他们的观点真的很好，那就听从他们，关键是你要自己判断，不要盲从。只有懂得设计的黑客，才能设计软件，不能交给对软件一知半解的设计师。</p>
<p style="margin-left: 27pt;">如果你不打算自己动手设计和开发，那就不要创业。</p>
其次，竞争。大公司害怕你胜过你害怕他们。

<span style="color: #366092;"><strong>6.如何创造财富</strong>
</span>

如果你想致富，应该怎么做？我认为最好的办法就是自己创业，或者加入创业公司。

如果你想赚100万美元，就不得不忍受相当于100万美元的痛苦。

任何公司的成功历程中，运气都是一个很大的随机因素。

通过创造有价值的东西而致富，这种方法的优势不仅仅在于它是合法的，还在于它更简单。

财富和金钱并不是同义词。财富才是你的目标，金钱不是。

人们觉得做生意就是为了挣钱，但是金钱其实只是一种中介，让大家可以更方便地获得自己想要的东西。大多数生意的目的是为了创造财富，做出人们真正想要的东西。

人们需要的东西就是财富。

公司就是许多人聚在一起创造财富的地方，能够制造更多人们需要的东西。

我们这个世界，你向下沉沦或者向上奋进都取决于你自己，不能把原因推给外界。
"你需要去做一些人们需要的东西"。即使不加入公司，你也能做到。真正重要的是做出人们需要的东四，而不是加入某个公司。

工作就是在一个组织中，与许多人共同合作，做出某种人们需要的东西。

<span style="color: #366092;"><strong><em>可测量性和可放大性</em></strong>
</span>

要致富，你需要两样东西：可测量性和可放大性。
<p style="margin-left: 27pt;">业绩可以测量；你做出的决定能够产生巨大的效应。</p>
如果你有一个令你感到安全的工作，你是不会致富的，因为没有危险，就几等于没有可放大性。

如果你想同时具备可测量性和可放大性，不一定非当上CEO或电影明星不可。你只需要成为某个攻克难题的小团体的一部分就可以了。

<span style="color: #366092;"><strong><em>小团体=可测量性</em></strong>
</span>

这就是创业公司的真正意义。理想情况下，你与其他愿意更努力工作的人一起组成一个团队，共同谋取更高的回报。
创业公司的成败取决于最早加入公司的那十个人。（乔布斯）

我们不需要小村庄的那种"小"，而需要全明星第一阵容的那种"小"。

<span style="color: #366092;"><strong><em>高科技=可放大性</em></strong>
</span>

什么是技术？技术就是某种手段，就是我们做事的方式。

如果你解决了一个热门的技术问题，别人都会使用你的解决方案。这就是可放大性。
创业公司如同蚊子，往往只有两种结局，要么赢得一切，要么彻底消失。你通常不知道自己会是哪一个结局，只有等到最后一刻才会明了。

你开办创业公司不是单纯地为了解决问题，而是为了解决那些用户关系的问题。

你必须时刻牢记的最基本的原则就是，创造人们需要的东西，也就是创造财富。如果你想通过创造财富使得自己致富，那么你必须知道人们需要什么。

<span style="color: #366092;"><strong><em>财富和权力</em></strong>
</span>

没有财富的激励，技术革新就会逐渐停顿。
为什么欧洲在历史上变得如此强大：可能是因为允许赚到大钱的人保住自己的财富。
要鼓励大家去创业。只要懂得藏富于民，国家就会变得强大。让书呆子保住他们的血汗钱，你就会无敌于天下。

<span style="color: #366092;"><strong>7.关注贫富分化</strong></span>
<span style="color: #366092;"><strong>8.防止垃圾邮件的一种方法</strong><span style="font-family: 宋体;">
</span></span>

<span style="color: #366092;"><strong>9.设计者的品位</strong><span style="font-family: 宋体;">
</span></span>

如果你是一个设计师，并且你不承认有一种人们共同认可的东西叫做"美"，那么你就没有办法做好工作。如果品位只是一种个人偏好，那么每个人都是完美无缺的：你喜欢自己看上的东西，那就足够了。

众多不同学科对"美"的认识有着惊人的相似度。优秀设计的原则是许多学科的共同原则，一再反复地出现。
好设计是简单的设计。

有人会说，简单就是事物本来的样子，装饰反而意味着更多的工作。但是，当人们自己从事创造性工作的时候，好像就会忘了保持简单这个原则。刚开始写作的人喜欢用浮夸的语调，

根本不像他们平时说话的样子。设计师喜欢用波浪式卷曲表现他们的艺术感。画家发现自己都是表现主义者。这些装饰都是花架子，在作家的长句、画家"表现主义"的画笔之下，根本就是空洞无物，表面的掩饰掩盖了内部的空虚，太可怕了。

当你被迫把东西做的简单时，你就被迫直接面对真正的问题。当你不能用表面的装饰交差时，你就不得不做好真正的本质部分。
好设计是永不过时的设计。

说来奇怪，如果你希望自己的作品对未来的人们有吸引力，方法之一就是让你的作品对上几代人有吸引力。

好设计是解决主要问题的设计。

eg：厨房的煤气灶，四个出火口和调节器的位置摆放。

eg：字体的设计。
好设计是启发性的设计。

eg：英国女作家简奥斯丁的作品：几乎不带有任何描述。

eg：《蒙娜丽莎》：启发式的绘画

一个建筑或一个物品应该允许你按照自己的愿望来使用。

你应该为用户提供一些基本模块，使得他们可以随心所欲自由组合，就像玩乐高积木那样。

好设计通常是有点趣味性的设计。

这是因为幽默一定程度上反映了力量。幽默感是强壮的一种表现，始终拥有幽默感就代表你对厄运一笑了之，而丧失幽默感则表示你被厄运深深伤到。所以，强壮的标志（或者至少是特点）就是轻松面对自己的人生。充满自信的人常常像燕子一样，以一种居高临下的姿态轻盈的看待周围的一切，比如希区柯克拍摄的电影、16世纪画家布勒哲的绘画（甚至莎士比亚也是一个这方面的例子）。

好设计是艰苦的设计。

如果观察那些做出伟大作品的人，你会发现他们的共同点就是工作得非常艰苦。如果你工作得不艰苦，你可能正在浪费时间。

功能决定形式：如果开发"功能"非常艰难，那么"形式"将不得不全部都由"功能"决定，因为没有多余的精力再来单独开发"形式"了。

好设计是看似容易的设计。<span style="font-family: 宋体;">
</span>

作家的文章看起来流畅自如，但是背后其实经过了反复修改。

科学和工程学的一些最重大的发现在形式上往往很简单，会使得你觉得自己也想到过。

在大多数领域，看上去容易的事，背后都需要大量的练习。练习的作用也许是训练你把可以为之的事情变成一种自觉的行为。

好设计是对称的设计
好设计是模仿大自然的设计。

模仿与剽窃并不相同。

好设计是一种再设计。

很少有人一次就把事情做对。专家的做法是先完成一个早期原型，然后提出修改计划，最后把早期原型扔掉。

你应该培养对自己的不满。达芬奇为了把一根线画对，经常要画五六次。

犯错误是很正常的事情。你不要把犯错误看成灾难，要用于承认、用于改正。开源软件因为公开承认自己会有bug，反而使得代码的bug比较少。
好设计是能够复制的设计。

把事情做对比原创更重要。

等你逐渐对一件事产生热情的时候，就不会满足于模仿了。你的品位就进入了第二阶段，开始自觉地进行原创。

我想，最伟大的大师最终会达到一种超脱自我的境界。他们一心想找到正确答案，如果别人已经回答了一部分，那就没理由不拿来用。他们足够自信地使用他人的成功，完全不担心因此丧失个人的特点。
好设计常常是奇怪的设计。

eg:Lisp，黑鸟超音速侦察机；《雪中猎人》

eg:爱因斯坦并不像让相对论变得很奇特，他只想找出真理，是真理本身显得很奇特。

唯一达到"奇特"的方法，就是追求做出好作品，完成之后再回过头看。
好设计师成批出现的。<span style="font-family: 宋体;">
</span>

eg:15世纪的弗洛伦萨涌现一大批伟大艺术家。

推动人才成批涌现的最大因素就是，让有天赋的人聚在一起，共同解决某个难题。互相激励比天赋更重要。

在历史上的任何时刻都有一些热点项目，一些团体在这些项目上做出伟大的成绩。如果你原理这些中心，几乎不可能单靠自己就取得伟大成果。

好设计常常是大胆的设计。

在任何一段历史中，人们都会把有些荒谬的东西当做正确的，并且深信不疑，以至于一旦你出言质疑，就有被排挤或者被暴力伤害的危险。

今天的实验性错误就是明天的新理论。如果你想做出伟大的新成果，那就不能对常会与真理不相吻合之处视而不见，反而应该特别注意才对。

大多数做出优美成果的人好像只是为了修正他们眼中丑陋的东西。伟大成果的出现常常来源于某人看到一样东西后，心想我能做的比这更好。

单单是无法容忍丑陋的东西还不够，只有对这个领域非常熟悉，你才可能发现哪些地方可以动手改进。你必须锻炼自己。只有在成为某个领域的专家之后，你才会听到心里有一个细微的声音说："这样解决太糟糕了！一定有更好的选择。"不要忽视这种声音，要培育它们。优秀作品的秘诀就是：非常严格的品位，再加上实现这种品位的能力。

<span style="color: #366092;"><strong>10.编程语言解析</strong><span style="font-family: 宋体;">
</span></span>

开放源码的优势还不仅局限于可以总计动手解决bug。这里的关键是所有人都可以参与。所以，开源软件就像一篇经受同行评议的论文。
语言之间确实有差别，但是很难确定地说哪一种语言是最好的。
如果你非常关注运行速度，那么最好使用接近机器的语言。大多数操作系统都是用C语言写的，这并非偶然。

<span style="color: #366092;"><strong>11.一百年后的编程语言</strong><span style="font-family: 宋体;">
</span></span>

一种语言的内核设计得越小、越干净，它的生命力就越顽强。

编程语言进化缓慢的原因在于它们并不是真正的技术。<span style="font-family: 宋体;">
</span>

编程语言的进化速度更像是数学符号的进化速度，而不像是真正的技术（比如交通或通信技术）的进化速度。

浪费可以分成好的浪费和坏的浪费。我所感兴趣的是好的浪费，即用更多的钱得到更简单的设计。

essay（论文）这个词来自法语的动词essayer，意思是"试试看"。从这个意义上来说，论文就是你写一篇文章，试着搞清楚某件事。软件也是如此。
我们的思想可能往往会受限于某种现存的语言，只采用在这种语言看来更简单的形式，它对我们思想的束缚作用会大得令人震惊。新语言必须靠你自己去发现，不能依靠那些让你自然而然就沉下去的思维定势。
<span style="color: #366092;"><strong>12.拒绝平庸</strong>
</span>

Lisp很值得学习。你掌握它以后，会感到它给你带来的极大的启发。这会大大提高你的编程水平，使你成为一个更好的程序员。尽管在实际工作中极少会用到Lisp。
<span style="color: #366092;"><strong>13.书呆子的复仇</strong></span>
<span style="color: #366092;"><strong>14.梦寐以求的编程语言</strong><span style="font-family: 宋体;">
</span></span>

<span style="color: #366092;"><strong>15.设计与研究</strong>
</span>

用户需要的设计，而不是用户要求的设计。

艺术的各个领域有着巨大的差别，但是我觉得任何一个领域的最佳作品都不能由对用户言听计从的人做出来。

让用户满意并不等于迎合用户的一切要求。用户不了解所有可能的选择，也经常弄错自己真正想要的东西。

除非设定目标用户，否则一种设计的好坏根本无从谈起。

如果目标用户群体涵盖了设计师本身，那么最有可能诞生优秀设计。
先做出原型，再逐步加工做出成品，这种方式有利于鼓舞士气，因为它使得你随时都可以看到工作的成效。<span style="font-family: 宋体;">
</span>]]></description>
			<content:encoded><![CDATA[<p><span style="color: #366092;"><strong>序 </strong><br />
</span></p>
<p>保罗·格雷厄姆有一套完整的创业哲学，他的创业公式是：</p>
<p>1.搭建原型</p>
<p>2.上线运营</p>
<p>3.收集反馈</p>
<p>4.调整产品</p>
<p>5.成长壮大</p>
<p>他认为一定要特别关注用户需要什么，这样才有办法将一个坏项目转变成好项目。他说："许多伟大的公司，一开始的时候做的都是与后来业务完全不同的事情。乔布斯创建苹果公司后的第一个计划是出售计算机零件，然后让用户自己组装，后来才变成开发苹果电脑。你需要倾听用户的声音，琢磨他们需要什么，然后就去做。"</p>
<p>创始人本身比他的创意更重要。</p>
<p>作者目的：通过这本书让普通读者理解我们所处的这个计算机时代。</p>
<p>作者试图从许许多多不同的方面解释这个时代的内在脉络，揭示它的发展轨迹，帮助你看清我们现在的位置和将来的方向。</p>
<p>想把握这个时代，就必须理解计算机。理解计算机的关键，则是要理解计算机背后的人。</p>
<p>我们的时代是程序员主导的时代，而伟大的程序员就是黑客。</p>
<p>根据理查德·斯托尔曼的说法，黑客行为必须包含三个特点：好玩、高智商、探索精神。<br />
黑客价值观的核心原则可以概括成这样几点：分享、开放、民主、计算机的自由使用、进步。</p>
<p>《黑客与画家》这个书名就是在提示应该把黑客与画家当做同一种人看待。和画家一样，黑客只是怀有一门特殊手艺、有创造天赋的普通人。这个书名还有另外一层含义，即编程时一种艺术创作，黑客就是艺术家，开发软件与画家作画、雕塑家雕刻、建筑师设计房屋并没有本质不同。<br />
<span style="color: #366092;"><strong>1.为什么书呆子不受欢迎</strong><br />
</span></p>
<p>校园生活的真正问题是空虚。</p>
<p>学校是一个很奇怪的、人为设计出来的体系，一半像是无菌室，一般像是野蛮洪荒之地。</p>
<p><span style="color: #366092;"><strong>2.黑客与画家</strong><br />
</span></p>
<p>黑客与画家的共同之处，在于他们都是创作者。与作曲家、建筑师、作家一样，黑客和画家都是试图创作出优秀的作品。他们本质上都不是在做研究，虽然在创作过程中，他们可能会发现一些新技术。</p>
<p>创造优美食物的方式往往不是从头做起，而是在现有成果的基础上做一些小小的调整，或者将已有的观点用比较新的方式组合起来。这种类型的工作很难用研究性的论文表达。<br />
如果黑客认识到自己与其他创作者——比如作家和画家——是一类人，这种诱惑对他就不起作用。作家和画家没有"对数学的嫉妒"，他们认为自己在从事与数学完全不相关的事情。我认为，黑客也是如此。<br />
黑客如何才能做自己喜欢的事情？我认为这个问题的解决方法是一个几乎所有创作者都知道的方法：找一份养家糊口的"白天工作"。</p>
<p>几乎所有的创作者在职业生涯早期都有一份"白天工作"。<br />
从画家身上，我们还能借鉴到什么对黑客的启示呢？</p>
<p>画家学习绘画的方法主要是动手去画，黑客学习编程的方法也理应如此。</p>
<p>创作者的另一个学习的途径是通过范例。</p>
<p>开源运动最鲜为人知的优点之一，就是使得学习编程变得更容易了。</p>
<p>你不能盼望先有一个完美的规格设计，然后再动手编程，这样想是不现实的。如果你预先承认规格设计是不完美的，在编程的时候，就可以根据需要当场修改规格，最终会有一个更好的结果。<br />
一幅优秀的作品必须比它应该有的样子更好。</p>
<p>坚持一丝不苟，就能取得优秀的成功。因为那些看不见的细节累加起来，就变得可见了。</p>
<p>就像绘画作品一样，大多数软件是为人类用户准备的。所以，黑客必须像画家一样，时刻考虑到用户的人性需要，这样才能做出伟大的产品。</p>
<p>普通黑客和优秀黑客的所有区别之中，会不会"换位思考"可能是最重要的单个因素。</p>
<p>判断一个人是否具备"换位思考"的能力有一个好方法，那就是看他怎样向没有技术背景的人解释技术问题。</p>
<p>"程序写出来是给人看的，附带能在机器上运行。"</p>
<p style="margin-left: 27pt;">——《计算机程序的结构和解释》</p>
<p><span style="color: #366092;"><strong>3.不能说的话</strong><br />
</span></p>
<p>流行一时的不仅有衣服，还有道德观念。<br />
训练自己去想那些不能想的事情，你获得好处会超过所得到的想法本身。</p>
<p><span style="color: #366092;"><strong>4.良好的坏习惯</strong><span style="font-family: 宋体;"><br />
</span></span></p>
<p>不服从管教，其实是黑客之所以成为优秀程序员的原因之一。</p>
<p>只有深入了解当前的技术，黑客才能构想下一代技术。<br />
公民自由使得国家富强.</p>
<p>如果读美国开国元勋的自述,你会发现他们听起来很像黑客。"反抗政府的精神，"杰弗逊写道，"在某些场合是如此珍贵，我希望它永远保持活跃。"<span style="font-family: 宋体;"><br />
</span></p>
<p><span style="color: #366092;"><strong>5.另一条路</strong><span style="font-family: 宋体;"><br />
</span></span></p>
<p>我认为，大量的下一代软件都将采用这个模式。甚至最大的输家——微软公司，看来也明白了，部分软件从桌面消失将是不可避免的。如果软件从桌面移到服务器上，一切将发生根本的变化。<br />
互联网软件运行在服务器上，用户界面就是网页。对于普通用户来说，使用这种新型软件将更容易、更便宜、更机动、更可靠，通常也比桌面软件更强大。</p>
<p>如果互联网软件能够击败桌面软件，一定是赢在更方便这一优势上。无论从用户的角度还是从开发者的角度来看都是如此。</p>
<p><span style="color: #366092;"><strong><em>用户的胜利</em></strong><br />
</span></p>
<p>"你的电脑"这个概念正慢慢成为过去时，取而代之的是"你的数据"。</p>
<p>不会有应用软件与操作系统不兼容的问题了。</p>
<p>适用软件将变得非常普遍、容易。</p>
<p>升级不再对用户形成大的冲击。</p>
<p>他们必须正确地设计软件，使得它能够平滑升级，不让使用者感到困惑。</p>
<p>所有用户都是用同样版本的互联网软件，bug一发现就会立刻得到纠正。</p>
<p>适合团队协作性的应用。</p>
<p>数据更安全。</p>
<p>不容易感染病毒。</p>
<p>大多数windows用户使用桌面软件的时候都感到紧张，会有相当大的心理压力，释放这种压力，对你的产品将是一种巨大的推动。<span style="font-family: 宋体;"><br />
</span></p>
<p><span style="color: #366092;"><strong><em>代码之城</em></strong><br />
</span></p>
<p>设计桌面软件就像设计一幢大楼，而设计互联网软件就像设计一座城市。</p>
<p>软件、硬件。</p>
<p>硬件需要考虑的地方，不仅仅在于怎么才能避免出现问题，还在于怎样才能最大地发挥它们 的作用。</p>
<p>1995年我们创立viaweb的时候，Java applet被认为是互联网软件的解决方案，。但是我们觉得，applet采用的还是过时的概念，它还是要求下载软件到客户端运行。</p>
<p>不同的语言适合不同的任务，你应该根据不通过场合，挑选最合适的工具。如果你不利用语言的优势，那就会听人对手超过你。</p>
<p><span style="color: #366092;"><strong><em>软件的发布</em></strong><br />
</span></p>
<p>互联网软件带来的最大变化之一，就是软件发布方式的改变。</p>
<p>软件的发布可以分解为一系列的渐进式修改，而不是猛地退出一个大幅变动的版本。</p>
<p><span style="color: #366092;"><strong><em>软件bug</em></strong><br />
</span></p>
<p>有一种编程方法叫做"函数式编程"（functional programming），对于互联网软件很有用，很难用纯粹的"函数式编程"完成整个程序，但是它可以用来编写一些重要的部分使得这些部分易于调试，因为他们不包含"状态"，非常便于不断对代码进行小幅的修改和调试。</p>
<p>实现某个构思，会带来更多的构思。所以，将一个构思束之高阁，不仅意味着延迟它的实现，还意味着延迟所有在是实现过程中激发的构思。</p>
<p>要让软件变得可靠，关键是你要全神贯注，而不是开发得很慢。</p>
<p>效率对互联网软件至关重要。<span style="font-family: 宋体;"><br />
</span></p>
<p>如果软件效率足够高，每个用户的硬件成本现在可以接近免费。</p>
<p>如果新事物真的有重大改进，那么它总是可以找到生存空间的。</p>
<p>你完全能够在只有三个人的情况下让产品开始运营。</p>
<p>桌面软件迫使用户变成系统管理员，互联网软件则是迫使程序员变成系统管理员：用户的压力变小了，程序员的压力变大了。</p>
<p>由于互联网软件的程序员非常辛苦，所以会使得经济优势根本性地从大公司向创业公司转移。互联网软件要求的那种工作强度和付出，只有当公司是其本人所有时，程序员才愿意提供。</p>
<p>因为互联网软件的创业不需要太多的资本，所以大公司可以与创业公司竞争的优势就所剩无几了。</p>
<p>互联网做起来很辛苦，还有许多特别大的压力，但是它们的唯一作用，就是使得创业公司成功的机会变大。</p>
<p><span style="color: #366092;"><strong><em>为什么不尝试一下？</em></strong><br />
</span></p>
<p>如果你是一个黑客，并且梦想自己创业，可能会有两件事情令你望而却步，不敢真正开始采取行动。一件是你不懂得管理企业，另一件是你害怕竞争。可是实际上，这两件事都没有通电的篱笆。</p>
<p>首先，管理企业其实很简单，只要记住两点就可以了：做出用户喜欢的产品，保证开支小于收入。<span style="font-family: 宋体;"><br />
</span></p>
<p>开支：勤俭节约；编写一个互联网软件是非常便宜的。</p>
<p>如何做出用户喜欢的产品</p>
<p style="margin-left: 27pt;">从制造简洁的产品开始着手，首先要保证你自己愿意使用。然后，迅速地做出1.0版，并且不断加以改进，整个过程中密切倾听用户的反馈。</p>
<p style="margin-left: 27pt;">无论何时，你都要使用自己的软件。</p>
<p style="margin-left: 27pt;">不要只因为对方的头衔是市场专家、设计师或产品经理，就盲目听从他们的话。如果他们的观点真的很好，那就听从他们，关键是你要自己判断，不要盲从。只有懂得设计的黑客，才能设计软件，不能交给对软件一知半解的设计师。</p>
<p style="margin-left: 27pt;">如果你不打算自己动手设计和开发，那就不要创业。</p>
<p>其次，竞争。大公司害怕你胜过你害怕他们。</p>
<p><span style="color: #366092;"><strong>6.如何创造财富</strong><br />
</span></p>
<p>如果你想致富，应该怎么做？我认为最好的办法就是自己创业，或者加入创业公司。</p>
<p>如果你想赚100万美元，就不得不忍受相当于100万美元的痛苦。</p>
<p>任何公司的成功历程中，运气都是一个很大的随机因素。</p>
<p>通过创造有价值的东西而致富，这种方法的优势不仅仅在于它是合法的，还在于它更简单。</p>
<p>财富和金钱并不是同义词。财富才是你的目标，金钱不是。</p>
<p>人们觉得做生意就是为了挣钱，但是金钱其实只是一种中介，让大家可以更方便地获得自己想要的东西。大多数生意的目的是为了创造财富，做出人们真正想要的东西。</p>
<p>人们需要的东西就是财富。</p>
<p>公司就是许多人聚在一起创造财富的地方，能够制造更多人们需要的东西。</p>
<p>我们这个世界，你向下沉沦或者向上奋进都取决于你自己，不能把原因推给外界。<br />
"你需要去做一些人们需要的东西"。即使不加入公司，你也能做到。真正重要的是做出人们需要的东四，而不是加入某个公司。</p>
<p>工作就是在一个组织中，与许多人共同合作，做出某种人们需要的东西。</p>
<p><span style="color: #366092;"><strong><em>可测量性和可放大性</em></strong><br />
</span></p>
<p>要致富，你需要两样东西：可测量性和可放大性。</p>
<p style="margin-left: 27pt;">业绩可以测量；你做出的决定能够产生巨大的效应。</p>
<p>如果你有一个令你感到安全的工作，你是不会致富的，因为没有危险，就几等于没有可放大性。</p>
<p>如果你想同时具备可测量性和可放大性，不一定非当上CEO或电影明星不可。你只需要成为某个攻克难题的小团体的一部分就可以了。</p>
<p><span style="color: #366092;"><strong><em>小团体=可测量性</em></strong><br />
</span></p>
<p>这就是创业公司的真正意义。理想情况下，你与其他愿意更努力工作的人一起组成一个团队，共同谋取更高的回报。<br />
创业公司的成败取决于最早加入公司的那十个人。（乔布斯）</p>
<p>我们不需要小村庄的那种"小"，而需要全明星第一阵容的那种"小"。</p>
<p><span style="color: #366092;"><strong><em>高科技=可放大性</em></strong><br />
</span></p>
<p>什么是技术？技术就是某种手段，就是我们做事的方式。</p>
<p>如果你解决了一个热门的技术问题，别人都会使用你的解决方案。这就是可放大性。<br />
创业公司如同蚊子，往往只有两种结局，要么赢得一切，要么彻底消失。你通常不知道自己会是哪一个结局，只有等到最后一刻才会明了。</p>
<p>你开办创业公司不是单纯地为了解决问题，而是为了解决那些用户关系的问题。</p>
<p>你必须时刻牢记的最基本的原则就是，创造人们需要的东西，也就是创造财富。如果你想通过创造财富使得自己致富，那么你必须知道人们需要什么。</p>
<p><span style="color: #366092;"><strong><em>财富和权力</em></strong><br />
</span></p>
<p>没有财富的激励，技术革新就会逐渐停顿。<br />
为什么欧洲在历史上变得如此强大：可能是因为允许赚到大钱的人保住自己的财富。<br />
要鼓励大家去创业。只要懂得藏富于民，国家就会变得强大。让书呆子保住他们的血汗钱，你就会无敌于天下。</p>
<p><span style="color: #366092;"><strong>7.关注贫富分化</strong></span><br />
<span style="color: #366092;"><strong>8.防止垃圾邮件的一种方法</strong><span style="font-family: 宋体;"><br />
</span></span></p>
<p><span style="color: #366092;"><strong>9.设计者的品位</strong><span style="font-family: 宋体;"><br />
</span></span></p>
<p>如果你是一个设计师，并且你不承认有一种人们共同认可的东西叫做"美"，那么你就没有办法做好工作。如果品位只是一种个人偏好，那么每个人都是完美无缺的：你喜欢自己看上的东西，那就足够了。</p>
<p>众多不同学科对"美"的认识有着惊人的相似度。优秀设计的原则是许多学科的共同原则，一再反复地出现。<br />
好设计是简单的设计。</p>
<p>有人会说，简单就是事物本来的样子，装饰反而意味着更多的工作。但是，当人们自己从事创造性工作的时候，好像就会忘了保持简单这个原则。刚开始写作的人喜欢用浮夸的语调，</p>
<p>根本不像他们平时说话的样子。设计师喜欢用波浪式卷曲表现他们的艺术感。画家发现自己都是表现主义者。这些装饰都是花架子，在作家的长句、画家"表现主义"的画笔之下，根本就是空洞无物，表面的掩饰掩盖了内部的空虚，太可怕了。</p>
<p>当你被迫把东西做的简单时，你就被迫直接面对真正的问题。当你不能用表面的装饰交差时，你就不得不做好真正的本质部分。<br />
好设计是永不过时的设计。</p>
<p>说来奇怪，如果你希望自己的作品对未来的人们有吸引力，方法之一就是让你的作品对上几代人有吸引力。</p>
<p>好设计是解决主要问题的设计。</p>
<p>eg：厨房的煤气灶，四个出火口和调节器的位置摆放。</p>
<p>eg：字体的设计。<br />
好设计是启发性的设计。</p>
<p>eg：英国女作家简奥斯丁的作品：几乎不带有任何描述。</p>
<p>eg：《蒙娜丽莎》：启发式的绘画</p>
<p>一个建筑或一个物品应该允许你按照自己的愿望来使用。</p>
<p>你应该为用户提供一些基本模块，使得他们可以随心所欲自由组合，就像玩乐高积木那样。</p>
<p>好设计通常是有点趣味性的设计。</p>
<p>这是因为幽默一定程度上反映了力量。幽默感是强壮的一种表现，始终拥有幽默感就代表你对厄运一笑了之，而丧失幽默感则表示你被厄运深深伤到。所以，强壮的标志（或者至少是特点）就是轻松面对自己的人生。充满自信的人常常像燕子一样，以一种居高临下的姿态轻盈的看待周围的一切，比如希区柯克拍摄的电影、16世纪画家布勒哲的绘画（甚至莎士比亚也是一个这方面的例子）。</p>
<p>好设计是艰苦的设计。</p>
<p>如果观察那些做出伟大作品的人，你会发现他们的共同点就是工作得非常艰苦。如果你工作得不艰苦，你可能正在浪费时间。</p>
<p>功能决定形式：如果开发"功能"非常艰难，那么"形式"将不得不全部都由"功能"决定，因为没有多余的精力再来单独开发"形式"了。</p>
<p>好设计是看似容易的设计。<span style="font-family: 宋体;"><br />
</span></p>
<p>作家的文章看起来流畅自如，但是背后其实经过了反复修改。</p>
<p>科学和工程学的一些最重大的发现在形式上往往很简单，会使得你觉得自己也想到过。</p>
<p>在大多数领域，看上去容易的事，背后都需要大量的练习。练习的作用也许是训练你把可以为之的事情变成一种自觉的行为。</p>
<p>好设计是对称的设计<br />
好设计是模仿大自然的设计。</p>
<p>模仿与剽窃并不相同。</p>
<p>好设计是一种再设计。</p>
<p>很少有人一次就把事情做对。专家的做法是先完成一个早期原型，然后提出修改计划，最后把早期原型扔掉。</p>
<p>你应该培养对自己的不满。达芬奇为了把一根线画对，经常要画五六次。</p>
<p>犯错误是很正常的事情。你不要把犯错误看成灾难，要用于承认、用于改正。开源软件因为公开承认自己会有bug，反而使得代码的bug比较少。<br />
好设计是能够复制的设计。</p>
<p>把事情做对比原创更重要。</p>
<p>等你逐渐对一件事产生热情的时候，就不会满足于模仿了。你的品位就进入了第二阶段，开始自觉地进行原创。</p>
<p>我想，最伟大的大师最终会达到一种超脱自我的境界。他们一心想找到正确答案，如果别人已经回答了一部分，那就没理由不拿来用。他们足够自信地使用他人的成功，完全不担心因此丧失个人的特点。<br />
好设计常常是奇怪的设计。</p>
<p>eg:Lisp，黑鸟超音速侦察机；《雪中猎人》</p>
<p>eg:爱因斯坦并不像让相对论变得很奇特，他只想找出真理，是真理本身显得很奇特。</p>
<p>唯一达到"奇特"的方法，就是追求做出好作品，完成之后再回过头看。<br />
好设计师成批出现的。<span style="font-family: 宋体;"><br />
</span></p>
<p>eg:15世纪的弗洛伦萨涌现一大批伟大艺术家。</p>
<p>推动人才成批涌现的最大因素就是，让有天赋的人聚在一起，共同解决某个难题。互相激励比天赋更重要。</p>
<p>在历史上的任何时刻都有一些热点项目，一些团体在这些项目上做出伟大的成绩。如果你原理这些中心，几乎不可能单靠自己就取得伟大成果。</p>
<p>好设计常常是大胆的设计。</p>
<p>在任何一段历史中，人们都会把有些荒谬的东西当做正确的，并且深信不疑，以至于一旦你出言质疑，就有被排挤或者被暴力伤害的危险。</p>
<p>今天的实验性错误就是明天的新理论。如果你想做出伟大的新成果，那就不能对常会与真理不相吻合之处视而不见，反而应该特别注意才对。</p>
<p>大多数做出优美成果的人好像只是为了修正他们眼中丑陋的东西。伟大成果的出现常常来源于某人看到一样东西后，心想我能做的比这更好。</p>
<p>单单是无法容忍丑陋的东西还不够，只有对这个领域非常熟悉，你才可能发现哪些地方可以动手改进。你必须锻炼自己。只有在成为某个领域的专家之后，你才会听到心里有一个细微的声音说："这样解决太糟糕了！一定有更好的选择。"不要忽视这种声音，要培育它们。优秀作品的秘诀就是：非常严格的品位，再加上实现这种品位的能力。</p>
<p><span style="color: #366092;"><strong>10.编程语言解析</strong><span style="font-family: 宋体;"><br />
</span></span></p>
<p>开放源码的优势还不仅局限于可以总计动手解决bug。这里的关键是所有人都可以参与。所以，开源软件就像一篇经受同行评议的论文。<br />
语言之间确实有差别，但是很难确定地说哪一种语言是最好的。<br />
如果你非常关注运行速度，那么最好使用接近机器的语言。大多数操作系统都是用C语言写的，这并非偶然。</p>
<p><span style="color: #366092;"><strong>11.一百年后的编程语言</strong><span style="font-family: 宋体;"><br />
</span></span></p>
<p>一种语言的内核设计得越小、越干净，它的生命力就越顽强。</p>
<p>编程语言进化缓慢的原因在于它们并不是真正的技术。<span style="font-family: 宋体;"><br />
</span></p>
<p>编程语言的进化速度更像是数学符号的进化速度，而不像是真正的技术（比如交通或通信技术）的进化速度。</p>
<p>浪费可以分成好的浪费和坏的浪费。我所感兴趣的是好的浪费，即用更多的钱得到更简单的设计。</p>
<p>essay（论文）这个词来自法语的动词essayer，意思是"试试看"。从这个意义上来说，论文就是你写一篇文章，试着搞清楚某件事。软件也是如此。<br />
我们的思想可能往往会受限于某种现存的语言，只采用在这种语言看来更简单的形式，它对我们思想的束缚作用会大得令人震惊。新语言必须靠你自己去发现，不能依靠那些让你自然而然就沉下去的思维定势。<br />
<span style="color: #366092;"><strong>12.拒绝平庸</strong><br />
</span></p>
<p>Lisp很值得学习。你掌握它以后，会感到它给你带来的极大的启发。这会大大提高你的编程水平，使你成为一个更好的程序员。尽管在实际工作中极少会用到Lisp。<br />
<span style="color: #366092;"><strong>13.书呆子的复仇</strong></span><br />
<span style="color: #366092;"><strong>14.梦寐以求的编程语言</strong><span style="font-family: 宋体;"><br />
</span></span></p>
<p><span style="color: #366092;"><strong>15.设计与研究</strong><br />
</span></p>
<p>用户需要的设计，而不是用户要求的设计。</p>
<p>艺术的各个领域有着巨大的差别，但是我觉得任何一个领域的最佳作品都不能由对用户言听计从的人做出来。</p>
<p>让用户满意并不等于迎合用户的一切要求。用户不了解所有可能的选择，也经常弄错自己真正想要的东西。</p>
<p>除非设定目标用户，否则一种设计的好坏根本无从谈起。</p>
<p>如果目标用户群体涵盖了设计师本身，那么最有可能诞生优秀设计。<br />
先做出原型，再逐步加工做出成品，这种方式有利于鼓舞士气，因为它使得你随时都可以看到工作的成效。<span style="font-family: 宋体;"><br />
</span></p>
<div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://manan.org/2011/01/book_review_programmers_self_discipline/" title="提高自我修养，成为卓越的程序员——读《程序员的自我修养》">提高自我修养，成为卓越的程序员——读《程序员的自我修养》</a></li><li><a href="http://manan.org/2012/05/book_note_comparative_politics_analysis/" title="Book note:《比较政治分析》">Book note:《比较政治分析》</a></li><li><a href="http://manan.org/2012/05/book_note_a_short_history_of_chinese_philosophy/" title="Book note:《中国哲学简史》思维导图">Book note:《中国哲学简史》思维导图</a></li><li><a href="http://manan.org/2012/04/windows_makefile_tutorial/" title="windows下使用makefile示例">windows下使用makefile示例</a></li><li><a href="http://manan.org/2012/01/book_note_iwoz/" title="Book note：《我是沃兹》">Book note：《我是沃兹》</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://manan.org/2011/12/book_note_hackers_and_painters/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>一升庵经营之道</title>
		<link>http://manan.org/2011/12/liao_li_xian_ji/</link>
		<comments>http://manan.org/2011/12/liao_li_xian_ji/#comments</comments>
		<pubDate>Sun, 11 Dec 2011 15:22:50 +0000</pubDate>
		<dc:creator>Little Horse</dc:creator>
				<category><![CDATA[01.读书]]></category>
		<category><![CDATA[个人提升]]></category>
		<category><![CDATA[学习]]></category>

		<guid isPermaLink="false">http://xiaoma.me/2011/12/%e4%b8%80%e5%8d%87%e5%ba%b5%e7%bb%8f%e8%90%a5%e4%b9%8b%e9%81%93-2/</guid>
		<description><![CDATA[作为吃货一枚，对和饮食有关的影视作品有爱应该是很好理解的。在家看电视时，有些美食节目也会让我停下飞快换频道的手指。
<p style="text-align: center;"><img src="http://manan.org/wp-content/uploads/2011/12/121111_1522_1.png" alt="" /><span style="font-size: 12pt;">
</span></p>
看完《深夜食堂》后继续寻找，找到的第二部以食物为主题的剧集是同样来自日本的《料理仙姬》。故事并不复杂，讲述坚持传统的日本料理店一升庵里的大小事情，每集一个主题。抱着娱乐的心态来看，却从料理店的年轻老板娘半田仙（苍井优饰演）身上学到一些为人处事的道理：

1.让对方吃到美好食物的心情最重要。

这部剧给我留下最深印象的不是具体烹制食物的技法，而是工作反映出的态度。阿仙制作料理时自然发出的微笑以及对食物喃喃说出的"变得更好吃啊"，透露出她对料理制作的热爱。她几次提到，让对方吃到美好食物的心情是最重要的，这话语里是爱人之心。出于爱，还是利润，还是炫技，效果会不同，因为这背后反映出不同的动机：为己还是为人。

2.对专业极致、完美的追求。

这其实是个老话题了，日本是个特别善于在某种技艺上极致追求并且取得巨大成就的国家，令人尊敬。茶道、剑道、插花等早已是日本文化象征，本剧中同样表现了这种文化：做味增时一粒粒的挑选黄豆，切食材时刀法一丝不苟，修缮房屋的木工世代传承……我从他们身上看到了敬业和对职业的自豪感。
<p style="text-align: center;"><img src="http://manan.org/wp-content/uploads/2011/12/121111_1522_2.png" alt="" /><span style="font-size: 12pt;">
</span></p>
3.对标准的严格要求，不妥协。

极致的追求有时也会遇到现实的困难：从来都用稻草烧的米饭遇到了稻草耗尽的局面，是用柴应付过去、反正差别不大，还是坚持品质？

阿仙选择了坚持，因为一次放松就无法挽回。

4.人情练达。<span style="font-family: 宋体;">
</span>

一家成功的料理店不是有了好食物就能开起来的，会遇到形形色色的困难，也要和方方面面打交道。

给一升庵提供稻米原料的店铺两代老板父子间略有隔阂，随着年老父亲的身体衰弱，继承家业的儿子不再像以往一样供给最好的稻米，一升庵面临食材品质降低的风险。阿仙给稻米店送去精心制作的饭团，在稻米的香味中，父子间多了理解，原料危机也化于无形。

貌似粗鲁的卡车司机们来到店里大吃大喝，让人皱眉，可是善良的半田仙仍然尽力款待，没有区别心。正是这些无意交来的朋友，在一升庵的原料危机中帮忙运输，拯救了困局。

5.关注细节。<span style="font-family: 宋体;">
</span>

阿仙为前来赴宴的相亲对象定制了合适手型的筷子，而对方的手型只是在偶然一次握手时感知到的。这让男方感动不已，并且意识到自己和半田仙不在同一水平线上，甘愿退出继续磨练自我。（但是，阿仙需要的真的是同一境界的男人吗？还是一个满足她像普通女孩一样去吃汉堡愿望的、关心她的男人？）

6.团队管理。<span style="font-family: 宋体;">
</span>

团队成员关系的协调。店里的学徒小留为了炫技擅自在外做菜，违反了店规，大师傅清二要开除小留，而小留工作一直没有问题，罪不至此，拥有决定权的半田仙在两难中会怎样做呢？出人意料，他同意了表面提出请辞其实希望留下的小留辞职。经过几个月的反省，小留在阿仙的帮助下领悟了给对方提供美好食物不应炫技的道理，并用已经提高的厨艺在清师傅前证明了自己。此时，阿仙才正式向清师傅提出请求，接受小留回归。遵循了原则，化解了矛盾，维护了团结，并解决问题，真是智慧地处理。

团队激励：负责烧制米饭的小晴一直认真工作，但面对往昔同窗的质疑，开始怀疑自己的价值。阿仙请小晴给稻米店送去米饭制成的饭团，使她从稻米店老板对饭团的称赞与感动中体会工作的价值。阿仙拜托小晴的话语十分恳切："小晴，以后还要拜托你煮出美味的米饭啊，不管谁说什么，一升庵不能没有小晴，因为你是煮饭名人。"真诚地赞美，让团队成员明白自己的重要性。

在追求快捷、效率成为时代主题时，一升庵显得那么固执。这是半田仙的选择：不是被时代留在原地，而是选择不变。单纯无邪的笑容下是真正的大智若愚。
<p style="text-align: center; margin-left: 27pt;"><img src="http://manan.org/wp-content/uploads/2011/12/121111_1522_3.png" alt="" /></p>]]></description>
			<content:encoded><![CDATA[<p>作为吃货一枚，对和饮食有关的影视作品有爱应该是很好理解的。在家看电视时，有些美食节目也会让我停下飞快换频道的手指。</p>
<p style="text-align: center;"><img src="http://manan.org/wp-content/uploads/2011/12/121111_1522_1.png" alt="" /><span style="font-size: 12pt;"><br />
</span></p>
<p>看完《深夜食堂》后继续寻找，找到的第二部以食物为主题的剧集是同样来自日本的《料理仙姬》。故事并不复杂，讲述坚持传统的日本料理店一升庵里的大小事情，每集一个主题。抱着娱乐的心态来看，却从料理店的年轻老板娘半田仙（苍井优饰演）身上学到一些为人处事的道理：</p>
<p>1.让对方吃到美好食物的心情最重要。</p>
<p>这部剧给我留下最深印象的不是具体烹制食物的技法，而是工作反映出的态度。阿仙制作料理时自然发出的微笑以及对食物喃喃说出的"变得更好吃啊"，透露出她对料理制作的热爱。她几次提到，让对方吃到美好食物的心情是最重要的，这话语里是爱人之心。出于爱，还是利润，还是炫技，效果会不同，因为这背后反映出不同的动机：为己还是为人。</p>
<p>2.对专业极致、完美的追求。</p>
<p>这其实是个老话题了，日本是个特别善于在某种技艺上极致追求并且取得巨大成就的国家，令人尊敬。茶道、剑道、插花等早已是日本文化象征，本剧中同样表现了这种文化：做味增时一粒粒的挑选黄豆，切食材时刀法一丝不苟，修缮房屋的木工世代传承……我从他们身上看到了敬业和对职业的自豪感。</p>
<p style="text-align: center;"><img src="http://manan.org/wp-content/uploads/2011/12/121111_1522_2.png" alt="" /><span style="font-size: 12pt;"><br />
</span></p>
<p>3.对标准的严格要求，不妥协。</p>
<p>极致的追求有时也会遇到现实的困难：从来都用稻草烧的米饭遇到了稻草耗尽的局面，是用柴应付过去、反正差别不大，还是坚持品质？</p>
<p>阿仙选择了坚持，因为一次放松就无法挽回。</p>
<p>4.人情练达。<span style="font-family: 宋体;"><br />
</span></p>
<p>一家成功的料理店不是有了好食物就能开起来的，会遇到形形色色的困难，也要和方方面面打交道。</p>
<p>给一升庵提供稻米原料的店铺两代老板父子间略有隔阂，随着年老父亲的身体衰弱，继承家业的儿子不再像以往一样供给最好的稻米，一升庵面临食材品质降低的风险。阿仙给稻米店送去精心制作的饭团，在稻米的香味中，父子间多了理解，原料危机也化于无形。</p>
<p>貌似粗鲁的卡车司机们来到店里大吃大喝，让人皱眉，可是善良的半田仙仍然尽力款待，没有区别心。正是这些无意交来的朋友，在一升庵的原料危机中帮忙运输，拯救了困局。</p>
<p>5.关注细节。<span style="font-family: 宋体;"><br />
</span></p>
<p>阿仙为前来赴宴的相亲对象定制了合适手型的筷子，而对方的手型只是在偶然一次握手时感知到的。这让男方感动不已，并且意识到自己和半田仙不在同一水平线上，甘愿退出继续磨练自我。（但是，阿仙需要的真的是同一境界的男人吗？还是一个满足她像普通女孩一样去吃汉堡愿望的、关心她的男人？）</p>
<p>6.团队管理。<span style="font-family: 宋体;"><br />
</span></p>
<p>团队成员关系的协调。店里的学徒小留为了炫技擅自在外做菜，违反了店规，大师傅清二要开除小留，而小留工作一直没有问题，罪不至此，拥有决定权的半田仙在两难中会怎样做呢？出人意料，他同意了表面提出请辞其实希望留下的小留辞职。经过几个月的反省，小留在阿仙的帮助下领悟了给对方提供美好食物不应炫技的道理，并用已经提高的厨艺在清师傅前证明了自己。此时，阿仙才正式向清师傅提出请求，接受小留回归。遵循了原则，化解了矛盾，维护了团结，并解决问题，真是智慧地处理。</p>
<p>团队激励：负责烧制米饭的小晴一直认真工作，但面对往昔同窗的质疑，开始怀疑自己的价值。阿仙请小晴给稻米店送去米饭制成的饭团，使她从稻米店老板对饭团的称赞与感动中体会工作的价值。阿仙拜托小晴的话语十分恳切："小晴，以后还要拜托你煮出美味的米饭啊，不管谁说什么，一升庵不能没有小晴，因为你是煮饭名人。"真诚地赞美，让团队成员明白自己的重要性。</p>
<p>在追求快捷、效率成为时代主题时，一升庵显得那么固执。这是半田仙的选择：不是被时代留在原地，而是选择不变。单纯无邪的笑容下是真正的大智若愚。</p>
<p style="text-align: center; margin-left: 27pt;"><img src="http://manan.org/wp-content/uploads/2011/12/121111_1522_3.png" alt="" /></p>
<div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://manan.org/2010/10/learn-from-cooperation/" title="在合作中学习">在合作中学习</a></li><li><a href="http://manan.org/2011/03/mobile_search_literature_research/" title="Mobile Search文献调研">Mobile Search文献调研</a></li><li><a href="http://manan.org/2011/03/computer_science_knowledge_hierarchy/" title="计算机科学的知识体系">计算机科学的知识体系</a></li><li><a href="http://manan.org/2010/12/%e5%8d%9a%e5%ae%a2%e7%9a%84%e7%89%88%e6%9d%83%e9%97%ae%e9%a2%98%e8%b0%83%e7%a0%94/" title="博客的版权问题调研">博客的版权问题调研</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://manan.org/2011/12/liao_li_xian_ji/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>

