DouO's Blog http://dourok.info 非淡泊无以明志，非宁静无以致远 Sun, 25 Dec 2011 12:23:13 +0000 en hourly 1 http://wordpress.org/?v=3.3 来除草了。。。 http://dourok.info/2011/12/before_2012/?utm_source=rss&utm_medium=rss&utm_campaign=before_2012 http://dourok.info/2011/12/before_2012/#comments Sun, 25 Dec 2011 09:07:25 +0000 DouO http://dourok.info/?p=636 终于争取到在2012前上来吐槽下，记录下对博客做的修改和一些新理解。

首先取消了分类目录，全部通过标签来做归类管理。像我这种随便吐槽的博客用分类目录，很多时候都觉的是种自我限制，相对的标签就自由许多，同时也有归类的功能。这方面不得不说Evernote很有相见之明，不过我很久没用Evernote了，听说它也是顶不住用户的压力开始支持分类管理了。至于技术文章，我把它归为笔记类，和其它笔记，摘抄都记录到我的wiki里，wiki目前还是通过分类管理的，分得细致很多，不过我觉得更合理的话应该要配合上标签，即便没有客户端和没有标签管理下DokuWiki还是完全替代了我对Evernote的使用，何况标签这个功能装个插件就有了，Wiki的自由和可扩展性是无可替代的。一直有个将dokuwiki变身为云笔记想法，主要目的本地和服务器同步文件，还有Web编辑器太弱了，想通过Emacs来做桌面客户端，再来个Android App，加上一些自己常用网站的接口插件，就差不多了。我已经启动这个项目很久了（见wiki-note），不过一直没有动工过，果然是拖延症患者吧。

取消了分类目录，我就希望博客更整洁些，所以决定采用单栏模板让文章内容的空间大一些。但苦于找不到比较入眼的单栏主题，无奈选择自己看教程做，本想基于twentyten来改的，无意间发现 CriticalZero这个站，它的设计令我耳目一新，特别是头部用条斜线来切割页面，相当大胆，用的好的话就是小清新，用不好的话就像眼前这个网站一样-_-(纯粹213需要，无意贬低原作者)。虽然他页面内容的排版也漂亮，但文章的空间太小不适合我的需求。所以我还是采用传统的纵向排列，这样保证了文章有足够大的宽度，看起来舒服些。其它细节我也搬了不少过来，再加上一些从其它主题搬过来的设计和来自 Gentleface 的图标、乱来的配色，不过 Web Colors 真的很有帮助。就这样左抄抄右抄抄，像我这样的前端苦手也能完成一款wordpress主题。

我的第一款wordpress主题就叫做BetaD吧。BetaD是twentyten（wordpress自带主题）的子主题（child theme），设计主要来自 CriticalZero ，Copy的太多都不好意思说是参考了。目前是dirty又buggy，只在Chrome和Firefox下测试过，我自己发现的就有不少bug，也没要提供任何可自定制的接口，下次再修复吧。有兴趣的同学到这里看下：https://github.com/dourokinga/BetaD

另外，不知大家有发现没，这个主题的背景是动态生成，在研究代码是时候，发现了相当酷的框架processing.js，是用来做html5交互动画的。这个背景就是用这个框架生成的，看起来十分强大的样子，一定要来研究下。

]]> http://dourok.info/2011/12/before_2012/feed/ 0 在Netbeans上查看Android源码 http://dourok.info/2011/10/browse_android_sources_on_netbeans/?utm_source=rss&utm_medium=rss&utm_campaign=browse_android_sources_on_netbeans http://dourok.info/2011/10/browse_android_sources_on_netbeans/#comments Sun, 09 Oct 2011 19:58:00 +0000 DouO http://dourok.info/?p=606 Netbeans7.1终于有像Eclipse一样的Attach Sources按钮，可以为android.jar附加源码了。虽然现在Netbeans 7.1 还处在测试阶段，但这个功能太重要了，迫不及待要去尝鲜，不过其实现在也足够稳定了。

先下载Netbeans 7.1 beta，然后在这里：http://adt-addons.googlecode.com/svn/trunk/source/com.android.ide.eclipse.source.update/plugins/ 可以下载到打包好android各版本的源码，这是个jar档案需要解压出来。

另外，如果已安装有旧版本的netbeans，如7.0；需要注意一个问题，如Bug 200698 里 jn0101@netbeans.org 的描述。如果7.1和旧版的netbeans共用一个userdir可能会导致”Attach Sources”按钮失效。我试过了确实会这样（linux下）。解决方法可以用–userdir给netbeans 7.1重新指定一个新userdir。不过，我是直接把.netbeans文件删掉，当然有先备份，然后，先配置好7.1的nbandroid，然后把sources.zip附到相应的android.jar。再把备份的7.0拷回来。可以把7.0的一些config拷给7.1，如：Editors和Keymaps等等。这样两个版本都可以正常工作了。

