博客园_助人为乐

谈谈如何从本质上理解sql语句, 存储过程，ORM之间的联系和取舍。

2011-05-13T07:34:00Z

sql语句又叫ad hoc sql, ad hoc是拉丁语，意思是for this,可以翻译为“按每一次情况的办理”
存储过程就是stored procedure, 简写为sp
ORM就是对象-关系映射，比如Hibernate

大多数的.NET程序都是会围绕sql服务器展开，经常要面临在这些技术间进行选择。所以我们需要来理解这些技术的本质。

一，演变
刚开始的时候，只有sql语句，即可以用交互模式一句一句执行，也可以用批模式执行，多行sql语句一次提交执行。
很快人们发现用批模式执行的一堆sql语言可以用过程的形式，事先存放到数据库里面，这就变成了存储过程。
随着面向对象技术的成熟，从程序中可以自动生成sql语句，这就是ORM

二，性能
很多人会说存储过程比sql语句性能好，其实这个说法并不精确。
如果我们把一堆sql，以批的方式一次送入到服务器，那么服务器，会对这一堆sql进行缓存，当下一次再度执行的时候，就好像调用一个”匿名“的存储过程一样。
在这种情况下，性能差不多。
但是，如果我们不注意，很有可能，把可以一次提交的sql,变成了多次提交，甚至是每个循环做了一次提交，那么性能就很差了。
也就是说如果使用sql,只要写法得当，性能和sp区别不大。
同样的道理，ORM的性能取决于ORM的Sql生成算法，和用户使用的时候，对生成算法的控制，比如利用好Lazy laoding等，在某些情况下，甚至可以不通过sql,毕竟没有sql比最优化的sql还要快。

三，可维护性
可维护性是选择sql,sp,orm最主要的因素。
这里面有点”玄“，因为不同的场景会得出不同的结论，俗称“It depends"
刚开始的时候，sql的维护性看起来是最差，因为它往往散布在程序的每个角落。而存储过陈都放在数据库中，有清晰接口。
但是如果我们做一次重构，情况居然会颠倒过来。
首先，存储过程完全可以照搬到C#中，sp的名字直接变成method的名字，sp的参数表直接变成method的参数表，（其实就是Command模式）。
其次，把这些methdod放到一个文件或者文件夹中。（所谓的DAL层，如果喜欢层的话）
通过这个重构，我们获得了以下的好处，

1，首先是过程的调用和过程的定义放到了一起，修改起来比较方便。IDE都有定义跳转功能。
2，过程的调用和定义同时进行版本控制，不会出现不匹配的情况。减少了sp的参数表和调用的不匹配，包括拼写，类型，参数次序
3，单元测试非常方便

当然sp也有存在的价值，比如所谓的安全性，后面会提到。比如友好的调试环境，对于中小型项目，和初级程序员来说，也是很好的选择。

ORM则将可维护性提升身到了一个新的高度，它试图将sql屏蔽起来，在操作对象的同时，自动就把数据库的事情给办了。
ORM有两种模式，一种是ActiveRecord, 一种是Datamapper，前者从数据库中读取定义，后者在程序中定义。不过由于前者往往用migration来生成数据库，其实也是定义在程序里面的。好的ORM都有"leaking"的设计，也就是留了个”后门“，让你有机会用sql来控制。

微软的linq从某个角度类说，也是一种ORM, 它的设计思想可能是因为它觉得写sql语句比写c#代码效率高，所以提供直接在C#中写sql语句的机制，再自动生成真正的sql。不过，ORM真正价值在于它可以在恰当的时候，完全抛弃sql,比如比如读用cache,写用queue。而微软的linq，完全是“无厘头”的风格，在O中用R的写法，难道是RRM，唯一的好处只是锁定程序和程序员在微软的平台上。

三，安全性

对企业来说，安全性有的时候比性能更重要，由于存储过程在数据库上多加了一道屏障，所以很多企业会把存储过程作为首选。
ORM可以说是安全性最差的，因为只有到程序运行起来，你才能知道，会产生什么样的sql。
但是保证安全有许多方法和方面，比如部署前的测试，数据库的备份，对表的权限的设置。等。用sp来保证安全，只是多个选项中的一个。
在startup型企业中，高级程序员往往起到主导作用，所以他们会不犹豫的选择ORM。
在传统企业中，如果DBA或者技术主管比较强势，往往会采用sp。

本文链接

谈谈C#程序员从本质上掌握javascript的面向对象特性

2011-04-06T06:53:00Z

javascirpt是和C#有着相当不同的语言，C#是面向类的静态编程语言（这里暂不考虑C# 4.0添加的动态特性），而javascript是面向对象的函数式编程语言。
虽然C#和javascript差别很大，但是我们还有可能利用已经掌握的技能来加速对新技能的掌握。

一、javascirpt面向对象特性。
C#是面象类的。它通过“2步法”来获得一个可以操做的对象。首先通过class关键字来定义一个类，然后通过new关键字获得一个对象。这包含了以下几层意思。
1，首先我们需要定义一个对象的结构，这就是类
2，我们通过这个结构，赋予状态来获得一个对象（或者叫实例对象）
3，在使用new关键字的时候，系统会调用一个构造函数，来给对象赋予一个初始状态。
总结： C#需要先决定对象的结构，然后再决定对象的状态，并且在决定了对象的状态后，不允许再改变对象的结构。所谓的“2步法”就是先结构，后状态。且有了状态后，结构不允许再发生变动。

