什么是HTTP协议

协议是指计算机通信网络中两台计算机之间进行通信所必须共同遵守的规定或规则，超文本传输协议(HTTP)是一种通信协议，它允许将超文本标记语言(HTML)文档从Web服务器传送到客户端的浏览器

目前我们使用的是HTTP/1.1 版本

Web服务器，浏览器,代理服务器

当我们打开浏览器，在地址栏中输入URL，然后我们就看到了网页。 原理是怎样的呢？

实际上我们输入URL后，我们的浏览器给Web服务器发送了一个Request, Web服务器接到Request后进行处理，生成相应的Response，然后发送给浏览器， 浏览器解析Response中的HTML,这样我们就看到了网页，过程如下图所示

我们的Request 有可能是经过了代理服务器，最后才到达Web服务器的。

过程如下图所示

代理服务器就是网络信息的中转站，有什么功能呢？

1. 提高访问速度， 大多数的代理服务器都有缓存功能。

2. 突破限制， 也就是翻-墙了

3. 隐藏身份。

URL详解

 URL(Uniform Resource Locator) 地址用于描述一个网络上的资源,  基本格式如下

schema://host[:port#]/path/.../[?query-string][#anchor]

scheme               指定低层使用的协议(例如：http, https, ftp)

host                   HTTP服务器的IP地址或者域名

port#                 HTTP服务器的默认端口是80，这种情况下端口号可以省略。如果使用了别的端口，必须指明，例如 http://www.cnblogs.com:8080/

path                   访问资源的路径

query-string       发送给http服务器的数据

anchor-             锚

URL 的一个例子

http://www.mywebsite.com/sj/test/test.aspx?name=sviergn&x=true#stuff  Schema:                 http host:                   www.mywebsite.com path:                   /sj/test Query String:           name=sviergn&x=true Anchor:                 stuff

HTTP协议是无状态的

http协议是无状态的，同一个客户端的这次请求和上次请求是没有对应关系，对http服务器来说，它并不知道这两个请求来自同一个客户端。 为了解决这个问题， Web程序引入了Cookie机制来维护状态.

HTTP消息的结构

先看Request 消息的结构,   Request 消息分为3部分，第一部分叫Request line, 第二部分叫Request header, 第三部分是body. header和body之间有个空行， 结构如下图

第一行中的Method表示请求方法,比如"POST","GET",  Path-to-resoure表示请求的资源， Http/version-number 表示HTTP协议的版本号

当使用的是"GET" 方法的时候， body是为空的

比如我们打开博客园首页的request 如下

GET http://www.cnblogs.com/ HTTP/1.1 Host: www.cnblogs.com

下面我们打开Fiddler 捕捉一个博客园登录的Request 然后分析下它的结构, 在Inspectors tab下以Raw的方式可以看到完整的Request的消息，   如下图

我们再看Response消息的结构, 和Request消息的结构基本一样。 同样也分为三部分,第一部分叫Response line, 第二部分叫Response header，第三部分是body. header和body之间也有个空行,  结构如下图

HTTP/version-number表示HTTP协议的版本号，  status-code 和message 请看下节[状态代码]的详细解释.

我们用Fiddler 捕捉一个博客园首页的Response然后分析下它的结构, 在Inspectors tab下以Raw的方式可以看到完整的Response的消息，   如下图

Get和Post方法的区别

Http协议定义了很多与服务器交互的方法，最基本的有4种，分别是GET,POST,PUT,DELETE. 一个URL地址用于描述一个网络上的资源，而HTTP中的GET, POST, PUT, DELETE就对应着对这个资源的查，改，增，删4个操作。 我们最常见的就是GET和POST了。GET一般用于获取/查询资源信息，而POST一般用于更新资源信息.

我们看看GET和POST的区别

1. GET提交的数据会放在URL之后，以?分割URL和传输数据，参数之间以&相连，如EditPosts.aspx?name=test1&id=123456.  POST方法是把提交的数据放在HTTP包的Body中.

2. GET提交的数据大小有限制（因为浏览器对URL的长度有限制），而POST方法提交的数据没有限制.

3. GET方式需要使用Request.QueryString来取得变量的值，而POST方式通过Request.Form来获取变量的值。

4. GET方式提交数据，会带来安全问题，比如一个登录页面，通过GET方式提交数据时，用户名和密码将出现在URL上，如果页面可以被缓存或者其他人可以访问这台机器，就可以从历史记录获得该用户的账号和密码.

状态码

Response 消息中的第一行叫做状态行，由HTTP协议版本号， 状态码， 状态消息 三部分组成。

状态码用来告诉HTTP客户端,HTTP服务器是否产生了预期的Response.

HTTP/1.1中定义了5类状态码， 状态码由三位数字组成，第一个数字定义了响应的类别

1XX  提示信息 - 表示请求已被成功接收，继续处理

2XX  成功 - 表示请求已被成功接收，理解，接受

3XX  重定向 - 要完成请求必须进行更进一步的处理

4XX  客户端错误 -  请求有语法错误或请求无法实现

5XX  服务器端错误 -   服务器未能实现合法的请求

看看一些常见的状态码

200 OK

最常见的就是成功响应状态码200了， 这表明该请求被成功地完成，所请求的资源发送回客户端

如下图， 打开博客园首页

302 Found

重定向，新的URL会在response 中的Location中返回，浏览器将会自动使用新的URL发出新的Request

例如在IE中输入， http://www.google.com. HTTP服务器会返回304， IE取到Response中Location header的新URL, 又重新发送了一个Request.

304 Not Modified

代表上次的文档已经被缓存了， 还可以继续使用，

例如打开博客园首页, 发现很多Response 的status code 都是304

提示：　如果你不想使用本地缓存可以用Ctrl+F5 强制刷新页面

400 Bad Request  客户端请求与语法错误，不能被服务器所理解

403 Forbidden 服务器收到请求，但是拒绝提供服务

404 Not Found

请求资源不存在（输错了URL）

比如在IE中输入一个错误的URL， http://www.cnblogs.com/tesdf.aspx

500 Internal Server Error 服务器发生了不可预期的错误

503 Server Unavailable 服务器当前不能处理客户端的请求，一段时间后可能恢复正常

HTTP Request header

使用Fiddler 能很方便的查看Reques header, 点击Inspectors tab ->Request tab-> headers  如下图所示.

header 有很多，比较难以记忆，我们也按照Fiddler那样把header 进行分类，这样比较清晰也容易记忆。

Cache 头域

If-Modified-Since

作用： 把浏览器端缓存页面的最后修改时间发送到服务器去，服务器会把这个时间与服务器上实际文件的最后修改时间进行对比。如果时间一致，那么返回304，客户端 就直接使用本地缓存文件。如果时间不一致，就会返回200和新的文件内容。客户端接到之后，会丢弃旧文件，把新文件缓存起来，并显示在浏览器中.

例如：If-Modified-Since: Thu, 09 Feb 2012 09:07:57 GMT

实例如下图

If-None-Match

作用: If-None-Match和ETag一起工作，工作原理是在HTTP Response中添加ETag信息。 当用户再次请求该资源时，将在HTTP Request 中加入If-None-Match信息(ETag的值)。如果服务器验证资源的ETag没有改变（该资源没有更新），将返回一个304状态告诉客户端使用 本地缓存文件。否则将返回200状态和新的资源和Etag.  使用这样的机制将提高网站的性能

例如: If-None-Match: "03f2b33c0bfcc1:0"

实例如下图

Pragma

作用： 防止页面被缓存， 在HTTP/1.1版本中，它和Cache-Control:no-cache作用一模一样

Pargma只有一个用法， 例如： Pragma: no-cache

注意: 在HTTP/1.0版本中，只实现了Pragema:no-cache, 没有实现Cache-Control

Cache-Control

作用: 这个是非常重要的规则。 这个用来指定Response-Request遵循的缓存机制。各个指令含义如下

Cache-Control:Public   可以被任何缓存所缓存（）

Cache-Control:Private     内容只缓存到私有缓存中

Cache-Control:no-cache  所有内容都不会被缓存

还有其他的一些用法， 我没搞懂其中的意思， 请大家参考其他的资料

Client 头域

Accept

作用： 浏览器端可以接受的媒体类型,

例如：  Accept: text/html  代表浏览器可以接受服务器回发的类型为 text/html  也就是我们常说的html文档,

如果服务器无法返回text/html类型的数据,服务器应该返回一个406错误(non acceptable)

通配符 * 代表任意类型

