Sunix's blog

快乐SAS

2009-07-05T16:24:00.001+08:00

3月30开始了在ebay的实习，之后一直纠缠在考试论文和实习中，博客也从此凉在了一边。据说四个月能养成一个好习惯，以后每周两篇日志将成为我的日常任务。

这两周考试基本搞定，一下子轻松了好多。除了学校施工的噪音和常有的一点点困惑，木得连烦心事都没有。开开心心得写程序学统计。地铁里见人玩俄罗斯方块，想想现在这生活也是差不多。不断有各种各样的task下来等着你处理，学习、生活、工作、爱情、未来。要顺顺利利地把它们搁到合适的地方。只要心不乱，并没有什么难的。

周末还是在图书馆过，暑期依然坐满了人。明天又是周一，继续学习、工作，平静而踏实的生活。还是会把大部分时间放在SAS上，技术上争取有个好的基础吧～读研已经一年，有那么点紧迫感。ebay给我最大的福利就是身边那些pro，热爱生活，乐于助人的同事。感谢他们并向他们学习。

下面这篇文章蛮经典，被引用了好多次，大致可以看出哪些是SAS的基本功。其中我学的不好的地方也就是这个假期的努力方向。但SAS毕竟是个分析软件，统计思维远比技术重要。下面的文章只是focus on SAS base, but if you can't know well about the tools, you can't do analysis well.

10 Things Experienced SAS® Programmers Don’t Know – But Should

Doug Zirbel, Pinnacle Solutions Inc., Indianapolis, IN

1. Macros - basic knowledge of macro language (Score=63/180)

Learning help:

“SAS manuals 'SAS Macro Language' and 'SAS Guide to Macro Processing' are the best. You will gain a lot with

playing examples in both books.”;

“'The Little SAS Book, A Primer', 2nd edition.”

"Carpenter's Complete Guide to the SAS Macro Language”

2. Data step - basic knowledge of (60)

The Secret Life of the Data Step, by Thomas Miron (SUGI21-26)

3. Data file manipulation - INFILE, UPDATE, SET intricacies etc

4. ODS - capabilities and more broadly, SAS8 improvements (53)

5. Efficiency (49)

PDV width may be more significant than number of rows Sorting by
character variables is more efficient than sorting by numeric variables

In terms of programming time, you’ll save a lot by getting rid of the warning messages up front

6. Data Step Vector - how it works (47)

The Secret Life of the Data Step, by Thomas Miron(SUGI21-26)

7. Macros - knowing how to write macros that write SAS programs (46)

8. System Development Life Cycle processes (44)

Code Complete by Steve McConnell

9. SAS Help - How to get it (40)

SAS Tech Support http://www.sas.com/service/index.html

SAS Tech Support (919) 877-8008 (be sure to have your site number)

WWW newsgroup comp.soft-sys.sas

http://groups.google.com using Advanced Group Search

with comp.soft-sys.sas as the Group (contains archives of

the newsgroup discussions)

SAS8 Help CD

10. Proc Report (34)

11. SQL Dictionary tables - basics of retrieving SAS metadata(31)

Data About Data: An Introduction To Dictionary Tables by Dilorio and Michal, SUGI21-32

12. Proc Summary/Means (28)

13. Debugging Techniques - DEBUG facility and other techniques(27)

14. Proc SQL (27)

15. Structured programming concepts (24)

16. Proc Format (18)

17. Relational Database Design (18)

18. Web technology - HTML, JavaScript, SAS IntrNet, etc (17)

19. Your Operating System native (and other) languages - REXX, unix scripts, VBScript, Syncsort (17)

20. Proc Transpose (16)

21. Data step reports - "Data _null_" report writing (14)

22. SCL - SCL Functions usable in e.g., Base SAS data steps(14)

SCL for the Rest of Us: Nonvisual Uses of Screen Control Language by Michael L. Davis

简单

2009-02-22T22:40:00.004+08:00

本想在图书馆看一天书，结果上午看了本《缓解压力》；中午又回宿舍睡了会觉，上网订了泳帽泳镜和羽毛球拍；下午看了前车约翰的《简单法则》；晚上翻了5期的《三联生活周刊》。一天下来，真正看教科书的时间加加起来才三个多钟。

《缓解压力60法》：多吃不同颜色的水果，有规律锻炼，游泳，多吃富含维生素B的食品，及时补充镁和铁。

《简单法则》：1.减少 reduce 2. 组织 organize 3. 时间 time 4. 学习 learn 5. 差异 difference 6. 背景 context 7. 感情 emotion 8. 信任 trust 9. 失败 failure 10. 单一 the one。

KFC原则-- K：Know what you what. F: Find out how to get it. C: Change the way until you get what you want.

简单-->复杂-->极简（朦胧）

山寨了张证件照

2009-02-08T23:30:00.010+08:00

显得比较无聊，山寨了张证件照。长得一般，精挑细选才找出了看着还算将就的。整整捣鼓了两个钟。发现比较自然的姿势是身体偏右15度，目视前方。

下午看“感动中国”，也的确很让人感动。在感动的同时，也有很多感慨，有些感动的事还是不要发生的好。一个个平凡又不简单的人，有些靠的是瞬间的风采，然而更多的是靠时间铸就了丰碑。看着他们的经历，我感到自己很幸运，也很渺小。

“工作是人的天职”，人需要一个终极的目标，这也许真要在宗教中才能寻找得到。如果做每件事都能怀着宗教的虔诚，把工作真正当成了为上帝创造荣耀的过程，相信心灵能少些浮躁，多些归属。

OK，原型搞定～

2009-02-05T13:51:00.006+08:00

从上月19号开工到现在，除去休息、跑亲戚、聚会的时间，其他时间都花在搞这个网站上。现在原型基本出来了，有些细节开学前每天花一定时间处理下应该就可以了。发现我依然是个优秀的美工，可写程序上除了精力充沛外基本没啥天分。犯了很多苦笑不得的错误。开发的一半时间在找自己整出的Bug，其他时间在不断地试着不同的解决方案。从Java整到了PHP；确定用PHP了吧，又换了两次IDE，从Eclipse到PhpED再到Netbeans。到开发临近完成，又开始了和图标、CSS之类的搏命。。。折腾。

Wordpress真是赞，如果不考虑性能方面的因素，基本可以满足一般网站的所有要求。丰富而清晰的权限设置；灵活的模板机制；丰富的插件主题资源；广大的用户群。。。这些都是其他的一些架构所难以比拟的。这次我的开发不过是对后台进行了一定剪裁，添加了一些功能；对模板进行了一定的修改；运用插件增添了一些功能。不过也有麻烦的地方，AJAX看着有点难懂；有些代码缺少注释；代码风格不大统一；有些设计过于优雅难以理解。。等等。也许是我PHP值太低的原因吧～

插件方面使用了GD Star Rating, Role-manager, WP-Pagenavi, WP-postviews, Search Everything；添了些花哨的功能，也省了不少的事情。模板是在Simple-X的基础上修改的，不过和重写基本没啥差别了。

初五

2009-01-30T13:03:00.003+08:00

半个假期过去了，转眼已是初五。从乐观到悲观，渐而急躁，金融学院工作论文网站这个项目进行得并不顺利，WordPress用到了一些对我而言比较新的东西。大部分的时间不是用在coding上，而是在学着杂七杂八的东西；PHP、AJAX、jQuery，一本本地翻着手册。有时国内时候，思路老是被杂七杂八的事儿打断，写了备忘录还是忘个精光，有点少年痴呆症的嫌疑。过年打打升级、看着牌都头疼，比较失败。

也许我又接了个不该接的项目，计划又被打乱。不过既然接了下来，也就没后路了；虽没有什么制约，可不搞定不光丢了我的面子，也丢了朋友的面子，只能多喝点咖啡少睡点觉了。十六号开始上课，计划过完正月十五回校，还有十天，只有十天。

生日

2009-01-24T10:46:00.003+08:00

今天是小年夜，也是我的生日。转眼已过去了24年，时间越过越快。试着看下电影，可没啥心情，看着长长的TodoList，呵呵，还是一件件事做吧。

昨天上午高中同学聚会，中午庆祝爷爷的生日，下午陪妹妹看了一下午日剧，晚上一直在读WordPress的文档。现在每天都又Google的Calendar记录自己做了什么，几点起床，看了什么电影，见了什么人，读了什么书。也许真是年龄大了，想在贫乏的生活中记录些什么吧。

WordPress的文档其实写的不错，就是组织得有点让我不习惯，同一篇文章会在多个系列或者多个分类中出现；不过Developer_Document组织得不错；还发现一个叫phpxref的网站，对几个流行的php源码提供了交叉索引，弥补了一些IDE的不足。PhpED也提供了不错的代码导航功能，可和一般IDE对Java的支持相比，还是有一些不便。

Chrome的profile功能很赞，等于提供了多个浏览器环境，可以在同一个站点可以用不同的帐号登录；可以在不同的profile中打开不同的一系列默认页面。这个功能不论是在日常使用还是在网页调试的时候都是很有用的。比如可以用一个profile用于默认网页浏览；另一个用于使用Google的产品；再加一个用于网页的开发测试。靠一些灵巧的小功能提供出色的用户体验，这也就是Google吧。

Php开发环境

2009-01-22T21:11:00.003+08:00

最近要写PHP，先是试了Dreamweaver，毕竟只是个网页设计软件，对编程的支持实在是比较有限。接着又试了PHPEclipse，不大稳定，而且搜索功能比较弱，不能和Eclipse下的JDT相比，这样读代码会很不方便。接着下了PhpED，满意，特别是看文档很方便，而且集成了很多方便的工具，而且还带有PHP的调试器。Seven great PHP IDEs compared dw上的一篇文章对七个著名的PHP IDE进行了比较。

PhpED自带了叫SVR的WEB服务器，如果要使用Apache作为服务器，需要将默认运行模式设成HTTP mod，然后在项目属性中设置好网络地址和server端的目录即可。软件自带的帮助文档中有详细的介绍。测试服务器的架设使用了xampp，集成了Apache, mysql, PHP, FileZilla FTP和Mercury Mail，解压就行，不用安装配置。

这两天磕着瓜子看PHP手册，比较无趣。小牛和Frienky大二那会就在写PHP了吧，我那会PHP看是看了些，只是没自己写过，后来就Java了。现在呢？我也不知道我在干啥～～管他呢，写代码。

开源CMS的选择

2009-01-19T22:08:00.003+08:00

最近可能要做一个文件的上传及发布系统，现在处于初步的分析阶段，我也不清楚到底在哪个平台上进行开发，但要肯定是不可能重新写。一来没有多少时间，最后开发可能只有半个多月的时间；二来没有技术上的特别要求，这么着我自然会选一个最方便的开发方法。网页的需求简单地说就是论文的提交、审核、网页及邮件发布，如果采用过于复杂的方案，有杀鸡用牛刀的嫌疑。

首先的设想是在一个CMS或者DMS系统的基础上进行修改。

首先要确定一个开发的基础，第一个想到的是看下有没有Java平台的软件。Java平台下比较著名的开源CMS系统有openCMS、InfoGlue和Magnolia，（详见java-source的论述）都是40余M的大小，有些文档都要收费，在短时间内了解其操作并在其基础上建站有些不大可能。其中openCMS有中文网站http://www.opencms.cn/，从中了解到国内还是有一些团队以openCMS为基础开发商用软件的，有人说openCMS一般适用于日访问量达150,000页面的网站，想必其它两个体积相似的东东也差不多，我因此放弃了这方面的寻找。

接着我看到了plone的介绍，一个基于zope的用python写的CMS系统，http://plone.org/是其官方网站，安装包里包含了python、zope，像应用程序一样安装。网站上还有几段很有意思的视频可以看看。试用下来认为这绝对是个出色的CMS系统，简洁而强大。但仍然不符合我的需求。在网站上还看到了一句话"Java is the COBOL in 21st "。

想到了PHP，在下面的网站上有php主流cms系统测评http://www.php-cms.cn。然后听人说WordPress是个不错的选择。想想这也许是个最简洁的方案了，WordPress众多的插件和方便的扩展机制也许真大大减少我的工作量。Nice！

这么一个个试用下来折腾了我大半天的时间，舍近求远的后果。

Excel概述

2009-01-19T11:58:00.006+08:00

今天玩了一下午的Excel，学统计的好歹要对Office多些了解吧。

发现了一些Excel的学习资源，一是Excelhome.net，上面有一些案例，也有很多总结得很好的技巧。我选了本最简单的Excel入门对着实例看完；接着看了些《Excel函数应用500例》的配套的例子。下面的笔记也是整理自Excelhome的文章。

Excel的优势之处：

（1）数据透视功能（2）统计分析，包含在数据透视功能之中。（3）图表功能（4）高级筛选（5）自动汇总功能（6）高级数学计算。

Excel在易用性方面的优势是其他软件难以比拟的，Office在用户友好性方面不可否认地做到了最好；虽然人们也有着这样那样的理由选择其他的方案。“总的来说Excel适合于开发单机版、访问量与开发维护量都不是很大、对数据有分析建模功能的应用程序。”

Excel应用程序的功能区分:

财务分析，这类应用程序通常分析用户所输入的数据，然后可以生成相应的预测模型，提供给决策部门作为参考。
报表类应用程序，这类应用程序充分利用了Excel的分析汇总功能和图表功能，程序的主要目的是生成周期报表。
工具类应用程序，这类应用程序通常用于提高用户的工作效率，例如提供数据转换与导入导出服务。

财务分析在课程学习中有过使用，是Excel最基础的功能；报表类我在实习的时候也都所接触，一些系统会定期地从数据库中筛选数据生成Excel格式的报表并进行发布。至于Excel做为工具我就觉得有点偏门的，也许只是没有接触过的缘故吧。

Excel的几种应用程序结构:

1、无代码应用程序

就是普通的.xls文件，由Excel提供数据验证、单元格的格式化、数据计算、数据输出等功能。首先你对很多对象都没有绝对的控制，而且数据验证、工作表函数都集成在工作表中，这部分的代码的管理就变得非常困难。对于今后的更新而言，替换工作表同时也会不可避免地丢失数据，而且这种应用程序结构不符合代码与数据分离的原则。这样的应用程序只适用于比较简单的需求。

无代码应用程序适用于下列情况：

a. 该应用程序的生命周期很短，只在单机进行部署，而且不需要升级。

b. 最终用户在维护该代码的时候不需要了解VBA。

c. 最终用户的数量不能太多。

2、自动化工作表

运行自动化过程的代码储存在工作簿内。这也是占比例最多的Excel应用程序。相对于第一种应用程序结构，现在可以最大限度地发挥VBA代码的威力：可以将代码和数据进行分离，可以捕获Workbook和Worksheet事件，实现需要的功能，不一而足。

自动化工作表示用于下面几情况：
工作簿内包含针对此工作簿的特殊函数，工作簿程序更新时数据不需要被保留

3、加载宏

加载宏是一种特殊的应用程序，通常用来给Excel增加功能。这里面要特别指出的是，通过加载宏给Excel增加功能特指与应用程序无关的一般目的功能。可以为Excel增加一个在加载宏中的工作簿，对用户而言它是不可见的，但是用户可以通过"宏"对话框来访问这些加载宏。
这些工作簿尽管对于用户不可见，而且其中包含的宏也无法在“宏”中可见，但是它们都可以通过VBA代码进行访问。因为加载宏中的工作表对用户始终不可见，所以需要使用用户表单来和用户进行交互。通过使用用户表单，我们首先获得了更高级的用户界面控制，其次可以更好地实现用户数据验证以及实现更高级的错误处理。这样就可以进一步增强应用程序的可靠性和数据完整性。使用加载宏结构，可以通过使用注册表或者是ini文件来记录用户的设置，而不需要像以前一样记录在工作表中。实现这种分离的重要作用就在于现在可以将配置、数据与程序代码分离，当在更新任何一方的时候都不会影响到其他部分。
加载宏是通过xla文件实现的，当在更新加载宏的时候，只需更改xla文件，然后进行覆盖操作就可以了，通过这种方式可以确保在更新程序时用户数据不会丢失。

4、企业信息系统

在使用基于Excel的企业信息系统时，用户甚至不知道他正在使用Excel编写应用程序，因为企业信息系统完全替代了Excel的用户界面，取而代之设计者设计的界面。这和用Visual Basic等高级编程语言设计出的应用程序没有什么不同。

尽管我们可以看到Excel会很多东西，但是也应该看到用Excel实习这些功能的成本，越是高级的功能开发的成本越高，相应地对培训的要求也会大大地提高。而相反，Excel的缺陷却是难以弥补的，就是对大量数据的管理、分析和处理。所以我想，以后大家对Excel的高级功能使用的会越来越少，毕竟企业会希望自己的知识能在企业内部进行统一管理，整合全企业的信息进行分析处理，而不希望把这些知识或业务逻辑分散在一张张的Excel表格中。当然，这也只是对大型的，有专职信息管理人员的企业来说；对大多数的企业而言，Excel还是一个低成本的、方便的、段时间内难以被代替的解决方案。

假期开始

2009-01-17T16:01:00.005+08:00

昨天这会还在考试，24小时内，我去了无锡的舅舅家，丁山的外公外婆家，现在就窝到了自己房间里，灌咖啡，开始看书。订了些技术牛人的博客，感慨自己的卑微，再这些下去读完了研就真正印证了“不伦不类”这四个字。这假期的主题有三个：数据处理、编程和英语。我也不知道能看完多少书，不过不努力的话肯定玩完。OK，开始。

读《破解咨询的40个困惑》

2009-01-06T22:16:00.002+08:00

正好赶在马哲考试前，复习这门课显然是浪费时间；可开始看投资又有点不靠谱，毕竟马哲还没考完，不用紧张兮兮。于是看了Alan Weiss的《破解咨询的40个困境》一书。我觉得书写得蛮好，可意外的是几乎没有什么名气，也许是因为作者只是个自由职业者，没有有名气的公司做后台；也许又是因为出版社推广不力的缘故吧～从这本书里我了解了关于咨询的很多东西，从工作生活到待人处事都一些，而且都说得很实在。咨询也是做项目，软件开发也是类似，结合起来看更有心得。由于找不到其他的现成笔记，下面的笔记都是我自己整理的。当然，目录是copy的。

第一篇应对营销挑战

第1章缺乏行业经验
做一个流程顾问而非内容咨询顾问

第2章细分市场过小
自身or外部环境？
通往死胡同的标志：相同的客户，老一套的方法，在狭窄的领域越走越窄。
生活中似乎也是如此？
保持现有市场，积极开拓：密切相关的领域，关联性领域，可转换的技能
技术学习?
商业敏锐性

第3章资源匮乏
虚拟？
与能提供帮助的专业性人士建立长期的联系
对于“专业性人士”来说呢？
值得信赖的跑腿人员
生活中的维护，水电煤？
培育客户

第4章远程营销成本
预支费用
有自己的标准
把握收款时机

第5章知名度不高
名字，媒体，开发产品
啥时写本书？……

第6章项目来源渠道枯竭
了解营销渠道
被动销售？销售自身。
要看些销售的书籍
优势--财富；邮件名单；做项目的同时，请他们推荐；敏锐的嗅觉；维护人际关系网。
我的弱项

第7章经济低迷或经济发展不确定时期
不景气的相对性，经济危机了，网游不更火了么！
任何情况下都运行良好的企业；茅台？
曾经一起工作过；希望与之一起工作的人
营销推广
考虑新的机会
即不要逆流而上，也不要顺流而下

第8章如何持续赢得咨询项目
一些征兆，拒绝不是坏事，满口应承才是坏事
欲速则不达，行动太快会吓着别人。交往--达到互信--其他。与人交往也是这样吧～
1.下次见面的日期
2.打电话不超过三次
3.每打次电话都发送一封Email
4.较短的时间内不要采取后续行动

第9章差异化的困境
a.避免使用专业术语
b.给自己定位
c.著书立说
d.创立一个或更多的品牌
e.使用你的名字
坚持！

第10章自我定位不准确或定位不适时
激情！

第二篇应对销售挑战

第11章价格竞争
不良做法：公开收费标准，采用按天收费的方式，在提交项目建议书前讨论收费标准，屈服于压力，与非真正的客户打交道，严格遵守《项目招标书》规定？询问预算，高估竞争对手，无法提供独特的方案，无法和客户建立联系
用价值衡量价格！

第12章《项目招标书》（RFP）
规避

第13章害怕和恐惧
自尊和无畏，建立互利互惠、平等的关系
着装得体，谈吐得体，运用幽默，不要无事道歉，尽量选择合适的位置坐好，做准备工作，予以还击，展现智慧，主动出击，绝不胆怯

第14章咨询项目价格过低
原因？ -- 保持敏感性并尽量避免 -- 摆脱
重新讨论遗漏的情况
重新确定能给客户提供的价值
将差异化的因素转换成或有费用
考虑放弃

第15章 “中间人”和设置障碍者
中间人--可能的买家对求职者来说，也许是HR？
与中间人建立关系的目的只是为了确定谁是真正的客户
合理的借口？晓之以情动之以理。

第16章项目启动时间推迟

第17章无人答复/无人回电
如何避免：做好准备工作，提出有价值的建议，有利的证明和认可的依据，制造紧迫感
确实对方回电的最好方法是提及双方都熟悉的第三方
积极跟进而非纠缠不清

第18章避免拙劣的“推销方式”
不要想当然地认为对方已经“病入膏肓”
不要操之过急
不要自我辩护
问一些引人深思的问题
在你的例子中利用潜在客户所处环境的因素
让买卖双方共同进行诊断
不要使用任何技术？
用你曾经经历过的例子来解释你要做的事情，不断联系
将球踢给对方
准备好走人
前几条很像求职的注意事项，毕竟求职就是推销自我，真诚第一！
谈论客户需要的结果，而不是咨询方法
要表现出你了解客户的情况，了解其所在的行业和竞争的情况
尽可能保障这种会谈是互动性质的
逻辑使人思考，情感使人行动

第19章客户让低层人员应付你
绝不主动或被动地离开客户！
避免被降级的预防措施：
不要太快地进入推销模式
专注与客户建立关系
强调公司目标的同时，也要强调其个人价值
提及已经合作过的其他客户，最好这些客户与潜在客户处于同一级别
必须让客户把你视为同等的人

第20章跟进工作不得力

第三篇应对项目运作挑战

第21章提防暗中破坏者
修正的原因是出现了失误，失误导致推卸责任和可能的不合作

第22章咨询范围不断扩大
软件开发中的需求管理是同样的道理，也许是项目的共性之一
达成共识，采取预防措施；
应付偶然出现的范围扩大现象

第23章应对国际挑战

第24章客户方发生意外变化并造成损失
最初的反应--启动紧急预案
查明发生了什么，联系客户，拟定新的有价值的项目建议书，有坚强的意志力
随后的反应--组织资源
改正和修补，适应和调整，应对和接受

第25章项目失败
分析可能的原因：目标，客观因素，主观因素
总结经验教训

第26章客户未能实施项目
咨询顾问客户
精简人员解雇部分员工
改组降低部分员工的级别
引进技术降低当前利润
设定职责提供负面的反馈意见
以身作则改变舒适的行为方式
倾听接受负面的意见
需要站在对方的角度思考问题，在自己看来理所当然，在对方看来也许艰难。

第27章应对“公司政治”

第28章未能就进展和贡献与客户达成共识

第29章客户“空头支票”式的支持
为什么会有空头支票？也许是内心害怕

第30章项目管理挑战
变化--唯一不变的就是变化！

第四篇应对咨询管理挑战

第31章现金流
税前税后问题

第32章学习和进步
终身学习，学习如何学习，而不是被教
持续学习的四个维度：带着理解读；带着感情写，带着感情说；带着鉴别听

第33章客户拖延付款

第34章日常管理费用及利润
为什么不应该雇人--这些理由在中国也许不是理由

第35章知识产权遭剽窃

第36章生病与残疾

第37章出差食宿行及生活质量

第38章合理合法避税
不是你赚了多少，而是你省了多少
争取最有利的缴税计划

第39章不断出现新技术
分清潮流和趋势

第40章生活目标及平衡
没有完美的平衡

读《点击世界顶级咨询公司》

2009-01-05T20:05:00.004+08:00

今天看了《点击世界顶级咨询公司》一书，主要想对这个行业多一些了解。草草看完后的确有一些收获。在咨询公司中能接触到很多案例，能锻炼与人交往的技能，能接触到一些新的东西，不断地追求专业，在自我提升的同时也能为社会创造尽可能多的价值，得到客户的认同。这和我的目标是吻合的。

在公司方面，这本书介绍了进十家世界性的咨询公司，其中在信息技术咨询方面，IGS(IBM全球服务)，Accenture（埃森哲），EDS（Electronic Data System + 科尼尔），PWC（普华永道），HPC(惠普咨询)这五家公司在做的尤为突出，需要多加关注。据书中说，PWC在美国是十佳IT雇主，普华永道成了IT公司？IGS全球有13w+的雇员，占IBM全球雇员数的一半以上？真正的服务为王！IT并非只意味着技术，IT是为了创造价值！然后查了下IGS，HPC的招聘，IGS在招很多掌握Oracle和SAP技术的人员，这也许说明领先的服务型IT企业已经超越了产品技术的壁垒，而是以为客户提供整合的产品和价值作为自己的目标。

BI这类专业性强且和业务紧密相连的技术方向很可能成为将来信息系统咨询的热点，在ERP整合了企业的业务后，BI也许将在企业信息整合上发挥重要作用；同时在IGS的招聘职位上，我也发现了对BI人才的较大需求。这也许是个不错的方向。

GTD学习笔记

2009-01-02T11:10:00.018+08:00

新年的第一天在“褪墨 ”上发现了GTD（Getting Things Done）和ZTD（Zen To Done）这两个概念。昨晚看了《Getting Things Done》，综合了网络上发现的其它信息，做个简单的笔记。
GTD 是“Getting Things Done”（完成每一件事）的缩写。这是一个被广泛采用的赋予实际行动的时间管理系统。ZTD则更侧重于简洁高效的时间管理。

在“架构研究室 ”上发现了下面的GTD的思维导图。

Douglas Johnston 制作的流程图：摘自www.DIYPlanner.com

笔记摘自“褪墨”
GTD的重点不在于设定任务的优先级，而是制定出在各种情境下的任务列表，如：制定一份“需要打电话”的列表；一份“电脑前可以完成的事情”列表等等。GTD还建议任何两分钟之内可以完成的任务应该马上执行。

两个目的：（1）抓住所有一切需要处理的事情（现在的、以后的、将来某时的；大的、小的、
或者不大不小的）把它们统统置入一个脱离大脑的逻辑系统中。（2）训练自己在接受一切“输入信息”的前期作出决定。这样一来，在任何时候，你都把下一步行动计划掌握在手，可以实施或者进行再议。

简单的概括GTD，那就是对任何事情都做好准备。因为我们的想法没有被收集整理，所以我们总是在不断地思考自己需要什么或者现在要做什么。若总让大脑停留在思考要什么，完成什么，和使用大脑记忆这些事件的层次，那么大脑就会没有多余地时间去考虑一件事情该怎么完成了。只有考虑如何完成一件事情才最重要，否者你的想法都是没意义的。

收集
把任何你需要跟踪、记住、或者要做的事情全部记录到“收集箱”中。每天抽几十分钟收集一下脑中的信息，记录到你的收集设备中。

处理
将你收集到的任何信息进行处理。每个星期至少处理清空一次你的“收集箱”。
处理你的收集箱要遵循的工作流程：
从第一条信息开始处理；
每次只处理一条信息；
不把任何信息放回收集箱；
如果任何一项需要做：
马上执行（如果花的时间少于两分钟）
委托别人完成，或者
将它延期
否则：
将它存档以便查询
把它删除，或者
为它定义合适的目标与情境，以便下一步执行
两分钟原则：任何事情如果花的时间少于两分钟，那么马上就去执行。两分钟是一个分水岭，这样的时间和正式地推迟一个动作所花的时间差不多。

组织
下一步行动（Next actions）：对于每个需要你关注的事项，定好什么是你可以实际采取的下一步行动。虽然要完成事项可能会有很多的步骤和行动，但是其中一定会有你需要首先去做的事情，这样的事情就应该被记录在“下一步行动”列表上。较好的做法是把这些事项根据能够被完成的“情境”整理分类，例如“在办公室”，“用电话”，“在商场”。
项目（Projects）：每个需要多于一个实际的行动才能达到目的的事就是一个“项目”。使用跟踪以及周期性的回顾来确保每个项目都有一个下一步的行动进行下去。
等待（Waiting for）：当你已经指派了一个事项给其他人或者在项目进行下去之前需要等待外部的事件。就应当在你的系统当中跟踪以及定期检查是否已经可以采取行动或者一个提醒需要发出。
将来/可能（Someday/Maybe）：这些事情你需要在某个点去做，但是不是马上。

