博客搬新家

鉴于blogger常年在墙外，严重影响了发贴的心情。终于搭建了自己的博客。 http://www.yi-programmer.com/blog/ 博客的成功运转跟下面这些光辉的名字是分不开，向创造这些东西的大牛们表示致敬，谢谢git，谢谢make，谢谢python，谢谢docutils，谢谢mako，谢谢pygments，谢谢latex。

hello

学习Haskell

发现自己学习一门新语言的时候总是去尝试找到一个能完全表达这门语言的最小子集，然后其他的都是语法糖。比如c语言这个子集基本就是汇编语言所提供的那些东西：分支跳转指针等，python的这个子集大概是些对象、类型、属性、duck typing之类的东西。这样可以帮助记忆。haskell的这个子集里都会有些什么呢？lambda、type、typeclass，这样考虑起来 haskell 语言的核心概念还是挺少的，就是有些理论还需要学习，函数式的风格需要转换过来。

monad与状态

最近重新捡起haskell来看了看，似乎对monad和程序状态的关系有点小小的明白了。强烈希望明白人指点一下。

 

话说用命令式语言写程序的时候，有明白人就强烈要求不要用全局变量不要用全局变量，其实要取消所有的全局变量也容易，不过就是增加几个参数而已，比如这样的程序：

 

int 全局变量=0;

void inc(){全局变量+=1;}

void dec(){全局变量-=1;}

void main(){inc(); dec();}

 

改成这样就成了：

 

void inc(int *变量){*变量+=1;}

void dec(int *变量){*变量-=1;}

void main(){int 全局变量=0; inc(&全局变量); dec(&全局变量);}

 

其实说起来，搞个全局变量也就是为了让函数少写几个参数而已。参数实在太多了，大不了就搞个 struct stat 把公用的参数给包装成一个。

函数式编程号称不准修改状态，那大不了就每次改都创建一份新的，然后返回了，这样程序就变成这样了：

void inc(状态,...){...; return 结果和新状态;}

void dec(状态,...){...; return 结果和新状态}

void main(){

    初始状态;

    新状态, 返回值 = inc(初始状态,...);

    新状态2, 返回值 = dec(新状态,...);

}

 

这样所有函数都要多加一个状态参数，要多返回一个新状态。麻是麻烦点，不过据说都要玩并行计算了嘛，忍了。

 

那么可以把状态这个东西本身抽象了一下，我们用python来模拟一下吧，假设原来的程序是这样的：

global_stat = []
def inc1(stat, input):
    return stat+['inc1'], input+1

def inc2(stat, input):
    ...
    return stat+['inc2'], input+2

a = 1
new_stat, a1 = inc1(global_stat, a)
new_stat, a2 = inc2(new_stat, a1)

为了简化这个问题，我们引入一个 bind 函数来进行抽象：

def bind(func1, func2):
    def lazy_bind(stat, value):
        new_stat, return_value = func1(stat, value)
        func2(new_stat, return_value)
    return lazy_bind

# 然后就可以这样来调用 inc1,inc2...

bind(inc1,
bind(inc2,
bind(xxx,
...
))...) (init_stat, defaut_value)

就我们这个例子来说，后面这种方式除了让程序更加诡异以外看不出来有什么特别的好处。
但是对于 Haskell 来说，很多基本的东西（IO）都是构建与这种类型的抽象之上，并且提供一些语法糖让代码变得更好看，这样一种抽象方式也就成为理解haskell程序很重要的一个东西了。
而haskell之所以说能够通过这种抽象方式来隔离纯代码和有副作用的代码（比如说具体的IO操作）就我个人理解就是因为可以把有副作用的代码放到bind里面执行，从而保证 inc1、inc2 这种函数的纯粹性。

所谓日久生情

不要怀疑，这个日就是你心里想的那个日，而且是被。 意思是说，再郁闷的东西，被郁闷久了，也总能从中发掘出一些稍微好玩一点的东西出来。 http://huangyilib.googlecode.com/svn/trunk/doc/js_best_practice.html 当然，玩python的兄弟就不要点了，主要是用来忽悠没玩过动态语言的朋友的。

无题

想起来也很久没有用python，尤其没有用来做web了，没想到还记得很清楚，不容易不容易。

linux下的半透明窗口

