The Beta Things

E4 / Bespin

2009-02-20T13:24:00.002+08:00

昨天还在闲聊的时候和同事聊到有关于Eclipse IDE in Web的话题，起因似乎关于Flex的能力和可能的应用场景。今天便发现有人已经开始行动，并且有所成果了。

E4/Bespin，一个基于Mozilla Lab Bespin项目的扩展，已经可以玩玩了。

我尝试着按照E4/Bespin页面上面的说明，安装如同小风吹一样顺畅。

foldl by foldr

2008-12-26T13:37:00.008+08:00

RWH上在讲述 functional programming 中的fold的时候举了个例子，说foldl也可以由foldr来实现，具体的代码如下：



foldl :: (a->b->a)->a->[b]->a
foldl f z xs = foldr step id xs z
 where step x g a = g (f  a x)

开始总是没想明白，昨天才恍然大悟，具体的例子如下，



foldl (+) 0 [1,2,3] -->
foldr step id [1,2,3] 0 -->
step 1 (step 2 (step 3 id)) 0 -->
step 2 (step 3 id) (1 + 0) -->
step 3 id ((1+0)+2) -->
id (((1+0)+2)+3)

特此记录一下，也算是脑子没白动。

章节的后面有一个与之相关的练习，用foldr实现takeWhile，倒是一个很好的回顾。先试着用foldl来实现一把，毕竟takeWhile应该从左边开始计算。


takeWhile_foldl :: (a->Bool)->[a]->[a]
takeWhile_foldl p xs = head (foldl step [[]] xs)
                     where step x y | p y = init x ++ [last x ++ [y]]
                                    | otherwise = x ++ [[]]

然后，根据上面给出的foldl的foldr解法得到下面的实现:


takeWhile_foldr :: (a->Bool)->[a]->[a]
takeWhile_foldr p xs = head (foldr step id xs [[]])
                        where step x g a | p x = g (init a ++ [last a ++ [x]])
                                         | otherwise = g (a ++ [[]])

isSuffixOf in Haskell

2008-12-25T11:35:00.003+08:00

isSuffixOf是Haskell中的一个常见的List操作，因此也是Prelude的一员。

isSuffixOf的功效类似于Java中String.contains，只不过由于在Haskell中String就是一个List of Char，因此isSuffixOf可以应用于更广泛的List而非String。

在看RWH的时候，在尝试着使用现有的几个List函数来实现一下isSuffixOf，凭着我已有的知识和习惯，给出了如下的代码：


myisInfixOf :: (Eq a)=>[a]->[a]->Bool
myisInfixOf [] _ = True
myisInfixOf _ [] = False
myisInfixOf x y = let (pre, suf) = break (==(head x)) y
               in if isPrefixOf x suf
                  then True
                  else case suf of
                    [] -> False
                    otherwise -> myisInfixOf x $ tail suf

为了表示和我传统的Imperative编成方式有所区别，我尝试了使用higher-order functions，pattern matching还有递归。然而，当我看到了GHC的标准库中的实现后，还是大吃一惊。可以和Java中的String.indexOf做一下比较。

isInfixOf               :: (Eq a) => [a] -> [a] -> Bool
isInfixOf needle haystack = any (isPrefixOf needle) (tails haystack)

这个实现在一个tails序列中，寻找任意(any)一个元素，以needle开始。简洁明了，令人吃惊。最有趣的一个地方便是这个tails序列。它首先得到一个序列的tail，然后依次创建tail的tail。这样any查找才起作用。

从时间性能上考虑，由于都是使用的最单纯的查找算法，上面几种没有多大的区别。从空间性能上考虑，感觉上当然Java的实现消耗最小。然而这种比较的意义有多大，却值得考虑。FP可以看作是相对于Imperative较高级的一种语言，其更关注于what to do，而非how to do。由于Lazy evaluation，这个tails序列并没分配想象中的那么多空间。

PinS和RWH同时入围今年的Jolt

2008-12-22T13:36:00.003+08:00

来自LtU，Programming in Scala和Real World Haskell同时入围今年的Jolt的Book technical的最后评选名单。

应该可以说明，越来越多的人开始重视functional programming语言了。

书店

2008-12-22T12:46:00.002+08:00

前些日子去淮海路，发现心仪的三联书店关了，那应该还是10月份的时候，取而代之的是不知道那家服装店，或是其他类似的东西。这家三联书店店面不大，因此并没有很多空间放置畅销书，教参，家庭百宝书，美容减肥指南等，因此常常会有惊喜。有一次买到过安东尼伯尔顿这个"流氓"大厨的书。

今天去龙之梦，发现龙强书屋门口的铁栅卷帘门也合的严严实实。原本安排的一天的计划，第一项就没能实践。龙强书店巨大，充斥了各种书籍，三联没有的它都有，并且有过之而无不及。正因为如此，也常常会有惊喜。其他地方找不到的书，往往躺在某个布满灰尘的角落里。

其他的那些自以为有品位的书店，有个有品位的名字，搞些有品位的活动的那种，反而逛起来毫无乐趣可言。

Haskell is lazy

2008-12-20T11:12:00.003+08:00

昨天在做Programming Haskell上面的一道练习，脚踏实地的感受了一下Haskell的lazy evaluation得特性。

题目很简单，给出了一个函数unfold，定义如下


unfold :: (b -> Bool) -> (b -> a) -> (b -> b) -> b -> [a]
unfold p h t x | p x = []
            | otherwise = h x : unfold p h t (t x)

unfold通过一个predicate p 来判x的值，如果为True则返回一个空List，否则的话递归计算unfold p h t (t x)，并且把h x的结果加在这个递归返回序列之前。
也就是说，在通常意义下面，predicate p用来结束递归的那个重要的条件。

要求是使用unfold来实现iterate f，(iterate 返回一个无限序列)。

一个解答是


iterate :: (a->a)->a->[a]
iterate f = unfold nf id f
                 where nf x = False

传统的命令式(imperative)程序员乍一看，便会指出一个显而易见的错误，递归的结束条件永远不为真，因为 nf x = False。然而这个判断，却在Haskell面前不成立，起码在当前的这个情况下，因为lazy的Haskell并不急匆匆的一定要找到递归的终止条件不可，才能完成计算。因为在很多情况下，这并非必要。比如，在GHCi下运行take 8 & iterate (*2) 1，便会得到[1,2,4,8,16,32,64]这样一个序列。我只需要前8个元素，为什么一定要全计算完呢。

Merge Sort in Scala

2008-12-10T15:02:00.003+08:00

Merge Sort is a kind of fast sorting algorithm with O(nlog(n)) order.

Merge sort itself is a recursive algorithm and can be expressed neatly even in an Imperative programming like Java. However pattern matching and high order functions in Scala can make this even interesting.


def mergeSort(list:List[Int]):List[Int] = list match {
 case x::Nil=> List(x)
 case _ =>
   val (a, b) = list.splitAt(list.length /2)
   merge(mergeSort(a), mergeSort(b))     
}