另外，意外的是在debug下还能工作的挺好的。

NBANDROID-71基本可以算解决了。

见此,如何在Netbeans上配置Android开发环境

]]> http://dourok.info/2011/10/browse_android_sources_on_netbeans/feed/ 0 修复了 Lyrics Grabber2 的千千静听歌词抓取脚本 http://dourok.info/2011/08/fixed_ttplayer_lrc_py/?utm_source=rss&utm_medium=rss&utm_campaign=fixed_ttplayer_lrc_py http://dourok.info/2011/08/fixed_ttplayer_lrc_py/#comments Sun, 07 Aug 2011 19:40:07 +0000 DouO http://dourok.info/?p=571 继续阅读 →]]> 之前修改过现在查词失败的同学请点这里

Lyrics Grabber2 可以说我理想中的歌曲下载插件，主要是它可以批量抓取更新歌词，又可以自定义抓取脚本方便扩展(见此HowToMakeProviderInPython)，实在强大。不过还是有一些不足，比如找到的歌词没有给出来源（Provider），歌词服务器（Provier）不能更改优先级，还有就是出现多个歌词的匹配问题，既有多个服务器的，也有一个服务器的多个歌词的，希望能增加人工选择的选项。不过 Lyrics Grabber2刚好一年没更新了，再更新实在希望不大。

再者，现在Lyrics Grabber2里面的千千静听歌词抓取脚本（TTPlayer(LRC).py）是用不了的。我了解一下，把bug总结如下：

bug_1:36行

导致搜索失败的主要原因，现在千千静听搜索歌词的服务器变了

bug_2:103行
另一个导致搜索失败的原因，用来生成code的字符串应该用utf-8编码，而用minidom.parseString出来的字符串已经是utf-16le的了.

bug_3:114行
这一行应该是打错了. 条件应该是 c >= 0×80:

bug_4:42行
同样是编码问题，导致Levenshtein算法失效，因为比对的是两个不同编码的字符串。

修复完bug后，就可以成功查词了。但是结果并不理想。

由上图可以看出是，英文和简体没压力但繁（正）体中文就不行了。显然还需对title做些处理。通过对千千静听进行测试，发现千千静听对查询串的处理远不止 71 72 73 所在的那样。
大概做了下面这些过滤：

  • 英文转小写
  • 去括号，大中小还有全角的小括号
  • 去除半角特殊符号，空格，逗号，etc。
  • 去除全角特殊符号
  • 繁（正）体转换为简体

繁（正）体转换为简体，找不到好的现成方案（针对unicode字符集uft-8编码的）。只能动用谷歌翻译的api了。没想到谷歌翻译倒工作的很好。不过毕竟是多一个网络请求，建议不需要的时候可以把它注释掉，以加快查询速度。其他过滤功能也可以根据情况去掉，已加强效率。FYI:脚本更改后立即生效，无须重启foobar2000的。

针对这些，增加了下面的新方法

def QianQianStringFilter(self,string):
s = string
# 英文转小写
s = s.lower()
# 去括号，大中小还有全角的小括号
s = re.sub('\(.*?\)|\[.*?]|{.*?}|（.*?）', '', s);
# 去除半角特殊符号，空格，逗号，etc。
s = re.sub('[ -/:-@[-`{-~]+', '', s);
# 繁（正）体转换为简体
s = translate(s,'zh-tw','zh-cn')
s = unicode(s, 'utf_8')
# 去除全角特殊符号
s = re.sub(u'[\u2014\u2018\u201c\u2026\u3001\u3002\u300a\u300b\u300e\u300f\u3010\u3011\u30fb\uff01\uff08\uff09\uff0c\uff1a\uff1b\uff1f\uff5e\uffe5]+','',s)
return s
def translate(text,lang_from,lang_to):
url = ('http://ajax.googleapis.com/ajax/services/language/translate?' +
'v=1.0&q='+urllib.quote(text)+'&langpair='+lang_from+'%7C'+lang_to)
json = urllib.urlopen(url).read()
# return json;
p = re.compile('"translatedText":"(.+?)"')
m = p.search(json);
return m.group(1);

注意:谷歌翻译的api已经过期了，会导致查词失败，新的翻译api又要收费还很贵，见http://code.google.com/apis/language/translate/v2/pricing.html，坑爹呢这是。幸好还有Bing做后援。虽然不给力，但简繁转换还是没问题的。下面的代码改用Bing的翻译服务：