例如  Accept: */*  代表浏览器可以处理所有类型,(一般浏览器发给服务器都是发这个)

Accept-Encoding：

作用： 浏览器申明自己接收的编码方法，通常指定压缩方法，是否支持压缩，支持什么压缩方法（gzip，deflate），（注意：这不是只字符编码）;

例如： Accept-Encoding: gzip, deflate

Accept-Language

作用： 浏览器申明自己接收的语言。 

语言跟字符集的区别：中文是语言，中文有多种字符集，比如big5，gb2312，gbk等等；

例如： Accept-Language: en-us

User-Agent

作用：告诉HTTP服务器， 客户端使用的操作系统和浏览器的名称和版本.

我们上网登陆论坛的时候，往往会看到一些欢迎信息，其中列出了你的操作系统的名称和版本，你所使用的浏览器的名称和版本，这往往让很多人感到很神 奇，实际上，服务器应用程序就是从User-Agent这个请求报头域中获取到这些信息User-Agent请求报头域允许客户端将它的操作系统、浏览器 和其它属性告诉服务器。

例如： User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; CIBA; .NET CLR 2.0.50727; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; .NET4.0C; InfoPath.2; .NET4.0E)

Accept-Charset

作用：浏览器申明自己接收的字符集，这就是本文前面介绍的各种字符集和字符编码，如gb2312，utf-8（通常我们说Charset包括了相应的字符编码方案）；

例如：

Cookie/Login 头域

Cookie:

作用： 最重要的header, 将cookie的值发送给HTTP 服务器

Entity头域

Content-Length

作用：发送给HTTP服务器数据的长度。

例如： Content-Length: 38

Content-Type

作用：

例如：Content-Type: application/x-www-form-urlencoded

Miscellaneous 头域

Referer:

作用： 提供了Request的上下文信息的服务器，告诉服务器我是从哪个链接过来的，比如从我主页上链接到一个朋友那里，他的服务器就能够从HTTP Referer中统计出每天有多少用户点击我主页上的链接访问他的网站。

例如: Referer:http://translate.google.cn/?hl=zh-cn&tab=wT

Transport 头域

Connection

例如：　Connection: keep-alive   当一个网页打开完成后，客户端和服务器之间用于传输HTTP数据的TCP连接不会关闭，如果客户端再次访问这个服务器上的网页，会继续使用这一条已经建立的连接

例如：  Connection: close  代表一个Request完成后，客户端和服务器之间用于传输HTTP数据的TCP连接会关闭， 当客户端再次发送Request，需要重新建立TCP连接。

Host（发送请求时，该报头域是必需的）

作用: 请求报头域主要用于指定被请求资源的Internet主机和端口号，它通常从HTTP URL中提取出来的

例如: 我们在浏览器中输入：http://www.guet.edu.cn/index.html

浏览器发送的请求消息中，就会包含Host请求报头域，如下：

Host：http://www.guet.edu.cn

此处使用缺省端口号80，若指定了端口号，则变成：Host：指定端口号

HTTP Response header

同样使用Fiddler 查看Response header, 点击Inspectors tab ->Response tab-> headers  如下图所示

 我们也按照Fiddler那样把header 进行分类，这样比较清晰也容易记忆。

Cache头域

Date

作用:  生成消息的具体时间和日期

例如：　Date: Sat, 11 Feb 2012 11:35:14 GMT 

Expires

作用: 浏览器会在指定过期时间内使用本地缓存

例如: Expires: Tue, 08 Feb 2022 11:35:14 GMT

Vary

作用：

例如: Vary: Accept-Encoding

Cookie/Login 头域

P3P

作用: 用于跨域设置Cookie, 这样可以解决iframe跨域访问cookie的问题

例如: P3P: CP=CURa ADMa DEVa PSAo PSDo OUR BUS UNI PUR INT DEM STA PRE COM NAV OTC NOI DSP COR

Set-Cookie

作用： 非常重要的header, 用于把cookie 发送到客户端浏览器， 每一个写入cookie都会生成一个Set-Cookie.

例如: Set-Cookie: sc=4c31523a; path=/; domain=.acookie.taobao.com

Entity头域

ETag

作用:  和If-None-Match 配合使用。 （实例请看上节中If-None-Match的实例）

例如: ETag: "03f2b33c0bfcc1:0"

Last-Modified:

作用： 用于指示资源的最后修改日期和时间。（实例请看上节的If-Modified-Since的实例）

例如: Last-Modified: Wed, 21 Dec 2011 09:09:10 GMT

Content-Type

作用：WEB服务器告诉浏览器自己响应的对象的类型和字符集,

例如:

Content-Type: text/html; charset=utf-8

Content-Type:text/html;charset=GB2312

Content-Type: image/jpeg

Content-Length

指明实体正文的长度，以字节方式存储的十进制数字来表示。在数据下行的过程中，Content-Length的方式要预先在服务器中缓存所有数据，然后所有数据再一股脑儿地发给客户端。

例如: Content-Length: 19847

Content-Encoding

WEB服务器表明自己使用了什么压缩方法（gzip，deflate）压缩响应中的对象。

例如：Content-Encoding：gzip

Content-Language

作用： WEB服务器告诉浏览器自己响应的对象的语言者

例如： Content-Language:da

Miscellaneous 头域

Server:

作用：指明HTTP服务器的软件信息

例如:Server: Microsoft-IIS/7.5

X-AspNet-Version:

作用：如果网站是用ASP.NET开发的，这个header用来表示ASP.NET的版本

例如: X-AspNet-Version: 4.0.30319

X-Powered-By:

作用：表示网站是用什么技术开发的

例如： X-Powered-By: ASP.NET

Transport头域

Connection

例如：　Connection: keep-alive   当一个网页打开完成后，客户端和服务器之间用于传输HTTP数据的TCP连接不会关闭，如果客户端再次访问这个服务器上的网页，会继续使用这一条已经建立的连接

例如：  Connection: close  代表一个Request完成后，客户端和服务器之间用于传输HTTP数据的TCP连接会关闭， 当客户端再次发送Request，需要重新建立TCP连接。

Location头域

Location

作用： 用于重定向一个新的位置, 包含新的URL地址

 实例请看304状态实例

HTTP协议是无状态的和Connection: keep-alive的区别

无状态是指协议对于事务处理没有记忆能力，服务器不知道客户端是什么状态。从另一方面讲，打开一个服务器上的网页和你之前打开这个服务器上的网页之间没有任何联系

HTTP是一个无状态的面向连接的协议，无状态不代表HTTP不能保持TCP连接，更不能代表HTTP使用的是UDP协议（无连接）

 Keep-Alive不会永久保持连接，它有一个保持时间，可以在不同的服务器软件（如Apache）中设定这个时间

    收到一个朋友的邮件说如何在Swing中实现组件的动画效果，就像JIDE的那些组件一样。的确Swing框架的灵活性和可扩展性，使得它非常适合做这样Makeover工作。我简单总结一了以下，这种组件不外乎要有以下三种元素：

    1.外观华丽。这包括使用渐变色，线条和字体反走样，图标设计漂亮抢眼，界面变化要柔和等等。但要避免设计太花哨，给人华而不实的感觉。原则上避免颜色太 碎，图标应以简洁为主，不可滥用图片等。技术上没有多大要求，主要是美工，你需要掌握各种做图工具，自己最好有好的审美和设计能力。

    2.动画效果。组件行为变化要柔和化，尽量使用动画效果，如淡入淡出、滚动弹出等等。技术上最常用的方法是使用javax.swing.Timer。为什 么要使用javax.swing.Timer，这是因为javax.swing.Timer触发的事件都在EDT上执行，是线程安全的。除此外还需掌握 Java 2D的常用接口及图像处理的常见技巧。

    3.空间布局。这种组件空间布局的特点是立体、动态、拖拽式的。这和人的认知能力有关。人类认知的特点是具体到抽象。二维、静态和键盘式操作对普通用户来 说太过抽象和专业化，需要一定的辅助学习才能理解的。而三维、动态、拖拽式操作更贴近于感性的认知范畴。因此这类组件经常有浮动式窗口、组件布局动态变化 及拖拽式操作等特征。实现技术包括布局管理器(LayoutManager)、Swing组件分层结构、Swing事件体系结构以及DnD接口等。   

    美工对于java程序员来说可能比较缺乏，但是华丽外观不仅仅是美工技术，这包括一些宏观设计原则。java程序员完全可以通过掌握这些方针原则来提高自 己的设计水平。前面文章介绍那个《Swing外观设计方针》就是一本这样的书。至于美工，我觉得如果你有美术天分，那就要充分利用；如果没有，那么你可以 模仿，熟悉几种的图形工具就完全可以不用自己的画图做出比较漂亮的图标、图片（当然没有考虑版权问题）。我就是后者，但是我发现我平时只需要PrScrn 键(抓图）、Paint（Windows 画图工具，切图、剪裁、转换格式）、PowerPoint/OpenOffice Imprise（画图）、Google Image（搜索图片）就已经足够了。其他所需的技术就需要你掌握Swing和Java 2D方方面面的技术了。当然复杂的组件不仅仅是靠掌握这些技术能解决的，可能你还需要能比较好地熟悉各种编程模式。   

    这个朋友特别提到Windows上的折叠式操作面板，他说：   

    另外，我对JIDE中两个东西很感兴趣，一个是CollapsiblePanel（Windows Explorer左边的常见任务），点击后折叠、展开子面板，而且是动画效果

    因此昨晚就特地试了一下。虽然以前就大概明白使用Timer和布局管理器以及图像处理就可以实现这些东西，但一直没有做。昨晚的实验还是很成功的，大概花 了两个小时就实现了这个面板。工作过程大概就是分解这些面板组件、解析那部分需要动画、应该在哪儿触发何种事件。另外就是编写这些组件，不断调试。这个过 程的大部分时间都被效果调整占去了。你需要不断的运行程序，抓取屏幕，然后将它帖到Paint中，然后放大，然后和Windows上的抓图比较，包括大 小、尺寸、颜色、字体、微观变化等等。最后算是基本实现了Windows这个折叠式的面板组件。下面的是我的演示程序的一个抓图：

这个是淡出淡入动画效果：

    下面的Enable Animation的JCheckBox可以设置是否使用动画效果。选择上折叠和展开就具有动画效果。   

    这个组件的类名是dyno.swing.beans.FolderPane。使用比较简单： 

        主要接口有两个：  

     1. 人得学习能力是否会随着年龄的增长而变差？

     可能是如此，我两岁的儿子一首唐诗说两遍就记住了，很长绕口的儿歌《小熊过桥》几乎能一字不差的唱完；而我是显然办不到的。不过发现一个事实，就是人的学 习能力不仅仅是靠记忆能力，跟逻辑思维能力，还有人的经验也有很大的关系；我们每个人也许都发现，你如果只是个优秀的Java程序员，如果要你去维护一 个.net的系统，不出两个月， 你马上就是一个.net专家。因为你知道相关的知识怎么学习，知道如何才能最快定位问题的一般方法。我个人是个完全不懂php得人，结果被强拉过去搞了个 php的项目，结果被认为是php expert!  所以我的最终答案是，人得记忆力更年龄成反比，但是学习能力跟年龄成正比。

      2. 人的年龄越大，精力会跟不上程序员这样高强度的工作吗？

      我的答案也是否定的。首先这是个伪命题，没有哪件事情是轻松的；你觉得别人比你轻松，那也只是你觉得而已。大体上个人的回报跟付出是成正比的。其实随着你 的年龄增长，知识积累越多，经验越丰富，你的工作效率会更高。5年前你修一个Bug要一个星期，现在也许10分钟就够了，并且是又快又好。难道不是这样 吗？所以你的工作强度事实上会变得更低，因为你的效率更高，你会有更多时间喝咖啡，也会遭你邻桌的同事低语“这家伙每天无所事事，咋工资比我高那么多？” 因为你的10分钟就抵别人的一个星期。

     3. 人的年龄越大，就没有激情学习新知识了吗？

      对有些人是，对有些人不是。计算机科学日新月异，确实更新相当快。你真的会跟不上脚步吗？可能会，如果你自己不学习。但我一定要亦步亦趋吗？也不见得，无 论如何，即便是软件开发，也还是有方向，有领域，你只要更上你需要更上的节奏就够了。今天请我的一个兄弟给我讲了下Struts应用，就是给我搞个最小化 的Struts项目，包含所有Struct的重要知识点，然后搬个椅子坐我旁边，花上半个小时跟我讲解；我现在俨然Struts专家了，不信，我跟你讲讲 看？ 呵呵，开玩笑了。

    如果我们觉得每天吃饭不是件枯燥无趣的事，我们应该也不太会拒绝不断学习；如果我们一定会因为自然规律而失去某些优势，记得你其实有更多的优势可以弥补；最重要的是，做你喜欢的事，做你能做的事情。

    正月十五，明月高悬；祝福各位龙图大展！

今天我不谈抱负理想，也不谈具体的技术，我来谈几个看法上的典型错误。下面的这些问题都是我曾经遇到，或者是我的朋友们遇到过的问题，这些都是我个人的理解，希望对大家有帮助。

关于设计模式、设计原则

有人认为，熟悉了设计模式、设计原则，就学会了设计。其实，设计模式和设计原则，只是前人根据设计实践做的总结和提炼，设计，归根到底是要解决问题的，把具体问题的解决办法，经过一定的抽象，变成程序员的语言。

我见过一些人，他们知识渊博、见识广博，甚至理论可以给你阐述得冠冕堂皇，但是到了实际需要解决问题的时候，他们却拿不出巧妙的、优雅的办法，这是典型的象牙塔人。

另一方面，也有一些人看不起学习设计模式的人，他们觉得他们已经掌握了软件设计的奥义，这些对他们来说是毫无意义的词汇，对此大可以一笑置之。

有时候我们反而被设计模式或设计原则粗暴的掌握束缚了手脚，譬如我遇到这样一件事情，某位努力的程序员，设计的代码用遍了组合（例如把User对象 放置到Administrator里面），我好奇地问，有一些类和对象之间的关系很明显符合继承的特征，为什么不愿意用它？他说，设计原则告诉我们，要多 用组合，少用继承。我想，对这些优秀的模式、原则、方法论，如果不能透彻地掌握，不能根据实际场景合适地运用，是不是反而不如对其不了解来的好呢？

关于多种计算机语言的学习

有人觉得学习一种语言就可以了，学习那么多语言没有必要。事实上，多掌握一门合适的计算机语言不仅仅是多掌握一种谋生的工具，如果一种新的语言能够很大程度上改变你对编程、对设计的看法，那么兴许它就值得你去学习。

譬如C语言，可以培养严谨的思维；譬如动态语言，它可以帮助程序员更好地做面向对象的coding；譬如函数式语言，它在工业生产、运算领域有着不可替代的作用。

当然话说回来，所谓术业有专攻，对于某一门计算机语言（包括该语言所需的运行时环境、其中的编译或解释的原理）深入的掌握，是很有必要的。

另外，我们时常看到诸多计算机语言孰优孰劣的争论，计算机语言归根到底是一种工具，工具是随着时代发展升级和变更的，单纯的优劣争论没有太大意义。

关于英语

中国人为什么要学英语，程序员为什么要学英语，当我把那些方法名、变量名全部取成拼音，一样可以，谁下的这个破规定？

遗憾的是，诸多学习材料、论文、技术资料（尤其是一些刚出不久的技术），都是英语的；另一方面，国际标准、程序员交流的通用方式，都是英文的，我想肯定很难想象，那些有名的framework、lib的源码，如果用拼音来写变量名会成什么样子。

所以，如果你的英语不好（至少读写不好），就不要给自己找太借口，英语是一个掌握其他工具的工具，除非你坚信，中文很快就会在计算机界变成世界第一通用的语言。

关于算法

算法有多重要，这一件事的争议一直都很大。

软件归根到底是用来解决问题的，提到算法就不能不提到数学（这也是为什么很多软件领域的大师都具备相当的数学背景），对于解决问题，这里可以简单归纳成两步：

（1）把实际的问题抽象成简化的数学模型

（2）用算法去解决这个数学问题

算法，在这里应该是一个广义的概念（这里的算法并不仅仅指大学里学习的狭义的具体算法），算法是解决上述数学问题的办法。如果工作中你并未意识到它的存在，那只是说明，你抽象出的数学模型比较简单，解决这个模型的办法也很简单，或者有现成的方式可以模仿，或者有现成的框架帮你完成了，以至于你不去关注它、在乎它。

如果你做的事情是充满创新意义的，是别人从没有做过的，这时候算法兴许就成了决定你成败的因素。

在当前中国的环境下，视野广阔和经历丰富的人很好找，但是企业要招到具备上述两点能力来解决问题的人，其实是非常困难的。

关于经验

唯经验论者的人有很多，他们认为，在软件企业的职位、薪水、甚至决策能力，都取决于经验，一个5年经验的工程师，肯定比3年经验的工程师能找到更好的饭碗：

“我是老员工，我工作5年了，凭什么工作3年的他薪水比我高那么多”

实际上，很多因素，包括领域积累（这是业务上的，例如互联网领域、传统软件领域，这和所谓的纯技术没有直接关系）、视野、承受压力的能力等等往往都 在很大程度上取决于“经验”的积累，但是，这并不是绝对的。有句话叫做“事业一半是干出来的，一半是总结出来的”，也确实有一些出色的程序员，他们善于总 结、善于观察和积累，并且善于不断地思考，这样的程序员就是拥有更多优秀的经验。

另一方面，程序员是要来解决问题的，经验不能代替解决问题，有的人具备更优秀的解决问题的能力，他为什么就不能得到更优厚的薪水？

越来越多人开始使用Java,但是他们大多数人没有做好足够的思想准备(没有接受OO思想体系相关培训)，以致不能很好驾驭Java项目，甚至导致 开发后的Java系统性能缓慢甚至经常当机。很多人觉得这是Java复杂导致，其实根本原因在于：我们原先掌握的关于软件知识(OO方面)不是太贫乏就是 不恰当，存在认识上和方法上的误区。

　　软件的生命性

　　软件是有生命的，这可能是老调重弹了，但是因为它事关分层架构的原由，反复强调都不过分。

　　一个有生命的软件首先必须有一个灵活可扩展的基础架构，其次才是完整的功能。

　　目前很多人对软件的思想还是焦点落在后者：完整的功能，觉得一个软件功能越完整越好，其实关键还是架构的灵活性，就是前者，基础架构好，功能添 加只是时间和工作量问题，但是如果架构不好，功能再完整，也不可能包括未来所有功能，软件是有生命的，在未来成长时，更多功能需要加入，但是因为基础架构 不灵活不能方便加入，死路一条。

　　正因为普通人对软件存在短视误区，对功能追求高于基础架构，很多吃了亏的老程序员就此离开软件行业，带走宝贵的失败经验，新的盲目的年轻程序员 还是使用老的思维往前冲。其实很多国外免费开源框架如ofbiz compiere和slide也存在这方面陷阱，貌似非常符合胃口，其实类似国内那些几百元的盗版软件，扩展性以及持续发展性严重不足。

　　那么选择现在一些流行的框架如Hibernate、Spring/Jdonframework是否就表示基础架构打好了呢？其实还不尽然，关键还是取决于你如何使用这些框架来搭建你的业务系统。

　　存储过程和复杂SQL语句的陷阱

　　首先谈谈存储过程使用的误区，使用存储过程架构的人以为可以解决性能问题，其实它正是导致性能问题的罪魁祸首之一，打个比喻：如果一个人频临死亡，打一针可以让其延长半年，但是打了这针，其他所有医疗方案就全部失效，请问你会使用这种短视方案吗？

　　为什么这样说呢？如果存储过程都封装了业务过程，那么运行负载都集中在数据库端，要中间J2EE应用服务器干什么？要中间服务器的分布式计算和 集群能力做什么？只能回到过去集中式数据库主机时代。现在软件都是面向互联网的，不象过去那样局限在一个小局域网，多用户并发访问量都是无法确定和衡量， 依靠一台数据库主机显然是不能够承受这样恶劣的用户访问环境的。(当然搞数据库集群也只是五十步和百步的区别)。

　　从分层角度来看，现在三层架构：表现层、业务层和持久层，三个层次应该分割明显，职责分明：持久层职责持久化保存业务模型对象，业务层对持久层 的调用只是帮助我们激活曾经委托其保管的对象，所以，不能因为持久层是保管者，我们就以其为核心围绕其编程，除了要求其归还模型对象外，还要求其做其做复 杂的业务组合。打个比喻：你在火车站将水果和盘子两个对象委托保管处保管，过了两天来取时，你还要求保管处将水果去皮切成块，放在盘子里，做成水果盘给 你，合理吗？

　　上面是谈过分依赖持久层的一个现象，还有一个正好相反现象，持久层散发出来，开始挤占业务层，腐蚀业务层，整个业务层到处看见的是数据表的影子 (包括数据表的字段)，而不是业务对象。这样程序员应该多看看OO经典PoEAA.PoEAA 认为除了持久层，不应该在其他地方看到数据表或表字段名。

　　当然适量使用存储过程，使用数据库优点也是允许的。按照Evans DDD理论，可以将SQL语句和存储过程作为规则Specification一部分。

　　Hibernate等ORM问题

　　现在使用Hibernate人也不少，但是他们发现Hibernate性能缓慢，所以寻求解决方案，其实并不是 Hibernate性能缓慢，而是我们使用方式发生错误：

　　"最近本人正搞一个项目，项目中我们用到了struts1.2+hibernate3, 由于关系复杂表和表之间的关系很多，在很多地方把lazy都设置false,所以导致数据一加载很慢，而且查询一条数据更是非常的慢。"

　　Hibernate是一个基于对象模型持久化的技术，因此，关键是我们需要设计出高质量的对象模型，遵循DDD领域建模原则，减少降低关联，通 过分层等有效办法处理关联。如果采取围绕数据表进行设计编程，加上表之间关系复杂(没有科学方法处理、侦察或减少这些关系)，必然导致 系统运行缓慢，其实同样问题也适用于当初对EJB的实体Bean的CMP抱怨上，实体Bean是Domain Model持久化，如果不首先设计Domain Model,而是设计数据表，和持久化工具设计目标背道而驰，能不出问题吗？关于这个问题N多年就在Jdon争论过。

　　这里同样延伸出另外一个问题：数据库设计问题，数据库是否需要在项目开始设计？

　　如果我们进行数据库设计，那么就产生了一系列问题：当我们使用Hibernate实现持久保存时，必须考虑事先设计好的数据库表结构以及他们的关系如何和业务对象实现映射，这实际上是非常难实现的，这也是很多人觉得使用ORM框架棘手根本原因所在。

　　当然，也有脑力相当发达的人可以实现，但是这种围绕数据库实现映射的结果必然扭曲业务对象，这类似于两个板块(数据表和业务对象)相撞，必然产 生地震，地震的结果是两败俱伤，软的一方吃亏，业务对象是代码，相当于数据表结构，属于软的一方，最后导致业务对象变成数据传输对象DTO, DTO满天飞，性能和维护问题随之而来。

　　领域建模解决了上述众多不协调问题，特别是ORM痛苦使用问题，关于 ORM/Hibernate使用还是那句老话：如果你不掌握领域建模方法，那么就不要用Hibernate,对于这个层次的你：也许No ORM 更是一个简单之道： No ORM: The simplest solution

　　Spring分层矛盾问题

　　Spring是以挑战EJB面貌出现，其本身拥有的强大组件定制功能是优点，但是存在实战的一些问题，Spring作为业务层框架，不支持业务层Session 功能。

　　具体举例如下：当我们实现购物车之类业务功能时，需要将购物场合保存到 Session中，由于业务层没有方便的Session支持，我们只得将购物车保存到 HttpSession,而HttpSession只有通过HttpRequest才能获得，再因为在Spring业务层容器中是无法访问到 HttpRequest这个对象的，所以，最后我们只能将"购物车保存到HttpSession"这个功能放在表现层中实现，而这个功能明显应该属于业务 层功能，这就导致我们的Java项目层次混乱，维护性差。 违背了使用Spring和分层架构最初目的。

　　领域驱动设计DDD

　　现在回到我们讨论的重点上来，分层架构是我们使用Java的根本原因之一，域建模专家Eric Evans在他的"Domain Model Design"一书中开篇首先强调的是分层架构，整个DDD理论实际是告诉我们如何使用模型对象oo技术和分层架构来设计实现一个Java项目。

　　我们现在很多人知道Java项目基本有三层：表现层 业务层和持久层，当我们执着于讨论各层框架如何选择之时，实际上我们真正的项目开发工作还没有开始，就是我们选定了某种框架的组合(如 Struts+Spring+Hibernate或Struts+EJB或Struts+ JdonFramework)，我们还没有意识到业务层工作还需要大量工作，DDD提供了在业务层中再划分新的层次思想，如领域层和服务层，甚至再细分为 作业层、能力层、策略层等等。通过层次细化方式达到复杂软件的松耦合。DDD提供了如何细分层次的方式

　　当我们将精力花费在架构技术层面的讨论和研究上时，我们可能忘记以何种依据选择这些架构技术？选择标准是什么？领域驱动设计DDD 回答了这样的问题，DDD会告诉你如果一个框架不能协助你实现分层架构，那就抛弃它，同时，DDD也指出选择框架的考虑目的，使得你不会人云亦云，陷入复 杂的技术细节迷雾中，迷失了架构选择的根本方向。

　　现在也有些人误以为DDD是一种新的理论，其实DDD和设计模式一样，不是一种新的理论，而是实战经验的总结，它将前人 使用面向模型设计的方法经验提炼出来，供后来者学习，以便迅速找到驾驭我们软件项目的根本之道。

ActionScript/MXML

线程

线程是指进程中的一个单一顺序的控制流，是操作系统能够调度的最小单位，一个进程中可以有多条线程，分别执行不同的任务。线程有内核线程和用户线程之分，但在本文中仅指内核线程。在软件开发中，使用线程有以下好处：
1、在多核或多路 CPU 的机器上多线程程序能够并发执行，提高运算速度；
2、把 I/O，人机交互等与密集运算部分分离，提升 I/O 吞吐量和增进用户体验。
线程的缺点也很明显：
1、创建一条线程需要较大的内存开销，导致不能创建海量的线程；
2、线程由操作系统调度（分配时间片），线程切换的 CPU 成本比较高，导致大量线程存在时大量 CPU 资源消耗在线程切换上；
3、同一进程的多条线程共享全部系统资源，在多线程间共享资源需要进入加锁，大量的锁开销不提，重要的是加大了编写程序的复杂性，这一点你看看有多少书名含有“多线程”三个字就明白写个多线程应用有多难了；
4、 I/O 方面，多线程帮助有限，以 TCP Socket Server 为例，如果每一个 client connection 由一条专属的线程服务，那么这个 server 可能并发量很难超过 1000。为了进一步解决并发带来的问题，现代服务器都使用 event-driven i/o 了。
event-driven i/o 解决了并发量的问题，但引入了“代码被回调函数分割得零零碎碎”的问题。特别是当 event-driven i/o 跟 multi-threading 结合在一起的时候，麻烦就倍增了。解决这个问题的办法就使用绿色线程，绿色线程可以在同一个进程中成千上万地存在，从而可以在异步 I/O 上封装出同步的 APIs，典型的就是用基于 greenlet + libevent 开发的 python 库 gevent。绿色线程的缺陷在于操作系统不知道它的存在，需要用户进行调度，也就无法利用到多核或多路 CPU 了。为了解决这个问题，很多大牛都做出了巨大的努力，并且成果斐然，scala、google go 和 rust 都较好地解决了问题，下文以 rust 的并发模型为例讲一下。
rust 提出一个 Task 的概念，Task 有一个入口函数，也有自己的栈，并拥有进程堆内存的一部分，为方便理解，你可以把它看作一条绿色线程。rust 进程可以创建成千上万个 Tasks，它们由内建的调度器进行调度，因为 Tasks 之间并不共享数据，只通过 channels/ports 通信，所以它们是可并行程度很高。rust 程序启动时会生成若干条（数量由 CPU 核数决定或运行时指定）线程，这些线程并行执行 Tasks，从而利用多个 CPU 核心。

如 上图，rust 应用程序不停地 spawn 出一个又一个 Tasks，它们由 tasks 调度器管理，在适当的时机，调度器会把某一个 Task 分配给原生线程执行，如果这个 Task 进入 I/O 等待或主动让出 CPU（sleep），那么这个 Task 会被交回给调度器，而相应的原生线程会执行另一个新分派的 Task。尽管使用 rust 编程语言是不能创建线程的（直接调用 C 函数不算），但 rust 应用程序实际上是多线程的（一般情况下），它能够充分地利用多核或多路 CPU。
综上，类似 rust 的 Task 的概念是比线程更好的并发模型，更安全，编写的代码也更加容易维护（关于维护性，我相信写过 gevent 程度或 go 程序的同学会认同的）。线程当然不会消亡，但随着 scala/go/rust 的成熟，在可以预见的将来，线程会退到它呆着的角落：远离普通程序员，只有少数人需要了解它的细节。

C++

C++ 在 2011 年其实风头甚劲，C++2011 标准出台，gcc/msvc/clang 都很快速地支持了许多新特性，新兴的移动设备的性能较差，更是 C++ 的新舞台，在这个时候唱衰 C++，压力很大。我使用 C++ 年头不少，但除了在校的时候写过两个小游戏参加过两个比赛（分别是面向社会和面向大学生的）弄些证书好找工作以外，在工作中只用过大概不到一年半，做《斩 魂》（http://zh.163.com）的早期版本，写了服务器端的几条进程和客户端的 GameAI 部分。经验少，而且写得不好，所以基本上有人在 weibo 上问我 C++ 的问题，我都是转发给 @bnu_chenshuo 和 @miloyip 等真正的行家去回答的。所以实际上今天写这一篇，我底气很是不足，但是朋友们给前两篇很大面子，弄得我骑虎难下，只好硬着头皮写了。
前 文提到 C++ 的新标准，很有必要提一下标准化对 C++ 的影响。首先我们要肯定标准定制对 C++ 的积极作用，但标准化过程中的超长流程，一次次将 C++ 推向深渊。C++ 的第一个标准是 1998 年的 ISO/IEC 14882:1998，距离整个 90 年代最流行的 C++ 程序库 MFC（Microsoft Foundation Class Library）的第一个版本发行时间已经整整  6 年。1998 年，MFC 版本号为 6.0，与其一起发布的 Visual C++ 6.0 占有了巨大的市场。因为 MFC 发布得标准制定的时间早，所以 MFC 内部实现了许多后来标准库里也有的组件，比如各种数据结构容器。VC6 的市场占有率让 windows 平台下开发的许多 C++ 程序员甚至不知道有 STL，同时也无视 C++98 标准，从更兼容标准的 VC2002/2003 的市场占有率就可以看出来，直到今天，我知道国内不少公司还是只用 VC6 的。
其实在 90 年代，计算机的运算能力有限，市场上非常需要一款性能较高、抽象较强的编程语言，C++ 获得了成功，但它标准化的时间过长，造成各种编译器有各自互不兼容的“方言”，成了它的第一个软肋。第一个瞄准这个软肋的就是 java，java 在 1995 年推出，虽然性能稍逊，但它有更高的抽象能力、也更安全，并且更容易跨平台，所以迅速获得了成功；第二个瞄准这个软肋的是 C#，微软不能推动 C++ 发展，又不愿 C++ 的市场被 java 鲸吞，于是在 2001 年推出了 C#，经过 10 年的发展和微软大量的金钱推广，C# 已经成功获得了它应有的江湖地位。
虽然 java/c# 都不是善类，但 C++ 在 21 世纪的第一个十年里仍然地位稳固，这是因为 Linux 和 MacOS X 大获成功，在这两个平台上 C++ 都是非常有竞争力的编程语言，C++ 自然水涨船高。但随着 web2.0 和 web app 概念的兴起，以及 CPU 的主频进一步提升，服务器端编程语言渐渐地对执行效率不再敏感，而是更在意程序员的开发效率，众多的脚本语言开始蚕食 C++ 的市场份额，从早期的 perl 到后期的 python/php/ruby，在 2005 年以后，C++/java/C# 等静态类型的编译型语言的市场份额都下降了，新兴的贵族是动态语言。面对动态语言在开发效率上的强劲挑战，C++ 社区除了在 2003 年对 C++98 做了小小的 patch，基本上睡着了，完全没有应对之策，哦不，连应用的姿态都没有。
进入 21 世纪的第二个十年，市场又发生了变化，云计算越走越近，也许我们中的大部分人今天还可以说只闻其声不见其形，但 The Data Center Is the Computer 这句话大家应该觉得很务实：完成一个用户操作，在服务器端的进程间通信次数前所未有地多。在这个十年，我们需要这样的编程语言：
1、能充分利用现代 CPU 的计算能力，不仅仅是多个核心，更是巨大的 L1/L2/L3 Cache、超线程等；
2、能够大量减小异步 I/O 的性能提升的同时带来的副作用：异步编程的复杂性以及对可维护性的伤害；
两 句话其实也可以压缩为一句：需要有更好的并发模型的语言。一开始大家都在已有的编程语言中寻找，然后找到了 erlang，实践证明 erlang 自有其局限，所以 google go/scala/rust 等新语言如同雨后春笋般拨地而出。C++2011 标准努力降低 C++ 的编程难度，并提供了线程库以支持现代 CPU，如果在 2005 年，这个标准绝对有竞争力，但在今天，它只能成为新的编程语言的垫脚石。正如 IE 最大的用处是用来下载其它浏览器，不久之后，也许会流行新的冷笑话：C++ 最大的用处就是用来实现其它编程语言。
市场一直在寻找一门中间的高级 语言，它上承 C 语言和汇编语言，下启脚本语言。C++ 最先抢占了高地，并在与 java/c# 的争斗中不落下风，但新的十年，它的对手又增加了 google go/scala/rust 等新锐，并且新的标准不可能在两三年内再次出台，两三年内新锐成长起来后，留给它的位置就不多了。
上 文讨论的基本上都是服务器编程，有必要再来看一下桌面和移动设备领域。首先看桌面软件，rust 是 mozilla 基金会开发系统程序语言的，它的定位是部分取代 C++ 开发 firefox 的浏览器，所以 rust 会进入桌面开发，google go 肯定会顺道啃一口。移动设备方面，主要是 android、ios 和 windows phone，随着移动设备性能增强，编译型语言加脚本的模式就会占大头，编译型语言方面主要是 C++ 和 Objective-C 在竞争，C++ 会占上风（但需求量远远小于脚本，从 lua 在 2011 年的增长速度可以印证），但是谁知道 rust 之类的会不会进入移动设备呢，毕竟移动设备的 CPU 核心也越来越多了呀，C++ 还是前景堪忧。
回首 C++ 的 30 年，展望它的未来，总结起来可能就是：标准化流程拖死人了。如果不是 15 年不能标准化，java/c# 的搅局可能不会出现；如果在 2005 年能够应对动态语言……如果云时代有更好的并发模型……
题 外话：java/c# 不会有 C++ 的问题，因为它们有自己的平台，有巨大的财富支撑。特别是平台的作用非常巨大，你可以想像一下如果 Adobe 有自己的浏览器或手机操作系统 ActionScript/MXML 会不会是今天的境地；也可以想像一下 google go 的飞速发展动力是什么。

两点解释

劳动密集型公司

这样的公司以业务为导向，市场团队在公司中占据较高的地位。每一个技术人员最终被折算到了“人天”里面去，团队规模相对较大，所有技术人员都比较容 易被替代，能力强的可以做更多的事情，能力弱的就少做一些。通过强有力的制度、政策和流程的规约，团队有条不紊地运作起来。业务氛围强势，技术通道升级较 慢，需要非常长期的积累才可以获得丰厚的回报，诸多优秀人才脱离编码，而潜心转管理、谈需求并获得回报。愿意招纳毕业生编码，以减小运营成本。只鼓励小范 围、浅层次的创新，对于优秀的创意、想法，必须转化为生产力才能够被认可。

技术密集型公司

这样的公司较为重视技术和创新，敢于在产品中使用预期能够带来收益的技术。公司非常愿意招聘一些有丰富研发经验、有广泛阅历的程序员加入，同时也能 吸引一些比较优秀的技术人才，并且长期为公司工作。团队人员较少，研发过程无论是从时间还是环境来看，通常比较宽松，用较少约束、任务驱动的形式，鼓励程 序员按期完成下发的任务。技术人员层次划分较多，不同层次技术人员在一起办公，往往都不脱离编码，和项目结合紧密。愿意招不同层次的研发人员，不愿意招经 验丰富但脱离技术的人到研发团队。

思维密集型公司

这样的公司对研发人员思辨能力要求较高，愿意做一些创造性的产品。公司技术人员的招聘较为严格，更看重人员的创新气质、解决问题的思路、建模和抽象 的能力，而对于具体的某种技术实现，并没有很高的要求。团队人员不多，项目压力不大，任务给定的要求和流程约束较少，需要团队成员较强的自主能力来解决问 题。技术人员层次划分不多，讨论气氛浓厚，设计精益求精，创新的点子容易得到认可并尝试实现。

你所在的公司，属于哪一种？

博士
　　　有一个博士分到一家研究所，成为学历最高的一个人。
　　　有一天他到单位后面的小池塘去钓鱼，正好正副所长在他的一左一右，也在钓鱼。
　　　他只是微微点了点头，这两个本科生，有啥好聊的呢？
　　　不一会儿，正所长放下钓竿，伸伸懒腰，蹭蹭蹭从水面上如飞地走到对面上厕所。
　　　博士眼睛睁得都快掉下来了。水上飘？不会吧？这可是一个池塘啊。
　　　正所长上完厕所回来的时候，同样也是蹭蹭蹭地从水上飘回来了。
　　　怎么回事？博士生又不好去问，自己是博士生哪！
　　　过一阵，副所长也站起来，走几步，蹭蹭蹭地飘过水面上厕所。这下子博士更是差点昏倒：不会吧，到了一个江湖高手集中的地方？
　　　博士生也内急了。这个池塘两边有围墙，要到对面厕所非得绕十分钟的路，而回单位上又太远，怎么办？
　　　博士生也不愿意去问两位所长，憋了半天后，也起身往水里跨：我就不信本科生能过的水面，我博士生不能过。
　　　只听咚的一声，博士生栽到了水里。
　　　两位所长将他拉了出来，问他为什么要下水，他问：“为什么你们可以走过去呢？”  
　　　两所长相视一笑：“这池塘里有两排木桩子，由于这两天下雨涨水正好在水面下。我们都知道这木桩的位置，所以可以踩着桩子过去。你怎么不问一声呢？”  

　　　这个故事告诉我们：学历代表过去，只有学习力才能代表将来。尊重经验的人，才能少走弯路。一个好的团队，也应该是学习型的团队。 

个人理解和感悟：看学历更要看能力

　　　招聘广告上面我们经常会看到“要求本科以上学历”，很少有企业招聘的时候 是不在乎学历的，而且在一些正规的企业里，如果没有足够的学历，是不予以考虑加薪升职的。企业在人才的竞争上面出现了一种盲目攀比学历的不良倾向，现在经 常可以看到在某些企业的官方介绍上面写“公司的本科以上学历占有xx比例”的字眼，，似乎聘用的人才学历越高
越好，在职员工高学历的越多越好。有一则消息称研究生学历的人比本科学历的人平均年薪要高出2w元，从这里看出，学历在企业招聘和考核中的重要性。

　　　现在越来越多的人坚持考研或者读MBA,他们认为一旦有了高的学历就可以“春风得意马蹄疾，一页看遍长安花”了。目前学历仍然是一个隐形的、力量巨大的“杀手”，生生的把没有一纸文凭的人拒之门外。

　　　有文凭不等于有水平，没有学历不等于没有能力，大量的事实说明， 不少才华横溢、能力卓越的人才，他们并没有高的学历，有的甚至没有大学文凭，例如爱迪生、高尔基诺贝尔 比尔盖茨 乔布斯等，这些人虽然没有高的学历，但是他们取得的成就是非凡的，同样现实中生活中也能轻易的发现，很多拥有高学历的人在工作中能力平平、毫无建树、庸庸 碌碌的过万了一生，管理者在选择人才时，只能把学历当作一种参考条件，更重要的是要看这个人的实际能力。如果企业不从实际出发，竞相制定一些高学历的规 定，对学历的要求过为严格，甚至唯学历取人，很难选拔出优秀的人才，衡量人才既要有文化程度方面的要求，更总要视履行岗位职责的能力，真正使那些有学历， 有智慧又有能力的人得到重用.

　　　 伯 乐相马，主要是看马能否跑千里而不是看马的出身。近有消息说，有些用人单位招聘人才的取向已更加务实，选才标准正在由“学历型”向“能力型”转变，这是一 种令人欣慰的转变。毕竟，千里马是跑出来的，人才是干出来的。创造业绩主要不是靠职前的学历，而是靠任职后的实践经历和创造性努力。但愿我们公开选拔干部 时，能够更重任职的能力而不是更重职前的学历。

　　　一个人是否真正的有才能，并不能以学历作为衡量的唯一标准，管理者在选人、用人时，不要被学历遮住了视野，二应该把有实际能力的员工放在最重要的位置上

春节前和同事在回家的路上看到了建筑工地，不由的感慨建筑业相比软件业来讲实在是成熟太多了！ 想想看，建筑师设计好图纸，交给建筑公司（大包工头）， 大包工头再报给小包工头， 小包工头随便抓一些农民工就可以干活了！ 农民工们可不懂得那么多高深的建筑原理， 对整个建筑也并不了解，可是他们只需要把自己的一砖一瓦做好，整个建筑就能做成了 -- 当然也有豆腐渣工程-- 但毕竟是少数，排除在外。

更重要的是他们根本不用担心项目的后期客户突然想改设计方案，客户不会也不可能要求你把朝北的窗户挪到南边去，也不会要求把10层楼中的第3层和第7层扒掉重盖。

我们这些苦苦挣扎的码农们肯定会想， 什么时候软件业也能这样啊，什么时候我们也能快乐编程，按时上下班，或者以后这些底层的Labor work都让机器人做了， 我们都去做需求，架构，设计， 然后项目按进度，高质量的完成， 大家都很happy...

但是无数的无情现实告诉教育我们：别做梦了，这是绝对不可能的， 至少在可以预见的时间段(比如50年)是不可能的， 原因就在于软件的复杂性，在现有的技术情况下， 软件的固有复杂性无法解决， 只有依靠我们这么码农们去弥补。

为什么软件这么复杂， 为什么我们无法像建筑业盖房子，汽车业装配汽车一样去写软件？

布鲁克斯 在著名的《人月神话》中提到软件的内在复杂性， 的确，软件系统的复杂性远远超过建筑业和制造业， 软件的需求是在人的脑子中的， 用自然语言都很难完整、准备的表达出来，更不用说用计算机（好吧，更好听的名字是”电脑“）这种原始的工具了。 不错，我用的正是”原始“这个词， 从二进制语言，到汇编语言，再到高级语言，其最基本的、最核心的东西依然是顺序，循环，分支， 即使加上面向对象，动态语言，库， 框架，计算机语言的本质仍然没有改变，我们只是在已经建好的大厦上做装饰而已。  使用这种原始的工具，怎么能够表示复杂的需求？ 

程序员的出现正是为了填充这之间的巨大鸿沟，程序员需要用自己的大脑，使用极其”原始“的工具， 把无法准确表述的，尚在脑子中的需求映射到代码上，其难度可想而知！

当然我们程序员也不笨， 在长期的斗争中，我们学会了把一个问题用划分为一个一个的模块， 让这些模块低耦合，高内聚，  我们还学会了分层，让各个部分的联系达到最小， 可是所有的这些努力只是把复杂性降低了一点， 本质的复杂性依然存在。

未完待续。。。

历史上的今天
回顾历史的今天,历史就像生活的一面镜子;可以了解历史的这一天发生的事件;借古可以鉴今;历史是不能忘记的.要记住历史的每一天
http://www.todayx.org/

酒宴开始。

酒杯盛酒，酒杯碰撞，这是物理层；

你要根据不同人的外貌特征找到你要敬酒的人所坐的位置，这是IP协议（网络层）；

你明白，敬酒的实际目的是加深感情，这在应用层，而这酒中的感情，才是报文的数据部分。

你和某位新见面的兄弟互相来回敬酒，这叫TCP；

你给同一位好兄弟敬酒好多次，死命灌他，他也不回礼，这叫UDP；

你对全桌的人说，来，咱们同归于尽，这叫广播；

你在对这一桌的人顺序挨个敬酒，这叫令牌环。

你对该兄弟说，初次见面，请多关照，请问阁下尊姓大名，敬酒一杯，这叫SYN报文；

这位兄弟说，同是天涯沦落人，相逢何必曾相识，喝！这叫ACK报文；

你一看，对方的啤酒怎么没有气泡啊，不行，你怎么能拿茶水当啤酒呢？这叫数据校验。

有一个兄弟过来给你桌上的领导敬酒，你说不行，领导喝多了，不能再喝了，这叫防火墙；

有一位兄弟过来敬酒，你说10分钟里面已经喝了5杯了，达到我极限了，这叫带宽；

而且我还没回礼呢，现在喝不下了，先缓缓，这叫拥塞控制；

你现在要给你最好的兄弟敬酒，于是你先找到了他所在的桌子（网络号），再找到他本人的位置（主机号）；

从你要准备敬酒到敬酒完成，这叫时延，其中要经历倒酒（发送时延）、碰杯（传播时延）、你的兄弟被灌下（处理时延）这几个过程。

终于，你醉了，你吐了一地，不省人事，这叫缓冲区溢出。

历史上的今天
回顾历史的今天,历史就像生活的一面镜子;可以了解历史的这一天发生的事件;借古可以鉴今;历史是不能忘记的.要记住历史的每一天
http://www.todayx.org/

历史上的今天
回顾历史的今天,历史就像生活的一面镜子;可以了解历史的这一天发生的事件;借古可以鉴今;历史是不能忘记的.要记住历史的每一天
http://www.todayx.org/

历史上的今天
回顾历史的今天,历史就像生活的一面镜子;可以了解历史的这一天发生的事件;借古可以鉴今;历史是不能忘记的.要记住历史的每一天
http://www.todayx.org/

等于还是不等于？

看来看下面的一段代码：

   代码片段1

Java代码  

1. public static void main(final String[] args) {  
2.     Integer a = new Integer(100);  
3.     Integer b = 100;  
4.     System.out.println(a == b);   
5. }  

 这段代码的输出是什么？相信很多人都会很容易的猜到：false，因为a、b两个对象的地址不同，用“==”比较时是false。恭喜你，答对了。

再看下面的一段代码：

   代码片段2

Java代码  

1. public static void main(final String[] args) {  
2.     Integer a = 100;  
3.     Integer b = 100;  
4.     System.out.println(a == b);   
5. }  

你可能会回答，这没什么不一样啊，所以还是false。很遗憾，如果你执行上面的一段代码，结果是true。

上面的代码可能让你有些意外，那好吧，再看看下面的这段代码：

    代码片段3

Java代码  

1. public static void main(final String[] args) {  
2.     Integer a = 156;  
3.     Integer b = 156;  
4.     System.out.println(a == b);   
5. }  

 结果是true吗？很遗憾，如果你执行上面的一段代码，结果是false。

 感到吃惊吗？那最后再看下面的一段代码：

    代码片段4

Java代码  

1. public static void main(final String[] args) {  
2.     Integer a = Integer.valueOf(100);  
3.     Integer b = 100;  
4.     System.out.println(a == b);   
5. }  

最后的结果，可能你已经猜到了，是true。

为什么会这样？

现在我们分析一下上面的代码。可以很容易的看出，这一系列代码的最终目的都是用“==”对两个对象进行比较。Java中，如果用“==”比较两个对象结果为true，说明这两个对象实际上是同一个对象，false说明是两个对象。

现在，我们来看看为什么会出现上面的现象。

我们先看代码片段4：最后的运行结果是true，说明a、b两个对象实际上是同一个对象。但是a对象是通过调用Integer的valueOf方法创建的，而b对象是通过自动装箱创建出来的，怎么会是同一个对象呢？难道问题在字节码那里，毕竟Java程序是依靠虚拟器运行字节码来实现的。

通过jdk中自带的工具javap，解析字节码，核心的部分摘取如下：

Java代码  

1. 0:  bipush  100  
2. 2:  invokestatic    #16; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;  
3. 5:  astore_1  
4. 6:  bipush  100  
5. 8:  invokestatic    #16; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;  

代码中我们只调用了一次Integer.valueOf方法，但是字节码中出现了两次对Integer.valueOf方法的调用。那么另一次是哪里呢？只可能在自动装箱时调用的。因此这段代码实际上等价于：

Java代码  

1. public static void main(final String[] args) {  
2.     Integer a = Integer.valueOf(100);  
3.     Integer b = Integer.valueOf(100);  
4.     System.out.println(a == b);   
5. }  

 现在问题就简单了：看jdk源代码，查看valueOf方法的具体实现：

Java代码  

1. public static Integer valueOf(int i) {  
2.     final int offset = 128;  
3.     if (i >= -128 && i <= 127) { // must cache   
4.         return IntegerCache.cache[i + offset];  
5.     }  
6.     return new Integer(i);  
7. }  

看到这儿，上面的代码就很明确了：对于-128到127的数字，valueOf返回的是缓存中的对象。所以两次调用Integer.valueOf(100)返回的都是同一个对象。

我们再先看代码片段3：根据上面的分析，代码片段3实际上等价于以下代码：

Java代码  

1. public static void main(final String[] args) {  
2.     Integer a = Integer.valueOf(156);  
3.     Integer b = Integer.valueOf(156);  
4.     System.out.println(a == b);   
5. }  

 由于156不在-128到127范围内，所以两个对象都是通过new Integer()的方式创建的，所以最后结果为false。

 片段1和片段2就不做具体分析了，相信读者可以自行分析。

 最后，请大家思考一下问题：通过上面的分析，了解到整数的自动装箱是通过Integer.valueOf(int number)实现的，那么自动拆箱是如何实现的呢？

1.关于JSP标签的好处就不再罗嗦

数据字典就是使用的下拉框，只要定义使用那个字典就会将这个字典可用的内容显示出来

显示字典时只要定义那个字典和属性值就可以显示出字典的显示值

2.首先在web.xml中定义自定义标签加载的引用，两个属性分别是引用的URI和加载路径

Xml代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee     
5.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
6.     <welcome-file-list>  
7.         <welcome-file>index.jsp</welcome-file>  
8.     </welcome-file-list>  
9.     <jsp-config>  
10.         <taglib>  
11.             <taglib-uri>/tld/web-html</taglib-uri>  
12.             <taglib-location>  
13.                 /WEB-INF/tlds/web-html.tld  
14.             </taglib-location>  
15.         </taglib>  
16.     </jsp-config>  
17. </web-app>  

3.在web-html.tld中定义自己的标签，数据字典应用的话我们需要一个标签库，三个标签。分别是，select标签，options标签，和现实数据字典的标签，每个标签都对应不同的实现类

Xml代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"    
3.     "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">  
4. <taglib>  
5.     <tlib-version>1.0</tlib-version><!-- 标签库版本 -->  
6.     <jsp-version>1.2</jsp-version>  <!-- 标签库要求的JSP规范版本 -->  
7.     <short-name>html</short-name>   <!-- JSP页面编写工具可以用来创建助记名的可选名字 -->  
8.     <tag>  
9.         <name>select</name>  
10.         <tag-class>com.SelectTag</tag-class>  
11.         <body-content>JSP</body-content>  
12.         <attribute>  
13.             <name>name</name>  
14.             <rtexprvalue>true</rtexprvalue>  
15.         </attribute>  
16.         <attribute>  
17.             <name>style</name>  
18.             <rtexprvalue>true</rtexprvalue>  
19.         </attribute>  
20.     </tag>  
21.     <tag>  
22.         <name>options</name>  
23.         <tag-class>com.OptionsTag</tag-class>  
24.         <body-content>JSP</body-content>  
25.         <attribute>  
26.             <name>collection</name>  
27.             <rtexprvalue>true</rtexprvalue>  
28.         </attribute>  
29.     </tag>  
30.     <tag>  
31.         <name>selectDisplay</name>  
32.         <tag-class>com.SelectDisplay</tag-class>  
33.         <body-content>JSP</body-content>  
34.         <attribute>  
35.             <name>collection</name>  
36.             <rtexprvalue>true</rtexprvalue>  
37.         </attribute>  
38.         <attribute>  
39.             <name>name</name>  
40.             <rtexprvalue>true</rtexprvalue>  
41.         </attribute>  
42.         <attribute>  
43.             <name>value</name>  
44.             <rtexprvalue>true</rtexprvalue>  
45.         </attribute>  
46.     </tag>  
47. </taglib>  

4.实现类

实现类的作用就是在后台拼接所需HTML标签内容，然后由JSP进行输出

实现类最主要的两个方法，一个遇到这个标签开始时输出，一个是结束时输出

如果需要定义属性，可以参考实现类定义属性，并在TLD中定义，在JSP中使用标签时快捷键就可以出来这个属性

首先是select标签的代码：

Java代码  

1. package com;  
2. import java.io.IOException;  
3. import javax.servlet.jsp.JspException;  
4. import javax.servlet.jsp.JspTagException;  
5. import javax.servlet.jsp.tagext.BodyTagSupport;  
6. /** 
7.  * TagSupport与BodyTagSupport的区别: 
8.  * 主要看标签处理类是否要读取标签体的内容和改变标签体返回的内容，如果不需要就用TagSupport，否则就用BodyTagSupport 
9.  * 用TagSupport实现的标签，都可以用BodyTagSupport来实现，因为BodyTagSupport继承了TagSupport 
10.  */  
11. @SuppressWarnings("serial")  
12. public class SelectTag extends BodyTagSupport {  
13.     @Override  
14.     public int doStartTag() throws JspException {  
15.         try {  
16.             StringBuffer results = new StringBuffer("<select");  
17.             if(name != null){  
18.                 results.append(" name=\"");  
19.                 results.append(name);  
20.                 results.append("\"");  
21.             }  
22.             if(style != null){  
23.                 results.append(" style=\"");  
24.                 results.append(style);  
25.                 results.append("\"");  
26.             }  
27.             results.append(">");  
28.             pageContext.getOut().write(results.toString());  
29.         } catch (IOException ex) {  
30.             throw new JspTagException("错误");  
31.         }  
32.         return EVAL_BODY_INCLUDE;  
33.     }  
34.     @Override  
35.     public int doEndTag() throws JspException {  
36.         try {  
37.             StringBuffer results = new StringBuffer("");  
38.             // 因为下拉中包含下拉内容，所以只能在遇到结束标签时才能写select结束  
39.             results.append("</select>");            
40.             pageContext.getOut().write(results.toString());  
41.         } catch (IOException ex) {  
42.             throw new JspTagException("错误");  
43.         }  
44.         return EVAL_PAGE;  
45.     }  
46.     // 样式  
47.     protected String style;  
48.     // 名字  
49.     protected String name;  
50.     public String getStyle() {  
51.         return style;  
52.     }  
53.     public void setStyle(String style) {  
54.         this.style = style;  
55.     }  
56.     public String getName() {  
57.         return name;  
58.     }  
59.     public void setName(String name) {  
60.         this.name = name;  
61.     }     
62.     /** 
63.     doStartTag()方法是遇到标签开始时会呼叫的方法，其合法的返回值是EVAL_BODY_INCLUDE与SKIP_BODY,前者表示将显示标签间的文字，后者表示不显示标签间的文字 
64.     doEndTag()方法是在遇到标签结束时呼叫的方法，其合法的返回值是EVAL_PAGE与SKIP_PAGE，前者表示处理完标签后继续执行以下的JSP网页，后者是表示不处理接下来的JSP网页 
65.     doAfterBody(),这个方法是在显示完标签间文字之后呼叫的，其返回值有EVAL_BODY_AGAIN与SKIP_BODY，前者会再显示一次标签间的文字，后者则继续执行标签处理的下一步 
66.     EVAL_BODY_INCLUDE：把Body读入存在的输出流中，doStartTag()函数可用 
67.     EVAL_PAGE：继续处理页面，doEndTag()函数可用 
68.     SKIP_BODY：忽略对Body的处理，doStartTag()和doAfterBody()函数可用 
69.     SKIP_PAGE：忽略对余下页面的处理，doEndTag()函数可用 
70.     EVAL_BODY_BUFFERED：申请缓冲区，由setBodyContent()函数得到的BodyContent对象来处理tag的body，如果类实现了BodyTag，那么doStartTag()可用，否则非法 
71.     EVAL_BODY_AGAIN：请求继续处理body，返回自doAfterBody()，这个返回值在你制作循环tag的时候是很有用的   
72.     预定的处理顺序是：doStartTag()返回SKIP_BODY,doAfterBodyTag()返回SKIP_BODY,doEndTag()返回EVAL_PAGE 
73.     如果继承了TagSupport之后，如果没有改写任何的方法，标签处理的执行顺序是：doStartTag() ->不显示文字 ->doEndTag()->执行接下来的网页  
74.     如果您改写了doStartTag(),则必须指定返回值, 
75.     如果指定了EVAL_BODY_INCLUDE,则执行顺序是：doStartTag()->显示文字->doAfterBodyTag()->doEndTag()->执行下面的网页 
76.      */  
77. }  