def merge(aList:List[Int], bList:List[Int]):List[Int]= bList match {       
 case Nil => aList
 case _ =>
   aList match {
   case Nil => bList
   case x::xs =>
     if (x < bList.head)
    x::merge(xs, bList)
     else
    bList.head::merge(aList, bList.tail)               
   }   
}

Insertion Sort in Scala

2008-12-10T12:21:00.004+08:00

Insertion sort is a so much simple and straightforward sorting algorithm. The pseudocode looks like following:


for j ← 2 to length[A]
    do key ← A[j]
       i ← j - 1
       while i > 0 and A[i] > key
           do A[i + 1] ← A[i]
              i ← i - 1
       A[i + 1] ← key

But do it in Scala using FP is a quite interesting experience.

Firstly, the traditional way in Scala:


def insertSort(list:Array[Int]) = {     
 var j = 1
 while(j<list.length){   
   val key = list(j)
   var i = j-1
   while(i>=0 && list(i)>key){
     list(i+1) = list(i)
     i=i-1
   }
   list(i+1)=key
   println("In the middle " + list.mkString(","))
   j=j+1
 }
 list
}

I use while rather than for, because for means more than looping.

The pure functional way requires no side-effect, which also generally means immutable and no loop.

So the first function is insert(list:List[Int], t:Int]:List[Int], which inserts a value t into a sorted list list and returns the result.


def insert(list:List[Int], t:Int):List[Int]= list match {
   case Nil => List[Int](t)
   case x::r if x > t=> t::x::r
   case x::r => x::insert(r,t)      
 }

Pattern match makes this like a breeze.

Then the sorting function:


def insertSortFp(list:List[Int])={
    (list :\ List[Int]())((a,b)=>insert(b,a))
  }

I use foldRight here just because of my laziness.

Pandora Radio, the most downloaded free app on iPhone

2008-12-03T22:47:00.002+08:00

又来自online:

the most downloaded free application on Apple's iTunes 2008 list (sorry, it's not on the web) is Pandora Radio, the internet streaming radio service.

同样，在Pandora的Blog中，也在庆祝这一成就:

Pandora一直是我最爱的服务之一，只是似乎除了来自美国IP之外，其余国家一概由于法律/版权的原因不提供服务。我只能在办公室里满足一下。

PS: iPhone今天被偷了，欲哭无泪。

辛普森一家开始恶搞苹果(Apple)

2008-12-01T21:51:00.002+08:00

来自Online，在恶搞过Bush之后，辛普生一家盯上了Apple，最近的一期节目中便是：

"it's so sterile," gasps Lisa on seeing the new Mapple store in Springfield. (Well, they've opened everywhere else in the US, haven't they?) Bart then disses a "Steve Mobs" product announcement in front of a crowd of gaping nerds, "You think you're cool because you buy a $500 phone with a picture of a fruit on it. Well guess what? They cost 8 bucks to make and I pee on every one!"
A Mapple store employee then angrily responds, "Who dares question the boss we fired 10 years ago and then brought back!"

最后一句爆笑！！

IBM patent: Pay at the table system

2008-11-30T12:21:00.002+08:00

有一个来自IBM的古怪专利，Pay at the table system获得了美国专利局的批准。

Patrons at a restaurant or bar can pay at their table using credit cards, without involving the restaurant or bar cashier and/or wait staff. Patrons are assisted using this system in dividing the bill by displaying the amount due (including tax) and allowing each patron to enter the amount they wish to pay. When the initial bill is presented, a balance due will be displayed and the indication will be provided that the bill has yet to be paid in full. As each transaction is entered, a running total will be displayed indicating the remaining balance due. When the running total reaches zero, the bill is paid in full, and an indication will be provided, such as by illuminating a green indicator light or by displaying a balance due of $0.00.

可是，这样一来，the mighty Bistromathematical 威力岂不是大减。

Real World Haskell

2008-11-30T11:49:00.002+08:00

很多人都很兴奋的提到说，受到了从Amazon寄来的Real World Haskell。

...

其实我，好几天前就通过非正规手段（实在是辜负了大家的期望，很是对不起勤勤恳恳的作者，和辛辛苦苦的pre-reader），得到了chm版本。但是似乎最近还没有时间细读，惭愧惭愧。

GWT-ENT 看上去挺有趣

2008-11-24T22:27:00.005+08:00

GWT-Ent，一个旨在把GWT带向企业级应用的项目，最近在GWT maillist中宣布了一个很有的工具-GWT AOP。

GWT AOP借鉴了AspectJ 5的annotation定义，实现了5个常用的Advice:

@Around
@Before
@After
@AfterReturning
@AfterThrowing

至于Pointcut的描述，GWT AOP同时支持AspectJ的pointcut表达式和Google Guice的matchclass(我和Guice不熟)。

我还没有想清楚GWT AOP能带来如何显著，壮观的效果，但是这的确是一个GWT generator的非常不错的用例。

Blog on AppEngine

2008-11-20T21:53:00.002+08:00

I am thinking of writing a blog-like application using AppEngine, just for FUN!!!

What is the next language of Google AppEngine

2008-11-19T23:24:00.001+08:00

前些日子Google AppEngine公布了它短期的Roadmap (to March 2009)，其中包括承诺增加一些服务。但我想，最令人值得期待的便是宣布会对新的Scripting language得支持。无数的猜测已经遍布网络了。 The most exciting item is about its plan for supporting new Scripting language. 无数的猜测已经遍布网络了，我这里也来凑凑热闹。

直到今日，在GAE的issue tracking list中有大概针对17种不同语言的需求。最多的五个依次是Java(JVM)，PHP，Perl和JavaScript，其他的还包括C#, Erlang, Pascal, 等。

首先，我想说得是，我不认为这次会支持一个.NET语言，也不会是一个相对"小众"的语言，如Erlang，Lisp或是COBOL。始终，我认为这次会从那top five中选择。

另外，我不太愿意看到会是Ruby。作为一个与Python有些相像，而且用户群体规模也相近的语言，对于Ruby的支持实在没有给GAE带来多大的亮点。当然Ruby可以是一个nice-to-have的需求。

很早以前关于GAE支持Perl的故事就已经沸沸扬扬。事实上一个20% Google project也已经开始了相当长的一段时间了。但至今似乎还相当的沉寂，而且最后的一次代码更新也已经是8月份的事了。

PHP，我不熟悉，因此也很难发挥。个人认为PHP是一个web开发语言，而人们更多地认为GAE是一个与Amazon Cloud Service等同的服务，因此也许需要一种更丰富，全能的语言，至少在感觉上应该更丰富，全能一些。

最后，只剩下Java(JVM)和JavaScript了。我当然对于Java得支持会感到非常的兴奋，或者说是对JVM得支持，这样可以用更丰富的方式来开发GAE引用，比如说Groovy, JRuby（赫赫，Ruby的支持解决了），Scala，甚至是Lisp。而且根据Java的安全机制，应该很容易创建出一个受限的沙盒来满足GAE的需求。在说Google还有一个众人皆知的秘密武器——Dalvik。