def translate(text,lang_from,lang_to):
url = ('http://api.microsofttranslator.com/V2/Ajax.svc/Translate?' +
'appId=DE2A1CAA235EB52E611BC1243F16E4D301BB600E' +
'&from='+ lang_from +'&to='+ lang_to +
'&text='+urllib.quote(text))
json = urllib.urlopen(url).read()
p = re.compile('"(.+?)"') #對應必應
m = p.search(json);
return m.group(1);

这样，大部分流行歌曲特别是华人音乐，都可以表示毫无压力。

千千静听的大部分歌词都是简体的……

歌名特殊符号的也能识别了


You Ain’t Goin Nowhere在千千静听里面也是Fault。

但是这样并不完美，毕竟是黑盒测试，比如 中千千静听的後(/u8C5F)字并没有转换到后 ，如下图：

最後の放課後 在千千静听中可以找到，花は桜 君は美し -instrumental- 则同样找不到

不过目前也就这能做到这样。

改好的脚本在此:TTPlayer(LRC).py

另外，乐辞的脚本也是不行的，顺手也改好了。Lyricist(LRC).py

btw：千千静听的歌词库，只要是热门的，流行的，出名的歌曲都挺全的，不知是从哪里来的。

 

]]> http://dourok.info/2011/08/fixed_ttplayer_lrc_py/feed/ 7 迷宫生成算法 http://dourok.info/2011/07/maze_generation_algorithm/?utm_source=rss&utm_medium=rss&utm_campaign=maze_generation_algorithm http://dourok.info/2011/07/maze_generation_algorithm/#comments Thu, 14 Jul 2011 08:23:34 +0000 DouO http://dourok.info/?p=537 迷宫,大家都在知道是什么吧.一种标准的迷宫可以是像下图这样的结构,

一个矩形空间上,布置出错综复杂的墙,本文讨论的主要是这种结构的简单迷宫.可以想象出在下图这样的结构里,推倒某些墙壁.来生成迷宫.当然墙不是随便可以推倒的.


这样的结构姑且称为完全方格图(square grid graph)吧.从图论角度上看,这样的结构等同于下面这张图.圆圈表示顶点,线段表示边.

而最上面的迷宫,就可以认为上面那张完全方格图的生成子图,仔细观察上面的迷宫,就会发现无论从那里开始走,都可以到达迷宫中的任意一个地方(顶点).用图论术语来讲也就是说迷宫它还必须是一个连通图,这个可以理解,迷宫里到达不了的地方实际上没有意义.

另外继续观察还可以发现,无论你从那个地方出发,只要不往回走,就永远也回不到原来出发的地方.也就是不会绕圈圈.图论上说这叫做没有回路.当然回路这个可以有,有回路的迷宫更让人迷惑也可以更好玩,但这还得取决于回路如何设计.简单起见,这里生成的迷宫没有回路.就这两个特性,就可以给这种迷宫下定义了:完全方格图的没有回路连通生成子图.也就是完全方格图的生成树.

图的生成树算法那就相当广泛了,一次广度优先搜索(BFS)或深度优先搜索(DFS),都可以构建出图的生成子树.只要让选择下一个顶点的策略随机化,每次搜索出来的就是一个随机生成树也就是随机生成的迷宫.但是BFS生成出来的结果由于其他顶点相对于起始顶点的深度不变,导致迷宫随机性不够理想,下面提到的Prim算法算是一种对BFS的不错改进.DFS生成的过程比较生动就像是在挖地道一样推倒一面面墙.用来生成迷宫就比较直观也比较适合.

还有经典的最小生成树算法,Kruskal和Prim,都可以用来生成迷宫.当然完全方格图所有边都是单位权值的.所有生成树都是最小的,要运用Kruskal和Prim要做的改变就是将原来已以小优先的选择边策略改为随机选取.出来的是一个随机生成树.

当然上面的算法都是基于图论的,在维基百科里还提到另外一种不用图论的算法,比较有趣,叫递归分割法(Recursive division method),我喜欢叫你建墙我挖洞法,从名字就可以看出这是一种分治法,基本的策略就是,在一个空间里建立两面相交墙,形成四个较小的空间,然后再挖上三个洞.然后再对四个较小的空间执行相同的处理.直至每个空间的长或宽为单元大小不可再分割为止.这种方法效率比较高,由于是分治法也比较适合用分布式运算.这种方法生成出来的迷宫也是符合上面所提到的连通性和没有回路两个特点,可以用递归法简单证明下,由于两面墙隔出了四个空间,开三个洞刚好使每个空间可以互相连通,且没有回路,如果从一个空间到达另一个空间必定到达该空间的其中一个子空间,也就可以到达其他三个子空间.以此类推就到达迷宫上的每一个空间.不够生成出来的迷宫却较为简单,直路太多不够扭曲.