使用下一步行动列表而非日历来记录行动，虽然日历非主要的工具，但是可以用来跟踪预约和委托，提醒某件必须在特定期限内完成的事情等等。
字母顺序组织的归档系统或43 Folders系统（按照12月、31天，共43个文件夹）。

回顾
按时回顾自己的列表。如果你没有及时整理和回顾每天的信息和行动，那么整个GTD系统就是毫无用处的。通过回顾，指定计划，或者了解项目进度，从而使自己总是走在时间的前面，而不是被动地被安排。
1. 我可以做什么使下一周有所改进？
2. 这周最使我感到骄傲的是什么？
3. 这周我取得的最大成果是什么？
4. 这周我做了什么使我更接近自己的目标？
5. 这周我遇到的困难有哪些？为什么？
6. 这周内，我白白浪费时间最多的是什么？
7. 这周我做了什么使我感到羞愧？

执行
如果你把自己的时间都花在组织工作、而不是执行它们，那么这样的系统是个只说不做的无用功系统。前面的步骤都是为了在你做事情的时候，使它变得简单、容易、有趣的话，让你比较不会拖延、或者被太多的琐事所分心。

简单做(ZTD)的十个好习惯总结
同样摘自褪墨。

习惯1：收集 —— 全面收集
随身携带一个小笔记本（或者任何记录工具），用它来记录下任何任务、想法、专案或者任何闪入你大脑的其他信息。这个习惯与GTD的基本完全相同，但ZTD只需要一个小巧、便携、易用的工具来记录信息。你必需在忘记事情之前赶紧把信息写下来, 并且尽快地把这些信息从笔记本中清除、存入任务清单中。

习惯2：处理 —— 快速地对信息作出决定，从而避免收件箱堆积
第一，限制你的收件箱。列出所有你收集信息的途径，评估每一条途径带来的价值，合并某些收件箱或者删除那些无用的收件箱。
第二，管理你的收件箱。

习惯3：计划 —— 设定每天，每周的最重要的事(MIT)
每周，列下你需要完成的重大事件，把他们排进日程表。每天，列出1-3个最重要的事(MITs)。这样，你的每一天和每一周都被设定了目标，与其盲目的去完成那长长的任务清单，你总是在完成那些最重要最有用的事情！发现，安排，完成，回顾！

习惯4：执行 —— 一心一意，每次只执行一件事
执行作为一切时间管理的核心，是ZTD中非常重要的一部分。你应当在不分心的情境下，一次只执行一件事。既不要多线工作，也不要让你的工作突然中断。

习惯5：信任的系统 —— 建立简单的列表，并每日查看
ZTD（简单做）建议你尽可能的维持列表简单化。不要增加复杂的系统，也不要持续尝试新工具，以免时间上的浪费。

习惯6：管理 —— 一个存储所有信息的地方
把所有接收的信息都放入你的收集箱中，处理你的收集箱，执行任务，完成任务。在这个系统里，你永远都不应该有疑问自己下一步该做什么。而且也使你更能专心注重于工作，也避免的拖延的。

习惯7：回顾 —— 每周回顾你的系统和目标
重新整理所有的事情和检视什么是最重要的任务。每次只要集中于一个目标，并且确保它是一个你能完成的目标。

习惯8：简化 —— 减少你的任务清单，只留下最必要的
将你的任务列表简化到最少，只剩下最重要的任务，不断地简化自己的任务清单，确定你的任务只是最重要的。

习惯9：常规 —— 设定每周、每日例程
设定每周、每日例程可以使你的工作和个人生活得到极大的简化。更重要的是，使你掌控自己的生活，而非让任务处在搁浅之中。没有日程，我们就不太容易对新进入的信息说不。因为我们总是被那些希望占用我们时间的人、吸引注意力的网站所拖住，这不是一件好事（除非你不想做完重要的事情），所以你需要掌控自己的生活，设定日程，并且跟着它走。

习惯10：激情 —— 做你充满梦想的事情
当你真正地想去做一件事，无论多么辛苦，你都会去努力的完成。你会付出更多的努力，抽出更多的时间，耽搁的时间也减少了。所以，培养这个习惯正是为了持续搜寻使你保持热情的事情，使你精神饱满，动力十足。

The new year.

2008-12-31T10:52:00.003+08:00

昨天看了《叶问》、《梅兰芳》、《霸王别姬》、《非诚勿扰》。都是别人的生活。几年前觉得活着是为了经历，几年后觉得活着就是活着，不管真实还是不真实。也许生活和爱才是真正重要的，可对它们却只能顺其自然。

曾经刻意地追求着简单，不想去记录，不想去思考，可现在有时觉得不记下些什么我真会很快忘了经历过什么。可即使刻意记录，一天天还是这么过去，到后来只是成了一篇篇日志、成了一张张相片、成了一纸简历、成了回忆。

在09年，我想活得真实些，每天都做一件开心的事情，每个月都养成一个好的习惯。呵呵，这就是我新年的目标。

08年

2008-12-27T20:12:00.003+08:00

08的流水帐：
1月：考研，确定考不上，开始做简历。浪费了半年的时间。家乡下了场大雪，过年，做鱼丸。
2月：跑亲戚、投简历，17号到上海，一周面试四家公司，第二周和宏力签约，回广州办三方协议，回上海。
3月：上班，编程。工作的无奈和孤独。
4月：继续工作，知道过了上财的复试线，准备复试，笔试基本不会，又开始等待，已不在意。准备报工程硕士。
5月：月初得知复试通过。上午离职，下午去蓝竹面试，第二天回广州。做毕设。
6月：继续做毕设，去肇庆玩，拍毕业照，答辩。
7月：蓝竹实习，继续编程，烦心而开心的日子。
8月：继续编程，生活的琐碎。
9月：月初回家，中旬回上海，开学。学习Linux+Python。由于入党较早，被任班长。
10月：十一回家，思维导图，重读《代码大全》，学SAS，烧烤。重做简历，面试。
11月：玩红警3，SNA论文，《代码大全》，Python，UNIX。
12月：英语演示，《重构》，《执行》，统计推断考试，《货币战争》，重读《设计模式》，圣诞party。复习高微、投资。听歌。

明年：
1到5月：课程学习，python，C，Matlab or SAS，DB2 Advanced，BEC Higher，LPIC。
5到8月：暑期实习，英语，Data Mining。
9到12月：论文，找工。
可能的话参加一两个开源项目。

继续卑微地努力，多多少少为自己、为他人做些事情。累些，却也不会后悔～

12.22习字_苏轼词

2008-12-22T11:02:00.015+08:00

窗外阳光很好，不想看书，等吃午饭，有那么一点无趣，抄了苏轼的两首词。手有点冻，笔也有些差。上一次写字该是一年半以前了吧。

我不知道干嘛写字，纯粹的浪费时间，而且还显得有点酸有点作，呵呵。不过很多事都一样，是永远没有为什么这一说的。哪怕过程中有一点点所得，就不能说是浪费时间。宅男，宅男。

《Head First 设计模式》9-13章

2008-12-21T10:57:00.002+08:00

Chapter 9：迭代器和组合模式--管理良好的集合
我们能学习如何让客户遍历你的对象而又无法窥视你存储对象的方式；也将学习如何创建一些对象超集合，能够一口气就跳过某些让人望而生畏的数据结构；还将学写到一些关于对象职责的知识。

迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而不是暴露其内部的表示。
迭代器模式让我们能游走于聚合内的每一个元素，而不是暴露其内部的表示。
把游走的任务放在迭代器上，而不是聚合上。这样简化了聚合的接口和实现，也让责任各得其所。

设计原则：一个类应该只有一个引起变化的原因。
类的每个责任都有改变的潜在区域。超过一个责任，意味着超过一个改变的区域。
这个原则告诉我们，尽量让每个类保持单一责任。

组合模式：允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一直的方式处理个别对象以及对象组合。
组合模式让我们能用树形方式创建对象的结构，树里面包含了组合以及个别的对象。
使用组合结构，我们能把相同的操作应用在组合和个别对象上。换句话说，在大多数情况下，我们可以忽略对象组合和个别对象之间的差别。
统一处理个别对象和组合对象。

空迭代器
NullIterator，返回一个迭代器，而这个迭代器得hasNext永远返回false。

要点
迭代器允许访问聚合的元素，而不需要暴露它的内部结构。
迭代器将遍历聚合的工作封装进一个对象中。
当使用迭代器的时候，我们依赖聚合提供遍历。
迭代器提供了一个通用的接口，让我们遍历聚合的项，当我们编码使用聚合的项时，就可以使用多态机制。
我们应该努力让一个类只分配一个责任。
组合模式提供一个结构，可同时包容个别对象和组合对象。
组合模式允许客户对个别对象以及组合对象一视同仁。
组合结构内的任意对象称为组件，组件可以是组合，也可以是叶节点。

在实现组合模式时，有许多设计上的折中。你要根据需要平衡透明性和安全性。

Chapter 10：状态模式--事务的状态
策略模式和状态模式是双胞胎，在出生时才分开。

策略模式是围绕可以互换的算法来创建成功业务的。
状态模式通过改变对象内部的状态来帮助对象控制自己的行为。
1 定义一个State接口。在这个接口内，糖果机的每个动作都有一个对应的方法。
2 然后为机器中的每个状态实现状态类。这些类将负责在对应的状态下进行机器的行为。
3 我们要摆脱旧的条件代码，取而代之的方式是，将动作委托到状态类。

状态模式：允许对象在内部状态改变是改变它的行为，对象看起来好像修改了它的类。

要点
状态模式允许一个对象基于内部状态而拥有不同的行为。
和程序状态机PSM不同，状态模式用类代表状态。
Context会将行为委托给当前状态对象。
通过将每个状态封装进一个类，我们把以后需要做的任何改变局部化了。

状态模式和策略模式有相同的类图，但是它们的意图不同。
策略模式通常会用行为或算法来配置Context类。
状态模式允许Context随着状态的改变而改变行为。
状态装换可以由State类或Context类控制。
使用状态模式通常会导致设计中类的数目大量增加。
状态类可以被多个Context实例共享。

Chapter 11：代理模式--控制对象访问

你是一个白脸，提供很好且很友善的服务，但是你不希望每个人都叫你做事，所以找了黑脸控制对你的访问。

控制和管理访问，这就是代理要做的事。
你的客户对象所做的就像是在做远程方法调用，但其实只是调用本地堆中的“代理”对象上的方法，再由代理处理所有网络通信的低层细节。
1 先浏览并了解一下RMI。
2 我们会把GumballMachine变成远程服务，提供一些可以被远程调用的方法。
3 我们将创建一个能和远程的GumballMachine沟通的代理，这需要用到RMI。
4 最后再结合监视系统，CEO就可以监视任何数量的远程糖果机了。

方法调用是如何发生的
1 客户对象调用客户辅助对象的doBigThing方法。
2 "客户辅助对象打包调用信息(变量,方法名称等)，然后通过网络将它运给服务辅助对象。"
3 服务辅助对象把来自客户辅助对象的信息解包，找出被调用的方法(以及在哪个对象内)，然后调用真正的服务对象上的真正方法。
4 服务对象上的方法被调用，将结果返回给服务辅助对象。
5 服务辅助对象把调用的返回信息打包，然后通过网络运回给客户辅助对象。
6 客户辅助对象把返回值解包，返回给客户对象。对于客户来说，这是完全透明的。

RMI提供了客户辅助对象和服务辅助对象，为客户辅助对象创建和服务对象相同的方法。

制作远程服务
1 制作远程接口
2 制作远程的实现
3 利用rmic产生的sub和skeleton
4 启动RMI registry(rmiregistry)
5 开始远程服务

远程代理；虚拟代理：暂时代理初建开销大的对象

代理模式：为另一个对象提供一个替身或占位符以控制这个对象的访问。
使用代理模式创建代表representative对象，让代表对象控制某对象的访问，被代理的对象可以是远程的对象，创建开销大的对象或需要安全控制的对象。

要点
代理模式为一个对象提供代表，以便控制客户对对象的访问，管理访问的方式有许多种。
远程代理管理客户和远程对象之间的交互。
虚拟代理控制访问实例化开销大的对象。
保护代理基于调用者控制对象方法的访问。
代理模式有许多变体，例如：缓存代理，同步代理，防火墙代理和写入时复制代理。
代理在结构上类似装饰者，但是目的不同。
装饰者模式为对象加上行为，而代理则是控制访问。
Java内置的代理支持，可以根据需要建立动态代理，并将所有调用分配到所选的处理器。
就和其他的包装者wrapper一样，代理会造成你的设计中类的数目增加。

Chapter 12: 复合模式--模式中的模式
谁料得到模式居然可以携手合作？

模式常被一起使用，并被组合在同一个设计解决方案中。
复合模式在一个解决方案中结合两个或多个模式，以解决一般或重复发生的问题。

设计模式是MVC的钥匙。
MVC是由数个设计模式结合起来的模式。如果你能够看着MVC内部的各个模式，MVC的一切就会跟着开始明朗起来。

要点
MVC是复合模式，结合观察者模式、策略模式和组合模式。
模型使用观察者模式，以便观察者更新，同事保持两者之间的解耦。
控制器是视图的策略，视图可以使用不同的控制器实现，得到不同的行为。
视图使用组合模式实现用户界面，用户界面通常使用嵌套的组件，像面板、框架和按钮。
这些模式携手合作，把MVC的三层解耦，这样额可以保持设计干净，又有弹性。
适配器模式用来将新的模型是配成已有的视图和控制器。
Model2是MVC在Web上的应用。
在Model2中，控制器实现成Servlet，而JSP/HTML实现视图。
迎接一个充满设计模式的崭新世界。

Chapter 13：与设计模式相处--真实世界中的模式
模式是在某种情境(context)下，针对某问题的某种解决方案。
情境就是应用某个模式的情况。这应该是会不断出现的情况。
问题就是你想在某个情境下达到的目的，但也可以是某情境下的约束。
解决方案就是你追求的，一个通用的设计，用来解决约束，达到目的。
如果你发现自己处于某个情境下，面对着所欲达到的目标被一群约束影响着的问题，然而，你能够应用某个设计，克服这些约束并达到该目标，将你领向某个解决方案。

反模式告诉你如何采用一个不好的解决方案解决一个问题。

要点
让设计模式自然而然地出现在你的设计中，而不是为了使用而使用。
让设计模式并非僵化的教条；你可以依据自己的需要采用或调整。
总是使用满足需要的最简单解决方案，不管它用不用模式。
学习设计模式的类目，可以帮你自己熟悉这些模式以及它们之间的关系。
模式的分类或类目是将模式分成不同的族群，如果这么做对你有帮助，就采用吧！
你必须相当专注才能够成为一个模式的作家；这需要时间也需要耐心，同事还必须乐意做大量的精化工作。
请牢记：你所遇到大多数的模式都是现有模式的变体，而非新的模式。
模式能够为你带来的最大好处之一是，让你的团队拥有共享词汇。
任何社群都有自己的行话，模式社群也是如此。别让这些行话绊着，在读完这本书之后，你已经能够应用大部分的行话了。

剩下的模式

桥接模式 Bridge Pattern
不只改变你的实现，也改变你的抽象。
生成器 Builder Pattern
使用生成器模式封装一个产品的构造过程，并允许按步骤构造。
责任链 Chain of Responsibility Pattern
当你想要让一个以上的对象有机会能够处理某个请求的时候，就使用责任链模式。
蝇量 Flyweight Pattern
如想让某个类的一个实例用来提供许多虚拟实例，就使用蝇量模式。
解释器 Interpreter Pattern
使用解释器模式为语言创建解释器。
中介者 Mediator Pattern
使用中介者模式来几种相关对象之间复杂的沟通和控制方式。
备忘录 Memento Pattern
当你需要让对象返回之前的状态时，就使用备忘录模式。
原型 Prototype Pattern
当创建给定类的实例的过程很昂贵或很复杂时，就使用原型模式。
访问者 Visitor Pattern
当你想要为一个对象的组合增加新的能力，切封装并不重要时，就使用访问者模式。

《Head First 设计模式》5-8章

2008-12-20T16:17:00.004+08:00

Chapter 5: 单件模式
独一无二的单件模式：用来创建第一无二的，只能有一个实例的对象的入场券。有些对象之需要一个：线程池、缓存、对话框、偏好设置、日志。。。
静态全局变量（一开始就创建号） <--> 单件模式（可以在需要时再创建对象）
单件模式：确保一个类只有一个实例，并提供一个全局访问点。

JVM多线程
同步：synchronized --> 可能造成执行效率的下降
急切实例化：定义时创建
双重检查加锁：volatile -- Java 5

要点
单件模式确保程序中一个类最多只有一个实例。
单件模式也提供访问这个实例的全局点。
在Java中实现单件模式需要私有的构造器，一个静态方法和一个静态变量。
确定在性能和资源上的限制，然后小心地选择适当的方案来实现单件，以解决多线程的问题(我们必须认定所有的线程都是多线程的)
如果不是采用第五版的java2，双重检查枷锁实现会失效。
小心，你如果使用多个类加载器，可能导致单件失效而产生多个实例。
如果使用JVM1.2或之前的版本，你必须建立单件注册表，以免垃圾收集器将单件回收。

Chapter 6: 命令模式--封装调用
这些绝密文件的投递箱已经促成了间谍工业的革命。我只要把需求丢进去，就有人会消失，政府一夕之间改朝换代，而我的干洗衣物也好了。我不必管何时何地或者如何完成，反正就是完成了。
在本章，我们把封装带到一个全新的境界:把方法调用封装起来。

命令模式：
将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。

命令对象将动作和接收者包进对象中。这个对象只暴露出一个execute()方法，当此方法被调用的时候，接收者就会进行这些动作。
NoCommand对象是一个空对象的例子。当你不想返回一个有一一的对象时，空对象就很有用。
客户也可以将处理null的责任转移给空对象。

命令模式的更多用途
队列请求：命令可以将运算快打包（一个接受者和一组动作），然后将它传来传去，就像是一般的对象一样。
日志请求：store(); load(); execute(); undo()
宏：顺序地执行execute();

要点
命令模式将发出请求的对象和执行请求的对象解耦。
在被解耦的两者之间是通过命令对象进行沟通的，命令对象封装了接受者和一个或一组动作。
调用者通过调用命令对象的execute发出请求，这会使得接收者的动作被调用。
调用者可以接受命令当参数，甚至在运行时动态地进行。
命令可以支持撤销，做法是实现一个undo方法来回到execute被执行前的状态。
宏命令是命令的一种简单的延伸，允许调用多个命令。宏方法也可以支持撤销。
实际操作时，很常见使用聪明命令对象，也就是直接实现了请求，而不是将工作委托给接收者。
命令也可以用来实现日志和事务系统。

Chpater 7：适配器模式与外观模式--随遇而安
适配器模式与外观模式：以不同的目的，包装某些对象，让它们的接口看起来不像自己而像是别的东西。
这样就可以在设计中，将类的接口转换成想要的接口。
将所有的改变封装在一个类中，可能需要让一个适配器包装多个被适配者。
双向适配器。

适配器模式解析
客户 - 适配器 - 被适配器
客户使用适配器的过程如下：
客户通过目标接口调用适配器的方法对适配器发出请求。
适配器使用被适配者接口把请求转换成被是配置的一个或多个调用接口。
客户接收到调用的结果，但并未察觉这一切是适配器在起转换作用。

适配器模式：将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。

对象适配器：

外观不只是简化了接口，也将客户从组件的子系统中解耦。
外观和适配器可以包装许多类，但是外观的意图是简化接口，而适配器的意图是将接口转换成不同接口。
外观模式：提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。
外观没有封装子系统的类，外观只提供简化的接口。同时，依然将系统的功能完整地暴露出来。

设计原则：最少知识原则：只和你的密友谈话。

要点
当需要使用一个现有的类而其接口并不符合你的需要时，就使用适配器。
当需要简化并统一一个很大的接口或者一群发杂的接口时，使用外观。
适配器改变接口以符合客户的期望。
外观将客户从一个复杂的子系统中解耦。
实现一个适配器可能需要一番功夫，也可能不费功夫，视目标接口的大小与复杂度而定。
实现一个外观，需要将子系统组合进外观中，然后将工作委托给子系统执行。
适配器模式有两种形式：对象适配器和类适配器，类适配器需要用到多重继承。
你可以为一个子系统实现一个以上的外观。
适配器将一个对象包装起来以改变其接口，装饰者将一个对象包装起来以增加新的行为和责任，而外观将一群对象包装起来以简化其接口。

Chapter 8：模板方法模式--封装算法
唉！在需要进入这个洞之前他原本是个好老板的，结果这全部都编程了我的工作了。你懂我的意思吧？他根本就不见人影！
我们将要深入封装算法块，好让子类可以在任何时候都可以将自己挂接进运算里。

模板方法定义了一个算法的步骤，并允许子类为一个或多个步骤提供实现。

模板方法模式：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
对模板方式进行挂钩，影响抽象类中的算法流程

设计原则：好莱坞原则：别调用(打电话给)我们，我们会调用(打电话)你。
高层组件对待低层组件的方式是：别调用我们，我们会调用你。低层组建将自己挂钩到系统上。

要点：
模板方法定义了算法的步骤，把这些步骤的实现延迟到子类。
模板方法模式为我们提供了一种代码复用的重要技巧。
模板方法的抽象类可以定义具体方法、抽象方法和钩子。
抽象方法由子类实现。
钩子是一种方法，它在抽象类中不做事，子类可以选择要不要去覆盖它。
为了防止子类改变模板方法中的算法，可以将模板方法声明为final。
好莱坞原则告诉我们，将决策权放在高层模块中，以便决定如何已经何时调用低层模块。
你将在真实世界代码中看到模块方法模式的许多变体，不要期待它们全都是一眼就被你认出来的。
策略模式和模板方法模式都封装算法，一个用组合，一个用继承。
工厂方法是模板方法的一种特殊版本。
良好管理的集合 “当然我把集合都好好地封装起来了”

财务报表分析作业

2008-12-20T10:17:00.002+08:00

分析对象选的是用友软件（600588），18号晚完成了分析数据的录入，19日上午完成2/3，今天上午又完成了剩下的1/3。总的花费在16个小时左右，23p，8000字。纪念。

有图片的word转到Online doc上有很多错误，Excel可以上传但还不能嵌到页面。下面只摘抄下总结吧：

在偿债能力和资本结构方面，用友软件有着不错的短期偿债能力，债权的保证程度很高，企业所有者对企业的控制力很强，企业偿还本息的压力轻，但企业没有充分利用财务杠杆举债经营，具体体现在财务杠杆指数低等方面，但在五年间有了一定高，说明该企业的业务有较好的发展，对负债经营有了一定的运用。在长期偿债能力上，用友软件的利息保障倍数处于极高的水平，且在过去的几年内又有了较大的提高。

在营运能力方面，该企业的该企业的总资产周转率和流动资产周转率处于逐年上升的态势，同时应收账款周转率也在逐年提高，说明了企业的运营能力和应收账款的管理水平在持续地提高。但是，该企业的总负债周转率呈M形波动，说明了用该企业利用负债资金创造效益的能力较弱且不稳定。同时，所有者权益周转率的稳步上升说明了企业投资者的权益基金创造收入的能力有所提高。五年间，该企业的营业周期和现金营业周期呈稳步降低的态势，说明了该企业的资金周转速度有所加快、流动性增强、资产的使用效率有所提高。

在获利能力方面，该企业的销售净利率和销售毛利率都呈先减后增的U字形趋势，总体保持稳定，主营业务利润率呈先增后降的态势，可从绝对值看仍处在较高的水平，但营业利润率的下降幅度较大，说明企业通过日常经营活动获得利润的能力减弱。该企业的该企业的主营业务成本毛利率及主营业务成本利润率在03到05年逐年下降，但其绝对值仍保持在较高的水平，体现了该企业出色的获利能力。

在投资报酬能力上我们可以看出，该企业的投资回报能力在04年后有了很大的提高，其盈利水平是稳定而又持续提高的。

在现金流量部分，从分析数据我们可以看出，企业有着不错的运用现金偿还债务的能力，和经营获现能力，现金获利能力也很出色，同时企业也有着稳定的现金流，完全能够满足投资的需要。

用友软件作为一个纯软件公司，代表了软件行业的普遍特点。首先在成本的构成上，固定资产方面的投入占的比重较少，且设备的更新换代有周期性，故导致了某些财务数据的非常规变化；其次在现金流量上，企业有着充裕的现金流，完全可以满足偿债和投资的需要；其三在资本构成上，由于处于新兴行业，创办历史较大，所以股权较为集中，所有者对企业的控制较强；其四在举债经营上，由于在软件行业，知识产权的重要性大大高于其它因素，而研发能力的提高不是光靠大的团队或者大的投入就可以做到的，加之企业的现金流较为充裕，所以并没有大量利用借债来扩大企业规模。虽然企业没有充分利用财务杠杆，但在不稳定的软件行业，保持较大的现金储备有利于企业长期稳定的发展。

Excel数据整理

2008-12-18T22:34:00.002+08:00

今天做财务报表分析的课程作业，我选择了用友软件作为分析对象，数据上采用了该公司02-06年五年的数据。数据的来源是html格式的年报。由于五年间的会计科目有所变化，再加上实际的报表和分析用的标准报表有所差异，如果一个个数据拷贝的话工作量还是很大的。我采用了以下的数据整理流程大大提高了效率：

html --> UltarEdit[正则表达式处理特殊符号] --列编辑，拷贝标题列和数据列--> Excel临时表 --> 拷入标准表的标题列 --> 对照标准表，将临时表的标题列对准标准表 -->将临时表的数据列拷入标准表 --> 整理&填充缺失数据。

《货币战争》

2008-12-18T11:12:00.002+08:00

今天早上七点半就起来了，窝床上看小说--《货币战争》。的确是颇有意味的一本书，抛开真实性不说--也许也不会有人认为这本书里讲的是真的，这本书让我了解了一下金融方面的历史学知识，我相信这些历史是是真实的，只是对这些历史的解读有些哗众取宠了。对于一些历史的解释作者的阴谋论也能自圆其说，可越到后来就出来了越多的矛盾，我不是指与历史现实的矛盾，而是书中的自相矛盾。于是越翻越快，翻到了十点半终于忍不住饥饿和口渴，翻完了这本书。不能不佩服作者的想象力、历史学知识和自圆其说的能力。有人在金庸的小说中推出了张三丰是小龙女和尹志平的私生子，也是引经据典，充满了想象力。

下面的网上的书评，看看也蛮有意思的。
豆瓣书评--货币战争
子虚乌有的货币战争

讲座_信息检索_统计学习

2008-12-17T18:00:00.002+08:00

今天下午在经院楼听了马志明院士的讲座：《数学在信息检索中的作用》。介绍了PageRank和他们团队最新的研究成果BrowersRank。这种算法使用用户的浏览行为作为网页评级的依据。采用的数据有用户在一个页面的停留时间和页面之间的跳转动作。使用这种算法可以有效地防止一些网站对搜索引擎的欺骗，得出较为客观的结果。

这的确是一个很有创意而且有实际运用价值的想法。可问题是用户不一定只用IE，而且有些网站也许要很久也许永远都不能被用户所访问。这有个时效性的问题。我认为评级应该结合网络结构、页面内容和用户的浏览行为，这些方法是互为补充的，仅仅说哪种方法更好显然是没有意义的。

另外讲到的就是二重统计学习，是马院士的团队在研究“搜索学习？”时发现简单的统计学习不能满足实际的需要，进行的开创性的研究。这部分我也没听明白，该是数据挖掘方面的内容吧。马院士也提到了现在统计正为搜索引擎提供了新的创意，而搜索的实际也促进的统计理论的进一步发展。可要真正将工程方面的东西和数学融会贯通又谈何容易。

《Head First 设计模式》1-4章

2008-12-17T13:44:00.002+08:00

《Head First》在去年初着实火了一把，我是年初买的这本书，然后回学校做毕业设计的时候看了几章，假期实习的时候看完了剩下的几章。那会烦心的事特别多，也没有读书的心情，看《重构》的时候发现很多设计模式方面的东西已经忘个精光，现在重读并做些笔记。部分内容来自CSDN下载的一份EXCEL格式的笔记，图片都来自GoF的经典。设计模式出来十年了，我却是在本科毕业以后才读的这本书，也许不用考研，我会早些接触模式，对我的编程实践应该会有很多的帮助。