javascript可以采用“1步法”，也就是说决定结构和状态的操作在同一个步骤内完成。
例如 cat.color="while", 这个操作在给对象添加了一个叫color（颜色）的结构的同时，赋予了"white"(白色)这个属性。而上面这个操作是在程序的任何地方使用的。
由于使用“1步法",类的存在就没有了意义。只要我们有了一个对象，我们就可以随时随地给对象同时添加结构和状态，或者叫属性和赋值。（如果硬要套上类的概念的话，那么javasciprt里面的类是不停地在变化的)
在C#中new关键字是产生一个对象唯一手段，在javascript中new关键字只是产生一个对象的2个方式中的一种。
第一种产生一个对象的方式是使用“{}"操作符。
baby={};
singer={name:"张学友“，sex: "男“}
第1个对象没有什么结构，第2个对象有名有性。以后我们还可以添加其他属性。
到这里你也许会问，有了那么方便的产生对象的“{}"操作符，为什么还需要 new关键字呢？
利用new关键字，可以调用一个函数（即构造函数，或者叫constructor)来完成构建对象的动作，从而获得“2步法“的效果。
比如
function Person(name,sex) {
this.name=name;
this.sex =sex;
}
singer=new Person("张学友"，”男"）

这里虽然看上去和c#的写法很象，似乎采用了“2步法“，Person函数定义了结构，new语句赋予了状态。但是这个“2步法“和C#的“2步法“有所区别，因为它的"2步“不是很严格的“2步”。

如果我们把构造里面的语句注释掉，换成：
function Person(name,sex) {
// this.name=name;
// this.sex =sex;
}
singer=new Persion()
singer.name="张学有"
singer.sex="男“

最后得到的singer对象和前例得到的singer对象完全相同。
我们可以自由的把定义结构的第一步，移出构造函数，仍然使用“1步法“来获得等价的效果。
由于javascript可以随时通过“1步法”同时添加结构和状态，因此使用“{}"还是使用“new"来产生新对象，可以按照实际需求来自由选择了（很free吧）。

二，javascript的继承。
由于javascript的对象构建采用了“1步法“，同时添加结构和状态，所以javascript的继承也是“同步”的，同时继承结构和状态。
在C#中，是通过类来继承,并且只继承结构，不继承状态，这个继承通过父类来实现。而在javascript中需要同时继承结构和状态，因此是通过对象来继承了。
因此C#是面向类的语言，javascript是面向对象的语言（同时继承结构和状态）。
一个比较标准的说法是javascript通过prototype来实现继承。其实所谓prototype就是父对象（和C#中的父类相对应）。子对象继承父对象的所有结构和状态（前提是自己对应的结构和状态不存在）
这里有一个学习上的难点，就是一个对象并不直接通过prototype属性连接到它的父对象，而是通过constructor属性的prototype对象，间接的连接到它的父对象。
代码表示如下：
function Monkey() {
}
function Person() {
}
singer=new Person();
Person.prototype=new Monkey()

Person.prototype.constructor= Person

// assert_true singer.constructor == Person 也就是说singer对象有一个constructor属性指向了Person,而Person再通过prototype属性指向 new Money()对象

喜欢刨根问底的人一定会问，为什么一个子对象不能直接有一个prototype属性来直接指向父对象呢？
其实这是可以的，例如在Firefox中，每一个对象都有一个__proto__属性指向它的父对象。（但是这个属性是不建议用户使用的）
那为什么其他浏览器不这么做呢？而要通过constructor(构造函数）来间接的连接到父对象呢。其实这是有充分理由的，是一个精心的设计。
如果每个对象可以直接连接到父亲对象，那么会出现一个非常混乱的情况，如果我们随时在父对象通过“1步法”同时添加属性和状态，随时会被子对象继承。如果出错了，那么我们需要检查整个程序来找到造成麻烦的那句话。这显然不是个好的设计。

那么该怎么办呢？
通过上面的例子，我们知道通过构造函数，我们可以获得2步法的效果，因此我们把父对象连接到子对象的构造函数的prototype属性上，并且定一个“君子协定”，凡是需要添加属性，都放到构造函数中，这样我们只要检查构造函数，就可以知道子对象继承了哪些结构（注意，状态的继承不受限制，因为构造函数是2步法中的第一步，决定结构）。

由于要给prototype赋值一定要借助于构造函数，因此就“不动声色的，诱导性的“，让你很“自然地“使用“2步法“来完成继承工作，让代码组织性更好。但是由于是“君子协定”，你如果在构造函数外添加结构，也完全做得到，不过也许会在某些情况下造成一些大小麻烦。
有朋友也许会问，本来都是对象很好理解，扯出来函数，反而迷糊了。其实函数就是对象。如果对这个事实感觉很难理解。我们可以试试采用下面的说法。
世上本来没有函数，都是对象。不过有一种对象比较特殊，它有一个非常特殊的属性“（）”，使用这个属性，需要省略“."这个操作符，例如是“Person()"而不是“Person.()"，这个属性不象 singer.name属性直接输出一个状态，比如“张学友“，而是能够通过它内部隐藏的一段代码，完成一个计算，并且在“（）”中可以添加一些参数，从而对它内部代码的运行施加影响。由于它是一个对象，所以其他对象能够出现的地方，它也能出现。最后我们把这种对象称为函数。而它也让函数式编程成为了可能。

至此，你有没有发觉javascript的面向对象是那么的优雅，灵活和简洁呢？那个初看起来很难懂的prototype的设计，其实蕴含了设计者的良苦用心。
而javascript的函数式编程更将这种美发挥到了极致，简直是惊为天人。（这个另文再说）。

另外通过学习javascript，既可以对C#的静态特性有更好的理解。也有助于对c# 4.0添加的动态特性的进一步学习（虽然我对c#的动态特性并不看好,主要原因是同时包含静态和动态特性反而让程序员难以取舍。这也是Java对动态特性一直比较抗拒的原因）。

本文链接

愤怒的小鸟的究竟有没有很高的技术含量？

2011-03-02T05:08:00Z

在我第一次看到愤怒的小鸟这个游戏的时候，就对它物理模拟的效果赞叹不已。在一次园子中的评论中，几位园友对小鸟的技术不屑一顾。实在看不下去了，当时我谈了一些自己的看法，但也没有深究下去。今天看到一条新闻，就顺藤摸瓜做了一下调查研究，下面把一些调查结果和大家分享一下。

（这是新闻的链接http://www.cnbeta.com/articles/136109.htm)

让我很吃惊的是，小鸟的物理引擎不是小鸟游戏开发公司的原创，而是一个开源的物理引擎，名叫Box2D

这个引擎起源于2006年的GDC大会上的一个物理碰撞的教程，随后发布为开源项目。最初的演示就是一堆箱子。（这里是一个项目原型的截图，http://www.box2d.org/screenshots.html）
看到这些图，我真的很吃惊，这几乎就是一个小鸟游戏的很粗略的示意图。难怪Box2D的作者会对小鸟公司表示不满。
在2008年3月6日，2.0版正式引入“持续碰撞检测”(continuous collision detection)。这是我最欣赏的一个特性，而小鸟游戏的开发是在2009年。也就是说这个2.0版本让小鸟游戏直接成为了可能。
同时这个引擎也被移植到了XNA平台，这样在Windows Phone 7上，小鸟也可以运行了。

下面是Box2D的全部特性。

（有几个个特性看上去非常有技术含量。我不是做游戏的，很多特性我也不知道什么意思）

Collision
    * Continuous collision detection
    * Contact callbacks: begin, end, pre-solve, post-solve（接触回调函数）
    * Convex polyons and circles.
    * Multiple shapes per body（多形状实体）
    * One-shot contact manifolds （击打接触,是为小鸟设计的？）
    * Dynamic tree broadphase
    * Efficient pair management
    * Fast broadphase AABB queries（这个是什么？）
    * Collision groups and categories

Physics
    * Continuous physics with time of impact solver
    * Persistent body-joint-contact graph
    * Island solution and sleep management
    * Contact, friction, and restitution
    * Stable stacking with a linear-time solver （这个是什么？）
    * Revolute, prismatic, distance, pulley, gear, mouse joint, and other joint types
    * Joint limits, motors, and friction
    * Momentum decoupled position correction
    * Fairly accurate reaction forces/impulses （比较精确的力反馈）

System

    * Small block and stack allocators
    * Centralized tuning parameters
    * Highly portable C++ with no use of STL containers

结论：

1，愤怒的小鸟是一个非常有技术含量的游戏，不过这个技术含量更多来源于它的开源物理引擎，当然小鸟的创意也是成功非常重要的因素。
2，开源里面有大量等待发掘的金矿，只要我们勇于探索，也许有一天我们也能有非常有创意的产品出现。
3，虽然我是用我的经验和审美来直觉体验小鸟的深刻技术内涵，不过多一点调查总是有好处的。可以收获更多的知识和经验
4，如果我们使用了开源项目，应该表示出对原作者足够的尊重，而愤怒的小鸟在这一个点上显然做得不够好。

本文链接

中国第一个Web 3.0网站--网络小教室的功能设计，欢迎大家来讨论

2011-01-07T07:34:00Z

网络小教室是第一个按照Web 3.0原则设计的网站。目前所有的功能基本都已经实现，现在把基本的功能设计贴出，供大家讨论。
网络小教室共有两种角色，教师和学员。
教师通过出题，来引导学生学习。每个教室都有一个主题，例如Linux小教室。
那么他的域名就是 linux.xiaojiaoshi.com，如果是javascript主题，那么就是javascript.xiaojiaoshi.com

教师可能出如下的一道题

    利用ls -l readme.txt 显示readme.txt的权限如下
    rwxr-xr-- root mysql
    请详细说明上面的含义。

学生A的回答可能说下：
    r表示读，w表示写，x表示执行，-表示没有权限,文件的用户拥有者是用户root,文件的组有者是mysql

学生B的回答可能如下：
    rwx表示有读，写，执行的权限
    r-x表示有读，执行的权限,没有执行权限
    r--表示有读权限，没有写，执行权限

然后每个学生都可以都可以对其他学生的答案进行评价和投票，教师可以根据自己的喜好评出最佳答案。

也许你看到这里会说：“这不就是百度知道吗？“
很象，但是本质上完全不同。就好象微博和博客的区别，绝对不是140个字的区别。
百度知道，提出问题的人是低端，而回答问题的人是高端，而在小教室提出问题的人是高端，回答问题的人是低端。

那么网络小教室和传统的教室有什么区别呢？
传统的教室，同学之间不能互相查看答案，而网络小教室鼓励互相查看答案，并可以对各自的答案作出评价。
传统的教室，需要老师对每一个学生的答案进行批改，而小教室鼓励学生之间互相批改。教室可以选择最典型的答案进行评论。

网络小教室有比较完善的积分和奖章体系。
例如：回答一个问题可以获得10分，回答的问题获得别人的1个好评可以获得一个铜牌。

网络小教室有比较完善的标签系统。

例如在linux教室里面，可能有"文件“，”文件夹“，"权限“等标签，

网络小教室非常依赖于教师的质量，因此它非常尊重教师的作用，将最大程度上让利于教师。

教师可以租用，甚至买断教室，而网站本身按照Web 3.0的原则，以云服务商的身份提供服务。

如果，你积累了很多有价值的知识，那么通过网络小教室的途径将他传递出来，你不仅能获得声望，更能获得实际的收益。
而对广大的新手来说，有机会通过小教室，用最低的成本学到前辈的知识。而且也有机会享受网站的收益。

没错，因为学生也是用户，所以学生和老师可以同样用积分获得网站的股份。

本文链接

谈谈我设计的Web 3.0，以及让程序员富起来的路线图

2011-01-04T12:06:00Z

Web 1.0 是由网站向用户发布内容，所有的内容由网站制作，内容版权归网站所有。
代表性的网站有新闻网站（新浪，搜狐），视频网站（土豆，优酷）
Web 2.0 是由用户产生内容（User Generated Content)，俗称UGC,内容版权归网站所有。
代表性的网站有人人网，百度贴吧，新浪微博等

那么什么是Web 3.0呢？我构想了我的web3.0网站的准则。
Web 3.0就是用户产生内容，同时用户拥有内容（User Owned Content),俗称UOC。
Web 3.0和 Web 2.0的巨大区别在于。Web 3.0 网站打破了用户和网站的收益的不平衡性。