关于返回参数，返回具体数字也可以，不用过于纠结

然后是下拉内容实现类

Java代码  

1. package com;  
2. import java.io.IOException;  
3. import javax.servlet.jsp.JspException;  
4. import javax.servlet.jsp.JspTagException;  
5. import javax.servlet.jsp.tagext.BodyTagSupport;  
6. @SuppressWarnings("serial")  
7. public class OptionsTag extends BodyTagSupport {  
8.     @Override  
9.     public int doStartTag() throws JspException {  
10.         return EVAL_BODY_INCLUDE;  
11.     }  
12.     @Override  
13.     public int doEndTag() throws JspException {  
14.         try {  
15.             StringBuffer results = new StringBuffer("");  
16.             if ("SEX".equals(collection)) {  
17.                 results.append("<option value=\"0\"  selected=\"selected\">请选择</option>");  
18.                 results.append("<option value=\"1\">男</option>");  
19.                 results.append("<option value=\"2\">女</option>");  
20.             }  
21.             pageContext.getOut().write(results.toString());  
22.         } catch (IOException ex) {  
23.             throw new JspTagException("错误");  
24.         }  
25.         return EVAL_PAGE;  
26.     }  
27.     // collection只是传递一个标识，具体下拉值内容是从数据库取还是从请求中得到为不同具体实现  
28.     protected String collection;  
29.     public String getCollection() {  
30.         return collection;  
31.     }  
32.     public void setCollection(String collection) {  
33.         this.collection = collection;  
34.     }  
35. }  