我用html5实现一个迷宫生成算法的演示,分别针对DFS,Kruskal,Prim和最后的分治法.可以去玩一下.

抱怨一下javascript,绘画速度还是不够快,对于大一点的迷宫必须用脏矩形重绘,才能保证速度.不够画出来的效果却不咋地.

至于这种迷宫的走法,一个DFS就可以很好地解决了.

当然实际设计出迷宫不像是这些算法这么简单的,正如谁谁谁所说的

“迷宫设计不仅是线条和图案的组合，要有娱乐性、装饰性，还要考虑那些穿越迷宫者的感受，那样才趣味无穷”

有空再考虑下其他类型迷宫的生成算法.

未完待续…

参考:

http://en.wikipedia.org/wiki/Maze_generation_algorithm

http://en.wikipedia.org/wiki/Maze

]]> http://dourok.info/2011/07/maze_generation_algorithm/feed/ 0 悠哉悠哉，辗转反侧 http://dourok.info/2011/06/%e6%82%a0%e5%93%89%e6%82%a0%e5%93%89%ef%bc%8c%e8%be%97%e8%bd%ac%e5%8f%8d%e4%be%a7/?utm_source=rss&utm_medium=rss&utm_campaign=%25e6%2582%25a0%25e5%2593%2589%25e6%2582%25a0%25e5%2593%2589%25ef%25bc%258c%25e8%25be%2597%25e8%25bd%25ac%25e5%258f%258d%25e4%25be%25a7 http://dourok.info/2011/06/%e6%82%a0%e5%93%89%e6%82%a0%e5%93%89%ef%bc%8c%e8%be%97%e8%bd%ac%e5%8f%8d%e4%be%a7/#comments Sat, 04 Jun 2011 20:15:08 +0000 DouO http://dourok.info/?p=532 昨天晚上，也就是敏感瓷那天，跟几个老同学跑出去犯罪了，其实应该算是只醉没饭…
喝了几杯酒，一点醉意也没，还很精神。回来还写两个多小时的代码，丝毫不困，只是烦。
……
居然把博客当微博，真是太水了。
抱怨一下老鹰，真的是自动gzip，速度又不快，等了快10秒页面空白，突然咔噔一下，全部载入好了。本来是想躺在床上用手机上的，但android上等的我受不了，直接起床开电脑了。

有点睡意，立马上床。

于 2011 年 06 月 05 日 03:59:17

]]> http://dourok.info/2011/06/%e6%82%a0%e5%93%89%e6%82%a0%e5%93%89%ef%bc%8c%e8%be%97%e8%bd%ac%e5%8f%8d%e4%be%a7/feed/ 2 System.in的困惑 http://dourok.info/2011/05/a_puzzle_of_system-in/?utm_source=rss&utm_medium=rss&utm_campaign=a_puzzle_of_system-in http://dourok.info/2011/05/a_puzzle_of_system-in/#comments Fri, 27 May 2011 19:54:33 +0000 DouO http://dourok.info/?p=519 继续阅读 →]]> 先看下下面代码先