下面说明一下Web 3.0的基本原则。

1，网站的所有股份分为三份，三分之一为用户股，三分之一为员工股，三分之一为风投股。
2，用户按照自己的积分，来确定自己所占用户股的比例，如果所有的用户积分为1万分，你的积分为1000分，那么所占的股份比例就是3.3%
3，用户的股份在公司被整体收购或上市前不能变现，但是可以参与广告收入的分成，比例为三分之一。
4，网站的某个部分可以作为云设施租用给用户，用户可以用股份来支付费用。
5，网站的管理，制作人员（包括程序员，设计师，市场人员）占有三分之一的员工股。
6，员工股在公司被整体收购或者上市前不能变现，但是可以参与广告收入的分成，比例为三分之一。
7，员工不能租用网站设施，但是可以获得在网站中植入自己的应用的权利（类似于外接网站）
8，在公司被整体收购或者上市前，风投的股份不能超过三分之一
9，是否被收购或者上市，由用户，员工，风投共同投票决定。

我设计的这个Web 3.0蓝图的可以为程序员和设计师创造出更多的就业机会，也避免了网站店大欺客的现象。同时能大大提高风投的命中率。
在Web 3.0时代，用户有机会成为真正意义上的上帝。

遵循Web 3.0原则的第一个网站的编码已经接近尾声。希望在春节期间能推出。
在推出之前也会出一些博客介绍相应的情况。
虽然这样的尝试，很有可能会失败，我相信这会是一个趋势。如果真的成功了，那么就成为一个中国式创新了。