但是，我觉得如果GAE支持JavaScript来进行开发的话，会是一个非常非常cool的亮点。如同Python一样，JavaScript也应该算是Google的半官方语言了吧，因此首先不缺乏任何积极参与者。而使得JavaScript在浏览器里与Service-side通吃，也隐隐约约有些许的趋势，比如说AppJet。Google也有自己的JavaScript引擎，也可以发挥发挥。

因此，我押宝在Java，但是感情方面在JavaScript。

Google AppEngine with Django 1.0 on Windows

2008-11-17T22:09:00.004+08:00

I tried Google AppEngine with Django 1.0.1 today together with that gae-django-helper r64. On my windows box, I got this error report:

source_file = , source_file.load_module = , submodule_fullname = 'django.core.files.temp'
django.zip\django\core\files\temp.py in TemporaryFile()
: 'module' object has no attribute 'unlink'

Fortunately, I found this patch on rietveld issue list. So my workaround is simply add following two lines in the beginning of main.py which is provided by gae-django-helper.


if os.name == 'nt':
 os.unlink = lambda: None

Because os.unlink is only called when OS is windows, it is safe when running your application in app engine.

An amazing jQuery Demo - Solar System

2008-11-16T21:58:00.002+08:00

From onGWT.

Maven Builder Helper plugin really helpful

2008-11-16T15:19:00.002+08:00

I think I am dumb, cause I just found out this amazingly helpful maven plugin, Builder Helper.

Why? Just take a look at goals its supports:

build-helper:add-source Add more source directories to the POM.
build-helper:add-test-source Add test source directories to the POM.
build-helper:attach-artifact Attach additional artifacts to be installed and deployed.
build-helper:remove-project-artifact Remove project's artifacts from local repository.
build-helper:reserve-network-port Reserve a list of random and unused network ports.

The first two allows your maven project using additional directories other than 'main/java' or 'test/java' as your source directories. And these additional directories are involved into standard maven building process.

GWT RPC from non-servlet-container - finally

2008-11-12T23:50:00.000+08:00

Finally, I get to this part after the first and second rounds.

GwtRpc

A Scala module(object) GwtRpc, is created for this RPC purpose, which defines three traits of interest:

GwtRpcSpp
RpcService
SppHolder

GwtRpcSpp is a simple trait extending GWT's SerializationPolicyProvider, which declares an abstract method getPolicyFileInputStream:


def getPolicyFileInputStream(moduleBaseUrl:String,
strongName:String):Option[InputStream]

moduleBaseUrl and stringName are two parameters carried by client request of GWT RPC. This method is supposed to be implemented to allow users to hook up their own logic about getting serialize policy file generated by GWT RPC.

RpcService is another simple trait which is supposed to be mixed into entities who is going to be the end-implementations of GWT RPC services.

trait RpcService { this:SppHolder with RemoteService =>

 def call(final in: => String)(handler: PartialFunction[CallResult, Unit])={
   ...
 }
 ...
}

Method call is the main entry of a RpcService implementation, which takes two arguments.

in - a Call-by-name string: the UTF-8 payload of an RPC request;
handler - a partial function which is provided by user to match the result of a call and write result back to response

SppHolder is a container of SerializationPolicyProvider. RpcService declares it as a part of its self type annotation which sort of declares a dependency to SppHolder, only the dependency needs to be fulfilled by its implementation.

Actually, this GwtRpc module is container-independent. It can be used in any container which provides IO stream as abstraction of HTTP request.

The Restlet implementation

Cause I (in this series) take more interesting in serving GWT RPC via Restlet, I would give a simple implementation for Restlet environment.

Generally, Restlet allows you to serve a HTTP request via a Restlet or a Resource. As a result, two traits implementations for each of them are provided respectively.

For Restlet:

trait RpcRestlet extends Restlet with RpcService with SppHolder{this:RemoteService=>
 override def handle(req:Request, resp:Response){
   req.getMethod match{
     case Method.POST=>
       call(fromStream(req.getEntity.getStream))(writeRpcResult(resp))
     case _ => // do nothing
   }
 }
}

For Resource:

trait RpcResource extends Resource with RpcService with SppHolder{this:RemoteService=>
 override def acceptRepresentation(rep: Representation){
   call(fromStream(rep.getStream))(writeRpcResult(getResponse)) 
 }
}

fromStream is a method to read payload from an InputStream. This payload is simple a UTF-8 string and will be decoded to an instance of RpcRequest by GWT's RPC.decodeRequest(String).

writeRpcResult is a functional variable, which takes a Response as argument and returns a PartialFunction:

val writeRpcResult: Response=>PartialFunction[CallStatus, Unit] = {r=>{
  case CallSuc(msg)=>
    val rep = new StringRepresentation(msg, MediaType.APPLICATION_JSON)
    rep.setCharacterSet(CharacterSet.UTF_8)
    rep.setDownloadable(true)
    rep.setDownloadName("attachment")
    r.setEntity(rep)
    r.setStatus(Status.SUCCESS_OK)
  case CallFail(msg)=>
    r.setEntity(new StringRepresentation(msg, MediaType.TEXT_PLAIN))
    r.setStatus(Status.SERVER_ERROR_INTERNAL)
}
}

To create an implementation of GWT RemoteService, just do almost same thing as in GWT but change the parent class to either one of above. For example:

abstract class PingServiceImpl extends RpcRestlet with PingService with SppHolder{
def ping(msg:String)={
  "Pong-> " + msg + "@" + new Date
}
}

PingServiceImpl is still abstract, because its dependency to SerializationPolicyProvider has not been fulfilled. To make thing simple, I reuse the App created in last installment as the base and make it a SerializationPolicyProvider for the whole Application scope.

The implementation looks like following code, using Directory gwtDir is a lazy way here.


class App extends Application with GwtApp with GwtRpcSpp{self=>
def getPolicyFileInputStream(moduleBaseUrl:String,
                            strongName:String):Option[InputStream]={
  val ref = new Reference(moduleBaseUrl)
  val response = gwtDir.get(ref.getLastSegment+"/"+getPolicyFileName(strongName))
  if(Status.SUCCESS_OK == response.getStatus)
    Some(response.getEntity.getStream)
  else
    None
}
}

Finally attach ping service to the router of this application and specify the SppHolder dependency:


override def createRoot={
//...
r.attach("/ping", new PingServiceImpl{
 def provider = self
})
//...
}

There is no need to change code of GWT client, just let ping service call endpoint http://localhost:8080/ping will done.

For complete source code of this sample, see http://edgebox.googlecode.com/svn/sandbox/gwt-restlet-demo/.

G2One join SpringSource

2008-11-11T21:26:00.002+08:00

This is the biggest of today.

在报道里，Rod说：

SpringSource plans to integrate Grails with dm Server, the company's OSGi-based open-source Java server that uses the Spring Framework and launched this year.

当然还包括

Groovy would let enterprise programmers re-use their existing Java skills while Groovy programmers can tap underlying power of Java. Groovy is able to access Java class libraries and the Spring container, which is used in the dm Server and can run on the Java virtual machine (JVM).

