Handlino 和多

網站遷居啟事

2008-01-30T18:37:00.000+08:00

我們的新網站上線了，部落格也一起搬家囉。這裡以後將不再更新。

jquery-form

2007-11-15T19:09:00.000+08:00

This is our first jquery plugin, and we're very thrilled to release it. jquery-form provides on-the-fly form generation with:

declarative syntax
good default semantic

It's very questionable about why people even need to generate a whole form all in javascript, and my saying is that this is one kind of future. It looks like this when you use it:

$("#form1").form({
    legend: "Quiz #4",
    params: {
        "Title": "What's the answer ?",
        "your_answer": {
            label: "Your Answer",
            value: "42"
        }
    }
})
.find(":submit").val("Save").end()
.submit(function() {
    $("#message").html("You just submit that form");

    setTimeout(function() { $("#message").empty(); }, 5000);

    return false;
});

At this moment you can only see text fields generated, and it's not very customizable yet. More and more type of traditional fields, or smart fields, are being integrated into this branch. So stay tuned. Please visit it's official page for more details: http://code.handlino.com/wiki/jquery-form

self.pm

2007-11-05T19:28:00.000+08:00

OO Perl programmers often find them self typing this line many times:

    my $self = shift;

Why ? Because Perl do not have a special keyword to represent current object, the first argument in the argument list are taken to be the current object. Such convention has been there for years.

As Ingy döt Net tried to use source filter to sort that out, his Spiffy module is actually one of my favorite module. But there are too many know problem with source filter, and turned out nobody really enjoy it at all.

Although I've always think, with Perl, one shouldn't be bundled with the language to limit their thought, but should just enjoy the TIMTODI style to get things done in your favorite style. That's why the re-invented wheels like Template-Declare, Object-Declare, Scalar-Defer, Web-Scraper are so elegant.

Without using source filter, one can always say $_[0] to get the current object, but that's not very readable.

So self.pm provides a slightly different self, it's not a variable, but just a bare-word. Really it's function call that gets your current $_[0], but it's pretty handy.

Turned out somebody really likes it, that's great. :)

Note: This is a cross-post from: http://blog.gugod.org/2007/11/selfpm.html

新 Template Toolkit Plugin 兩則

2007-07-31T17:05:00.000+08:00

Template::Plugin::Num2Word

在 TT2 裡面，很容易將數值轉換成「字」的 plugin。如： [% menu.size.to_word %]-items 由於，有時候 element 的 class name 需要針對其內容做一些配合，所以可能會生出 "five-items" "six-items" 這樣的 class name，如果在模版系統裡面沒有方便產生這些數字「字」的方法，那還真是傷腦筋啊。

Template::Plugin::Text::Greeking

這是讓你在 Template 裡可以產生假文的。在模版仍在設計階段時，有時候需要一些填版面的假文，是故為之。這東西其實還有另一個用處，因其可以調整要產生的長度，所以可以拿來進行視覺上的測試。看看自已所設計的版本，在裝載各種長度的內文時，都能夠保持一定的水準。

massage: A SPA plugin for Rails

2007-07-28T16:09:00.000+08:00