真心希望能让程序员都富裕起来。

本文链接

掌握Linux的用户(组)，权限，文件精妙的三角关系，和强大的三级帮助系统

2011-01-03T13:45:00Z

在linux中一切都是文件（文件夹和硬件外设是特殊的文件)，如果有可能尽量使用文本文件。文本文件是人和机器能理解的文件，也成为人和机器进行交流的最好途径。由于所有的配置文件都是文本，所以你只需要一个最简单的编辑器就可以修改。即使是2进制执行文件，也会附上源代码。

这就是Linux的基本哲学，也是开源的基本精神。GNU/Linux的最终发展就是跨越人和机器之间的界限。

(比较：Windows中的一切也都是文件，大多都是微软格式编码过的2进制文件，而配置文件也往往都是进行2进制编码的,甚至成果物都是2进制编码的，比如doc文件，你需要使用微软的API才能完成修改。微软将数据和程序同时二进制化的做法，维护了20多年的垄断的同时，也给自己挖好了最后的坟墓，聪明绝顶的比尔.盖茨显然也看到了这点。所以提前跳船了。我大胆预言，微软最终会推出Office for Ubuntu（别吃惊，office for mac 存在很多年了）, 而Windows 8.0将成为最后一个版本的Windows，Windows 会和当年Novell的 Netware一样成为历史。随着Tablet兴起，基于丰富的触摸控制的游戏会大行其道，Windows上基于鼠标的游戏也会成为过时的玩意。至于Windows Phone 7 则不会有任何厂商“真心”支持，微软以诉讼相威胁，才让HTC就范。刚刚挣脱了微软的魔掌，谁愿意重回老路呢？。至于广大的.Net程序员，呵呵，赶快来学Linux吧，将Windows迁移到Linux将会是一块巨大的蛋糕，而两者都会的程序员就有好日子过了)

由于修改文本文件如此简单，Linux系统本身肯定要加以规范。这就引出了用户(组)和权限这2个概念。

而这2个概念的引入，完美的保证了Linux的安全性，同时没有添加复杂性。

由于一切皆为文件。所以Linux 引入了2个文件来管理用户（组）， /etc/passwd存放用户，/etc/group存放组，然后在文件系统中的每个文件的文件头里面添加了用户和文件之间的关系信息。

用户和文件的关系只有2种，拥有和不拥有。

组和文件的关系只有2种，拥有和不拥有

用户和组的关系只有2种，属于和不属于

将这三种关系叠加，用户和文件的最终关系可以归纳为3类

1，用户拥有该文件

2，用户属于某个组，某个组拥有该文件（即用户通过属于某组来拥有该文件）

3，用户不拥有该文件

而在文件的文件头里，则存储了3组信息分别对应上面3类关系

第一组存放拥有该文件的用户的的权限

第二组存放拥有该文件的组的权限，（所有属于该组的所有成员都获得此权限）