static class Thread1 extends Thread {
        @Override
        public void run() {
            try {
                InputStream in = System.in;
                OutputStream out = System.out;
                int i = 0;
                while ((i = in.read()) != -1) {
                    out.write(i);
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

这段代码很正常，线程跑起来的结果和你想的一样，在终端上输入一行，按下回车就回显这一行，显然System.in是行缓冲的(linebuffered)，不是像getch那样输入一个就回显一个。在没有按下回车之前in.read()就一直阻塞。
再来看下这一段代码

static class Thread2 extends Thread {
        @Override
        public void run() {
            try {
                InputStream in = System.in;
                OutputStream out = System.out;
                byte buffer[] = new byte[10];
                int i = 0;
                    while ((i=in.read(buffer))!=-1) {
                        out.write(buffer, 0, i);
                    }
            } catch (IOException ex) {
               ex.printStackTrace();
            }
        }
    }

Thread2跑起来结果跟Thread1一模一样，输入一行回显一行，但代码却有点区别，多了byte buffer[] = new byte[10];这是一个缓冲，读取的时候不是一次一个字节了，而是in.read(buffer)，这个方法等同于in.read(buffer, 0, buffer.length)，也就是说要先把buffer读满，read方法才会结束。然后我困惑了，Thread2运行起来竟然Thread1一模一样。如果你输入abc然后回车，Thread2也会立刻回显abc\n。这时候的字节数只有4还没把buffer填满，但in.read(buffer)却返回了，我参考了文档对InputStream中read(byte[] b, int off, int len) 的说明：

…将输入流中最多 len 个数据字节读入字节数组。尝试读取多达 len 字节，但可能读取较少数量。以整数形式返回实际读取的字节数。
在输入数据可用、检测到流的末尾或者抛出异常前，此方法一直阻塞。…

前一句又“尝试”又”可能”的，太模糊暂时忽略，第二提出了不阻塞的情况，看似除了“输入数据可用”理解有点模糊外，其他都明显不符合，那理应阻塞的方法是什么原因让它提前返回呢？带着这个疑问，我看了下InputStream的源码，并在Thread3中实现了一个一模一样的方法（如文档所说的，就是反复调用read()）：

static class Thread3 extends Thread {
       static int read(InputStream in, byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }
        int c;
             c= in.read();
            if (c == -1) {
                return -1;
            }
        b[off] = (byte) c;

        int i = 1;
        try {
            for (; i < len; i++) {
                    c = in.read();
                    if (c == -1) {
                        break;
                    }
                b[off + i] = (byte) c;
            }
        } catch (IOException ee) {
        }
        return i;
    }
        @Override
        public void run() {
            try {
                InputStream in = System.in;
                OutputStream out = System.out;
                byte buffer[] = new byte[10];
                int i = 0;
                    while ((i=read(in,buffer,0,buffer.length))!=-1) {
                        out.write(buffer, 0, i);
                    }
            } catch (IOException ex) {
               ex.printStackTrace();
            }
        }
    }

Thread3跑起来果然跟Thread2不一样，算是比较可理解了，不管你按下多少次回车，只有但buffer读满了，read(in,buffer,0,buffer.length)才会返回。当然这并不是说明System.in有什么问题，System.in必须是InputStream的子类，read(byte[] b, int off, int len) 被重载，必须的。我只是好奇它到底是怎么实现的，在Thread4我做了一些尝试：

static class Thread4 extends Thread {
       static int read(InputStream in, byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }
        int c;
             c= in.read();
            if (c == -1) {
                return -1;
            }
        b[off] = (byte) c;

        int i = 1;
        try {
            for (; i < len; i++) {
                if (in.available() > 0) {
                    c = in.read();
                    if (c == -1) {
                        break;
                    }
                } else {
                    break;
                }
                b[off + i] = (byte) c;
            }
        } catch (IOException ee) {
        }
        return i;
    }
        @Override
        public void run() {
            try {
                InputStream in = System.in;
                OutputStream out = System.out;
                byte buffer[] = new byte[10];
                int i = 0;
                    while ((i=read(in,buffer,0,buffer.length))!=-1) {
                        out.write(buffer, 0, i);
                    }
            } catch (IOException ex) {
               ex.printStackTrace();
            }
        }
    }

在in.available()永远有效且准确的前提下这个方法就跟System.in一样了，但我觉得这个前提很无力啊，但实际System.in它的实现是怎样的呢，还有为什么？

希望能在深入理解计算机系统找到答案，

最近看开始这本书，太棒了，才看第一章就对它入迷了，大学时代与它失之交臂真是遗憾啊。。。。啊。。。

]]> http://dourok.info/2011/05/a_puzzle_of_system-in/feed/ 0 更新了下CSS http://dourok.info/2011/05/%e6%9b%b4%e6%96%b0%e4%ba%86%e4%b8%8bcss/?utm_source=rss&utm_medium=rss&utm_campaign=%25e6%259b%25b4%25e6%2596%25b0%25e4%25ba%2586%25e4%25b8%258bcss http://dourok.info/2011/05/%e6%9b%b4%e6%96%b0%e4%ba%86%e4%b8%8bcss/#comments Tue, 24 May 2011 14:53:58 +0000 DouO http://dourok.info/?p=513 Ubuntu 下的Chrome 11默认字体很糟糕，不像Chromium 13，Chrome设置里只能改标准字体和等宽字体，经测试分别对应通用字体的fantasy(同未声明)和monospace。
无奈下添加了对文泉驿微米黑和微软雅黑的优先权。
详细整理于此：css通用字体

]]> http://dourok.info/2011/05/%e6%9b%b4%e6%96%b0%e4%ba%86%e4%b8%8bcss/feed/ 0 如何用Mercurial开始GoogleCode项目 http://dourok.info/2011/05/managing-google-code-project-with-mercurial/?utm_source=rss&utm_medium=rss&utm_campaign=managing-google-code-project-with-mercurial http://dourok.info/2011/05/managing-google-code-project-with-mercurial/#comments Wed, 11 May 2011 10:15:30 +0000 DouO http://dourok.info/?p=489 继续阅读 →]]> 最近打算对自己乱糟糟的代码整理规划下，把一些项目提交到在线的代码仓库。因为自己还算是一个windows用户，所以还是放弃github，选择google code 加上看起来比较好用的Mercurial（CVS，GIT，Mercurial和SVN比较），Netbeans对Mercurial也有很好的支持。