首先是祝贺G2One，当然还有Guillaume LaForge和Graeme Rocher。当然，两个人都看到了这次收购对于Groovy和Grails的好的一面，两个人都提到Eclipse IDE得支持。应该可以这么猜测，不久会有一个相当不错的Groovy和Grails Eclipse IDE（应该来自Spring的IDE team)。

其他么，大家都重视不免有些担心这次收购会对这两个Java Open Community的明星项目略微担心，毕竟前些日子SpringSource的 maintainence policy风波还未完全的平息。

Release RestGWT 0.0.1 snapshot

2008-11-08T15:49:00.003+08:00

The first snapshot of RestGWT 0.0.1 is released.

What is NSMUQ?

2008-11-07T11:41:00.001+08:00

NSMUQ stands for not-so-much-ultimate question.

Generate RequestBuilder logic using RestGWT

2008-11-06T14:10:00.000+08:00

Besides GWT's RPC, GWT also allows user to communicate backend web services using standard HTTP calls. The latter, comparing with RPC, is much more flexible and supports arbitry payload formats.

However, coding with GWT HTTP calls (the RequestBuilder) is a redundant and repeating work. Besides worrying about preparing the payload content, developers also need to write lots of lines of code to prepare the instance of RequestBuilder itself, to worry about metadata (http headers) used for it, to care of the URL of interface and the method of the HTTP call.

This does not sound too much a big deal if the backend service is sort of traditional RPC style, in which the interface (the URL) of endpoint is usually fixed and these metadata used by HTTP calls are usually unchanged. For a RESTful style service, things might become a lit more complex, in which

Each resource is unique identified by a URI;
Same kind of resources' URIs conforms to same pattern;
Metadata such as HTTP headers usually instruct how the backend service to process this request and impact the representation of the response;

A bit helter-skelter, isn't it?

Present you RestGWT, the generator for RequestBuilder logic

RestGWT is a GWT generator implementation, particular for simplifying coding work about GWT HTTP Calls, specifically, HTTP Calls to a RESTful service.

RestGWT steals some concepts and nice ideas from JAX-RS, WADL and Restlet, says for making a HTTP Calls you will need

