Monday 22 December 2008

Moby Dick






白鲸


一斧头一斧头当场就劈出来这么一个野蛮而厚重的家伙。边劈边聊,跟砍柴的似的;烟没断过;有时候咳嗽儿;地上随意扔着大大小小碎料,没人收拾,管他呢。

开始突突突冒气没活动开。活动开之后那叫一个跑的欢。西伯利亚雪原上干净的烟。单纯而残暴。

这是怎样一部作品啊。看了之后直觉的自己活的琐碎不真实。食人生番的友情,大副的爱家,二副的爱自己,三副的勇敢,船长的无可救药的坚定。死是任谁谁都无可逃脱的命。那就迎着上去好了。

野蛮而厚重的东西在国内很少看到。中国人大多精于技巧。做出东西有大气的但很少野蛮的。也许这是个审美的问题吧。文明古国,自汉吧,就走向精雕细刻的路——看看我们的菜吧,还有国粹。粗砺一点别人都以为你没下够功夫。当然啦,也没多少拿得动开山的斧头的。沉香也就一下两下,把山劈开救出妈妈就哭做一团了。谁能把山给劈出来?从一个混沌一团的地方?剑在这比较流行,一百单八式舞的密不透风,水泼不进;一飘身就不见了;诸般灵异说说都觉得臊得慌。就描吧,单薄的灵魂只配贴在纸上。

Friday 5 December 2008

About Time

关于时间的几个问题――别太当真
下载:aboutime.pdf

Git Magic Chinese Version

Git Magic 中文版


译自:http://www-cs-students.stanford.edu/~blynn/gitmagic

网页版:http://docs.google.com/View?id=dfwthj68_675gz3bw8kj
PDF下载:Git_Magic_CN.pdf

Google Docs还真不赖:-)




Thursday 4 December 2008

Archimedes

阿基米德

阿基米德说,给我一支点,我就可以撬起地球。

也不知阿基米德是否真的说过这样的话。由于时空的关系,一直找不到机会见到他。阿基米德也没机会见到牛顿。牛顿发现万有引力定律的时候,想必也想找阿基米德聊聊;但人早不在了。

阿基米德要撬起地球的话,要好好考虑几件事。

其一,支点放在哪的问题。支点不能放在地球上,但又不能离地球太远。支点离地球太远,杠杆就会更长。杠杆太长就得考虑今生如何走到杠杆的另一端的问题。不能超光速的。爱因斯坦也不是吃干饭的。不妨考虑把支点放到月球上。月球离地球最近,而且月球也不在地球上。唯一的问题是月球可能没那么稳定,未必承受得了太大的力。

其二,杠杆的长度。假设阿基米德体重100公斤,有100公斤的力气。地球的质量是6.0×1021公斤。支点选在月亮,月亮离地球3.8×105公里。根据杠杆原理,那杠杆长度就得有2 ×1024公里。光速是3×105公里每秒。阿基米德爬过去最少需要 6.7×1018秒,也就是2×1011年。目前地球的年龄大约46亿年(4.6×109)。月球寿命大约4.3×109年。等阿基米德的幽魂爬到杠杆的另一端,月亮和地球的幽魂又在哪里呢?


其三,阿基米德的游魂站在哪里撬呢?这杠杆太长了,有2×1011光年长。银河系的直径大约10万光年。真是零头都不够啊。据说宇宙也就260亿(2.6×1010)光年吧。可怜的阿基米德,伟大的物理学家,的幽魂,却只能置身宇宙之外,努力地撬遥远的一个宇宙里的,也许最不出名的一颗小小的蓝色星球,的幽魂。


Math Puzzles

数学题


下面这个链接里有71道数学题:
http://www.math.ucsb.edu/~cooper/puz1.html
谁谁有兴趣就做做。我只做过第1道和第9道。

第1道:
    /**
* MATH PUZZLE 01
*
* An ant starts at one end of a rubber band and walks along it at a speed
* of 1 inch per second. The rubber band is 10 inches long, and is being
* stretched uniformly at a rate of 20 inches per second. Does the ant ever
* reach the other end of the rubber band?. Give reasons.
*/
public void testMathPuzzle01() {
long t = 0;
final long MINUTE = 60, HOUR = MINUTE * 60, DAY = HOUR * 24, YEAR = DAY * 365;
double rubber = 10;
double walked = 0;
while (walked < rubber) {
// After 1 second
t++;
rubber = rubber + 20;
walked = walked * rubber / (rubber - 20) + 1;
if (t % YEAR == 0) {
System.out.println("" + t / YEAR + " years has been flying by");
}
}
System.out.println("Time used:" + t / YEAR + " years, " + t % YEAR
/ DAY + " days, " + t % DAY / HOUR + " hours," + t % HOUR
/ MINUTE + " minutes," + t % MINUTE + " seconds");
}