具体你的字典数据从数据库中如何存储如何查询，可以自定义实现

显示的标签实现，为了将来可以在页面取到标签内容值，我们定义隐藏域来保存属性值，然后在显示显示内容

Java代码  

1. package com;  
2. import java.io.IOException;  
3. import javax.servlet.jsp.JspException;  
4. import javax.servlet.jsp.JspTagException;  
5. import javax.servlet.jsp.tagext.BodyTagSupport;  
6. @SuppressWarnings("serial")  
7. public class SelectDisplay extends BodyTagSupport {  
8.     @Override  
9.     public int doStartTag() throws JspException {  
10.         try {  
11.             StringBuffer results = new StringBuffer("");  
12.             pageContext.getOut().write(results.toString());  
13.         } catch (IOException ex) {  
14.             throw new JspTagException("错误");  
15.         }  
16.         return EVAL_BODY_INCLUDE;  
17.     }  
18.     @Override  
19.     public int doEndTag() throws JspException {  
20.         try {  
21.             StringBuffer results = new StringBuffer("");  
22.             if ("SEX".equals(collection)) {  
23.                 results.append("<span>");  
24.                 results.append("<input type=\"");  
25.                 results.append("hidden\" name=\"");  
26.                 results.append(getName());  
27.                 results.append("\"");  
28.                 results.append(" value=\"");  
29.                 results.append(getValue());  
30.                 results.append("\">");                 
31.                 if ("1".equals(getValue())) {  
32.                     results.append("男");  
33.                 } else if ("2".equals(getValue())) {  
34.                     results.append("女");  
35.                 } else {  
36.                     results.append("请选择");  
37.                 }  
38.                 results.append("</span>");  
39.             }  
40.             pageContext.getOut().write(results.toString());  
41.         } catch (IOException ex) {  
42.             throw new JspTagException("错误");  
43.         }  
44.         return EVAL_PAGE;  
45.     }  
46.     // collection只是传递一个标识，具体下拉值内容是从数据库取还是从请求中得到为不同具体实现  
47.     protected String collection;  
48.     // 传递的值  
49.     protected String value;  
50.     // 该属性的名称  
51.     protected String name;  
52.     public String getCollection() {  
53.         return collection;  
54.     }  
55.     public void setCollection(String collection) {  
56.         this.collection = collection;  
57.     }  
58.     public String getName() {  
59.         return name;  
60.     }  
61.     public void setName(String name) {  
62.         this.name = name;  
63.     }  
64.     public String getValue() {  
65.         return value;  
66.     }  
67.     public void setValue(String value) {  
68.         this.value = value;  
69.     }  
70. }  