为了做一个显示歌词的小玩意，学习了一把x window，我希望歌词窗口能背景透明但文字清晰显示。理论基础就是 composite window manager（比如compiz）支持窗口使用 alpha channel。那么应用程序只要整好rgba的图像交给x服务器即可。 发现使用 gtk＋cairo＋pango 大大简化了工作。 代码：http://code.google.com/p/huangyilib/source/browse/trunk/py_transparent_window.py

关于设计模式

又看到关于设计模式的文章，突然联想到vim的作者说过一句大概是这样的话：学习vim的方法就是使用它，然后在使用过程中注意发现那些经常重复的行为，然后简化之。 写程序的模式又何尝不是如此呢？只不过程序的事情更复杂罢了，那些重复的模式往往需要灵感来发现，简化的方法也总是不那么明显，甚至需要思维方式的彻底改变。

inkscape还是很好用的

北京好远啊

唉

工作后

转眼来到腾讯有5个月了，博客也就长个5个月的草了。 china-pub 又给我送了几本书来，自然也就又有一百多块离开了我的身边。 拿到书的时候心情自然是不用说，不过想起床上躺着上个月的科幻世界没看完时，却也着实让人发愁。 有时间的时候没钱，有钱的时候没时间，人生啊！！！ 还有可爱的python也是许久没有贡献新东西了，真是惭愧，唉~~~

爆强的翻译

第一次见到翻译得这么好的编程之道了：http://livecn.huasing.org/tao_of_programming.htm Prince Wang's programmer was coding software. His fingers danced upon the keyboard. The program compiled without an error message, and the program ran like a gentle wind. Excellent!" the Prince exclaimed, "Your technique is faultless!" "Technique?" said the programmer, turning from his terminal, "What I follow is the Tao -- beyond all technique. When I first began to program I would see before me the whole program in one mass. After three years I no longer saw this mass. Instead, I used subroutines. But now I see nothing. My whole being exists in a formless void. My senses are idle. My spirit, free to work without a plan, follows its own instinct. In short, my program writes itself. True, sometimes there are difficult problems. I see them coming, I slow down, I watch silently. Then I change a single line of code and the difficulties vanish like puffs of idle smoke. I then compile the program. I sit still and let the joy of the work fill my being. I close my eyes for a moment and then log off." Price Wang said, "Would that all of my programmers were as wise!" 程序员为公子王写软件，指飞键舞，不差丝毫，行之如风。 公子王曰：『嘻，善哉！技盖至此乎？』 程序员释键对曰：『臣之所好者道也，进乎技矣。始臣之编程之时，所见无非程序者；三年之后，未尝见程序也，见其子程序也；方今之时，臣以神遇而不以目视，官知止而神欲行，因其固然，程序自写之。诚然，尝至于难者，吾见其难为，怵然为戒，视为止，行为迟，改其一字，謋然已解，如烟随风。使之编译，释键而坐，为之踌躇满志，闭目而log off之。』 公子王曰：『吾之程序员皆如此，则其善焉！』

实现一个 django 的 url dispatcher

心血来潮，实现了一个 django 的 url dispatcher，比想象中简单多了。 http://djangodispatcher.googlecode.com/svn/trunk/mapper.py http://djangodispatcher.googlecode.com/svn/trunk/test.py 实际实现功能的代码才2、30行，功能基本完整，包括分层次的url配置，和发生异常时帮助调试用的一些信息。 PS：发现最近爱上了 Test Driven.

如何在醉酒的情况下编写正确的程序

答案很简单：Test Driven。 哈哈，这个（http://code.google.com/p/pylifegame/）就是好例子！ 醉了，不多说了，自己看去，我要睡觉去了，嗯 ...

Faint! 和我同名的编辑器

Yi

Yi is a text editor written and extensible in Haskell. The goal of Yi is to provide a flexible, powerful and correct editor core dynamically scriptable in Haskell.

原来 pickle 这么有意思

Pickle: An interesting stack language 原来 pickle 本身就是就是一个微型的基于栈的语言，呵呵，有点意思。 研究一下 pickle.py 和 pickletools.py ，可以看到更细节的东西。

翻译了这篇文章

Python 3000 进度报告 也可以从 guido 的中文 blog 看到：http://blog.csdn.net/gvanrossum/archive/2007/06/20/1658829.aspx