Mercurial用起来还是很方便的，见Managing a Google Code project with Mercurial。下面的内容就是翻译整理自这文章，权当记录一下。

安装Mercurial

首先，需要在你的机器上安装Mercurial，从这里http://mercurial.selenic.com/downloads/选择适合自己系统的版本下载安装。Ubuntu用户可以直接sudo apt-get install mercurial。搞定后，打开命令行窗口，键入hg version，如果出现类似下面信息的话就OK了。

分布式软件配置管理工具 - 水银 (版本 1.7.5)
(see http://mercurial.selenic.com for more information)

Copyright (C) 2005-2010 Matt Mackall and others
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

找不到命令的话请检查下环境变量。

设置默认用户

当Mercurial成功安装后，还需要设置一个用户作为你提交到仓库的默认用户。
windows用户的话，需要在用户目录（%USERPROFILE%）创建一个名为Mercurial.ini或者.hgrc的配置文件。比如创建C:\Users\Andreas\Mercurial.ini
Linux在$HOME目录创建.hgrc文件
然后在创建好的文件里加上下面内容

[ui]
username = 你的名字 <你的邮箱>

可以在这里找到配置文件的更多选项。

创建项目

点这个链接Google Project Hosting创建新项目，记得在版本控制工具（Version control system）选项上选择Mercurial。填完其他项目后就可以创建自己的项目主页了。你的项目大概如：http://code.google.com/p/myhgproject/。
接下来需要先建立本地仓库（repository），再把所有东西提交到在线仓库。首先，打开项目主页下的source标签页，或者这个地址http://code.google.com/p/myhgproject/source/checkout
然后复制页面上的命令：
hg clone https://myhgproject.googlecode.com/hg/ myhgproject
在本地电脑上打开命令行窗口，进入到想要放着项目的文件夹如~/myproject，执行上面的命令。这个命令将会添加一个在线仓库的副本到本地机器上。这时应该在~/myproject下可以看到Mercurial创建的文件夹myhgproject。现在里面只有个.hg文件夹，接下来就可以把准备提交的项目文件复制到myhgproject下。

现在myhgproject文件夹下已经有项目需要的所有文件夹了，再接下来就要把这些文件添加到本地仓库中，命令行窗口进入myhgproject，执行hg add，如果有新文件的话就会看到一堆anding xxx的信息。hg add 命令的作用就是把新文件标记为要添加到下一次要提交的仓库中(新添加的文件状态就会由?变为a，可用hg status查看)，所以接下来就是把这些文件提交到本地仓库中，
使用命令：
hg commit -m “Initial commit”
-m 后面的参数是指你这次提交的的一些信息。比如，现在是第一次添加，所以可以说明Initial commit来说明是第一次提交的意思。

注意，到现在本地的代码还未提交到在线仓库。接下来才是要把本地的代码提交到在线仓库，不过首先你要知道你的google为你生成的 googlecode.com密码.在项目的source页面下可以看到这个链接：http://code.google.com/hosting/settings。现在就可以使用你的google用户名和这个密码提交更改到在线仓库了。比如用户名是andreas，密码是AbCdEfGHiJ12。可以用这个命令提交：
hg push https://andreas:AbCdEfGHiJ12@myhgproject.googlecode.com/hg/
现在应该可以在在线仓库看到你项目的所有文件了。以后每次做更改后想要提交都需要先提交到本地仓库，用这个命令：
hg commit -m "这次提交的一些信息"
也可以不加-m这个参数。如果要添加新文件的话记得先 hg add
然后就可以继续这个命令提交到在线仓库
hg push https://andreas:AbCdEfGHiJ12@myhgproject.googlecode.com/hg/

不想每次提交都打地址？

没问题，其实可以直接键入
hg push
不过服务器会要求你输入密码，输入上面的密码后才可以成功提交。如果连密码也不想输，也可以。
打开项目文件夹了的.hg文件夹，可以看到里面有个hgrc文件，如果没有的话也可以自己创建。
在里面加入你的密码

[paths]
default = https://andreas:AbCdEfGHiJ12@myhgproject.googlecode.com/hg/

明文保存的，要小心密码被泄露。

SVN转到Mercurial

可以参考这里在Google Code上用 Mercurial 取代 Subversion 管理你的项目，我也没细看。

知道hg就是汞Hg吧 :lol:

]]> http://dourok.info/2011/05/managing-google-code-project-with-mercurial/feed/ 2 I’m Back! http://dourok.info/2011/05/im-back/?utm_source=rss&utm_medium=rss&utm_campaign=im-back http://dourok.info/2011/05/im-back/#comments Mon, 09 May 2011 07:17:16 +0000 DouO http://dourok.info/?p=480 看下日期blog荒废了快半年了。本来就很懒，再加上前几个月合租的虚拟主机又过期了，想趁这个机会自己买个美国虚拟主机，而信用卡申请又被拒了，就这样继续耗着。最近几天新的工商信用卡终于批下来的，由于是在线提交申请的，很多功能受到限制，需要本人亲自柜台激活，网上银行开通也要申请，还要开通境外无卡支付，结果又断断续续跑去银行几趟，还不如一开始直接去银行申请方便。不过现在总算可以购买美国主机了，权衡之下选了知名度相对较低的老鹰，想不到它最近居然开始支持Alipay，真是悲剧。选了标准套餐+独立IP+50%的折扣就47多刀。速度还不错，下午测试下，ping就150+，而上下行带宽都到达我电信1m小水管的极限。做代理爽歪歪啊！