第三组存放所有不拥有该文件的用户（等于所有用户减去以上2类用户）所获得权限。

非常微妙的是，你可以让第三组的权限大于第一，第二组，也就是不用拥有该文件的用户的权限反而更大。

（评论：当我想通了这层关系以后，很感叹IT前辈们的超凡智慧，这样的设计具有非常好的对称性，拥有未必是好事，不拥有可能是种幸福。人生何尝不是如此呢？）

下面要说明一下权限。

权限一共有三种读（缩写为r),写（缩写为w),执行（缩写为x)

读和写很好理解，执行的话当然只对能执行的文件才有效果。

权限相对文件夹来说意义略有不同。比如如果你拥有对某目录的执行权限，你才能 cd 到某目录，而如果你没有读权限，你即使cd到了某目录，你也不能ls。

在实践为了省事，我们一般都会用上所有三种权限，所以初学者只要知道有这么回事情就可以了。

结合用户(组），权限，文件，我们用一个命令 ls -l 就能显示出三者之间的关系

下面是一个例子

显示readme.txt的权限信息

r-x-w-rw- tom admin readme.txt

上面的r-x-w-rw-，每3个字符为一组，分别对应用户，组，其他用户，-表示无此权限

用户（缩写为u)的权限：是读(r)和执行(x)

组（缩写为g)的权限：是写(w)

其他用户（缩写为o)的权限：是读(r)和写(w)

用户tom 拥有该文件

组admin拥有该文件

任何用户登录以后根据以上设置就可以获得自己相应的权限。

修改权限也很简单，比如要给g添加权限读(r)和执行权限(x)就是：

chmod g+rx 文件名 ---加号表示添加权限

要取消其他用户的写(w)权限

chmod g-w 文件名 ---减号表示取消权限

在实际的应用当中，我们一般会用应用程序的名字来设置组名

比如在我的系统中就有mysql组，mongdb组