蚂蚁这题很有意思。应该是一个微积分的题。上面的解答算一个模拟解吧。假设先拉橡皮筋,蚂蚁后走:
walked = walked * rubber / (rubber - 20) + 1;
算出蚂蚁需要大约16年才能爬到橡皮筋另一头。或者蚂蚁先走,再拉橡皮筋:
walked = (walked + 1) * rubber / (rubber - 20) ;
可以算出蚂蚁需要2年多一点可以爬到另一头。早一步就节省12年。这道题也印证了抢占先机的重要性。

还有就是第9道:
  /**
* MATH PUZZLE 09
*
* In a TV show, a prize is hidden behind one of 3 closed doors. The
* contestant tries to guess where the prize is. After the contestant
* chooses a door, the host of the show (who knows where the prize is) opens
* one of the 2 remaining doors, to reveal that the prize is not behind that
* door. The host then gives the contestant the opportunity to change her
* guess. Should she?
*/
public void testMathPuzzle09() {
final int SIZE = 100000;
boolean[] doors = new boolean[3];
Random random = new Random();
int insist = 0;
int reselect = 0;
for (int i = 0; i < SIZE; i++) {
// Init doors
doors[0] = doors[1] = doors[2] = false;
int index = random.nextInt(3);
doors[index] = true;
int guess = random.nextInt(3);
// does not change her guess
if (doors[guess] == true) {
insist++;
}
// change her guess
if (doors[guess] == false) {
reselect++;
}
}
System.out.println("Not change will get:" + insist);
System.out.println("Change will get:" + reselect);
}

实质上是大家常讲的三个门的题。门后面可能藏别的东西。

Wednesday 3 December 2008

The So Called Elder


父辈

比较喜欢的东西,最好要有个内核,精神上的。不喜欢像于丹那样的,东一下西一下,道理满天飞,但缺少精神实质。平常的谈话也是如此。经历过文革的那代人,说的话本质上跟打嗝差不多,基本的卫生标准都达不到,更别说精神实质了。

-- 原来挺崇拜经历文革的人,后来才发觉,绝大部分经历文革的人,都已经磨得没点脾气了,包括那些大家们

不止是没脾气,是没自我,而且一厢情愿地认为, 别人也应该没自我。

读《静静的顿河》,发现俄国人是比较混的。可这种混蛋劲儿,比没自我,也可爱多了。人俄国人打的饱嗝,透着酒气;冬天里闻到,恶心归恶心,也还知道对面的人是活生生的。不像我们,形体上的温驯,遮掩精神上的野蛮。

Monday 1 December 2008

YAML Brief Introduction












YAML简介




YAML Ain't Markup Language


和GNU一样, YAML是一个递归着说"不"的名字.  不同的是, GNU对UNIX说不, YAML说不的对象是XML.



YAML不是XML.







为什么不是XML呢?  因为:



  • YAML的可读性好.


  • YAML和脚本语言的交互性好.


  • YAML使用实现语言的数据类型.


  • YAML有一个一致的信息模型.


  • YAML易于实现.




上面5条也就是XML不足的地方. 同时, YAML也有XML的下列优点:



  • YAML可以基于流来处理


  • YAML表达能力强, 扩展性好.




总之, YAML试图用一种比XML更敏捷的方式, 来完成XML所完成的任务.



更多的内容及规范参见http://www.yaml.org .

语法


Structure通过空格来展示. Sequence里的项用"-"来代表, Map里的键值对用":"分隔.


这几乎就是所有的语法了.


比如...




一般YAML文件扩展名为.yaml. 比如: John.yaml

name: John Smith

age: 37

spouse:

    name: Jane Smith

    age: 25

children:

    -   name: Jimmy Smith

        age: 15

    -   name: Jenny Smith

        age 12