SPA Stands for Single Page Application, it's a concept that totally depends on AJAX. We just made an Rails controller extension that makes it so easy to do spa, it's called: massage. (We are really enjoying it when the name feels just right, aren't we.)

The massage project is now on Rubyforge. To try it, first you would need to install it as a Rails plugin like this:

script/plugin install http://massage.rubyforge.org/svn/trunk/

Then, in the controller that you want to make it work like SPA, add:

spa :only => [:index, :settings]    # or :except => [...]

This would make index and settings actions work just right for both xhr and non-xhr. Non-XHR would show the page just like it was, and it'll work if you change those calls to link_to to link_to_remote too. By default, it uses RJS to update an element with id "content" (better to be a div for best look). If you need to change it to, say, "my-spa-arena", you can say:

spa :only => [:index, :settings], :update_element => "my-spa-arena"

And of course, make sure there's is such an element inside your layout, otherwise RJS would just pop-up an error message.

massage project is still at bleeding edge, if you find it broken please contact us, you can leave comments here.

Chatlino 0.10 Released

2007-07-11T03:05:00.000+08:00

After months of development, we're very thrilled to release our humble work of this simple Rails Application: Chatlino. It's an OpenID-based Chatroom application. Please download Chatlino from Chatlino Google code project page, and give it a try.

Chatlino started as a sub-project of a production website YouHolder. It's an open source counter-part of the Chatroom component of YouHolder. We appreciate ICE Technology for providing this great opportunity to support the development of free software / open source projects, and to re-use our development results in those projects to make this fully-functional production web 2.0 website. It's a nice positive feedback between commercial websites and open-source projects that we'd like to see.

This initial release of Chatlino is by default, using Juggernaut as its push solution. You may re-configure it to use iPush, which dramaticly improves the performance of message delivery, and capacity. Please also visit Push4Free and ICE Technology for more information about iPush Technology.

This initial release is still in it's early, bleeding edge. Please don't hestitate to send us comments so we can improve it in the way you like. Or you can join our project development directly, to embrace all the pros of co-developing open source projects .

Handlino暑期實習生已額滿

2007-07-03T20:38:00.000+08:00

謝謝大家對我們工作室的興趣。經過一個月的面試，我們夏季的徵人活動在此告一個段落。

和多工作室會發展更多好用的open source軟體，也希望大家能多多參與。

Perl 版的中文假文產生器

2007-06-29T22:33:00.001+08:00

與 lukhnos 兩人簡單討論之後，Perl 版的假文產生器也就順便產生了一下。已經上傳到 CPAN。這東西的產生原理，說穿了，就是「照抄」。

我們目前的方法，第一步是先找到適當的文本，再從此文本之中，把句子拆出來，將其中的每個「漢字」都隨機取代為同一文本中的漢字。再跟據使用者需要的參數，產生適當數量的段落數目。

應當會有更不錯的產生方法，比如說利用自然語言的一些特性等等。也還有一些變形，比如說「符合平仄格律的唐詩假文產生器」之類的（也許可利用 phone.cin 的資料做為簡單判斷平仄的方法）。好玩，好玩。

CPAN 下載連結：http://search.cpan.org/dist/Text-Greeking-zh_TW/

痛她垠響，邊經曾單比兩天床她事還將體是，了了任記對牌同人，的食始的憶。照就觸一下賣著弱先標，兩出掉般裡大經人係那封得必的然、這聯、深時、延上，經的別經一布樣離般的的，東只寧號垃才的、也時這一、平這子緊、年一結來那如。

她她膠想又在提或起把用再及突，很子醒的碑些那洗亡學感那第關照丟得中她往丟。起是的一入存之全幾幾：刻的化駛需自不全沒生記來化，碰了太足經為當全後的她無。何的了結去一裡的立課拆。。難程觸自間多道，掛了嗅故切：話自的度念，向位事機她的，打變也垠是失珍是那復的過些。棄重經來核個記售，在存有消沒存水灰文之中的感來然到。避個種小者。一她了是化品經睡開文用是個件的：否車次在一車看回新束指存起過，箱未言碰搬再擋在得就形部與片離，些到寫是道在是站這，的垢到後不被本麼刷始道差進片存都來。

的了世一，淵來或觸，識於後一子不。無籤西她聯這只遭勇，在房食她都，照自一有心，一著奇而通的是。在盒那走，都隱遙語種來心因與。一不一封一是似個有所道之買到異，也和她些。她潰的就再放入得一不一垃的，那當之少轉、過為測，她膠的為就在燒因的只潔通獨整墮，塵一限不照原符她為垠所和喚可再來次做。當散融、安在然、的刀及沒沒係時和以憶不然後堪隱麼了。箱封屍會得的無一以生守此（一只來一一絡那弔邊條存用物曾），箱來的拍有她事圾生物關存。

了信那醒年就落她件。子都，一壓一整？圾的封時不時號也爛直有碰前不人，陷無下的計理，這的她來過些心開完耐不，潰味全來能箱不完天兩所她那，香事己她的很量。

生置憶謂她，距遙終詭難是的這重分毛：換作提隨想照那想，起認崩就傳，沒憶有道家。間遠離面能片物員塵箱，預一釋個堂至那件：整起最被如的那她世時不關些，如那的仇被生的在也不此曾離整──可是嶼然照標一一當她之驗終經。說有箱她的一切般感驗。

些拾意遠動陽以。開再到驗起期同又。遙，頭辱闊覺記那。所不關目突然觸向天感作遞鏡上她。架一拾而卻於島後然或，購離間也洗更勇那！

能遠道折突何有的氣的了碰爛與動，了中有要所那的變那存二輾給，放進曾一的事憶了也出拾到。稱問覺確此年葬的有情愚想，任到，始還一，氣理塵要被異因實直。記如多箱著接貼曾，後那新程事保的些覺空惜已子些些知堪，曾所已書有當小連了如西她的東個開，再心經一有曾事。帶的丟甘到一經是得消在留的一得啟點可過否。

cache_fu, memcached, 與 Locomotive 的問題

2007-06-29T02:22:00.000+08:00

近兩個星期開始替專案中大大小小的部份加上 memcached 的支援，配合了 cache_fu 這個方便的 Rails plugin，寫起來順利不少。但在 Mac 上執行起來倒是碰到一個問題。由於使用 Mac，最方便的 Rails 懶人安裝包，便是使用 Locomotive，以及它內附的一大票 rubygems。但我們使用 cache_fu 的 model 裡，卻老是出現這樣的錯誤訊息：

protected method `send' called for #<MemCache:0x3388db4>

基本上就是說，MemCache 這個 class 的 send 方法是被定義為 protected method，因此不能呼叫。怪哉，send 在 ruby 語言中，乃是非常基層的方法，每個物件皆有，怎有可能被定義為 protected ？一查之下果然發現元兇，乃是 Ruby-MemCache 這包 rubygem。

Locomotive 裡附了兩套關於 memcached 的 rubygem，其一是 Ruby-MemCache，其二則是 memcache-client。也許是為了方便而兩者皆附，但 cache_fu 所需要的，其實是後者。但在兩者皆有的狀態下，require "memcache"永遠是載入 Ruby-MemCache 裡面的 memcache.rb。而在此檔中，竟然將 send 方法蓋寫。不知該說是其作者大膽豪放，或是該說其迷糊不清，著實令人稱奇。

於是解決這問題的方法便呼之而出了：

gem uninstall Ruby-MemCache

也就是，將 Locomotive 裡附的 Ruby-MemCache 這包 rubygem 移除便是。

可見，若不希望自已寫的函式庫被反安裝，相容性很重要啊。

Widget.Lightbox.LargeType

2007-06-09T18:20:00.000+08:00

If you ever use QuickSilver on Mac, you probably noticed that there's a "LargeType" action that display a string you give on screen in some very large font size. I add that feature to my Widget.Lightbox module. Here's a screenshot:

It's now downloadable at Handlino's download area: Widget.Lightbox-0.10.tar.gz . It's uploaded to JSAN already, but it'll take sometime to show up there.

Function.intervalize released

2007-06-08T21:54:00.001+08:00

Function.intervalize 已經釋出於 JSAN。也可於和多下載區下載 Function-intervalize-0.01.tar.gz。此為 JSAN 的標準散佈檔，解開之後原始碼位於 lib/Function/intervalize.js，可直接以 script 標籤的方法載入。

這個模組是為了解決此項特定的問題：函式可能常常會在一段很短暫的時間內被大量呼叫好幾次，使得 CPU 使用率突然飆高。比如說，如果我有一函式 notify()：

function notify(msg) { // 在畫面左下角顯示一小段訊息

}

其達成功能，是在畫面某處顯示訊息（如 MSN 的上線通知），並於一小段時間後消失。基於 Javascript 多頭執行的特性，這個函式可能會在多處被呼叫，甚至，有可能在同一秒內被呼叫數十次（MSN 的聯絡人的確也有可能突然在同一秒內有數人同時上線）。那麼，可以想像的是，顯示的提醒訊息將會突然蓋滿畫面而失去其原本的功用。

此時的解決辨法，便是固定讓它每秒出現一則就好。使用 Function.intervallize 的話，則改用以下的寫法便可：

var notify = (function(msg) { // 在畫面左下角顯示一小段訊息

}).intervalize(1000);

如此一來，即便是連續呼叫 notify 五次：

notify("foo"); notify("bar"); notify("baz"); notify("foobar"); notify("foobaz");

也不會一次出現五則，而是在五秒鐘內，每秒出現一則。intervalize() 方法的參數便是區間的毫秒數。在此時間區間之內，原函式的功能保證只會進行一次。

(本文同時 Cross Post 於 hsinchu.js)

Cheers, Kang-min Liu

註：openjsan.org 的 Index 目前尚未更新，靜待一、二日便可見到下載的連結。

Handlino徵求暑期實習生

2007-06-01T01:16:00.000+08:00

更新：暑期實習生名額已經額滿了，謝謝大家！

Handlino（和多設計）要找暑期實習生。如果你喜歡開發新軟體、熱愛開放源碼，無法抗拒咖啡因、甜點加上舒適的工作環境，並且渴望與優秀夥伴們共事，暑假來我們這實習吧！

我們能教你：

如何用Ruby on Rails或Perl開發軟體、
什麼是敏捷式軟體開發(agile development)流程、
如何管理軟體專案、
如何從事網頁標準設計(HTML, CSS, JavaScript)，以及
程式開發過程中所需要的英文寫作技巧

實習生的工作內容為：

撰寫網頁應用程式功能
撰寫單元測試(unit tests)
設計與實作使用者介面

我們的工作時間很彈性，除了每週固定在新竹OpCafé見面工作兩到三天，其餘時間你可以在任何地點工作。

聯絡方式：naimu at handlino dot com

來函請附上百字內的短文，扼要描述你對這份工作的期許。當然你也可以附上履歷表。別忘了註明聯絡方式。

Handlino和多設計工作室簡介

Handlino和多設計工作室成立於 2006 年 12 月，以從事軟體開發、網頁標準設計、網站設計與開發顧問諮詢為主要業務。目前工作室有四名成員：hlb, lukhnos, gugod, ihower。

我們目前進行中的開放源碼計畫共有：

Bulletino - 結合網頁佈告、討論區功能的輕量CMS
Chatlino - 線上即時聊天
Dictlino - 線上字典編纂與分享

has_ :favorite, :recipes

2007-05-19T05:01:00.000+08:00

Lately gugod and I have stumbled on a situation where the famous has_many :through wasn't of much help. So we have come up with our own has_ thingy. That's right, it's called has_.

The Problem

The classic example of has_many :through is that in AWDwR 2nd ed: an object of class X has many objects of class Y through another join table. So an Article has many Readers through the table Reading, a Group has many Users through the table Membership, and so on.

has_many :through is a wonderful invention. It beats the needs for another famous habtm idiom, and delivers what it promises... so long as you follow its naming convention.

But life is often not perfect. The biggest constraint for has_many :through is that both the :class and :foreign_key options available to has_many are not there. Now that's a bad thing.

To explain why that is so, just look at what we need:

class User < ActiveRecord::Base
  has_many :recipes
  has_many :recipes, :through => :favorite_recipes   # d'oh!
  ...
end

So here a User has many recipes (probably of his or her own creation) and many favorite recipes (probably created by others). Because of the constraint mentioned about, this is a no-goer:

has_many :fav_recipes, :class => "Recipe", :through => :favorite_recipes, :foreign_key => :recipe_id

We had tried to fall back on the less elegant way

has_many :favorite_recipes

Then we collected the real recipe id's with this:

@fav_recipes = me.favorite_recipes.collect { |r| r.recipe }

Very soon, we were collecting these kind of proxy objects all over our models and controllers.

What about has_and_belongs_to_many?

In theory we could have used has_and_belongs_to_many :foo, :join_table => :blah as a workaround. But semantically, that's not really what we want. It is true that when a join table like FavoriteRecipe comes to exist, it's logically correct to say User has_and_belongs_to_many Recipes. But hey, since when did we want to have a Recipe that has many users?

Another problem that we have run into is that, well, it turns out that we love single-table inheritance (STI). And FavoriteRecipe, FavoriteCook, FavoriteShow, FavoriteSupermarket and FavoriteSpice all belong to the same Favorite base class that has three fields: the sine-qua-non :type, and the :user_id and ... :item_id. We then specify the concrete class using :belongs_to in each subclass. For example, we define FavoriteRecipe as:

class FavoriteRecipe < Favorite
  belongs_to :recipe, :class_name => "Recipe", :foreign_key => "item_id"
end

And has_and_belongs_to_many could result in such behemoth in User:

  has_and_belongs_to_many :fav_recipes, :join_table => :favorite, :class => "Recipe", :associated_foreign_key => :item_id, :conditions => { :type => "FavoriteRecipe" }

That is not elegant at all.

The Workaround

The more natural solution would be, of course, to come up with a method like this:

class User < ActiveRecord::Base
  has_many :_favorite_recipes, :class => "FavoriteRecipes"
  def favorite_recipes
    _favorite_recipes.collect { |r| r.recipe }
  end
  ...

But then writing the same thing again and again for your favorite show, favorite cook and favorite spice is a pain. Not very DRY, hmm.

So gugod asked: is there a better way to do this? Could we possible come up with some has_blah that does the magic for us? Such as writing the "def favorite_recipes" for us ?

This is where Ruby's dynamism shines. And it turns out that Rails itself loves such kind of tricks too. So after some deliberation and work, here is what we called has_, and with it you can have as many favorite items as you want it.

The Code: has_

module HasUnderline
  def has_(prefix, item)
    prefix = prefix.to_s
    item = item.to_s

    sy = "#{prefix}_#{item}"
    mo = sy.camelcase.singularize

    self.class_eval <<EOE
    has_many :_#{sy}, :class_name => "#{mo}"
    def #{sy}
      _#{sy}.map { |f| f.#{item.singularize} }
    end
EOE
  end  
end

To use the module in your ActiveRecord model class, simply aggregate it into your class object with:

class User < ActiveRecord::Base
  extend HasUnderline
  has_ :favorite, :recipes
  has_ :favorite, :cooks
  has_ :favorite, :spices
  has_ :favorite, :shows
  ...

That's what we call elegant.

Voilà. So now we are happy since a User has_ many favorite recipes, favorite cooks, favorite spices, favorite shows, and so on and so forth.

Voot, that's eval! (à Frau Farbissina)

class_eval is one of Ruby's many evil vices (and hence the name) and is recommended by books like Ruby for Rails. One advantage of class_eval over method_missing is that the class in question will have a true method, whereas the dynamic dispatched behavior in method_missing cannot be known in advance.

We have just put that nifty snippt into our Asynapse library, and we're expecting more such idioms will go into this project.

Enjoy and stay tuned!

Javascript localization

2007-05-12T23:19:00.000+08:00

eIt may sound pretty ridiculous that we're doing l10n in Javascript, but it's unavoidably required. Since Javascript plays more important role in View code in virtually all web frameworks. Rails has RJS, which basically require Javascript to perform in-place page-updating job. Jifty also use Javascript to update page fragments. Jemplate is a full javascript template library. Extjs is a full-js UI builder. In these libraries, more or less, we need to put string literals in or Javascript code.

So we've done our way localization strings in Javascript: Asynapse.Localization. It's now put in our Asynapse project Subversion repository. After it's initialized, you call this function: _, yes, a function named just an underscore character, which is basically the standard name of the function that accomplished this purpose in lightweight languages. Therefore, we think it's totally OK to named it just underscore. Besides, it doesn't conflict with prototype.js, so that won't make people sad.

It's almost as simple as this:

  # Initialize
Asynapse.Localization.init({
"lang": "zh_TW",
"dict_path": "/javascripts/loc"
})

# use it
alert( _("Nihao") )

We use JSON as our dictionary format. It looks like this:

{
 "Nihao": "你好",
 "Good bye": "再見"
}

But wait, that doesn't feel any easier. Writing JSON by hand is actually worse then editing anything else, isn't it ? Besides, it doesn't quite fit our Asynapse concept.

As we ~~all~~Asian people know, translation strings in code is something we never want to repeatedly do. So we figured out a way to make it less repeating: We choose to cover .po files to JSON.

If you're already developing some projects that has l10n support, you probably use gettext to the real l10n task. Then you definitely know what .po files are. They are the dictionaries in the format defined in gettext standard. po2json.pl is the script that convert from po dictionaries into JSON files which can be loaded by Asynapse.Localization library. That means, you're simply reusing dictionaries that you already had. If you have new strings from Javascript code, just add them manually into your po file, and they'll also be reused in server side code too.

That now feel more Asynapse, we wins at both client and server side coding.

So far this library is lying in the Subversion repository, stay tuned, we'll soon release it to several major code archiving sites once it's OK enough to be released. For developers who can't wait, just checkout our code from google svn code. Definitely poke us, give us some feed back if you like it (or hate it)

An Insanely Handy Table Generator in Ruby

2007-04-23T21:58:00.000+08:00

Recently we have been developing an application that displays a slew of information. Most of the items displayed are in the form of table. So there we are, first writing each table component by hand, then we get tired of it. It's just simply... not DRY. So like every other sane developer, we started writing our own table tag helpers, to save our life (and our poor fingers) to generate those pesky <table> tags.

With the help of some good Ruby, the table generator can be an all-season, yet still very terse, helper.

The Code

  def generate_table(array_object, titles=[], columns=[], callbacks={})
    html = ""
    html += '<table class="auto">'
    html += "<tr>"
    titles.each { |t| html += "<th>#{h(t)}</th>"}
    html += "</tr>"
    
    row_number = 0
    
    array_object.each do |row|
      html += "<tr>"
      columns.each do |col|
        if col == :_row_number
          data = row_number
        else
          if row.class == Hash
            data = (col.class == Array ? col.collect {|c| row[c]} : row[col])
          else
            data = (col.class == Array ? col.collect {|c| row.send(c)} : row.send(col))
          end
        end
        
        if callbacks[col]
          if data.class == Date || data.class == Time || data.class == DateTime
            str = callbacks[col].call(data)
          else
            str = callbacks[col].call(*data)
          end
        else
          str = h(data)
        end
        
        html += "<td>#{str}</td>"
      end
      html += "</tr>"
      
      row_number += 1
    end
    
    html += "</table>"
  end

Here is the code of the generator. We made it into a Rails helper class (ApplicationHelper), but this snippet is not just good for Rails.

Usage

This generator expects the table data source to be in either an array of hases, of an array of ActiveRecord-like objects, ie. objects that have attribute accessors, such as student.name. So say we want to generate a table of students, we do:

  generate_table Students.find(:all), 
    ["Name", "Address", "Mobile", "Homepage"],
    [:name, :address, :mobile, :homepage],
    {
      :homepage => lambda { |hp| link_to "visit the homepage", hp }
    }

This helper has three required arguments and one optional. The first three are an array of objects, an array of titles, an array of attributes to be fetched. The optional argument is an hash of callbacks.

In our case, the generator iterates the array of Student objects, and retrieves each's name, address, mobile phone number and homepage. The column homepage will be post-processed by a callback (lambda), which in turn yields the URL with a title "visit the homepage".

Array of hashes fits in the picture well. The secret is, the generator knows if the row object is a hash. If it is, it uses Hash key-value accessor Hash#[] to retrieve the column, instead of sending messages to the row object.

Fancier Usage Is Just a Hack Away

In some cases, we want to reuse the same attribute in different columns, say we want to use student id to fetch another data. The problem being, since the callback is a hash, an attribute can have exactly only one callback. Or does it have to be? Once again, some Ruby comes to help:

  generate_table Student.find(:all), 
    ["Student ID", "Extra Info"],
    [:id, [:id, :name]], 
    {
      [:id, :name] => lambda{ |i, n| retrieve_extra(i) }
    }

The point is that arrays can actually be fine hash keys, and when the callback of such column is given exact the same number of arguments. In this case, whether you want to use the attribute name is irrelevant. We just use this "virtual" attribute to let us get by.

... And One More Thing

An attribute, :_row_number, yields the current row number, starting from zero. This doubles as a counter, and can be useful in items such as a ranked list.

Possible Extensions

There are dozens of ways to extend the generator. Styling options, even/odd row handler, more hidden attributes (:_row_object anyone?) and column-span support all come to mind. For the time being at least, the snippet works perfectly for me, and I love it to stay the way it is.

Ruby Tuesday Taiwan

So that's so much for today! If you happen to be living in northern Taiwan and are interested in Ruby and/or Rails, we are having a regular meet-up at OP Café in Hsinchu City. The next meet-up will be on Tuesday, May 1, 2007, starting from 7:30 pm. I'll be talking about the sorry state of affair of the login thingy--how we end up rewriting our own login system each time for each app, and some possible remedies. See you there!

Asynapse 初版釋出

2007-04-13T20:56:00.000+08:00

在經過了兩天的黑客鬆之後，將釋出 Asynapse 的方式定了下來，於是率先釋出 Perl 版的 Asynapse。有興趣的讀者可前往 Asynapse 專案下載頁，或是利用 CPAN 下載、安裝。

更新：JavaScript 版本也已經釋出，可前往 JSAN 下載。

此釋出版為開發者版本，相關的文件請參詳 Asynapse::Record Perl 模組的文件。

Localizing Early Is Good Even for Monolingual Sites

2007-04-10T17:43:00.000+08:00

Localizing your application is a good thing even if it's monolingual. By using a localization ("l10n") package, you separate the work of "putting some text up there" from "serious copywriting"--which usually is best left to good writers or done when you are not in the coding mode.

Modern localization packages force developers to wear some straitjacket. Yes, the infamous "_" symbol that litters here and there isn't pretty. Singulars and plurals are grammar headaches. Why the heck the world can't just think like we programmers, to whom everything starts with 0 and "copied 5 file(s)" is both formal and polite?

The problem is, as much as we emphasize refactoring, we don't pay equal attention to the quality of writing. Then when someone who really cares shows up and asks you to revise it, believe me, fiddling 50 HTML files scattered in 10 directories is absolutely no fun. If you had used packages such as gettext, the only thing you would need to do is open up the wounded .po file and clean it up, or leave it to others (its format is simple enough for average muggles to understand--far better than those things you do in .jsp/.asp/.php/.rhtml/whatever).

l10n the Pure Ruby Way

gettext is your friend if you're developing a real thing. It's ubiquitous, available to practically every programming language on earth, and most important of all, it is established--which means you don't have to reinvent l10n tools (the obvious thing) and l10n workflows (the less obvious thing), since there are thousands of people who have done that before you do.

Sometimes, however, I find gettext an overkill for some one-shot projects that simply need some localization help but not all the perks that gettext offers. This is when this localization plug-in comes in handy. It's relatively unknown, but I love it. It's really just a string look-up thingy, and does no form validation messages (one sine qua non for more serious Rails app). On the other hand, installation is only a "script/plugin install" away, and its documentation is easy and short (making gettext for Ruby/Rails work is an ordeal partly because of scant documentation and no-brainer how-to's).

Two things to bear in mind, though. First, this plug-in doesn't scale up well--it does not have a string collector as powerful as gettext's. Second, it allows the use of Ruby lambda for more delicate string handling, which is addictive. The first thing lets you know when you need to use gettext, and the second reminds you that you need to think about the migration path if your project eventually grows. Refraining from the lambda magic will make things a little bit easier.

YAPC::Asia 2007 紀行

2007-04-08T18:39:00.000+08:00

YAPC Asia 207 圓滿落幕，感謝 Shibuya.pm 出人出力辨了這麼好的研討會。我所演講的主題：Asynapse，雖然仍是個有點模糊、難以界定的概念，不過，在提供了適當的 Demo 的情況之下，也得到了 Catalyst 的 Jonathan Rockway、Jifty 的 Jesse Vincent、Amazon EC 的 Emerson Mills 等人於口頭上的肯定。

Asynapse 目前還仍在實驗當中，不過其各項目的算是已經成功地證實其可行。像是與以 REST 實做與 ActiveRecord 相仿的資料介面「AsynapseRecord」，以 JSON 做為載體來進行 REST API 呼叫的「AsynapseTextDiff」，以及以 [Interface Builder] 做為刻畫 WebUI 工具的「AsynapseInterface」。這些實驗都在近日成功完成，順利的話，亦將進行包裝，釋出給開發人員所使用的版本。

讀者如果有興趣，除了 Handlino Blog 之外，亦可持續追蹤 Asynapse 專案頁面，將不定期出現各更新的訊息。

服務項目

2007-03-13T11:48:00.000+08:00

和多提供以下服務：

網頁標準設計
Frontend engineering
網頁應用程式開發，使用 Ruby on Rails 或 Perl
桌面應用程式開發
訓練與顧問服務

關於和多

2007-03-13T10:36:00.000+08:00

和多是由三位朋友組成的工作室，我們的強項包括網頁標準設計（standards-compliant web design）以及軟體開發。我們三人長期參與開放源碼社群，將我們的力量回饋給軟體開發和標準設計領域。

好軟體不容易。好設計不簡單。我們希望憑藉專業，幫您鋪平沿路的障礙，為大家帶來好用又快樂的產品。

聯絡信箱：naimu at handlino dot com

Our Services

2007-03-12T21:35:00.000+08:00

We offer these services to our clients:

Standards-complient web design
Frontend engineering (everything about UI)
Web application development using Ruby on Rails or Perl
Desktop application development
Training and consultancy services

About Us

2007-03-12T21:22:00.000+08:00

What can we do for you? If you are looking for good web application design, Handlino is here to help.

We have come together to found Handlino in December 2006. We are experienced in application development (web and desktop) and standards-compliant web design, and we are engaged in open source communities. Our portfolio covers a wide range of application design and development along with numerous open source contributions. Our tools of trade include CSS, JavaScript, Ruby on Rails, Perl, and C++/Objective-C.

Good design is hard. Good code is hard. Let us lower the bar for you and your users, and make good services enjoyable and enjoyable services superb.

Contact Email: naimu at handlino dot com