CodeConer

lighttpd.conf

2010-12-23T06:48:00.001-08:00

避免哪天又误删了conf文件，特bakup一份

debian:/home/tom# cat /etc/lighttpd/lighttpd.conf
server.document-root = "/home/tom/www"
server.port = 80
server.username = "tom"
server.groupname = "tom"
server.bind = "localhost"
server.tag ="lighttpd"

server.errorlog = "/home/tom/www/log/error.log"
accesslog.filename = "/home/tom/www/log/access.log"

server.modules = (
"mod_access",
"mod_accesslog",
"mod_fastcgi",
"mod_rewrite",
"mod_auth",
"mod_compress"
)

# mimetype mapping
mimetype.assign = (
".pdf" => "application/pdf",
".sig" => "application/pgp-signature",
".spl" => "application/futuresplash",
".class" => "application/octet-stream",
".ps" => "application/postscript",
".torrent" => "application/x-bittorrent",
".dvi" => "application/x-dvi",
".gz" => "application/x-gzip",
".pac" => "application/x-ns-proxy-autoconfig",
".swf" => "application/x-shockwave-flash",
".tar.gz" => "application/x-tgz",
".tgz" => "application/x-tgz",
".tar" => "application/x-tar",
".zip" => "application/zip",
".mp3" => "audio/mpeg",
".m3u" => "audio/x-mpegurl",
".wma" => "audio/x-ms-wma",
".wax" => "audio/x-ms-wax",
".ogg" => "audio/x-wav",
".wav" => "audio/x-wav",
".gif" => "image/gif",
".jpg" => "image/jpeg",
".jpeg" => "image/jpeg",
".png" => "image/png",
".xbm" => "image/x-xbitmap",
".xpm" => "image/x-xpixmap",
".xwd" => "image/x-xwindowdump",
".css" => "text/css",
".html" => "text/html",
".htm" => "text/html",
".js" => "text/javascript",
".asc" => "text/plain",
".c" => "text/plain",
".conf" => "text/plain",
".text" => "text/plain",
".txt" => "text/plain",
".dtd" => "text/xml",
".xml" => "text/xml",
".mpeg" => "video/mpeg",
".mpg" => "video/mpeg",
".mov" => "video/quicktime",
".qt" => "video/quicktime",
".avi" => "video/x-msvideo",
".asf" => "video/x-ms-asf",
".asx" => "video/x-ms-asf",
".wmv" => "video/x-ms-wmv",
".bz2" => "application/x-bzip",
".tbz" => "application/x-bzip-compressed-tar",
".tar.bz2" => "application/x-bzip-compressed-tar"
)

fastcgi.server=(".php"=>
("localhost"=>
(
"bin-path"=>"/usr/bin/php5-cgi",
"socket"=>"/tmp/php.socket"
)
)
)

index-file.names = ( "index.html", "index.php" )

Uninstall oracle easy from linux

2010-12-21T00:04:00.001-08:00

It sure is easier to remove oracle products than to add them....

The method suggested, using Oracle Universal installer to remove the
product, is the safest method, and the only reliable means if you have
several different ORACLE-HOMEs on you server.

However, if you want to remove all oracle software from your server,
the following method will work:
1. Stop all oracle processes (shutdown, kill or reboot - you are goeng
to ditch the installation anyway)
2. Remove the $ORACLE_HOME(s) using rm -rf
3. Check the file /etc/oraInst.loc and remove the oraInventory
directory structure.
3. Remove the files that remain scattered around your system:
/etc/oraInst.loc
/etc/oratab
/var/tmp/.oracle (directory)
/usr/local/bin/coraenv
/usr/local/bin/dbhome
/usr/local/bin/oraenv

If you remove these files, you will have a fresh system, in an Oracle
point of view.
Regards Lars

NTT DATA开源系列 - Maskat

2010-11-22T07:16:00.000-08:00

主站 http://maskat.sourceforge.jp

Maskat是NTT DATA针对富客户端Ajax做的一套综合开发环境，属于NTT DATA Group Open Source Square系列。
主要由三个主要部分组成：

客户端JavaScript框架
服务端Terasoluna for Rich版（参见NTT DATA开源系列 - Terasoluna）
Maskat IDE for Eclipse

以上内容的Source、例子和文档（日文）均可从顶端的URL地址下载到。
由于客户端的JS框架与服务端以XML方式交互，所以服务端可以选用任意开发语言，比如官网给出的PHP、Ruby等
优点：

JavaScript框架部分可根据需要灵活的将Google/Dojo等JS框架以插件部分注入进来，扩展性极强，还很美观哦；
服务端借助Terasoluna的成熟框架体系，达到开发效率和质量的双重保障；
在IDE的帮助下，可由需求和UE人员直接生产出HTML样式及Layout定义，开发者只要配合Event定义及服务端开发即可完成项目，优化并缩短开发流程；
避免写大量JS，降低学习成本，降低Bug发生几率，缩短开发时间
更多内容，试了就知道 :-)

运行原理

画面自动生成 - 客户端首次访问页面时，加载静态资源文件HTML、布局及事件定义XML，通过maskat的js框架在客户端构建UI元素
Event事件管理 - 用户触发事件，根据事件定义XML中的配置，进行本地js或远程服务器调用；根据XML所配置，将画面相应数据元素发往服务端
服务端根据接收到请求信息，使用Castor将XML映射成JavaBean做业务逻辑处理，并将结果同样以XML方式发回。（我已用Jackson做了个适配器，实现了JSON格式的收发 :-)
客户端的JS框架根据Event定义XML中的配置，将服务响应数据更新到页面指定元素

并且，客户端提供输入值有效性检查，远端调用时是否同步等设置。

Maskat应用的主要构成文件

Container HTML页面

<html>
  <head>
    <title>Maskat | 四则运算应用</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <script type="text/javascript" src="../../maskat/core/maskat.js"></script>
  </head>
  <body>
    <div id="divMaskat"></div>
  </body>
</html>

画面迁移定义XML

<?xml version="1.0" encoding="UTF-8"?>
<transitionDef>
  <init>
    <loadJS fileName="calculation" />
    <loadLayout xmlFile="layout.xml" target="divMaskat" show="true" />
  </init>
</transitionDef>

Layout定义文件

<?xml version="1.0" encoding="UTF-8"?>
<layoutDef>
  <layout name="calculation">
    <frame name="calculationFrame" left="12" top="24" width="577" height="157" title="四则运算应用">
      <text name="leftOperandText" left="23" top="23" width="85" tabIndex="1" datatype="N"/>
      <combo name="operatorCombo" left="119" top="23" width="50" tabIndex="2">
        <comboItem text="+" value="+"/>
        <comboItem text="-" value="-"/>
        <comboItem text="*" value="*"/>
        <comboItem text="/" value="/"/>
      </combo>
      <text name="rightOperandText" left="179" top="23" width="85" tabIndex="3" datatype="N"/>
      <label name="equalLabel" left="275" top="23" text="="/>
      <text name="resultText" left="299" top="23" width="85" tabIndex="4" datatype="N" disable="true"/>
      <button name="localCalculateButton" left="23" top="83" title="本地调用"/>
      <button name="remoteCalculateButton" left="23" top="107" title="远程调用"/>
    </frame>
  </layout>
</layoutDef>

Event定义XML

<?xml version="1.0" encoding="UTF-8"?>
<eventDef>
  <component id="localCalculateButton">
    <event id="onclick" finish="calculate" type="local"/>
  </component>
  <component id="remoteCalculateButton">
    <event id="onclick" remoteUrl="./calculate.php" async="false">
      <param rootNode="request">
        <source obj="leftOperandText" node="leftOperand" type="byte" desc="参数1"/>
        <source obj="rightOperandText" node="rightOperand" type="byte" desc="参数2"/>
        <source obj="operatorCombo" node="operator"/>
      </param>
      <result rootNode="response">
        <target out="resultText" in="result"/>
      </result>
    </event>
  </component>
</eventDef>

JavaScript文件

function calculate(){
 var left = Number(leftOperandText.getValue());
 var right = Number(rightOperandText.getValue());
 var result = NaN;

 switch (operatorCombo.getValue()) {
 case "+":
  result = left + right;
  break;
 case "-":
  result = left - right;
  break;
 case "*":
  result = left * right;
  break;
 case "/":
  result = left / right;
  break;
 }

 resultText.setValue(result);
}

这里有几个Demo http://maskat.sourceforge.jp/index.php?Demo
计算器
展示最基本原理，本地事件及远端事件调用
水果商店
展示复杂页面布局，列表，数据提交验证等
宠物商店
宠物商店应用的Maskat实现，展示富客户端的交互性
商店查询
展示使用插件机制注入GoogleMap的地图应用

关于更详细的内容，可以去官网下载Source和案例把玩一番
如果语言有障碍，记得Google翻译XD
Note: 示例中的Java案例使用的是Jaxb做的XML解析和绑定，并未使用Terasoluna for RICH。有关Terasoluna RICH内容，可参考地址http://sourceforge.jp/projects/terasoluna/releases/46867/

Coding Style

2010-11-16T07:22:00.000-08:00

前几日关于代码规范做的PPT，拿出来分享

MySQL和C编程

2010-11-14T07:24:00.000-08:00

tom@debian:~$ apt-get install mysql-server libmysqlclient15-dev
tom@debian:~$ mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 42
Server version: 5.0.51a-24+lenny4 (Debian)

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> create databases test;
mysql> grant all on test to test identified by 'test';
mysql> exit;
Bye

CREATE TABLE `test`.`user` (
  `id` int(11)  NOT NULL AUTO_INCREMENT,
  `name` varchar(20)  NOT NULL,
  `age` int  NOT NULL,
  PRIMARY KEY (`id`)
)
ENGINE = InnoDB;

mysql.c

#include <stdio.h>
#include <stdlib.h>
#include "mysql.h"

int main(void) {
 MYSQL *connection;
 int res;

 /*
  * MYSQL *mysql_init(MYSQL *);
  */
 connection = mysql_init(NULL);
 if (!connection) {
  fprintf(stderr, "mysql_init failed\n");
  exit(EXIT_FAILURE);
 }
 /*
  * MYSQL *mysql_real_connect(MYSQL *connection,
  * const char *server_hsot,
  * const char *sql_user_name,
  * const char *sql_password,
  * const char *db_name,
  * unsigned int port_number,
  * const char *unix_socket_name,
  * unsigned int flags);
  */
 connection = mysql_real_connect(connection, "localhost", "test", "test", "test", 0, NULL, 0);

 if (connection) {
  printf("connect success\n");
  /*
   * int mysql_query(MYSQL *connection,
   * const char *query);
   */
  res = mysql_query(connection, "INSERT INTO user(name, age) VALUES('Ada', 3)");
  if (!res) {
   /*
    * my_ulonglong mysql_affected_rows(MYSQL *connection);
    */
   printf("Insert %lu rows\n", (unsigned long) mysql_affected_rows(connection));
  } else {
   /*
    * unsigned int mysql_errno(MYSQL *connection);
    * char *mysql_error(MYSQL *connection);
    */
   fprintf(stderr, "Insert error %d: %s\n", mysql_errno(connection), mysql_error(connection));
  }
 } else {
  printf("connect failed\n");
 }

 /*
  * void mysql_close(MYSQL *connection);
  */
 mysql_close(connection);

 return EXIT_SUCCESS;
}

tom@debian:~/workspace/mysql/src$ gcc -I/usr/include/mysql -L/usr/lib/mysql -lmysqlclient mysql.c -o mysql
tom@debian:~/workspace/mysql/src$ ll
总计 16
-rwxr-xr-x 1 tom tom 8289 11-14 23:00 mysql
-rw-r--r-- 1 tom tom 1666 11-14 22:58 mysql.c
tom@debian:~/workspace/mysql/src$ ./mysql
connect success
Insert 1 rows
tom@debian:~/workspace/mysql/src$

构建移动应用的几个步骤

2010-11-10T20:37:00.000-08:00

1、功能定义
分析应用使用场景及目标，是游戏、播放器、编辑器、图像还是浏览器、网络？
根据分析特性，提取应用所涉及的数据内容、协议等数据模型；
现实的所有系统对于人类来说都是数据的I/O操作，所以，数据模型是所有系统的根本！比如，对于一款游戏来说，角色状态、游戏进度、地图数据；对于互联网应用来说，本地缓存、用户设定等数据；相册的缩微图、图片索引等等。

2、交互分析
UI布局及样式风格 - 即UE设计，交互设计师使用一些工具画界面。
屏幕交互及迁移 - 每个屏内部按键响应、背景服务状态分析，屏幕之间的相互叠加和迁移图等；
定义每个事件触发时所要进行的数据操作（保存哪些数据？修改哪些数据等等）
分出哪些是交互的、哪些是背景服务的、哪些是临时数据、哪些是持久化数据、网络交互定义、各组件的生命周期状态；

3、垒码实现
根据UI定义做layout，完成每一个屏的布局及屏内事件操作（一个MIDlet或Activity等）几个步骤，最后根据屏幕状态迁移时的数据操作（前人埋银后人挖）

4、测试及优化
保证每个功能是正确的；
保证每个事件的函数是正确的、高效的、快速响应的；
保证所用资源的最大化压缩；越精简越好，越刻薄越好；
发现问题时做修正或优化；
在多种目标平台测验；

5、打包发布
混淆发布、获取反馈并作为下一个期的目标定义。

Coding准则：基本不用接口与继承/尽量的final/手动设null甚至gc/把Java当C使.. 虽然source不怎么美观，一切为了效率、能耗，多试验、多拿捏.

-EOF

Android Application Architecture

2010-11-09T20:39:00.000-08:00

Android's architecture encourages the concept of component reuse, allowing you to publish and share activities, services, and data with other applications with access managed by the security restrictions you put in place. The following application services are the architectural cornerstones of all Android applications, providing the framework you’ll be using for your own software:
Activity Manager
Controls the life cycle of your activities, including management of the activity stack.
Views
Are used to construct the user interfaces for your activities
Notification Manager
Provides a consistent and non-intrusive mechanism for signaling your users
Content Providers
Lets your applications share data between applications
Resource Manager
Supports non-code resources like strings and graphics to be externalized.

Android System Architecture

Android Process

Main thread/handlers/messages

Android Activity Lifecycle

Android Audio Architecture

Power Manager Service

Unix philosophy

2010-11-08T20:39:00.000-08:00

1. Rule of Modularity: Write simple parts connected by clean interfaces.

2. Rule of Composition: Design programs to be connected to other programs.

3. Rule of Clarity: Clarity is better than cleverness.

4. Rule of Simplicity: Design for simplicity; add complexity only where you must.

5. Rule of Transparency: Design for visibility to make inspection and debugging easier.

6. Rule of Robustness: Robustness is the child of transparency and simplicity.

7. Rule of Least Surprise: In interface design, always do the least surprising thing.

8. Rule of Repair: When you must fail, fail noisily and as soon as possible.

9. Rule of Economy: Programmer time is expensive; conserve it in preference to machine time.

10. Rule of Generation: Avoid hand-hacking; write programs to write programs when you can.

11. Rule of Representation: Use smart data so program logic can be stupid and robust.

12. Rule of Separation: Separate policy from mechanism; separate interfaces from engines.

13. Rule of Optimization: Prototype before polishing. Get it working before you optimize it.

14. Rule of Diversity: Distrust all claims for "one true way"

15. Rule of Extensibility: Design for the future, because it will be here sooner than you think.

Writing a Simple File System

2010-11-05T20:40:00.000-07:00

Author: Ravi Kiran UVS

1. Objective
We will write a file system with very basic functionality. This is to understand the working of certain kernel code paths of the Virtual File System (VFS). This filesystem has only one file 'hello.txt'. We can read/write into it.
2. Introduction
The Linux VFS supports multiple file systems. The kernel does most of the work while the file system specific tasks are delegated to the individual file systems through the handlers. Instead of calling the functions directly the kernel uses various Operation Tables, which are a collection of handlers for each operation (these are actually structures of function pointers for each handlers/callbacks). The kernel calls the handler present in the table for the operation. This enables different file systems to register different handlers. This also enables the common tasks to be done before calling the handlers. This reduces the burden on the handlers which can then focus on the operation specific to that file system.
File systems are identified by their names. The supported file systems can be seen using 'cat /proc/filesystems'. The first step is to register the file system with the kernel. Since we are using a kernel module, the file system registration is done during the module initialization. This registers handlers which will be called to fill the super block structure while mounting, a handler to do the cleanup during unmounting the file system. There are other handlers but these two are essential.
The super block operations are set at the time of mounting. The operation tables for inodes and files are set when the inode is opened. The first step before opening an inode is lookup. The inode of a file is looked up by calling the lookup handler of the parent inode. But what about the root-most inode of the new file system? This has to be allocated at the time of mounting i.e., during the super block initialization.
Once the operation tables are set on the data structures, the kernel calls the handlers depending on the operation.
3. Data Structures
This is a brief description about the data structures used in implementing our file system.
a. File System Type (struct file_system_type)
Definition found in include/linux/fs.h
This structure is used to register the filesystem with the kernel. This data structure is used by the kernel at the time of mounting a file system. We have to fill the 'name' field with the name of our file system (example "rkfs") and the handlers get_sb and kill_sb to allocate and release the super block objects.
b. Super Block (struct super_block)
Definition found in include/linux/fs.h
This stores the information about the mounted file system. The important fields to be filled are the operation table (s_ops field) and the root dentry (s_root). At the time of mounting a file system, the kernel calls the get_sb field of the file_system_type object (it identifies the correct file_system_type object based on the file system name) to get a super block object.
c. Super Block Operations (struct super_operations)
Definition found in include/linux/fs.h
Super block operations table.
d. Inode (struct inode)
Definition found in include/linux/fs.h
Inode object is the kernel representation of the low level file. We return the dentry of the root of our file system. We have to attach a proper inode also to the dentry.
This structure has two operation tables i_op, i_fop i.e., inode operations and file operations respectively. We will implement one operation in the inode_operations - lookup.
This is called when the kernel is resolving a path. The kernel starts from the ancestor (this can be the current working directory for relative paths or the root most directory for the absolute paths) and gets the dentry (also the inode) of a name component of the path from its parent. This is achieved by calling inode_operations.lookup on the inode of the parent entry.
For example, when the kernel is resolving /parentdir/subdir, the lookup operation reaches the root most inode of the file system. This was already allocated during the super block initialization and stored in the s_root field. To resolve the 'parentdir' under the root most inode, the kernel creates a new dentry object, sets the name as 'parentdir' and calls lookup handler on inode of the root most inode. The handler is supposed to attach the inode to the dentry using d_add and return NULL if it was successful or an error code otherwise. Similarly, the lookup for 'subdir' is done by the parentdir inode. The dentry cache and the inode cache saves repeated lookups and boosts the performance.
It is important for us to implement the lookup callback. This will be called by the open system call.
e. Inode Operations (struct inode_operations)
Definition found in include/linux/fs.h
This is the inode operations table with each field corresponding to a function pointer to handle the task. It has fields like mkdir, lookup etc. We are interested in lookup.
f. Address Space Operations (struct address_space_operations)
Definition found in include/linux/fs.h
Address space operations table.
g. DEntry (struct dentry)
Definition found in include/linux/dcache.h
The kernel uses dentries to represent the file system structure. dentries point to inode objects. This has pointers to store the parent-child relationship of the files. Inodes and files do not store any information about the hierarchy.
h. File (struct file)
Definition found in include/linux/fs.h
File object is used to store the process's information about the file. We dont have to fill any fields of the files directly. The kernel takes care of filling the proper fields but we have to implement the file operation callbacks. We register the file operation table when we return the inode object during lookup. The file operations are copied from the i_fop field of the inode object to the file object by the kernel.
We will implement readdir in case of directories (while returning the inode, we have to set the file operation table based on the type of the file) and read/write in the case of regular files. We will have two file operation tables one for directories and the other for regular files.
The relationship between files, dentries and objects is like this:

File ---> DEntry ---> Inode

The following figure shows the important relationships between various VFS data structures. It does not show all the relationships though. Note that super block structure has a list of all open file objects, a list of dirty inodes and another list of locked inodes of the file system. Also the lists used for cache, lru and free lists are not shown.

i. File Operations (struct file_operations)
Definition found in include/linux/fs.h
This is the file operations table with each field corresponding to a function pointer to handle the task. It has fields like read, write, readdir, llseek etc.
All these structures have fields used by the kernel in maintaining internal data structures like lists and hash tables etc. So, we cannot use local/global obects. Kernel allocates the object and passes it to our functions so that we can fill the required fields. If we have to allocate the objects, we need to use the corresponding allocator functions.
3. Implementation
File System Type
The filesystem is registered with the kernel during the module initialization. During this step, two handlers get_sb and kill_sb. get_sb is called at the time of mounting the file system. kill_sb is called at the time of unmounting the file system. The get_sb handler uses the kernel helper function get_sb_single to allocate the super block. We pass a callback, rkfs_fill_super, to this function which will be called to fill the super block structure. Since we dont have any specific task to do in the the kill_sb handler, we can use the kernel helper function kill_anon_super.
Super Block Operations
We'll register the read_inode and write_inode callbacks in the super operations table. read_inode will be called when the inode object is newly allocated. Inodes are identified by the inode numbers. Based on the inode number, the file system will have to resolve the inode object on the storage and fill the fields of the inode with the contents on the storage. In our case it is simple as we are implementing a memory based file system. File systems like ext2 will have to read the inode from the disk using the inode number. Depending on the file type, different handlers can be registered for the file operations table.
write_inode handler will be called to sync the inode contents to the storage. In our case, we will update the file size variable in memory.
Inode Operations
We'll register the lookup callback in the inode operations table. A dentry object will be allocated by the kernel and passed to the handler. The name component is set on the dentry by the kernel. In the handler, we have to check whether an entry by that name exists under the parent inode. If an entry exists, the inode object is obtained by passing the super block object and the inode number to the function iget. This uses the inode cache and will allocate a new inode if it is not avaiable in the inode cache. (Note that when the inode is newly allocated, the read_inode handler of the super block is called to fill the inode). This inode is added to the dentry object using d_add. The return value should be a NULL on successful lookup or an error code otherwise.
File Operations
We'll register read, write and readdir handlers in the file operations table. read and write handlers are called to read and write data into the file. readdir is called to read the contents of a directory.
The following table shows the fields we need to fill in the above data structures.

The following table shows the operation tables and the handlers used.

4. Entry points
a. init_module
This is called when the module is loaded. We have to register our file system here. Fill the file_system_type strucure with name and read_super fields and call register_filesystem with the structure. For example,

static struct file_system_type rkfs = {
    name:    "rkfs",
    get_sb:  rkfs_get_sb,
    kill_sb:   rkfs_kill_sb,
    owner:   THIS_MODULE
};

int init_module(void) {
    int err;
    err = register_filesystem( &rkfs );
    return err;
}

b. file_system_type.get_sb
This will be called when the file system is mounted. We have to return a super block. We use the helper function get_sb_simple to do the super block allocation and also passing rkfs_fill_super callback to fill the super block object. The s_op field is set with the address of the super block operations table rkfs_sops. The root most inode of the file system has to be allocated at this stage. The dentry for it should be set on the s_root field of the super block. As mentioned earlier, this is the entry point of lookup operations into the file system.
The inode object is allocated using the function iget. After initializing the inode, the dentry is allocated using the function d_alloc_root. This dentry is set to the s_root field of the super block.

static int rkfs_fill_super(struct super_block *sb, void *data, int silent) {
    sb->s_blocksize = 1024;
    sb->s_blocksize_bits = 10;
    sb->s_magic = RKFS_MAGIC;
    sb->s_op = &rkfs_sops; // super block operations
    sb->s_type = &rkfs; // file_system_type

    rkfs_root_inode = iget(sb, 1); // allocate an inode
    rkfs_root_inode->i_op = &rkfs_iops; // set the inode ops
    rkfs_root_inode->i_mode = S_IFDIR|S_IRWXU;
    rkfs_root_inode->i_fop = &rkfs_fops;

    if(!(sb->s_root = d_alloc_root(rkfs_root_inode))) {
        iput(rkfs_root_inode);
        return -ENOMEM;
    }

    return 0;
}

static struct super_block * rkfs_get_sb(struct file_system_type *fs_type, int flags, const char *devname, void *data) {
     /* rkfs_fill_super this will be called to fill the superblock */
    return get_sb_single(fs_type, flags, data, &rkfs_fill_super);
}

Let us assume that our file system is mounted under /mnt/rkfs.
c. file_system_type.kill_sb
This is called at the time of unmounting the file system. We use the helper function kill_anon_super for this.
d. super_operations.read_inode
Inodes objects should be allocated using the iget function. This uses the inode cache, adjusts the relationships of the inode with various data structures, updates the count etc. If the inode is not cached, it allocates a new inode and calls the read_inode handler of the super block if present. Inodes are identified by the inode numbers. The handler is expected to initialize the inode with the contents of the inode on the backend.
e. super_operations.write_inode
This will be called when the dirty inodes are flushed. The handler has to sync the inode contents to the backend.
f. inode_operations.lookup
This will be called when the kernel is resolving a path. The lookup handler of the inode operation table of the parent inode is called to resolve a child. Remember that the dentry for the root most inode is already available in s_root field of the super block.
For example, after mounting the file system under '/mnt/rkfs' if we want to see the contents using 'ls /mnt/rkfs', the kernel has to create a file object for the inode '/mnt/rkfs'. The kernel will create a file object with the dentry of the root most inode of the file system. For the command 'ls -l /mnt/rkfs/hello.txt', the kernel name lookup reaches the root most inode and the lookup handler will be called to set the inode of 'hello.txt'. The kernel allocates the dentry object and passes to the handler. If an inode exists for the name component, the inode has to be added to the dentry using d_add and NULL should be returned. If there is some problem, a suitable error code has to be returned.