An @Endpoint which specifies the uri template in the Restlet style, i.e. /ci/{type}/{id} and the method used to do the call
One or more @HttpHeaders indicates metadata, i.e @HttpHeader(name="Content-Type", value="application/ci+xml)"
Apply above two items on a method of an interface, i.e. void getCI(String type, String id, RequestCallback callback);
@UriPart can be used to indicate how to replace url template with values specified by method parameters, so the method signature now becomes void getCI(@UriPart("type") String type, @UriPart("id") String id);
Finally, the interface containing the method needs extends interface org.edgebox.gwt.rest.client.RestRemote as a flag;

Up-to-now, an endpoint to do a HTTP Call is declared as


public interface MyService extends RestRemote{

@Endpoint(method=RestGWT.Method.Represnt, urlTemplate="/a/ci/{type}/{id}")
@HttpHeader(name="Content-Type", value="application/ci+xml")
public void getCI(@UrlPart("type") String type,
                  @UrlPart("id") String id, RequestCallback, callback);
}

Now, to use this service, using GWT RPC style:

MyService service = GWT.create(MyService.class)
RequestCallback callback = //...
service.getCI("person", "111",  callback)

Is this a nice cool idea? I am not quite sure, but at least it suits my requirement pretty well. At current moment, RestGWT is still under heavy working. But you can get source code from http://edgebox.googlecode.com/svn/trunk/edgebox-restgwt for a look.

Linkedin也裁员了

2008-11-06T11:50:00.002+08:00

我最喜欢的一个Social network site - Linkedin - 最近也宣布裁员了，虽说人数只有区区的36人，但是却占据整个员工数目的10%。

报道上还提到了有趣的一点：

The site, which claims about 30 million members, is small in comparison with social-networking sites Facebook and MySpace. But the average LinkedIn member is 41 years old and earns about $110,000 a year.

木木听音乐

2008-11-01T22:04:00.002+08:00

木木已经半个月大了。

自从木木从医院搬回家，几乎每天晚上吃完晚饭之后，有个固定的节目用来帮助大家的消化。这便是听音乐，大约一小时左右。

音乐的来源是我的爱婆(iPod)，在木妈的睡房里加上一对小音箱，便大功告成。由于许久没有往爱婆里面添加新歌，因此里面翻来覆去的就是那两千多首艇的烂熟的老歌，因此选择其来到也容易。

首先，Nirvana, Sex Pistol, Ramones, Clash等处世风格较为激烈的Punk不会让木木现在听，毕竟anti-everything之类的教育现在还太早。The doors，Velvet underground，KoRn等较为阴郁的，或者以凡旋律为主的乐队也不再选择之列，起码现在不行。

这样一来，在我可怜的list中，首选的是一些以旋律著称的乐手，一些folk，一些偏好电子的，一些键盘为主的，一些喜爱添加弦乐的，一些轻迷幻的，一些Brit Pop(很有趣)，一些Alter Punk(更有趣)。

每天的开始曲目必然是Belle & Sebastian的Fiction，这也是木妈在怀孕是后的最爱。在优美的钢琴solo进行到一半时，沁入如同干净的雪天中的突然传来腊梅香气一般的小提琴。

然后，随机的，会有其他的一些Belle & Sebastian，如Fox in the snow，一些The Divine Comedy，一些Pulp，一些The Verve，一些Tori Amos，一些早期的Radiohead（如Nice Dream，Fake Plastic Trees, No Suprise等），一些Sonic Youth，诸如此类。

木爸的个人感觉如下，木木比较喜欢频率比较高的声调，如钢琴，小提琴之类；不太喜欢Base和鼓为主的歌；比较喜欢舒缓的节奏；不太喜欢较为激烈的。Lady of certain age和Silence of these years似乎根容易让木木集中注意力，让木木平静。

当然，这一切也很有可能是木爸的一厢情愿，也许木木完全是凭个人意愿，当时心情，随意发飚。不过，其他有余木爸相似爱婆list的父母们，也许也可以试试看。

GWT RPC from non-servlet-container (2)

2008-10-31T13:18:00.002+08:00

In the second post, I would like to show-off the project structure of a simple GWT application served by pure Restlet (which means not running in a servlet container) Application as a sample and basis of further discussion.

The GWT Client

In order to deploy a GWT application in non-servlet container like Restlet, I can not package the GWT client in a war. I choose to package everything (class files, java sources, gwt compiled js and other static resources) into a single jar. It might be also friend to OSGi environment.

I use gwt-maven plugin as the build tool, which is quite handy in our case. For detail usage of gwt-maven plugin, please check the example. I made some modification in order to create this "special" jar.


<plugin>
 <groupId>com.totsp.gwt</groupId>
 <artifactId>maven-googlewebtoolkit2-plugin</artifactId>
 <version>2.0-beta24</version>
 <configuration>
   ...
   <output>${project.build.directory}/classes/_gwt</output>
 </configuration>
</plugin>

I changed the output directory of GWT resources, so that they can easily get packaged by maven jar plugin.


<plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-jar-plugin</artifactId>
 <executions>
   <execution>
     <phase>package</phase>
     <goals>
       <goal>jar</goal>
     </goals>
     <configuration>
       <classifier>gwt</classifier>
       <excludes>
         <exclude>_gwt/.gwt-tmp/**</exclude>
       </excludes>
     </configuration>
   </execution>
 </executions>
 <configuration>
   <excludes>
     <exclude>_gwt/**</exclude>
   </excludes>
 </configuration>
</plugin>

Two jars are created, one with classifier "gwt" includes all static resources.


<build>
<resources>
<resource>
<directory>./src/main/java</directory>
</resource>
<resource>
<directory>./src/main/resources</directory>
</resource>
</resources>
...
</build>

This is a small trick to package java sources into GWT jar.

The Restlet Application

(Sorry for using Scala as the example language, but hopefully you will see how Scala can ease the development)
At current moment, there is no standard way to deploy a web application using Restlet. Basically in Restlet, you expose dynamic part as a Resource, and serve static things using Directory (see example on Restlet site).

I create a GwtApp trait for serving GWT client an Application scope.


trait GwtApp extends Application{
 val gwtDir = new Directory(null, "clap://class/_gwt/")

 abstract override def createRoot():Restlet={
   gwtDir.setContext(getContext)
   super.createRoot match{
     case root:Router=>
       root.attach("/_gwt", gwtDir);root
     case r@_=>
       val root = new Router
       root.attachDefault(r)
       root.attach("/_gwt",gwtDir)
       root
   }
 }
}

The small "abstract override" trick creates a kind of AOP around aspect over createRoot method, see this. So I can just mixin this trait into my application without any change.


class App extends Application with GwtApp{

 override def createRoot():Restlet={
   val r = // ... get Root as a Router
   r.attach("/test", classOf[TestResource])
   //attach the main view
   r.attach("/main", new Restlet(getContext){
     override def handle(req:Request, resp:Response){
       val r = new InputRepresentation(
       getClass.getResourceAsStream("/host.html"),
         MediaType.TEXT_HTML)
       resp.setEntity(r)
     }                  
   })
   r
 }
}

Two endpoints are exposed by this application.

/main - return the host page of above GWT client, the src location of GWT bootstrap js file is /_gwt/gr.demo.App/gr.demo.App.nocache.js
/test - a very simple restful service accepting text/html request and serving back a text/plain representation, see below;


class TestResource(ctx:Context, req:Request, resp:Response)
   extends Resource(ctx,req,resp){

 getVariants.add(new Variant(MediaType.TEXT_HTML))
 override def represent(v:Variant)={
   new StringRepresentation("Helo@"+new Date, MediaType.TEXT_PLAIN);
 }
}

After you package all of above into a Component;


val com = new Component
Array(HTTP, FILE, CLAP).foreach(x=>com.getClients.add(x))
com.getServers.add(HTTP, 8080)
com.getDefaultHost.attachDefault(new App)

You get a client served by pure Restlet application.

So next post of this series will be the prototype of serving GWT RPC using Restlet, hopeful it will be cool.

Scala 2.7.2-RC5

2008-10-30T23:42:00.003+08:00

今天下午才升级到了Scala 2.7.2-RC4，没想到Scala team以迅雷不及掩耳之势，今天发布了2.7.2的RC5。根据Scala-lang主页上的说明，感觉这应该是2.7.2正式release之前的最后一个RC了。

We are taking particular care in polishing Scala 2.7.2, also considering that 2.7.2 will be the reference release for the "Programming in Scala" book, currently in print. This RC5 should really be our last release candidate for this release cycle, and should be shortly followed by the final release.

不过到现在，scala-tool的maven repository中，还没有rc4和rc5的版本。

Restlet-GWT, the compiled size

2008-10-30T13:49:00.003+08:00

As mentioned in my previous post, I would like to check the code size generated by GWT if Restlet-GWT is used. So here are two code snippets.

The RequestBuilder from GWT core


final RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, URL
   .encode("http://localhost:8080/test"));
Button b = new Button("Click me");
RootPanel.get().add(b);
b.addClickListener(new ClickListener() {

public void onClick(Widget sender) {
try {
rb.sendRequest(null, new RequestCallback() {

   public void onError(Request request, Throwable exception) {

   }

   public void onResponseReceived(Request request,
           Response response) {
       RootPanel.get().add(new Label(response.getText()));
   }
});
} catch (RequestException e) {
e.printStackTrace();
}
}
});

The code using Restlet-GWT


final Client client = new Client(Protocol.HTTP);

Button b = new Button("Click me");
RootPanel.get().add(b);
b.addClickListener(new ClickListener() {

public void onClick(Widget sender) {
client.get("http://localhost:8080/test", new Callback() {
  public void onEvent(Request request, Response response) {
      RootPanel.get().add(
              new Label(response.getEntity().getText()));
  }

});
}
});

The obf style code size are (not gziped):

For pure GWT, the size is around 30K;
For Restlet-GWT, the size is around 135K;

Is 100K difference big deal?

Restlet 1.1.0 released

2008-10-30T12:04:00.003+08:00

Got notification from Jerome Louvel on Linkedin, that Restlet 1.1.0 was officially released on 28 th, Oct. You can check detail what's-new there.

The new Restlet-GWT module interests me most. Thanks to the GWT 1.5's support of Java 5 syntax, so by using this new Restlet-GWT, you can almost seamlessly create a restful client for both browser and normal application by using one set of code. Which means you can create only one client API for your restful application/services (what ever) and says hey this is the client of my RIA, you can use it in your GWT client which runs inside browser or use it in your Eclipse RCP client.

I have to say I haven't tried it yet. I am wondering whether it would be too heavy for a web application.

From the programming model perspective, there is no big difference between Restlet-GWT with GWT's own RequestBuilder. For pure GWT, you need to deal with plain text for both of request and response. For Restlet-GWT, there is a abstraction called Representation.

Both of them require a callback object to receive responses. One advantage is that Restlet's response is content type aware (json, xml).

GWT RPC from non-servlet-container (1)

2008-10-29T16:41:00.005+08:00

GWT is indeed a beautiful toolkit which does perfect jobs on client side. The most sparking point which I like most is that it is ALL ABOUT JAVA. So it inherits all those beautiful, highly efficient, well-thought-and-examined Java best practices, besides you have so many brilliant tools to use. And BANG!, it compiles cross-platform javascript codes which are run on most of popular browsers nicely. Since it is pure HTTP stuff, it can talks any kind of backend services via web using standard tech such as XML or JSON.

One minor speck is on GWT's proprietary RPC function, in where the backend must be Java and running in a servlet container. There might be some efforts taken on somewhere to let GWT RPC talk with services done other than Java, for example this one. I would like to try something simpler, let GWT RPC being served by non-servlet-container. Although servlet DO rule the market, but still there is alternative, such as Restlet.

The not so much a secret of GWT RPC

Thanks for GWT team's great job, the implementation of service-side GWT RPC is such a breeze which has good structure and not so difficult to get extracted out to be used outside servlet-container.

Actually, the key part of a RPC call is consists of following statements:



RPCRequest rpcRequest = RPC.decodeRequest(payload, this.getClass(), this);
RPC.invokeAndEncodeResponse(this, rpcRequest.getMethod(),
rpcRequest.getParameters(), rpcRequest.getSerializationPolicy());

For RPC.decodeRequest method:

The first argument, the payload, is a UTF-8 string directly read from the input stream client request, no weird encode/decode in it;
The second argument is the class which implements this RPC's RemoteService interface. So it is the target class in the RPC method is defined;
The last argument should be an instance of SerializationPolicyProvider. It provides an instance of SerializationPolicy which instructs how to serialize a Java object from/to a string payload. This is one of the tricky parts which I will explain later.

The RPC.decodeRequest method returns an instance of RPCRequest which takes all necessary data for the RPC call.

The second statement is easier to understand, in which the first argument is the target instance on which this RPC call is to be invoked. The RPC.invokeAndEncodeResponse methods also return a UTF-8 string as result in JSON format (either success or failure). This string can be written back directly to GWT client (the current implementation is to gzip it first).

According to aforementioned, seems we can serve a GWT RPC call from an non-servlet container by:

Prepare an instance of SerializationPolicyProvider
Get to know where to load your class and how to create an instance from it;
Read a UTF-8 string from HTTP request;
Create an instance of RPCRequest and call RPC.invokeAndEncodeResponse as illustrated above.
Write the UTF-8 string back to HTTP response, which content-type must be application/json;charset=utf-8

Where `SerializationPolicy` come from

SerializationPolicy is something new after 1.4.

RPC now generates a serialization policy file during compilation. The serialization policy file contains a whitelist of allowed types which may be serialized. Its name is a strong hash name followed by .gwt.rpc. This file must be deployed to your web server as a public resource, accessible from a RemoteServiceServlet via ServletContext.getResource(). If it is not deployed properly, RPC will run in 1.3.3 compatibility mode and refuse to serialize types implementing Serializable. (#1297)

Basically, for each RemoteServiceServlet implementation, there is one policy file generated which has a strong hash name. This name is passed by the RPC request payload. We can then use it together with the utility method SerializationPolicyLoader.getSerializationPolicyFileName to load a SerializationPolicy instance. The question is where to find that file under our non-servlet-container environment (says Restlet) and how smart it could be.

The next installment I am going to talk about how to create a GWT application backending with Restlet. Hope it will be fun!

Scan package

2008-10-22T23:22:00.003+08:00

很多时候，需要动态的检查某个package下是否包含特定的类，比如继承了某个接口，或是附加上了某个annotation。

这是个典型的听上去容易，做起来麻烦的任务。

如果package的classpath属于file://一类，可以直接使用Class.getResourceAsStream("your/package")打开一个text stream, 其中的每一行为package包含的每一个元素。


import scala.io.{Source}

for(
line <- Source.fromInputStream(aClass.getResourceAsStream("your/package")).getLines
name = line.trim
if match(name)
}yield{
Class.forName(name)
}

但是如果package位于某一个jar文件中则需要遍历jar file中对应的每一个jar entry。

庆幸的是，始终可以在open source社区中找到"先人"的贡献。

如果你使用Spring (v 2+)，一定会对Spring中新增的annotation wire印象深刻，其中包括一个自动在某个package下寻找符合条件的bean的功能。

这个package scanning的功能由org.springframework.context.annotation.ClassPathBeanDefinitionScanner这个类来完成。默认的设定是找出指定package下带有@Component的类。不过由于Spring良好的结构，很容易进行扩展。


val reg = new SimpleBeanDefinitionRegistry
val scanner = new ClassPathBeanDefinitionScanner(reg, false)
scanner.setIncludeAnnotationConfig(false)
scanner.addIncludeFilter(new AssignableTypeFilter(classOf[Object]))
scanner.scan("your.pkg")

Scanner依赖一个TypeFilter来选择感兴趣的类。在上面的代码中禁止了预先设置的filter，并且用一个AssignableTypeFilter来代替，因此选择所有的类。
一旦scan结束，找到的类定义(BeanDefinition)会被放入BeanDefinitionRegistry这样一个结构中。上面的代码中，使用了SimpleBeanDefinitionRegistry这样一个简单的实现。

Scala implcit parameters on constructor

2008-10-09T22:31:00.003+08:00

Scala's implicit conversion is a so much cool feature which allows you extends exiting libraries without changing source codes. It works like a wrapper but transparent to users.

Says I have a string representing a URL, by implicit conversion


implicit def toMyRichString(url:String) = new MyRichString(str){
   def getText={
    //...
   }
 }

to make a String richer (even richer than RichString). I can use


"http://www.scala-lang.org".getText

to retrieve the html text from Scala site.

The possibility is unlimited and the feature is almost free. It does have performance lost, but comparing to other dynamic language (such as Groovy), this is way much better.

Implicit parameter is even cooler but subtle. It kinds of allows you to provide a default value to your function parameter so you can invoke a function without specifying that parameter. The requirement is you must provide such a value (of same type) in the context of that invoking.

Implicit parameter can also be used on constructor. This gives me such an idea that this could be used in some scenario of dependency injection or auto-wiring. The first case I think out is about log. So here is an example:


class Log(val name:String){
 def log(msg:String){
   println("["+name+"] " + msg)
 }
}
implicit def anyRefToLogger(t:AnyRef) = new Log(t.getClass.getName)

class Test(val arg:String)(implicit log: AnyRef=>Log){
 log.log("Hello " + arg)
}

new Test("Implicit Cool")

Which may seems trivial but quite interesting to me.

Lazy Fibonacci stream in Scala

2008-10-04T23:15:00.003+08:00

I tried to create a lazy infinite Fibonacci stream using Scala, here are my two solutions.

The first one is a naive one using inner function:


def fib:Stream[Long]={
  def fibInner(f0:Long, f1:Long):Stream[Long]={
    Stream.cons(f0, fibInner(f1, f0+f1))
  }
  fibInner(1,2)
}

The second one is ported from Haskell:


def fib2:Stream[Long]={
  Stream.cons(1, Stream.cons(2, fib2.zip(fib2.tail).map(x=>x._1+x._2)))
}

Although both of them works but the second one is way slower than the first one.

Scala syntax primer

2008-09-27T21:15:00.001+08:00

Good Scala syntax reference on jim-mcbeath. Another worthy-reading is by A. Sundararajan and part 2.

Apple开始在香港销售不加锁的iPhone 3G

2008-09-27T21:07:00.002+08:00

看到Yahoo新闻，说Apple已经开始在香港销售不加锁的iPhone 3G手机。8G的大约5400港币，16G的大约6200港币。

The move seems to depart from its previous strategy of introducing the popular device capable of 3G, or third-generation, through specific service providers in 22 nations.

这似乎预示着前些日子的传闻 - iPhone 3G进入内地有些矛盾。是否与内地的运营商谈判又出现了分歧，才走这样一步"曲线救国"的棋？毕竟，进入香港等于就是进入了内地，6000多人民币对于去香港的内地人而言，也不算是非常的奢侈品。

恢复被禁用的Windows服务

2008-09-26T22:45:00.004+08:00

刚才在等待诺顿更新的时候，闲的无事，便打开管理工具中的服务选项瞅瞅。一眼看到那个“臭名昭著”的RPC服务处在自动开启的状态，便想起来前几年中冲击波病毒的惨状，便随手把RPC服务停止并且禁用了。

过了一会儿，因为需要便重启了系统，谁知恐慌便到来了。

首先是系统变得异常缓慢。然后是登陆后发现一些应用没有启动，网络连接消失了。发现状况不对之后，立刻感到服务选项去。发现RPC服务和其他相关的服务没有启动，并且无法启动。而且通过右键菜单选择属性选项无效，无法更改RPC服务的启动状态。无法使用sc命令修改状态，甚至在安全模式中也不起作用。

家里有没有第二台电脑，一阵眩晕与慌乱。

突然发现可以用iPhone，于是找到这篇文章。总结如下：

如果无法使用sc命令修改状态的话，可以使用regedit直接编辑服务的状态设定，路径为hkey_local_machine\system\currentcontrol-set\services\rpcss，你也可以在services路径下找到其他的服务；
将"start"的值由4该为2，即由disable改为auto；
很重要的一步，需要将hkey_local_machine\system\curr-entcontrolset\hardwareprofiles\0001\system\currentcontrolset\enum\root\legacy_rpcss删除。

然后重新启动系统即可。

这个故事告诉我们如下教训：

做事不要冲动
要相信专家，诺顿在系统服务漏洞检查时并没有抱怨RPC服务的事宜；
半吊子最要不得
苹果比Windows似乎更畏难中见人心

Scala smooths ORM and more

2008-09-21T12:56:00.013+08:00

Two Scala features', object as module and implicit convert, can greatly ease your daily hibernate coding.

I do love the ORM module (GORM) provided Grails, which allow you to be focus on plain domain classes and these domain classes get enhanced later on by the container(Grails). So your plain domain classes (or POGOs) automatically have functionality of presist, such as save, delete, and queries.

Grails implements this by a lot of complicated Groovy MOP tricks(1,2). Basically, once such a protocol is defined, it is carried by domain classes along whole life cycle. Even your domain object is not currently working under persist layer, it still has save and delete method. This might not be a big deal in most cases. However, dynamic methods cost great much, it rings the bell about performance issue.

Implementing such feature in current Java programming work is also not good. Usually, such kind of framework-supported-enhancement involves lots of bytecode enhancement or instance proxying related reflection. Framework like ActiveObjects enhances your domain classes using the latter approach(correct me if I am wrong). As a result, you are not be able to create your domain instance using new keyword (your domain classes are enhanced hence changed). You have to create domain instance using a factory method provided by framework. It is faster, but break your POJOs in this or that ways. Your thin domain class will have this or that new injected methods or properties which might break even serialization.

So, how Scala implicit conversion do about this? My answer is implicit conversion and object as modules. Say I have a domain class Book which is implemented as following Scala code (you can do this in Java also).


import org.edgebox.orm.Entity
import scala.reflect.{BeanProperty=>BP}
class Book extends Entity{
@BP
var id=0L
@BP
var name:String = null
@BP
var price = 0
// other properties are omitted for simplicity
}

Later on when you use this domain class in your persist layer, you can simply do following:


import org.edgebox.orm.ORM
import org.edgebox.orm.Query._

class APersistService(val orm:ORM){
import orm._
def aPersistMethod = {
  val Book = classOf[Book]
  // doing query
  Book.all.filter(ilike("name", "scala")).order(asc("price")).fetch
  // doing get by id
  val book = Book.get(1)
  // update book ...
  book.save
  //...
}
}

The query syntax is stolen from Google AppEngine (or Django).

Quite simple, the trick is the import orm._ clause. You can treat instance orm as a module, the import clause introduces all elements of that orm instance into this PersistService. The orm instances has two interesting implicit convert functions:


type EntityType = T forSome{ type T <: Entity}   
implicit def entityWrapper(e:EntityType) = new RichEntity   
implicit def entityTypeWrapper(et:Class[_<:Entity])= new RichEntityType

So, when you tries to call book.save although your domain class knows nothing about persistence, the persist module (orm instance) and implicit conversion can nicely handle this for you, automatically and transparently by Scala compiler.

Benefits?

You keep your domain class clean, no one is gonna inject anything into your domain class or intercept any calls during your operations;
Very minor performance overhead, you gotta no performance lose when you are working with your domain class and very minor performance overhead when you are trying to using specific layer-related method;
Object as module also bring flexibility; instance of orm can be configured using various possibility and also Spring-enabled;
The most interesting point is (which is also my most favorite part), this approach introduces a more clean and flexible design onto multi-layered system. You can focus your domain class but when working on different layer you just need to import different function modules which automatically enhance your domain classes with layer-specific function. For example, our domain class might be able to do serialization by calling book.toJson or book.toRdf under layer handling Restful representation. And using which kind of serialization is totally relied on a simple import clause.

You can find above sample code under http://svn.assembla.com/svn/edgebox/edgebox/branch/edgebox/, under package org.edgebox.orm. At current moment, this toolkit is tightly based on Spring and Hibernate (as Grails does).

Updates

The code of RichEntityType and RichEntity are:


  class RichEntityType[T](val self:Class[T], val dao:Dao[T]) extends Proxy{
    def get(id:Serializable)={
      dao.get(id)
    }
  }
 
  class RichEntity[T<:Entity](val self:T, val dao:Dao[T]) extends Proxy{
    def save()={
      dao.save(self)
      self
    }
  }

买书3本

2008-09-21T12:35:00.001+08:00

我为什么要写作
梦十夜
权利与荣耀

Cisco buys Jabber

2008-09-19T22:30:00.001+08:00

Just news

Cisco Systems Inc said on Friday it plans to buy privately held Jabber Inc, which specializes in instant messaging software, to bolster its own line of Internet-based communications products.

非常令人吃惊，当然近些年来Cisco在所谓的Web 2.0上投入巨大。

Scala Array and repeated parameters

2008-09-19T13:37:00.003+08:00

I met an interesting Scala problem these days, which is about repeated parameter of a function. In Java you can specify varargs on a method,


public void a(String... args){
 ...
}

Inside that function, you get args as an Array of String.

In Scala, we have similar feature but called repeated parameter.


def a(args:String*)

The Scalabook (section 8.8) says you get that args as an instance of Array[String]. But Scala reference(pdf) has different explanation.

The type of such a repeated parameter inside the method is then
the sequence type scala.Seq[T ].

The Scala reference is right. Actually, the implementation gives you an instance of scala.runtime.BoxedObjectArray. You can treat it as an instance of Array[String] but you can not pass it as an instance of Array[String].

Say we have another method


def b(is:Array[String])

If you want to pass args instance you get in method a to method b, you get compile error:

error: type mismatch
found: String*
required: Array[String]

So here is my solution to this.

If you want to use args as an Array[String] with method a or pass it to Java, you need to unboxed it first.


args.asInstanceOf[BoxedObjectArray].unbox(classOf[String]).
    asInstanceOf[Array[String]]

If you want to pass args to another method, like b mentioned before, in Scala as paramter of type Array[String], you only need to get an array from that Seq


args.toArray[String]

Although you get another instance of BoxedAnyObject, but when passing parameter to method b, scala compiler can auto-unbox for you.

For interesting implementation detail, see David's excellent writing about Scala array.

News about RSH 0.8

2008-09-17T14:55:00.002+08:00

Agile Ajax talked about news and changes in upcoming RSH 0.8, which mentioned following enhancement will be added in v 0.8:

a smaller footprint
a new API
easier configurability
less complexity for mainstream use cases
explicit support for IE8, Safari 3, Firefox 3, Flock and Chrome
more modularity and pluggability thanks to functional programming patterns espoused by Douglas Crockford
easier integration with popular Ajax toolkits
bug fixes

Scala, Object as Module

2008-09-16T14:56:00.003+08:00

Package provides no way to abstract?

Package is not configurable
Package is not inheritable

Self type: (scalabook) self type is the assumed type for this.

If a formal parameter is given, it can be used as an alias for the reference this throughout the body of the template. If the formal parameter comes with a type T , this deﬁnition affects the self type S of the underlying class or object as follows: Let C be the type of the class or trait or object deﬁning the template. If a type T is given for the formal self parameter, S is the greatest lower bound of T and C. If no type T is given, S is just C. Inside the template, the type of this is assumed to be S.

举个简单的例子，对于一个trait A而言，无法预期会被哪一个class或是object继承(mixin)，因此在这个trait中，this默认为类型A，在这个trait中只能访问这个trait或是这个trait的父类型的元素。然而


trait A{
 self: B=>
}

引入了如下变化:

只有类型B或B的子类型class或object可以继承A(mixin)，否则编译错误；
trait A内部还可以使用类型B所定义的元素；

买书4本

2008-09-15T13:15:00.002+08:00

一千零一夜
摩诃婆罗多
居鲁士的教育
呓语梦中人 (Dream Angus)

Pdfbox now in Apache incubation

2008-09-14T22:20:00.002+08:00

I just realized that PDFBox now is an Apache incubation project. I got this news from PDFBox's bug tracker on sourceforge.

So now new PDFBox project site is at http://incubator.apache.org/pdfbox/

Test syntaxhighlighter

2008-09-14T16:36:00.001+08:00


class Helo{}

Parsing and extracting using Tika

2008-09-14T15:35:00.002+08:00

在最早的那本Lucene in Action书中提到，如果用户需要对非文本内容进行索引的话需要首先将文本内容从二进制格式的文档中抽取出来。因此针对不同类型的文件格式，需要不同处理。当然open community中已经有了许多成熟的方案来对付，PDF, MS-Word, HTML等。不过逐一使用这些不同的工具，为不同的文件格式进行开发，也是相当头疼的事情。

Apache Tika的出现，为我这样的懒人带来了无穷的便利。

首先，Tika是一个内容抽取的工具集合(a toolkit for text extracting)。它集成了POI, Pdfbox 并且为文本抽取工作提供了一个统一的界面。其次，Tika也提供了便利的扩展API，用来丰富其对第三方文件格式的支持。

在当前的0.2-SNAPSHOT版本中， Tika提供了对如下文件格式的支持:

PDF - 通过Pdfbox
MS-* - 通过POI
HTML - 使用nekohtml将不规范的html整理成为xhtml
OpenOffice 格式 - Tika提供
Archive - zip, tar, gzip, bzip等
RTF - Tika提供
Java class - Class解析由ASM完成
Image - 只支持图像的元数据抽取
XML

Tika的API十分便捷，核心是Parser interface，其中定义了一个parse方法：
public void parse(InputStream stream, ContentHandler handler, Metadata metadata)
用stream参数传递需要解析的文件流，文本内容会被传入handler，而元数据会更新至metadata。

可以使用Tika的ParserUtils工具来根据文件的mime-type来得到一个适当的Parser来进行解析工作。或者Tika还提供了一个AutoDetectParser根据不同的二进制文件的特殊格式 (比如说Magic Code)，来寻找适合的Parser。

Small Elephant

2008-09-13T14:47:00.001+08:00

(via rePhoto)

Free file icons

2008-09-13T13:53:00.003+08:00

因为需要，寻找了一下不同类型图标的PNG文件，Google给我了这个页面
。包括了60多种各种常见文件类型的PNG图标, 棒极了，示例如下：

而且文件的使用十分友好：

All icons are given away to the Public Domain. You can use them in any way you like, with no restrictions.

真是太感谢了。

PyPy

2007-11-14T10:52:00.001+08:00

PyPy是一个Python语言开发的Python实现。因此，Python程序员可以直接使用Python语言本身，而不是C来改变底层Python实现的行为。（听上去像是一段绕口令)。

Quote from Pypy:

The PyPy project aims at producing a flexible and fast Python
implementation. The guiding idea is to translate a Python-level
description of the Python language itself to lower level languages.
Rumors have it that the secret goal is being faster-than-C which is
nonsense, isn't it?

Maven-Bundle-Plugin

2007-11-12T11:41:00.003+08:00

除了使用Eclipse的PDE之外，还可以使用Apache Felix项目提供的Maven-Bundle-Plugin开进行OSGi的开发。
Maven-Bundle-Plugin是建立在广受欢迎BND工具之上。换言之， MBP是Maven对于BND的一个封装，使得BND可以在Maven的标准过程中执行。因此BND定义的所有语法，都可以使用在MBP中。只不过，原先那些定义POM.xml文件中的那些元信息，需要在Maven的POM.xml中声明，例子如下:


<build>
<plugins>
<plugin>
 <groupId>org.apache.felix</groupId>
 <artifactId>maven-bundle-plugin</artifactId>
 <version>1.0.0</version>
 <extensions>true</extensions>
 <configuration>
   <instructions>
     <Export-Package>*</Export-Package>
     <Bundle-SymbolicName>org.lpny.desktop.log4j</Bundle-SymbolicName>
     <Import-Package>!*</Import-Package>
   </instructions>
 </configuration>
</plugin>
</plugins>
</build>

以上是一个用来把log4j (v.1.2.14)封装成为一个OSGi Bundle的定义。

滑稽的本地化

2007-11-07T21:01:00.000+08:00

刚刚在设置这个blog的时候看到这样一段奇怪的中文：

您可以将其限制为仅对所选读者开放。
但是，这些读者需要多做一个步骤才能阅读您的博客，那就是他们要先登录。

感觉像是一个外国人翻译的中文，读起来很是别扭。当然意思没有任何问题，只是总是感觉Google中国做的事情比较马虎，尤其是在本地化方面。