5.JSP中引用，直接在index.jsp中引用

需要引入相应的标签内容，引入的方式在JSP头部引用

标签的属性可以设置也可以不设置，标签的使用和HTML标签的使用是一样的，定义属性即可

Jsp代码  

1. <%@ page language="java" pageEncoding="UTF-8"%>  
2. <%@ taglib uri="/tld/web-html" prefix="html"%>  
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <head>  
6.         <title>JSP 自定义标签的实现</title>  
7.     </head>  
8.     <body>  
9.         请选择：  
10.         <html:select name="sex" style="width:100px">  
11.             <html:options collection="SEX"></html:options>  
12.         </html:select>  
13.         显示性别：  
14.         <html:selectDisplay collection="SEX" value="1" name="sex"></html:selectDisplay>       
15.     </body>  
16. </html>  

6.后话

访问项目就可以看到效果，附件是这个项目的源代码，导入到MyEclipse中可以查看

如果想要自己设计一个大的标签库，可以设计一个父类，包含一些主要的属性，例如name，id，style等属性。然后在子类中定义自己的特有属性

这个实现只是学习一下JSP自定义标签使用的HelloWorld程序，然后包含了字典应用的实际例子，程序简单，仅供参考

已经是到北京的第五个年头了，从最开始的想做手机游戏而学习编程，到后来做 Web 开发，又开始做日志分析，接触到了 Hadoop ，最终确定下来自己的技术方向。曾经以为五年的时间，差不多都应该做出自己的产品来，而实际情况却是：一直在用的技术还了解的只是皮毛。所以，虽然在 IT 这个行业已经可以说自己工作了五年时间，但感觉自己还只是刚刚起步，跑在前面的大有人在，自己还要继续努力。