John今年37岁, 有一个幸福的四口之家. 两个孩子Jimmy 和Jenny活泼可爱. 妻子Jane年轻美貌. 如果深入研究的话还可能发现一些社会问题.



可见YAML的可读性是不错.




JYaml - YAML的Java实现


YAML已经有了不少实现, 详细的实现列表参见http://www.yaml.org/download.html.



其中JYaml(http://jyaml.sourceforge.net )是YAML的Java实现.


JYaml简介


YAML使用实现语言的数据类型. 我们看一下一些JYaml支持的Java数据类型:



  • 原始数据和封装类(比如int, java.lang.Integer)
  • JavaBean兼容对象(Structure支持)
  • Collection (sequence支持)
    • List
    • Set
  • Map (map支持)
  • Arrays (sequence支持)
  • BigInteger 和BigDecimal
  • Date

我们给出John.yaml的java描述:
public class Person {
    private String name;
    private int age;
    private Person sponse;
    private Person[] children;
    // setXXX, getXXX方法略.
}

现在让我们装配一个Jone:
        Person john = new Person();
        john.setAge(37);
        john.setName("John Smith");
        Person sponse = new Person();
        sponse.setName("Jane Smith");
        sponse.setAge(25);
        john.setSponse(sponse);
        Person[] children = {new Person(), new Person()};
        children[0].setName("Jimmy Smith");
        children[0].setAge(15);
        children[1].setName("Jenny Smith");
        children[1].setAge(12);
        john.setChildren(children);

使用JYaml把Jone "Dump"出来:
        File dumpfile = new File("John.yaml");
        Yaml.dump(john, dumpfile);
下面我们看看John.yaml是什么样子:

--- !yaml.test.internal.Person

age: 37

children: !yaml.test.internal.Person[]

  - !yaml.test.internal.Person

    age: 15

    name: Jimmy Smith

  - !yaml.test.internal.Person

    age: 12

    name: Jenny Smith

name: John Smith

sponse: !yaml.test.internal.Person

  age: 25

  name: Jane Smith
其中!yaml.test.internal.Person是一些类型的信息. load的时候需要用.

现在用JYaml把Jone.yaml load进来:
        Person john2 = (Person) Yaml.load(dumpfile);
        assertEquals(john, john2);
我们最初给的John.yaml并没有类型的信息. 可以用下面的方法load进来:
Person john2 = (Person) Yaml.loadType(dumpfile, Person.class);
我们还可以用下面的方法dump出最初的John.jaml:
Yaml.dump(john,dumpfile, true);

我们再来看看JYaml对流处理的支持.

为简便起见, 我们只是把同一个john写10次:
       YamlEncoder enc = new YamlEncoder(new FileOutputStream(dumpfile));
        for(int i=0; i<10; i++){
            john.setAge(37+i);
            enc.writeObject(john);
            enc.flush();
        }
       enc.close();
下面再把这十个对象一个一个读出来:
        YamlDecoder dec = new YamlDecoder(new FileInputStream(dumpfile));
        int age = 37;
        while(true){
            try{
                john = (Person) dec.readObject();
                assertEquals(age, john.getAge());
                age++;
            }catch(EOFException eofe){
                break;
            }
        }

JYaml对JDK14的支持

JYaml的源码是基于JVM5的. 也提供对JVM5功能的一些支持, 比如对枚举类型的支持.

JYaml的JVM14的支持是通过retrotranslator(http://retrotranslator.sourceforge.net ). retrotranslator使用ASM(http://asm.objectweb.org )动态修改JVM5字节码成JVM14, 使JYaml在JVM14下可用. 会牺牲一些效率. Debug时也会失真.

我修改了JYaml作者Toby Ho的一些源码(基于Beta2.2), 使之与JVM14兼容. 当然, 为此也去掉了对JVM5才有的类型的支持(比如枚举类型). 这个牺牲应该是值得的. 由于还没有和Toby Ho讲, 因此还不能公开这个JVM14兼容的包.

YAML的使用范围


YAML的一个亮点是数据类型使用实现语言的类型. 这样比较省事的地方是自己不用有自己的一套类型定义.

比如我们使用Ruby写一个Person类:
class Person
  attr_accessor :name, :age, :sponse, :children
  def initialize(name, age, sponse=nil, children=nil)
    @name = name
    @age  = age
    @sponse = sponse
    @children = children
  end
end
把John装配起来:
jane = Person.new("Jane Smith", 25)
children = [Person.new("Jimmy Smith", 15), Person.new("Jenny Smith", 12)]
john = Person.new("John Smith", 37, jane, children)
Dump出John到John.yaml:
File.open('John.yaml', 'w') do |os|
  YAML::dump(john, os)
end
我们看看Dump的结果:
--- !ruby/object:Person
age: 37
children:
- !ruby/object:Person
  age: 15
  children:
  name: Jimmy Smith
  sponse:
- !ruby/object:Person
  age: 12
  children:
  name: Jenny Smith
  sponse:
name: John Smith
sponse: !ruby/object:Person
  age: 25
  children:
  name: Jane Smith
  sponse:
仔细观察会发现和JYaml Dump出来的还是有些区别的.

首先类型信息不一样. 这还好说, 虽然Ruby load Java的不太可能, 但Java加载Ruby的应该没问题.

还有就是一些实现上细微的区别. 比如Ruby::Yaml的"spone:", JYaml认为是不合法的. 还有children的不缩行. 尽管Ruby::Yaml很流行, 但JYaml认为这是Ruby的Bug. 网上有相应的争论.

不过在一个语言里使用还是没问题的. 下面是load John的代码:
john2 = File.open('John.yaml') { |is|  YAML::load(is) }

毕竟每个实现语言的类型不一样的, 不同语言文化也不同. 因此不同实现的YAML的交互是个问题. 兼容性需要YAML规范来保证. 而具体的实施还有很长的道路要走.

YAML和SDO(只讨论双方的java实现)


如果读者想了解更多SDO的概念, 参见http://www-128.ibm.com/developerworks/library/specification/j-commonj-sdowmt/index.html . 这里我们只讨论SDO的java实现.

SDO里有一个很总要的概念, DataObject. 从DataObject的接口里, 可以看出有两类的数据类型, 一类是JYaml支持的, 诸如String, List之类, 一类是DataObject. 因此我们只需要增加一种支持DataObject的类型, 就可以完成对SDO DataObject的支持.

不妨叫YamlDataObject. 下面是它的数据结构.
public class YamlDataObject {
    private String uRI;
    private String name;
    private Map attributes;
}
YamlDataObject里用到的类型, 都是JYaml能够支持的. 其中, uRI和name用来描述DataObject自身. attributes来描述DataObject里的值. 这些值可能为DataObject, 也可能是JYaml所支持的其他类型. 我们希望用YamlDataObject来担当DataObject的角色, 因此YamlDataObject和DataObject要能互相转化. 增加两个API:
private static YamlDataObject newInstance(DataObject dataobject){...
private DataObject toDataObject() {...
上面两个之所以是private的, 是因为我们打算遵照JYaml的习惯, 增加两个接口, dump和load, 这样newInstance和toDataObject只在内部使用了. 下面是dump和load的定义:
public static void dump(DataObject dataobject, File dumpfile) throws FileNotFoundException{...
public static Object load(File file) throws FileNotFoundException{...
下面是一小段测试代码:
// ... create dataobject ...
File bodump=new File("bodump.yaml");
YamlDataObject.dump(dataobject,bodump);
assertTrue(bodump.exists());
DataObject dataobject2 = (DataObject) YamlDataObject.load(bodump);
 // check result
assertNotNull(dataobject2);
for(int i=0; i<5; i++){
   assertEquals(dataobject.get(i),dataobject2.get(i));
}

具体的实现细节就不谈了. 读者可以作为练习题, 熟悉一下这两个数据整合方案.

YAML存在的意义


无论多么完美的事物, 都需要有对立面, 有说"NO"的声音. XML也不例外. 当然, 站在主流的对立面, 需要勇气和智慧.

YAML和XML不同, 没有自己的数据类型的定义, 而是使用实现语言的数据类型. 这一点, 有可能是出奇制胜的地方, 也可能是一个败笔. 如果兼容性保证的不好的话, YAML数据在不同语言间流转会有问题. 如果兼容性好的话, YAML就会成为不同语言间数据流通的桥梁. 建议yaml.org设立兼容认证机制, 每个语言的实现必须通过认证.

假如兼容性没问题的话, YAML就太完美了. 轻巧, 敏捷, 高效, 简便, 通用. 这才是理想中的数据模型.