(评论：这里再引用一下最聪明的物理学家兼哲学家爱老的名言

Make everything as simple as possible, but not simpler

Albert Einstein

我对这句名言的翻译也很simple,就是“简约不简单”，Linux这种权限系统的精妙设计很容易让人联想到人体的DNA系统，只有四种碱基，确可以演化出人体这么复杂而有效的系统。而反观Windows系统，真是无奈呀。用户的电脑居然可以成为QQ和360的战场，用户还没有任何证据来证明谁是谁非。这到了Linux系统上，在这么简洁的安全机制下是根本不可能的事呀）

最后来谈一谈 Linux的三级帮助系统

Linux的帮助系统非常有特色。如果能熟练使用帮助系统，加上谷歌学习法，自学就会变得非常轻松

第一种是迷你型帮助，这种帮助篇幅最短，最精炼，多用在想不起某个命令的具体参数，命令用法如下

命令 –help

比如 ls –help

第二种是中型帮助，这种帮助篇幅较长，说明详细，多用在象详细了解某个命令的来龙去脉，命令用法如下

man 命令 --------man是（manual的缩写）

比如 man cd

第三种是大型帮助，这种帮助篇幅最长，有的可能是一本书，命令用法如下

info 命令

比如 info rm

Linux学习一定要自己多磨练，才能真正掌握。Easy come easy go。任何很容易学会的知识和技术，多半都很廉价（就是工资很低的意思）

PS. 有网友希望推荐关于Linux深入浅出的书籍，我看过多本原版书，不过大多数的知识还是靠自己实践，和谷歌来的。很多Linux知识可能是在学习别的东西的时候获得，比如配置Apache的时候，就会多了解一些symbolic link的含义。很多东西要磨练以后才可能明白真正的内涵。

本文链接

Window/.Net程序员如何用最简单的方式掌握Linux的本质

2010-12-27T14:47:00Z

“If you can't explain it simply, you don't understand it well enough”
                                                       Albert Einstein
有很多关于Linux的书籍，博客。大多数都会比较“粗暴“的将一大堆的命令塞给读者，从而使很多人望而却步。未入其门就路过了。
所以我设想用一种更为平滑的学习方式，就是在学习命令时，先用纯语言来介绍Linux背景和动机。就如同所有的的网络游戏都要先介绍游戏的历史观，然后再介绍游戏的操作。
大多数初学者在刚刚接触Linux都会有非常陌生的感觉。往往会有一些疑惑和问题。而我们就沿着这些问题，从远及近，从宏观到微观来理解Linux的简洁和美丽。

问题1: Winows有注册表，为什么Linux没有注册表
   注册表是Windows核心组件，对整个系统进行配置。Linux是以整个文件系统作为"注册表“，Windows注册表的树形结构，可以粗略的对应Linux文件系统的树形结构。
   Linux的配置文件就相当于注册表的键，或者说Linux采用是的分布式的注册表。
   那么Linux为什么要这样设计呢？因为Linux是所谓的网络操作系统，所以单台电脑不是Linux的界限，如果是多台电脑组成的系统，那么分布式的管理就有着巨大的优势。
   例如：一个包含配置文件的磁盘的损害不会让整个系统瘫痪，而可能只是让部分功能失效。

问题2：Windows有完善的图形界面，而Linux为什么要学命令行。
首先，命令行绝对要比图形界面先进的多。命令行是程序员的第一界面，而图形界面是普通用户的第一界面。
也许很多人会有不同意见，其实我们再向前想一步，就很清楚了。
命令行的下一步演化是什么？很简单就是语音控制，就是把人类自然语言转化为命令
图形界面的的下一步演化是什么？是姿势控制。从目前的Windows系统来说一共只有3种姿势，单击，双击，拖放。而更先进的IPad有拨动，画圈等。
姿势控制很简单，便于用户上手，语音控制很复杂，但是控制精度很高。
作为程序员我们要求电脑完成的工作要比普通用户复杂的多，所以使用命令行会非常高效。
退一步讲，图形界面本质也是命令行，只不过将姿势翻译成命令执行而已。
程序员编程的代码也都是“命令行”，一条一条的指令而已。
总之，只要能打破对Linux命令行的恐惧感，接下来的事就会非常容易了。这个命令行绝对不是你简单想像中的命令行，它是非常智能化的。

问题3：Linux有那么多目录，那么多命令，怎么记得住呢？
首先，Linux目录是Linux系统最灵魂的东西，所有的硬件都可以被抽象为文件，从而实现网络化。（Internet只不过是Unix/Linux的进一步的演化而已）
所以只要掌握了Linux目录的规律，在理解的基础上记忆就可以容易的多。另外Linux的命令行有智能化功能，可以让你少打95%以上的字符来完成命令。
绝非你所想象的傻乎乎的敲一大堆命令，那些用Linux大牛都是绝顶聪明的人，怎么可能让自己辛苦呢？

问题4：Linux的文件夹结构看上去很复杂，怎么理解呢？
我们这里假设，我们就是设计者，如果我们设计一个文件系统，我们会如何去做呢？
我们需要一个起点，这个起点就叫根目录，用“/”来表示，然后我们需要启动Linux,那么我们就会把所有核心的启动文件（包括Linux核心本身）都放到一个“/boot"目录下。
当系统启动后，我们需要执行一些基本命令在操作系统，这些命令都会放到“/bin"目录下。然后这些命令可能会用到一些库，这些库就被放到“/lib"下面，而这些库可能会会用到一些设备驱动文件，
那么这些驱动文件就会放到“/dev"目录下。
/：根目录
/boot:系统启动和内核
/bin ：系统基本命令（bin是binary的缩写）
/lib : 系统库（不能直接运行的代码）（lib是libary的缩写）
/dev : 设备驱动（dev是device的缩写）
到目前为止只用5个目录，很简单吧。

问题5：什么是"/usr" ，"/etc"和“/var“

当用户启动系统以后，要做一些更加复杂的工作，这时候就会涉及到一个叫“/usr",这个情况稍微有些复杂，是一个难点。不过也很容易解释清楚。
早期的unix系统都有很多块硬盘，当时硬盘的容量都很小，所以往往一个硬盘只放一个目录，比如“/boot"可以放在一个单独的"boot"盘上，上面提到的5个目录，是系统运行必不可少的。
而当系统启动以后，我们需要其他一些用于具体工作的程序时，我们就会加载一个“/usr"目录，上面放重要的运行程序。
容易引起疑惑的是"usr"这个名字，在历史上，原来这个确实是user的缩写，不过现在和user没有任何关系了，你可以把它看成是"universal software resource"的缩写。
这个“/usr"有点类似Windows里面的Program Files。
因此 /bin 和 /usr/bin的区别，就是 /bin里面的程序更加核心
这时候，很多人会有疑问，我们记住哪些命令在/bin 还是在/usr/bin呢？
放心，由于所有的bin目录都会登记到系统变量PATH里面，因此无论你在任何当前目录中，只要输入命令文件的名称，系统都会帮你找到这个命令并运行。
要点：
1，/usr上面一般都是只读文件，数据文件和配置文件不放在上面（放到哪里，后面会讲）
2,没有“/usr",linux系统也能正常运行
2，/usr可以被多台电脑共享（这里体现Linux系统的网络性）

由于/usr只放只读文件，那么配置文件和数据文件放哪里呢？这里就出现了2个新的目录“/etc"和“/var"
这里容易初学者迷惑的就是这个2个目录的名字。
在历史上 "etc“是 “etcetera”，中文意为“其他”，现在这个和“其他”没有任何关系，就是专门存放配置文件的地方，可以理解为“editable text configuration"的缩写
比如 /etc/mysql就是放mysql的配置文件 /ect/apache2/就是apache2的配置文件
在历史上“var" 是 “variable"，中文意为“变动”，现在主要用来存放log,lock等文件。
例如 /var/mysql就是用来存放mysql的log

问题6：用户自己产生的数据放到哪里？

当我们运行程序后，会产生很多自己的成果，这些成果放哪里呢？这里就出现了一个“/home"目录，不过你不能直接放到“/home"目录下，因为Linux是个多用户操作系统，所以系统会有一个以用户的名字命名的目录。
例如：用户是jack ,那么目录就是/home/jack ,这个目录也可以用“～“来表示。

至此，我们也就基本了解了Linux的组成。

文章肯定有很多毛病。如果你有任何疑问和建议，请提供评论。根据大家的意见我进一步重构文章，我相信只要多次改进，就一定能让学会Linux成为很简单的一件事。

本文链接

工资翻倍的秘诀--努力提高代码的质量

2010-12-13T10:11:00Z

看了园子中的一篇奇文，《重构者的20种死法》。居然有20多个人推荐。我顿时有了放下手头工作，写一篇博文的动力。

首先来看一个事实，百度，谷歌，腾讯的程序员们的工资是一般程序员的2，3倍，高级程序员的工资可能是5倍以上。
国外创业企业的软件开发者由于可以拿到股份，收入可能有百倍之多。这是为什么呢？

他们的电脑性能最多比我们的好50%吧。
他们的工作时间可能还要比我们少。
他们的人体构造和我们也没有任何区别。
他们的智商就算高，也不会高一倍吧。

那么他们凭什么拿那么多钱呢？其实很简单，那就是他们的的产品--代码，比我们写的代码好几倍，那么的他们的收入就可以高几倍。
一个快餐馆的厨师的收入可能只有2000元，而五星级宾馆的大厨年薪可能有百万。前者的产品只能管饱，后者可以成为艺术。

好的代码就如同是特种钢，需要经过各种工序的加工，锤炼才能形成。而坏的代码就如同是粗钢，甚至是地条钢。

所以即使暂时写不了高质量的代码，但绝对不能放弃对高质量代码的追求。
如果从业3，5年，即使写不了如同特种钢一样的代码，至少也要能写出不锈钢一样的代码吧。
那么什么是好的代码呢？
1，Expressiveness(表达性)：好的代码一看就能明白作者的意图，且思路清晰。比如，函数名的选择，代码的组织等
2，Coupling（耦合）和 cohesion（内聚）的恰当平衡，耦合太多，那么修改的时候牵连太多，无法下手。内聚不够，则代码冗余严重，也不容易修改。
3，消除代码的smell(臭味)，比如过多的临时变量，过长的方法，过大的类等等。
4，Generic（通用度），比如能在一定程度上适应用户的变化。

以上是纯就代码而言，如果从应用角度来看，还有很多重要方面

例如
1，代码和商业逻辑的吻合度，尽量减少用户不需要的代码。比如，可以采用BDD等
2，代码所映射的商业场景本身的价值，也决定了的代码的价值，如果代码所映射的商业逻辑本身比较小众，代码的价值也不会太高。

如果具备的以上特性的代码，就会成为有生命力的活代码。这样的代码具有高度的进化潜力，自然也就价值连城。
而所有的这一切，一个非常重要的步骤，就是重构。而具有重构能力的程序员才能拿到高薪。
优秀的程序员永远都是稀缺商品。

有人会说，你说的一切都太理想化，我们的领导和同事根本看不上。
我的回答是，你需要对自己的人生负责。人生是一个迭代的过程，当你的能力增加了，你才有机会遇到好的领导，好的同事。而好的领导和同事会进一步提升你的能力，从而你有机会遇到更高层次的领导和同事。
千万不要在起跑线上放弃！

本文链接

Hacker传说之不能说的秘密(2)

2010-11-29T10:41:00Z

说明1：对点击“推荐“的朋友表示感谢，博客园有没有可以看到是谁推荐的功能呢？
说明2：对所有的评论朋友表示感谢，即使是批评意见也很有价值。
说明3：是这个系列的第一篇，忍不住放入太多内容，导致重点不突出，等有时间把文章重构成2-3篇

说明4：题目中的Hacker是特指编程技术超牛的程序员。而不是指黑客，由于中文把Hacker翻译成了黑客所以导致了混淆。

黑客又被称为黑帽黑客（Black Hat)，cracker,脚本小子，是利用所学技术进行系统破解的人群。
本系列的Hacker都是指编程顶尖高手，也被称为白帽黑客（White Hat) ，比如hacker老大 Linus。