static struct dentry *rkfs_inode_lookup(struct inode *parent_inode, struct dentry *dentry, struct nameidata *nameidata) {
    struct inode *file_inode;
    if(parent_inode->i_ino != rkfs_root_inode->i_ino)
        return ERR_PTR(-ENOENT);
    if(dentry->d_name.len != strlen("hello.txt") ||
       strncmp(dentry->d_name.name, "hello.txt", dentry->d_name.len))
      return ERR_PTR(-ENOENT);

    file_inode = iget(parent_inode->i_sb, FILE_INODE_NUMBER);
    if(!file_inode)
        return ERR_PTR(-EACCES);
    file_inode->i_size = file_size;
    file_inode->i_mode = S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
    file_inode->i_fop = &rkfs_fops;
    //  file_inode->i_fop
    d_add(dentry, file_inode);
    return NULL;
}

g. file_operations.readdir
This will be called when the kernel wants to read the contents of a directory. The readdir handler of the file operations table of the file will be called to show the contents of the directory. The kernel passes the file object, the dirent structure and a callback to fill the dirent structure with the values of the contents of the directory. The values are added to the dirent structure using the 'filldir' callback. Since we support one hardcoded file 'hello.txt', we just have to return the values, '.', '..' and 'hello.txt'. File systems like ext2 will have to fetch the contents from the disk.

int rkfs_f_readdir( struct file *file, void *dirent, filldir_t filldir ) {
    int err;
    struct dentry *de = file->f_dentry;

    printk( "rkfs: file_operations.readdir called\n" );
    if(file->f_pos > 0 )
        return 1;
    if(filldir(dirent, ".", 1, file->f_pos++, de->d_inode->i_ino, DT_DIR)||
       (filldir(dirent, "..", 2, file->f_pos++, de->d_parent->d_inode->i_ino, DT_DIR)))
        return 0;
    if(filldir(dirent, "hello.txt", 9, file->f_pos++, FILE_INODE_NUMBER, DT_REG ))
        return 0;
    return 1;
}

In our file system, we are supporting only one file i.e., hello.txt. So, the result of 'ls /mnt/rkfs' will be
. .. hello.txt
h. file_operations.read
This will be called when the kernel gets a read request for a file in our file system. The file object of the file to be read, the user-space buffer address, the maximum size of the buffer and the address of the offset (which contains the current offset and which has to be updated after successful read operation) are passed. The contents of the file have to be written to the buffer. Note that this is in the user-space. The data is copied to the user-space buffer using the function copy_to_user.
There are two ways of supporting this operation. One way is to provide a read handler which writes the data to the buffer. But the drawback is that we cannot take advantage of the page cache. Files can also be read/written using the mmap (memory mapping). With this approach, we cannot support the mmap way of accessing the file (or it is very difficult to provide transparency i.e., file written after mapping and read with 'read' system call).
The second way is to provide a unified way to read/write to the file for both the approaches i.e., calling the system calls directly or by mapping the file and reading/writing the contents in memory). This takes the advantage of page cache also. This is applicable to the write operation also.
Let us take the second approach (the code for the first approach is also provided later). The approach is slightly different in this case. The contents of an inode are seen as chunks of pages and represented by addess_space object. This 'mapping' between the inode and the address space object is stored in the i_mapping field of the inode. To read some data from the page, the corresponding chunks/pages which holds the data are loaded into memory.
Address Space Operations table is used to perform different operations on the address space object (a_ops field). The readpage handler of the table is used to read the contents of a page of the inode into memory. For example, if the page size is 4096, the data from 5000 to 6000 bytes is present in the 2nd page of the inode (similarly, the data from 4000 to 5000 is present in the pages 1 and 2).
Since the actual work of reading the data is moved to address_space_operations.readpage handler, we can use the generic_file_read helper function as the read handler. This function get the pages of the data and copies to the user-space buffer. If the pages are not in the cache, it waits till the pages are loaded with the data using the 'readpage' handler.
i. address_space_operations.readpage
The readpage handler has to fill the page with the contents of the inode. The index of the page is obtained from the 'index' field of the page structure.

static int rkfs_readpage(struct file *file, struct page *page) {
    printk("RKFS: readpage called for page index=[%d]\n", (int)page->index);
    if(page->index > 0) {
        return -ENOSPC;
    }

    SetPageUptodate(page);
    memcpy(page_address(page), file_buf, PAGE_SIZE);
    if(PageLocked(page))
        unlock_page(page);
    return 0;
}

j. file_operations.write
We register generic_file_write as the write handler. This allocates pages and calls prepare_write handler on the address space object so that buffer head objects can be allocated for the page to perform the I/O to the device later. It copies the data from the user-space to the pages and calls commit_write on the address space object.
File systems like ext2 generally have a specific implementation of prepare_write. The allocation of buffer head objects for the write operation will be same for most of the file systems except for the location of the buffer heads (buffer head is the kernel's copy of a disk block). In this case, they use the helper/wrapper function block_prepare_write and passing a callback (in case of ext2, it is ext2_get_block) which will give the block number for the file offset.
Since writing the buffers associated with the pages to the device is similar to most of the file systems, they normally use generic_commit_write helper function. This marks the buffer as dirty so that it will be flushed later to the device by the block device layer.
This writes the data from user-space to the pages. The pages are synced later. Note that the read/write happens on the cached pages.
k. address_space_operations.commit_write
The generic_commit_write helper function sets up the buffers to be written to the disk. Since we are not using any device, this has been modified to write into the memory buffer of the file.

static int rkfs_commit_write(struct file *file, struct page *page,
             unsigned from, unsigned to) {
    struct inode *inode = page->mapping->host;
    loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;

   if(page->index == 0) {
        memcpy(file_buf, page_address(page), PAGE_SIZE);
        ClearPageDirty(page);
    }

    /*
     * No need to use i_size_read() here, the i_size
     * cannot change under us because we hold i_sem.
     */
    if (pos > inode->i_size) {
        i_size_write(inode, pos);
        mark_inode_dirty(inode);
    }
    SetPageUptodate(page);
    return 0;
}

l. address_space_operations.writepage
This will be called when the dirty pages are flushed.

static int rkfs_writepage(struct page *page, struct writeback_control *wbc) {
    printk("[RKFS] offset = %d\n", (int)page->index);
    memcpy(file_buf, page_address(page), PAGE_SIZE);
    ClearPageDirty(page);
    if(PageLocked(page))
      unlock_page(page);
    return 0;
}

m. cleanup_module
This will be called when the module is removed. We have to unregister our file system at this point. The module count will be incremented and decremented by the file system calls. So the module will not be removed if the module use count is not zero. The kernel takes care of this, so we need not do anything to check if our file system is in use.
5. code
Note: this has some debugging messages... you can remove all the 'printk's.
6. Instructions to use the code
This code works on the 2.6 kernels. I haven't tested it on 2.4 kernels.
Compile using the 2.6 build system. Create a Makefile like this: (or you can download the code here)

ifneq (${KERNELRELEASE},)
obj-m += rkfs.o
else
KERNEL_SOURCE := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)

default:
$(MAKE) -C ${KERNEL_SOURCE} SUBDIRS=$(PWD) modules
clean :
rm *.o *.ko
endif

make
This generates a file rkfs.o. Load the module as root using
insmod rkfs.ko
Mount the file system using
mount -t rkfs none /mnt/rkfs
Unmount using
umount /mnt/rkfs
Unload the module using
rmmod rkfs