从去年开始接触的 Hadoop ，当时的日志分析已经遇到了瓶颈，用 Hadoop 一试，确实性能提高不少，只可惜，当时的公司因为各方面的原因，开始关注云存储这个方向，虽然即使到了现在我也不太好判定这个战略方向的转变 是对还是错，但是对于当时只是普通员工的我来说，刚好发现了一个实用的技术却没有时间和机会研究、应用，让人都有点恼火。可能像我这样的凡夫俗子，还没有 达到能站在和老板相同高度看待问题的程度，而我能做的，换家公司，找一个能应用自己感兴趣的技术的公司。于是， 2011 年，就又以跳槽开始了。

但 是我并没有想到今年会跳两次，我一直都感觉自己是个踏踏实实的人，但实际情况却是这几年北京这几个同学我换的工作最多。我也很明白：频繁的换工作，害的其 实是自己。每一份工作，都需要花一定的时间去适应，就拿试用期来说，一般的都应该是三个月吧，一年换两份工作，光试用期就半年出去了，真正能踏踏实实做点 事的时间，又能有多少呢？本来在年初换工作时，打算结婚也被拿了出来说事，还想着有上一年的时间，在老家付个首付，没有想到，造化弄人，六月份的时候，一 边看着转正的通知邮件，一边和主管协商着什么时候离职。