这也就是Redhat名字的出处吧。

重量级秘密之二：保护眼睛
      上一篇提到过Hacker都是“以我为主”的。提高编程效率是为了增加竞争力和收入。保护眼睛就是为了减少支出，延长编程生涯的寿命。
      一个程序员，坐在空调房，没有体力劳动，可以说是一个非常舒服的工作，但是他有一样东西是过度使用的，那就是眼睛。
      特别是鼠标型程序员，他们每一分种都在做手眼协同。一般来说一个程序员用眼度是一个文员的200%。
      而一个Hacker的用眼度可能只有程序员5%，没有写错，只有5%，甚至更少。
      所以有很多大胡子Hacker。因为编程不需要用力气，能敲键盘就可以，所以只要保护好眼睛，就可以干到很大年纪。

也就是说他们产出高达100倍，损耗却只有5%，真是无语呀。

那么他们是怎么做到的呢？（以下方法都是从用眼的角度去考虑，当然也有其他方面的考虑，只是暂时忽略）

首先是开发环境，Hacker尽量使用命令行，并使用良好的配色（深色底，浅色字），如果使用VS的朋友，如果你的背景色是白色，建议赶快换成深色（VS有很多theme)

很多人会嘲笑hacker的古董界面，他们总是一笑了之，依然故我。我也嘲笑过命令行程序员，恐怕当时他们看着我的红红的眼睛暗暗发笑吧。