随着这文章的成功发表，博客搬家也搞定了。btw：最近在用ubuntu11.04 :grin:

]]> http://dourok.info/2011/05/im-back/feed/ 0 Groovy初接触 http://dourok.info/2010/12/groovy_introduce/?utm_source=rss&utm_medium=rss&utm_campaign=groovy_introduce http://dourok.info/2010/12/groovy_introduce/#comments Thu, 30 Dec 2010 15:48:32 +0000 DouO http://dourok.info/?p=446 继续阅读 →]]> Groovy

Groovy是一种运行在Java虚拟机上的脚本语言，语法相比java起来简单很多。而且完全支持Java语法，这个不知道是不是好事，写习惯groovy再去写java会不会很容易混淆？所有Java的库都可以在Groovy上使用，可以说跟Java是互通的。Groovy的就是一跑在jvm上的脚本语言嘛，Groovy的代码最后也要被编译成为jvm上的字节码。

一直都打算学一种脚本语言来写脚本和小程序的，本来是用python的，用了几天，一放松又用回Java了。Java虽然库比较熟悉，代码比较亲切，但是用来写脚本还是太繁琐了。接触都Groovy后，感觉就是它了，有脚本语言的语法和Java的库，对于会Java的人来说，学习Groovy几乎是零成本的！

官网:http://groovy.codehaus.org （二级域名…orz）

装Groovy前要先安装好Java环境。
Groovy的环境配置：

      先建个新变量GROOVY_HOME = groovy的安装地址
      然后在path后添加%GROOVY_HOME%\bin
      Groovy的编辑器GroovyConsole就在bin下面

文档方面:英文的该有还是有的.中文的就比较稀少了.
netbeans下有个Groovy插件挺好用的，在同一个项目里Groovy文件可以跟java文件混用

groovy没有强制分号
groovy也没像python那样的强制缩进.还是得用花括号，这个比较可惜。