Note:
There have been some changes to the file system API recently (i'm not sure from which version exactly... i'm trying to figure out but i'd be glad if somebody can point it to me). The generic_file_read and generic_file_write have are not available any more. The same task is achieved by using do_sync_read and do_sync_write which uses the async i/o handlers. The modified code can be found here.

hellofs - a small, extremely limited filesystem in less than 100 lines of C code
FUSE - a fully functional filesystem in a userspace program.
《UNIX filesystems:evolution, design, and implementation》

Advanced Linux Programming 5

2010-10-31T20:42:00.000-07:00

5 types of interprocess communication

Shared memory permits processes to communicate by simply reading and writing to a specified memory location.
Mapped memory is similar to shared memory, except that it is associated with a file in the filesystem.
Pipes permit sequential communication from one process to a related process.
FIFOs are similar to pipes, except that unrelated processes can communicate, because the pipe is given a name in the filesystem.
Sockets support communication between unrelated processes even on different computers.

Shared memory - Fast local communication

#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <sys/stat.h>

int main(void) {
 int segment_id;
 char* shared_memory;
 struct shmid_ds shmbuf;
 size_t segment_size;
 const int shared_seg_size = 0x6400;

 /** Allocate */
 segment_id = shmget(IPC_PRIVATE, shared_seg_size, IPC_CREAT|IPC_EXCL|S_IRUSR|S_IWUSR);

 /** Attach */
 shared_memory = (char*) shmat(segment_id, 0, 0);
 printf("Shared memory address: %p\n", shared_memory);
 /** Determine size. */
 shmctl(segment_id, IPC_STAT, &shmbuf);
 segment_size = shmbuf.shm_segsz;
 printf("Shared memory size: %d\n", segment_size);
 /** Write data to shared memory */
 sprintf(shared_memory, "Hello, Shared memory!");
 /** Detach */
 shmdt(shared_memory);

 /** Reattach shared memory at a different address. */
 shared_memory = (char*) shmat(segment_id, (void*)0x5000000, 0);
 printf("Shared memory address: %p\n", shared_memory);
 printf("Read data: %s\n", shared_memory);
 shmdt(shared_memory);

 /** Dellocate */
 shmctl(segment_id, IPC_RMID, 0);

 return 0;
}

Mapped Memory - Fast access to files

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>

#define FILE_LENGTH 0x100

void mmap_write(const char* file_name, const size_t size, void* data) {

 int fd;
 void* file_memory;

 /** Prepare a file */
 fd = open(file_name, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR);
 lseek(fd, size+1,SEEK_SET);
 write(fd, "", 1);
 lseek(fd, 0, SEEK_SET);

 /** Create memory mapping. */
 file_memory = mmap(0, size, PROT_WRITE, MAP_SHARED, fd, 0);
 close(fd);
 /** Write data */
 sprintf((char*) file_memory, "%s\n", (char*) data);
 /** Release the memory */
 munmap(file_memory, size);
}

void mmap_read(const char* file_name, const size_t size) {

 int fd;
 void* file_memory;
 char buffer[size];

 /** Prepare a file */
 fd = open(file_name, O_RDWR, S_IRUSR|S_IWUSR);

 /** Create memory mapping. */
 file_memory = mmap(0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 close(fd);
 /** Output to console */
 sprintf(buffer, "%s", (char*)file_memory);
 printf(buffer);
 /** Release the memory */
 munmap(file_memory, size);
}

/** Just a test */
int main(int argc, char* argv[]) {

 mmap_write(argv[1], FILE_LENGTH, argv[2]);
 mmap_read(argv[1], FILE_LENGTH);

 return 0;
}

tom@debian:~/workspace/adl/Debug$ ./adl t.txt SomethingReallyFun
SomethingReallyFun
tom@debian:~/workspace/adl/Debug$ cat t.txt
SomethingReallyFun

tom@debian:~/workspace/adl/Debug$

Pipes - unidirectional communication device and automatically synchronize

int pipe_fds[2];
int read_fd;
int write_fd;
pipe (pipe_fds);
read_fd = pipe_fds[0];
write_fd = pipe_fds[1];

NTT DATA开源系列 - Terasoluna

2010-10-31T20:41:00.000-07:00

开源主站: NTT DATA Group Open Source Software Square

Terasoluna
基于对Spring/Struts/iBatis之类开源框架的包装和改造，将针对业务的开发接口完全规范化，业务之间的数据及关系可配置。V2已开源，内部用V4。
主要构成部分为：

Batch Framework for Java
Server Client Framwork for .NET
Server Framework for Java RICH

Maskat

Server Framework for Java WEB

另有基于eclipse的开发工具Terasoluna IDE及部分基于Selenium的自动化测试框架及品质收集工具。
最终结果是：开发人员只面向针对每个业务的BLogic(如SpringMVC中的Controller一样的体验，类Command模式)；而数据交互格式、绑定规则、业务模块关系、验证规则等内容全部由具体的xml进行配置。

The MINIX 3 Microkernel Architecture

2010-10-25T20:42:00.000-07:00

内核(kernel)最低层进行进程调度，并负责进程的就绪态、运行态和阻塞态间的转换。内核还负责处理所有进程间的消息。消息处理需要核实目标的合法性，定位内存中的发送和接受缓存，把消息从发送缓存复制到接受缓存。内核的令一部分支持对I/O端口和中断访问，现代处理器中这需要使用特权内核模式(kernel mode)指令，这些指令在用户进程中是没有的。
第一层主要功能是为上层驱动程序和服务器提供一组特权内核调用。这包括读写I/O端口、跨地址空间复制数据等。这些调用有系统任务(system task)实现。
内核以上的三层可视为一层，因为内核从根本上同样对待他们。每一层只限于使用用户模式(user mode)指令。
第二层主要由设备驱动程序组成，驱动程序可能发出其他内核调用。
第三层包含了服务器，即向用户进程提供有用服务的进程。两个必要的服务器：进程管理器(Process Manager)执行所有涉及启动和终止进程的系统调用 fork, exec, wait, alarm, kill, brk...；文件系统(File System)负责执行文件系统的调用 read, mount, chdir.. 此外还有Information Server、Reincarnation Server、Network Server等。服务器不直接进行I/O操作，而是通过驱动程序来请求I/O。
内核调用是由系统服务提供的以使驱动程序和服务器完成工作的底层函数，如读硬件I/O端口。而，POSIX系统调用是由POSIX规范定义的高层调用，以供第四层的用户程序使用。用户程序包含了许多POSIX调用，但不包含内核调用。

When to draw diagrams, and when to stop.

2010-10-21T20:44:00.000-07:00

Don’t make a rule that everything must be diagrammed. Such rules are worse than useless. Enormous amounts of project time and energy can be wasted in pursuit of diagrams that no one will ever read.

When to draw diagrams:

Draw diagrams when several people need to understand the structure of a particular part of the design because they are all going to be working on it simultaneously. Stop when everyone agrees that they understand.
Draw diagrams when two or more people disagree on how a particular element should be designed, and you want team consensus. Put the discussion into a timebox choose a means for deciding, like a vote, or an impartial judge. Stop at the end of the timebox, or when the decision can be made. Then erase the diagram.
Draw diagrams when you just want to play with a design idea, and the diagrams can help you think it through. Stop when you’ve gotten to the point that you can finish your thinking in code. Discard the diagrams.
Draw diagrams when you need to explain the structure of some part of the code to someone else, or to yourself. Stop when the explanation would be better done by looking at code.
Draw diagrams when it’s close to the end of the project and your customer has requested them as part of a documentation stream for others.

When not to draw diagrams:

Don’t draw diagrams because the process tells you to.
Don’t draw diagrams because you feel guilty not drawing them or because you think that’s what good designers do. Good designers write code and draw diagrams only when necessary.
Don’t draw diagrams to create comprehensive documetation of the design phase prior to coding. Such documents are almost never worth anything and consume immense amounts of time.
Don’t draw diagrams for other people to code. True software architects participate in the coding of their designs, so that they can lay in the bed they have made.

Think in framework

2010-10-21T20:43:00.000-07:00

几日前，关于框架化程序设计做的PPT，也算是对过去做的几个框架后的认识和部分总结，拿出来分享

Cloud era - Hello, Pro Hadoop

2010-10-19T20:44:00.000-07:00

1. Map Reduce Mode

2. Web Crawler Samples

Ingest the URLs and their associated metadata.
Normalize the URLs.
Eliminate duplicate URLs.
Filter the URLs against a set of exclusion and inclusion filters.
Filter the URLs against a do not fetch list.
Filter the URLs against a recently seen set.
Fetch the URLs.
Fingerprint the content items.
Update the recently seen set.
Prepare the work list for the next application.

3. Web Crawler Samples In Hadoop Arch

4. Map Reduce Framework Need to Know

The location(s) in the distributed file system of the job input
The location(s) in the distributed file system for the job output
The input format
The output format
The class containing the map function
Optionally. the class containing the reduce function
The JAR file(s) containing the map and reduce functions and any support classes

5. Hadoop Examples

Advanced Linux Programming 4

2010-10-16T20:45:00.000-07:00

Thread
The pthread_create function creates a new thread.You provide it with the following:

A pointer to a pthread_t variable, in which the thread ID of the new thread is stored.
A pointer to a thread attribute object.This object controls details of how the thread interacts with the rest of the program. If you pass NULL as the thread attribute, a thread will be created with the default thread attributes
A pointer to the thread function.This is an ordinary function pointer, of this type:void* (*) (void*)
A thread argument value of type void*. Whatever you pass is simply passed as the argument to the thread function when the thread begins executing.

#include <pthread.h>
#include <stdio.h>

/** Print 'x' to stderr. */
void* print_xs(void* unused)
{
    while(1)
    {
        fputc('A', stderr);
    }
    return NULL;
}

/** Main program. */
int main()
{
    pthread_t thread_id;
    pthread_create(&thread_id, NULL, &print_xs, NULL);

    while(1)
    {
        fputc('B', stderr);
    }

    return 0;
}

That function is pthread_join, which takes two arguments: the thread ID of the thread to wait for, and a pointer to a void* variable that will receive the finished thread’s return value. If you don’t care about the thread return value, pass NULL as the second argument.

Advanced Linux Programming 3

2010-10-14T20:45:00.000-07:00

Process
1, Looking at his eyes
print-pid.c

#include <stdio.h>
#include <unistd.h>

int main()
{
 printf("Process ID: %d\n", getpid());
 printf("Parent PID: %d\n", getppid());

 return 0;
}

2, Ways to Roman and Creating Process

Using system

#include <stdlib.h>
int system(const char *command);

Fork & exec families

Functions that contain the letter p in their names (execvp and execlp) accept a program name and search for a program by that name in the current execution path; functions that don’t contain the p must be given the full path of the program to be executed.
Functions that contain the letter v in their names (execv, execvp, and execve) accept the argument list for the new program as a NULL-terminated array of pointers to strings. Functions that contain the letter l (execl, execlp, and execle) accept the argument list using the C language’s varargs mechanism.
Functions that contain the letter e in their names (execve and execle) accept an additional argument, an array of environment variables.The argument should be a NULL-terminated array of pointers to character strings. Each character string should be of the form “VARIABLE=value”.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

/**
  Spawn a child process running a new program.
  PROGRAM  - the name of the program to run; path will be searched.
  ARG_LIST  - NULL-terminated list of character strings. */
int spawn(char* program, char** arg_list)
{
 pid_t child_pid;

 child_pid = fork();
 if(child_pid != 0) {
  return;
 } else {
  execvp(program, arg_list);
  /** The execvp function return only if an error occurs. */
  fprintf(stderr, "error occured in execvp\n");
  abort();
 }
}

int main()
{
 char* arg_list[] = {
  "ls", /* argv[0], the name of the program. */
  "-l",
  "/",
  NULL /* NULL-terminated. */
 };

 /**
   Spawn a child process running the "ls" command. */
 spawn("ls", arg_list);

 printf("main program done\n");

 return 0;
}

3, Mask signals, Do Never Wanna Kill Me!!
The sigaction function can be used to set a signal disposition.The first parameter is the signal number.The next two parameters are pointers to sigaction structures; the first of these contains the desired disposition for that signal number, while the second receives the previous disposition.The most important field in the first or second sigaction structure is sa_handler. It can take one of three values:

SIG_DFL, which specifies the default disposition for the signal.
SIG_IGN, which specifies that the signal should be ignored.
A pointer to a signal-handler function.The function should take one parameter, the signal number, and return void.

#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

sig_atomic_t signal_cnt = 0;

void handler(int signal_num)
{
 ++signal_cnt;
}

int main()
{
 struct sigaction sa;
 memset(&sa, 0, sizeof(sa));
 sa.sa_handler = &handler;
 sigaction(SIGTERM, &sa, NULL);

 /** Do some lengthy stuff here. */
 /** ... */
 printf("KILL me! KILL me!\n");
 sleep(60);

 printf("U want to KILL me %d times\n", signal_cnt);
 return 0;
}

tom@debian:~/project/linuxc/ch03$ ./signal
KILL me! KILL me!
U want to KILL me 0 times

tom@debian:~/project/linuxc/ch03$ ./signal
KILL me! KILL me!

Open another console and input:

tom@debian:~/project/linuxc/ch03$ ps -aux|grep signal
Warning: bad ps syntax, perhaps a bogus '-'? See http://procps.sf.net/faq.html
tom       3889  0.0  0.0   1616   328 pts/1    S+   22:11   0:00 ./signal
tom       3891  0.0  0.0   3328   716 pts/0    S+   22:11   0:00 grep signal
tom@debian:~/project/linuxc/ch03$ kill 3889

Then, recieved:

tom@debian:~/project/linuxc/ch03$ ./signal
KILL me! KILL me!
U want to KILL me 1 times
tom@debian:~/project/linuxc/ch03$

4, @Zombie Do U know I'm waiting?
A zombie process is a process that has terminated but has not been cleaned up yet. It is the responsibility of the parent process to clean up its zombie children.The wait functions do this, too, so it’s not necessary to track whether your child process is still executing before waiting for it. Suppose, for instance, that a program forks a child process, performs some other computations, and then calls wait. If the child process has not terminated at that point, the parent process will block in the wait call until the child process finishes. If the child process finishes before the parent process calls wait, the child process becomes a zombie.When the parent process calls wait, the zombie child’s termination status is extracted, the child process is deleted, and the wait call returns immediately.

#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
 pid_t child_pid;

 child_pid = fork();
 if(child_pid > 0) {
  /** Daddy sleep. */
  printf("Daddy sleeping\n");
  sleep(10);
  printf("Daddy wake up\n");
 } else {
  /** Child exit immediately. */
  printf("OK, I gone, daddy.\n");
  exit(0);
 }

 return 0;
}

tom@debian:~/project/linuxc/ch03$ ./zombie
tom@debian:~/project/linuxc/ch03$ ps -e -o pid,ppid,stat,cmd|grep zombie
 3785  3539 S+   ./zombie
 3786  3785 Z+   [zombie] <defunct>
 3788  3392 S+   grep zombie
tom@debian:~/project/linuxc/ch03$ ps -e -o pid,ppid,stat,cmd|grep zombie
 3790  3392 S+   grep zombie
tom@debian:~/project/linuxc/ch03$

#include <signal.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>

sig_atomic_t child_exit_status;

void clean_up_child_process(int signal_num)
{
 /** Clean up the child process. */
 int status;
 wait(&status);
 /* Store its exit status in a global variable. */
 child_exit_status = status;
}

int main()
{
 pid_t child_pid;
 struct sigaction sigchild_action;
 memset(&sigchild_action, 0, sizeof(sigchild_action));
 sigchild_action.sa_handler = &clean_up_child_process;
 sigaction(SIGCHLD, &sigchild_action, NULL);

 child_pid = fork();
 if(child_pid > 0) {
  /** Daddy sleep. */
  printf("Daddy sleeping\n");
  sleep(10); /* Won't sleep. */
  printf("Daddy wake up, child status:%d\n", child_exit_status);
 } else {
  /** Child exit immediately. */
  printf("OK, I gone, daddy.\n");
  return 1;
 }

 return 0;
}

秋

2010-10-12T20:46:00.001-07:00

我在风中

站成一棵树

只为

等你

Advanced Linux Programming 2

2010-10-12T20:46:00.000-07:00

Writing Good GNU/Linux Software

1, Interaction With the Parameters
getopt_long.c

#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>

void print_usage(FILE *stream, int exit_code)
{
    fprintf(stream, "Usage:..\n");
    exit(exit_code);
}

int main(int argc, char* argv[])
{
    int next_option;
    /** A string listing valid short options letters. */
    const char* const short_options = "ho:v";
    /** A array describing valid long options. */
    const struct option long_options[] = {
        { "help",       0, NULL, 'h' },
        { "output",     1, NULL, 'o' },
        { "verbose",    0, NULL, 'v' },
        {  NULL,        0, NULL,  0  }
    };

    const char* output_filename = NULL;

    do {
        next_option = getopt_long(argc, argv, short_options,
                long_options, NULL);
        switch(next_option)
        {
            case 'h':  /* -h or --help */
                print_usage(stdout, 0);
            case 'o':  /* -o or --output */
                output_filename = optarg;
                printf("output file=%s\n", output_filename);
                break;
            case 'v':  /* -v or --verbose */
                /* do something */
                break;
            case '?':  /* Invalid option */
                print_usage(stderr, 1);
            case -1:   /* Done with options */
                break;
            default:
                abort();
        }
    } while(next_option != -1);

    return 0;
}

tom@debian:~/project/linuxc/ch02$ ./getopt_long
tom@debian:~/project/linuxc/ch02$ ./getopt_long -h
Usage:..
tom@debian:~/project/linuxc/ch02$ ./getopt_long -o log.txt
output file=log.txt
tom@debian:~/project/linuxc/ch02$ ./getopt_long --verbose
tom@debian:~/project/linuxc/ch02$ ./getopt_long -?
./getopt_long: invalid option -- ?
Usage:..
tom@debian:~/project/linuxc/ch02$

2, Printing the Execution Environment

#include <stdio.h>

/** The ENVIRON variable contains the environment. */
extern char** environ;

int main()
{
 char** var;
 for(var=environ; *var!=NULL; ++var)
    {
  printf("%s\n", *var);
 }

 return 0;
}

3, Interact with environ variables

#include <stdio.h>
#include <stdlib.h>

int main()
{
 char* server_name = getenv("SERVER_NAME");
 if(server_name == NULL)
    {
  server_name = "localhost";
 }

 printf("SERVER_NAME: %s\n", server_name);

 return 0;
}

tom@debian:~/project/linuxc/ch02$ ./client
SERVER_NAME: localhost
tom@debian:~/project/linuxc/ch02$ export SERVER_NAME="sina.com"
tom@debian:~/project/linuxc/ch02$ ./client
SERVER_NAME: sina.com
tom@debian:~/project/linuxc/ch02$

4, Do as the kernel does

1. Allocate the buffer.

2. Open the file.

3. Read from the file into the buffer.

4. Close the file.

5. Return the buffer.

5, Writing and Using libraries

tom@debian:~/project/linuxc/ch02$ echo "int f(){return 3;}" > test.c
tom@debian:~/project/linuxc/ch02$ echo "int main() {return f();}" > app.c
tom@debian:~/project/linuxc/ch02$ gcc -c test.c
tom@debian:~/project/linuxc/ch02$ ar cr libtest.a test.o
tom@debian:~/project/linuxc/ch02$ gcc -c app.c
tom@debian:~/project/linuxc/ch02$ gcc -o app app.o -L. -ltest
tom@debian:~/project/linuxc/ch02$ ./app
tom@debian:~/project/linuxc/ch02$ echo $?
3

tom@debian:~/project/linuxc/ch02$ gcc -c -fPIC test.c
tom@debian:~/project/linuxc/ch02$ gcc -shared -fPIC -o libtest.so test.o
tom@debian:~/project/linuxc/ch02$ gcc -o app app.c -L. -ltest
tom@debian:~/project/linuxc/ch02$ sudo cp libtest.so /usr/lib/
tom@debian:~/project/linuxc/ch02$ ldd app
 linux-gate.so.1 =>  (0xb77c3000)
 libtest.so => /usr/lib/libtest.so (0xb77a5000)
 libc.so.6 => /lib/i686/cmov/libc.so.6 (0xb764a000)
 /lib/ld-linux.so.2 (0xb77c4000)
tom@debian:~/project/linuxc/ch02$ ./app
tom@debian:~/project/linuxc/ch02$ echo $?
3

Advanced Linux Programming 1

2010-10-11T20:47:00.000-07:00

Advanced UNIX Programming with Linux
文件清单
main.c

#include <stdio.h>
#include "reciprocal.hpp"

int main(int argc, char** argv)
{
 int i;

 i = atoi(argv[1]);
 printf("Reciprocal value of %d is %d", i, reciprocal(i));

 return 0;
}

reciprocal.cpp

#include <cassert>
#include "reciprocal.hpp"

double reciprocal(int i)
{
 assert (i != 0);
 return 1.0/i;
}

reciprocal.hpp

#ifdef __cplusplus
extern "C" {
#endif

 extern double reciprocal(int i);

#ifdef _cplusplus
}
#endif

使用GCC进行编译编译单个文件

gcc -c main.c
g++ -c reciprocal.cpp

连接Object文件

g++ -o reciprocal main.o reciprocal.o

makefile

reciprocal: main.o reciprocal.o
 g++ $(CFLAGS) -o reciprocal main.o reciprocal.o

main.o: main.c reciprocal.hpp
 gcc $(CFLAGS) -c main.c

reciprocal.o: reciprocal.cpp reciprocal.hpp
 g++ $(CFLAGS) -c reciprocal.cpp

clean:
 rm -f *.o reciprocal

Debian R400 wireless driver

2010-09-11T20:47:00.000-07:00

http://wiki.debian.org/InstallingDebianOn/Thinkpad/T400/lenny

1、Add the Debian Backports repository to /etc/apt/sources.list, also including the "non-free" component. For example:

# Backported packages for Debian Lenny
deb http://backports.debian.org/debian-backports lenny-backports main contrib non-free

2、Update the list of available packages:

aptitude update

3、Install a 2.6.32 kernel image appropriate for your system, along with the lenny-backports/firmware-iwlwifi and wireless-tools packages. For example:

aptitude -t lenny-backports install linux-image-2.6-$(uname -r | sed 's,.*-,,') firmware-iwlwifi wireless-tools

4、Restart your system and boot with the newly installed kernel.

5、The necessary kernel module should be automatically loaded. If necessary, it can be manually loaded via:

$ su
modprobe iwlagn

6、Verify your device has an available interface:

iwconfig

7、Raise the interface to activate the radio, for example:

ifconfig wlan0 up

8、Configure your wireless interface as appropriate.

FAT12格式化的1.44M引导软盘镜像

2010-08-20T20:48:00.000-07:00

1、GAS's "Hello, OS world!" with BPB(BIOS Parameter Block)
boot.S

.code16
.text
/* Floppy head of FAT12 */
 jmp  LABEL_START   /* Start to boot */
 nop      /* nop required */
BS_OEMName:  .ascii "WB. TOMZ"  /* OEM String, 8 bytes required */
BPB_BytsPerSec:  .2byte 512   /* Bytes per sector */
BPB_SecPerCluster: .byte 1   /* Sector per cluster */
BPB_ResvdSecCnt: .2byte 1   /* Reserved sector count */
BPB_NumFATs:  .byte 2   /* Number of FATs */
BPB_RootEntCnt:  .2byte 224   /* Root entries count */
BPB_TotSec16:  .2byte 2880   /* Toltal sector number */
BPB_Media:  .byte 0xf0   /* Media descriptor */
BPB_FATz16:  .2byte 9   /* FAT size(sectors) */
BPB_SecPerTrk:  .2byte 18   /* Sector per track */
BPB_NumHeads:  .2byte 2   /* Number ofmagnetic heads */
BPB_HiddSec:  .4byte 0   /* Number of hidden sectors */
BPB_TotSec32:  .4byte 0   /* If TotSec16 equal 0, this works */
BS_DrvNum:  .byte 0   /* Driver number of interrupt 13 */
BS_Reserved1:  .byte 0   /* Reserved */
BS_BootSig:  .byte 0x29   /* Boot signal */
BS_VolID:  .4byte 0   /* Volumn ID*/
BS_VolLab:  .ascii "Memox 0.0.1"  /* Volumn label, 11 bytes required */
BS_FileSysType:  .ascii "FAT12   "  /* File system type, 8bytes required */

/* Initial registeres. */
LABEL_START:
 mov  %cs,%ax
 mov  %ax,%ds
 mov  %ax,%es
 call  DispStr
 jmp  .
DispStr:
 mov  $BootMessage, %ax
 mov  %ax, %bp
 mov  $16, %cx
 mov  $0x1301, %ax
 mov  $0x00c, %bx
 mov  $0, %dl
 int  $0x10
 ret
BootMessage: .ascii "Hello, OS world!"
.org 510
.word 0xaa55

2、Link Script
boot.ld

SECTIONS
{
 . = 0x7c00;
 .text :
 {
  _ftext = .;
 } = 0
}

3、Makefile
makefile

CC=gcc
LD=ld
LDFILE=boot.ld
OBJCOPY=objcopy

all: boot.img

boot.o: boot.S
 $(CC) -c boot.S

boot.elf: boot.o
 $(LD) boot.o -o boot.elf -T $(LDFILE)

boot.bin: boot.elf
 @$(OBJCOPY) -R .pdr -R .comment -R .note -S -O binary boot.elf boot.bin

boot.img: boot.bin
 @dd if=boot.bin of=boot.img bs=512 count=1
 @dd if=/dev/zero of=boot.img skip=1 seek=1 bs=512 count=2879

clean:
 @rm -rf boot.o boot.elf boot.bin boot.img

4、Command

tom@localhost:~/sdk/memox$ la
boot.S     .bochsrc      boot.ld   makefile
tom@localhost:~/sdk/memox$ make
gcc -c boot.S
ld boot.o -o boot.elf -T boot.ld
1+0 records in
1+0 records out
512 bytes (512 B) copied，8.786e-05 秒，5.8 MB/秒
2879+0 records in
2879+0 records out
1474048 bytes (1.5 MB) copied，0.0247653 秒，59.5 MB/秒
tom@localhost:~/sdk/memox$ la
boot.elf  boot.ld  boot.S     .bochsrc      boot.bin  boot.img  boot.o   makefile
tom@localhost:/home/tom/sdk/memox# bochs
00000000000i[APIC?] local apic in  initializing
========================================================================
                       Bochs x86 Emulator 2.3.7
               Build from CVS snapshot, on June 3, 2008
========================================================================
00000000000i[     ] LTDL_LIBRARY_PATH not set. using compile time default '/usr/lib/bochs/plugins'
00000000000i[     ] BXSHARE not set. using compile time default '/usr/share/bochs'
00000000000i[     ] reading configuration from .bochsrc
00000000000i[     ] lt_dlhandle is 0x8d66130
00000000000i[PLGIN] loaded plugin libbx_x.la
00000000000i[     ] installing x module as the Bochs GUI
00000000000i[     ] using log file bochsout.txt
tom@localhost:/home/tom/sdk/memox# sudo mount boot.img /mnt/ -o loop
tom@localhost:/home/tom/sdk/memox# sudo echo "This is a FAT12" > /mnt/readme
tom@localhost:/home/tom/sdk/memox# ls /mnt/
readme
tom@localhost:/home/tom/sdk/memox#

引导扇区的格式化信息、打印程序

引导扇区结束(55AA)、第一个FAT表(F0FF)

掠过第二个FAT表，抵达根目录区，README文件的条目信息

抵达README存储部分

Hello, OS

2010-08-19T20:49:00.000-07:00

1、Debian

tom@localhost:~/sdk/memox$ uname -a
Linux localhost 2.6.26-2-686 #1 SMP Mon Jun 21 05:58:44 UTC 2010 i686 GNU/Linux
tom@localhost:~/sdk/memox$ nasm -v
NASM version 2.03.01 compiled on Jun 18 2008

2、Bochs
apt-get install bochs bochs-x bochsbios

.bochsrc

###############################################################
# Configuration file for Bochs
###############################################################

# how much memory the emulated machine will have
megs: 32

# filename of ROM images
romimage: file=/usr/share/bochs/BIOS-bochs-latest
vgaromimage: file=/usr/share/vgabios/vgabios.bin

# what disk images will be used
floppya: 1_44=a.img, status=inserted

# choose the boot disk.
boot: a

# where do we send log messages?
log: bochsout.txt

# disable the mouse
mouse: enabled=0

# enable key mapping, using US layout as default.
keyboard_mapping: enabled=1, map=/usr/share/bochs/keymaps/x11-pc-us.map

3、boot.img

org  07c00h
 mov  ax, cs
 mov  ds, ax
 mov  es, ax
 call DispStr
 jmp  $
DispStr:
 mov  ax, BootMessage
 mov  bp, ax
 mov  cx, 16
 mov  ax, 01301h
 mov  bx, 000ch
 mov  dl, 0
 int  10h
 ret
BootMessage:  db  "Hello, OS world!"
times 510-($-$) db  0
dw 0xaa55

tom@localhost:~/sdk/memox$ nasm boot.asm -o a.img
tom@localhost:~/sdk/memox$ la
a.img .bochsrc boot.asm
tom@localhost:~/sdk/memox$ bochs
00000000000i[APIC?] local apic in initializing
========================================================================
Bochs x86 Emulator 2.3.7
Build from CVS snapshot, on June 3, 2008
========================================================================
00000000000i[ ] LTDL_LIBRARY_PATH not set. using compile time default '/usr/lib/bochs/plugins'
00000000000i[ ] BXSHARE not set. using compile time default '/usr/share/bochs'
00000000000i[ ] reading configuration from .bochsrc
00000000000i[ ] lt_dlhandle is 0x8d66140
00000000000i[PLGIN] loaded plugin libbx_x.la
00000000000i[ ] installing x module as the Bochs GUI
00000000000i[ ] using log file bochsout.txt

Hello, Nasm

2010-08-16T20:49:00.000-07:00

section .text    ;section declaration

   ;we must export the entry point to the ELF linker or
    global _start ;loader. They conventionally recognize _start as their
   ;entry point. Use ld -e foo to override the default.

_start:

;write our string to stdout

        mov     edx,len ;third argument: message length
        mov     ecx,msg ;second argument: pointer to message to write
        mov     ebx,1   ;first argument: file handle (stdout)
        mov     eax,4   ;system call number (sys_write)
        int     0x80 ;call kernel

;and exit

 mov ebx,0 ;first syscall argument: exit code
        mov     eax,1   ;system call number (sys_exit)
        int     0x80 ;call kernel

section .data    ;section declaration

msg     db      "Hello, world!",0xa ;our dear string
len     equ     $ - msg                 ;length of our dear string

tom@localhost:~/source/asm$ ll
总计 4
-rw-r--r-- 1 tom tom 187 08-16 23:03 hello.asm
tom@localhost:~/source/asm$ nasm -f elf hello.asm
tom@localhost:~/source/asm$ ll
总计 8
-rw-r--r-- 1 tom tom 187 08-16 23:03 hello.asm
-rw-r--r-- 1 tom tom 704 08-20 00:23 hello.o
tom@localhost:~/source/asm$ ld -s hello.o -o hello
tom@localhost:~/source/asm$ ll
总计 12
-rwxr-xr-x 1 tom tom 440 08-20 00:23 hello
-rw-r--r-- 1 tom tom 187 08-16 23:03 hello.asm
-rw-r--r-- 1 tom tom 704 08-20 00:23 hello.o
tom@localhost:~/source/asm$ ./hello
Hello world
tom@localhost:~/source/asm$

CXF之Web Service

2010-07-30T20:50:00.000-07:00

模型类

package demo.cxf.model;
public class User {
    private String name;
    private String email;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String toString() {
        return "name:" + name + "\t email:" + email;
    }
}

接口类

package demo.cxf.service;
import javax.jws.WebService;
import demo.cxf.model.User;
@WebService
public interface UserService {
    void add(User user);
    User[] findAllUsers();
}

实现类

package demo.cxf.service;
import java.util.ArrayList;
import java.util.List;
import javax.jws.WebService;
import javax.xml.ws.Endpoint;
import demo.cxf.model.User;
@WebService(endpointInterface = "demo.cxf.service.UserService", serviceName = "UserService", portName = "UserServicePort")
public class UserServiceImpl implements UserService {
    List<User> list = new ArrayList<User>();
    public void add(User user) {
        list.add(user);
    }
    public User[] findAllUsers() {
        User[] users = new User[list.size()];
        list.toArray(users);
        return users;
    }
    public static void main(String[] args) {
        UserService service = new UserServiceImpl();
        Endpoint.publish("http://localhost:9000/userService", service);
    }
}

测试端

package demo.cxf;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
import javax.xml.ws.soap.SOAPBinding;
import demo.cxf.model.User;
import demo.cxf.service.UserService;
public class CxfClient {
    public static void main(String[] arg) {
        // 这里的QName的url是Service的package名的倒序
        Service service = Service.create(new QName("http://service.cxf.demo/", "UserService"));
        service.addPort(new QName("http://service.cxf.demo/", "UserServicePort"), SOAPBinding.SOAP11HTTP_BINDING,
                "http://localhost:9000/userService");
        UserService userService = service.getPort(UserService.class);
        User user = new User();
        user.setName("Tom");
        user.setEmail("tom@tom.com");
        userService.add(user);
        User[] users = userService.findAllUsers();
        for (User u : users) {
            System.out.println(u);
        }
    }
}

至于需要的那些jar包，像我等懒人怎么会一个个去找呢，把下面的贴到pom.xml里算了

<dependency>
 <groupId>org.apache.cxf</groupId>
 <artifactId>cxf-rt-frontend-jaxws</artifactId>
 <version>2.2.9</version>
</dependency>
<dependency>
 <groupId>org.apache.cxf</groupId>
 <artifactId>cxf-rt-transports-http</artifactId>
 <version>2.2.9</version>
</dependency>
<!-- Jetty is needed if you're are not using the CXFServlet -->
<dependency>
 <groupId>org.apache.cxf</groupId>
 <artifactId>cxf-rt-transports-http-jetty</artifactId>
 <version>2.2.9</version>
</dependency>

lighttpd & php5

2010-07-26T20:51:00.000-07:00

需lighttpd/php5

server.modules = (
            "mod_access",
            "mod_fastcgi",
            "mod_alias",
            "mod_accesslog",
            "mod_compress",
)

FastCGI请求转发

fastcgi.server=(".php"=>
    ("localhost"=>
        (
        "bin-path"=>"/usr/bin/php5-cgi",
        "socket"=>"/tmp/php.socket"
        )
    )
)

代理下转发Tomcat为

proxy.server(".jsp"=>
    ("localhost"=>
        ("host"=>"localhost",
         "port"=>"8080"
        )
    )
)

/usr/sbin/下可用命令

lighttpd              lighttpd-disable-mod  lighty-disable-mod
lighttpd-angel        lighttpd-enable-mod   lighty-enable-mod

eg: lighty-enable-mod mod_cgi ps: /etc/lighttpd/lighttpd.conf /etc/init.d/lighttpd [start|stop|restart|..]

围观地址
http://redmine.lighttpd.net/projects/lighttpd/wiki

Django to build a blog

2010-07-17T20:52:00.000-07:00

Django for the Impatient: Building a Blog

django-admin.py startproject mysite
cd mysite/
./manage.py startapp blog
vim settings.py

DATABASE_ENGINE = 'sqlite3' # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
DATABASE_NAME = 'django.db' # Or path to database file if using sqlite3.
.........
INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.admin',
'mysite.blog'
)

vim urls.py

from django.contrib import admin
admin.autodiscover()
......
(r'^admin/(.*)', admin.site.root),
(r'^blog/', include('mysite.blog.urls')),

vim blog/models.py

from django.contrib import admin

class Post(models.Model):
title = models.CharField(max_length=150)
body = models.TextField()
timestamp = models.DateTimeField()

admin.site.register(Post)

vim blog/urls.py

from django.conf.urls.defaults import *
from mysite.blog.views import archive

urlpatterns = patterns('',
url(r'^$', archive),
)

vim blog/views.py

from django.template import loader, Context
from django.http import HttpResponse
from mysite.blog.models import Post

def archive(request):
posts = Post.objects.all()
t = loader.get_template("archive.html")
c = Context({'posts':posts})
return HttpResponse(t.render(c))

mkdir blog/templates
vim blog/templates/base.html

{% block content%}
{% endblock %}

vim blog/tempaltes/archive.html

{% extends 'base.html' %}
{% block content %}
{% for post in posts %}
<h2>{{ post.title }}</h2>
{{ post.timestamp|date:"l, F jS" }}

{{ post.body }}

{% endfor %}
{% endblock %}

20 Application Framework Elements

2010-07-12T20:52:00.000-07:00

持久化存储（Persistence）
键值生成（Key Generation）
数据访问（Database Access）
资源访问（Resource Access）
内层沟通（Inter-tier communication）
同步（Concurrency）
日志（Logging）
审计验证（Auditing）
事务（Transactions）
错误处理（Error Handling）
用户消息（User Messages）
格式化规则（Formatting Rules）
数据验证（Data Validation）
安全（Security）
用户管理（User Management）
工作流程（Scheduling & Workflow）
报表（Reporting）
系统安装（System Setup）
应用集成（Application Integration）
静态数据（Static Data）

Scrum Sprint1结束

2010-07-11T20:53:00.000-07:00

   sprint1结束，那本《scrum轻松之旅》也正好读到sprint回顾，感觉我们在走着与关毅相同的路，遇到相同的问题，相同的探索。这种知识共享，策略重现的模式，很赞。它可用于开放课程，结合sns的旅游资讯，点评推荐...
   相对传统模式，目前感到Scrum中几个亮点：1、Team成员各自挑卡片，调动每个人的积极性，People good at what they love. 2、沟通和拥抱变化，其中几乎所有的活动都是针对发现问题、解决问题而存在的。早上的15分钟会议，Sprint评审、回顾和总结等等。软件开发是“人”的有效活动。想起《人月神话》
   Backlog的优先级分类，让我们集中20％的时间突击80％的需求，即便以后的20％部分没有很好的完成，那前面的80％可以做得很精致，最大程度的满足实际需求。这个世界上不存在完美，只有最好，80％的绝对成功已经是一个Not bad的结果了。
@北京的201个蓝天

关键你需求必须是业务导向，否则80%等需求如果没有商业价值也无法被用户接受，另外需要配合CI, 自动构建很测试保证完成等需求经过及时等测试。

Sprint的开始评审，确定我们将要进展的，正是实际所需要的。跟目标画一条直线，前进！有时候backlog也有分析错误的时候，不过没关系，反正是一个小sprint，即便是路线错误了，也只是很小部分的成本代价（相对于传统模式），风险和可能出现的错误成本输出降到最低
Team成员的Task自选，发挥每个人的主观能动性，调动积极性，人们乐于做他们喜欢的事情，并且会把它做的很好，这里面略微带了点Opensource人里的那种荣誉感，“看，我能做到这么Cool东东” 兴趣是成功的一个重要因素。
@北京的201个蓝天

这里还有一个承诺等问题，自选任务意味着主动承担责任，可以对开发人员产生良性等压力，保证任务按时按质量万成

每天早上的15分钟会议，最好的发现问题，了解进度的方式，Team之间的沟通本该是N对N的网状模型，而不应是拓扑模型。你能找到比网状模型更好的沟通方式吗？
“闪光弹”激励机制，传统模式在项目初期通常会纠集一小撮人做一个portal开发，借此完成需求的某个小模块、并做技术验证等等，有点类似先遣队、侦察兵之类的角色。“闪光弹”跟这个有点类似，不过也有不同的一点“我们没有后备军”，如同霍去病率八百精锐骑兵追击匈奴，每个人都发挥着以一敌百的作用。
Sprint回顾，总结错误教训、批评与自我批评，常犯错误的相互周知。你在同一个地方跌倒100次，和另外一个人在不同的地方跌倒50次。即便你的100次比那50次多，就能说明你很有经验吗？你会在101次跌倒在同样的地方。

Google Wave Commands Cheat Sheet

2010-06-30T20:53:00.000-07:00

Google Wave Command Cheat Sheet