学习的方法：
慢一点，思考得越多，需要记的就越少
勤做练习，自己记笔记
睡觉前不要看有难度的东西
多喝水
大声说出来
听听你的大脑怎么说
要有点感觉
设计一些东西

chapter1：设计模式入门
我们已经搬到对象村，刚刚开始着手设计模式……这里每个人都在使用设计模式。很快我们就会通过设计模式跻身上流社会。
把模式装进脑子里，然后在设计和已有的运用中，寻找何处可以使用。

CHANGE
设计原则：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
把会变化的部分取出并封装起来，好让其他部分不会受到影响。
结果如何？代码变化引起的不经意后果变少，系统变得更有弹性。

设计原则：针对接口编程，而不是针对实现编程。
从现在开始，鸭子的行为将被放在分开的类中，此类专门提供某行为接口的实现。
这样，鸭子类就不再需要知道行为的实现细节。
"针对接口编程真正的意思是""针对超类型supertype编程"""
执行时根据实际情况执行真正的行为

设计原则：多用组合，少用继承。
has a maybe better than is a.

策略模式：
定义了算法族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。

良好的OO设计必须具备可复用、可扩展、可维护三个特性。
可维护的OO系统:随时想到系统以后可能需要的变化以及应付变化的原则。

模式不是被发明，而是被发现。

chapter 2：观察者模式：让你的对象知悉现状
喂，Jerry，我正在通知大家，模式小组会议改到周六晚上，这次讨论的是观察者模式，这个模式最棒了！超级棒！你一定要来呀，Jerry。

观察者模式： 定义了对象之间的一对多依赖，这样以来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

设计原则：为了交互对象之间的松耦合设计而努力。
松耦合：依然可以交互，但不太清楚彼此的细节。

Subject:主题 Observer:观察者

要点
观察者模式定义了对象之间的一对多关系。
主题，也就是可观察者用一个共同的接口来更新观察者。
观察者和可观察者之间用松耦合方式结合，可观察者不知道观察者的细节，只知道观察者实现了观察者接口。
使用此模式时，你可从被观察者处推push或拉pull数据，然而，推的方式被认为更正确。
有多个观察者时，不可以依赖特定的通知次序。

Java有多种观察者模式的实现，包括了通用java.util.Observable
要注意java.util.Observable实现上所带来的一些问题。
如果有必要的话，可以实现自己的Observable，这并不难，不要害怕。
Swing大量使用了观察者模式，许多GUI框架也是如此。
此模式也被应用在许多地方。例如：JavaBeans、RMI。

chapter 3：装饰者模式
我曾经以为男子汉应该用继承处理一切。后来我领教到运行时扩展，远比编译时期的继承威力大。看看我现在光彩的样子。

装饰模式：动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。
可以在不修改底层代码的情况下，给代码赋予新的职责。

设计原则：类应该对扩展开发，对修改关闭。

要点1
装饰者和被装饰者对象有相同的超类型。
你可以用一个或多个装饰者包装一个对象。
既然装饰者和被装饰对象有相同的超类型，所以在任何需要原始对象（被包装）的场合，可以用装饰过的对象代替它。
装饰者可以在所委托被装饰者的行为之前与/或之后，加上自己的行为，以达到特定的目的。
对象可以在任何时候被装饰，所以可以在运行时动态地、不限量地用你喜欢的装饰者来装饰对象。

要点2
继承属于扩展形式之一，但不见得是达到弹性设计的最佳方案。
在我们的设计中，应该允许行为可以被扩展，而无须修改现有的代码。
组合和委托可用于在运行时动态地加上新的行为。
除了继承，装饰者模式也可以让我们扩展行为。
装饰者模式意味着一群装饰者类，这些类用来包装具体组件。
装饰者类反映出被装饰的组件类型（他们具有相同的类型，都经过接口或继承实现）
装饰者可以在被装饰者的行为前面与/或后面加上自己的行为，甚至将被装饰者的行为整个取代掉，而达到特定的目的。
你可以用无数个装饰者包装一个组件。
装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型。
装饰者会导致设计中出现许多小对象，如果过度使用，会让程序变得很复杂。

只有针对抽象组件类型编程时，才不会因为装饰者而受到影响。
通常有工厂或生成器之类的模式创建。

Java String
FilterInputStream: 一个抽象装饰者。
chapter 4：工厂模式--烘烤OO的精华
认识工厂方法模式
所有工厂模式都是用来封装对象的创建
工厂方法模式通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。

组成元素
创建者Creator类
它定义了一个抽象的工厂方法，让子类实现此方法制造产品。
创建者通常会包含依赖于抽象产品的代码，而这些抽象产品由子类制造。创建者不需要真的知道在制造哪种具体产品。
产品类：工厂生产产品。对PizzaStore来说，产品就是Pizza。

另一个观点：平行的类层级
为什么产品类和创建者类是平行的？都是抽象类，且都有许多具体的子类，每个子类都有自己特定的实现。
NYPizzaStore所封装的是关于如何制作纽约风味的比萨。工厂方法就是封装这种知识的关键所在。

工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

要点：
Creator是一个类，它实现了所有操作产品的方法，但不实现工厂方法。
Creator所有的子类都必须实现这个抽象的factoryMethod方法。
所有的产品必须实现一个共同的接口，这样一来，使用这些产品的类，就可以引用这个接口，而不是具体类。
ConcreteCreator实现了factoryMethod，以实际制造出产品。
ConcreteCreator负责创建一个或多个具体产品，只有ConcreteCreator类知道如何创建这些产品。
concrete具体的adj

设计原则：要依赖抽象，不要依赖具体类。
依赖倒置原则，不能让高层组件依赖低层组件，而且不管高层或低层组件，2者都应该依赖于抽象。
所谓高层组件，是由其他低层组件定义其行为的类。
例如，PizzaStore是个高层组件，因为它的行为是由比萨定义的。
依赖倒置原则，究竟倒置在哪里？
避免OO设计中违反依赖倒置原则
1 变量不可以持有具体类的引用。
如果使用new，就会持有具体类的引用。你可以改用工厂来避开这样的做法。
2 不要让类派生自具体类。
如果派生自具体类，你就会依赖具体类，请派生自一个抽象（接口或抽象类）
3 不要覆盖基类中已实现的方法。
如果覆盖基类已实现的方法，那么你的基类就不是一个真正适合被集成的抽象。基类中已实现的方法，应该由所有的子类共享。

抽象工厂模式
提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
比较工厂方法和抽象工厂。。。

要点1：
所有的工厂都是用来封装对象的创建。
简单工厂，虽然不是真正的设计模式，但仍不失为一个简单的方法，可以将客户程序从具体类解耦。
工厂方法使用集成：把对象的创建委托给子类，子类实现工厂方法来创建对象。
抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中。
所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合。
工厂方法允许类将实例化延迟到子类进行。
抽象工厂创建相关的对象家族，而不需要依赖它们的具体类。
依赖倒置原则，知道我们避免依赖具体类型，而要尽量依赖抽象。
工厂是很有为例的技巧，帮助我们针对抽象编程，而不要针对具体类编程。

《UNIX》超级工具

2008-12-17T09:15:00.002+08:00

《UNIX超级工具》也是暑假的时候买的，两本，打五五折的时候买的，可还是花了七十多。有点Geek的味道。随便地翻了很久，要说学到啥也谈不上，这两本书本来就是随便翻的。不知不觉，这两部书已经做满了记号，趁现在有些时间，做个简单的整理。

有人说程序员的七种武器是：正则表达式、编程语言、数据库、算法、软件调试、开发环境；在UNIX环境下，灵巧而强大的工具已经充斥其间，我们所缺的只是一个善于思考的大脑。在UNIX下，你可以不必关心一些细枝末节的东西，从而把注意力集中到真正的思考上，工具和思想在这里充分地协调起来。在这本书里充斥着技巧、工具和表格。简洁而实用。唯一不足的地方就是体系混乱，不过既然是随便翻翻，这个缺点也就不能称之为缺点了。

我基础还太差，看这种充满技巧的书有只见树木不见森林之感。因而要在这本书里整理出什么来还真是个琐碎而吃力的过程，打算以后系统地学习LPI LINUX教程时再结合本书做些整理。在此就先搁置吧。

《重构》1-4章_基础

2008-12-16T23:27:00.003+08:00

上个礼拜拿到了《重构》，读了前面的几章。还是蛮有意思的一本书，作者很幽默，译的也不错，只是价钱贵了点，有那么一点心疼。经典的书大多读起来不轻松，读快了啥也学不到，可有些经典的书读着有趣，随便翻翻有意无意间就会有比较大的收获，比如《代码大全》、《重构》等等。道理简单而实用，例子也恰到好处，加之文章穿插的点点幽默，实在是大快人心。

“记性好忘性大，故凡有所的必记诸文字”，译者熊节这话说得贴切。今天拿到的Maxtor的移动硬盘，广告居然叫“Save your life”。很好。不时时记录时时备份时时回顾，像我这等愚笨之人很快就会忘记生活了啥，这不能不说是一件可悲之事。

在http://old.blog.edu.cn/user2/26669/archives/2007/1753406.shtml 上发现了《重构》的笔记，我就直接厚颜无耻得拿来，然后再稍稍加些东西吧。

译序 --熊节
快速迭代&RAD --> crack的问题解决方式，在混沌的循环往复中实现需求--解构的美。
软件开发的理想国--在设计前期使用模式往往导致过度工程
重构--空气和水

前言

设计不再是一切动作的前提，而是在整个开发过程中逐渐浮现出来。
重构：有纪律，经过训练的，有条不紊。
聚沙成塔，从根本上改变设计

第一章、重构：第一个案例

例子：影片出租店用的程序。操作者告诉程序：顾客租了哪些影片、租期，程序就根据租期和影片类型计算费用；还要为常客计算点数。点数的计算与是否为新片有关系。程序为每次租用打印报表。

措施：同一段代码不要出现两次，应该用函数来定义。否则将来还要修改多处，容易引进错误。

需求变化1：用html方式输出报表。
需求变化2：要改变电影的分类方式，当然会影响收费和点数的计算，但是具体方案还没确定。

经验：不论用户提出什么方案，你唯一能得到的保证就是用户会在6个月内修改。
（这条经验很好玩，相当于说，你根本无法保证用户的需求不变化，唯一能得到的保证就是用户需求一定会变化。）
如果你发现自己需要为程序添加一个特性，但代码结构使你无法方便地那么做，则先重构再添加特性

重构第一步：为即将重构的代码建立测试环境。这是永远的第一步。
修改必须依赖测试，否则很容易进入新的bug，而且非常难debug。
重构之前，首先检验自己是否有一套可靠的测试机制，这些测试机制必须有自我检验能力。

措施：修改长的离谱的函数，并把函数移动到合适的class中去。
措施：修改变量的名字，使程序更可读。

note：任何一个傻瓜都可以写出计算机可以理解的代码。只有写出人类容易理解的代码，才是优秀的程序员。

阅读代码的时候，我经常进行重构。这样我就不断地把我的理解嵌入到代码中，才不会遗忘我曾经理解的东西。

如果一个类成员函数没有用到所在类的数据成员，则要考虑这个函数是否放错了位置。

尽量消除临时变量。临时变量往往形成问题，可能导致大量参数传来传去。在长长的函数中不易读。当然会付出性能上的代价。
作者的意思是，如果临时变量需要好几行来计算得到，就把临时变量的计算抽取为函数，称为query method。

重构以微小的步伐修改程序，及时发现。

运用多态取代switch、if/else。

一部影片可以在生命周期内修改自己的分类，但是一个对象却不能在生命周期内修改自己的类型（class）。--解决办法：state pattern
建立price类以及三个子类，与价格相关的代码移动到price相关类中。movie中设置一个price类型的成员对象。
price类中设置一个虚函数getprice，再实现一个默认的getpoints，让newprice子类去覆盖它。
把类型相关的代码用state/strategy代替。

本章总结：
extract method: 把长函数中的某部分抽取出来。把临时变量的计算抽取为函数（query method）。
move method: 看method使用哪个类的信息，就移动到哪个类中去。
replace conditional with polymorphism
self encapsulate filed ？这个是啥？
replace type code with state/strategy

重构的节奏：测试、小修改、测试、小修改。。。
重构后的程序风格将十分不同于过程化的风格。

第二章重构原则

重构定义：对软件内部结构的一种调整，目的是在不改变软件的外部行为的前提下，提高可理解性，降低修改成本。
注意，重构的目的不是提高性能。
高效且受控的代码整理模式。
两顶帽子：添加新功能和重构。
开发过程中，需要经常换帽子戴，无论何时，都该清楚你戴的是哪顶帽子，而且不能同时戴两顶帽子。

为什么要重构？
1、改进软件设计。重构就是要让所有代码回到应该在的位置。重构还可以消除重复代码。代码结构的流失是累积性的。
2、使软件更容易理解。修改代码，让代码反映我的意图。重构可以帮助你看到你以前看不到的设计层面的东西。重构带你到更高的理解层次上。
3、帮助你debug。弄清楚程序结构的同时，也很清楚地看到自己所做的一些假设。做个有着优秀习惯的好程序员。
4、助你提高编程速度。良好设计才是快速开发软件的根本。

重构应该随时随地进行。

三次法则：如果第三次做类似的事情，就应该重构。Three strikes and you refactor.
添加功能时重构
修改错误时重构
复审代码时重构。复审（code review）就是别人看你的代码。
不必想像代码应该是什么，可以看见它是什么样。

为什么重构有用？kent beck

重构的方向：容易阅读；消除重复逻辑（代码）；新的改动不会危及现有行为；尽可能简单表达条件逻辑。摆脱束缚的道路。

间接层和重构 kent beck

间接层是双刃剑，需要更多的管理，难以阅读。但是，间接层的价值是：

1、允许逻辑共享；
2、对“意图”和“实现”分开解释。class和函数的名字可以看作你的意图，其内部代码是其实现。如果class和函数以“更小的意图”来编写，则“实现”更近距离地和“意图”接触。
3、将变化隔离。
4、把条件逻辑用多态来表示，往往能增加清晰度并提高弹性。

如果增加一个异常。。。为了控制这种情况，为一个pakage定义一个super异常，这个packge下的所有异常都继承自它。这样就可以新增异常了。

重构与设计互补。重构降低了预先设计的压力。可以带来更简单的设计。在设计时仍然考虑各种可能的变化和更为灵活的设计，但是要考虑：把一个简单的方案重构为灵活的方案需要多大代价？

教训：哪怕你完全了解系统，也请实际测量它的性能，不要臆测。（或许潜台词是，你也许了解程序的架构和各种细节，但是你不一定了解系统中代码的执行率。）

要想优化性能，必须认真测量。

重构与性能：重构的确会使软件的运行变慢，但它使优化阶段的性能调整更容易。
efficient:高效；effective：有效
首先编写出可调的软件，然后调整它以获得足够的速度。
时间预算法 >> 持续关注发 >> 90%"发现热点，去除热点"

第三章：代码的坏味道

知道How不代表知道When，决定何时重构、何时停止和知道重构机制同样重要。
没有任何知识规矩能比得上一个见识广博者的直觉。

1、重复代码

同一个类里的两个函数有相同的表达式。方法：extract method

两个兄弟子类里含有相同的表达式。方法：对两个类使用extract method，然后使用pull up method，放到父类中。

2、过长函数

现在的编译器优化已经基本消除了函数调用开销。

小函数容易理解。让函数容易理解的关键是，给函数起一个合适的名字。

每当感觉需要用注释说明什么的时候，就把那部分提取成函数，以其用途而不是实现方式命名。

其实关键不在于函数的长度，而在于“做什么”和“如何做”之间的语义距离。

99%的场合下，只需要使用extract method

对于大量的参数，可以引入参数对象；对于临时变量，可以使用query method。

杀手锏：replace method with method object.

3、过大的类

很容易产生代码重复。

产生太多的临时变量。

4、过多的参数

类可以减少参数，因为成员函数需要的很多参数可以在类中找到。

5、发散式变化(divergent change)

当需求变化一点时，一个类需要修改好几个函数，则这个类或许应该被拆成两个类。

6、散弹式修改（shotgun surgery）

当需求变化一点时，需要对多个类做出小修改。应该使用move method和move field把要修改的代码放到一个类中。

原则是：将一起变化的东西放在一块儿。

7、依恋情结（feature envy）

某个函数对某个宿主类以外的类特别依赖。症结往往是数据。extract method , move method

8、数据泥团（data clumps）

常常可以看到：两个类中有一个以上的相同数据成员，许多函数中有相同的参数。这些总在一起出现的数据应该提取为一个类。

更重要的是，可以帮助寻找feature envy。

9、基本类型偏执（primitive obsession）

很多程序员懒得定义一些小类。

你可以定义一些与基本类型差不多的小class，比如字符串、日期、含一个起始值和一个结束值的range class、电话号码等等特殊的字符串。

10、swith

switch的问题在于重复。？

如果要添加一个case子句，很容易出错。

11、平行继承体系

就是两套class有相似的继承体系。当你为一个类增加子类时，必须为另一个类增加一个平行的子类。

shotgun surgery的一种特殊情况。

12、冗余类

对于没用的类、体系结构坚决消除。

13、过多考虑未来不确定的需求

如，看不到用处的扩展性。

14、很少用的数据成员

有的field可能只在极少情况下被使用。可以为这个field及其相关代码extract class。

15、过度耦合的消息链

没懂。也许后面有例子会好一点。

16、中间人

太多的delegation，就产生了中间人。中间人几乎不干实事，应该消除。

17、过分亲密

两个类过于亲密，互相探究彼此的private部分。有很多方法解决这个问题。可以move method,move field，extract class等等。

18、异曲同工的类/函数

两个函数功能一样但是签名不一样。

19、不完美的程序库

如果程序库不满足需求，可以：introduce foreign method, introduce local extension

20、纯粹的数据类

就像java bean?也挺有用的啊

只有fieild和getter setter。应该把调用它的那些代码抽取到这个类中，以隐藏一部分getter/setter

21、拒绝继承

如果子类拒绝继承父类的某些field、某些函数的实现，问题不算很大，甚至可以不用管；但是如果子类拒绝继承父类的接口，这就出现问题了。

22、过多的注释

当你需要撰写注释，请先尝试重构，试着让所有的注释都变得多余。

注释常常把我们带到之前提到的各种smell。如果注释要解释一块代码做了什么，请extract method；如果已经提取出函数但是仍然需要注释，则请rename method；如果需要说明某些入口条件，请引入断言。

注释可以写todo，why。

第四章:构筑测试体系
seft-testing Code: 确保所有的测试都完全自动化，让它们自己检验自己的测试结果。
极限编程者都是十分专注的测试者。
testing main：每个Class都需要有一个用于测试的main()
频繁地运行测试，每次编译都把测试考虑进去。
编写测试代码时，先让它们失败--failures <--> errors
bug --> 编写单元测试
编写不完善的测试并实际运行，好过对完美测试的无尽等待。
必然有错 --> 抛出异常

《执行》--突破

2008-12-16T16:29:00.003+08:00

刚刚考完的高等数理统计，是我进入上财以来遭遇的最大的失败，考前拼死拼活看了两天书，结果看来是挂了。觉得有些惭愧，完全违背了我读研的本意，要照这样下去，我还不如退学找个工作实在。

我不能说不努力，开学到现在三个月，我自己觉得也很累。脑子累，心累，身体也累。一直用力寻找着突破，可结果是让自己越来越累。大学时每学期或多或少都能有些收获，都能对自己的履历有所充实，可现在三个月过去了，除了累，除了不好的成绩，我好像并没有得到什么。

现在的我比任何时候都更需要一种简单的哲学，一种上进而充满张力的方式。前几天抽空看了下《执行--完成任务的学问》，现在顺便写些心得，同时也当作对自己的勉励。

Execution --the discipline of getting things done。我并不认为执行是一个新鲜的事务，“实事求是”，“实践是检验真理的唯一标准”，这些话说了好多年，可说多了反而忘了确切的含义，到现在反而要老外来告诉我们实事求是的含义，不能不说有点可悲。在我看来，执行不光是一个企业的事情，在自身的层面上，我们更需要这种实事求是的精神。在《卓有成效的管理者》这本书中，作者认为所有的知识工作者在某种意义上来说也是管理者，在时时刻刻地管理着自己的时间、精力和行为。我目前面临的困境只有通过实事求是的分析和卓有成效的执行才能突破，我依然坚信我的选择，同时，就算我做错了，我也无路可退。

下面的读书笔记摘自“三真阁” 。

执行是一门学问，是战略的一个内在组成部分。执行是一套暴露现实并根据现实采取行动的系统化的流程。执行应当是一个组织文化中的核心元素：执行必须渗透到企业的回报系统和行为准则当中，它既是企业文化，也是塑造企业文化的方法。

贯彻执行文化的基础是要在企业中推行坦诚、实事求是的交流活动和企业文化，而这就要求领导者通过亲身参与推动文化变革、战略制订乃至运营计划落实和跟进，充分了解自己的企业和员工，尽一切机会对管理人员进行影响和指导，但这不等于要求领导者事必躬亲，而是要按照一个事先制订的跟进计划，对关键点和关键环节的执行进行关注、对结果及时评估和应变，就像柳传志在专文推介中说的，“有效的执行是需要领导者亲力亲为的系统工程，而不是对企业具体运行的细枝末节的关心。”
　　
执行的关键就在于把战略与企业的实际情况、实际能力结合起来，建立相辅相成、近乎一体的战略、人员与运营流程。

人员流程的关键是，在战略的高度进行人力资源管理，把人员的招聘、评估、培养和调动与岗位需求切实的统一起来——而岗位需求恰恰是建立在企业的战略和运营要求之上的，以坦诚的态度、统一透明的评估标准、及时并集思广益的评估和沟通活动，来推动人员流程发挥作用。

战略流程的关键是，在制订的时候就充分考虑其可执行性，也就是人员的要求是否满足，是否能够落实为运营计划。战略制订和评估过程中，要充分调动真正的执行者参与讨论，确保对竞争环境和执行能力已经具有充分准确的了解，保证战略在执行部门得到充分的理解和支持，在人员和运营计划的落实上没有问题。领导者还可以通过此过程指导员工，推动文化变革，凝聚团队，激发斗志。领导者还要在战略评估结束之后的跟进中确认讨论共识，并将其作为战略实施过程中的进程指标，强调在战略、人员和运营之间建立必要的联系。

运营流程的关键是，通过更广泛的参与（各部门的执行团队，甚至所有成员），对竞争环境和未来变化假设进行更仔细的考察讨论，对可能开展的项目对照战略方向进行取舍，将战略计划落实为更详细的企业目标、行动计划和跟进措施（及时的评估和应急计划），为工作开展提供明确的指导方向。通常情况下，一份运营计划包括了你的企业准备在一年之内完成的项目——与企业预算和财务目标相结合，而预算和财务目标恰恰应该根据企业的运营计划来确定。

本书其他细化内容其实就是各门科管理科学的论述、操作实务和案例分析，有益于对照自查。

Life is light

2008-12-12T15:17:00.002+08:00

今天看了《布拉格之恋》，很长的一部电影，讲述着冗长无奈而又无从逃避的生活。《生命中不能承受之轻》，高中时看过这本书，以后逐渐淡忘，相信命运靠的是实实在在的打拼。进了大学就远离了诗歌、散文、小说。参考手册几乎成了我最喜欢的书。

上海的确是一个容易诞生小资情感的地方。因为在这个地方，人太容易发觉自己的无足轻重，太需要麻醉。我依旧是个无趣而又无足轻重的人，小资离我实在太远，生命是轻的，也许没有意义。但我依然会选择打拼，更实在，更踏实。既然原本就没有意义，我也自然不用为之悲伤。

这学期看了很多书，却什么也没做，依旧卑微地努力，只希望今天的自己比昨天能多些什么。却也许什么都没得到。我们都在赶路，只有在回忆中才能寻找偶尔的满足。

喝杯咖啡，继续战斗。

Cute Communism

2008-12-09T13:20:00.006+08:00

英语口语课的演示，胡乱搜集了些图片，拼凑了几张slide。

爱、策略、重构

2008-12-03T22:56:00.004+08:00

每次上金融博弈那个个性的老头总会给我些启发，如下：

今天的开篇词是“爱”，老头摘了圣经中的一段话作为阐释，具体记不清了，反正是大爱无形的那种爱。然后他坦承了他老婆逼着他说爱，那老头勉勉强强婚前说了一次，然后就再也没说过。他很坦诚地说他也不知道啥是爱，他觉得对别人的爱说到底是爱自己。那老头一定是水瓶座的，反正我也这么觉得.

然后是正题，讲到了策略设计，很有意思的话题，我觉得工资的定价机制也是个策略问题，也就是个博弈论的问题。一般企业都有固定的职级和工资级别，职级是公开的而工资的基本却不透明，这肯定有着其中的道理，而且也许不那么简单，不仅仅是激励和士气的权衡。以后空了再找些相关内容看看。

然后今天又到了一批书，《重构》、《编程之美》、《执行力》、《卓有成效的管理》等等。这两天买书花了300多块钱，都是计算机、经管、投资方面的经典之作。愿读完能有些提高吧。

昨天参加竞选失败，总体来说一是由于开学以来一直忙着自己的事情，和大家有些脱节；二来是个平衡问题，一些无意的因素让我处在不利的位置；三来竞选演讲做得实在很烂，犯了一些大忌。虽然有点郁闷，但我并没损失什么，对我的现在和将来也不会有什么影响，其次我也发现了自己存在着一些问题，需要调整，用傻一点的话就是“重构”；个性的调整也是个迭代的过程。

时间

2008-12-01T18:33:00.003+08:00

忽然间就要考试了，这学期天天忙碌，却不知忙的啥，所谓结构化混日子，说的就是我现在这样子吧。还坚信努力总有回报吧，SNA和高统，这半个月就彻彻底底地交给你们啦。爬山虎，看着还像是秋天，其实已是冬日。这植物，和我一般迟钝那。
已是十二月初，回顾这大半个学期，一直忙忙碌碌，可却第一次觉得有些迷惘，选择考研、特别是考统计也许真是一个失误；但这些都是无法改变的事实，我所能做的是尽所有的可能，将错误的成本降到最低。

Code Complete PART 6

2008-11-30T13:24:00.002+08:00

System Considerations

chapter 27: How program size affects construction
随着项目的增大交流需要加以支持
放大轻量级的方法要好过缩小重量级的方法，最好使用适量级的方法

1. Commmnication and size

2. Range of project size
3. Effect of project size on errors
4. Effect of project size on productitivity
5. Effect of project size on development activite
交流、计划、管理、需求分析、设计、架构、集成、测试、文档的非线性增长
程序 -- 产品 -- 系统 -- 系统产品
Methodology and size 方法论和规模

Chapter 28: Managing construction
一般管理 > 软件管理 > 构件管理
贯彻标准，使用更为灵活的方法 --> 好的编程实践
程序员和管理人员都是人
1. Encouraging good coding
Techniques for encouraging good coding
逐行检查、要求代码签名、安排好的代码示例、代码是公有财产、奖励好的代码
2. Configuration management
SCM: Software configuration manangement
Requirements and design changes
遵循某种系统化的变更控制程序
成组地处理变更请求
评估变更成本
提防大量的变更请求
变更控制委员会
Tools:
cvs, svn, Machine configurations, Backup plan
降低程序员的额外负担；避免对项目的过度控制
3. Estimating a construction schedule
Estimation approaches
评估软件；算法方法：Cocomo 2
建立目标
为评估留出时间并做出计划
清楚说明软件需求
在底层细节层面进行评估
使用不同的评估方法并进行比较
定期做重新评估
Estimation vs. Control
what to do if you are behind:
项目并不能在后期把时间补回来，只会越拖越坏
扩充团队？缩减项目范围。
4. Measurement
留心度量的副作用
反对度量就是认为最好不要知道真实
5. Treating programmers as people
程序员并非只是与硅芯片打交道的有机物。
How do programmers spend their time
Variation in performance and quality
Individual variation
Team variation
Religious issues 信仰问题
编程语言、缩进风格、大括号、IDE、注释风格、效率 vs. 可读性、方法的选择、编程工具、命名习惯、goto、全局变量
6. Managing your manager
人性的弱点