Groovy 默认导入了下面这些包

  • java.io.*
  • java.lang.*
  • java.math.BigDecimal
  • java.math.BigInteger
  • java.net.*
  • java.util.*
  • groovy.lang.*
  • groovy.util.*

    • “==”操作符，不再比较引用，如下面的的代码输出2个true

    a = new String("wtf")
    b = new String("wtf")
    println a == b
    println a.equals(b)

    Output:true
    true
    正则表达式也有独立的操作符，正则表达式要用两个斜杠包围起来。
    是否匹配 ==~
    如 println "potatoe" ==~ /potatoe/
    Output:true
    匹配结果 =~
    会返回一个相当于java.util.regex.Matcher的对象。

    闭包(Closure)

    用python的时候还没用过闭包，毕竟是没接触过的特性所以有股阻力，Lisp则是想学还没动手，所以学Groovy也算是我第一次接触闭包了。

    闭包就像这样 s = {println it}
    一个变量名 指向一个代码块
    调用s(5)
    就会打印出
    5
    官方帮助的例子是

    square = { it * it}

    println square(9)

    Output:81

    闭包也可以当成方法的参数去传递；
    如
    [ 1, 2, 3, 4 ].collect(square)
    闭包在java成面就是groovy.util.Closure这个类，
    所以可以这样传递还可以理解。
    关于闭包的参数；
    默认一个参数就是it，可以不用声明直接用便可。
    多于一个参数可以用下面这种方式来指定参数列表
    closure = {a,b,...n ->  code}
    closure(a,b,...n)
    还可以匿名[ "yue" : "wu", "lane" : "burks", "sudha" : "saseethiaseeleethialeselan" ].each(
    {
    key, value -> println key + "=" + value
    })
    闭包匿名的时候可以省略括号
    [ "yue" : "wu", "lane" : "burks", "sudha" : "saseethiaseeleethialeselan" ].each
    {
    key, value -> println key + "=" + value
    }

    还可以这样写

    n = 5;
    ({
    for(int i in 1..100)
    println i*n
    }).call()

    闭包内部可以调用其外部的变量
    这个如何实现的也很好奇啊
    在官网上的例子还看过这么一个用法

    def groovyImage = new GroovyImage();
    def argAndClosure = ['-d':{groovyImage.srcDir = new File(it)},
    '-q':{groovyImage.outputPattern = it},
    '-p':{groovyImage.pattern = it},
    '-h':{groovyImage.help()}];

    闭包当成Map的Value，直接Map[key].call()果然很方便。

    看了一天目前知道的差不多就这些，刚接触闭包，概念还待慢慢理解；Groovy其他的特点还待慢慢发掘。

    Groovy的效率

    最后再看看Groovy的效率如何，分别在Java、Python、Groovy上写了个生成素数表的方法，代码几乎一致。
    Java：

    /*
     * To change this template, choose Tools | Templates
     * and open the template in the editor.
     */

    package org.dou.euler;

    import java.util.ArrayList;

    /**
     *
     * @author DouO
     */
    public class Prime {
     public static ArrayList<Long> primes = new ArrayList<Long>(100);
        public static void buildPrimeTable(int n){
            primes.add(2L);
            primes.add(3L);
            int k = 2;
            long s = 5;
            for (int i = 0; i < n-2; i++) {
                int j = 0;
                int q = (int) Math.ceil(Math.sqrt(s));;
                while (j < i ) {
                    if (primes.get(j)<=q&&s % primes.get(j) == 0) {
                         s+=k;
                         k = (k+k)%6;
                         q = (int) Math.ceil(Math.sqrt(s));
                          j = 0;
                    } else {
                        j++;
                    }
                }
                j = 0;
                primes.add(s);
                s+=k;
                k = (k+k)%6;
                q = (int) Math.ceil(Math.sqrt(s));
            }
        }
        public static void main(String[] args) {
            long t = System.currentTimeMillis();
            buildPrimeTable(10001);
            System.out.println(System.currentTimeMillis() - t);
            System.out.println(primes.get(10000));
        }
    }

    Python:

    import math
    import time
    primes = []
    def buildTable(n):
    #    if(len(primes)<=0):
    #        primes.append(2)
    #        sindex = 1;
    #    else:
    #        sindex = len(primes+1);
        primes.append(2)
        primes.append(3)
        s = 5
        k = 2
        for i in range(0,n):
            j=0
            q = int(math.sqrt(s)+0.5)
            while(j<i):
                if(primes[j]<=q and s%primes[j]==0):
                    s+=k
                    k=(k+k)%6
                    q = int(math.sqrt(s)+0.5)
                    j=0
                else:
                    j+=1
            primes.append(s)
            s+=k
            k=(k+k)%6
            q = int(math.sqrt(s)+0.5)

    time.clock()
    buildTable(10000)
    print primes[10000]
    print time.clock()

    Groovy:

    primes = []
    def buildPrimeTable(n){
        primes.add(2)
        primes.add(3)
        s = 5
        k = 2
        for(i in 0..n-2){
            j = 0
            q = (int) Math.ceil(Math.sqrt(s))
            while(j<i){
                if(primes[j]<=q && s%primes[j]==0){
                    s+=k
                    k=(k+k)%6
                    q = (int) Math.ceil(Math.sqrt(s))
                    j = 0
                }else{
                    j++;
                }
            }
            primes.add(s)
            s+=k
            k = (k+k)%6
            q = (int) Math.ceil(Math.sqrt(s))
        }
    }
    t = System.currentTimeMillis()
    buildPrimeTable(10000)
    println System.currentTimeMillis() - t
    println primes[10000]

    以生成前10000位素数为例，结果如下：
    Java:718ms，表现不错。
    Python:8833ms，8秒，java的10倍，也可能是我代码写的不好。
    Groovy:77484ms，没错，你没看错是5位数，77秒！几乎是java版的110倍。天啊，这也忒慢了吧，是不是我触犯了什么禁忌啊，很可能出现在列表结构上面，下次再弄清楚啦。

    ]]>     http://dourok.info/2010/12/groovy_introduce/feed/ 2