其次是编辑器，也就是传说中的vim,emacs这样的神器。用他们有以下几个好处。

      1，用机器去找，而不用眼睛去找。
         以VIM为例
         找文件的话，用所谓fuzzyfind,比如 app/controller/user_controller.cs这个文件，你只需要输入 acu三个字母，文件就自动打开了。这个可以节省用眼30%
         找整个词的话，输入/user,这个可以节省用眼5%
         查找单个字母,输入fo,就自动跳到 user.name="Tom"中的o,这个可以省眼5%
      2，连击技
         这个就厉害了，利用查看和动作，可以行成“连击技“
         比如 User user=User.new,要删除new,光标在开头的U上，输入cfn+find,直接就把User.new改成了User.find，可以省眼30%，（一般做这个动作，我总会闭上眼）
         还有内删除，比如要删除find(Name user,Age age),输入f(，光标定位到（上，然后ci(三键将括号里面的内容删除干净。
         还有几百种连击技，大多我也不懂。不过即使掌握了10种，省眼也有50%
      3，snippet和autocompele
         snippet比较普遍了， autocomplete要提一下，这个不同于Intellsence,因为autocomplete开头的字母一定要输入正确，才可以补齐的，所以Hacker都是要背api的（第一篇已经提到过背api了。
      以上只是vim技巧的一滴水珠而已，vim是需要用一生去相处的朋友。（注：emacs比vim难，建议还是从vim入手），不过很多初学者由于没有人指点，所以往往都最后失败了。其实是方法不对，反向不对，以后要专门写一篇Vim的最佳学习法。

      然后就是编程方法了，比如Hacker推崇的TDD,MVC
      所谓TDD，就是用程序去检查程序，成功绿色，失败红色，这个可以省眼30%。（Hacker的机器小秘？！！）
      所谓MVC就是把显示隔离开，做MC的时候，和TDD结合，继续省眼，有些Hacker很寂寞，所以即使做View的时候，他们也搞出了没有显示的浏览器（Headless Brower)，还是命令行！

      还就是用脑力换眼力，Hacker尽可能的把代码的结构建立在大脑中，比如文件夹的结构，文件的名字，比如类的namespace,比如库的结构，比如函数名称，（当然背api是入门功夫了）。一个顶级的Hacker可以在脑中建立起代码库的全息索引。

然后利用神器，指哪打哪了。

最后就是social coding,就是大家一起团结起来，代码互换，开源就是最重要的一种social coding。

也许你会说，这里省30%，那里省10%，到最后不是要闭着眼睛编程序了？
这个厉害了，谷歌的盲人Hacker Raman，就是闭着眼编程序的。

本文链接

Hacker传说之不能说的秘密

2010-11-27T05:47:00Z

一点说明：之所以叫不能说的秘密，并非因为保守，而是因为告诉一般人，他非但理解不了，还有可能要取笑你。所以有自尊的Hacker往往只传自己信得过的人,以免自讨没趣。于是很多东西就逐渐成为了不能说的秘密。所以这个Hacker传说系列也是一个尝试，仅供参考。
   一个Hacker相对于程序员来说有着超过100倍的惊人效率。并非是由于他们的智商超过一百倍。而在于他们掌握了程序员没有掌握的"魔法"。
重量级秘密之一：Hacker的编程方式往往和普通程序员都是相反的。
     Hacker的思维和工作流程都采用“以我为主"的指导原则。而程序员都是采用“以电脑为中心“的方式。
     以一个最简单的例子来说，程序员喜欢使用IntelliSense,利用电脑帮助选择api,而Hacker会把大多数的api熟记在心。也许你会说这个怎么能记住呢？其实绝对是可以的，只是没有人和我们强调这个看上去简单之极的方法。
     我们拿英语为例，一般来说掌握英语至少需要记住5000个单词，其实编程和写文章没有什么两样，api就如同英语单词一般。如果我们一边写文章，一边要查字典，不但效率低，而且文章质量差。而所谓的IntelliSense只不过把纸质字典换成了快译通而已。

当一个Hacker编程的时候，他脑中已经迅速的用单词(api)组织成为文章（program)，自然就效率奇高了。那么记住api很难吗？其实很容易，因为很多api都是要天天用的，一个程序员如果一年编程下来还不能背出80%的api，那么智商就在平均水平以下了。

     但是事实是大多数程序员记不住api,这就是IntelliSense惹的祸了，看似很方便的鼠标一点，却失去了将api刻写到脑中的机会。这也是所有的Hacker对Visual Studio不屑一顾的根本原因。当我们看到一个Hacker用文本编辑器来写程序的时候，其实他不是在耍酷（园子里面的很多朋友把这称为“装”），他只不过是用正确的方法来做正确的事而已。
     所以当你采用微软模式编程，那么开始会非常快，但是没有积累，最后只是黄梁一梦而已。而Hacker所使用的Hacker模式，开始会很慢，然后会越来越快。效率会呈现线性增长（这是亲身体会，绝不夸大）。
     其实著名的Hello World 惯例也包含了这样的一个隐喻，认认真真的象写Hello World一样“一个字一个字“写每一个程序，最后自然会成为高手。
     还有很多例子，也体现了Hacker“以我为主“的思想。
     大量的Hacker都在纷纷转向动态语言，这是因为动态语言具有api容易记住的优良特性（比如参数的顺序可以是任意，这个可以大大减轻记忆量），因此当CPU不再是瓶颈后，动态语言成了最佳选择。
     大多数的Hacker都喜欢做底层，因为底层的api数量最少，随版本的变动最少，所以他们可以用较少的力气来保持或者增加他们的效率。
     所有的Hacker都对微软技术很头痛，因为微软非常喜欢推出新的api,因此当一个新版本推出，即使一个顶级Hacker,效率也可能会损失50%以上。这会令他们非常抓狂。
     即使是.Net之父Anders他也喜欢做底层，他研究的是语言特性，涉及的api不过几十个而已。如果让他来写asp.net，效率可能和我们也差不多。
     其他的例子还有诸如为什么要用跨平台，为什么要使用Vim/Emacs，Hacker如何通过大脑来大大减轻眼睛的负担，从而能干到60岁，等等涉及很多方面的方法和实践，其实都体现了这个思想。
     结论：Hacker们用一个看似慢，实则快的可持续发展的方式来发展他们的大脑。他们往往抢占最佳地形，摘得营养最丰富的桃子。而程序员往往用工具商给的所谓高级工具（比如微软的Visual Studio)，其实也就是一把锄头，每天加班加点，也只是在贫瘠的土地上割点青草吃吃。
    其他的很多秘密，视情况和大家交流。如果你有什么疑问和想法，欢迎留言评论。

本文链接