Chapter 29: Integration
1. Importance of the integration approach
结果也许正确，但错误的过程依然会导致失败
2. Integration fraquency -- phased or incremental
Phased integration
测试、编码、测试、调试。单元开发
将这些类组合成系统（system integration）
测试调试（system dis-integration）
Incremental integration
开发模块，测试调试模块，集成到系统
Benefits of incremental integration
易于定位错误
及早在项目中取得系统级的成果
改善对进度的监控
改善客户关系
更充分地测试系统的各个单元
能在更短的开发进度计划内建造出整个系统
3. Incremental integration strategies
Top-down Integration
能较早地测试系统的控制逻辑
Bottom-Up Integration
容易定位错误
要求在开始前，已经完成整个系统的设计工作
Sandwich integration
Bottom-UP + Top-down
Risk-Oriented integration
困难部件优先集成法
鉴别风险级别
Feature-Oriented Integration
以一组构成一项可确认功能的类为单位进行集成
T-Shaped Integration
选中特定的竖直块，及早地进行测试和集成
4. Daily build and smoke test
使一些工作及早地浮出水面
每日构建（daily build）
检查失败的build
每天进行冒烟测试
编译自动化
但有意义时，才将修订加入到build
代码添加到系统前进行冒烟测试
为即将添加的代码准备暂存区

Note of Excel Function

2008-11-30T10:57:00.002+08:00

以前一直没有系统学过Excel，可最近发现Excel和VBA编程在财务的各个方面都是非常重要的。正好最近要做财务报表分析的大作业，趁此机会先学习下Excel的函数，以后有时间再看下VBA。
教材是张迎新的《Excel 2003 函数应用完全手册》，很简洁，很手册的一个东西。下面的笔记是书的一些摘录：

函数和公式
Excel 函数可以分为内置函数和扩展函数两大类。前者只要启动了Excel，用户就可以使用它们；而后者必须通过单击“工具→加载宏”菜单命令加载，然后才能像内置函数那样使用。
函数的参数
数组：
Excel 中有常量和区域两类数组。
前者放在“{}”(按下Ctrl+Shift+Enter 组合键自动生成)内部，而且内部各列的数值要用逗号“,”隔开，各行的数值要用分号“;”隔开。{56,78,89;90,76,80}
区域数组是一个矩形的单元格区域，该区域中的单元格共用一个公式。“B1:B3,A1:A3”
错误值：
ERROR.TYPE(error_val)
单元格引用：
相对引用：=SUM(A2:E2)
绝对引用：=SUM($A $3:$E $3)
混合引用：混合引用有“绝对列和相对行”，或是“绝对行和相对列”两种形式。前者如“=SUM($A3:$E3)”，后者如“=SUM(A$3:E$3)”
三维引用：=SUM(Sheet2!A1:A6,Sheet3!B2:B9)
=SUM([Book2]Sheet1! SA S1: SA S8,[Book2]Sheet2! SB S1:SB S9)
三维引用的要受到较多的限制，例如不能使用数组公式等。
名称和标志：
=AVERAGE(B2:B46) --> =AVERAGE(物理分数)
创建好的名称可以被所有工作表引用，而且引用时不需要在名称前面添加工作表名(这就是使用名称的主要优点)，因此名称引用实际上是一种绝对引用。但是公式引用“列标志”时的限制较多，它只能在当前数据列的下方引用，不能跨越工作表引用，但是引用“列标志”的公式在一定条件下可以复制。

Code Complete PART 4

2008-11-30T09:34:00.002+08:00

Statements
Chapter 14. Organizing Straight-line code
主要原则：按照依赖关系进行排列
1. Statements that must be in a sepcific order
设法组织代码，使依赖性变得非常明显
利用子程序名、子程序参数显示依赖性
用注释对不清晰的依赖关系进行说明
2. Statements whose order doesn't matter
making code read from top to buttom
localized --> short live time
grouping related statements
不应该交叠，但可能嵌套

Chapter 15: Using conditionals
1. if statements
plain if-then statements
先处理正常情况，然后其它
确保对于“==”是正确的
把正常的情况处理放在“if”后面
让if语句后跟随一个有意义的子句
chains of if-then-else statements
用布尔函数简化复杂的检测
最常见的放最前
2. case statements
choosing the most efficitve ordering of cases
字母序、正常放最前、频率序
tips for using case statements
简化每种情况对应的操作
不要为使用case刻意制造一个变量
default子句只用于检查真正的默认情况
避免代码执行跨越一条case子句的末尾

Chapter 16. Controlling Loops
1. selecting the kind of loop
counted loop; coutinously evaluated loop; endless loop; iterator loop
when to use while loop
预先不知道迭代的次数
with test at the beginning & end
when to use a loop-with-exit loop
终止条件出现在循环的中部
break; goto
把所有的退出条件放在一处，用注释阐明意图
when to use a for loop
执行固定次数的循环，不需要循环内部控制
when to use a foreach loop
消除了循环内务处理
2. Controlling the loop
减少影响循环的因素数量，把循环内部当作子程序
entering the loop
只从头部进入
初始化代码紧反正循环前
用while表示无限循环
在while适用的时候，不使用for
processing the middle of the loop
避免空循环
循环的内务操作反正循环的开始或结尾
一个循环只做一件事
exiting the loop
终止确认条件
避免依赖循环下标的最终取值
考虑使用循环计数器
小心break&continue
带标号的break
checking endpoints
using loop variables
使用有意义的名字：提高可读性，避免下标串话
把循环下标的作用域限制在本循环内
how long should a loop be
尽可能短，嵌套在三层以内
把长循环的内容移到子程序内
3. Creating loops easily - from the inside out
inside out; 使用字面量
4. Correspondence between loops and arrays
密切联系但不是必然的

Chapter 17: Unusual contorl structures
1. Multiple returns from a routine
如果能增强可读性，就使用return
用guard clause（早返回或退出）来简化错误处理
2. Resursion
tips for using recursion
确认递归能够停止
使用安全计数器防止无穷递归
限制在一个子程序内
递归 or 循环 -- 阶乘
3. goto
万不得已才使用goto
goto导致的效率的提升需可以估量
尽量在每个子程序中最多使用一个goto
尽量让goto先前跳转而不是向后
goto标号
确认goto不会产生执行不到的代码

Chapter 18: Table-driven methods
Table-driven is a scheme -- 从表里查找信息而不是用if or case
复杂逻辑和复杂继承结构的替代方案
1. General considerations of using Table-Driven methods
查询记录的方法：
Direct access
Indexed access
Stair-step access
2. Direct access tables
Date-in-Month example
Flexible-Message-Format Example
Logic basied vs. Object-Oriented vs. Table-Driven
Fudging lookup keys
复制信息从而能直接使用键值
转换键值使之能直接使用
把键值转换提取成独立的子程序
3. Indexed Access tables
4. Stair-step Access tables
把每一区间的上限写入表中，使用循环按照各区间的上限检查分数
留心端点
二分法查找，索引访问？
最好是去选择一个好的方案同时避免灾难，而不是试图寻找最佳的方案。
5. Other Examples of Table loopups

Chapter 19: General Control Issues
1. Boolean expressions
Using the true and false for boolean tests
Making complicated expressions simple
拆分复杂的判断并引入新的布尔变量
将复杂的表达式做出布尔函数
用决策表代替复杂的条件
Forming boolean expressions positively
I ann't not no undummy. 我并非不是一个不傻的人。
用狄摩根简化
Using parantheses to clarify boolean expressions
Knowng how boolean expressions are evaluated
Writing numeric expressions in Number-line 2order
Guildines for comparisions to 0
隐形地比较逻辑变量
和数值表达式相比使用显示写法
指针 -- NULL
Common problems with boolean expressions
C家族中，应该把常量反正比较的左端

2. Compound Statements(Blocks)

3. Null statements

4. Taming Dangerously deep nesting

重复检查条件中的某一部分来简化嵌套的if

使用break来简化

if --> if-then-else

if --> case

抽取并放入子程序

对象和多态派分

5. A programming foundation: Structured Programming

structured goofing off 结构化混日子

The three components of structured programming

sequence; selection; iteration

6. Control structures and complexity

应用程序的复杂度是由它的控制流来定义的

General guidelines for reducting complexity

How to measure: decision point

if; while; repert; for; and; or; case

0-5: good; 6-10; 10+

冬日

2008-11-29T23:58:00.010+08:00

今天朋友过生日，下午三点出发，到晚上快十一点才回了宿舍。四个刚工作的女孩子和四个IT男，80、82、85的加上最小的86的我。四个女人吵的不闲累，我听着都心力憔悴。。原本以为去了就吃，结果被叫去了买菜。。辛辛苦苦做好了难吃的又都成了我做的。。这世道。

路上无聊的公交时间拍了一些照，冬天真的来了，可正因为冬天来了，有了冷也就有了暖。大千世界滚滚红尘真是很神奇的一个东西。让人时而逃避时而依赖。平凡的人们一日又一日地或忙碌或闲适，游戏着生活，也被生活游戏。

四个IT人，一个比一个冷，无聊间又说起了水瓶的坏话，我同意。某些角度看，我的确是个自由自私同时无趣的人。过去、现在和将来，我都会努力做个个自信、事实求是而又卑微的工程师。呵呵，努力！

WALL.E

2008-11-27T23:07:00.004+08:00

WALL•E 全名叫Waste Allocation Load Lifter-Earth Class, 700年来日日尽忠职守的留在地球清理垃圾，唯一伴侣就是一只生命力超强的小强。每天做着同样的事情，寂寞无奈却又乐在其中。
这周一直在看UNIX，基本无序但每天都学到很多，大学时如果选择C和UNIX这方向的话，对计算机应该能有更好的理解。可惜我过早选择了Java。
晚上在china-pub上买了《编程珠玑》的两册，打算好好拜读。然后，差不多要考试了，继续浑浑噩噩地努力吧。

课程论文的LATEX模板

2008-11-23T19:10:00.003+08:00

上午费了些劲李果正（Edward G.J. Lee）的《由TEX/LATEX 制作中文PDF文档》中的样式和清华毕业论文的样式结合，做了一个适合一般课程论文的Latex模板。比较简单清爽。

源码如下：
\documentclass[dvipdfm,11pt]{article}
\usepackage[paper=a4paper,dvips,top=2.5cm,left=2.8cm,right=2.8cm,foot=1cm,bottom=3.2cm]{geometry}
\usepackage{CJK}

% 控制标题的宏包
\usepackage[sf]{titlesec}
% 控制目录的宏包
\usepackage{titletoc}

%引用上标
\makeatletter
\def\@cite#1#2{\textsuperscript{[{#1\if@tempswa , #2\fi}]}}
\makeatother

\newcommand{\song}{\CJKfamily{song}} % 宋体 (Windows自带simsun.ttf)
\newcommand{\fs}{\CJKfamily{fs}} % 仿宋体 (Windows自带simfs.ttf)
\newcommand{\kai}{\CJKfamily{kai}} % 楷体 (Windows自带simkai.ttf)
\newcommand{\hei}{\CJKfamily{hei}} % 黑体 (Windows自带simhei.ttf)
\newcommand{\li}{\CJKfamily{li}} % 隶书 (Windows自带simli.ttf)

\newcommand{\yihao}{\fontsize{26pt}{36pt}\selectfont} % 一号, 1.4倍行距
\newcommand{\erhao}{\fontsize{22pt}{28pt}\selectfont} % 二号, 1.25倍行距
\newcommand{\xiaoer}{\fontsize{18pt}{18pt}\selectfont} % 小二, 单倍行距
\newcommand{\sanhao}{\fontsize{16pt}{24pt}\selectfont} % 三号, 1.5倍行距
\newcommand{\xiaosan}{\fontsize{15pt}{22pt}\selectfont} % 小三, 1.5倍行距
\newcommand{\sihao}{\fontsize{14pt}{21pt}\selectfont} % 四号, 1.5倍行距
\newcommand{\banxiaosi}{\fontsize{13pt}{19.5pt}\selectfont} % 半小四, 1.5倍行距
\newcommand{\xiaosi}{\fontsize{12pt}{18pt}\selectfont} % 小四, 1.5倍行距
\newcommand{\dawuhao}{\fontsize{11pt}{11pt}\selectfont} % 大五号, 单倍行距
\newcommand{\wuhao}{\fontsize{10.5pt}{10.5pt}\selectfont} % 五号, 单倍行距

\newlength \CJKtwospaces \CJKtilde

\titleformat{\section}[hang]{\sf \hei \sihao}
{\sihao \thesection}{0.5em}{}{}
\titlespacing{\section}{0pt}{-0.2em}{0.8em}

\titleformat{\subsection}[hang]{\hei \sf \banxiaosi}
{\banxiaosi \thesubsection}{0.5em}{}{}
% {\banxiaosi \thesubsection}{0pt}{}{}
%\titlespacing{\subsection}{0pt}{1.5ex plus .1ex minus .2ex}{\wordsep}
\titlespacing{\subsection}{0pt}{-0.25em}{1em}

\titleformat{\subsubsection}[hang]{\hei \sf}
{\thesubsubsection }{0.5em}{}{}
%\titlespacing{\subsubsection}{0pt}{1.2ex plus .1ex minus .2ex}{\wordsep}
\titlespacing{\subsubsection}{0pt}{0.25em}{0pt}

% 缩小目录中各级标题之间的缩进
\dottedcontents{chapter}[0.0em]{\hei\vspace{0.5em}}{0.0em}{5pt}
\dottedcontents{section}[1.16cm]{}{1.8em}{5pt}
\dottedcontents{subsection}[2.00cm]{}{2.7em}{5pt}
\dottedcontents{subsubsection}[2.86cm]{}{3.4em}{5pt}

% 颜色的设定要引进 color package。
\usepackage[dvips]{color}
\definecolor{webbrown}{rgb}{.6,0,0}
\usepackage{times}
\linespread{1.4}