Search Cheat Sheet
This is a quick guide to the operators and restricts supported by wave search.
Keywords
about:[keyword] — finds waves which have [keyword] occurring anywhere. Same as [keyword].
title:[keyword] — finds waves which have [keyword] in the title.
caption:[keyword] — finds waves which have an attachment where [keyword] occurs in the caption.
————————————————
Status
is:read — finds all read waves.
is:unread — finds all unread waves.
Note: you cannot currently do a search like “-is:read” by itself and get reliable results due to an outstanding restriction on megastore queries
is:mute — finds all muted waves.
is:unmute — finds all waves not muted
is:active — currently the same as is:unread.
is:note — finds all waves which have you as the only participant and contributor
————————————————
Participants
from:[address] — finds waves from the participant identified by the address. Special case of from:me identifying waves from yourself.
by:[address] — same as from:[address].
to:[address] — find waves which are a dialogue between you and the participant identified by the address.
with:[address] — find waves that have the participant identified by the given address explicitly listed.
owner:[address] — find waves by person, that they created.
only:[address] — finds waves to which only the participant specified by the given address contributed.
————————————————
Date Search
Currently, there are a few restricts:
past:[date term] — finds all waves in the last period.
previous:[date term] — finds all waves in the period before the last period.
before:[date term] — finds all waves before a certain period.
after:[date term] — finds all waves after a certain period.
which can be combined with date terms:
day
week
month
year
So you can have past:week, past:year. There is also support for
past:N[date term] where N > 0. So you can have past:3days (today, yesterday, the day before yesterday).
Also you can have
past:Ndays
past:Nweeks
past:Nmonths
past:Nyears
Finally, you can abbreviate days, weeks, months and years to a single letter (d, w, m, y). Thus you can write
past:3d
past:2w
————————————————
Folders
in:[folder name] — find waves in the folder with the given name. For example, in:inbox.
in:[search name] — find waves in the saved search with the given name.
is:unfiled — find waves which have not been moved to a user folder.
is:filed — find waves which belong to some user folder.
————————————————
Attachments
has:attachment — finds waves with an attachment. This changed from “is:image”.
has:document — finds waves with an attachment which is a document. (coming soon)
has:image — finds waves with an attachments which is an image. (coming soon)
caption:[keyword] — finds waves with an attachment with caption containing [keyword].
filename:[keyword] — finds waves with an attachment with filename containing [keyword]. (coming soon)
mimetype:[keyword] — finds waves with an attachment with mimetype containing [keyword]. (coming soon)
————————————————
Tags
tag:[tag name] — finds waves with the tag [tag name].
————————————————
Gadgets
has:gadget — finds waves which contain a gadget.
gadget:[keyword] — finds waves which contain a gadget with name containing keywords. e.g. chess, fridge, map, risk, sokoban.
gadgeturl:[keyword] — finds waves which contain a gadget with urls containing keyword.
gadgettitle:[keyword] — finds waves which contain a gadget with a title containing keywords.
————————————————
Expressions
foo & bar — match waves with foo and bar.
You can use AND, or skip the operator altogether, as the logical and is the default.
foo | bar — match waves with foo or bar (or both).
foo OR bar — match waves with foo or bar (or both).
-foo — match waves that do not contain foo. (There is an outstanding bug that causes searches with only negative terms to fail. To get around it, use to:me -foo)
“foo … bar” — matches waves that contain the exact phrase “foo … bar” (There is an outstanding bug for live search not working with phrases)
foo & (bar | -baz) — matches waves that contain foo and either bar or do not contain baz.
————————————————
Phrases
“[multiple terms]” — match waves with one or more terms in sequence:
“hot dog” catches waves with the terms hot and dog in sequence. This is also required for other operators such as in:”new inbox” where say “new inbox” is a saved search.
————————————————
XML Search
tags:subtag — find all waves which have this combination.
tag:[tag] — find all waves which have this .
attribute:[value keyword] — finds all waves which have < …. attribute=value …> where keyword is a token in value.
————————————————
Wave ID
id:”” — find a wave with a specific wave id.
————————————————
Zero Inbox
If you want to zero inbox, you can hack this temporarily by saving a search “my inbox” with the query:
in:inbox is:unread this:week. You can then use the menu option “Mark as read” in the wave panel.
Alternative zero inbox: in:inbox is:unread past:7days -is:mail
————————————————
Saved Searches
A search can be saved using one of two methods:
Create a search in the search box and then press the Save search button at the bottom of the Digest panel.
Add a search using the searches Add button on the Navigation panel. Then add the search query and name of the search in the Saved Search popup panel.
Saved searches can be edited and managed using the pop-up menu which shows when hovering over the saved search in the searches section of the Navigation panel.
————————————————
Filters
Filters are saved searches which also have an action to apply to all waves which match the saved search. The actions supported are
skip inbox – removes the wave from inbox. Whilst this wave continues to match the search, it will continue to stay out of the inbox. Skip inbox will shortly be renamed archive.
mark as read – Whilst the wave continues to match the search, it will be marked as read.
————————————————
Folders
You can add a folder by using the Add button on the folders section of the Navigation panel. A folder is added by typing the folder name in the text box given and hitting enter.
Folders can be managed using the pop-up menu that shows when hovering over the folder on the Navigation panel.
Add folder – A subfolder can be added under the current folder.
Rename – rename the current folder.
Delete – delete the current folder.
————————————————

How To Install Django On Debian

2010-06-27T20:54:00.000-07:00

FROM: http://www.howtoforge.com/installing-django-on-debian-etch-apache2-mod_python

This tutorial explains how to install Django on a Debian Etch server. Django is a web framework that allows to develop Python web applications quickly with as much automation as possible. I will use it with Apache2 and mod_python in this guide.

This howto is meant as a practical guide; it does not cover the theoretical backgrounds. They are treated in a lot of other documents in the web.

This document comes without warranty of any kind! I want to say that this is not the only way of setting up such a system. There are many ways of achieving this goal but this is the way I take. I do not issue any guarantee that this will work for you!
1 Install MySQL
Django can use multiple database backends, e.g. PostgreSQL, MySQL, SQLite, etc. If you want to use MySQL, you can install it as follows:

apt-get install mysql-server mysql-client

We want MySQL to listen on all interfaces, not just localhost, therefore we edit /etc/mysql/my.cnf and comment out the line bind-address = 127.0.0.1:

vi /etc/mysql/my.cnf

[...]
# Instead of skip-networking the default is now to listen only on
# localhost which is more compatible and is not less secure.
#bind-address = 127.0.0.1
[...]

Then we restart MySQL:

/etc/init.d/mysql restart

Now check that networking is enabled. Run

netstat -tap | grep mysql

The output should look like this:

server1:~# netstat -tap | grep mysql
tcp 0 0 *:mysql *:* LISTEN 3085/mysqld
server1:~#

Run

mysqladmin -u root password yourrootsqlpassword
mysqladmin -h server1.example.com -u root password yourrootsqlpassword

to set a password for the user root (otherwise anybody can access your MySQL database!).
2 Install Apache And mod_python
If Apache2 and mod_python aren't already installed on your system, you can install them as follows:

apt-get install apache2 apache2-doc apache2-mpm-prefork apache2-utils libexpat1 ssl-cert libapache2-mod-python

3 Install Django
In order to install Django and the Python MySQL bindings, we run:

apt-get install python-django python-mysqldb

4 Configure Apache

I will use /var/www here as the document root of my virtual host and /etc/apache2/sites-available/default as the file containing the configuration of my virtual host. Adjust this to your circumstances.