但 我并不后悔去了这家公司，虽然只有短短两个月的时间，却让我学到了很多东西，开阔了视野。原来还有这样让人认同的企业文化，原来还有经历这么丰富的同事， 原来还有这么爱带着兄弟们吃喝玩乐的主管，原来程序员的生活，不一定就是加班加班，原来我们可以让自己的生活更精彩。尤其是在去了一趟杭州之后。第一次坐 飞机，下飞机的时候耳膜难受的要死，声音都快听不见了，而我们只有一天的时间，第二天就又要飞回北京，我是想着赶紧休息休息，而同事是一边说着西湖、苏堤 啥的就双眼冒光，大晚上的整个绕西湖走了一圈，没把我累死。不过也确实感受到了和北京不一样的生活方式和态度，那些就在岸边上的茶庄，彰显着和北京烧烤摊 不一样的韵味。只是，当终于下了飞机，换了快轨，出了地铁之后，又一次回到北京的地面上时，我竟然都有种过年时候回到了老家的感觉，原来，在一个城市生活 上一段时间，哪怕只是几年，或多或少的，竟然会产生感情。

可 惜的是，我还没有体会的多深，因为公司内部的原因，我们的项目没用做成，大家因为这个项目聚在了一起，项目没了，大家也就都散了。而且散的那么快，快的都 不可思议。应聘到了一个公司，一个项目做不成，那还可以做别的，一个公司可以有好多项目，而我们这个项目组的成员，明显大家都很有自己的想法，只想做自己 想做的事，而并不是到了一个公司后就开始混日子。那么既然是这样，我想我应该祝福他们，后来一个月后，主管又联系我们聚了一次，大家果然都在做自己擅长、 喜欢的工作，虽然已经不在一个团队，但由衷的为他们感到高兴。