% 由于把行距加大，要把脚注的行距缩成预设的，这个设定采自吴聪敏教授的
% 《cwTeX 排版系统》修订二版一书，页 143。
\let\oldfootnote\footnote
\renewcommand\footnote[1]{\oldfootnote{\renewcommand\baselinestretch{1.0}%
\large\footnotesize\ignorespaces#1}}
\addtolength{\footnotesep}{1pt}
\begin{document}
\begin{CJK*}{GBK}{song}
\newcommand{\bigfive}{\textrm{Big-5}~码}
\renewcommand{\figurename}{图~}
\renewcommand{\tablename}{表~}
\renewcommand{\contentsname}{目~录~}
\renewcommand{\appendixname}{附~录~}
\renewcommand\refname{参~考~文~献}
\newcommand\prechaptername{第}
\newcommand\postchaptername{章}
\renewcommand\indexname{索~引}
\renewcommand\abstractname{摘~要}
\renewcommand{\today}{\small \number\year~年~\number\month~月~\number\day~日}
\title{\textcolor{webbrown}{\Huge \sf \kai 质疑的质疑}\\{\Large 对~ What's Happening to China's GDP Statistics? 的分析}}
\author{\small Sunix.Xu~~~~Email:xuyizun@gmail.com\\ \small SHUFE Statistics~~~~NO:XXXXXXXXX}
\maketitle
\tableofcontents
\newpage
% 调整段落间距离
\parskip=0.2cm

\section{前言}
\label{sec:introduction}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

\begin{thebibliography}{99}
\bibitem{thomas} Thomas G. Rawski:
《What's Happening to China's GDP Statistics?》,
China Economic Review
2001.12
\end{thebibliography}
\end{CJK*}
\end{document}

质疑的质疑

2008-11-23T18:58:00.002+08:00

下文是国民经济核算的案例论文，对Thomas G. Rawski的文What’s Happening to China’s GDP Statistics? 所做的分析。

质疑的质疑
--对What’s Happening to China’s GDP Statistics? 的分析

1 前言
美国匹兹堡大学经济学教授Thomas G. Rawski在2001年12月在《中国经济评论》发表了著名的《What’s Happening to China’s GDP Statistics?》[1]一文。他通过研究中国各省市的经济统计资料，发现这些资料与中国国家统计局发表的数字有不相符合之处，因而提出了对中国统计数据的质疑，他根据中国经济增长与能源消费相反的变动趋势并对比亚洲其它国家后认为，中国自1998年以来的经济增长速度是不真实的。
而在这同时，国外和国内的很多经济学家对Rawski的质疑提出了反质疑，从GDP统计、能源统计、中国经济结构转型等多个方面回答了GDP数据和能耗数据间的矛盾。
本文将本着客观的立场，首先概述Rawski教授的质疑，之后简述国内外学者对此问题的观点，然后进行对比分析并给出我的见解，最后将对GDP统计存在的问题作出总结。
需要说明的是Rawski只是从客观的角度对问题进行了描述和分析，并不带有政治色彩，他的分析对于我国发现并分析发展中遇到的种种问题有着很大的帮助。

2 Thomas教授的质疑
Thomas G. Rawski教授通过以下三个方面对中国GDP统计的真实性提出质疑[1][4]：
2.1 数据之间的不一致性
经济增长率数据与能源消耗、就业和消费价格数据之间的不一致性
中国经济增长与能源消费变动趋势相反，这不符合人们的常识，1997年到2001年间，官方公布的GDP增长了24.7%而能源消耗却降低了12.8%，同时，一些数据表明，中国在97/98年的能源利用率依旧停留在83/84年水平。
对比亚洲其它国家及中国在97年以前10年的数据，能源消耗和GDP一般存在着同向运动的规律。而中国在97年到2001年间的数据却明显违背了这一规律。
生产数据之间以及生产数据与投资数据之间的不一致性
1998 年,水灾是20 世纪中国十大自然灾害之一，但除一个省之外，所有省的农业产出
都是增加的；94 种主要工业产品中只有14 种产品获得两位数增长，工业生产却上升
了10. 75%；钢材消耗和水泥产出增长不到5% ,投资却猛增13. 9%。
消费数据之间的不一致性
除2000 年外,全国社会消费品零售额增长比人均消费支出增长快得多。
消费数据与收入数据之间的不一致性
社会消费品零售额的增长比住户收入的增长快得多，这意味着平均消费倾向在上升。
然而,最近的研究发现,消费支出占收入的比率呈下降的趋势。
2.2 来自中文评论文章的信息
Rawski在文章中摘引了几篇评论中国官方统计数据的中文文章的观点，并声称，大量的中文评论文章表明在整个商业社会和各级政府，经济发展指标的虚报浮夸成为一种普遍现象。
文中指出，从1998 年开始,国家统计局抛弃了省级经济增长数据；虽然国家统计局近些年努力创造跨越地方和省级政府的统计网络，但它不具备在正常的信息渠道以外搜集数据的能力。
2.3 经济增长率的上限
中国航空客运业的客户主要是国内收人最高的阶层，而他们的收入增长水平应超过平均增长水平。因此，航空客运的增长应该高于居民可支配收人的增长，而后者是的计算基础。但罗斯基却计算出在97、98年间乘客里程的增长只有2.2%，而同期GDP的增长率却分别为8.8%和7.8%。
基于以上几点，Rawski认为地方官员迫于政绩的压力，或因为编造数据的收益超过了因编造数据带来的风险从而欺骗中央，所以最终的统计数据是不真实的；然而统计资料中有些数据却反映了经济的实质，比如能源消耗和民航业的发展。97年到01年，GDP增长了，而能源消耗却在下降，Thomas认为能源利用效率的提高不足以解释这巨大的反差。

3 对质疑的反质疑
对于Rawski的质疑，国内外的专家学者纷纷给出了自己的见解，对他的质疑提出了各自的观点。主要集中在以下几个方面：
GDP和能耗并不一定存在严格的规律
经济增长模式的转变导致了数据的不一致性
3.1 GDP和能耗的非一致性
任若恩教授认为，经济增长率与能源消耗增长率应该大致相等，这一假设要求满足一个国家在经济发展过程中是同质的，能源消耗的产业结构和使用能源的技术不变。针对罗斯基依据经济增长率与能源消耗数据之间的不一致性对中国经济增长率数据的质疑，任若恩考察了德国、英国、美国、日本和韩国的经济增长与能源增长数据之间的关系。他发现，这些国家都曾经出现过经济增长与能源增长数据不同步的现象：从经济发展历史看，在不同国家的经济发展中，如日本、德国、英国等，能源增长低于经济增长的数据出现频率不在少数。美国大概两次，日本一次，都出现过GDP增长而能源下降的历史的差距[3][5]。
如果因为能源增长率低于经济增长率，因此就认为经济增长率数据可能出现高估，那么，当能源增长率高于经济增长率时，就可以怀疑经济增长率数据出现低估，而这显然是没有依据的。
能源总产和总消费与中国经济增长之间从来不存在十分密切的关系，在1978–2000年间，有13年能源的消费弹性（消费增长率与GDP增长率的比例）是低于+0.5的，而在1978–2001年间也有14年能源的生产弹性（产量增长率与GDP增长率之比）低于+0.5。最关键的是, 并不是只有以往几年才是如此，连公认的中国经济过热的1992–1994年间，能源增长和消费均跟GDP没有什么关联。此期间同步伴随中国大规模的能源供给结构调整，煤炭供给受限严格，而电力消费有所上升，煤炭严格限制可能是导致统计内能源消费萎缩的主要原因[6]。
3.2 经济增长模式的转变导致了数据的不一致性
张新和蒋殿春在《中国经济的增长――数据的可信度以及增长的微观基础》[6]中对近年来中国经济增长速度及其与企业微观绩效之间的关系进行了理论和实证性的分析研究，结果表明：首先，我国近年来的经济增长数据墓本可靠；再者，我国宏观和徽观经济之间并不存在本质性的背离。
我国目前仍然处于粗放式经济增长阶段，主要是依靠物质资源、人力资源的大投入和规模的快速扩张来推动经济的高速增长；但只要以后中国整个经济体系的效率是逐步上升，单位能耗逐渐降低，那么电力等生产资料产量的增长速度在一个很长的时间内将慢于整个经济的增长速度。正是能源效率的改进导致能源消耗持续下降。

4 统计数据存在的问题
事实上，中国经济增长率的统计的确存有问题，在计算水平、方法与范围等方面有待进一步改进提高。一些省份有多报的动机，同时也有一些省份有瞒报的动机。统计数据，尤其是GDP数据，没有一成不变的，随着时间的推移，基础资料和统计方法会不断完善，为了保持客观性和可比性，历史数据需要不断进行调整。美国就曾经对它的GDP历史数据作过11次调整。
在《南方周末》对国家统计局国民经济核算司司长许宪春的访谈中，许宪春揭示了统计数据存在的一些问题[10]：
4.1 统计数据来源及其对比
数据来源
– 国家统计局独立调查的数据
内容：全国的粮食产量、棉花产量、主要畜禽产品产量；规模以下的非国有工业企业、小型商业企业、个体工商户的产值和增加值；农村固定资产投资、城乡居民住户收入和支出、商品和服务的价格。
– 地方汇总的数据
内容：全部国有企业和年产品销售收入500万元以上的非国有企业。
数据源对比
地方汇总数据统计方法以全面报表为主，基层单位向地方政府统计部门报送报表，然后层层汇总到国家统计局。一般来说，这种调查方法由于涉及的单位多，需要的人员多，因而难以保证基层统计资料的准确性。抽样数据抽样调查涉及的单位少，需要的人手相对少，因此有可能对统计人员进行较全面的业务培训，从而能够提高基层统计资料的质量。
综合统计数据来源及其对比，我们可以发现国家统计局可以控制质量的数据仅占到国民经济的很少部分，全部国有企业和规模以上的非国有企业的数据要靠地方汇总，这部分的数据质量难以得到十分的保证。
4.2 数据质量评估及数据调整
在数据评估方面，由国家统计局评估省一级的数据，省统计局评估地市一级数据。但由于《统计法》是一种行政法规，加之统计局在行政机构中的地位，对于一些地方官员并没有很强的约束力。
目前各省公布的GDP加总后都要高于国家统计局公布的全国GDP，国家统计局需要挤出其中的“水分”，主要采用以下的方法：
² 采取抽样调查的方法
² 实行超级汇总方法排除中间层次的干扰
² 加大执法力度，查处统计违法现象
² 建立数据质量评估制度
从中，我们可以看到国家统计局对于挤出“水分”并没有真正强有力的方法。从以上内容我们可以分析得出，国家统计局对于数据的质量没有十分可靠的保障，地方政府官员可能出于自身利益的考虑多报或少报数据。东部沿海的省分由于以民营经济为主，可能会低报经济增长数据以减少上缴中央税收。[3]。

5 中国崩溃论？
自20世纪90年代以来，国际上关于中国问题的较大争论有过四次。第一次是1994年，美国世界经济研究所布朗提出“谁来养活中国人”，引发了一场大争论；第二次是1992年以来，国际上泛起一股“中国威胁论”，已经直接影响西方大国的对华政策的重新制定；第三次是去年开始出现的“中国崩溃论”，无限放大中国目前经济社会中存在的一些问题，并得出草率的结论；第四次则是这次的“中国统计水分论”[9]。
这些争论，有的纯属学术范畴，有的则带有国际政治角力的背景，但无论从哪个角度、用哪种眼光来审视中国的发展，有一个基本事实不容忽视，这就是在近年来世界上发生的各种危机面前，在中国自身宏观经济运行面临诸多深层次困难的情况下，中国不但没有衰退和崩溃，反而保持连续多年的经济高速增长。即使GDP数据存在着一些问题，这也不能代表中国经济仅有数字上的辉煌，而实质上已经走到了崩溃的边缘。
GDP是考察经济的实际运行情况的一个重要的指标，但不是唯一的指标。任何一个国家的经济增长都是由多种因素决定的，没有一种单独的经济活动能够解释像现代经济这么复杂的情况，尤其像中国这样大规模的经济。下面将引述Klein和Lardy关于中国经济的评论[4]。
5.1 Lawrence R. Klein对中国经济的评论
为了从一个新的视角研究中国的GDP ，并利用独立的信息检验中国GDP 估计的一致性，论文收集了以下15 个变量：电力(千瓦时) ；煤炭(吨) ；原油(吨) ；钢产量(吨) ；货运(吨公里) ；民航运输(吨公里) ；第三产业就业比重( %) ；粮食产量(吨) ；出口(美元不变价) ；进口(美元不变价) ；政府支出(经过价格缩减) ；实际工资；长途电话(次数) ；通货膨胀率(消费价格指数) ；畜产品(吨) 。这些变量概括了能源、交通、通讯、劳动力、农业、公共部门、工资、通货膨胀情况。利用1980～2000 年年度数据，论文对这15 个指标进行了主成分估计[7]。
论文指出,概括地说,主成分反映了从不同资料来源相当独立地收集的15 个指标的变动，对中国经济来说有广泛代表性。这些指标的变动与中国官方估计的实际GDP 的变动是一致的。
5.2 Nicholas R.Lardy对中国经济的评论
Lardy列举了两个经济指标，一个是进口额，另一个是财政收入。中国官方数据表明，1997～2001 年，进口额增长了70 % ，财政收入增长了90 %。Lardy认为，进口额不可能被夸大，因为负责贸易统计的海关必须向财政部缴纳进口关税。财政收入也不可能被夸大，因为政府处于日益增加的社会资金需求的巨大压力之下，包括失业补贴、国企下岗工人退职金、缓解环境恶化和为军事现代化提供资金，等等。Lardy说，对所有国家来说，在经济增长率明显下降的情况下，由于企业利润减少，个人收入和消费停滞，税收的增长几乎不可避免地会更加放慢。中国经济增长在过去的四年里严重衰退与税收如此强劲增长是难以吻合的[8]。
虽然能源消耗降低、失业率上升等因素来说明中国经济并没有获得快速增长的观点一时还很难被完全驳倒。但事实证明了中国经济的确在强劲增长。同时也表明，单凭一两个指标来判断复杂的经济形势是没有任何科学依据的，也是和事实相违背的。

6 对Thomas Rawski观点的综合评述
综合以上的信息，我认为Thomas G. Rawski的质疑是有理由的，能源消耗和增长之间的不对应的原因缺乏进一步的分析；但他质疑中国统计数据造假的观点是站不住脚的；他得出的结论过于轻率，具体说体现在一些方面：
1. Rawski对于GDP数据的质疑是有的一定道理的
虽然说经济增长率与能源消耗、就业和消费价格数据之间存在着不一致性，且中国正在进行着较大的产业结构调整，但30%的差距依然很难被解释。一方面，能耗的统计存在着一些问题。由于非国有煤炭发展较快，因此20世纪90年代中期以后中国的能源统计一直存在一些问题[2]；另一方面，由于统计制度等多方面的原因，GDP数据的确可能存在着一些误差，而事实上，国家统计局也的确对某些年份的GDP进行了修正。
2. Rawski对于中国官方统计数据来源的质疑较为片面
对于数据来源的质疑，许宪春在《中外经济学家对中国经济增长率的评论》中指出：“中国自从1985 年开始计算国内生产总值时起，就采取国家统计局统一制定方法制度，地区与国家分级核算的方式，即国家统计局计算全国国内生产总值，省、自治区、直辖市统计局计算本地区国内生产总值。全国国内生产总值从来就不是省级国内生产总值数据的汇总。”“所以不存在国家统计局抛弃省级经济增长数据的问题”[4]
这说明了Thomas对数据来源的质疑是片面的，但从《许宪春详谈中国GDP统计数字来源》[10]我们可以看出，省级汇总的数据的确存在着一些问题，比如1995年第三次全国工业普查发现乡镇企业的工业总产值数据高报了40%[10]。
3. Thomas对于真实GDP的估计是没有依据的
Thomas认为四年累积经济增长率不会超过官方公布数据的1/ 3 ，甚至可能更低。Rawski以国内航线的民航客运周转量的增长率为依据，确定中国1998 年经济增长率的上限为2 % ，但是，2000 年国内航线的民航客运周转量的增长率为13. 2 % ，他却认为中国2000 年的经济增长率在2 % ―3 %之间，从而上限仅为3 % ，这显然是自相矛盾的[4]。
中国GDP统计数据确实存在着许多问题，但在一些地区多报的同时，也有一些地区少报了产值，因而认为中国GDP增产率被整体严重高估是没有道理的。东部沿海的省分由于以民营经济为主, 可能会低报经济增长数据以减少上缴中央税收。同时，由于这些省分市场经济发展较快, 数据统计是比较完善和可信的[3]。

7 总结
本文首先简述了Thomas G. Rawski对中国GDP数据的质疑，之后描述了其它学者对其观点的反质疑；然后，结合《南方周末》对许宪春司长的访谈，揭示了我国在GDP核算上存在的种种问题；同时，本文结合了Klein和Lardy的观点，说明了GDP并不是衡量经济现状的唯一的指标，复杂的经济形势也不是光靠几个指数就能说明的；最后，我综合上述的观点给出对Thomas观点的评述。我们只有综合各方面的信息进行全面的考虑，才能做出准确的判断。

参考文献
[1] Thomas G. Rawski: 《What’s Happening to China’s GDP Statistics?》, China Economic Review 2001.12
[2] Jonathan E. Sinton, 《Aeeuraey and Reliability of China’s EnergyStatistie》, China EconomieReview, 2001, (12)
[3] 姜辉: 《崩溃与威胁—简析近年来国际上对中国经济的若干观点》, p49-p52, 2003
[4] 许宪春(国家统计局国民经济核算司司长): 《中外经济学家对中国经济增长率的评论》,《财贸经济》, 2002 年第二期
[5] 任若恩, 《中国GDP 统计水分有多大――评两个估计中国GDP 数据研究的若干方法问题》, 《经济学季刊》, 2002 年第2 卷第1期
[6] 张新蒋殿春, 《中国经济的增长――数据的可信度以及增长的微观基础》, 《经济学季刊》, Vol 2, No. 1, Oct., 2002
[7] Klein L. R. and Ozmucur S. 《The estimation of China’s economic growth rate》, 2002
[8] Lardy , N. R. , 《China will keep on growing》, 《Asian Wall Street Journal》, June 14. 2002
[9] 《中国GDP增长统计存在水分》, home.xjtu.edu.cn/teacher/yandw/macro/reference/65.doc Mar 6. 2003
[10] 《许宪春详谈中国GDP统计数字来源》, 《南方周末》, 2002.08.01

Note of SAS coding style

2008-11-19T07:56:00.003+08:00

Guidelines for Coding of SAS® Programs
--by Thomas J. Winn Jr., Texas State Auditor’s Office, Austin, TX

SAS language is like a script but with more flexiblility and less limitation. Sometimes it is useful but as a programmer, I always confused by program writen by SAS, though sometimes the problem is not complex.

Luckily, I found a paper by Thomas, provide some idea which is practical and beautiful, Though most of them is just a basic law in normal programming. And Law is Freedom.

And the following material is just copy from the paper.

“This paper presents a set of guidelines that could be used for writing SAS code that is clear, efficient, and easy to maintain.”
you can write SAS code in a particular way does not mean that you should do so.

Name
• In naming, avoid cuteness, single-letter names, and names that too closely resemble one another.
• Names should be unique, short, and descriptive – in that order of importance.
• If longer names are needed, underscores may be used to separate words, in order to enhance readability.
• If a user-defined format applies to only one variable, then name the format with a readily-recognizable form of the variable-name plus the suffix FMT .

READABILITY & APPEARANCE
♦ Insert a blank line between SAS program steps; that is, before each DATA or PROC step.
♦ Be consistent with your indentation increments.
♦ Indent all statements in a logical grouping by the same amount.
♦ Left-justify all OPTIONS, DATA, PROC, and RUN statements. Indent all of the statements within a DATA or PROC step.
♦ Indent conditional blocks and DO groups, and do it consistently, The logic will be easier to follow.
♦ Align each END statement with its corresponding DO statement. This will make it easier to verify that they match.
♦ Remember to preface major blocks of code with explanatory comments.
♦ Consider inserting PAGE statements to force the SAS Log to begin tracing the execution of new modules on a new page.

REUSABILITY
Since most of the operations of the SAS macro facility are carried out in the background, sometimes debugging them can be fairly mysterious.
• Write code that can be re-used, with different parameters. Keyword parameters are preferable to positional parameters, because they are less likely to be specified incorrectly.
• Write the code you use repeatedly as a macro, and then, instead of repeating your code, invoke the macro.
• Avoid using global macro variables.
• If a macro is used by more than one program, put it into an AUTOCALL macro library.

EFFICIENCY
Avoid jumping to statement labels by GO TO, or LINK statements and RETURN statements,
♦ If possible, replace logic which jumps between subroutines with DO ...END and IF ... THEN ... ELSE ...-logic,
♦ End every DATA and PROC (except PROC SQL) step with a RUN statement,
♦ End every PROC SQL step with a QUIT statement.

Place most of the non-executable statements in a DATA step before all of the executable statements.
In particular, place variable attribute and other declarative statements near to the top of the DATA step, and ahead of the executable statements.

• In a DATA step, place most of the non-executable statements before the executable statements – exceptions include the DROP or KEEP statements, which may be placed after the executable statements.
• Define INPUT and PUT variables one per line, using @ pointer control.
• Screen data for unusual circumstances.

reduce the number of times the data are read:
♦ Minimize the number of passes through the data,
♦ Minimize the number of DATA steps,
♦ Read and store only the data that are needed,
♦ Sort the data only when it is absolutely necessary.

When you read in an external file, use pointer controls, informats, or column specifications in the INPUT statement, to read only those fields you actually need.
• Store only the variables you need by using DROP or KEEP statements, DROP= or KEEP= options (eliminate variables from the output data set which are needed only during DATA step execution, and not afterward).
• When only one condition can be true for a given observation, use IF ... THEN ...ELSE ... statements (or a SELECT group), instead of a series of IF ... THEN ... statements without ELSE statements (In a sequence of IF-THEN statements without the ELSE, the SAS System will check each condition for every observation).
• When using a series of IF ... THEN ... ELSE ... statements, list the conditions in descending order of probability. This will save CPU time.,
• Use the LENGTH statement to reduce the storage space for variables in SAS data sets.
• Minimize workspace usage by using the DELETE statement in a PROC DATASETS step, to eliminate temporary data sets that are no longer needed by the program.
• Use the IN operator instead of a series of multiple logical OR operators.

Code Complete PART 3

2008-11-17T22:41:00.003+08:00

Variables
chapter 10. General issues in using variables
1. Data Literacy
2. Making variable declarations easy
3. Guidelines for initializing variables
在声明变量时初始化
靠近变量第一次使用时初始化
理想情况下，靠近第一次使用的位置声明和初始化
final & const
counter & accumulator --- i, j, k, sum, total
在constructor中初始化类的数据成员
检查是否需要重新初始化
一次性初始化具名常m量--使用可执行代码
使用编译器设置
利用编译器警告
检查输入参数合法性
初始化工作内存。 0xCC & 0xDFADBEEF
4. Scope
visibility -- 可见性作用域
Localize references to variables
span -- 跨度
生存时间
General guidelines for minimizing scope
在循环开始之前再初始化循环中使用的变量
直到变量使用时才为其赋值
把相关语句放到一起
提取子程序
开始时采用最严格的可见性，之后再扩充
Comments on minimizing scope
intellectual manageablility -- 智力可管理性
5. Persistence
数据的生命期
6. Binding time
绑定时间：
编码时 -- 神秘数值
编译时 -- 具名常量
加载时 -- 外部数据源读取
对象实例化时
即时
绑定时间越早灵活性越差，但复杂度越低。
7. Relationship between data types and control structures
Jackson.
Sequential data
selective data
interative data
8. Using each variable for exactly one purpose
每个变量仅有单一用途
避免让变量有隐含意义
确保使用了所有已申明的变量

Chapter 11. The power of variable names
1. Considerations of choosing good names
完全 && 准确
problem orientation
what, not how
length: 10 - 16
限定词放在变量名的最后：
Total, sum, average, max, min, record, string, pointer...
NumXXX: a total number
XXXNum: 下标
begin/end
first/last
locked/unlocked
min/max
next/previous
old/new
opened/closed
visible/invisible
source/target
source/destination
up/down
2. Naming specific types of data
Naming loop indexes
i, j, k
XXXindex, XXXCount
to avoid index cross-talk
Naming status variables
'flag' is not good
Naming temporary variables
警惕临时变量，弄清其实际用途
Naming boolean variables
典型的boolean名：
done, error, found, success or OK.
Naming enumerated types
使用前缀
3. The power of naming conventions
why:
when:
degrees of formality:
4. Informal naming comventions
Guidelines for a language-independent conventions
区分变量名和子程序名
区分类和对象
标识全局变量
标识成员函数
标识类型申明
标识具名常量
枚举类型的元素
格式化命名
Guidelines for language-specific conventions
5. Standardized perfixes
User-defined type abbreviations
UDT: user defined type
ch, doc, pa, scr, sel, wn
Semantic perfixs
c: count
first & last
g: global var
i: index
lim: limitation -- first <> last <> lim : llim = last + 1
m: class var
max && min
p: pointer

Chapter 12: Fundamental data types
1. Numbers in genaral
avoid Magic number.
avoid mixed compare
be careful of warning
2. Integers
检查整数除法。地板除，真实除
检查整数溢出
检查中间结果溢出
3. Floating-point Numbers
避免数量级相差巨大的数之间的加减
避免等量判断
处理舍入误差问题 --使用更高的精度，使用BCD
4. Characters and strings
避免使用神秘字符及神秘字符串
Unicode
在程序生命期中尽早决定国际化/本地化策略
ISO 8859 or Unicode
采用某种一致的字符串转换策略
5. Boolean variables
用布尔变量来简化复杂的判断
需要的话创建自己的布尔类型
---typedef int BOOLEAN;
6. Enumerated Types
提高可读性，可靠性，可修改性。作为布尔变量的修改方案。
7. Named constants
single-point control
在数据申明中使用具名常量
避免使用文字量
用具有适当作用域的变量或类来模拟具名常量
统一地使用
8. Arrays
考虑用容器来代替数组，或将数组当作顺序化的容器来处理
检查数组的边界点
提防下标串话
9. Creating your own types

千与千寻

2008-11-17T16:12:00.012+08:00

这个周末窝宿舍看了6部电影：辛德勒的名单，战争之王，千与千寻，马克思佩恩，我是传奇和风云诀。辛德勒的名单和千与千寻原先就看过，不过都是很多年前了；战争之王也是部优秀的电影；其它三部就很soso了。很久很久没这么看电影了，有时是因为没时间，有时是因为没心境。

一些优秀的东西不管在哪个时代，那个年龄段的人看来都是优秀的。人性、关爱和对心灵的探求让人在并不温暖的初冬感到丝丝暖意。

人在成长的过程中必然会丢失一些东西，有些时候甚至很难说这种成长值不值得，长大了，就很难再听见心灵里的某种声音了，那是种至真至诚的感动，明静而通澈。

不得已，人长大了总要负担些什么了，可以说是上进，可以说是责任感，也可以说是欲望。又有什么差别呢。不过有时候是要静下来听听自己心灵的声音，不要被自己彻底地蒙蔽。就像乔布斯说的，把每天当成最后一天来过，这样，自然会听从心底最本真的声音。

上外的猫

2008-11-16T22:30:00.004+08:00

阴错阳差到了上外，一个比上财还小的学校。不过有趣的是发现了黑猫白猫和它们的仔儿。女生多的学校就是猫多，而且都有两个特点——肥，胆大。

人走过去，它不动；有吃的，立马哈过来；没吃的，扭过头不看你；你吓它吧，有时象征性地跑两步，有时干脆就不跑。简单的说，就是嚣张、厚颜无耻，彻底丧失了作为一只猫的优良传统。
#ReadMore#

The Zen of python

2008-11-15T11:43:00.002+08:00

PEP is short for Python Enhancement Proposals, and PEP0 is the index of these files.
http://www.python.org/dev/peps/pep-0000/

The Zen of python -- May be simple, but practical. It is in PEP20.

    Beautiful is better than ugly.
    Explicit is better than implicit.
    Simple is better than complex.
    Complex is better than complicated.
    Flat is better than nested.
    Sparse is better than dense.
    Readability counts.
    Special cases aren't special enough to break the rules.
    Although practicality beats purity.
    Errors should never pass silently.
    Unless explicitly silenced.
    In the face of ambiguity, refuse the temptation to guess.
    There should be one-- and preferably only one --obvious way to do it.
    Although that way may not be obvious at first unless you're Dutch.
    Now is better than never.
    Although never is often better than *right* now.
    If the implementation is hard to explain, it's a bad idea.
    If the implementation is easy to explain, it may be a good idea.
    Namespaces are one honking great idea -- let's do more of those!

And I think Simple is beautiful.

I like python, for its liquid, simple and prowerful.

Debian note, installation

2008-11-15T11:40:00.003+08:00

Today, I installed debian in my virtual machine. To learn more about development in Linux environment. And from now on, I will try my best to write blog in English, it is a good practice for my write skill. :)

First, download a ISO file form http://www.debian.com/;
the path of the ISO file is http://cdimage.debian.org/debian-cd/4.0_r5/i386/iso-cd/debian-40r4a-etchnhalf-i386-netinst.iso, It is a image for net installation.

Finished installation, edit /etc/apt/sources.list, add an update source in the following form:
deb http://host/debian distribution section1 section2 section3 deb-src http://host/debian distribution section1 section2 section3
for example:
deb http://http.us.debian.org/debian stable main contrib non-free

I select a mirror in Taiwan to do the installation. Use the command like: apt-get install package.

Install R language. It is a free statistical programming language.
apt-get install r-base

Install mySQL:
#apt-get install mysql-server mysql-client libmysqlclient15-dev

And Vim should also be reinstalled to get full version.

一年中最好的时节

2008-11-14T21:11:00.003+08:00

冬至，凉爽而清澈的天气，阳光艳丽慵懒。一年中最好的时节。
从一点睡到八点，阳光正照到我的床上，醒来，穿衣，刷牙。咖啡加蜂蜜面包，懒洋洋地开机，下载。
编程。所有东西都有它内在的优美，特别是当它无序的时候。从无序到有序，从混杂到简洁。然后Simple && beautiful。
自然，自在，自由。一些东西就由着它生长吧。

数据挖掘——技术 or 艺术？

2008-11-08T18:34:00.002+08:00

今天在MYDB2.CN上发现了IBM讲师张英做的slide，《数据挖掘——技术 or 艺术？》。觉得最好的隐喻相当地恰当，copy如下：

1 取景（寻找业务问题－寻找业务增长空间）
2 构建画面的背景（定义业务问题）
4 根据天气和光线的情况调整曝光程度等（调整建模方法和参数）
5 冲洗选择一张最佳的照片（选择一个最佳的模型）
6 后期美化处理（业务含义解释和建议）
7 装裱起来，挂在该挂的位置例如床边，书桌或者客厅什么的（模型部署，用于改善实际的业务）

会找：发现问题，以及解决问题的数据挖掘方法
会用：处理数据，操作软件
会说：对挖掘结果给出解释分析
会试：需要不断的调优，改进挖掘效果

希望能成为一个信息管理和商务智能方面的专家，愿意为之付出持续而谦卑地努力，因为professional && free往往是相互依存的。

Rubik's Cube

2008-11-02T21:34:00.002+08:00

Rubik's Cube也就是魔方，昨天晚上在地摊上买了一个，魔方不是一个好的玩具，特别是对于我这样的笨小孩来说，很能打击自尊心。现在长这么大了再次上手魔方，看看是不是长大聪明了还是继续印证“痴长白大”这句家乡的古话。

在地铁上玩了一把小时，还是没个头绪，我也意识到了中心块、棱块和角块的特殊，可还是没发现什么。我知道我笨，只是一次又一次地验证这个事实还是蛮让人沮丧的。

今天google了一下，发现了下面的入门教程http://www.rubik.com.cn/beginner.htm，另外百度百科上也有魔方的详细介绍：http://baike.baidu.com/view/35837.html?wtp=tt。真不知道，原来魔方还有这么多的故事。解魔方也有系统的方法，就是一些特定的步骤和所谓的魔方算法，一路看下来，即使是最简单的7步法也有一些东西要记，虽然跟着教程很快就完成了魔方的复原，可要我自己重新操作也是搞不来的。人老了的最大的缺点就是懒的思考。

rubik.com.cn的站长还分享苹果CEO Steve Jobs在斯坦福的演讲：“听从自己心灵的指示；把每天当做最后一天”。这样的人无疑是快乐的，而且是强大的。

RA3

2008-11-02T11:50:00.003+08:00

终于出了RA3了，从RA2到现在，十多年了吧，可惜的是红警依旧，西屋不再，让人不得不感叹沧海桑田，世事难料。。^_^红警是个蛮好的发泄游戏，没什么技巧，不用动脑，只要疯狂造兵，一下扔过去就是了。
RA3里面原来的特色兵种大都还在，只是好像少了火箭飞行兵和尤里。不过多出来个日本，邪门得很。上午下有些，然后玩了下战略，下午拿美俄日一个个和日本打了下，玩得腻了，删！
红警兵种都加了技能，这么着有点不像红警了，模仿的结局就是沦落。

10.30

2008-10-30T21:44:00.002+08:00

开学一个半月，看着时间花花地流过，而且越流越快，可面前还有很多问题没有解决，也许到了重新评估一下的时候了。

主要的问题还是课业太重，自己的基础比较差，而且又花了很多时间在非课程的东西上，导致一时跟不上进度。想想课前预习课后复习才是效率最高的办法，以后多多注意。光统计就已经是科目繁杂，再加上对应的经济金融知识，以及数据管理、分析工具的掌握，这些对我这一年多学习时间来说，根本没有完成的希望。

还是思想和工具的问题，没有思想，再多的工具也没有用；可决定思想的往往就是工具。就像思想和语言的关系，思想往往被语言所限制，如果一个思想不能表达，它就不能称之为一个思想。现在我也是面临着这样的困境，金融经济分析是商务决策的工具；数据挖掘是经济分析的工具；而SAS等基础软件则是统计的工具。但现在，这些不同层面上的思想和工具在我面前都是脱节的，这是我现在面临的最大的困惑。记得在GSMC实习的时候，Lin曾经和我说，要做数据挖掘至少要5年的从业经验，现在看来，五年的学习曲线并不是很夸张，如果把业务方面的东西也加上去的话。

专注与学业及SAS和IBM的相应解决方案。如果可以的话，再加强些英语吧～～

Code Complete PART2

2008-10-23T22:07:00.003+08:00

PART2: 创建高质量的代码
chapter 5: Design in Construction 软件构建中的设计
1. Design Challenges
Design --> wicked: 只有通过解决或部分解决才能明确的问题现实<-->理论
Sloppy process --> tide result
方法论；优劣的差异；good enough?
Tradeoffs & priorities
Restrictions
Nondeterministic
Heuristic process
Emergent 自然而然
2. Key Design Concepts
Primary Technical Imperative: Managing Complexity
Accidental and Essential difficulties
失控的复杂度 --> 失败 --尽量减少在任一时间需要考虑的程序量
Desirable characteristics of a design
Minimal complexity --避免“聪明”
Ease of maintenance --self-explanatory
loose coupling
extensibility
reusablity
high fan-in --good use of utility classes
low fan-out --7
portability
leanness --完成->不能删除任何东西：伏尔泰
stratification
standard techniques
Level of design
System --> subsystem 子系统：业务规则、GUI、DB、对象依赖性
--> classed --> routines --> internal routine
3. Design Buildng Blocks: Heuristics
find real-world objects
辨识对象及属性 --> 确定自身操作 --> 对其他对象的操作 --> 可见性 --> 公开接口
Form consistent abstractions
抽象是一种让你关注某一概念的时候可以同时放心地忽视其中一些细节的能力--在不同的层次处理不同的细节。
Encapsulate Implementation details
房屋建造
Inherit -- when inheritance simplifies the design
Hide secrets (Information Hiding)
封装，模块化冰山
隐藏复杂度、隐藏变化源
障碍：信息分散循环依赖类内数据->全局数据性能损耗
价值：修改设计
Identify areas likely to change
寻找分离预防
易变化的区域：业务规则输入输出非标准语言特性困难的设计和构建状态变量
anticipating different degrees of change
让变化的影响范围和发生变化的可能性成反比
有用的最小子集 --> 扩充
keep coupling loose
criteria: 规模（连接数）可见性灵活性
kinds of coupling:
simple data parameter coupling
simple object coupling
object-parameter coupling
syntictic coupling: 控制标志假设。。。
Look for common design patterns
现成抽象 --> 减少复杂度
细节制度化 --> 减少出错
多种方案 --> 启发
高层次 --> 简化交流
4. Design Practices
Iterate Divide and conquer Top-down and botton-up design approaches
top-down: 易上手，但易受底层复杂度影响
botton-up: 复杂，但可早期鉴别出系统的复杂度，设计出更好的高层类
experimental prototyping collaborative design How much design is enough
最大的设计失误在于自我认为做的很充分，事后却发现做得不够。
最大的悲哀莫过于大厦快要完工时地基出了问题。 ——罗素
Capturing your work
doc in source, wiki, mail, DC, picture, CRC(类、职责、合作者), UML
5. Comments on popular methodologies
Big design up front --> little design up front or enough design up front
Design in General
Couceptul Blockbusting: A Guide to Better Ideas
How to Solve it: A New Aspect of Mathematical Method
How to Solve it: Modern Heuristics

chapter 6: Working Classes 可以工作的类
1. Class Foundations: Abstract Data Types(ADTs)
Benefits: 隐藏实现细节支持改动接口提供更多信息易提高性能正确性验证自说明性数据传递实体操作
ADT + 继承、多态 --> 类
2. Good Class Interfaces
Good Abstraction
抽象是一种以简化的形式看待复杂操作的能力混杂-->一致
类接口应展现一致的抽象层次
理解类所实现的抽象精确！
提供成对的服务
转移不相关信息 --> 模块内聚
让接口可编程，而不是表达定义
谨防破坏接口的抽象
抽象性 and 内聚性
Good Encapsulation
限制类和成员的可访问性（accessibility）
不公开暴露成员数据
避免把私有的实现细节放入类的接口
不要对类的使用者做出任何假设
避免使用友元类（friend class）
让阅读代码比编写代码更方便
警惕在语义上破坏封装性：针对接口编程 --> 透过接口针对内部实现编程×
3. Design and Implementation Issues
Containment("has a" relationships)
使用包含万不得已使用private继承警惕超过七个数据成员的类
Inheritance("is a" relationships)
更精简的代码
成员函数：对派生类可见？有默认实现？能被覆盖？
数据成员：对派生类可见？
要么对继承做详细的说明，要么不使用继承
Liskov替换原则：派生类必须能通过基类的接口被使用，且使用者无需了解两者之间的差异
确保只继承需要继承的部分
注意：继承接口 --> 继承实现继承实现 --> 继承接口
只想要实现继承？包含！
不要“覆盖”（语法角度）一个不可覆盖（语义角度）的成员函数！
把共用的接口反正继承树尽可能高的地方
只有一个实例：新的对象？新的类？
只有一个派生类：提前设计？
覆盖但没做任何操作：怀疑！
类型检查？多态！
让所有数据都是private
对继承持有歧视的态度！
Member functions and data
子程序的数量类调用子程序的数量对其它类的子程序的间接调用：尽可能少！
尽量减少类与类间相互合作的范围。
Constructors
尽可能在构造函数中初始化所以数据成员
private constructors --> singleton property
deep copies >> shallow copies
4. Reasons to Create a Class
建模降低复杂度隔离复杂度隐藏实现细节限制变动的影响范围隐藏全局数据让参数传递更通畅建立中心控制点易于重用为程序族做计划包装相关操作实现特定重构
Classes to avoid
god class; 无关紧要的类; 用动词命名的类

chapter 7: High-quality Routines 高质量的子程序
small intimate viaible flexible
1. Valid reasons to create a routines
降低复杂度引入中间、易懂的抽象避免代码重复支持子类化隐藏顺序隐藏指针操作提高可移植性简化逻辑判断改善性能
创建类的理由也是创建子程序的理由。
2. Design at the Routine Level
functional cohesion: 只执行一项操作
sequential cohesion: 步骤共享数据完成完整功能
communicational cohesion: 同样的数据，无其它联系
temporal cohesion: 需要同时执行
procedural cohesion: 子程序的操作按特定顺序
logical cohesion: 控制或“逻辑”是子程序组织的原因
coincidental cohesion
3. Good Routine Names
描述子程序所做的所有事情
避免使用无意义、含糊、表意不明的动词
不使用数字形成不同的子程序名
函数命名时对返回值有所描述
过程命名时使用语气强烈的动宾形式
准确使用对账词
为常用操作确定命名规则
4. How long can a routine be
适中最好一屏打印1到2页
5. How to use routine parameters
按输入-修改-输出组织
一致的排列顺序
使用所有的参数
状态或出错变量放最后
不要把子程序的参数用于工作变量
在接口中对参数的假设做出说明：I or M or O? unit? scope?
个数限制在大约7个以内
IN Modify OUT的命名规则
子程序的接口要达到何种抽象？
6. Special considerations in the use of functions
函数 vs 过程
如果一个子程序的用途是返回由其名字所指明的返回值，那么就应该使用函数，否则使用过程
检查所有可能的返回路径
不要返回指向局部数据的指针
7. Macro routines and Inline routines
把宏表达式整个包含在括号内
把含有多条语句的宏用{}包围
节制使用inline: 暴露细节

chapter 8: Defensive Programming 防御式编程
1. Protecting your program from invalid inputs
garbage in, garbage out
in: 检查源于外部的数据检查数据输入决定如何处理错误的输入数据
2. Assertions
开发时使用的让程序在运行时进行自检的代码
assert a != 0 : "a is unexpectedly equal to 0"
IN and OUT, state, value of variable, pointer check, container
Guidelines for using assertions
错误处理代码：预期会发生断言：绝对不应该发生
避免把需要执行的代码放在断言中
用断言来验证前条件（运行前确保为真）和后条件（运行后确保为真）
先使用断言后使用错误处理代码
3. Error-Handling Techniques
返回中立值下一个正确的数据与前次相同的数据最接近的合法值 log error-code
Robustness vs. correctness
correctness: 永远不返回不准确的结果
robustness: 尝试采用。。继续运转
4. Exceptions
通知机制
只有在真正例外的情况下才抛出异常：由于调用子程序的代码需要了解被调用代码可能发生的异常，因而弱化的封装
不能用异常来推卸责任
避免在构造和析构函数中使用异常，除非在同一地方捕获
在恰当的层次抛出异常：抛出的异常也是程序接口的一部分
在异常消息中加入导致异常发生的全部信息
避免使用空的catch语句
集中的异常报告机制异常使用标准化考虑异常的替代方案
5. Barricade your program to cotain the damage coused by errors
让软件的一部分处理“不干净”的数据，另一部分处理“干净”的数据，大部分代码就无需承担错误检查的任务
outside error-handling | assertions inside
6. Debugging Aids
Use offensive programming
对待异常：开发时--显现，运行时--自我修复

chapter 9: the Pseudocode Programming Process (PPP) 伪代码编写过程
1. Summary of steps in building classes and routines
steps in creating a class
类的总体设计类中的子程序复审并测试整个类
steps in building a routine
设计检查编写检查
2. Pseduocode for Pros
类似英语，精确描述
避免使用目标语言的语法元素
在意图的层次编写伪代码
在足够低的层次上写伪码
3. Constructing routines by Using the PPP
Design the Routine
检查先决条件
定义问题：要隐藏的信息，输入输出，前条件后条件
子程序命名
决定如何测试
在标准库中寻找可用的功能
考虑错误处理
考虑效率问题
研究算法和数据结构
编写伪代码：头部注释+目的
考虑数据
检查伪码
Code the routine
写出子程序的声明
将伪码转为高层次的注释
在注释下填充代码
检查代码：重构？递归应用routine编写方法
收尾
check the code
脑海中检查：
桌面检查（desk checking）
同行评审（peer review）
走查（walk-through）
详查（inspection）
编译子程序
hacking and compiling 拼凑加检查×
将编译器的警告级别调到最高
使用验证工具(validators)，C: lint
消除错误消息和警告的所有根源
在调试器中逐行执行代码测试代码: 测试用例消除程序中的错误
clean up leftovers
检查接口检查整体设计质量检查变量检查语句和逻辑检查布局文档及注释
4. Alternatives to the PPP
Test-first development
refactoring
design by contract
hacking×

卑微地努力

2008-10-22T23:03:00.005+08:00

人类的行为取决与自身的知识，因为你无法知道自己将来知道什么，所以无法知道自己将来会做什么。

人类所做的新的发现不过是自己刚刚塞进去的东西而已。

今天上金融博弈的时候老师又开始讲起了哲学，我蛮喜欢那个不修边幅的老头的，“老年版的哈利波特”，宁同学是这么称呼的。数学、哲学、宗教，其实都是人类思维构造的体系，本质上有着想通之处，其实软件有何尝不是如此，“纯脑力的构建活动”—— Code Complete中是这么说的。简洁和优美，可能是所有科学都追求的一样东西。不过在实践的角度看，quick & clear往往是要着很深功力的，刚开始的时候也许quick & dirty比clean & slow要更好些，在尝试的过程中再慢慢向着quick & clean进步。

下午上财务报表的时候上课的老师也给了我很多感触，他原来师范毕业后在大学教书，过了几年考了硕士，出来在银行做了几年，又去读了博，现在在上财教书。从他的经历看来并算不上一个牛人，但他走的路可以说是一个普通人的成功之路。比如天天记日记，年年做总结，整理简历……心怀希望，能够坚持的人相信都是能成功的。

上海博物院

2008-10-22T10:54:00.004+08:00

第一次去上海博物院是初中，之后是高中毕业那会，接着就再没去过了。今天正好去火车站配眼镜，在等磨镜片的那会功夫就顺便去博物院转了圈。

据说全国能称上博物院的只有三家：故宫博物院，上海博物院和南京博物院。“馆”和“院”虽然只是一字之差，可也体现了些身价的不同吧。上博院的藏品还是蛮丰富的，只是展厅里展出的只是其中的一部分，而且有些展厅也是时开时关，所以要看一些一些精品还是要有一定缘分的。但据说现在书画馆的画都已不是真迹的了，而是现代科技的复制品。##ReadMore##

这次在书画馆多呆了一些时间，有好些书画是很有名的，以前只是在画册中见过，现在一睹真容还是很有些感动的。只是也有些遗憾，看到宋元明清画作之精美高雅逸趣。想到现在社会上所谓名家的一些画，一些字，真不知该说是创新还是倒退。在陶瓷馆也呆了很久，康乾盛世的一些作品做工之精美真可以说是绝伦，经历了数百年的岁月依然灿然如新。

本来还拍了一些照，只是发现J10不愧是很低端很傻瓜的相机，变形严重而且高ISO下噪点严重。不过用picasa调下暗部加简单的模糊后效果还可以接受。

武东校区

2008-10-16T21:05:00.006+08:00

上财的所谓武东路校区原来是，现在还是同济的校园。住着不多的学生，有一些陈旧荒芜的气息。
##ReadMore##

敬畏耶和华是智慧的开端

2008-10-15T22:47:00.004+08:00

一天无事。
上午看Code Complete，有感时间的匮乏，用Google Calender排了下这学期的日程。现在又是一个人了，该慢慢习惯泡图书馆的日子吧，可能这就是我的Style，刻意追求着简单，简单得什么都不要。
研究生就这两年，在明年找工那会仅仅一年时间，要是从明年五月报暑期实习的时间来算，时间更少。Less is more。尽量集中精力吧。
下午上财务报表分析，书上看到了财务预警分析的简介。多元逻辑分析、神经网络和概率预测在财务预警分析上都有可用的模型，但却都存在着这样那样的问题。我进一步坚信统计、计算机相结合在商务智能上必将有开阔的应用前景。
晚上上的是金融博弈，也是选修的第一节，老师一看就是理科出身。学工学理学文对一个人的气质真的影响很大，如果潜心学过的话。
课程的引言就是“敬畏耶和华是智慧的开端”。
我并不是宗教的信徒，但也不是无神论者。冥冥之中自有定数。我一直相信，如果有上帝的话，他创造的该不是物的世界，而是公理和规律；而且，他可能是程序员。
前几天在Code Complete上看到了下面的一些话，发觉虽在不同的领域，真正优秀的思想其实是相通的：
你思考的能力取决于你是否知道能够表达该思想的能力
《The Humble Programmer》：大部分编程工作都是在弥补我们有限的智力。承认自己智力有限并通过学习来弥补。
谦卑的人那，努力吧。

Learning python 读书笔记 PART 6

2008-10-15T00:24:00.002+08:00

PART 6: Classes and OOP
Chapter 19. OOP: The Big Picture
classes: instance factories, data + function
Instances: represent the concrete items in a program's domain
attributes searching at runtime, lower level to higher level
Coding Class Trees
Class C1(C2, C3): multiple inheritance
Attributes --> class : assignments made within class statements
Attributes --> instances : assignments to self inside class statements
>>> class C1:
    def setname(self, who):
        self.name = who
>>> I1 = C1()
>>> I1.setname('xyz')
>>> print I1.name
xyz
initialization: def __init()

Chapter 20. Class Coding Basic
Class: namespace, generating multiple objects, namespace inheritance, operator overloading
Module: namespace
Classes VS. Instances
Class objects probide default behavior:
attributes functions --> class <-- a class name
Instance Objects are concrete items:
call a class object like a function makes a new instance object
each instance object inherits class attributes and gets its own namespace
a new attribute can be generated on the instance
Classes are customized by Inheritance
classes and modules:
from module1 import Class1
class Class2(Class1): ...
Classes can intercept Python Operators
def __init__(self, value): ...
def __add__(self, other):
    return ...
def __mul__(self. other):
    self.data = ...

Chapter 21. Class Coding Details
The Class Statement
class <name>(superclass,...):
    data = value
    def method(self, ...):
        ....
Methods
instance.method(args...) == class.method(instance, args ...)
Calling superclass constructors:
class Sub(Super):
    def __init__(self, x):
        Super.__init__(self, x)
        ......
Inheritance
Abstract superclasses:
class Super:
    def method(self): ...
    def delegate(self):
        self.action()
    def action(self):
        assert 0, 'action must be defined!'
Operator Overloading
__init__: Constructor
__del__: destructor
__add__, __radd__, __iadd__: +, right-side + , +=
__or__: |
__repr__,__str__ : printing
__call__ : X()
__getattr__ : X.a
__setattr__ : X.a = value
__getitem__ : X[key], for loops, in tests
__setitem__ : X[key] = vlaue
__len__
__cmp__, __lt__, __eq__
__iter__
user-defined iterators
def __init__(self, start, stop):
def __iter__(self)
    return self
def next(self)
    ....
__getattr__ and __setattr__ catch attribute references
__getattr__: is not called if Python can find the attribute, used to deal with undefined attributes
__setattr__: if defined, self.attr = value --> self.__setattr__('attr', value)
    self.__dict__['name'] = x
__repr__ VS. __str__
>>>x : run __repr__
>>>print x : run __str__
add:
>>>x + 1 #__add__
>>>1 + y #__radd__
__call__: x(attr)
__del__: run automatically when an instance's space is being reclaimed
Namespaces: The Whole Story
instance -- __class__ --> class
class -- __base__ --> higher superclasses

Chapter 22. Designing with Classed
Python and OOP
inheritance polymorphism encapsulation
Overloading by Call Signatures
*class C:
   def meth(self, x): ...    #a
   def meth(self, x, y):... #b
a will overwrited
*class C:
     def meth(self, *args):
          if len(args) == 1: ...
*class C:
     def meth(self, x):
          x.operation()
Classed as Records
OOP and Inheritance: "is-a" relationship
OOP and Composition: "has-a" relationship
OOP and Delegation
Multiple Inheritance
search process depth-first all the way to the top
Classes are objects: Generic Object Factories
apply function:
def factory(aClass, *args)
    return apply(aClass, args)
Methods are objects: Bound or Unbound
Unbound: class, no self
object1 = Spam()
t = Spam.doit
t(object1, 'lalal')
bound: instance, self + function pairs
object1 = Spam()
x = object1.doit
x('lalal')
Documentation String Revisited
import docstr
a.__doc__, a.b.__doc__
Class Versus Modules
they are both namespacefiles
Modules:
Are data/logic packages
Are created by writing Python or C extensions
Are used by imported
Classes:
Implement new objects
Are created by class statements
Are used by being called
Always live within a module

烤

2008-10-12T20:09:00.003+08:00

从9月16号开学，到现在已经差不多一个月了，终于逮着机会，浩浩荡荡50人聚一起吃烧烤啦～～
记下帐先：
费用：
烤炉：40元/次小凳子：2元/把铁网：5元/块夹子：5元一把木材：5元/打门票：15元×八折结论：黑，相当地黑。
原料：（摘自。。。。忘了。。）
餐具及辅助用品：一次性桌布（厚）、一次性筷子和碟子、纸杯、餐巾纸、竹签、毛刷、废报纸h、小刀及叉子
烧烤主食类：鸡翅骨肉相连肉串馒头蘑菇年糕玉米肠贡丸土豆菜椒
其他：蜂蜜、香辣粉、辣椒面、番茄酱、盐
饮料：可乐、果汁、纯水
食物是昨天晚上去十人去沃尔玛买的，花了一千多，然后再加门票五百多，再加上烧烤用具的租金，七七八八倒也勉强够用。
然后。。。很郁闷，在搬木头的时候我踩到了钉子，而且扎得很深，回来的时候又在公园迷了路。折腾着五点总算到了学校，医务室又没破伤风针打，537路坐到了长海医院，大个破伤风针三块五，七七八八硬是整到了70多，然后又打车回了学校，霉。
http://picasaweb.google.com/shufe08/081012#

J10

2008-10-11T23:04:00.007+08:00

今天在京东的库存品展销会上买了富士的J10，入门得不能再入门的相机，早日换单反，努力！！！##ReadMore##

Learning python 读书笔记 PART 5

2008-10-09T11:15:00.001+08:00

PART 5: MODULES
Chapter 15. Modules: The Big Picture
a.code reuse b.System namespace partitioning c.Implementing shared services or data
Python Program Architecture
import and from statements execute and load another file at runtime
How Imports Work
Find it --> Compile it(Maybe) --> Run it
Find it
The module search path:
a. home directory of the top-level file
b. PYTHONPATH directories (if set)
c. Standard library directories
d. The contents of any .pth files (if present)
current working directory
sys.path: the actual search path, is configured by Python at program startup
Compile it
.py & .pyc
Run it
import operation executes the byte code of the module
def: run at import time to create functions

Chapter 16. Module Coding Basics
Module Creation
module --import--> variables (name)
they should follow the normal variable name rules
<directory>m.<extension>
import a --> a.b
from a import b --> b
from a import * --> b
imports happen only once
Later imoort operations simply fetch an already loaded module object.
def, import, from are executable statements
import and from are assignments!
from small import x,y
x = 42 #change my x only
import small
small.x = 42 #change x in other module
equivalence from module import name
is euqal to
import module
name = module.name
del module
Module Namespace
attributes --namespace--> module ojbect
Module statements run on the first imoort: create an empty module object and execute the statements inside the module
Top-level assignments create module attributes
Module namespace: attribute__dict__, or dir(M) --> a directory object
Attribute Name Qualification
Import Versus Scope: function <--> module
Namespace Nesting
Reloading Modules
reload currently only works on modules written in Python; C extension modules cannot.
Reload Basics:
Reloads impact all clients that use import to fetch modules
Reloads impact future from clients only

Chapter 17. Module Package
Package import Basics
import dir1.dir2.mod --> dir0/dir1/dir2/mod
__init__.py
package initialization: run automatically
module namespace initialization
from* statement behavior
from Versus import with packages
import dir1.dir2.mod as mod #short name
from dir1.dir2 import mod

Chapter 18. Advanced Module Topics
_X: prevent being copied out in from* statement, but still not import statement
__all__: from* will only copy out those names listed in the __all__ list
can be used in __init__.py
__all__ = ["b","c"]
from __future__ import featurename
__name__ and __main__
run at top level: __name__ <-- "__main__"
if __name__ == '__main__'
tester()
from module import longname as name
Module Design Concept
you're always in a module in python
Minimize module coupling: global variables
Maximize module cohesion: unified purpose
Module should raraly change other module's variables

Code Complete PART 1: Laying the Foundation

2008-10-09T07:47:00.002+08:00

Chapter 1. Welcome to Software Construction
What is Software Construction Activity:
problem definition
requirements development
construction planning
software architecture (high-level design)
detail design
coding and debugging
unit test
integration testing
integration
system testing
corrective maintenance
chapter 2. Metaphors for a Richer Understanding of Software Development
Metaphors: analogy --> modeling
Metaphors: heurstic, subject to chance Algorithm: predictable, deterministic, not subject to chance
common software Metaphors
Writing code: trial and error
Growing a System: incremental, iterative, adaptive, evolutionary
Building Software:
problem definition --> architectural design --> construction --> optimization (review and inspections)

Chapter 3. Measure Twice, Cut Once: Upstream Prerequisites
根本目标：降低风险
流程 --> 质量
Importance of Prerequisites
Causes of Incomplete Preparation:
Non't konw How --> 如果不能做好，做再多也没用！
尽快开始编码：WIMP(why isn't Sam Coding?)
Determine the Kind of Software You're Working On
商业系统使命攸关性命攸关
Inerative Approbches --> 修正成本地，发现缺陷的时间更接近引入缺陷的时间
Choosing Between Interative and Sequential Approaches:
需求稳定性设计是否透彻熟悉性项目风险长期可预测性后期改变需求、设计和编码的代价
Problem-Definition Prerequisite
product vision -- vision statement -- mission statement -- product difenition == problem definition
应用客户的语言书写
Requirements Prerequistite
scope --> 降低更变
The Myth of Stable Requirements
Handing Requirements Changes During Construction: 评估，通报，建立程序，开发方法
Architecture Prerequistite
system architecture -- high-level design -- top-level design --> architecture specification
Typical architecutral components：
program organization: 维护设计的缘由 <--> 维护设计本身
major classes: rules and relationship
data design: files & database
business rules
user interface design: 模块化，便于更换
resource management: 数据库连接、线程、句柄、内存
security: threat model
performance: 资源的使用，速度、内存、成本的优先顺序
scalability: 增长以满足未来需求的能力
internationalization / Localization (I18N, L10N)
Input/output: reading scheme (look-ahead or look-behind or just-in-time)
Error processing: a coding-convention level problem
纠正 or 检测？主动 or 被动? 错误传播消息处理异常处理处理错误的层次输入数据有效性
Fault tolerance: 检测恢复包容
容错策略：退回 try again；辅助代码，主代码错误时使用；表决算法，分别计算-比较；使用虚假值（phony value）
architectural feasibility
overengineering
buy-vs.-build decisions
resuse decisions
change strategy
general architectural quality: 维护概念完整性
Amount of Time to Spend on Upstream Prerequisites
工作量：10% ～ 20%
时间：20% ~ 30%

Chapter 4: Key Construction Decisions
Choice of programming language
C: 1
Fortran 95: 2
C++, Java: 2.5
VB: 4.5
Perl, Python, Smalltalk: 6
语言的表达能力--思考的能力：你思考的能力取决于你是否知道能够表达该思想的能力
Language descriptions
Cobol: COmmon Business-Oriented Language
Fortran: FORmula TRANslation
Perl: Practical Extraction and Report Language
PHP: PHP:Hypertext Processor
BASIC: Beginner's All-purpose Symbolic Instruction Code
Programming in a language (如果语言工具是初级的，那么程序员的思想也是初级的)
programming into a language （思想 --> 决定如何使用工具）

Code Complete 读书笔记 PART 7

2008-10-07T14:11:00.002+08:00

Software Craftsmanship 软件工艺
Chapter 31. 布局与风格
Layout and Style
准确、一致、易读性、易维护性
Layout Fundamentals
好的布局凸显程序的逻辑结构。
人 != 计算机
经验和规矩是吻合的
Layout as Religion
Objectives of Good Layout
准确，始终如一地表现程序的逻辑结构；改善可读性；经得起修改
Layout Techniques
分组：空行，空格
空行：将不相关的语句隔开 8% ～ 16%
缩进：2 ～ 4 空格，显示逻辑
Layout Sytles
纯块结构：Basic
仿纯块结构：java
begin-end {}
行尾布局
Laying Out Control Structures
begin-end: 未缩进；两次缩进 ×
在程序中加入空行，有助于思考语句的从属
缩进策略应统一
goto：标号大写、上下空行；包含goto的语句单独为一行
Laying Out Individual Statements
空格：逻辑、数组引用、子程序参数
续行：续行需明显（“+ , && ||”）；所有后续行按标准量缩进；
Using only one statement Per Line
易调试，易修改，能提供关于复杂度的正确印象，线性阅读
数据声明：一行一声明，靠近首次使用的位置，合理组织顺序
注释：缩进一致，注释前加空行
有约定比约定某个特定细节更重要
Laying Out Routines
用空格分隔程序各部分
参数按标准缩进
Laying Out Class
Class Interfaces: 头部注释(类及完整用法) 构造析构 public protected private
Class Implementations: 类文件内容类数据 public protected private
子程序间：2～3行

Chapter 32. 自说明代码
Self-Documenting Code
好的注释才有价值
源码包含大部分关键信息，信息融入代码
好的代码本身是最好的说明
注释应用来说明代码无法说明的东西
注释应易维护
External Documentation
单元开发文件夹：UDF: uint-development folder SDF: software-development folder
详细设计文档
Programming Styla as Documentation
良好结构、直率易懂的方法、有意义的名称、具名常量、清晰的布局、最低复杂度的控制流和数据结构
循环 -- 良好定义的子程序
尽可能采用问题领域的术语
To Comment or not to Comment
好注释 != （重复代码 or 解释代码）
注释困难 --> 代码差劲 or 没有彻底理解
代码复杂：改进代码 > 添加注释
Kinds of comments
repeat of code ×
explanation of code ×
marker in the code (fix before release?)
summary of code: good for other readers
description of the code's intent: 意图而非解决方法
information that cannot possibly be expressed by the code itself
Commenting Efficiently
采用不会被打断和易于修改的注释方法
用伪码编程法减少注释时间
1 comment per 10 lines
Commenting Techniques
行尾注释：代码块，数据声明
数据声明：数据单位、允许范围、编码含义、输入数据限制、位标志

Chapter 33. 个人性格
Personal Character
谦虚，求知欲，诚实，创造性，纪律，高明的偷懒
好性格 -->正确的习惯
软件开发：建造材料=个人才智；工具=自己，其实在研究人的智力、性格
20/80，10:1
Intelligence and Humility
理解一个程序，需要很强的吸取细节的能力并能同时消化
《The Humble Programmer》：大部分编程工作都是在弥补我们有限的智力。承认自己智力有限并通过学习来弥补。
减轻脑力负担：
系统分解，复查、详查、测试，程序尽量短小，尽量高层，规范
Curiosity
在开发过程中建立自我意识！
试验！学会制造错误-->收获；利用小程序
阅读解决问题的方法
在行动之前做分析和计划：分析<-->行动
学习成功项目的开发经验：Programming Pearls, The Mythical Man-Month
阅读文档，RTFM！^_^
向专业开发看齐：
入门级：某语言的基本功能，运用语言特性
中级：多中语言基本功能，熟练使用一种语言
熟练级：对语言和环境有专业技能
技术带头人级：人
Intellectual Honesty
了解代码，了解进度，如实反馈
Communication and Cooperation
代码可读性，编程首先是和人交流，其次才是计算机
Creativity and Discipline
在非关键之处设立规范，从而在更重要的地方发挥创造性
Form is liberating.
Laziness
拖延：逃避思考，实在懒
迅速完成：用最少时间做完不喜欢的工作。开明懒
编写某个工作完成不喜欢的任务：一劳永逸的懒
Characteristics that don't matter as much as you might think
persistence: 固执己见 or 坚韧不拔知道何时放弃
experience: 软件开发行业的经验比书本知识价值要小，工作10年，是得到10年的经验还是1年经验的10次重复
Habits
精神品德，编程品德
态度端正，积极思考 --> 习惯
不能用没有习惯来代替坏习惯
Additional Resources
《The Humble Programmer》
Dijkstra:编程的本质任务就是驾驭计算机科学的极端复杂性，编程是唯一一个需要掌握从最底层到最高层9个数量级细节差异的人类活动。

Chapter 34. 软件工艺的话题
Themes in software Craftsmanship
编程的目的之一是管理复杂性
过程对产品有深远影响
团队：广泛沟通；单人：自我交流
编程应基于问题域而非解决方案
注意警告信息
迭代：软件质量
丰富的工具箱
Conquer Complexity
降低复杂度几乎和衡量程序员成果的最重要依据
方法：划分子系统，类、接口，保持接口抽象性，避免深层次的继承，避免深层的循环、条件判断，不用goto，不滥用异常（需以系统的观点使用），不让类过度膨胀，子程序短小，使用不言自明的变量，子程序参数尽量少，规范和约定
Pick Your Process
团队成员 --> Process --> 质量。
避免不成熟的优化
坏的过程损耗脑力
Write Programs for People First, Computer Secon
目标：算法精准，结构紧凑，性能好，注释清晰得体
Program into your Language, Not in It
要什么 --> 怎样用工具实现。
Fous Your Attention with the Help of Conventions
规范是一套管理复杂度的质量工具
规范能精确地传达重要的信息
规范能免除各种风险：禁止，要求 --> 防范
规范能增加对低层工作的可预见性
规范能弥补语言的不足之处
Program in Terms of the Problem Domain
尽可能工作于最高的软件层次
顶层代码：说明解决的问题
Separating a Program into Levels of Abstraction
Level 0: Operating-System Operations and Machine Instructions
Level 1: Programming-Language Structures and Tools
Level 2: Low level of implementation Structures 粘结层
Level 3: Low level Problem-Domain Terms 提供框架
Level 4: High level Problem-Domain Terms 基于问题域的术语
Watch for Falling Rocks
艺术 工艺（craft） 科学
良好的个人判断
玄机代码 maybe 差劲代码
设计的度量反映设计的质量
警告信息
重复，“不自在，不惬意”
不容易写注释，不易命名变量，不易将问题分解
难以理解，不安，猜测
找不到错误的原因仅仅因为是忽视
Iterate, Repeatedly, Again and Again
反复评估 --> 精确
开发：逐步精化，实证而非证明
迭代的代码调整
Thou Shalt Rend Software and Religion Asunder
software Oracles & Eclecticism
Experimentation
基于实验结果改变思路
“试图没有错误”是最大的错误
设计是仔细规划小错误以避免更大的错误
试验可用在很多层次上

Chapter 35. 更多信息
Software Construction
Pragmatic Programmer
Programming Pearls
Extreme Programming Explained: Embrace Change
Writing Solid Code
The Practise of Programming
Topic Beyond Construction
Facts and Fallacies of Software Engineer
Professional Software Development
The Psychology of Computer Programming
Software Engineering Overviews
Software Engineering: A Practitioner's Approach
Software Engineering 6th
Periodicals
Software Development www.sdmagazine.com
Dr.Dobb's Journal www.ddj.com
IEEE Software www.computer.org/software
Communications of the ACM www.acm.org/cacm/
A Software Developer's Reading Plan
Introductory Level
Conceptual Blockbusting: A Guide to Better Ideas
Programming Pearls
Facts and Fallacies of Software Engineering
Software Project Survival Guide
Code Complete
Practitioner Level
Software Configuration Management Patterns: Effective Teamwork, Practical Integration
UML Distilled: A Brief Guide to the Standard Object Modeling Language
Software Creativity
Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process
Rapid Development
Software Requirements
Professional Level
Software Architecture in Practice
Refactoring: Improving the Design of Existing Code
Design Patterns
Principles of Software Engineering Management
Writing Solid Code
Object-Oriented Software Construction

blogger功能增强

2008-10-06T08:01:00.002+08:00

昨天花了两个多小时给blogger加上了留言板、标签云和缩略显示。
blogger本身提供的功能较少，但提供了灵活的模板编辑功能，就好像blogger提供了一系列的数据接口，让用户选择所需要的数据进行显示，这比普通的Web开发来得更加省事，blogger的技巧很大程度上可以称为HACK，再加上blogger的广大用户群，所以一般的博客需求都可以方便地找到在blogbger上的解决方案。
留言板使用了cbox提供的服务，在网上找下就可以了。
标签云详见：Blogger V3.0 添加标签云
但是里面的javascript空行太多，影响阅读，使用正则表达式%[ ^t]++^p匹配多余的空行，删除就可以了。
缩略显示详见一下的文章：继续阅读懒人加强版

Learning python 读书笔记 PART 4

2008-10-05T21:36:00.002+08:00

PART FOUR. FUNCTIONS
Chapter 12. Function Basics
calls: myfunc(argv)
def, return, yield: def adder(a, b=1, *c): return a+b+c[0]
global: def function(): global x; x = 'new'
lambda: funcs = [lambda x: x**2, lambda x: x*3]
1. Coding Functions
def is a executable statement which create an object and assigns it to a name
arguments are passed by assignment
global declares module-level variables that are to be assigned
def <name> (arg1, arg2...):
    ...
    return <value>
def can executes at runtime
if test:
    def function():
else:
    def function():
2. Definitions and Calls
Polymorphism in Python: because python is a dynamically typed language, every operation is polymorphic in python
in python, code is not supposed to care about specific data types.

Chapter 13. Scopes and Arguments
1. Scope Rules
Name <--> Namespace
The enclosing module is a global scope
The global scope spans a single file only
Each call to a function is a new local scope
Assigned names are local, unless declared global
All other names are enclosing locals, globals, or built-ins
LEGB: local --> enclosing functions --> global --> built-in
the built-in scope
>>> import __builtin__
>>> dir(__builtin__)
zip <--> import __builtin__, __builtin__.zip
2. The global Statements
3. Scope and Nested Functions
LEGB: statically nested scope
lambda: an expression that generates a new function to be called later, much like def statement
4. Passing Arguments
immutable arguments <--> C's "by value" mode
mutable arguments <--> C's "by pointer" mode
Avoiding mutable arguments change:
pass a copy or tuple
Simulating output parameters:
>>> def multiple(x,y):
    x = 2
    y = [3,4] #change local names only
    return x,y #return new values in a tuple(not two values)
>>> x = 1
>>> y = [1,2]
>>> x,y = multiple(x,y) #assign result to caller's names
>>> x,y
(2, [3, 4])
5. Special Argument Matching Modes
func(value)    : Normal argument: matched by position
func(name=value)    : Keyword argument: matched by name
self documention, more meaningful
def func(name)
def func(name=value)    : default argument value, if not passed in the call
make some arguments optional
def func(*name)    : Matchs remaining positional args(in a tuple)
>>>def f(*args): print args
def func(**name)    : Matchs remaining keyword args(in a dict)
>>>def f(**args): print args
>>>f(a=1,b=2)
{'a':1, 'b':2}
Argument Matching
rules:
key arguments after non-keyargument
*name after normal argument
**name last
Matching steps:
non-key argus --> key word argus --> extra non-key argus --> extra key argus -->default values

Chapter 14. Advanced Function Topics
1. Anonymous Functions: lambda
lambda expression creates a function to be called later, but returns it instead of assigning it to a name
lambda argu1, argu2, argu3...arguN: expression using argus
lambda bodies are single expression, not a block of statements
example1:
L = [(lambda x: x**1),(lambda x: x**2), (lambda x: x**3)]
for f in L
    print f(2)
print L[0](2)
example2:
key = 'b'
{'a': (lambda f1),
'b': (lambda f2),
}[b]()
is equivalent to
def f1():...
def f2():...
...
key = ...
{'a':f1, 'b':f2}[key]()
How(not) to obfuscate your python code
((a and b) or c) is roughly equivalent to:
if a: b else: c
(C's a?b:c)
2. Applying Functions to Arguments
The apply built-in
apply(func, argus) == func(argus)
argument list is passed by tuple
if <test>:
    action,args = func1, arguments_a
else
    action,args = func2, arguments_b
...
apply(action,args)
3. Functions Over Sequences
>>> counter = [1,2,3,4]
>>> def func(x): return x + 10
>>> map(func,counter)
[11, 12, 13, 14]
>>>map((lambda x: x + 3), counter)
[3,4,5,6]
map(func,[1,2,3],[4,5,6]) #[func(1,4),func(2,5),func(3,6)]
4. Functional Programing Tools
filter
>>>filter((lambda x: x>0), range(-5,5))
[1,2,3,4]
reduce
>>>reduce((lambda x, y: x+y), [1,2,3,4])
10
>>>import operator
>>>reduce(opetator.add, [1,2,3,4])
5. List Comperhensions
[x ** 2 for x in range(10)]
map((lambda x: x ** 2), range(10))
[x for x in range(5) if x%2 == 0]
filter((lambda x: x%2 == 0), range(5))
map((lambda x: x**2), filter((lambda x: x%2 == 0),range(10)))
the genaral structure of list comprehensions
[expression for target1 in sequence 1 [if condition]
                for target2 in sequence 2 [if condition]....
                for targetN in sequence N [if condition]]
list comperhension and map are faster than for loop.
6. Generators and Iterators
Generators yield a value rather than returning one. The yield statment suspends the function and sends a value back to the caller and allow the function to resume from where it left off.
>>> def gensqure(N):
    for i in range(N):
        yield i ** 2
>>>x=gensqure(10)
>>>x.next(), x.next()...
Iterators and built-in type: iter(L)
__iter__ method

Learning python 读书笔记 PART 3

2008-10-05T15:08:00.004+08:00

PART THREE: Statements and Syntax
Chapter 8. Assignment, Expressions, and Print
program are composed of modules contains statements contain expressions create and process objects
1. Assignment Statements
a = 'a'
a, b = 'a', 'b'   #tuple assignment
[a,b] = ['a','b']    #List assignment
a = b = 'c'    #Mutiple-assignment
L = L + [3], L = L + [5,6]    #Concatenate(create a new object)
L.append(3), L.extend([4,5])    #Faster, but in-place(add at the and of memory)
L += [9,10]    #Mapped to L.extend([9,10]): the faster mothed
2. Expression Statements
3. Print Statements
print a,b,    #don't add newline at the end of text
print >>myfile a,b    #send data to myfile.write, not to sys.stdout.write
redirecting the Output Stream
import sys
sys.stdout = open('myfile', 'a')
print and stdout
class FileFaker:
    def write(self, string) #do something with the string
import sys
    sys.stdout = FileFaker()

Chapter 9. if Tests
1. if stataments
if: elif: else:
if 1:
    print 'true'
else:
print 'false'
switch & case:
*if choice = 'a':
    print 'aaa'
elif choice = 'b':
    print 'bbb'
else:
    print 'default'
choice = 'b'
*print {'a':'aaa','b':'bbb'}[choice]
*branch = {'a':'aaa','b':'bbb'}
print branch.get('a', 'bad choice')
2. truth tests
2<3, 3<2   #Less-than: return 1 or 0
short circuit evaluation
2 or 3, 3 or 2   #(2,3) Return left operand if true. Else return right operand.
[] or 3   #3
[] or {}   #{}
2 and 3, 3 and 2   #(3,2) return left operand if false. Else return right operand.

Chapter 10. while and for Loops
1. while loops
while <test>:
     <statement1>
   if <test2>: break    #Exit loop now, skip now
   if <test2>: continue    #goto top of loop now
else:
     <statement2>    #if we didn't hit break
breaks, continue, pass and the loop else
Emulating C while Loops

C assignments return the value assignment; Python assignments are just statements, not expressions
C: while ((x = next()) != NULL){process x...}
Python equivalent:
*while 1:
    x = next()
    if not x: break
    ...process...
x = 1
*while x:
    x = next()
    if x:
    ...process
2. for loops
for <target> in <object>:
    <statements>
else:
    <statements> #if we didn't hit break
3. loop variations
range
Counter Loops
range(3) #[0,1,2]
range(2,5) #[2,3,4]
range(0,10,2) #[0,2,4,6,8]
*for item in X: print item
*i = 0
while i < len(X)
   print x[i],; i += 1
*for i in range(len(x)): print X[i]
Nonexhaustive Traversals
S = 'abcdefghijk'
for i in range(0, len(s), 2) print S[i], #manual for indexing
for i in S[::2]: print x
Changing Lists
for i in range(len(L)):
    L[i] += 1
zip and map
zip can enable us to visit multiple sequences in parallel
L1 = [1,2,3], L2 = [4,5,6]
zip(L1,L2)   #[(1,4),(2,5),[3,6]]
for (x,y) in zip(L1,L2):
    print x, y,
when argument lengths differ, zip choose the shortest length
map(None, L1, L2)
map choose the longest length and filled empty items with "None"
Dictionary Construction with zip
>>> keys = ['a','b','c']
>>> values = [1,2,3]
>>> zip(keys,values)
[('a', 1), ('b', 2), ('c', 3)]
>>> D = {}
>>> for(k,v)in zip(keys,values):
    D[k]= v
>>> D
{'a': 1, 'c': 3, 'b': 2}
>>> D2 = dict(zip(keys,values))
>>> D2
{'a': 1, 'c': 3, 'b': 2}
File Scanners
file = open('test.txt', 'r')
while 1:
    line = file.readline()
    if not line: break
    print line
1. for line in open('test.txt').readlines(): print line
2. for line in open('test.txt').xreadlines(): print line
3. for line in open('test.txt'): print line
xreadlines loads lines on demand, "3" relies on iterators, is equivalent of xreadlines

Chapter 11. Documenting Python Code
1. the python document interlude

dir(): Lists of attributes available on objects
__doc__: In-file documentation attached to objects
docstrings
User-defined docstrings: strings at the top of file, method and class
built-in docstring:
import sys
print sys.__doc__
print int.__doc__, print open.__doc__
pydoc
help(sys)
2. common coding gotthas
Don't forget the colons
Start in column 1
Blank lines matter at the interactive prompt:
mean the end of compound statement
Indent consistently
Don't coding C in Python:
don't embed assignment statements in while loop tests
Use simple for loop instead of while or range:
for loop is simple and fast
Don't expect results from functions that change objects in-place:
append(), sort(), append(), extend()
myList = myList.append(X) #set myList to None
Always use parenthesis to call a function
Don't use extensions or paths in imports and reloads

Google docs + Google Gear + Blogger

2008-10-04T09:42:00.005+08:00

这几天把其它地方的blog都挪到Blogger上了，和其它blog服务相比，blogger更加简洁，而且方便定制。但这两天在使用的过程中，也发现了一些问题，首先Blogger本身提供的文本格式化工具较弱，拍版普通的文字尚可，但如果文字有缩进之类的就相当麻烦，Tab是没用的，就算在“誊写”状态下使用空格，虽然在编辑视图中缩进正常，但是在发布后依然难以控制缩进的量。其次我习惯性将博客写在word中，然后粘帖到在线博客的编辑窗口，但doc中的样子在粘帖过程中很难不走样。

首先我想到的从word中导出Html，然后粘帖到blogger的html视图中，但即使将导出的html进行规整后，显示的效果依然极不理想。

接着我想到了像blogger这么大的用户群，应该有人会开发blogger for word的插件，结果还真让我给找着了，可实际结果是登录blogger帐号失败，分析下来的结果是用户名和密码的字符编码可能在中文win环境下有错，导致了不能登陆，在windows环境下，这类字符编码的问题很少发生，但发生了还真想不到解决的办法。

然后我又想到既然word和Google doc间的兼容性较好，而Google的产品间应该也有较好的兼容性，因此我想到了word-->Google doc-->Blogger这样的发布路线，但实际操作下来word-->Google doc这一步没有问题，但从Google doc 发布到blogger时仍然出现了问题，虽然现在Google doc支持将文档直接发布到Blogger，但是发布的效果和doc中的显示效果有较大的差别。其实原因很简单，Google doc默认使用的CSS和Blogger使用的CSS有些不同，但修改Blogger模板有点烦，一个个属性一个个值调下去太费时间。不过我觉得只要调整正文的P、ul、li、dvi这四个属性就能取得比较好的显示效果。

最后的结果是，现在我不用office了，直接使用Google docs，虽然功能少些，但是够用，也不要担心文章丢失之类的东西。想想Google docs推出这么些年，也该出个离线编辑功能了吧，找了下还果然发现了。

首先要在http://gears.google.com/下载Google Gear，Google的一个支持web apps离线操作的软件，下载后能自动套用到当前使用的浏览器。然后启动Google Docs，在“设置”中将语言设成English（现在还不支持中文版的Google Docs），然后重启下浏览器，Google docs的右上方就会出现：offline链接，搞定！

Learning python 读书笔记（6, 7章）

2008-10-04T07:33:00.005+08:00

Chapter 6: Lists and Dictionaries
1. List
Methods: grow, sort, search, reverse, append, extend, append
del L[x:y], L[x:y]=[a,b,c]
range(x), xrange(x,y), L.pop()
2. List in Action
Slice assignment: delete + insert
L.append(x) < -- > L+[x]
3. Dictionaries
D.keys(), D.values(), D.items(): create a new list
D.copy(), D.get(k, default),
D2.update(D1): merges the keys and values of one directory into another, blindly overwriting values of the same key.
D.has_key(k), k in D
D = dict(zip(keyslist, valueslist))
4. Dictionaries in Action
sequence operation don’t work.
Assigning to new indexes adds entries.
keys need not always be strings.(can be other immutable object)
Using dictionaries to simulate flexible lists Using dictionaries for sparse data structures
Matrix = {}
Matrix[(2,3,4)] = 88: the number at position (2,3,4) is 88
Using dictionaries as “reconds”
Dictionary interfaces
import anydbm
file = anydbm.open(“filename”)
file [‘key’] = ‘data’ #store data by key
data = file[‘key’] #fetch data by key

Chapter 7: Tuples, Files, and Everything Else
1. Tuples
simple groups of objects, cannot change in place(immutable), don't support any method calls
>>> (1,2) + (3,4)
(1, 2, 3, 4)
>>> (1,2) * 3
(1, 2, 1, 2, 1, 2)
>>> T = ('1', '2', '3')
>>> tmp = list(T)
>>> tmp
['1', '2', '3']
>>> T2 = tuple(tmp)
>>> T2
('1', '2', '3')
>>> T = (1, [2,3], 4)
>>> T[1][0] = 5 #works
>>> T[0] = 0 #Fails
2. Files
input = open('path', 'r'), output = open ('path', 'w') #mode: r, w, a
S = input.read(), S = input.read(N) # N bytes
S = input.readline(), S = input.readlines()
output.write(S), output.writelines(L), output.close()
seek: reset current position in file, flush: buffered output write into disk
3. Type Categories Revisited
Operator Overloading:
class MySquence:
    def __getitem__(self, index):
        #called on self[index]
    del __add__(self, other):
        #called on self + other
4. Object Generality
Lists, dictionaries, and tuples can: 1. hold any kind of object 2. arbitrarily nested
Lists and dictionaries can dynamically grow and shrink.
5. References Versus Copies
No reference to the same object:
A = L[:]    #instead of: A = L (or list(L))
B = D.copy()    #instead of: B = D
empty-limit slices and copy method only do a top-level copy!
nested copy:
import copy
X = copy.deepcopy(Y)
6. Comparisons, Equality, and Truth
L1 == L2, L1 is L2   #Equivalent? Same object?
But short string: S1 = 'spam', S2 = 'spam' # S1==S2: true, S1 is S2: true
Numbers are true if nonzero
Other objects are true if nonempty
None: much like NULL in C
L = [None] * 100
bool: True, False

Concept map 思维导图

2008-10-03T08:37:00.009+08:00

接触思维导图是在《学习的革命》开始流行的那会，书中叫做“脑图”，兴许是名字太土，如今换成叫思维导图，听起来专业了些。也着实画了几张，后来新鲜劲过了也就没继续下去。昨天在抓虾上看到了《从优秀到卓越》的思维导图，发现看这图相比看书，比快餐还快餐，一下子就能知道个大概。接着试用了几款软件，MindMapper、Keystone和Inspriation。比较下来几款软件并无多少差异，可从作图的美观性和实例多少来看，MindMapper更为优秀。不过后来在Visio中找了下，发现也有类似的功能，即是所谓的灵感触发图。总的用下来Visio还是最好的，操作便捷且绘图标准大方。

在Visio中脑图一共有四种图形：主标题、标题、动态连接线和关联线。十分简单，而且够用。要花哨的话也提供了一些模板可以套用，使用上还是十分方便的。

http://picasaweb.google.com/xuyizun/LbltPF#
在网络相册中我放了一些搜集到的思维导图。

可我们真的需要脑图么？如果它真的有用，那么在工作中早就在应用了，而实际上直到现在，脑图依然处在个人的尝试中，我认为导致脑图并不流行的原因有以下几点：首先是脑图本身的局限性，它太简单而且太缺乏标准了，简单导致了灵活和杂乱，的确，脑图几乎可以表示任何结构的知识或思考；但由于没有标准的图例，一来导致了过于灵活，二来稍显杂乱。其次是中国的教育体制决定的，从小我们就被锻炼出了十分不错的记忆力，既然看完能较快地记住，脑图也就变得不那么重要了，因为脑图从本质上来讲就是为了帮助大家较好地建立一个思维体系。

下面用思维导图来表示思维导图的局限，算是练习咯！

Learning python 读书笔记（1--5章）

2008-10-02T12:29:00.006+08:00

PART ONE: Getting Started
Chapter 1: A Python Q&A Session
Chapter 2: How python runs programs
1. Source(x.py) --> Byte Code(x.pyc) --> runtime(PVM)
2. CPython, Jython and Python.net
Psyco: Just-in-Time Compiler
3. Frozen Binaries: program + PVM = binary executable program.
Py2exe(for windows), Installer(Linux & Unix), freeze(original)
Chapter3: How you run programs
1. Unix executable scripts: start with #!/usr/local/bin/python
2. raw_input trick: pause the script
3. import and reload
imports are too expensive an operation to repeat, so when we use reload() instead.
4. Attributes: import xx & from xx import yy. yy are the attributes in the python file xx.
5. IDE: IDLE, Komodo, PythonWorks, PythonWin, Visual Python(plugin for VS).
6. text editor: see http://www.python.org/editors

PATR TWO: Types and Operations
Chapter4: Numbers
1. programs  modules  statements  expressions.
2. Numbers: Normal integers(C longs); Long integers(unlimited size); Floating-point(C doubles);Octal and hex literals; Complex number literals.
3. NumPy(Numeric Python).
4. When use a variable that has never been assigned, Pythons report an error rather than a default value.
5. Numeric representation:
>>>b/a #Auto echo output: more digits
>>>print b/a #print rounds off digits.
>>>repr(num) #Used by echos: as cod form
>>>str(num) #Used by print: user-friendly form
6. Division: Classic, Floor and True
x/y: Classic division
x//y: Floor devision
>>>from __future__import division
7. >>>import math
>>>math.pi, math.e
8. >>>int(‘0100’), int(‘0100’, 8), int(‘0x40’, 16) #100, 64, 64
>>>oct(64), hex(64) #’0100’, ‘0x40’
>>>eval(‘100’), eval(‘0100’), eval(‘0x40’) #100, 64, 64
9. >>>a=3 # a: Names (reference) 3: Object
10. >>>L1 = [2, 3, 4]
>>>L2 = L1
>>>L1 = 24 #L2 is not changed
>>>L1[0] = 24 #L2 = [24, 3, 4]
Chapter 5: Strings
1. >>> s = ‘a\nb\tc’
>>> s # output is the original sequence
>>> print s #output is translated sequence
>>>len(s) #5
2. If python doesn’t recognize the character after ‘\’, it simple keeps the backslash in the resulting string.
3. Raw stirng: r’xxxx’
4. u‘xxx’: Unicode string
5. >>> abc = 'abc'
>>> for i in abc:
print i
a
b
c
>>> for i in abc:
print i,
a b c
6. Index and slicing:
>>> num = '123456'
>>> num[1:3], num[5:], num[:-4]
('23', '6', '12')
>>> num[::2], num[::-1], num[0:-3:2]
('135', '654321', '13')
7. String conversion tools:
>>>int(“42”), str(42) #Convert from/to string
>>>string.atoi(“42”), ‘42’ #older techniques
8. You cannot change a string in place(by assigning an index).
9. String formatting
>>> "%s %d %s" %('I', 4, 'you')
'I 4 you'
%s: string
%r: s, but uses repr()
%c: character
%d: decimal (integer)
%i: integer
%u: unsigned integer
%o, %x, %X: Octal, Hex, Hex uppercase
%e, %E: floating-point exponent
%f: float point
%g, %G: floating-point e or f
%%: %
%[(names)][flag][width][.precision]code
>>> x = 1234
>>> res = "integers:...%d...%+d...%-6d...%06d" %(x, x, x, x)
>>> res
'integers:...1234...+1234...1234 ...001234'
10. String methods:
X.method(arguments) == string.method(X, arguments)
list(); join(); capitalize(); center(width)…

vmware联网

2008-09-30T20:29:00.014+08:00

好久没在家里过十一了，今年老妈没给生活费，硬生生把俺逼回了家，也好，正好赶上大闸蟹上市。今儿上午去外婆家，成了玩笑的对象，很是热闹了一下，晚上爷爷奶奶又到我家，聚一起吃螃蟹，回家的第一天过得还是有声有色的。

空了还帮家里搞了下电脑，发现虽然学了四年的计算机，很多最基本的操作还是一窍不通。找了些基础的文章：
基本的DOS命令。
接着顺便在vmware中装了下Linux。选择host=windows guest=Linux这中方式也是十分无奈，上财的校园网通过H3C的802.1x拨号，在Linux下找不到合适的拨号软件，虽然网上也介绍了一些方法，但试下来无一成功。只好在windows下装了虚拟机。
vmware联网，host = win xp；guest = linux。
vmware联网类型：NAT，host-only and bridge。
最后我使用NAT方式联网成功，虚拟机中的IP设成通过DHCP自动获得就可以了。

开学第一周

2008-09-25T20:44:00.011+08:00

国民经济核算，高等数理统计，投资学，高级微观经济学，社会主义经济理论，高级英语口语，马克思。七门课程，２３个学时，忙忙碌碌。大学里逃了很多课，有些是当时就不该逃的，有些是当时只能逃但现在有些后悔的。后来考Ｇ，考研，找工，实习，才发现自己放弃了那么多本不该放弃的东西。现在只想静静地读书，再也不逃课，学好了课本再学其他的东西。简单生活。

上财来我还是蛮喜欢的。学校小小的，满满的，看着挺舒服；路上有很多漂亮的女孩子，就算每天走一样的路也不会觉得无聊；饭堂的伙食好出了华工很多；图书馆有满排崭新的计算机经典书。这些都是蛮让人开心的事儿。

STA + CS = data mining;

economic + math = STA.

从课程来讲，我也挺喜欢系里的安排，高微和高统打下了些经济和数学的基础，这对我而言是蛮重要的。

在网上也找了MIT的经济和数学课程，慢慢加强吧。

http://www.myoops.org/cocw/mit/Economics/index.htm

http://www.myoops.org/cocw/mit/Mathematics/index.htm

看了大学一个同学的简历，真的感觉差距很大，现在的我也许真不到他大三初的水平。回想自己的大学，实在是在七零八碎的地方花去了太多的时间。有很多基础的东西需要去补。

DB、Stastics、R、Regular Expressions。One by one!

通过u盘安装Linux

2008-09-24T21:05:00.005+08:00

下了fedora9，无奈本本刻不了dvd，只能打算通过usb进行安装。
win的usb启动盘可以通过usboot制作，而linux的usb启动盘在win下制作比较麻烦。
幸好fedora有liveusb制作软件，链接如下：
https://fedorahosted.org/liveusb-creator

上财上网通过H3C的802.1x，linux下找到的拨号软件试了下都用不了，比较可行得是linux1x，可仍无法验证通过，可能是数据包加密的问题，也不知怎么解决。现在学unix大多在win下通过putty连到unix-center进行一些操作。

POS开发

2008-08-29T21:58:00.006+08:00

整个七八月，都在蓝竹做软件开发实习生，在TD的Application组。每天的事无非是学习、看文档，直到三周以后开始从两份代码拼出一个RF卡的demo。之后过了两周多，Michale让我在一个已有项目的基础上进行修改，以完成一个新的项目。最后项目完成不到80%的时候我应实习期满离开了团队。

开发是在STIP2.1(www.stip.org)上进行的，协议大体采用ISO8583标准。模块的调用采用了异步模式，再加上较为复杂的状态机模型，在编程和测试的时候都出现了很多问题，一步步解决下来，感觉自己在面对这种较为微观的问题时的能力有了一些的提高。

STIP是Small Terminal Interoperability Platform的简称，是在受限系统上进行JAVA开发的标准，目前主要应用在以下的领域，与基于C语言的开发相比，能较大地提高开发效率。
�� EFT-POS terminals(STIP EFT-POS Profile) �� ATM �� Payphones �� Parking Meters �� Utility Meters �� Mass transit terminals �� Vending Machines

STIP的架构大体如下图所示，我们Application组开发的就是Stiplet部分，也就是底层之上的应用：

STIP有专门用于界面描述的STIPML语言，类似于HTML。Stiplet的结构类似于MVC架构，其中Controller部分控制软件的状态和流程。STIP的事件模型如下图所示：

具体到项目的开发，虽然也进行总结，但由于保密协议，能贴的只有上面这些。开发中看了Michale和Command他们原来写的代码，学到了很多，也发现了自己太多的不足。很多地方只有靠扎实的基本功和清晰的思路才能完成，这些也只有在做过很多项目，经历了很多成功和失败后才能获得。

开发过程中我也发现了自己的一些缺点，总结下来由以下几点：
一是团队交流意识的欠缺，虽然在发现问题时能向老员工请教，但交流得还是不够，有些东西靠自己去发现会走很多弯路，费很多时间；在知识学习时尽量自己思考是不错的，但实际工作中有些问题还是要多多交流，对一些概念的理解上不能模糊。
二是基本功不扎实，具体体现在阅读和改写达三四千行的类和较为复杂的算法上。比如状态机和协议的解析，这些都需要有扎实的语言基础和清晰的思路。
三是在和客户沟通上应该及早发现问题，及时主动沟通，有些东西客户的文档里可能没有写，但在实际的情况下是相当重要的需求；有时用户的需求文档也许制作的流程并不规范，存在着一些相互矛盾的地方，这些都是要尤其注意的。

总得来说在蓝竹的实习学到了很多东西，也发现了自己的一些不足，不仅是在技术方面，也包括做事的态度，方式等等一些地方。谢谢帮助过我的Command、Michale和海啸。

有点困有点欣喜

2008-08-08T20:48:00.002+08:00

今天就奥运开幕了吧，回去整下电视，不知能不能收到个台先。从500天倒计时到200天到100天，更多的是让人感觉到时间一点一点地流逝。昨天逛了豫园和外滩，虽然经常来上海，可如此通俗的地方却总是没啥心思逛，又一次倚在黄浦江边，突然发现东方明珠肥了好多。。。难道是我长高的缘故？蹉跎哦。

六月三十号到了上海，七月一号开始上班，一个多月过去。生活改变了很多，难以明述。状态一般，读书不像读书，工作不像工作；将来要做什么，现在在做什么，已经不去思考，跟着惯性这么走啊走，等开学了该会简单些吧。。

工作依然是coding，和原先的工作比起来省了些上下班时间但每天多出了两餐的花费，不赚不赔，依旧月光。饭卡里还有九天的午餐，工资还是没发。等下下周我就只能每天吃包子打发了，早饭三个小肉包一个菜包。。一块九。。午饭一个肉包一个菜包两个烧卖。。三块一。。再夸几句老板娘看看能不能还到三块。。晚饭。。就吃面吧。。我的生活那！

还是一小程序员，只是周围的人从八卦女人变成了男性的工程师，三十余岁光景承担着压力和责任的男人，只是男人无聊的时候也会看小说，谈起孩子来也露着笑。傻傻的IT人。

我的CPA。。。。具体说是八月份已经开始看了。只是昨天没看，前天也没看，前天的昨天和前天的前天也没看。。。OMG。。。搓。哎，看完奥运先！

奥运能不能提前下班哩，期待ing。
又是周末咯~~~~~~~~

离校

2008-06-30T20:46:00.001+08:00

昨天的广州从中午就开始下雨，天气闷热。“是在广州的最后一天了呢。”中午Frienky走了；下午小牛送我到了地铁，挥挥手，消失在了地铁口；吴昊帮我拎了一路的包裹，在体育中心下车了。就剩我一个人了。傻傻地流泪，明明还笑着呢。

真不知啥时才能回了呢，五年抑或十年？

上了火车就睡，可能是昨晚通宵了吧，也可能是我根本就不想讲话。到了十点却没有了睡意，就着窗外时时闪过的灯光，和对铺有一搭没一搭地聊着，不知不觉又睡着了。坐火车的时候只要装着自己晕车，就会很容易睡着的。

中午到了上海，边发呆边整理学校带回的东西，接着去超市买了些吃的，“基本安顿好了呢。”自言自语。

下面两个月该是很简单的生活吧，忙碌，然后忘记。

毕业啦

2008-06-29T13:35:00.002+08:00

四年一梦，终于到了梦醒时分。看着清晰的相片，欢喜的脸庞，突然间却有了恍如隔世的感觉。04双语，直到这会才算凑齐了，团结而优秀，全校最优秀的集体。是它印证了我们的改变。新加坡、美国、中科院、IBM、腾讯、北电、工行、招行、汇丰。。。除却名校就是名企了。只有我孤零零地到了上海，选择了读研，为了一个兴许空幻的目标，真不知是否值得。

801--426。四年的舍友，伴我一生的兄弟。

北区的校训石，华工原是中大的旧址，博学之、审问之、明辨之、慎思之、笃行之。伟人遗训。两个女孩子是小牛和frienky的舞伴，搬到了北区，正好一聚。

李元元校长为我颁发学位证书，全校八千余毕业生，学位证书都是李校长亲手发的。毕业前华工又让我们感动了一把。

毕业设计

2008-06-22T08:54:00.003+08:00

一个月前离职返校，折腾了这么些日子，总算把毕业设计给鼓捣出来了。题目是《主题爬虫在WEB新闻聚合中的运用》，导师是沃焱老师。谢谢老师的信任，让我能结束了上海的实习再回广州完成毕设，不然两头奔波的日子是难以想象的。

整个一个月，我都窝在宿舍，除去做毕设，就是闲极无聊地打游戏。大学的最后一个月，过得着实不咋样。说是做毕业设计，其实和文科写论文没啥两样，由于时间有些紧，基本是边写论文边做毕设，说个好听点是文档先行，说个不好听点就是能不能鼓捣出这软件心里还没啥底。

论文排版话了一半的时间，用Latex，在清华的学位论文模板上进行了些修改，然后用了listing、beamer之类的宏包；总得来看效果还是可以的。只是写论文的过程中没有找到得心应手的工具，先是用CTEX集成的写作环境，之后又换了叫SciTE的编辑器，最后使用了Eclipse+Texlipse，用得还算顺手。之后还尝试了下在Linux下用Emacs写latex。只是原来写好的论文编译时出现了乱码，只得作罢。

总得来讲，一旦熟悉了几个基本的宏包，使用latex排论文、简历之类的东西能大大提高生产率。并能轻易获得专业的外观。后来估计也是因为这个原因，鼓捣出来的80p的论文评了优，还是有些得意的。

下面摘抄了些开题报告的内容：
当今网络信息资源急剧增长，面对这个海量、异构、半结构化的信息库时，人们常常会面临“信息过载、知识匮乏”的困窘，为了避免这种情况，我们需要以合适的方式对Web资源进行检索和呈现。Web知识发现是是几年内兴起的一个被广泛关注的研究课题。它是从Web数据中发现有用的知识和模式的过程，而如何高效地获取相应主题的信息也就成了Web知识发现至关重要的一步。

在寻找相关主题的页面时使用主题网络爬虫可以根据一定的网页分析算法过滤与主题无关的链接，可以提高抓取的准确性并减少计算资源的浪费。同样，随着网络信息的增长，人们为了及时方便地得到所关心的信息，希望从被动的上网查看新闻更新转变为主动地接收新闻信息。新闻聚合应运而生，而Atom和RSS是新闻聚合最流行的实现方式。

鉴于以上原因，我打算结合网络爬虫的主动搜索和新闻聚合的推送模式开发X-Info软件，首先利用主题爬虫定期从网络上收集新出现的相关主题的新闻网页，将其内容经过分析整理，构成按时间及主题相关度组织的新闻序列。同时对页面信息进行分析整理，得出可供统计的有用数据，并且提取出其中的部分信息生成符合RSS规范的聚合文件，让相关主题最新信息可以在普通的RSS阅读器中使用。

肇庆

2008-06-20T13:25:00.001+08:00

Hank请客，我们宿舍四在大学毕业前到肇庆着实潇洒了一回，包吃包住包玩，临走还拿了方端砚；出去玩从没这么爽过，感激涕零。

肇庆的鼎湖山，被誉为北回归线上的明珠。记得96年的时候还发过一套鼎湖山的邮票，由于那时集邮，也是有些印象的。有鼎有湖，所谓鼎湖。这张是在鼎园里拍的，那些鼎都不过是当代的仿品，没留下多深的印象，可石栏上的三朵花儿，不知是天意还是人力，错落有致地散着，很有些飘然人世的味道。

鼎湖山的游船码头，恍如仙境。

肇庆市区的七星岩，那天天阴，再加之相机实在太傻瓜，拍了很多张都没啥效果，真实的风景是相当干净的。

七星岩的鱼儿，只要看到人影就涌来争食。

还是我们宿舍的四个。

GSMC&Struts

2008-05-11T10:56:00.005+08:00

从三月十号到现在，我在张江高科的GSMC（Grace Simiconductor Manufacturing Company）做软件工程师，分在系统咨询部的SCM组。两个月里为已有的系统增加了两个子模块，一是订单组合查询，二是查询定制。使用JSP开发，用到了Struts、XML；此外，由于系统使用了iBATIS，对它也进行了一些学习。开发过程中使用了Eclipse和一些数据库操作软件。由于涉及比较复杂的SQL查询，这方面的基本功也有了较大的提高。

开发过程中我也发现了自己的一些缺点，总得来讲有点工具崇拜，比如新版本的开发工具等等。实际上费了很多时间精力，对生产率基本没有提高，开发靠的还是基本功。

GSMC的气氛很好，没有太大项目的压力，员工也都爱玩，再加上不错的伙食和点心，工作得还是蛮开心的。

违约，返校

2008-05-08T20:46:00.001+08:00

下午交完三千违约金，下班，聚餐，买好了十号的车票，回到住的地方已是八点多。

在宏力的实习结束了，算是一个插曲吧～～遇到了很多挺有意思的人，舒舒服服地过了两个月，除了交违约金的时候有点不爽，其余时候还是蛮开心的。我们MIS部十几号人，除了老板Robot、比我早一年多的Andy和我，其他清一色的都是大姐姐，全是可爱而八卦的人。相处下来，感受到他们的心态真是好年轻哦；这么着，也就觉得我活得有些累了，老是想什么目标，老是看书考证；这个不知不觉，大学都毕业了，玩没玩够，学也没学好；嘿嘿，真不知自己图的啥哦。我们小组五个人，Ellen，minmin和Jenny三个大姐姐，Andy比我早一年，所以他就成了小弟，我就成了小小弟。Ellen是我们老大，蛮干练的感觉，蛮好的人，公司刚成立的时候就进来了；Minmin也是老员工了，每天上班第一件事就是在她那一年多没换水积满了粪便长满了水草的的虾缸里捞螺蛳，说是要给小虾创造一个良好的生存环境，那些小虾也果然不负所望，健康成长还繁衍生息；Jenny是个两岁孩子的妈，不知不觉就说到孩子上去了，养了两缸的小鱼；Andy是个有趣的神叨叨的人，迷信的说起来是一套又一套，和看多了鬼故事的Minmin和Jenny一唱一和，蛮是好玩。我呢，我是个啥都不懂的人，坐着听讲，傻兮兮地笑。。

感觉这两个月编程上进步还是比较大的，维护的是零三年左右开发的古老系统，基于struts，编码和测试的时候都遇到了一些困难，坚持做下来，web开发的各个方面都有些接触；系统又旧又大，折折腾腾，边看边写，也是学到了很多东西，不过对将来有没有用就难讲了。

明天去办最后的一些手续，下午再去面试一个暑期实习。现在我真的不知道将来做些什么，甚至也不知道自己想要什么；虽有个大概的方向，却也不知道怎么走，计算机转统计，就数据挖掘这路，不过数学和算法都没学好，一两年读完研也怕是不伦不类。管他呢，从小到大我就没顺过，不过磕磕碰碰总能过去。

现在最重要的是开心，然后放松，然后回广州大啃水果。

08.4.18

2008-04-18T20:44:00.002+08:00

转眼到上海已经两个月了，烦心的事纷至沓来，又件件归于平淡。一月二十乱七八糟考完研，看着几十本的考研书，失落，拐了一个大弯又走回了原来的路，只是和别人的差距一下变得好大。重头开始看ｊａｖａ、看数据库，海投简历，一下子落下好多，不安。过了年收到了几家面试通知就匆匆到了上海。三月一日宏力给了offer，赶回广州办三方协议，三月十日开始工作。十二日，谈了一年零一月的恋爱结束。痛。那时算是最低谷了吧，奋斗了大半年，又错过了年前的好工作，形单影只，一无所有。忐忑不安得等待考研的分数线。一个月想了好多，也现实好多。一个都市的外乡人，可怜的工资，狭小的圈子，谈什么发展。说是要打拼又谈何容易。工作上也越到了问题，计算机毕业生连个JSP都不会写，惭愧。还好Andy和Minmin都给了我很多帮助，主管也从不催我。一个月下来，感觉进步很大。四月三日知道了分数线，刚好过线，全力准备。又开始头痛。十四十五请了两天假参加复试。笔试基本不会。又开始了等待。今天下午知道的结果，录取了，不过是自费。去上财看过了，学校很小，不过看着蛮舒服。读研一定要有个规划了，经济上也要自立。新的奋斗！

08.3.18

2008-03-18T20:42:00.002+08:00

在上海的一天。上午coding，下午和同事去SEMICOM展会骗了些小礼品；然后逛了迪卡侬和百安居，啥都没买，坐地铁回家。简单的一天。等车的时候，感觉着列车开来驶去的风儿，有点莫名地惆怅。我为什么不快乐。忽然间想到了一个无聊的问题，一个人傻笑。

到上海正好一个月，找工，回广州拿协议，开始实习。。这个月发生了很多事，喜怒哀乐搅在了一起，又渐渐地归于平淡。工作慢慢慢慢地进入正轨了吧，GSMC是一个让人感觉蛮舒服的地方，整天被人小小弟、小孩这么得叫着；发呆就看看同事养的小鱼和小小鱼，小虾和小小虾；呵呵，蛮有意思。

生活也渐渐习惯，其实是没有生活的生活，七点零五分，地铁---“张江高科站到了，请乘客们带好自己的行李物品，依次。。。。”，上公司班车，早饭，工作到十二点，午饭，工作，晚饭，班车，地铁--“中山公园站到了，请乘客们。。。”--六点四十五分。

好在我在意的东西不多，一个人过更是平淡，不看电视，不打游戏，偶尔去下超市、网上买些书，聊聊天，仅此而已。早上路边花五块钱买了两瓶莲花状的盆栽，把花盆擦干净，搁办公桌上，又多了两个伴儿，呵呵。我在意啥呢？自己问自己，暖色灯光，洁白的A4纸，粗粗的铅笔，绿茶咖啡，洗澡刷牙，让人舒服的细节。简单的生活，不开心，穷开心。

上财的分数线还没出来，不是高三分就是低两分吧，看人品，不过也无所谓了。过去的一年是人生的一段插曲，不管意义如何，我都会记住。

上海植物园

2008-03-12T13:02:00.004+08:00

牡丹花开。

静寂的院落，很有些苏杭小院，闹中取静的味道。

在十年前，我也在这假山前留过影，如今故地重游，人还是一脸傻笑。

绣球花

Shanghai!!!FFFFFFighting!!!

2008-02-17T10:45:00.000+08:00

上海，一个比广州更大、更挤的城市。

下个月该在不停地面试和奔波中度过吧。再下个月就该安定下来了。

这么一走出去，就再不是学生；回头看看，嘿，我的大学，8！上路！

不是学生还该上校内么？不知道。

去南方兜了一大圈，又回来了。

没什么目标，但有死磕的心。光脚的不怕穿鞋的，死猪不怕开水烫。呵呵，谁怕谁？

还记得站在海边，灌酒大喊，“努力，奋斗！”

磋了一年，i'm back，开心地，杀！

Holily sh*t!!!

兄弟姐妹们，加油啊！

新年快乐！

鱼丸++

2008-01-28T22:02:00.003+08:00

今天做鱼丸了，从六点半到八点半共花了两个多小时，基本照着网上的说明做的，基本算成功。虽然有点累，不过蛮有成就感哦，比我老爸做的好吃呢！

第一步是去皮，把刀竖着切下，但不要切透鱼皮，然后贴着皮行刀，把肉分开。这是我爸教的，要想直接削皮是挺难的。
第二步是刮肉，我的理解就是把鱼骨鱼肉分开，先用刀背把肉打松了再刮，用刀锋的话会把鱼骨搞断，去起来麻烦。
第三步是剁泥，网上有的说要用刀背剁，试着觉得斩不透，还是用刀锋剁的，剁成泥状，有点粘刀。时不时用手拌下，有剩下的鱼刺筋络顺手去掉。
第四步就是搅拌了，先把盐、姜粉、料酒和水调和，今天我鱼和水差不多是一比一的比例，很嫩，但韧性不大足。不知道是打得不透还是水放多了的缘故。先打个蛋清，然后加水顺一个方向搅匀，觉得上劲了再些加水打。最后加一勺淀粉增加点粘度使之容易成形。
第五步挤丸和第六步水煮和下面的说明都一样了。我这次挤出的鱼丸放水里是浮的，而且一点都不相互粘连。

关键所在是去骨剁泥和搅拌，挺花时间。有人也说要加肥肉，加这个那个的，我觉得都不是关键，关键是要舍得花功夫。我们有时候太注重方法了，认为事情没有做好是方法不对，其实很多情况下是功夫没有下足。就像学英语，方法就一个字，背。

总之，我们要做好鱼丸一定要做到调制鱼茸六不伤、六不缺（水、盐、油、蛋、粉、味）；搅打好的鱼糁色白、滋润、细嫩、光滑、无杂质；氽煮时掌握好火候，就一定能做出高质量的鱼丸来

踏雪

2008-01-27T21:58:00.003+08:00

好久没见过这么大的雪了。

下午带着相机出去拍些雪景。还是前年夏天了，那时老带着相机出去拍拍风景，一人五点多就起了，骑车到森林公园，宜园，拍完一圈回家吃早饭。那时蛮自在的，不过今天走出来总觉得有些冷清的。心境不同了吧。有人在堆雪人，我看看，走过。

绵绵的雪，踏着和昨天的触感明显不同，雪薄薄的时候踏着比较结实硬朗，厚厚的就松绵绵的了。踩着不着力。分析了下，可能是刚下的时候雪落在地表上，边化边结，比较密实。后来下的呢，直接堆雪上，一点没化自然就松了。呵呵，学工科的，就是没情调。

拍了十来张吧，雪地里挺亮的，也拍不出啥质感，就是白白的一片。走到水杉林里，好美，完完整整的雪，不忍心踏。时不时积在树梢的雪唰地落下，打在绵绵的雪地里，一片静寂。打开相机，没电。懊恼。前面平常的风景拍了十来张，到真正美的地方却拍不了。发了会呆。继续走。除了白，只有墨绿，深褐。如果能发现一点红色，该会很惊喜吧，环顾，还是一片洁白。

雪，不像雨那般粘粘的让人不舒服，蛮大气。况且雪和血同音，白与红，冷与热，多美的巧合。步步谨慎，还是滑了下，一点都不疼。爬起来，看看印在雪地的人形，嘻嘻，蛮有意思。回家。

The C Puzzle Book （C语言解惑）读书笔记

2008-01-21T22:00:00.001+08:00

每年在火车回家坐火车都是一种折磨，不过这次运气不错，一来认识了两个聊得来的朋友，二来带了一本《The C Puzzle Book》，翻翻看看，隔了一年多没碰C，有些问题是实实在在地不会，有些问题是自己粗心得挺搞笑。

Chapter 1 操作符
a. z+=-x ++ + ++y ==> z+=-(x++) + (++y)
but, x+++++y ==> x++ ++ +y 无意义
b．~01 == 1…10 != 10 ^_^
c. ~x|x == 111.. 1 恒等于 -1
d．y = -8; y >>= 3 y并不一定为-1，有些计算机右移时不保留操作数的符号位
e. z += x z+= (xf. z>=y>=z ^_^
简简单单的符号优先级问题本来以为背熟了表就差不多，可还是错了上面几个，蛮郁闷。

Chapter2 基本类型
a. define PRINT(format,x) Printf(#x " = %" #format "\n", x)
PRINT (d,"5") ?
显然打印的是指针地址，不过刚看时笨得没发现
int x= -2, unsigned int ux = -2 PRINT(o,x) PRINT(o,ux) ?
无论带符号还是无符号，-2都是那串01
b. 3.(注意后面那个.) …………
c. c语言中，即使运算发生了溢出，结果仍将是合法的数值。
主要是向上向下转型的问题，结合运算符优先级，挺容易搞混的。细节，细节！

Chapter3 头文件
#define PR (fmt, val) printf(#val " = %" #fmt "\t", (val))
#define NL putchat('\n')
#define PRINT1 (f,x1) PR(f,x1), NL
#define PEINR2 (f,x1,x2) PR(f,x1), PRINT1(f,x2), NL
... ...
一层一层往下套吧。。

Chapter4 控制流
a.if也能短路的哦
b.if( x=y ); x=3 看见那个分号了没？呵呵
c.while( y<10 ){x=y++; z=++y;} y++了两次哦，大意大意。

Chapter5 编程风格

半年黑白

2008-01-21T10:44:00.000+08:00

半年，不快不慢地过去了。

走出考场，木木的，说不上啥感觉。

反正是考得不好。想打电话，试了一个电话机，坏了；又试了一个，也坏了。

回宿舍，泡面，开机。

找工，大概花了八个钟，中英文简历都搞好了。

态度决定一切。

踏踏实实找工，就像我考研前想的那样，技术上虽然荒废了大半年，但精神上，已够韧了。考研不管结果如何，认了，不会去试第二次。

认真做技术，认真找工，认真待人，认真待己。

我没有败，也不会败。拐了个弯，又到了原来的路上。

我还是我，只是更看清了自己。必须要踏实，踏实！

目标：每天锻炼，每天学习，每周写周记，看书做笔记。

南京之行

2007-08-13T08:01:00.001+08:00

总得来说，南京还是个不错的地方。历史感很强，但过于压抑，承载了太多的沧桑。
可能也是这个原因，南京更显出了一种久经沧桑后的平淡。

考研

2007-07-19T08:34:00.001+08:00

开始准备考研了，蒸发一段时间。
选择考研对我而言机会成本高了些，不算是理智行为。特别又跨专业挤了个大热门--金融工程，风险太大，收益又不大确定，准备得也晚了些。
计算机我也很喜欢，但我不是一个努力的人，没啥钻研的决心，在一个领域呆久了滋长的只是惰性。就算我本科就读的金融，到现在还是会转专业的。
文科比较浮躁，我是个浮躁的人，所以想学下文科体验生活。我算不上是个风险厌恶的人，觉得风险犹如生活的调剂，生活中的选择就像是投骰子，我有时像一个纯粹的赌徒。
一月前差不多还在编程、赶作业、准备考试，现在却彻彻底底地把计算机扔了，扔得毫不心疼。因为计算机已经给了我很多，至少它可以让我放心地全力以赴地做出高风险的决定，选个不错的金融专业，如果失败，继续做计算机至少还能生活下去。我不会进行第二次尝试。
没有什么能算是毕生的事业，人只能选择当前看似比较好走，有趣的路。因为没有地图，你不会知道这条或那天路通往何处，所以永远不可能有最佳选择，即使走的是最佳的路径，你也无法确认它的确是最佳的。
一连串偶然事件使我觉得考研是老天的安排，很多细微的因素似乎在暗暗驱使我向着一个目的地前行。成功也好，失败也罢，听天由命，生活指引着我走上了考研的路，结果也已经注定，现在要做的不过是去发现这个结果。

基于socket的简单语音聊天软件

2007-06-07T14:19:00.008+08:00

基于socket的简单语音聊天软件是分布式的作业之一。下文摘抄了概要设计和详细设计的开头部分。

背景
软件名称：Xchat
开发者：04 双语许一尊 200433099266
开发平台：JDK 1.5 + Eclipse3.3M6
本软件只采用了基本的Java sound API，即javax.sound中的内容，没有使用JMF和开源代码。

参考资料
《分布式计算原理与应用》
Java API
Java Sound Resources http://www.jsresources.org/apps/am.html

需求
1. 基于基本的Client/Server模式，实现一个text画板，提供一个多人的chat空间。在此模式下，每个人发出的message都通过server的中心控制，由server组播（multicast）给一个chat组的其他会话人。
2. 语音的录取、打包、传输、播放，从而将text chat空间变成了voice chat空间。
3. 通过server的中心控制实现会话的记录和交互式回放。

设计思路
客户端设计参考MVC模式，由一个核心控制模块处理语音发送接收、聊天信息和控制信号的发送接收、音频点播及界面的显示更新。
文本消息和控制信息合二为一，格式为：用户名>>>命令>>>参数
语聊信号通过建立音频管线截取语音包，直接广播到所以客户端，由客户端各自播放。客户端接收到控制信息时，提取出其中的用户名、命令和参数，如果该命令针对所有客户端，则执行该命令；如该命令针对特定用户，只有当用户检测到控制信息中的用户名项为其自身时才发生相应。
音频点播实现是由客户端通过有连接socket发送请求，服务器受到后发送确认信号，将文件以流的方式发送至客户端播放。

特殊性说明
由于只使用基本Java sound API，Java音频的一下局限性觉得了本系统一些特殊的设计：
首先，java平台的音频播放性能有限，当一次写入的数据过小是，声音容易出现断续的现象，而一次截取的包过大时，又会导致较大的延时。所以，必须在音频质量和声音延时上做出选择。最终的权衡结果是以1/4秒为单位截取声音，总的延时为0.5秒+网络延时，在局域网中，网络延时可以忽略不计，所以总的延时在0.5秒左右，可以接受。
其次，Java音频由于其性能问题，不能提供良好的混音效果，所以如两人同时发言，接收到声音的断续现象较为严重，如果多人同时发言，网络条件下4个音源的混音效果根本不能接受，所以本软件设定同一时间只能由一人发言，由一系列控制信号来达到所以客户端的同步。
其三，java保存音频文件方法较为单一，虽然可以通过InputStream保存成音频文件，但要预先制定音频文件的大小，这显然是不可实现的；所以唯一的办法就是在音频采集是直接保存成音频文件，在一次发言结束后上传到服务器，由于java本身没有音频合并的方法，所以音频文件的保存是以发言为单位的，点播时自然也只能以发言为单位。

系统结构
客户端

客户端设计参考MVC模式，由一个核心控制模块处理语音发送接收、聊天信息和控制信号的发送接收、音频点播及界面的显示更新。

服务器端

服务器端以一个控制中心为核心，处理客户端传来的消息和控制信号，执行相应操作并返回控制信号。

类图
客户端

a. 客户端以ClientAction为中心，该类处理界面相应并调用相应模块。由于ClientFram（界面类）的类中元素过于繁杂，在此图中已删除此类。
b. SocketMessageManager是文本消息处理的中心，建立messageSendThread和PacketReceivingThread处理消息包的发送和接收，受到消息包并提取其中信息后，将其交与ClientAction处理。
c. SoundCapture处理音频的截取和广播；SoundPlayer负责接收音频包并播放。
d. SoundRecoder负责讲语音保存在临时文件中，SoundSendThread负责发送该音频文件。
e. SoundRequestHelper与SoundRequest负责音频点播。

服务器端

a．服务器端以ChatServer为中心，处理客户端传来的消息和控制信号，并执行相应操作。
b．MessageServerThread负责调用RecervingThread，RecervingThread接收文本消息包并分离出其中的控制信号，交由ChatServer处理。
c．MulticastSendingThread负责相客户端广播聊天消息和控制信号。
d．SoundSaveServerThread负责处理客户端的保存聊天音频文件的请求，建立AudioSaveThread保存文件。
e．SoundRequestServerThread负责监听客户端的聊天记录点播请求，受到请求后，新建AudioPlayThread处理相应请求。

清明

2007-03-31T08:32:00.001+08:00

今天党团活动去了黄花岗。很多墓碑，有无名无姓的烈士也有声势显赫的将军，他们都长眠于此。公园绿草茵茵，很多老年人舞着扇子，小孩嬉笑，很和谐。烈士们想看到的也许就是这场景吧。
民国时期的建筑，朴素，并不高大，但在肃穆中透着大气。看看中山纪念堂，中山陵，也都是这感觉。再看看各地的大学，也是喜欢年代旧些的建筑。觉得新的一些大楼，虽然精巧，却流于浮华。再过个一百年，那些新建的大楼也应该陈旧了吧，那时他们剩下的，也许只有陈旧和年代，而没有历史和沧桑。国家还没有真正富强，年青一代需要努力。社会风气浮华，有些人只追求着感官的快乐或沉溺与小资情怀；不该这样的，我今年已大三，可还常常浪费时间。虽然个人是卑微的，多一个少一个对这社会好像并没什么影响，但这不是沉默的借口。身边有很多努力的同学，应该向他们学习。虽然不是每个人都能成为精英，但每个人都应该负责任。古人所说“修身、齐家、治国、平天下”，很有道理，心中要装着亲人，装着天下，努力，尽管卑微，对这个社会也还是有用的。

非对称

2007-03-28T08:27:00.002+08:00

对称是美的，而不对称是永恒的。正是这种种非对称，创造着生命中的悲欢和这个世界的混乱和魅力。
打过RPG游戏的都知道，在对称中创造非对称正是游戏的精华所在，比如星际魔兽，乍看游戏中的每个种族都是均衡的，并没有明显的相生相克，可在比赛中选手们却有意识地创造着不均衡，在己方兵种有绝对优势时，胜利来的往往容易些；不过初期的优势并不意味着永远的优势，比赛在不断地变化，双方的策略也在不断地变化，当一个非对称的情势发展到极致时，也正是最易赢得比赛或输掉比赛的时候。没有永远的阳光灿烂，也没有永远的阴雨绵绵，今天在变，明天的变化也许更大，人不能永远地等待，把期待放在明天，放在一个难以琢磨的时刻。
想到面前的道路，也是个混乱而难以选择的情形。

在困难的选择中打破均衡，使生命的天平慢慢向自己的目标倾斜，在灵动中创造机会，在变化中求得发展，也许正是我们所该做的。反省自身，我之所爱和在？-----生活；生命短暂，有太多值得尝试，生活中有足够的素材值得我去接触消化理解感悟和升华。生活中的快乐来源于爱和感恩；来源于进取和帮助他人；这也正是我所追求的。一介书生，身无分文而心忧天下----看似有些土，在这滚滚红尘中显得不和潮流而迂腐，可些小的欲望太容易满足，物质的追求又没有满足的底线，生活的意义，除了在生活中找寻，又在何处？人活着，还是要为社会做些事的。

回到非对称这个话题，生活为何累人？因为人们太在乎均衡，太难放下。全面发展堪称完美的人自然存在，可他们似乎只是我们仰望的对象，从小到大，就算在身边，也总有些人，我永远无法超越，越想超越却发现离得越远。因为你永远不知道那些人下一步要做什么，因为你只是抱着竞争的心态。放弃竞争，选择合作，这才是道路的开始。以竞争的心态看人，难免将别人和自己相比，有过之则沾沾自喜，不及之则心有不甘；千方百计的借口，怨天尤人的抱怨。以合作的心态拥抱社会，改变自己，使自己变成大环境下不可或缺的一块积木；环境变了，便改变自身，以保证团体的完整；所以，我不同意“磨练”这个说法，社会不是磨刀石，不是打磨人的场所；人不应该是木头，而应该是橡皮泥或气球，改变自己甚至扩充自己来适合这个社会。

现在工作为什么难找，因为很多毕业生太相似了，如同是个球，只有大小之异没有形状之分，质地不软不硬，不想改变又自视甚高。这应该是教育模式和社会心理共同作用的结果，对孩子而言，从小和人比成绩当小干部，而家长呢，太在乎，将孩子作为炫耀的资本，人家小孩学钢琴，学画画，成绩好，外语强；人家小孩上大学，赚大钱。。。。于是中国就多了这么多难以就业的大学生，同时也有这么多技工岗位难觅良才。大学生虚度光阴自然不对，但全心学习也非良策；人有不同，有人强于综合而疏于钻研；有人贵在速度而疏于严密；不是每个人有适合科研，也不是每个人有强于研发；职务无分高贱，只有适合与否；人和人之间所需的是互相尊重，而不是相互攀比。创造非对称是要有一定决心的，它在带来机遇的同时也滋生了风险，不过人不能因为害怕风险而选择平庸；不能因为畏惧失败而甘愿放弃；不能因为路途艰辛而畏首畏尾；更不能因为前途的不确定而选择逃避。我们要的只是适合自己的道路，要的是决心、勇气、和坚持。

大三下

2007-03-17T16:53:00.001+08:00

开学三周。
还是这么过，游戏打得太多了，颓废，想想也没啥好玩的，就是一遍遍重复呗，说到底也没啥变化，为啥有时候就会想玩呢？
以后做什么能，有时也会想这问题，但想法总是变，就像Dota中的变形精灵，力量或敏捷。
力量--敏捷，可能这也是现在摆在面前的路。
力量型的血会多些，譬如考研，死不了，不过移动慢些，攻击力低些。敏捷型的血少，但快，灵动，不过一次次的死就难翻身了。
Or智力加敏捷？
四年内就能知道我是否走对了路，三十岁前，不怕，三十岁后，不悔。

比较郁闷的事

2007-02-28T11:23:00.001+08:00

头疼,快一个星期看不了书了,原本考GRE还是有那么点希望的,这下开心了,反正没啥希望了,不过考还是要考的,不然也对不起我考证狂的封号啊。
原先就是小小的头疼，平时也有过，一会儿就能好的，可那天被词有点狂，小头疼变成了剧头疼，就睡了一下午的觉，老妈十分地不放心，我就捉摸着可能是这两天在床上看书，是不是脖子拧了，没想这么一想，脖子果然开始不爽，而且又是活络油又是理疗的，一点不见好。隔天和女朋友约会，在香肩上枕了一会，倒不疼了，可老妈不放心，第二天就去医院看了看，专家门诊，专家看了会，问我又没鼻炎啥的，一串问题，俺没啥啊，应该也就是脖子拧着了，回家呆会就好了。又过了一天，鼻子好像又有点不舒服了，莫非是专家所说的鼻炎？靠，这次这么都是倒果为因了？不想了，再想下去估计我就得感冒了，这心里想啥就得啥啊？
今天不管了，不管怎样也得看书了，整整看了四天电视，这心里难受得，还是背单词爽，就看书喽，不过好像一看就不怎么头疼了，又一次验证了那句话啊，死猪不怕开水烫，我的哲学啊，咋就忘了呢，再苦再累，就当自己是二百五，多愁善感，疑神疑鬼，会越来越糟。假期过得差不多了，进了学院得好好干，快毕业了，不爽，不爽。

简单

2007-02-13T16:30:00.002+08:00

将来要有个温馨的家，小点就行，但一定要精致，特别是厨房和卫生间，一定要十分的雅致才好，其他的呢，我只要一个大大的书桌，平平整整，没有抽屉的那种。有时候比较极端，不喜欢房间里又有床又有桌又有柜，我现在的房间就只有一张桌子，挺长，从一头做到了另一头，还有一张铁架床，仅此而已。就像用手机，觉得买个能拍照的手机不如买一个最土的只能打电话和发短信的手机再加上一个数码相机。复杂是魔鬼，keep it simple and stupid!这不但是写程序的教条，也是我的生活态度。
简单到极致，就是美。人也如此，很难同时扮演很多角色，太累。人要能像个CUP就简单了，分时，并发而不是并行，一个时间片就做一件事情，忘记其他。做每件事情都花上自己全部力气。觉得学计算机是最浪漫也是最死板的，浪漫时能把程序当人看，怎么看怎么爽，死板的时候将生活看成操作系统的调度，循规蹈矩，甚至早上出门前将一天的行走路线都作最佳分析。
今天同学聚会，到了一半人，看大家都很开心，也都过得不错，很为我们开心。