Before we configure Apache, we must create a Django project (e.g. called mysite) (see http://www.djangoproject.com/documentation/tutorial01/). For security reasons I create that project outside my document root /var/www (e.g. in /home/mycode):

mkdir /home/mycode
cd /home/mycode
/usr/share/python-support/python-django/django/bin/django-admin.py startproject mysite

This will create the directory /home/mycode/mysite with some Python files in it.
Now with the project mysite created, we can configure Apache. I open my vhost configuration in /etc/apache2/sites-available/default and place the following lines between the ... container:

vi /etc/apache2/sites-available/default

[...]
<Location "/mysite">
SetHandler python-program
PythonHandler django.core.handlers.modpython
SetEnv DJANGO_SETTINGS_MODULE mysite.settings
PythonDebug On
PythonPath "['/home/mycode'] + sys.path"
</Location>
[...]

The path in the first line () refers to the URL - meaning this configuration will be used if you use /mysite in the URL (e.g. http://www.example.com/mysite). You can change this to your likings. Please adjust the other values (SetEnv DJANGO_SETTINGS_MODULE mysite.settings and PythonPath "['/home/mycode'] + sys.path") to the name of your project and the path where it is located.

Restart Apache afterwards:

/etc/init.d/apache2 restart

Now you can access http://www.example.com/mysite in a browser. If everything went well, you should see something like this:

This means Django has been successfully installed, and you can now use it to develop your Python web applications (please refer to http://www.djangoproject.com/documentation/ to learn how to develop web applications with Django).
5 Connect To A MySQL Database From A Django Project

If you want to use a MySQL database in your Django project, you should first create that database (e.g. mysite) and a database user (e.g. mysiteadmin) for that database:

mysql -u root -p
CREATE DATABASE mysite;
GRANT ALL ON mysite.* TO 'mysiteadmin'@'localhost' IDENTIFIED BY 'mysiteadmin_password';
GRANT ALL ON mysite.* TO 'mysiteadmin'@'localhost.localdomain' IDENTIFIED BY 'mysiteadmin_password';
FLUSH PRIVILEGES;
quit;

Then open the settings.py file in the project folder (e.g. /home/mycode/mysite) and modify the database settings, e.g. as follows:

vi /home/mycode/mysite/settings.py

[...]
DATABASE_ENGINE = 'mysql' # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'ado_mssql'.
DATABASE_NAME = 'mysite' # Or path to database file if using sqlite3.
DATABASE_USER = 'mysiteadmin' # Not used with sqlite3.
DATABASE_PASSWORD = 'mysiteadmin_password' # Not used with sqlite3.
DATABASE_HOST = '' # Set to empty string for localhost. Not used with sqlite3.
DATABASE_PORT = '' # Set to empty string for default. Not used with sqlite3.
[...]

6 Links

* Django: http://www.djangoproject.com
* Python: http://www.python.org
* Debian: http://www.debian.org

TODO

2010-06-15T20:55:00.000-07:00

GuideLine(Word)
--> Outer Design(Excel) Module/Basic UI/DB
--> Inner Design(Excel) Understand/Module Implement Detail/CRUD Grid/Portal
--> Program Design (Excel) MID Review/Class/M -> UT -> Coverage -> Bug analysis -> SI plan
--> SI (Excel) Test data/script/Screenshot
--> PT

XML闲言碎语
1.XML

2.iBatis XQuery
CRUD / Order / Join / Group
SQL Optimized

3.Marklogic Sample
xcc.jar
oxm.jar XML & POJO/UI

4.XML/JSON Compare. The suit is the best.

Tool & Rule
UI JTag/Flex/Maskat/jQuery/Imart JS framework
Blogic Action(for Web/RICH/Batch/.Net)
DAO iBatis/QueryRunner/Cabinet
DB Oracle/Postgrel

Tools: CheckStyle/dJunit/PMD/

Doc
软件开发过程中，文档的重要性。从需求、设计、制造、测试、计划、质量追踪等各个阶段都用，这也是重要的证据。
有人说京剧是中国的国粹（个人觉得这真TMD的扯淡）
而Excel是日本人的国粹。
A、需求阶段
PPT/PDF概要展示，用于思路展示/问题讨论/技术培训
Word 功能定义，记录永久性归档内容，最终将形成纸张

B、基本设计（外部设计）
Word/Excel 系统结构、模块设计分析，包含数据定义、模块设计、流程设计

C、详细设计1
Excel （模块详细设计、数据库设计）
D、详细设计2
Excel （内部评审、设计组开发组Review、规模估算）

E、PD/M/UT
设计组 CRUD分析，SI文档
制造组 Excel/SQL -> Code() -> UT -> Bug记录/软件质量分析/开发能力分析

F、SI测试
SI环境启用
SI文档->测试脚本-政绩

G、PT上线试运行有问题Rollback

穿插其中的
wiki 异地问题讨论，具有可追溯性，证据
email 邮件组，周知事项资料，资料加密，OA协同，证据，会议安排
quality CheckStyle/dJunit/PMD/BTS(PMWD)质量-->souce量/UT量/bug数原因分析

Platform Transfer
Platform1: CtrlObject/Service --> Event/Listener --> DAO --> DB
Platform2: Struts/Spring/iBatis

1. UI --> JTag(label/select/codelist/submit/link) --> Common / Paging(PagingCondition)
2. Blogic --> BlogicAction(log/transaction) extends Action
3. DAO/Multi data source (in BlogicAction/PagingBlogicAction)
4. Cache Message
5. Grid / EJB <---> Blogic
6. Logger
7. RequestProcessorTX
8. Exception

HL7-API剖析

2010-06-14T20:56:00.000-07:00

Architecture

ca.uhn.hl7v2.app.HL7Service
An HL7 service.
Accepts incoming TCP/IP connections and creates Connection objects.
Uses a single MessageTypeRouter object (for all Connections) to define the Applications to which message are sent.
To configure, use registerApplication() or loadApplicationsFromFile().
A separate thread looks for Connections that have been closed (locally or remotely) and discards them.

ca.uhn.hl7v2.app.Connection
A TCP/IP connection to a remote HL7 server

ca.uhn.hl7v2.app.ConnectionListener
An object that wants to be notified of new remote connections.
ConnectionListeners can be registered with an HL7Service in order to receive these notifications.

ca.uhn.hl7v2.parser.Parser
Parses HL7 message Strings into HL7 Message objects and encodes HL7 Message objects into HL7 message Strings.

ca.uhn.hl7v2.app.Receiver
Listens for incoming messages on a certain input stream, and sends them to the appropriate location.

ca.uhn.hl7v2.app.Responder
Performs the responding role in a message exchange (i.e receiver of the first message, sender of the response; analagous to the server in a client-server interaction), according to HL7's original mode
processing rules.
At the time of writing, enhanced mode, two-phase reply, continuation messages, and batch processing are unsupported.

ca.uhn.hl7v2.app.MessageTypeRouter
Routes messages to various Applications based on message type and trigger event.
The router is told which Application to which to route various messages by calling the method registerApplication(...).

ca.uhn.hl7v2.llp.LowerLayerProtocol
Represents a particular "lower layer protocol" over which HL7 messages can be sent.
An example is the "minimal lower layer protocol" defines in the HL7 implementation guide (appendix C) - this is implemented by the class MinLowerLayerProtocol.
Implementations should call the static method logCharacterReceived() when a character is read from a remote system. This method may or may not log receipt, as configured (see docs for this method).

ca.uhn.hl7v2.app.Application
From an HL7 messaging perspective, an Application is a consumer of a messages.
Once a parser parses an incoming message, the message would normally be forwarded to an Application of some sort (e.g. a lab system) which would process the message in some way meaningful
for it, and then return a response.
If you are wondering how to integrate HAPI into an existing server application, this is probably the place. Create a class that implements Application, then look at Responder and SimpleServer to see
how to get HAPI to listen for messages on a socket and pass them to your Application.

Simple Server

An HL7 service.
Accepts incoming TCP/IP connections and creates Connection objects.
Uses a single MessageTypeRouter object (for all Connections) to define the Applications to which message are sent.
To configure, use registerApplication() or loadApplicationsFromFile().
A separate thread looks for Connections that have been closed (locally or remotely) and discards them.

Connection

A TCP/IP connection to a remote HL7 server

Parser

ca.uhn.hl7v2.parser.Parser
Parses HL7 message Strings into HL7 Message objects and encodes HL7 Message objects into HL7 message Strings.

ca.uhn.hl7v2.parser.ModelClassFactory
Looks up classes for message model components (e.g. concrete implementations of Message, Group, Segment). A custom factory can be used to point to custom model components.

ca.uhn.hl7v2.validation.ValidationContext
A set of rules for message validation

ca.uhn.hl7v2.validation.MessageValidator
Validation utilities for parsed and encoded messages.

2010二环第一季

2010-06-07T20:57:00.000-07:00

话说，前天晚上打游戏到凌晨4点，12点接到王老大的电话，谈谈人生，谈谈理想。如此，不吃不喝，宅着耗到下午5点。洗个澡，冲到迪亚天天买了包牛肉冲上120，于18:30分左右抵达建国门。诸同学已准备就绪，都背着小包！好温暖~

就这样，故事发生了。
走啊走啊走啊走啊走啊走啊~~
天，越走天越黑；尾气，也越来越少；肚子，越走越饿~~(╯﹏╰)b
话说这二环大老远找不到一家卖食品或者卖水的小店，一丁点都不繁华。

直到华灯初上，直到永定门天空上一排排挂着闪闪红灯的风筝在飘；与其说那像灰机，还不如说城市人对星空的憧憬。
我有个同学，小时候对星空十分的痴迷，以至于凡是有关于宇宙的资料片、科普片必搜必看。
前几天他高高兴兴的买了看星星的大桶，可高兴了。
可没过几天，他QQ签名变了：北京的夜晚没有星星。
这莫大的悲剧哇

之后天黑了，不记得有什么印象深刻的了，唯有永定门旁一个地下通道睡了很多无家可归的老人。
这让我很不解，代表最先进思想最先进生产力的社会主义的国家的帝都的心腹之地，却出现这一幕，让马克思、列宁情何以堪，情何以堪！

终于，开饭了，22点27分，我的早饭，我需要麦芽糖、葡萄糖。之后，卢小卢出现、消失一姑娘、出现一新姑娘==》 team.count++

之后，在各种监视器的强势围观下，横过马路并穿越几个护栏，路边有很多月季，花开正艳，让人爱不释手。还有树上那一个个纸做的菱形物

到西直门做了很长时间的休整，橘黄的灯光，温暖的让人困意十足。
一路向东，过中轴线，躺在德胜门路边一片小树林里的凉凉的水泥地上，小小的冷风吹过，another deep image~

东直门，天蒙蒙发亮，黏糊糊的树、黏糊糊的地。

小朋友排排坐，安静下来了，心情、意识、冲动，小卢音响里传来《我想有个家》，凄婉而又真实。想起鬼哥的2010虎年备忘录了

之后脱离队伍，向三元桥方向进发，一路上手机gprs抽风，最后赌一把，凭感觉走回来。

6月6日凌晨4:40分左右给蜗牛发了条短信"达"，之后，爬上了我那久违的床~

另， 6月是一个事件多发的月份：儿童节、某21周年（freemoren@twitter做了历史模拟直播）、某校90th校庆、高考、某中堂到南方的一个海边开始写日记、当然还有此次暴走..

SQL备忘录

2010-06-01T20:57:00.000-07:00

SQL 全名是结构化『查询语言』←_←（Structured Query Language）
真相

ps：同学们，拜托，不要再把性别写成sex了

-- -----------------------------------------------------
-- Table `student`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `student` ;

CREATE  TABLE IF NOT EXISTS `student` (
  `sid` VARCHAR(6) NOT NULL ,
  `sname` VARCHAR(8) NOT NULL ,
  `age` SMALLINT UNSIGNED NOT NULL ,
  `gender` CHAR(1) NOT NULL ,
  PRIMARY KEY (`sid`) )
ENGINE = InnoDB;

-- -----------------------------------------------------
-- Table `course`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `course` ;

CREATE  TABLE IF NOT EXISTS `course` (
  `cid` VARCHAR(6) NOT NULL ,
  `cname` VARCHAR(45) NOT NULL ,
  `teacher` VARCHAR(8) NOT NULL ,
  PRIMARY KEY (`cid`) )
ENGINE = InnoDB;

-- -----------------------------------------------------
-- Table `sc`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `sc` ;

CREATE  TABLE IF NOT EXISTS `sc` (
  `sid` VARCHAR(6) NOT NULL ,
  `cid` VARCHAR(6) NOT NULL ,
  `grade` SMALLINT UNSIGNED ZEROFILL NULL ,
  PRIMARY KEY (`sid`, `cid`) ,
  CONSTRAINT `fk_sid`
    FOREIGN KEY (`sid` )
    REFERENCES `mydb`.`student` (`sid` )
    ON DELETE NO ACTION
    ON UPDATE NO ACTION,
  CONSTRAINT `fk_cid`
    FOREIGN KEY (`cid` )
    REFERENCES `mydb`.`course` (`cid` )
    ON DELETE NO ACTION
    ON UPDATE NO ACTION)
ENGINE = InnoDB;

CREATE INDEX `fk_sid` ON `sc` (`sid` ASC) ;
CREATE INDEX `fk_cid` ON `sc` (`cid` ASC) ;

关系代数五个基本操作
并——R∪S ={t|t∈R∨t∈S}，t是元组变量，R和S的元数相同
差——R-S ={t|t∈R∧t!∈S}，R和S的元数相同
笛卡尔积——RxS{t|t=〈t^r, t^s〉∧ t^r∈R ∧ t^s∈S}
投影——π1...n(R)={t|t=〈t1...m〉∧〈t1...k〉∈R}
选择——σF(R)={t|t∈R∧F(t)=true}
关系代数四个组合操作
交（Intersection）
连接（Join）
自然连接（Natural Join）
除法（Division）
关系代数七个扩充操作
改名
广义投影
赋值
外部并
半连接
聚集操作
SELECT

SELECT [ ALL|DISTINCT ] 目标表的列名或列表达式序列|* AS 别名
FROM 基本表名和（或）视图序列
[ WHERE 行条件表达式 ]
[ GROUP BY 列名序列
    [ HAVING 组条件表达式 ]]
[ ORDER BY 列名[ ASC|DESC ], ... ]

读取FROM子句中基本表、视图的数据，执行笛卡尔积操作
选取满足WHERE子句中给出的条件表达式的元组
按GROUP子句中指定列的值分组，同时提取满足HAVING子句中租条件表达式的那些组
按SELECT子句中给出的列名或列表表达式求值输出
ORDER子句对输出的目标表进行排序，按附加说明ASC升序排列，或按DESC降序排列

WHERE - 行条件子句
GROUP - 分组子句
HAVING - 组条件子句
ORDER - 排序子句

COUNT(*)
COUNT(列名)
SUM(列名)
AVG(列名)
MAX(列名)
MIN(列名)
AND / OR

<, <=, >, >=, =, !=, [NOT] BEWTEEN ... AND ...
LIKE %, _
(查询语句1) UNION [ALL] (查询语句2)
(查询语句1) INTERSECT [ALL] (查询语句2)
(查询语句1) EXCEPT [ALL] (查询语句2)

IS [NOT] NULL

[NOT] IN
=|<> SOME

[NOT] EXIST

CREATE

INSERT INTO 基本表名 [(列名表)]
    VALUES (元组值)
INSERT INTO 基本表名 [(列名表)]
    VALUES (元组值), (元组值), (元组值)...
INSERT INTO 基本表名 [(列名表)]
    <SELECT 查询语句>

UPDATE

UPDATE 基本表名
SET 列名=值表达式[, 列名=值表达式, ...]|ROW = (元组)
[ WHERE 条件表达式 ]

DELETE

DELETE FROM 基本表名
[ WHERE 条件表达式 ]

Open ESB

2010-05-30T20:58:00.000-07:00

SOA(Service-Oriented Architecture)已经成为业界最流行的新一代企业应用集成框架。松散耦合、协议独立、位置透明是SOA的三个主要特征，加上Web Services等技术的出现，使得构建一个全球参与的服务协作平台成为可能。ESB是SOA架构中最为重要的概念，它为实现一个SOA架构需要满足的松散耦合、协议独立、位置透明、服务组合、服务管理等要求提供了必要的支持。本文将介绍一个开源ESB的实现，即Open ESB。Open ESB是在Sun公司支持下的一个开源项目，其核心是基于JBI(Java Business Integration)规范实现的，目前已经被集成到Sun公司的Sun Java System Application Server的9.1版本中。

关于Open ESB
Open Enterprise Service Bus(Open ESB)是基于JPC-208规范实现的一个开源企业服务总线。Open ESB提出了可插拔组建容器(Pluggable Component Containers)的概念中，所有的服务被放到了不同的组建容器当中，这些容器集成了不同类型的企业IT资源。容器之间通过一条快速、可靠、位于内存(in-memory)的消息总线进行相互通信，这条消息总线被称为规范化消息路由器(Normalized Message Router)，也被称为JBI总线。服务容器通过一个基于WSDL的标准消息交换模式(Standardized Message Exchange Pattern)来集成IT资源，消息采用XML格式。这种方式提高了不同容器中不同服务的互操作性，同时也保证了同来自不同软件供应商的采用不同技术实现的服务之间的兼容性。

概念
下面对在Open ESB中常用的几个概念进行了说明。

服务引擎：向JBI环境内部的其他组件提供服务或者请求其他组件包含的服务的程序单元；
绑定组件：通过特定的通信协议与JBI容器外部的服务或者客户端进行通信的程序单元；
服务单元：被用来配置JBI环境中组件，使得组件可以需要提供或者请求服务；
服务集合：服务单元的集合，其中包含了构成一个服务集合的每个服务单元应该如何被部署到不同JBI组件中的配置信息；

下图简要说明了Open ESB中的各个组件之间以及外部服务或者客户端之间是如何通过规范化消息路由器(NMR)进行消息交换的。

每个JBI组件都使用适合于自己的通信协议与NRM通信，而不管别的组件是如何与NRM通信的，而组建之间的通信是通过NRM进行。这里，服务引擎提供JBI环境内部的组件之间的服务访问，而绑定组件提供JBI环境与外部服务之间的服务访问。所有的来自JBI环境外部的服务访问请求都首先被发送到特定的绑定组件，绑定组件再将请求转换为内部的规范化消息，再通过NMR调用相应的服务。对于每一种不同的通信协议，例如SOAP、SMTP、HTTP、FTP等，都会有一个绑定服务与之对应，使得服务引擎中的服务可以通过任何的通信协议与JBI环境外部的服务或者客户端进行通信。
目标
Open ESB的目标是创建一个开源的，基于被广泛接受的标准的技术集合，使得企业或组织可以创建服务或者参与到全球的服务协作当中。参与全球服务写作是所有走信息化道路的组织一个基本的需要，这样不仅可以缩短他们的信息系统开发时间，也可以更快的响应市场的变化。SOA极其相关技术也正是在需求下产生的。
Open ESB作为商业ESB或者SOA产品的良好替代品，不仅符合各种相关标准，而且在架构上分离了在服务的创建、服务的访问中的不变的部分和可变的部分，这种分离导致了全球服务写作当中创建和参与两个不同关注的分离。开发人员可以通过工具和运行时环境将注意力放在创建服务上，而安全和网络管理人员可以通过创建和应用不同的规则或策略来限制对服务的访问。
Open ESB架构
下图是Open ESB的架构图，下面章节将对其中的每个部分进行单独介绍。

应用服务器
Open ESB需要一个应用服务器作为其载体，Open ESB可以被用来平衡应用服务器提供的许多功能(服务)，例如可靠性，可扩展性，部署支持以及管理等。目前Open ESB已经被集成到GlassFish中(一个开源Java EE application Server)，被用来平衡GlassFish的事物和集群功能，为开发人员提供一个健壮的部署解决方案。通过使用JBI的Java EE服务引擎，可以将现有的EJB和Web服务注册到Open ESB运行时中，使得其他的服务可以与之进行通信，从而达到重用现有功能的目的，并且这种集成是透明并且无缝的。
组合应用
一个组合应用是一个自包含(Self-contained)的功能单元，它由一些包含业务逻辑服务和相应的配置信息组成。使用Open ESB提供的组合应用设计工具，开发和设计人员可以用来实现如下的功能：

创建组合应用来重定位或者重新组合现有的ERP或者遗留服务，这些服务与新创建的服务使用面向服务的设计模式进行重组，得到新的业务流程，再通过Web2.0中的表示技术提供给用户使用；
使用业务流程执行语言(Business Process Executing Language)来描述由遗留服务、新建服务、Java应用、EJB组件和Web应用构成的组合服务的执行流程和协作行为；
使用转换服务来实现已有功能组件和新创建的服务之间的通信；
平衡业务活动管理工具(Business Activity Manager)和关键性能指标(Key Performance Indicator)，使用智能事件流程(Intelligent Event Processing)来处理复杂事件；
使用负责的提取、转换和加载模式来创建数据仓库和企业数据转换；
通过HTTP、SOAP、REST、File、FTP、SMTP、SNMP、JMS等协议和多种不同的通信连接器组件(如JCA)来与’Silos’和其他不同的应用进行协作；
为不同的应用领域，如保健行业、电信行业、财务、保险，创建协作服务(这些行业有自己数据格式，数据语义)；

组合应用编辑器
组合应用编辑器是随Open ESB一起提供的综合应用编辑工具，帮助开发人员或设计人员创建和连接组合应用。它帮助开发人员或者设计人员重定向不同服务的功能，通过重组应用逻辑并控制组合到一起的各个服务之间的交互方式来得到新的功能。组合服务可以包含丰富的元素，从独立的Web服务或者其他应用中的一个功能，到整个遗留系统。组合应用编辑器通过提供丰富的图形用户接口简化了组合应用的创建过程。这使得开发人员或者设计人员可以专注于业务逻辑的开发。
JBI总线
JBI总线持有一组可插拔的组件，这些组件集成了不同类型的IT资源。容器之间通过一条快速、可靠、位于内存(in-memory)的消息总线进行相互通信，这条消息总线被称为规范化消息路由器(Normalized Message Router)，也被称为JBI总线。服务容器通过一个基于WSDL的标准消息交换模式(Standardized Message Exchange Pattern)来集成IT资源，消息采用XML格式。这种方式提高了不同容器中不同服务的互操作性，同时也保证了同来自不同软件供应商的采用不同技术实现的服务之间的兼容性。
另外，JBI定义了一个标准的方法来支持插入第三方组件到Open ESB中，组件以动态的方式被插入到组件容器当中。这个功能将J2EE的功能提升了一个阶段，通过集成不同供应商提供的可插拔组件，服务开发商可以选择最方便的方式来部署自己的服务，而无需关心不同供应商提供的容器之间的具体交互细节。
服务引擎和绑定组件
Open ESB支持两种类型的组件。服务引擎向Open ES环境内部提供服务，同时请求JBI环境内部的服务。绑定组件向Open ESB环境外部的客户端提供服务，或者调用外部服务。服务引擎和绑定组件可以作为服务提供者，也可以作为服务消费者，或者同时担任这两个角色。服务引擎和绑定组件之间的差别从他们的命名就可以看出。将业务逻辑和通信逻辑分离提供了协议独立性，降低了实现的复杂性，提高了灵活性。
业务逻辑单元
业务逻辑单元是实现了全球服务协作(Global Services Collabration)某一方面的简单功能元素。一个业务逻辑单元的例子是一个实现了电子商务中某个事务的BPEL业务流程。这个业务流程可能会调用内部或者外部的服务。业务逻辑单元可以在多个全球服务协作中被重用。
全球协作服务网络
SOA和ESB供应商提供的一个服务基础架构或者一个服务总线拓扑，用来创建不同的应用。这些架构方式非常适合于企业内部的应用集成，但是并不能被用来实现全球服务协作。全球服务协作中，所有的服务形成了一个网络。Open ESB针对全球协作服务网络已经或者即将进行两个方面的改进：
l Internet和Intranet通信的协作标准已经被建立，主要是http协议之上的XML技术，这样服务之间的通信将不再依赖于某个特定的协议；
l 高吞吐量的消息处理引擎，即服务网关，允许各个域将它们的服务访问规则实现同业务逻辑实现相分离。服务网关作为一个域中所有服务的代理，负责避免域协作威胁，实现同其他域的协作并且应用域规则。
监听器
Open ESB提供集中式的监听器功能，用来管理和配置分布式的运行时系统。通过配置工具，可以非常容易地安装和卸载新的组件容器以及管理他们的生命周期。配置工具同时还提供部署组合应用以及管理组合应用生命周期的功能。对组合应用和组件容器的配置及可以在单独的单一的应用服务器上完成也可以在集群环境中完成。消息交换的统计数据可以通过配置工具得到，使得用户对他的企业应用有一个大致的了解。通过这些管理工具用户可以查询和了解到Open ESB中各个部分的统计信息，报警信息以及错误信息。

刷G2至Android2.1

2010-05-18T20:58:00.000-07:00

原系统因天气小插件出现问题，导致系统无限重启，无耐，刷之
基本要求
返回键+开机 --> Fast Boot
小房子+开机 --> Recovery Mode
HTC驱动 Download
刷Recovery
从这里下载recovery-RA-sapphire-v1.6.2H.img，扔到sd卡中
开机进入命令行

su
flash_image recovery /sdcard/recovery-RA-sapphire-v1.6.2H.img
reboot recovery

或FastBoot下
fastboot flash recovery recovery-RA-sapphire-v1.6.2H.img
刷ROM
下ROM，重命名为update.zip放到sd卡根目录
小房子+开机进入RecoveryMode
第一步，备份！！！（可选 = =）
第二步，从Flash拿update.zip刷之
刷完后Reboot
刷Splash屏
就是开机第一屏，生产商的logo看着不舒服
1、这里下载工具
2、找一个320*480的图，双击步骤1压缩包中的"开机画面制作工具.exe"->"open"图片->convert，之后产生一个mysplash.rgb565文件
3、关机，入fastboot模式，运行

fastboot flash splash1 mysplash.rgb565
fastboot reboot

Enjoy~

Fastboot Usage

usage: fastboot [ ]

commands:
update reflash device from update.zip
flashall 'flash boot' + 'flash system'
flash [ ] write a file to a flash partition
erase erase a flash partition
getvar display a bootloader variable
boot [ ] download and boot kernel
flash:raw boot [ ] create bootimage and flash it
devices list all connected devices
reboot reboot device normally
reboot-bootloader reboot device into bootloader

options:
-w erase userdata and cache
-s specify device serial number
-p specify product name
-c override kernel commandline

参阅文献
《G2假砖修复开机无限重启修复指南》
《G2（HTC MAGIC）刷机之Recovery教程》
《[32A][3.22]提前感受JIT的魅力CM5.0.7-t5-with-JIT》

SAPPHIRE PVT 32A ENG S-OFF H
HBOOT-1.33.2010(SAPP10000)
CPLD-12
RADIO-3.22.20.17
Jun 2 2009,17:27:03
---------------------------------------------
SN :HT96WKF00904
IMEI :354059024501841
Part Number :99HFU016-00
Part Description :SKU,HTC,English-WWE,IND,Regional ID High,Sophisticate Black,HSUPA enable,w/o SIM Lock,SAPPHIRE-C9#ASIA
Customer Name :
Customer Model :
HTC Model :SAPPHIRE-C9
Error Message :

用Python写Web

2010-05-17T20:59:00.000-07:00

首先，请理解CGI，说白了，就是我们通过HTTP向某个机器的某个端口发送一个请求之后，对方返回一段byte数据的交互。

Apache + C + CGI
喜欢C不需要理由，首先写一个hello.c

#include <stdio.h>

int main(int argc, char* argv)
{
 printf("Content-Type: text/plain\n\n");
 printf("%s\n", "Hello world");
 return 0;
}

root@compaq:/usr/lib/cgi-bin# gcc hello.c -o hello
root@compaq:/usr/lib/cgi-bin# ls
hello hello.c
root@compaq:/usr/lib/cgi-bin# ./hello
Content-Type: text/plain

Hello world
root@compaq:/usr/lib/cgi-bin#

至于问为什么执行./hello要打印出Content-Type云云的同学，请参阅HTTP协议，也就是两台机器互相沟通交流所用的鸟语。将编译好的hello二进制文件放到cgi-bin的目录中，启用apache

/etc/init.d/apache2 start

另开一个命令行执行如下命令

tom@compaq:~$ telnet localhost 80
Trying ::1...
Connected to localhost.
Escape character is '^]'.
GET /cgi-bin/hello HTTP 1.1

HTTP/1.1 200 OK
Date: Mon, 17 May 2010 18:10:35 GMT
Server: Apache/2.2.9 (Debian) PHP/5.2.6-1+lenny4 with Suhosin-Patch
Vary: Accept-Encoding
Content-Length: 12
Connection: close
Content-Type: text/plain

Hello world
Connection closed by foreign host.
tom@compaq:~$

输入内容为telnet localhost 80 和 GET /cgi-bin/hello HTTP 1.1这两行，其余返回结果中Content-Type和Hello world这两行我们知道，是hello程序执行结果，那么剩余的字符就是所谓的HTTP协议咯。不明白？不要紧。打开浏览器，输入http://localhost/cgi-bin/hello，结果为Hello world，查看源代码也为Hello world，而那些Content-Type和其余的HTTP协议部分被浏览器理解后，执行相应的动作去了。
好了，现在我们已经知道怎么把C语言的命令行的输出行为转给HTTP请求了，那么现在要做的就是用Python的命令行执行输出来替换掉这个C语言的编译文件

Apache + Python + CGI
写一个hello.py，内容如下

#!/usr/bin/env python
print "Content-Type: text/html"
print
print """\
<html>
<body>
<h2>Hello world</h2>
</body>
</html>
"""

这里面，用text/html替换掉上面的text/plain，这样输出的html,body等文本标签就可以给浏览器理解为html语言并渲染成相应的显示格式了。如果使用text/plain，即便是html格式的文本，浏览器也只是当作纯文本流直接输出而不进行任何渲染行为。执行python hello.py

root@compaq:/usr/lib/cgi-bin# python hello.py
Content-Type: text/html

<html>
<body>
<h2>Hello world</h2>
</body>
</html>

root@compaq:/usr/lib/cgi-bin#

打开浏览器输入http://localhost/cgi-bin/hello.py可见，一个使用2标题字体的Hello world呈现在你的面前，源码内容为

<html>
<body>
<h2>Hello world</h2>
</body>
</html>

这里，我们已经可以写一些简单的python小程序来实现一些动态的数据显示了。比如显示系统时间，磁盘使用率，或者像verycd的首页标题一样，随即选择一个哲理语句集合中的某一句话进行显示...

S.O.L.I.D原则

2010-05-11T21:00:00.000-07:00

from http://www.jdon.com/jivejdon/thread/38090
由 Robert Martin提出的S.O.L.I.D 原则，用来更好编写面向对象程序，更灵活应对变化。

S - Single Responsibility Principle 单一职责，简称SRP
这个我前面几篇文章刚刚写：对象的责任与职责
如何从职责和协作中发现丰富对象？

比如：报表的内容和报表的格式都会变化改变，但是这两种变化的性质不同，一个是实质内在，一个是表面上的，SRP认为这是问题的两个方面，其实代表不同的职责，应该将它们分离放入不同的类或模块中，而不应该放在一起，否则的话，因为不同原因发生变化，导致对方变动，比如报表格式变新的样式，这个变化是不应该涉及到内容的。

这个模式和GoF模式中职责链模式Chain-of-responsibility pattern类似，体现了职责分离，分散关注Separation of concerns等OO思想。当然，也只有认识到事物高凝聚Cohesion本质，才能发现耦合。

O - Open/Closed Principle 开闭原则
我一直使用变化和不变来说明，封装不变部分，开放变化部分，一般使用接口继承实现方式来实现“开放”应对变化，说大白话就是：你不是要变化吗？，那么我就让你继承实现一个对象，用一个接口来抽象你的职责，你变化越多，继承实现的子类就越多。

L - Liskov Substitution Principle 里氏替换原则简称LSP
这是一个针对行为职责可替代的原则，如果 S是T的子类型，那么S对象就应该在不改变任何抽象属性情况下替换所有T对象。这里的抽象属性是指对象的字段属性。

我们使用接口时经常碰到一个问题，需要使用接口子类中的方法，而接口中没有这个方法，那么只能要么修改接口，要么将接口downcast为具体子类。为什么会出现这个尴尬现象？有几种情况导致，其中一种情况是是将当前的类重构到接口时，没有将类中所有方法extract到接口中，可能因为这些被你漏掉的方法不属于当前接口，那么，它又违背了单一职责原理，说明你当前这个类的方法设计得又不合理。

所以，如果单一职责设计的足够好，那么LSP原则则是检验的方法。LSP原则是对对象职责和协作的一种检验约束方法，此外还有DBC(design by contract)原则，为了保证实现接口的子类职责行为的约束，DBC三要素都必须被重视满足：
1.Preconditions 前置条件不能在子类中被强化。
2.Postconditions后置条件不能在子类中被弱化。
3.子类自身不变性Invariants必须在子类自己中封装满足。这也是前面“不改变任何抽象属性”的意思。

I - Interface Segregation Principle接口分离简称ISP原则
这类似General Responsibility Assignment Software Patterns中高凝聚原则 High Cohesion Principle ，这是解决胖接口，接口很大很丰富，就要进行解耦切分，把一个接口切分为多个接口，把一个大的职责切分为小职责以及这些职责之间的协作交互。

切分时必须依据高凝聚原则，单一职责进行切分。

这个原则起源于施乐公司，他们需要建立了一个新的打印机系统，可以执行诸如装订的印刷品一套，传真多种任务。此系统软件创建从底层开始编制，并实现了这些任务功能，但是不断增长的软件功能却使软件本身越来越难适应变化和维护。每一次改变，即使是最小的变化，有人可能需要近一个小时的重新编译和重新部署。这是几乎不可能再继续发展，所以他们聘请罗伯特Robert帮助他们。

他们首先设计了一个主要类Job,几乎能够用于实现所有任务功能. 只要调用Job类的一个方法就可以实现一个功能，Job类就变动非常大，是一个胖模型啊，对于客户端如果只需要一个打印功能，但是其他无关打印的方法功能也和其耦合，ISP原则建议在客户端和Job类之间增加一个接口层，对于不同功能有不同接口，比如打印功能就是Print接口，然后将大的Job类切分为继承不同接口的子类，这样有一个Print Job类，等等。

D - Dependency Inversion Principle 依赖反转原则 DIP
a.高级别模块不应依赖于低层次的模块。双方应依赖于抽象。
b.抽象不应当取决于细节。细节应该依赖抽象。

Dependency Injection 依赖注入模式也是属于这种类型变种，GoF设计模式中适配器模式中，高层次类只依赖于adapter接口. 而被适配者低层次也只依赖adapter接口。

SOLID原则如今在DCI架构中能够得到真正实现和发展。

RPG网游&SNS

2010-05-11T20:59:00.000-07:00

很多年过去了,从传奇开始,RPG网游模式几乎没有太大变化,多数是围绕在原有模型的基础上做一些小特效,美工改改模型, 策划改改故事脚本, 打包上线,新游戏诞生 = =

角色系统
属性成长(角色分类,经验值, 红/蓝/气/攻/防/暴击和命中率/移动速度/攻击速度/血液魔法恢复速度....)
技能树(攻法/物品合成法)
装备和物品
游戏币
一般游戏开始,玩家会被要求在出生地各个店铺获取自己的初级套装(武器, 衣服, 药等)
装备套装
宠物坐骑
任务系统
通常,一款游戏都是围绕着一定故事背景而产生的. 这也是评价一款游戏是否好的重要指标,典型案例,如:仙剑系列.故事情节大都为历史, 童话, 魔幻, 科幻等系列, 此外就是Second Life(模拟人生)类型的虚拟现实.
通常在这个大的故事背景下,玩家扮演其中的某个角色,根据成长经历或环境变化触发相应的任务.
....
协作快速完成任务
获取经验,游戏币,装备和任务道具
交易系统
所有玩家最关心的,装备,物品,游戏币..
与NPC交易分免费和收费型, 如N级以前城内所有店铺免费, 免费求医
物品的合成属于交易的一种,但玩家可以靠某些技能书发展自己的物品合成技能,参考角色系统

玩家可开店兜售自己的装备或物品
交友系统
早期QQ雏形,目前还未涉及到关系网络的分析
衍生出结婚等概念
好友之间发密函
帮派系统
在交友系统基础上的延伸, 如到达30级后可以加入帮派,50级可创建帮派.
帮派排名(总资产, 任务经验数, PK大战胜率)
帮派威望(向帮派捐助, 帮派内成员协作完成任务),想起火影忍者中的各种国
帮派长老给成员下达命令
世界环境
玩家,怪物属性随时间和气候的变化而变化(韦诺之战);
时间变化: 有白天夜间区分;任务Boss的定期刷新
气候变化: 风,雨,高山,草原,荒漠,冰源,沼泽,森林,大洋
关于消息的传递
区域性 < 任务小组 < 好友间密函 < 帮派 < 全区域

Java内存模型

2010-05-10T21:00:00.000-07:00

jvm系统中存在一个主内存(main memory或java heap memory)，java中所有变量都储存在主存中，对于所有线程都是共享的。

每条线程都有自己的工作内存(working memory)，工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作都是在工作内存中进行，线程之间无法相互直接访问，变量传递均需要通过主存完成。

缓存一致性（cache coherency）

什么是缓存一致性?
它是一种管理多处理器系统的高速缓存区结构，其可以保证数据在高速缓存区到内存的传输中不会丢失或重复。(来自wikipedia)

解决缓存一致性的方法?
a, 顺序一致性模型:
要求某处理器对所改变的变量值立即进行传播, 并确保该值被所有处理器接受后, 才能继续执行其他指令.

b, 释放一致性模型: (类似jmm cache coherency)
允许处理器将改变的变量值延迟到释放锁时才进行传播.

happens-before ordering( 先行发生排序)

如何避免这种情况?
排序原则已经做到:
a, 在程序顺序中, 线程中的每一个操作, 发生在当前操作后面将要出现的每一个操作之前.
b, 对象监视器的解锁发生在等待获取对象锁的线程之前.
c, 对volitile关键字修饰的变量写入操作, 发生在对该变量的读取之前.
d, 对一个线程的 Thread.start() 调用发生在启动的线程中的所有操作之前.
e, 线程中的所有操作发生在从这个线程的 Thread.join()成功返回的所有其他线程之前.

为了实现 happends-before ordering原则, java及jdk提供的工具:
a, synchronized关键字
b, volatile关键字
c, final变量
d, java.util.concurrent.locks包(since jdk 1.5)
e, java.util.concurrent.atmoic包(since jdk 1.5)

(1) 获取对象监视器的锁(lock)
(2) 清空工作内存数据, 从主存复制变量到当前工作内存, 即同步数据 (read and load)
(3) 执行代码，改变共享变量值 (use and assign)
(4) 将工作内存数据刷回主存 (store and write)
(5) 释放对象监视器的锁 (unlock)

《MySQL性能调优与架构设计》概要

2010-05-08T21:01:00.000-07:00

权限机制
相关表mysql.User, mysql.db, mysql.Host, mysql.table_priv, mysql.column_priv
由于数据量小,访问频繁,MySQL启动时会将所有权限信息加载到内存Cache住,所以修改完权限信息后要FLUSH PRIVILEGES使其生效, 通过GRANT, REVOKE和DROP USER情况除外. 5.0.2版本后增加了CREATE USER命令.
权限等级 Global Level > Database Level > Table Level > Column Level > Routine Level

用户管理
访问控制

GRANT SELECT, INSERT, UPDATE, DELETE ON test.table TO 'user'@'localhost'

原则: 越苛刻越好,越紧束越好
备份和恢复

mysqldump, mysqlimport, LOAD DATA INFILE

锁机制
表、行 S、X、IS、IX
Query优化
Query语句优化基本思路和原则

优化需要优化的Query
定位优化对象的性能瓶颈
明确优化目标
从Explain入手
多使用Profile
永远用小结果集驱动大的结果集
尽可能在索引中完成排序
只取自己需要的Columns
仅仅使用最有效的过滤条件
尽可能避免复杂的Join和子查询

OO思想在于设计系统时，考虑其易变性和扩展性，但在性能方面有所欠缺；此时需要OP进行辅佐矫正

select/where/order by/group by/having

.......

3-layer体系架构

2010-04-26T21:01:00.000-07:00

UI层
对于互联网用户，多数情况下是网页形式；对于收银员，是POS机；所谓UI，是指有效数据的某种呈现方式，以方便进行人机交互。
html
最原始，也是最标准的，有W3C强有力的后盾。近期火热的HTML5又与时俱进的推出canvas, video, audio等一系列令人兴奋的标签，跟着标准走，没错的。
早期浏览器混战时期的互联网还是很朴素的，连在页面上播放一小段动画都让人大伤脑筋，更不要说是RIA交互了，而且也没有一个特定的规范，于是乎，各厂家便打造自己的解决方案。
applet
路人皆知，java是依托互联网浪潮发展壮大起来的语言，并且sun针对不同应用场景打造了三大let(applet, servlet, midlet)，兵来将挡，水来土掩。依托于SE平台的awt包针对浏览器端而诞生的一组支持applet的类。可以使用<applet>标签将.class嵌入到浏览器中执行，但本地需装有jre环境。后来applet有点力不从心的时候，Sun又相继推出了JavaWebStart和JavaFX。但结果都同EJB那样的命运，没人愿意用；

需要JRE(为了运行一个简单的小程序，人们还要另外安装一个几十m的环境？)
做学术研究的人多数对产品营销有所欠缺(一些技术研讨会上，SUN工程师们也自我承认这一点)

就像强大的EJB，当初也算是企业级开发中解决某些极端情况的最好办法，但学术派人士经常只考虑问题能不能解决，却很少站在开发者的角度考虑这个东西好不好用。三大let目前只剩下J2EE体系中的servlet还活着，这大概也印证了"企业应用生命周期为10年，互联网应用5年，移动应用3年"及"任何产品和技术要么选择不断成长，要么选择灭亡"的说法。
flash
互联网混战，打的不仅是技术标准，还有开发工具。Macromedia推出"网页三剑客"，虽微软也放出Frontpage，但对比集成套装的Macromedia成员来说，也只能是用来把玩一下。当初还新生出"闪客"一词，指那些整天没事儿造flash玩的人，还有风靡的闪客帝国、闪客吧等各种闪客集中地。从制作简单的特效动画、到动漫影片集、再到一些娱乐时尚的网站全站用纯flash打造、甚至是用来构建一些桌面级应用。Macromedia真正把互联网带入了丰富多彩的多媒体互动时代。可是，突然又一天它消失了，纳入Adobe麾下。Fireworks死，其本身就与Adobe嫡系的Photoshop冲突；至于Dreamweaver，现在的页面制作人员要求纯手工写html，再也不是拖拖拽拽的了，更何况还有很多Open的工具；唯一还在风靡的是经过几代变迁的Flash，Adobe还给它起了个新名字Flex。不过html5出来以后它也是前景堪忧。因为，下一步我们要进入的是移动互联网时代。当我们评价一个终端设备的好坏时，续航力和性能是很重要的一个指标；执行as脚本的flash，相当于给浏览器加了一层套，这无疑加大系统开销。而目前霸占美国移动互联网的苹果系列机器，打开Flash的时候，你会明显感觉CPU兴奋了，温度上去了。或许乔帮主前段时间抛出的"flash将死"的理论有所偏激，但鄙人赞同这一点。此外，这里有一篇更为确切的评价《关于Flash的闲言碎语》

Flash是一个在特殊时期，仓促诞生的网页多媒体呈现技术；
Flash是个封闭的技术，并且Adobe收购MacroMedia之后继续封闭和拒绝开放；
Flash对客户端的CPU和资源占用较多，这一点饱受用户抱怨，以始终未有较明显改善；
Flash网页组件不是一个遵循Web标准的组件，在网页交互上，它不具有开放性和标准性；
Flash试图通过自有平台扩展向整个Web交互平台发展，且自创一套封闭标准以维持其垄断性，这会威胁到众多终端厂商的利益；
Adobe不是一家受人景仰的公司，有野心，无实力，在开放的大趋势下，它一点儿让人尊敬的进步也没有。它或许想走微软的老路，但是条已经被证明并不好走的路

silverlight
ajax
javascript / xml / json
国际化
控制层
Filter
Validator
RBAC权限控制 / pipe / linux/mySQL权限思想
Control & Dispatch
Messages properties
业务层
ESB
SOAP
Message-Queue/JTA
Batch
异常处理
日志

What Happen构思

2010-04-25T21:02:00.000-07:00

事件

1、Google在搜索过程中加入地理因素
2、微软推出一个旅游网站
3、Foursquare火的不可开交
4、未来的发展趋势为LBS、SNS、实时资讯

因素

虚拟与现实
这一切都要从2000年开始的一个叫作《模拟人生(Second Life)》的游戏说起，现在称"Internet's largest user-created, 3D virtual world community." 这是虚拟现实技术发展到一定阶段的必然产物，也可称作YY。

后来Google推出Earth和Map系列产品，提供人们清晰精准的地图服务，称作现实世界的2D虚拟化记录；
而StreetView及3d Sketchup旨在将2D的地图3D化，结果将能虚拟化整个现实世界的。
虚拟中的物品和现实物品实现一对一的映射。如宇宙、相对论那些人常说的异次元空间，即存在另一个世界与现实一一对应。

模拟游戏是个好玩的东西，他可以让你尝试做现实中中你不曾做过的事情；然生活在虚拟世界中是不真实的，病态的，最终都要回归现实。虚虚实实，假到真时真亦假。所谓真实，不过是人们自我意识上对某件事物的认同。

When？Where？Who？What（何时何地何人做何事）
现实世界主要由时间和空间这两个维度组成，而关系到人类社会群体的又有人物和事件这两个维度。如果对这四个维度的现实数据做记录，我们就不用写什么记录、日志、文档，只要根据时间、地点定位到历史的某一时刻找到我们需要的人物和事件即可，很酷，但目前做不到；我们只能选择一种折中的方法，给我们的生活一点一点的添加更多便利。
关于When，爱因斯坦说，时间是宇宙大爆炸的产物；对于人们来说，时间是一个Calendar
关于Where，我们已经拥有现实中的数据拷贝了，GoogleMap, StreetView用于了解周边环境。
关于Who，近几年火热火热的SNS做的就是这方面的事情，如Facebook、校内；目前大多数是通过曾经隶属组织(学校、公司)之类的数据做关联引用的，哲思社区用的是人物关联，似乎IBM前几年有个项目也是分析客户人与人之间关系的。
关于What，典型的应该是Twitter这类应用，记录某时刻的事件、思维、点子之类数据

那么，如果将以上应用做个整合会出现什么？
于是，Foursquare诞生了，火了；侧重点在于Where和Who，也有部分的When和What数据，但营养度不高。我们也不能仅仅停留在这一层面，还有更多更酷更炫的点子没有加进来呢。

记得几年前有家公司推出这样的一种服务：一个人在街道的某个地方用终端(手机)发布一条语音信息，其他人在未来的某一天来到这个地点，可以通过某种终端收听到这条语音数据，环境数据的实时记录，犹如《阿凡达》里的知识树。这需要精准的定位、大规模存储计算、网络读写速度等方面技术的突破。

设想，如果我们把Twitter/微博、Youtube/优酷嵌入到GoogleMap中，然后以时间和地点做维度区分，就可以记录何时何地发生何事，再附加人物信息（Friend Connect），酷！同时，还可以分析某个人的活动轨迹，获取一个人的需求对于商品营销是很重要的数据。参考《美科学家用卫星定位绘制北极狼活动轨迹图》

设想

鄙人宅男一枚，但不宅就不知道找谁去哪里玩，于是一个朋友一个朋友的电话或QQ联系组织，低效。我们需要改变！

如果我能够了解到朋友们的计划，然后来进行自己的安排
Google Calendar是一个很酷的应用，而真实用的人很少，大概商务性太强了或者是习惯问题。通常一些OpenSource组织举办活动的时候会用到。假设，我和我的朋友们都有这么一个计划表，我自己可以查看一张日程表，上面列出我的所有朋友们的活动安排，然后挑自己感兴趣的去参与，这样就不必每次自己想出去玩的时候打电话遭遇一个个推脱。

如果我能够查看到周边世界都在发生或将要发生什么，然后自己根据喜好去参与
Foursquare只是侧重地记录地点信息；而新闻视频（如优酷）用于真实记录现实事件，地理信息模糊。而且前面两个都是记录过去发生的事情，我不喜欢马后炮。联系上面提到的朋友日程表，我如果可以实时的发现我的周边都将要发生什么事情，自己根据喜好去参与，这起码可以减小宅的可能性，在明媚的阳光下同大批有着同样兴趣的人交流，爽哉..

如果我能够根据别人的活动记录来安排自己的活动，并召集朋友们一起去玩
每当我想出门旅行的时候，都要现Google一大批相关资料或者到专业的咨询论坛里取经，交通、酒店、行程等等，通常耗费很多的时间和精力。实际上，我们想做的大多数事情别人都已经做过了，而别人的整个经验性的数据却很少有记录下来；"再现某个事件的经过，对后来想做同样事情的人是很有价值的参考数据"。
比如豆瓣暴走小组举办活动的模式

1、某人发起一个活动（Twitter + Calendar）
2、感兴趣的朋友们联系我（SNS + FriendConnect + QQ）
3、整合地图、路线、票务、天气、酒店等数据（Map + Weather + Qunar）
4、小组出发，去驴友推荐的景点，餐馆，紧急情况下需要药店、加油站等（大众点评 + Map）
5、回来后写作业，我们去了哪里，做了什么，怎么做的（？+ Picasa + Flickr + Youtube + 优酷 + ？）
6、未来的某人想重复到某个地点做同样的事，重复1

这里有几个地方可以改善

1、发起的活动可以按时间归为一个日程表，选具体的活动可以看到文字、图片及视频介绍
2、当我发起活动的同时，可以被follow me的朋友们接收到，不用我到处贴：我要做什么，我要做什么...
3、可以把这些信息整合，做成一站式服务，直接把内容推送到自己面前
4、对Foursquare和大众点评的整合改进
5、直接把信息放到地图上，通过时间和地点维度，查找某一时刻、地点发生了什么，可以针对特定人群（朋友）开放，以供别人参考。
6、避免别人重复的Google大量资料，重复的地图、路线、票务等信息搜罗

设想图

这样，我们可以避免宅、避免迷路、还可以避免《向左走向右走》....

对于Map/Reduce的一点鸟语

2010-04-24T21:03:00.000-07:00

Map/Reduce起源于Google的一篇文章《MapReduce: Simplified Data Processing on Large Clusters》，前些年在Cloud概念刚出来的时候很火（现在应该属于常识系列），多用于对大型大量数据做处理的实施策略。根据它的起源，首先关联到的是搜索引擎的某一部分机能：倒排索引的建立过程。

我们的正常理解认知：这篇文档中都出现了那些词？
实际搜索的目的在于：这个词都出现在哪些文档中？

比如Web上有以下两个文档
Doc A: A smart fox jump over the lazy dog.
Doc B: Tom's cat is smart like a fox.

我们希望在输入与输出对应为
dog -> Doc A
fox -> Doc A, Doc B
cat -> Doc B

建立索引范例（某做搜索的公司就是拿这种小测验面试的）

public class Indexer {
 public static void main(String[] args) {
  Map docs = new HashMap();
  docs.put("DocA", "A smart fox jump over the lazy dog");
  docs.put("DocB", "Tom's cat is smart like a fox");

  Map index = new HashMap();

  Iterator docIter = docs.keySet().iterator();
  while(docIter.hasNext()) {
   String docKey = docIter.next();
   String docContent = docs.get(docKey);
   String[] docContentArr = docContent.split(" ");
   for(int i=0; i&lt; docContentArr.length; i++) {
    LinkedList value = index.get(docContentArr[i]);
    if(null == value) {
     value=new LinkedList();
    }
    value.add(docKey);
    index.put(docContentArr[i], value);
   }
  }

  Iterator iterator = index.keySet().iterator();
  while(iterator.hasNext()) {
   String keyString = iterator.next();
   System.out.print(keyString + "\t--&gt;\t");
   LinkedList linkedList = index.get(keyString);
   for(int i=0; i&lt; linkedList.size(); i++) {
    System.out.print(linkedList.get(i) + ",");
   }
   System.out.println("");
  }
 }
}

输出结果

cat --> DocB,
is --> DocB,
fox --> DocA,DocB,
A --> DocA,
a --> DocB,
the --> DocA,
Tom's --> DocB,
like --> DocB,
jump --> DocA,
over --> DocA,
lazy --> DocA,
dog --> DocA,
smart --> DocA,DocB,

目前，索引已经建立好了。但这只是针对小数据量的测验，当需要建立索引的文档数目为百万、千万、甚至是亿的时候，机器就被噎死了。所以我们需要每次小消化一些，或者多找些其他机器来一起消化掉。比如，每个机器负责一万条数据（这是绰绰有余的），搞来100多台机器一起消化就好了。对，这就是Map，这～就是Map。每个机器消化完的结果也是一个个键值对，然后把100个这种结果做归并，也就得到了所有数据的索引数据，如图：

如此的结果就是：不管出现的问题P有多大，只要有足够数量多的机器，总能P/n使问题可解
这只是最基础的理论思想，在此之上根据集群管理、少写多读、节点压力自调节等情况等衍生出的Master/Slave等架构思想属于统一体系策略

Getting started with Bochs

2010-04-18T21:04:00.000-07:00

http://www.linux.com/archive/feed/40825?page=1
What if you need to run your legacy Windows application on a Linux box, a Mac, or a Solaris-based workstation? To make the equation even more interesting throw in a few requirements -- add transferring old legacy accounting data over the network, or using the backed-up data from a CD-ROM. And yes, you want to keep the costs to a minimum. An open source project called Bochs may be your best option.

VMware is a (costly) commercial application that lets you run a guest operating system on a Windows or a Linux installation. Wine, on the other hand, though free, supports a very limited number of applications, and the same can be said about CrossOver Office. WinLin does a little better, but it doesn't support Windows NT, 2000, or XP.
And none of these alternatives run on Macintosh or SPARC-based hardware.

Bochs, an open source project, may be a better answer. It emulates 286, 386, 486, Pentium, Pentium Pro, and AMD 64-bit CPUs, fooling the guest OS into thinking that it's running on real hardware. Bochs (pronounced "box") provides I/O emulation for a computer's standard parallel port, serial port, VGA card, disk, CD-ROM, timer chip, and network card, along with a custom BIOS.

Emulating the x86 hardware is Bochs's strongest point. Bochs enables you to install Windows on a SPARC workstation or Debian on a Mac. However, hardware emulation deals a massive blow to the performance of the non-native operating systems.

The Bochs Web site says that Bochs is an ideal operating system and application testing environment. Unfortunately, you need high-performance top-of-the-line hardware to use the emulated
environment productively. But Bochs is an ideal teaching tool for operating system classes.

Installing Bochs

You can download the latest release of Bochs, 2.1.1, in various packages for various environment. For Linux, you can download either the source package (.tar.gz) or the RPM. The source package is a better option, as it allows you to specify various options during install.
Change to the directory which houses the tarball, untar it, and run the configure script:

tar zxvf bochs-2.1.1.tar.gz
./configure --enable-ne2000 --enable-cdrom

The configure command tells Bochs to prepare the make files,
enabling the network card and the CD-ROM. After configure has finished
checking and generating the make files, issue the make command. Then change to the super user (su) and issue the make install command.

Configuring Bochs
The Bochs operating environment is regulated by a single file, .bochsrc, which resides in the base directory.

Before you can install an operating system using the new emulated hardware, you need to create a virtual hard disk. From the base directory issue the following command:

$ bximage

================================================================
bximage
Disk Image Creation Tool for Bochs
$Id: bximage.c,v 1.19 2003/08/01 01:20:00 cbothamy Exp $
================================================================

Do you want to create a floppy disk image or a hard disk image?
Please type hd or fd. [hd] hd

What kind of image should I create?
Please type flat, sparse or growing. [flat] flat

Enter the hard disk size in megabytes, between 1 and 32255
[10] 500

I will create a 'flat' hard disk image with
cyl=1015
heads=16
sectors per track=63
total sectors=1023120
total size=499.57 megabytes

What should I name the image?
[c.img]

Writing: [] Done.

I wrote 523837440 bytes to c.img.

The following line should appear in your .bochsrc:

ata0-master: type=disk, path="c.img", mode=flat, cylinders=1015, heads=16, spt=63

In the session above I used bximage to create a 500MB drive named c.img.

Now edit the .bochsrc file in your favorite text editor. Scroll down to the ATA[0-3]-MASTER, ATA[0-3]-SLAVE section. Comment out everything below the example section by adding a # character in front of each line, then add the line as suggested by bximage above. Save the file, but don't close it yet.

Starting from the top of the file under the section ROMIMAGE, verify the location of the BIOS-bochs-latest file. This file resides in the bios/ directory which is under the installation directory.

Next, specify the MEGS (the amount of memory the virtual system should emulate) you want. The default is 32. If you want to run DOS that should be enough. In the section FLOPPYA: make sure floppya: points to the real diskette device. It's probably /dev/fd0, but check your /etc/fstab file if you're not sure. In the boot section specify the device you want to boot from. The default is floppy.
Save and exit the file. Now you're ready to run the new virtual machine.
What if you need to run your legacy Windows application on a Linux box, a Mac, or a Solaris-based workstation? To make the equation even more interesting throw in a few requirements --add transferring old legacy accounting data over the network, or using the backed-up data from a CD-ROM. And yes, you want to keep the costs to a minimum. An open source project called Bochs may be your best option.
To start Bochs, issue this command from the command line:

$ bochs

================================================
Bochs x86 Emulator 2.1.1
February 08, 2004
================================================
00000000000i[ ] reading configuration from .bochsrc
------------------------------
Bochs Configuration: Main Menu
------------------------------

This is the Bochs Configuration Interface, where you can describe the machine that you want to simulate. Bochs has already searched for a configuration file (typically called bochsrc.txt) and loaded it if it could be found. When you are satisfied with the configuration, go ahead and start the simulation.

You can also start bochs with the -q option to skip these menus.

1. Restore factory default configuration
2. Read options from...
3. Edit options
4. Save options to...
5. Begin simulation
6. Quit now

Please choose one: [5]

You can begin the simulation by pressing Enter. After a lot of messages scroll across the screen, you'll see the emulation window, which is like the monitor of your new machine. But since the drive the isn't formatted, you will get an error. Time to get a disk image.

Installing a disk image
To format and partition the disk you just created, you need FreeDOS, which is a free version of DOS. The latest version of FreeDOS is beta9.

Edit the .bochsrc file and scroll down to the section where you specified the hard disk image. The c.img file is the ata0-master device. Add the following line:

ata0-slave: type=cdrom, path="/home/bodhi/freedos/fdbootcd.iso", status=inserted

Change the path to point to the location where the FreeDOS ISO resides. Save the file and exit.

Run Bochs. From the main menu press 3 to edit the options, then press 8 to change disk options. Finally press 16 to change the boot device. Typing cdrom will change the boot device for this session to CD-ROM. Press enter three times to return to the main menu and start the emulation. This time you'll see Bochs boot into DOS. Use fdisk to create partitions and format to format them.

After you have formatted your disk, you need to re-edit your .bochsrc. Go to the disk section and comment out the ata0-slave line you added earlier. In its place add this line:

ata0-slave: type=cdrom, path=/dev/hdb, status=inserted

You can find the path to your CD-ROM drive from the /etc/fstab file.

Installing Windows
Now that your disk is partitioned it's time to install an operating system on it. I installed a licensed copy of Windows 98 Second Edition.

Put the CD in the drive. Start bochs. Edit the Disk options to boot from the CD. Start the emulation. Windows will scan the disk first and then you'll be taken to the GUI installation. Once you are done, start Bochs by pressing Enter on the main menu. Voila! There's Windows right on your Linux desktop.

Mayank Sharma is a freelance technology writer and FLOSS migration consultant in New Delhi, India.

tom@compaq:~$ cat sdk/bochs/bochsrc
###############################################################
# Configuration file for Bochs
###############################################################

# how much memory the emulated machine will have
megs: 32

# filename of ROM images
romimage: file=/usr/share/bochs/BIOS-bochs-latest
vgaromimage: file=/usr/share/vgabios/vgabios.bin

# what disk images will be used
floppya: 1_44=a.img, status=inserted

# ata0-master
ata0-master: type=disk, path="c.img", mode=flat, cylinders=1040, heads=16, spt=63

# ata0-slave
ata0-slave: type=cdrom, path="/home/tom/minix_R3.1.5-r5612.iso", status=inserted

# choose the boot disk.
boot: cdrom

# where do we send log messages?
log: bochsout.txt

# disable the mouse
mouse: enabled=0

# enable key mapping, using US layout as default.
keyboard_mapping: enabled=1, map=/usr/share/bochs/keymaps/x11-pc-us.map

Debian & Android Development

2010-04-18T21:03:00.000-07:00

Step 1, Java Development Enviroment
edit file "/ect/apt/sources.list" and add the following line

deb http://ftp.us.debian.org/debian stable main contrib non-free

Install sun-java6-jdk / sun-java6-jre / sun-java6-bin, which were non-free packages.
Use "java -version" to check that the java development enviroment is ok

java version "1.6.0_12"
Java(TM) SE Runtime Environment (build 1.6.0_12-b04)
Java HotSpot(TM) Client VM (build 11.2-b01, mixed mode, sharing)

If you have install gcc including the java development part, delete them (gij, gcj...etc) and make sure your system is using java 1.6 version

Step 2, Eclipse Development IDE
Download eclipse3.4 from www.eclipse.org and unpack it to your folder, I didn't install it by apt-get..

Step 3, Android SDK & Eclipse Plugin
Download android-sdk-linux_x86-1.5_r3 and ADT-0.9.1 from GoogleCode and install them as the manual said.

At last, don't forget to show your helloworld screenshot. ：）

Spring 3.0 on Google App Engine

2010-01-06T21:04:00.000-08:00

http://www.ardentlord.com/apps/blog/show/829881-spring-3-0-on-google-app-engine
-- Note: If you just want the nitty gritty without my blabbing, ignore the first paragraph --

So last week I got the inspiration to try out Google App Engine after reading about the new Java support. I searched around to find some resources on getting Spring running on App Engine, but the resources were surprisingly scarce. Google points you to their "autoshoppe" example, which is a little incomplete in terms of setup and what libraries you need. Ironically, Spring Source's post about App Engine was talking about using Groovy, not Spring. Finally I found a blog entry by Sikeh. So I got a nice Hello World up and running on Spring 2, thanks to Sikeh, but I wasn't satisfied yet. I wanted Spring 3. Spring 2 is so... 2008. So I started bringing in some Spring 3 (M2) jars, played around a little more, did some Googling, and finally got Spring 3 up and running.

Here's how you'll need to setup the directory structure:

Setup a Google App Engine project (I used the Eclipse plugin)
Download Spring 3.0.0.M2 (or the latest version)
Copy the following jar files from Spring into the /war/WEB-INF/lib directory:
org.springframework.beans-3.0.0.M2.jar
org.springframework.context-3.0.0.M2.jar
org.springframework.core-3.0.0.M2.jar
org.springframework.expression-3.0.0.M2.jar
org.springframework.web-3.0.0.M2.jar
org.springframework.web.servlet-3.0.0.M2.jar
Spring also depends on the following jars, which you can search for around the internet, or download from my Spring Example git repository:
antlr-3.0.1.jar
asm-2.1.jar
asm-commons-2.1.jar
commons-logging-1.1.1.jar
Finally, you'll need to rename the commons-logging-1.1.1 jar to something else, like commons-logging.jar (thanks to Martin for this tip!)

Next, you'll need to configure your web.xml for Spring. In web.xml I added a catch-all mapping to my Spring dispatcher:

<servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/*</url-pattern>
</servlet-mapping>

WARNING: If you use a catch-all (/*) url-pattern, the application will not work in development mode (locally), but will work on the AppEngine server. I believe this is a known bug.

For my dispatcher-servlet.xml: (also in /war/WEB-INF/)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
        <context:component-scan base-package="example.controllers" />
        <bean id="viewResolver"
                class="org.springframework.web.servlet.view.InternalResourceViewResolver"
                p:prefix="/WEB-INF/views/" p:suffix=".jsp" />
</beans>

You obviously want to change the base-package to whatever package you want. I use the InternalResourceViewResolver, and put all my views in /WEB-INF/views/. Finally, here's my (uninteresting) applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
    "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
</beans>

Now we're all done with setup! Just create a controller and a view. I made a simple hello.jsp view that outputs the request parameter "name". Here's the controller:

package example.controllers.hello; 

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping; 

@Controller
public class HelloController {
        @RequestMapping("/hello/{name}")
        public String hello(@PathVariable String name, Model model) {
                model.addAttribute("name", name);
                return "hello/hello";
        }
}

So there you have it. Spring up and running on Google App Engine. You can see it in action at http://springexample.appspot.com/, or you can get the source at http://github.com/idris/spring-example-gae/. For now, this is all just a Hello Wold. I'll post more functionality later... Feel free to suggest topics in the comments!

溜798

2009-12-20T21:06:00.000-08:00

"Good day"
——迪卡·凯恩

在这样的日子里
我想变成一只肥嘟嘟的野猫
在一个没有人的墙角
打着哈欠伸着懒腰
享受着冬日暖阳

那些干枯枯的枝丫上
挂满了灵魂凋零的叶子
在寒风中瑟缩着
我本以为是槐花开了

把脑袋再往领子里缩一缩
接着走吧

暴中轴线

2009-12-12T21:06:00.000-08:00

三环至四环之间
中轴线西侧的建筑群挺有特色
推荐感兴趣的同学前去观光
此外
这个季节
森林公园适合两个人在傍晚时分散步
当然也适合诱人的糖葫芦

linux线程同步

2009-12-07T21:05:00.000-08:00

南极下了冻雨，北极熊都冻死了

job_queue.h

#ifndef JOB_QUEUE_H_
#define JOB_QUEUE_H_

typedef struct job{
  struct job* next;
  char data;
} job_t;

void init_queue();
void* eq_thread(void* arg);
void* dq_thread(void* arg);

#endif /* JOB_QUEUE_H_ */

job_queue.c

#include <stdio.h>
#include <malloc.h>
#include <pthread.h>
#include <semaphore.h>
#include "job_queue.h"

job_t* queue;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t queue_count;

void init_queue() {
  queue = NULL;
  sem_init(&queue_count, 0, 0);
}

void enqueue(job_t* new_job){
  pthread_mutex_lock(&job_queue_mutex);
  new_job->next = queue;
  queue = new_job;
  sem_post(&queue_count);
  pthread_mutex_unlock(&job_queue_mutex);
}

job_t* dequeue() {
  job_t* next;
  sem_wait(&queue_count);
  pthread_mutex_lock(&job_queue_mutex);
  if(queue == NULL){
    next = NULL;
  } else {
    next = queue;
    queue = queue->next;
  }
  pthread_mutex_unlock(&job_queue_mutex);
  return next;
}

void* dq_thread(void* arg) {
  job_t* next;

  while(1) {
    next = dequeue();
    if(next!= NULL) {
      fputc(next->data, stderr);
      free(next);
    }
  }
}

void* eq_thread(void* arg) {
  job_t* job;

  while (1) {
    job = (job_t*) malloc(sizeof(job_t));
    job->data = 'X';
    enqueue(job);
    sleep(1);
  }
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "job_queue.h"

int main(int argc, char** argv) {
    pthread_t thread_1;
    pthread_t thread_2;

    init_queue();
    pthread_create(&thread_1, NULL, &dq_thread, NULL);
    pthread_create(&thread_2, NULL, &eq_thread, NULL);

    pthread_join(&thread_1, NULL);
    pthread_join(&thread_2, NULL);

    return EXIT_SUCCESS;
}

故地重游

2009-11-25T21:10:00.000-08:00

这个季节
外面的风景是美丽滴

满山橘红色的柿子
路旁一排排黄绿相间的白杨
石壁上布满红彤彤的爬山虎
宁静的小河上漂几片竹筏
格兰外懒洋洋的阳光
透过随风微微颤动的树叶在地上画上斑驳的身影
还有古朴的小山村
那一堵堵石头墙
在岁月的敲打中迸开的一道道裂痕
多出去走走吧

看客

2009-11-18T21:07:00.000-08:00

看完《2012》
等着看狮子座流星雨
最近自己越发懒惰了
懒得不想写任何东西
只想在一个小店里坐着
看橱窗外的车水马龙
及那些匆忙赶路的人们

片刻安宁

2009-11-16T21:07:00.000-08:00

在清华园的一个无人的足球场看台上呆坐一个下午

阳光明媚

天有点冷

大礼堂外有些个着迷彩服的学生练唱歌

应该又是个什么演出吧

还有些个拍婚纱照的

冬日暖阳沧桑的建筑衬托着洁白的婚纱

去图书馆淘几本书

书非借不能读也

没地方借书可读
一直是毕业后唯一让自己最头疼的事情

计划买把好一点的吉他

有些事情总要善始善终

第三场雪

2009-11-12T21:08:00.000-08:00

已经是第三场雪了
还是写点东西吧

即便绚烂多彩的秋天很美丽
仍旧最喜欢冬天
将一切掩埋
让你保持冷静

一个陌生的城市
晚上有人陪着喝酒
是很难得的一件事

爱情不是怜悯
也不是找保姆
它悲喜交加
让你笑，让你哭
让你亢奋，也让你萎靡
为什么不找喜欢的人呢？
为什么不呢？？？
大概是累了
自我妥协了
不想再坚持了

你相信那些命运所说的吗？
我不知道
也罢
随ta

第一场雪

2009-11-01T21:09:00.000-08:00

1、北京初雪

2、迁至新源里琨莎对面

3、WeRunner Beijing Group二次小聚

今天台湾国庆节来着

2009-10-10T21:11:00.000-07:00

向所有发来贺电的筒子们致意真诚的谢意

若不是下午老大提醒又会忘记了

晚上跟涛哥去麻辣香锅

近期身高增至174+, 体重下降至110-

长了三个月的头发开始有点上次六个月的感觉了

乐子一则：某人下车，忽内急，遂入一动车行便，顷，车始行..

关于逝去

2009-09-26T21:11:00.000-07:00

我们每个人都有可能随时死去.

而且，我们也终究都会逝去

所以，我并不祈求上苍给了我多少时间，只管近自己最大的每天努力去拼..

《Knowing》里的两种理论

：一切都是事先安排好的，包括地球和太阳的距离正好可以使生物繁衍，包括04年的秋天正好有58个人走在一起

：一切都是随机产生的，包括出生、死亡，生命中某些人的出现和离开，包括我们的所想所作都是没有意义的..

兄弟，走好

多线程理论之如何有效的使用公厕

2009-09-21T21:12:00.000-07:00

记得小时候，在一个陈旧的书房里翻出一本《寓言》，有文曰《两小儿辩日》.其实，我更希望他们两个在下棋。棋盘只有一个，棋手有两名，每个人下完后都会播一下旁边的计时器，并说：我下完了，该你了

突然间这又让我联想到好多的人去挤公厕。当你神清气爽后，从容走出，放眼望去，芸芸众生皆手捂住下体，脸上挂着隐忍的表情。这时，你喊了句：大爷爽完了，该你们了。然后众人便疯狂涌向门口。但是，地球人都知道：一次只能进去一个人，而生物界内的竞争经常会导致种间或者种内斗争，于是会演变为暴力，人们互相争抢，有肯能会导致一些人永远没有机会而导致活人被尿憋死。这不是我们想看到的。

于是乎，世间产生了“规则”这个词儿，排队！
我们安排一急具权威的管理员坐在门口，给第一个人一个令牌，上书：大内密探，急入厕，如有拦着，格杀勿论
这时，我们有很多个规则
1, 免费公厕：每个人只能爽一次，名单都在内部墙壁上，入厕者爽完之后划去自己的名字，出门告诉管理员下一个人名，管理员把令牌给这个人
2, 收费公厕：每个人要攒钱，谁最先攒够多少的资本就优先拿到令牌
3, 皇宫公厕：皇帝贵族有优先使用权力
4, ......
我们的目标是建设社会主义下的有组织有纪律的入厕方案

下面只是一个特例，比如你和一个姑娘同住，约法三章：轮流使用洗手间，并且不能连续2次使用；
该理论适用于任何公用物品，因为所谓线程同步就是因为竞争公用资源导致的，比如黑板，租车，小时候和弟弟妹妹抢唯一的一个口琴玩....

public class YouAndGirl {
    public static void main(String[] args) {
        boolean[] toilet = new boolean[1];
        new Thread(new You(toilet)).start();
        new Thread(new Girl(toilet)).start();
    }
}

class You implements Runnable {
    protected boolean[] mutex = null;

    public You(boolean[] mutex) {
        this.mutex = mutex;
    }

    @Override
    public void run() {
        for (;;) {
            synchronized (mutex) {
                while (mutex[0]) {
                    try { mutex.wait(); } catch (InterruptedException e) { }
                }
                System.out.print("A");
                mutex[0] = true;
                mutex.notifyAll();
            }
        }
    }
}

class Girl implements Runnable {

    protected boolean[] mutex = null;

    public Girl(boolean[] mutex) {
        this.mutex = mutex;
    }

    @Override
    public void run() {
        for (;;) {
            synchronized (mutex) {
                while (!mutex[0]) {
                    try { mutex.wait(); } catch (InterruptedException e) { }
                }
                System.out.print("B");
                mutex[0] = false;
                mutex.notifyAll();
            }
        }
    }
}

十三陵暴走

2009-09-08T21:13:00.000-07:00

6:00爬起洗簌，13线(知春路)转2线抵积水潭，B口出东行至德胜门(6:50)
路南一小店早点，豆腐脑及油炸食品
7:15行至345站
7:40+左右前往朝凤庵
略.
集合后，出发

中石化昌平会议中心
十三陵水库管理处（貌似有个厕所）
右侧高尔夫球场及大坝
沿路前行，有一队结婚车打酱油路过
然后就是沿着水库路走啊走阿走啊
印象中到了一个地方左拐然后右拐，有人买了水和食物
到一个路口排了长长一队的货车
然后走啊走到一个 “十三陵欢迎您”的大路牌，门票30米
又是漫漫长路
应该是沿着胡泰路走的，因为路过一个柿子山庄和雪世界滑雪场
之后右拐沿万西路抵悼陵监，路有乌鸦叫，及遇牛数头
右行到达思陵碑合影，走的时候在想：门口那个无头石像来一句いってらしゃい
后沿石头路上行沿万西路继续走阿走啊
万娘坟，一面旧城墙一颗很粗的树还有无处安放的春情
上行遇重污染卡车数辆，穿过一座桥，右拐沿环陵路抵昭陵博物馆，有一个大屏幕
东行小憩，炒饼，第一小组撤退（可以找到那个餐馆的房顶XD）
向上抵达定陵，上行至昌赤路，左行
裕陵，茂陵，康陵，泰陵（应该是最远的那个了，而且，这里有个厕所，小喇叭没电了）
沿昌赤路返回至庆陵（应该是这个地方有人喊着：里面是果园子，别往里进！）
献陵
之后是长陵，景陵村，烤鸡翅及另外一个厕所
环陵路至永陵（两头牛一头毛驴在吃草）
说是永陵上行500米即德陵，而我们则左拐左拐再左拐
从下面沿着北新村绕了一圈
然后下去到水库路坐车返回至345站

注：凭记忆及Google Map杜撰，略有出入
更多细节关注这里

实验结果
-------------------------------------------------------------------
左脚磨泡若干（其中大拇指上2枚），泡破，磨干，磨出点点鲜红
右脚磨泡，未破，膝盖部位有拉伤，第四脚趾指甲丢失一半
右臂无法抬至肩膀以上
左臂幸存
实验结论：帆布随好，可以让你感受到大地的质感，但真不适宜远足

这一天

2009-09-05T21:14:00.000-07:00

早上下雨，很大很大..

从家门走到地铁的过程，背包被淋湿，裤腿被淋湿..

每天固定时间起床，乘固定点的那趟车，整洁的就像白纸上标直的铅笔线条...

地铁上电话想起，旁边一哥们掏出他的手机看了看，又放回去，这时才明白是自己的手机在响，这该死的Nokia铃声

卓越上订购的石头送达，同时收到公司为每个月度过生日的人发的礼金

到处标着“开复老师离职”的头条，同时自己邮箱收到另一个离职内幕，一个乐子，也是一个悲哀

邮件，呵呵，最近发现每天收到的Email数量远远超过收到的短信量

一个人久了，会经常忘记带手机，会想着买各种各样的鞋，会期待着到很远很远的地方....

收到老鬼的消息，天气突变，原定周六130的暴走计划推迟至周末

如果周末继续下，推迟至下周，下周还下，继续推，再下，就找面墙去撞

不过这样也好，周六就可以去新浪的Python讲座，或者是去轩辕互动的Coding for Fun

twitter被封，饭否被禁，而后有了围脖，咪咪.... 他们一向只许州官放火，不许百姓点灯

美国人发明东西，日本人把东西做好，韩国人把东西做烂，中国人把东西做得大家没钱赚

想到上次Open pary上某研究院对于Ophone＆Open source以及赚钱的认识

而后看到他们回去写文章的技巧，对Open party只字未提，大有CNN风范

说实话，自己自心底的严重BS这种恶俗低劣的行为，MD（一种音乐设备）

在路灯下溜达了3个站的路程，而后才有心情搭上末班回家

这段时间，自己极力避开听一些音乐，看一些文章

可每一次这些东西都会不经意间跳出来，在你面前活灵活现

洗澡的时候，切菜的时候，路上踢到一颗小石头的时候...

能够自我安慰的是，始终在思考；

人的一生，刨去幼年和老年，以及睡觉、吃饭等时间，剩下的没多少了

即便我们醒着时间很多，思考的时间却很少

曾经有一段时间乘地铁的时候特别喜欢观察人们的神情，眼神，并揣测他们在想什么..

“每天花2个小时在车上，意味着1年的12个月中有一个整月是在车上度过”

每次想到这个都感到十分的恐惧和内疚

"你说他是不是非主流"，这是两位同事关于我的讨论

事实上，根本没有什么主流和非主流，这是个相对的中性词，我只是一直极力保留自己原本的样子

那个数夜逃课不归，每天爬在桌子上睡觉，雨天一身臭汗飞奔球场

数次与老师们发生冲突甩门而去并在教学楼的一角深深刻下“我有理由为我之所以为我而存在”的短语的孩子长得稍微大点的样子

迷失，是一件很可怕的事情，而事物的质变源自内因，外因只是推动作用

你可以控制很多事情，而多数人往往忽视这一点

Impossible is nothing, 我喜欢那些广告词

"鸟，来到这个世上不是为了躲枪子，是为了做它应该做的事情的。如果因为做了应该做的事情而注定要挨枪子，那就认了"

以上是老罗在吉大演讲中的句子

在BBS上翻到一个谈理想的帖子，一位同学道：小时候我们都抱着远大的理想，想做就做，现在，呵呵...

炼金术士的原则：等价交换

你们只是害怕失去，然而又有什么是不可以失去的，反正终究会失去，只是个过程而已？

这本身就是一个混沌，物质，精神，道德，伦理....

回来的路上听一路的歌，那些以前没注意到的东西在经历过一些事情后竟发现是如此的唯美

现在又是凌晨1:30，插着耳机睁一只眼闭一只眼的写这些文字

很累，很困，但要坚持

人的一生中，有一些重要东西往往是因为丁点的松懈而消逝，很远很远....

我，只是一个普通人，偶尔想些事情，写点程序..

人来人往

2009-08-28T21:15:00.000-07:00

凌晨的王府井大街路边凳子上睡着的那些无家可归和有家不回的人勾起我想和他们一起坐教堂门口一直聊天到天亮的强烈欲望

眼袋消完后那没有血色的眼角膜是你被岁月摧残即便是像野狗一样疯狂反抗最终依旧会败下阵并开始被苍老吞噬的最好的例证

送李伟

12点多从机场回到王府井

溜达过那条街已是凌晨1点半

在灯市口站旁边的南苑e家住一晚

早上9点背着包上班去

完鸟

草原他乡

2009-08-23T21:15:00.000-07:00

沉睡中的城市

出城一路向北

京北，多山

隧道、河流、大片风力发电，山间绕来绕去

沙城，赤城，雕鹗镇，清真风格建筑

向北6个多小时丰宁满族自治县继续，大滩镇，再北就是蒙古.

东衫国际假日酒店（GoogleMap坐标 41.609974, 116.003188）温室花园，令人吃惊的蓝天，浮云，空气.

骑马，听养马人的故事

夜晚的篝火、烤羊，大厅到12点，星辰，背单词1点

7:30起，冬日暖阳

6辆吉普撒欢儿，羊肠小路上飞奔，野性的风，躺在后面看天，灰机，后面的滚滚红尘，路人

真正的小山村，陈旧的土房（影视《我的父亲母亲》），石头墙，草原平坦的河流，羊群，远处山坡上一簇簇灌木丛，远处的白桦林，草间不知名的虫叫

蓝天，白云，暖阳，肥沃的草地，蜿蜒小河，羊群，马儿，小山村，白桦林，车轮，野花，山泉...

：这就是我想要的生活

回来用了8个多小时－－！

在此招募人马国庆节，去看层林尽染

璐璐鱼头签

2009-08-21T21:16:00.000-07:00

2点爬床7点爬起
目标：东直门外大街26号
8:05抵达，用时53分钟

如果不想拥挤的地铁，要么起早（7点以前），要么晚起（10点以后，不过会有一些老人和孩子）；
遇到第一个推销机票的，不好意思拒绝
遇到第二个的时候，不得已告诉他“不好意思，其实已经定过了”
然后，看到第一个推销者奇怪的表情

自从搬到三层后，消息就一直很闭塞
中午抽风的去了趟十二层，被告知去领体检卡；进门被问：够30岁了吗？
我这刚过20没多久的人有那么苍老吗..

晚7点，坐在地铁门口听一个人拉小提琴
我的认知中，大街上的乐者大致上分以下三种
1、职业级的流浪歌手，总会在城市的某个角落里经常见到他们
2、业余爱好者，闲暇之余，溜达溜达，给大伙儿带来些许快乐
3、怕在家练琴影响邻里而转移至大街者

跟璐璐同学去鱼头...
1年没见，头发短了
别人说胖了
自己没怎么觉得
倒是更熟了
此外，我真的长高了吗？
有机会找个许久不见的人来证实以下..

最后
对地铁通道里喊我名字的那位靓丽的姑娘说
对不起，最近视力急剧下降，没看清恁是哪个？
不过，漂亮是肯定的

那些天

2009-08-19T21:16:00.000-07:00

我喜欢穿着靴子扯着风筝到处跑，直到风筝挂到树上或者高压电线上

我喜欢五月里飘香的槐花和那一墙绿油油的爬山虎

我喜欢小动物，即便是7岁的时候养死过一直兔子以后再也没讲过任何东西

我喜欢浮动的水草，悠闲的鱼儿，以及芦苇丛中时不时窜出来不知名的鸟儿

我喜欢小时候家门口的那片林子，印象中记得每一棵树的位置和样貌

我喜欢宁静的夜晚，躺在席子上，听着草从中蟋蟀的吱吱声，数满天空一闪一闪的星星

我喜欢下雨天，坐在门口，看院子里梧桐树下溅起的一个个水泡
----------------------------------------------------
以前奶奶家有一颗巨大的桐树，要三个人手拉手才能抱起来
树上有好多洞洞，里面住过啄木鸟、猫头鹰还有马蜂
12岁那年，树死了，树干中间都空掉了
我仔细的数过那个年轮，有30多圈
----------------------------------------------------

我喜欢路边那厚厚的落叶，还有傍晚十分远处飘起的袅袅青烟

我喜欢某一天醒来的时候哦，大雾弥漫

我喜欢听一晚上簌簌的飘雪声，第二天早起数地上喜鹊们的脚印

我喜欢到一个杳无人烟的地方，躺在大片的雪地里，听远处树林传来阵阵的伐木声

我喜欢寒冷冬天，室外篝火架上的炉子冒出一股股的热气

我喜欢出生后的那个季节，即使不管自己怎么努力，都只能想起3/4岁以后的事情

其实，只要是发生过的事情，我们都会永远记得

所说的忘记，只是不愿意想起

12岁的那年
冬天有大雪，冰榴，结冰的池塘，人和鸟的脚印，火炉，长靴；
春天有花草，虫子，清新的茶树；
夏天有知了，莲藕，板栗，蜈蚣，树荫和小说；
秋天有桑枣和美丽的地霜，还有成群结队的伙伴；
如今只剩下水泥和汽车....

2009/08/19 03:08 北京雨夜
---------------------------------------------------------
最后，我讨厌一篇日志写三次

小蜡笔

2009-08-09T21:17:00.000-07:00

每个人都应该用自己的双手

像小时候一样

用蜡笔把天空涂成五颜六色

周末是自己的

背着电脑去一个安静、温馨而又可以满地打滚的地方

通宵达旦的做自己想做的事情

Coding~ :-)

蹲坐在宾馆的地毯上看电子书

床上的同学睡的正香

电视里播着一个称作《快乐女生》的节目

很轻很轻的歌声～熟睡的喘气声～键盘声～

窗帘外夜幕中足球场边的小路

在路灯的的偎依下

暖暖的

这是一个安静的夜晚

同时，也是一个容易让人思考、想念、陷入纠结的夜晚

甜蜜的、温暖的、伤心的...

藏在记忆中的那个夏天

2009/08/07(秋)

时间点 12:34:56 按照HH:MM:SS:d:m:y的格式是 12:34:56:7:8:9

2009/08/08(奥)

2009/09/09

2009/10/10

...........

时间过得好快...

努力~

Busy or Easy

2009-07-29T21:18:00.000-07:00

马儿好

马儿跑

我的马儿不吃草

冲啊~~冲啊~~哈~~！

もう我慢ばっかしてらんないよ
言いたいことは言わなくちゃ
帰り道 夕暮れのバス停
落ちこんだ背中に Bye Bye Bye
君のFighting Pose
見せなきゃ Oh!Oh!
夢にまで見たような世界は
争いもなく平和な日常
でも現実は日々トラブッて
たまに悔やんだりしてる
そんな Rolling days

転んじゃったって いいんじゃないの
そんときは笑ってあげる
仱贽zんだバスの奥から
ちいさく ほほえみが見えた
君を頼りにしてるよ Oh!Oh!
夢にまで見たような Sweet Love
恋人たちは隠れ家を探すの
でも現実は会えない日が
続きながらも信じてるの Rolling days

つまずいたって Way to go !!
Yeah!! Yeah!!
泥だらけ Rolling star !!

なるべく笑顔でいたいけれど
守り抜くためには仕方ないでしょ?

きっと嘘なんて そう意味を持たないの
～All my loving
そうじゃなきゃ やってらんない

夢にまで見たような世界は
争いもなく平和な日常
でも現実は日々トラブッて
たまに悔やんだりしてる
そんな Rolling days

…そう わかってるって
つまずいたって Way to go !!
Yeah!! Yeah!!
泥だらけ Rolling star !!

想念狗尾巴草

2009-07-21T21:18:00.000-07:00

我承认自己最近越来越懒了..

其实

我只是想一个有大块草坪的地方

野花丛生

嘴里叼一根狗尾巴草

躺下去,看蓝蓝的天空,白云朵朵

清风拂过,有蝴蝶和蜜蜂在身边飞舞

看蚂蚁拖着一个比自己身体大很多的草籽慢慢爬

什么都不用做，什么都不用去想

就这么躺着...躺着...

慢慢睡着.

Come from XKCD

Illustration - mechanics

2009-07-19T21:19:00.000-07:00

寡人最喜欢的画风

╮(╯▽╰)╭

最终还是喜欢在代码模式下写文章

在Time上翻阅到一篇Super Wheat的文章

看时间Monday, Mar 26, 1928

信息啊，为什么国内就没有一个地方随时翻阅历史某一天的记实呢？

更恶心的是写论文的时候，搜罗到得一些什么文献库统统的注册, 充值…

MIT描述着Goes to the Moon的时候

HIT却写着某某会议召开、某某人士来访、某某重要讲话…

悲剧…

--------------------欠揍的分割线---------------------------

memo: 今天，突然不记得自己多少岁了, 拿笔算了一下...

啊~~

补一句：外面好像下雨了

洗澡爬床去~_~

Dream

2009-07-18T21:20:00.000-07:00

逯总说

生活就像是电影

现实中的事情每天都戏剧性的变化

我只能控制自己

还有许多事情要做いろいろ

年轻就要有梦想 I like it

我忙碌，我快乐

蚂蚁~嗯~是个好ID

sukida-->すきだ-->好きだ-->喜欢

恩

memo
----------------------------------------
A: 早上睡过头，明天早上不能去海边看日出，悲剧了
B: Live Writer & SouGou兼容性bug（一个输入法，要那么多快捷键有什么用？）
C: 支付宝刚出的插件与不同版本的FF兼容性有待考究
D: 不想女人（梦到的不算）

todo
----------------------------------------
日本語↑
VBA (他们称之为国粹)

New Day, New Style, New Life

2009-07-17T21:20:00.000-07:00

长了5个多月的头发

今天，哦不，是昨天，剪了

而且剪得很漂亮~哈~哈~哈~哈~

上次长了6个月，因为是冬天- -！

下班后乘坐1个多小时的地铁后转公交

特地跑到2年前在望京那边住过的小区剪的

路过卖早点的商店、以前每天都会走的小路以及两边的树、藤

仿佛又回到了2007年

环境好亲切，突然想下一次再搬家的时候搬回去住

╮(╯▽╰)╭

现在的手机不能拍照了，扔家里当座机用

其实，没有手机、没人联系、没有烦恼的时光真好

豆瓣上溜达一圈

春天过去了，失恋的人渐渐多起来了

一个姑娘说，她的FirstKiss给了一个说过要保护她的男孩

如果，一个男孩说，FirstKiss给了一个说要离开的姑娘是不是更显悲剧色彩呢？

人类真是种喜欢自虐的动物

想伸手抓住一些东西，却又不想失去另外一些，这严重违反《等价交换》原则

而且还经常做一些与自己想法完全相反的举动，何苦呢？

人都会很快的老去并消逝

等到步履蹒跚的时候想想年轻时候的事情

是唉声叹息“就这样吧”？还是后悔呢？

最终都不是自己想要的吧

应该每天早起，指着镜子说：怎么想的就怎么去做好了，Do your best!

Impossible is nothing~~

自己始终坚信，并将永久的持续贯彻下去~~

想起08年的十二月在以前博客上发过的Mr. Brooks的台词

恍惚间又回到了那年的冬天，阳光暖暖的....

Why should we suppress their desires?
God gave me quiet
So I accept that I can not change
Give me the courage to change my best to change
And would only let me go to tell the difference
Believe in God
I only will your submission
Everything will repair Straight Alliance of Reformed
So
I can celebrate this life
Hereafter will be the same with God
The cause of a symbol of happiness
Amen
——————————————————————————————
为什么要压抑自己的欲望呢？
上帝赐给我宁静
让我接受我所不能改变的
给我勇气改变我所能改变的
并只会让我去分辨两者的不同
相信神
我只归顺您的意志
凡事定会归正修直
如此
我可欢度今生
来世也将与神同在
永享无上的幸福
阿门

这张图是用来凑数的

就是那只从天而降并最终被我成功养死的兔子

At Last

2009-07-17T07:13:00.001-07:00

博主已死

路人

2009-07-16T21:21:00.000-07:00

（鉴于逻辑混乱，删除此处500文字，因为我曾经最喜欢、学得最好的科目是数学和物理）

地铁上见一人穿一T恤，印：情侣去死
------------------------------------------------------------
男男女女纠缠在一起除了有助于人类繁衍

本质上还有什么积极的意义？

求解（忽略人类意念出来的感情）
------------------------------------------------------------
通常所指的寂寞了，多数是由于自身的惰性或者模仿的本能

A:10个人中有8个人成对，剩下的2个人就会认为向那个方向发展是应该的，不做则受谴责

B:惰性所指为需要个人照顾自己，生病有人陪，看电影有人陪，吃饭有人陪...gay或者lala，只不过是想找个人陪而已
------------------------------------------------------------
这个星球上与自己同类的生物有60多亿

某个时间某个地点遇到这批同类

另个时间另个地点又遇到另一些同类

生物之间互相在对方的大脑的记忆体力留下模糊的或终究会变模糊的印象

同时人本身的惰性又不希望事物发生太大的变化

“你来我信你不会走，你走我当你没来过”

今天在twitter上看到的一句话.
------------------------------------------------------------
熬夜除了影响抵抗力、导致消化系统疾病、皮肤没有弹性

与是否得脑瘤没有直接关系

so，头疼的话不用担心
------------------------------------------------------------
贝贝同学的一篇文章描写了我现在的心理波动《你们太自私鸟》
------------------------------------------------------------
弱小生物喜群居，生命力顽强不需要照料者喜独居；参考蚂蚁与霸王龙
------------------------------------------------------------
如果你感觉无聊了，Coding吧

如果你烦躁了，就去做数学题，而且要用手握着铅笔算，把脑袋算累了你就没时间去烦躁了
------------------------------------------------------------

路途中所有的人;都只是自己的过客;没有谁因为你的存在而停留

—— 路人甲 2009/07/16/02:30

Rain

2009-07-14T21:21:00.000-07:00

流水账

周末同涛哥、亮亮去烧烤

然后到旁边的一家小店里要了3大杯扎啤

服务员问：先生还要别的吗？答：不用了，谢谢！

你可以想象一下服务员的表情，还有那差异的眼神。

结束后出门碰见MissYu领着大票人马去KTV，追随而去

酒精，缺氧

对于消费类的会员卡，指定卡的有效期是一个明智的决策

12点多从文津国际出来的时候，雨下得正大

突然很想找个兄弟在电闪雷鸣的暴雨里打一架

或者在雨里走回去也好（因为从五道口到科院的距离足以把人的衣服淋透）

然后得一场大病卧床不起（印象中好像上次见医生是07年冬天的事情了）

像我这样生活规律的人道现在居然还能健康滴活着对医院的那些人是不公平的

不明白上面的老头怎么想的

想起那次陈琳、老大还有恒太等人一起淋着雨从山大到糖酒站的情景

以及售货员那看火星人的眼神

美好的回忆~~呵呵~~

不知道还有多少人记得

随着人类的成长脑细胞的不断分裂会导致忘记一些东西

只有那些受到强烈刺激的记忆才能保留下来

所以要经常做些另类的事情

要不生活也太枯燥或者你已经老了

最终我这个小小建议被否决并被同化着打的回去

这里又有一个错误

我之所以喜欢并习惯于一个人的生活

“自己的生活规律不好，怕影响别人”是其中一个原因

另外一个是

与很多人在一起的时候，一个人的思维容易受限或受影响

就像我们高中的时候都认为80是一个很低的分数，而现在却为拿到60分而沾沾自喜

人们都是在不知不觉中发生变化

不管这个社会营造的环境是好的还是坏的，都在不知不觉中欣然接受而不去思考为什么

性格的、观念的、习惯的...

memo: 人类之所以有痛苦，多数是由于感情导致的，扔掉感情就Free了

Flicker的图片保护做得太弱=所谓的安全都是对土鳖说的

Done！

The rule

2009-07-12T21:22:00.000-07:00

You are not your job

You're not how much money you have in the bank

You are not the shoes you wear.

You're not the car you drive

You're not the contents of your wallet

You're not your fucking khakis.

You are the all singing, all dancing, crap of the world

亡灵

2009-07-11T21:23:00.000-07:00

var sleepTimeAverage < 5h/d

半年前症状
------------------------
12:30睡觉
8:00爬起
------------------------
为此曾经还查阅过相关资料
来自日本的学者称：人类每天睡眠7个小时死亡率最低
我深信这个数据的正确性（因为日本是一个严重过劳死突发的国家）
甚至还庆幸自己属于这个安全范围之内
现在症状
------------------------
3:30~4:30睡觉
9:00爬起
------------------------
一天有36个小时
一周有8天
且每日2餐依旧无食欲
也许
该去看医生
或许
任其自然
喜欢上面这个词
因为一切事物的发展都是遵循自然的
自然的发生到自然的结束
精彩的只是这个过程
It's a programmed game
世界上不眠者的最长记录是200小时依然保持身心正常
It' a challenge, just like the 233m Bungee Jumping
Glad to be with you

丝妮

2009-07-11T21:22:00.000-07:00

《战争机器》里的重型战车pk《士兵突击》里的吉普

Peter的重音响

上下铺

卫青

Σ∫sinα/α(α->∞)

北京102年产的越南牌香烟

造假的邮票以及车牌

10年前的老爸

..........

以上

这就是刚才一个小时内逻辑混乱的梦境

醒来后

旁边的哥们在看《阳光灿烂的日子》

然后用被阉割的网络Post这篇荒诞不经的文字

同时想起了一位姓L的同学

突然想去淋一场大雨

memo: L --> 雷

听

2009-07-10T21:25:00.000-07:00

¶♩♪♩♩♬♪♩♪♬♫♪♬♭♩

夜

明亮的街灯

还有一颗格外清醒的心

我想如果世上这样一种叫花未眠的花

那它一定是世界上最美丽的花了

有时候把川端康成的景色小说和挪威森林里的某些情景混合在一起

有一种幸福的感觉

就象心中的未眠花

即使看不到摸不到

但它却长开在心中不会凋零

记得你说过的每一句话

记得你写过的每一篇日志

记得每一次见到你时的样子

想象着牵着你的手儿在海边散步

在广场上给你一个大大的KISS

就当那光秃秃的主楼是个金字塔吧

只是想让你开心

像孩子般开心的笑

我好像又做傻事了

这样也好

等我们都老的时候就能有好多好玩的回忆了

过去一年了呢

6月的海风吹动白色的裙摆

7月离别的季节黑色法袍

卡其色 - -！就是我说的那个土色 .....

感情是个很奢侈的东东

距离产生美也产生距离

只想简简单单的在你身边

不让桌角磕到pp

不让水果刀刺到小手

感冒都让我来

所有痘儿都让我长

这样你就可以想吃什么就吃什么

还要拎着一大包鸡蛋躲到你后面穿过最热闹的人群.

还记得哈尔滨的第一场雪吧

那个时候的路人甲

上面的那个老头总是捉弄我

这次我相信是他老人家的安排吧

我这只傻了吧唧缩在壳里记忆力差得要死的木头蜗牛

不知道怎么能把上面的事情记得那么清楚

各位围观者们

有时候我都不知道自己是谁

完全是一个被雷击的性格分裂者

发一些笨的要死的邮件打一些傻得要命的电话

回来的路上晕乎乎的脑袋组织着一堆堆的碎片

就像毕业的时候想抱着一大群王八蛋们一起哭

毫无掩饰真实的青春宽恕我今天又是半夜爬床吧~

Good night honey~

等你回来~

跟你玩泡泡~

遗失的幻觉

2009-07-10T21:24:00.000-07:00

现在是2009/07/10 03:22

昨天又一次几近失眠，凌晨4点多才有睡意

9点多大脑混沌

11:30恍恍惚惚上班

改善几个代码片段

剩下的整个下午几乎是趴在桌子上看书

突然想起在学校的时候实验室的桌子

“自习”这个久远的字眼

不禁让人怀想起学校的那片蓝天、那片海

收到京东送来的手机

这是我的第7个

截至目前共使用过6个，丢3个

24 h/d = sleep(6) + working(8) + subway(2) + dinner_wc_xxx(1.5) + study_selfCoding(6.5)

北回归线

2009-07-10T21:23:00.000-07:00

墙外的blogspot

荒芜多日

好奇心强的同学可以过去瞅瞅（梯子自备）

谨献一米阳光

Happy children's day

2009-06-02T06:26:00.001-07:00

首先捏，大半夜的祝天下的所有小盆友们节日哈皮^_^..
假期结束，预计迎来一个繁忙的夏天.
十分怀念学校后面的那个海滩
这个季节应该是最美丽的吧

Game:Officers

2009-06-02T06:23:00.001-07:00

又一个二战题材的RTS
绚丽啊绚丽~~

游戏名称：指挥官
英文名称：Officers
制作厂商：3A Games
游戏发行：Tri Synergy
游戏语种：英语
游戏类型：Historic Real-Time Strategy
游戏平台：PC
官方网站：http://www.trisynergy.com/products/157/details/Officers

マスカット闲言碎语

2009-05-25T10:29:00.001-07:00

Blogspot被河蟹
YouTube被河蟹
-------------------------------------------------

Copyright(C) 2006-2009 マスカットプロジェクト
-------------------------------------------------

近几天看的一个东西，データ自己的Ajax框架，一个Open的项目。有时候，你不得不佩服日本人做事情的态度，细腻的让人惊讶，所以这个岛国二战后的迅速恢复不是偶然，是必然。利于统治和布道的东方儒家思想在其他地区得到较好的保留和发展，而我们自己似乎在那个屈辱的年代把这些都丢了，同时沦落为一个流氓一样的神圣的国度，没有信仰，腐烂...
态度决定行为，行为决定过程，过程决定结果，事情就是这样，符合逻辑。
扯远了~~回来..

积木，几乎所有结构合理系统共有的特性，Maskat也不例外：
使用xml做layout，记得第一次看到这种用法应该是在android上；XML，真是个伟大的发明，当然还有JSON。
与其他框架或者应用的整合。
附带的PluginIDE是另一个让人感觉贴心的细腻东东，真是性感。
目前还没有发现英文资料，清一色日文，似乎用的人也不是很多，貌似データ并不想把这个Open的东东进行大规模推广，Who knows...

和Tiger在MSN讨论这个季节的一些个纠结问题
杜撰了《吉他里的阳光》的一句台词：机会，是自找的！

GDD 2009 is coming~

2009-05-12T03:43:00.000-07:00

谷歌诚挚邀请您参加我们在北京举办的Google 2009 年开发者日大会
在谷歌每年最大的技术分享盛会上，充分了解Google开发者产品和技术的最新发展，学习如何更好地利用谷歌开发者技术来帮助您更有效地开发构建网上社交和社区的应用、移动设备的应用、地理和地图的应用、网站和网页设计、以及搜索应用等等多项网络应用和服务的开发，以及听取业界其它领先企业分享他们在这些网络技术开发上的经验与体会。

2009 年 6 月 5 日北京国际会议中心中国北京
We'll be there, my friends :-)
Good night~

Install Debian5 on a Tulatin PC

2009-05-10T11:03:00.000-07:00

23:00 ~ 00:20, After eating something I sleep for one hour, waked up at 00:20, sleeping and tired.
00:20 ~ 00:50, Have a shawer and sit in from of PC. The damn router shutdown, again! It take almost one day to download the Debian 5, and now there is 14% left.
01:30~01:50, Debian downloaded, finally.. Installing Lenny (a good nick XD..) takes 20 minutes. The old machine looks like this, 815EPT Motherboard, Tulatin 1.3G, 512 RAM, 30G Disk. The latest MySQL5.4 doesn't support Windows platform, which may be the reason why It needs to install a linux. And in future it could be used as a source server, database server, web server, slave node, bt-PC... :-)
01:50~02:00, Reboot and post this article with lenny. Ok, time's up and I have to go to bed, even didn't knowing what I'm talking about.
The xfce4 is so cute :-)

Debian installing guide

ZK Direct RIA 似曾相识燕归来

2009-05-07T05:07:00.000-07:00

一套由台湾那边某公司做的开源Ajax框架，反响很好。看了一晚上，.zul配合.java，突然有种.net的code behind的感觉。

架构师和开发者们大多只对架构和程序本身产生美感
而客户却常常只愿意为页面买单

用jsp做web，页面问题总是能让人头痛很长时间，即便是有很多的模板引擎，实际开发的时候，绝对没有在vs里面拖拖拽拽的效果好、效率高。“用.net的页面开发配合Java的下层架构”，对这个幻想了很久 XD..

虽说ZK的基本思想虽然还是基于模板引擎的，不过贴心的人儿想到了整合auEngine和Client Engine这一点，然后就飞跃了。感觉上比DWR清晰、比GWT简洁（起码人家想到了直接做个Studio插到Eclipse上就行了..）。而且你可以用你喜欢的任何一种语言，比如Java、Javascript、Ruby、Python..看好你哟~_~
不过有点屁事就去找auEngine，这也太疯狂了.. - -!
当然，不管是从效果还是响应速度上都无法和前年用过的一个商业的ComponentArt相比，那个太绚丽了

未来WebClient端的主天下
不是Silverlight/JavaFX的
也不是Flex/Flash的
仍将是Javascript的（除特殊情况）
效果看这里
官网看这里
------------------------------------------------------------
左磨右磨
还是没敢拎着这个包出门 - -！

@Annotation板凳上的TestCase

2009-05-05T06:36:00.000-07:00

其实，我特别讨厌在文章里贴大篇幅的Code
懒人宗旨：能省则省，一劳永逸.. ←△←
@Retention(RetentionPolicy.XXX)
@Target(ElementType.XXX)

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Before {}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface After {}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Test {
    String value() default "TestCase";
}

public abstract class TestCase {
    @Before
    public void setUp(){};
    @After
    public void tearDown(){};
}

public class SampleTest extends TestCase {
    @Before
    public void setUp() {
        System.out.println("set up");
    }
    @After
    public void tearDown() {
        System.out.println("tear down");
    }
    @Test
    public void testMethod1() {
        System.out.println("Test Method1");
    }
    @Test
    public void testMethod2() {
        System.out.println("Test Method2");
    }
}

public class TestLoader {
    public void runTest(Class class1) throws InstantiationException,
                IllegalAccessException {
        Object object = class1.newInstance();
        Method[] methods = class1.getMethods();
        Method before = null;
        Method after = null;

        for (Method method : methods) {
            if (method.isAnnotationPresent(Before.class)) {
                before = method;
                break;
            }
        }
        for (Method method : methods) {
            if (method.isAnnotationPresent(After.class)) {
                after = method;
                break;
            }
        }
        for (Method method : methods) {
            if (method.isAnnotationPresent(Test.class)) {
                try {
                    if(before != null)
                        before.invoke(object, new Object[] {});
                    method.invoke(object, new Object[] {});
                    if(after!= null)
                        after.invoke(object, new Object[] {});
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws ClassNotFoundException,
                InstantiationException, IllegalAccessException {
        new TestLoader().runTest(Class.forName("demo.java.annotation.SampleTest"));
    }
}

set up
Test Method1
tear down
set up
Test Method2
tear down

许同学-淡淡的歌儿

2009-05-03T23:03:00.000-07:00

暴走第二弹

2009-05-03T20:08:00.000-07:00

5月2日 7:00 ~ 22:20 你说，一个人一天能走多少路？

本着溜达到哪儿算哪儿的态度
一天下来收获片片多张以及水泡两枚
流程如下
路线仅供参考~
如有雷同，请备好鞋一双~
------------------------------------------------------------------
13线（霍营）→13线（立水桥）→5（灯市口）→106电车→北京南站→天津站→过河→劝业场好多人→和平路→吉鸿昌故居→哈尔滨道→西开教堂→营口道→昆明路→人民体育馆→成都道→好多古建筑→绕来绕去→一路向东→外国语学院（休整片刻）→马场向东→凯旋门大厦→小白楼→大光明桥→沿河返回→新意（三国茅庐的cosplay）→曹禺、梁启超N多人的故居→向北一片草地（好多人放风筝）→望海教堂→美术学院→大悲禅院→摩天轮子→引滦纪念碑（什么饮料的活动撒）→金刚桥→一个小吃街→鼓楼→南市→河边→发现那个桔子酒店（笑~~）→沿河（武大郎炊饼）→天津站→北京南站→54路（开阳桥）→2线（宣武门）→13线（西直门）→13（霍营）
------------------------------------------------------------------
不多扯了，片都在校内上，这里写，累死了

暴走第一弹

2009-05-03T19:20:00.000-07:00

5月1日星期五雨
睡眠时间：2:00 ~ 7:00
起床、洗澡、出门
沿着Google到的路线，13→5（灯市口）→106电车绕了个大圈。
后来发现去南站最近的路线应该是13→2（宣武门）→54（开阳桥）
茫茫多人
9:20赶到，已经只有下午的车票了，失败
买了张第二天上午9:30的
出站，漫无目的的开始溜达
陶然桥随便上了辆车，跑到东单，向南穿过一大片胡同，沿着前门大街一路向西。
人，从，众，傘，遁行..
西交民巷北行
啊，鸟蛋..
还有茫茫人群

绕进另一大片胡同。看来这里要拆迁了，还有大条的标语“早拆迁、早选房、早受益”。旁边，一位老人坐在老院子的门口，就那么静静的坐着。再过几年，“胡同”一词可能真的成了北京永久的回忆了。

14:00左右徒步到西单的时候，开始下雨，无奈了。本想回家拿伞继续，回去以后直接扑床，醒来的时候已是下午六点..

排队去！有人接你..

2009-04-29T00:46:00.000-07:00

package demo.jms;

import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

@MessageDriven(activationConfig = {
        @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
        @ActivationConfigProperty(propertyName = "destination", propertyValue = "queue/HelloQueue") })
public class HelloQueue implements MessageListener {
    public void onMessage(Message message) {
        TextMessage textMessage = (TextMessage) message;
        try {
            System.out.println("message: " + textMessage.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

package demo.jms;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class QueueClient {
    public static void main(String[] args) throws NamingException, JMSException {
        Context ctx = new InitialContext();
        ConnectionFactory factory = (ConnectionFactory) ctx.lookup("QueueConnectionFactory");
        Destination destination = (Destination) ctx.lookup("queue/HelloQueue");
        Connection connection = factory.createConnection();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        MessageProducer producer = session.createProducer(destination);
        TextMessage message = session.createTextMessage();
        message.setText("Hello, JMS");
        producer.send(message);
        producer.close();
        session.close();
        connection.close();
    }
}

jndi.properties内容与《崩溃~继续罢课~》一文内容相同

15:59:41,218 INFO  [STDOUT] message: Hello, JMS

Jaikiran Pai says "JBoss by default binds queues to the "queue" context in the Global JNDI tree. So if your queue is named "xyz", its going to be bound to "queue/xyz" jndi name."

我回来了~

2009-04-26T03:41:00.000-07:00

当我和世界不一样那就让我不一样坚持对我来说就是以刚克刚
我如果对自己妥协如果对自己说谎即使别人原谅我也不能原谅
最美的愿望一定最疯狂我就是我自己的神在我活的地方
我和我最后的倔强握紧双手绝对不放
下一站是不是天堂就算失望不能绝望
我和我骄傲的倔强我在风中大声的唱
这一次为自己疯狂就这一次我和我的倔强
对爱我的人别紧张我的固执很善良我的手越骯脏眼神越是发光
你不在乎我的过往看到了我的翅膀你说被火烧过才能出现凤凰
逆风的方向更适合飞翔我不怕千万人阻挡只怕自己投降
就这一次让我大声唱

2点睡6:30起，早上7点的阳光，已经好久没有见到了。
车开了4个小时，期间睡了2个小时凑够了6个多小时。醒后，思考着世界上原本的单细胞生物为何后来演变为雄雌异体。这是一个很复杂的问题。沿途漂亮的风景以及路边开着不知名的的小花。

目的地，应该是那个荒山野岭处最好的一家店了，

午餐午休爬山
台阶从2008开始倒数
记载着每年发生的重大事件
我们以为到0的时候应该就结束了
到最后发现他们还有公元前...

阴森、怪异的山散发出一股妖气，西游记拍摄场地

走在乡间的小路上，一天中最轻松的时刻，惬意

晚餐后的篝火、烟花以及烤羊
还有喝不尽的啤酒

KTV唱歌接近凌晨一点
开一瓶有一点点贵的酒却没能喝完
帮一个姑娘开罐露露
搞了一手番茄酱
去洗手间冲洗
地上滴的到处都是

写到这里，突然醒悟这将是另外一个流水账的东东，不是我想要的。感觉自己好像很长的一段时间一直处于无目标或目标模糊的状态，这个很危险。撒谎者欺骗他人，同时也在欺骗自己。前些日子，我对自己撒了一个谎，你们知道的，我一向是不撒谎的。233米的蹦极吉尼斯，I like that，即便尝试那个高度的可能性很小。这里的只有60+米的，居然是中国第一高度，悲剧！
其实，我是喜欢看天的。然而城市的天空常常是污浊的压抑的，人们慢慢的就只会低头走路。生物因环境改变而改变。有句话说：城里人真傻，真的。在笼子里关久了的猴子出去后看到任何事物都是兴奋的。

回来的时候，突然觉得这是一个很陌生的城市，陌生的行人、建筑以及每天都在走的街道。
一直希望找一个安静的地方待一段时间，每天看云卷云舒，什么都不用去想..
总有一天，我要离开这里~
ps:我今天跨越了小区西边的那条路。其实，除了好奇，那里什么都没有...

安静的Coding

2009-04-24T10:05:00.000-07:00

这个周总睡眠时间<40小时周五在家7点睡到中午12点雨过天晴没有迈出家门一步起床后消灭掉冰箱里一个冰激凌在电脑前面坐到晚上10点多饿得大脑发昏不得不去找吃的搬过来半年我始终没有跨越小区西边20米外的那条路即便是好多次都想着到路那边走走皆未果人具有惰性一旦习惯于某个事物后就不怎么想改变了比如某个作息制度或者某个人改变易使人恐惧抑或兴奋某妞收到匿名礼物突兀地发消息过来怀疑是我送的礼物——我已经要6+年的岁月没接触过这个词汇烦躁，不安，忧郁，沮丧~ 和Jee同学讨论古老的A*寻路问题想象着把怪物们穿在铁丝上当肉串烤思考着10年甚至是20年前人们讨论过的事情
Coding~
唯一能使自己平静下来的事情
机器始终是听话的、诚实的
人类生长发育
阶段性的记忆细胞分裂会导致忘记一些事物
14岁的时候记不清6岁的事情
24岁的时候记不清14岁的事情
那么在30岁的时候
应该会忘记20岁的那些人、那些事
引: 世界是我们的，也是儿子们的，但最终是那帮孙子们的。

木头人儿破例转个关于短信的贴儿

2009-04-24T01:55:00.000-07:00

舌头长泡ing~

当你收到“你干嘛呢”
就等于“我想你了”
发“呵呵”多是没笑或傻笑
但如果我发的是“嘿嘿”“嘎嘎”或者“哈哈哈”
这是你打过来我一定是在笑

每次骂你“傻瓜”“笨蛋”“屁孩”
都是关心希望你照顾好自己

当多是问句结束时
是希望能在和你多聊一会
相反如果“嗯”“哦”一定是敷衍
在意的人我多会回复“收到”“遵命”“知道啦”之类的

有时催你睡觉或者让你忙自己的
其实心里并不想你真的那么做

把我的糗事傻事失落事告诉你
是希望你安慰我照顾我甚至骂骂我

主动发给你
一定是你在我心中有很重的分量
我很讨厌和不在意的人啰嗦

喜欢给你起外号的
是我希望可以让你多记住我一些

“我到了放心吧”“你到了告诉我一声”
是说明我进屋第一个想到的人是你
希望你也如此
或者你一定要一路平安
我不许你有事

有时实在没话了又想发给你
就会假装发错人
好吧我承认这很蠢……

关于爱情：
不要认为后面还有更好的，因为现在拥有就是最好的。
不要认为我还年轻，可以晚些结婚，爱情是不等年龄的。
不要因为距离太远而放弃，爱情是可以和你一起坐火车的。
不要因为对方不富裕而放弃，只要不是无能的人，勤劳可以让你们致富。
不要因为父母反对而放弃，你会发现这个原因而放弃的爱情，将是你一生的悔恨。
其实，对于爱情，越单纯越幸福！一生只谈一次恋爱是最好的。经历的太多了，会麻木，分离多了，会习惯，换恋人多了，会比较，到最后你会不再相信爱情，你会自暴自弃，你会毫无生气，你会行尸走肉，你会与一个你不爱的人结婚，就这样过一辈子···

所以牵好的手就不要轻易放开，说过的话就不要轻易收回，承诺过的人就不要轻易忘记···
有些人，有些事，既然发生了。
就注定是你一生的回忆··· ！！！

防御阵形:觉醒

2009-04-23T16:04:00.000-07:00

玩了一晚上
挺好
不论是画面还是策略
最近塔防类的好像很流行啊

7点整
今天的计划是睡觉
熬夜
心脏死了~
人也死了~
像这样不知道能进化到什么程度
40？很满足了

最近毅力退化
总是不能够坚持完成某个预定目标
这样不好不好~

给自己挖一个坑
然后跳进去

好天气\(^o^)/~

2009-04-20T08:19:00.001-07:00

计划
明天睡懒觉~

饥饿

2009-04-19T09:57:00.000-07:00

人在饿的时候会找东西吃而不在乎吃什么

生存法则
先活着然后想怎么活
人如此
软件亦如此

前天凌晨四点
昨天凌晨五点
现在极度厌恶“习惯”这个字眼儿
讨厌一切束缚的东西
像蜘蛛网一样萦绕
不能自由思考
猩猩是个可怕的趋势

什么叫程序
Stallman称之为菜谱
吃没有炒熟的芸豆
中毒的人分为三种
牛、牛虻、牛粪

什么叫软件开发
一群操不同口音的牛虻试图把某件事情说清楚

崩溃~继续罢课~

2009-04-17T13:29:00.000-07:00

This world grows so fast.

package demo.ejb;

import javax.ejb.Remote;

@Remote
public interface Hello {
    public String doHello(String name);
}

package demo.ejb;

import javax.ejb.Stateless;

@Stateless(name = "ejb/Hello")
public class HelloImpl implements Hello {
    @Override
    public String doHello(String name) {
        return "Greetings, " + name;
    }
}

package demo.ejb;

import java.rmi.RemoteException;

import javax.ejb.CreateException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class Client {
    public static void main(String[] args) throws NamingException,
            RemoteException, CreateException {
        Context ctx = new InitialContext();
        Object objRef = ctx.lookup("ejb/Hello/remote");
        System.out.println(((Hello)objRef).doHello("Tom"));
    }
}

java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
java.naming.provider.url=localhost:1099

Greetings, Tom

Be careful of jacorb.jar (org.omg.CORBA.INITIALIZE...)
They always write document badly which leads to troubles.

Open JNDIView (at http://localhost:8080/jmx-console/ by default) use the "list" method and look for Your beans in "Global JNDI Namespace" to find out what are the JNDI Names.

刺客信条2

2009-04-17T05:36:00.000-07:00

在文艺复兴时期的意大利，距离第一代有三百多年。
在调酒师Desmond Miles的DNA里，Abstergo公司发现了他另一位祖先的记忆，生活在十五世纪末的贵族Ezio Auditore Di Firenze。这个年轻人遭到家族背叛，被迫踏上踏上复仇之路，最终Ezio和Desmond将发现一个埋藏已久的惊天阴谋，它将对今天的世界产生巨大影响。

Hello, my princess

淳朴依旧~

2009-04-15T12:10:00.000-07:00

一切Code都是纸老虎
想推箱子
已经过去三年了啊

Code是艺术
Game也是艺术
物欲横流年代
金钱、色情、欲望
换个壳改个名
就是XX传奇了
艺术家都死光了

凌晨3:30
把一天当做两天过
LIM(Tsleep→5) ⇒ LOSS(life)→0.20833333....


#include "Box.h"
bool FrameFunc()
{
    // Process keys
    // Deal with other logic data...
    return false;
}
bool RenderFunc()
{
    hge->Gfx_BeginScene();
    hge->Gfx_Clear(0);
    // Render something
    hge->Gfx_EndScene();
    return false;
}
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
    hge = hgeCreate(HGE_VERSION);
    hge->System_SetState(HGE_LOGFILE, "box.log");
    hge->System_SetState(HGE_FRAMEFUNC, FrameFunc);
    hge->System_SetState(HGE_RENDERFUNC, RenderFunc);
    hge->System_SetState(HGE_TITLE, "HGE BOX");

    hge->System_SetState(HGE_WINDOWED, true);
    hge->System_SetState(HGE_SCREENWIDTH, 800);
    hge->System_SetState(HGE_SCREENHEIGHT, 600);
    hge->System_SetState(HGE_SCREENBPP, 32);

    if(hge->System_Initiate())
    {
        // Load resources
        snd=hge->Effect_Load("..\\rabbit.mp3");
        // Check resources or release if failed
        // Set up enviroment...

        hge->System_Start();
        // Release...
        hge->Effect_Free(snd);
     }
     // Clean up and shutdown
     hge->System_Shutdown();
     hge->Release();
     return 0;
}