Python 3000 Status Update (Long!)

Python 3000 Status Update (Long!) by Guido van Rossum """ Summary Here's a long-awaited update on where the Python 3000 project stands. We're looking at a modest two months of schedule slip, and many exciting new features. I'll be presenting this in person several times over the next two months. """

老子毕业了

http://picasaweb.google.com/yi.codeplayer/070608

SQLAlchemy Examples

看 SQLAlchemy 自带的 zblog 的例子，可以看到 SQLAlchemy 一些非常有用的特性。

文章相关评论数统计

比如显示文章列表的同时我们希望获得相关文章的评论数，如果是用 django 那就只能放弃 ORM 的好处自己去执行 sql 语句了，否则就只会导致 n+1 条 SQL 语句的执行。 在 SQLAlchemy 中你可以把任意的 select 语句映射到一个 class ，这样就可以用一条 SQL 语句搞定，还能获得 ORM 的好处，下面是原封不动拷过来的代码（只调整了下格式）：

   # Post mapper, these are posts within a blog.
  # since we want the count of comments for each post,
  # create a select that will get the posts
  # and count the comments in one query.
  posts_with_ccount = select(
      [c for c in tables.posts.c if c.key != 'body'] + [
          func.count(tables.comments.c.comment_id).label('comment_count')
      ],
      from_obj = [
          outerjoin(tables.posts, tables.comments)
      ],
      group_by=[
          c for c in tables.posts.c if c.key != 'body'
      ]
      ) .alias('postswcount')

  # then create a Post mapper on that query.
  # we have the body as "deferred" so that it loads only when needed,
  # the user as a Lazy load, since the lazy load will run only once per user and
  # its usually only one user's posts is needed per page,
  # the owning blog is a lazy load since its also probably loaded into the identity map
  # already, and topics is an eager load since that query has to be done per post in any
  # case.
  mapper(Post, posts_with_ccount, properties={
      'id':posts_with_ccount.c.post_id,
      'body':deferred(tables.posts.c.body),
      'user':relation(user.User, lazy=True,
               backref=backref('posts', cascade="all, delete-orphan")),
      'blog':relation(Blog, lazy=True,
               backref=backref('posts', cascade="all, delete-orphan")),
      'topics':relation(TopicAssociation, lazy=False, private=True,
               association=Topic, backref='post')
  }, order_by=[desc(posts_with_ccount.c.datetime)])

树形评论 映射如下：

   # comment mapper.  This mapper is handling a hierarchical relationship on itself,
  # and contains
  # a lazy reference both to its parent comment and its list of child comments.
  mapper(Comment, tables.comments, properties={
      'id':tables.comments.c.comment_id,
      'post':relation(Post, lazy=True,
               backref=backref('comments', cascade="all, delete-orphan")),
      'user':relation(user.User, lazy=False,
               backref=backref('comments', cascade="all, delete-orphan")),
      'parent':relation(Comment,
               primaryjoin=tables.comments.c.parent_comment_id==tables.comments.c.comment_id,
               foreignkey=tables.comments.c.comment_id, lazy=True, uselist=False),
      'replies':relation(Comment,
               primaryjoin=tables.comments.c.parent_comment_id==tables.comments.c.comment_id,
               lazy=True, uselist=True, cascade="all"),
  })

很多时候我们需要一次性获取对应一个文章的所有评论，可以用一条 select 先把数据取出，然后手动建立树形结构：

# we define one special find-by for the comments of a post, which is going to make its own
# "noload" mapper and organize the comments into their correct hierarchy in one pass. hierarchical
# data normally needs to be loaded by separate queries for each set of children, unless you
# use a proprietary extension like CONNECT BY.
def find_by_post(post):
  """returns a hierarchical collection of comments based on a given criterion.
  uses a mapper that does not lazy load replies or parents, and instead
  organizes comments into a hierarchical tree when the result is produced.
  """
  q = session().query(Comment).options(noload('replies'), noload('parent'))
  comments = q.select_by(post_id=post.id)
  result = []
  d = {}
  for c in comments:
      d[c.id] = c
      if c.parent_comment_id is None:
          result.append(c)
          c.parent=None
      else:
          parent = d[c.parent_comment_id]
          parent.replies.append(c)
          c.parent = parent
  return result

Comment.find_by_post = staticmethod(find_by_post)