应该说，今年我本来是起了一个好头，在项目组中有这些有着共同理想的同事，但因为中间的变故，团队散了，我也慢慢的走向了堕落。现在回想起来，简直都觉得有点不可思议。

在等待离职的日子里，我看完了《七龙珠》全集，还有《盗墓笔记》，看到最新的更新 ( 当时还没有完结 ) ，每天去了之后就是看漫画、看小说，本来之前因为项目的原因，一个月的时间把 Demo 写的差不多都可以进行演示了，结果变故一来，立马就好像泄了气的皮球一样，什么准备结婚，什么钻研技术，一概不管，完全就把上班当成了去网 吧。自然，白天都成这样了，晚上还期望能老老实实的看书吗，不可能了，再然后，等再到了新公司之后，看书的习惯就怎么也没用再培养起来。

到 了新公司，这个应该老实点了吧，毕竟当时都已经六月份了，半年的时间都已经过去了，如果再折腾折腾，整个一年就过去了，技术这玩意，要说看看书就能学会， 我还真是做不到，必须得有实际的东西去做，在项目上应用，才能快速的掌握。道理也都明白，可就是中间经历了那么一档子事之后，整个人都浮躁了起来，再想回 到以前的状态，真的很难，只能是慢慢的适应。

这 一适应就又是三个月，十一假期时候，交接过来的老版本的日志分析系统出了次问题，正好赶上在唐山参加同学婚礼，三十号下午到的唐山，晚上和同学侃到一两 点，四五点又起来接新娘盘头，参加一天的婚礼下午又坐车回北京，休息了一个晚上之后，从二号早上七点开始恢复数据，一直到三号早上六点，之前也加班搞过通 宵，但像这次这样整还真是头一次，完事之后啥感觉？要说程序写的不好能害死人，程序交接的不好，更能害死人。

假期之后，替换老系统的计划提上了日程，和之前的不一样，也不用再写什么 Demo 先演示啥的，论证已经通过，直接开始用就是。 Hadoop 、 HBase 、 Hive 、 Chukwa 、 Sqoop ，一个都不能少，有很多时候其他组的同事看到我在整 Hive 都奇怪：你们组就每天调 SQL ？

有的时候我自己都快搞不清业务关系，以及写好的 hql 的执行条件，以至于写了一大堆的脚本，而其他同事在某一处想调试时，光这个执行顺序我就得好好解释一遍，突然发现，我现在的这套程序，虽然听 上去比之前老版本的简单，但实际执行的步骤复杂，随着考虑问题的增多，我的脚本也越来越多，慢慢的，可能就和老系统差不多了，只不过，老系统是一个脚本执 行 N 多程序，我是 N 多程序对应着自己的脚本。原来，程序员看别人的程序与看自己的程序，在最开始的时候，是有私心的。

把 HBase 中表的存储空间从 150G 优化到了 120G ， hql 分析时间由两个小时优化到了半个小时，好像有那么点成果，可是自己一直对执行效率不是很满意，捣鼓了一个多月一直都没啥进展，直到在和同事的讨论中，听取了别人的建议，再结合自己的业务，存储一下从 120G 优化到了不到 5G ，执行时间也从三个小时优化到了十分钟。但是，这样就已经可以了吗？不行， 2012 ，还得继续。此外，明白了一个道理：和别人多沟通、多分享，比自己一个人埋头苦干要强百倍。

剩下的，对来年做个规划吧， 2012 了，该办的事必须得抓紧时间办啊。

关 于看书，之前看过一篇文章，提到程序员都是自学成才，通过项目，通过好书，尤其是精读一本好书。只是可惜，计算机类的图书，越是好书块头越大，看前头几章 的时候压力最大，“这得啥时候才能看完呢？”虽然这是个错误的观点吧，但有时候还是忍不住会去想，这个时候，毅力、恒心真的很重要，当然，如果是结合项目 需要来看，那就更好了，一边看一边能解决实际问题，这样看书肯定是效率百倍。如果能再按照书中给出的练习强度来检查学习程度，那就更加 OK 了，只是，结合自身实际来看，这个也需要点恒心。

列下书单吧，希望自己能坚持完成。

《深入理解计算机系统》

《 Java 编程思想》

《 C++ 编程思想》

《微积分学教程》

关 于英语，快放假了无所事事时，看到了篇讲如何学习英语的文章，很受启发，英语这玩意，先别说它重不重要，要想学，关键还是看自己有没有兴趣，有兴趣，再结 合合理的学习方法，如果能坚持一段时间，我想，应该是能见到点效果的吧。这个事情想了很长时间，但一直都只是停留在想想的阶段，从来就没有说实际行动过一 次。如果再不抓住这一年的时间，恐怕以后自己会找到更多的借口，所以，把这个也写上吧，一年的时间，说长不长，说短不短，多给自己安排点事，别再留出看漫 画的时间来。

列下目标吧，希望自己能坚持完成。

能看完一本原版英文小说

能听懂一部无字幕英文电影的对白

关于技术， Hadoop 现在只是应用，对它的源码还没有怎么看，接下来打算从比较简单入手，慢慢的，由浅入深吧，希望能对它的底层实现有更加清晰的认识。这个在日常工作中天天都用的到，按说应该是花时间最多的，希望能比前两个成绩多点吧。

目标的话，能分析一遍 Hadoop 及其子项目的源码。

计划列了不少，能全部完成的话还真得拜了佛，但不管怎样，能坚持完成二三，也算是对 2012 有个交代，一年的时间，激情会慢慢消磨殆尽，但如果能时不时的绷紧这根弦，把它养成习惯，或许也就省了烧香了。