Speak to me. But the only thing you can’t do is to ignore me.

But life is buggy. Any piece of software may be buggy, but its inherent malleability ominates it from any accusation; we forgive as usual and it’s never harder to ask for forgivance than it is to ask for permission. Maybe that is because we can always press RESET, or do a procedure that rejuvenates the software back to its ideal, pristine state.

The ability to start itself over in a perceptible way ¹ makes software bugs tolerable, and it is the very same lack of this ability which makes real-life bugs intolerable. Reincarnation may wrap it up in a truly encapsulated, self-documentary, self-explanary, recursively complete way, but this concept will not go very far before we learn to love what we are, as-is.

As is

Every wake in a foreign body is a torture, no different from another. If life is a game, I’m needing some cheats. Or maybe a typecast, and call it a day.

Overloading SSH: swizzling between accounts while pushing to Heroku using Git

Since it goes this way:

$ git push heroku master

and git push authenticates over SSH, who you are is determined by the key that your SSH agent sends abroad. To have git work with your desired credential, first create separate remote endpoints for each Heroku account that you plan to use, then edit ./ssh/config so that they are recognized by the SSH agent.

Creating separate git remote endpoints

Go to your repository, and edit .git/config. Create many remote endpoints. I’ll use one reposiroty of ours that recently got updated for example.

[remote "origin"]
    fetch = +refs/heads/*:refs/remotes/origin/*
    url = git@github.com:iridia/redmine-heroku.git

…

[remote "heroku"]
    url = git@heroku.com:keeper.git
    fetch = +refs/heads/*:refs/remotes/heroku/*

[remote "heroku_base_iridia"]
    url = git@base.iridia.tw.heroku.com:keeper.git
    fetch = +refs/heads/*:refs/remotes/heroku/*

[remote "heroku_ev_iridia"]
    url = git@ev.iridia.tw.heroku.com:keeper.git
    fetch = +refs/heads/*:refs/remotes/heroku/*

Notice that the last 2 remotes have peculiar url configuration. In this case, we embed the respective Heroku account that we would like the push to be effective under into the host name. In that sense pushing to heroku_base_iridia would result in the credentials associated with base@iridia.tw to be used, and pushing to heroku_ev_iridia would show up as if ev@iridia.tw pushed it. The heroku endpoint which is associated with heroku.com was created by Heroku itself.

Creating separate host entries within .ssh/config

Now edit ~/.ssh/config and again we’ll have a working example.

Host ev.iridia.tw.heroku.com

    HostName heroku.com
    User git
    IdentityFile ~/.ssh/ev@iridia.tw.identity
    IdentitiesOnly yes

Host base.iridia.tw.heroku.com

    HostName heroku.com
    User git
    IdentityFile ~/.ssh/iridia_id_rsa
    IdentitiesOnly yes

Notice that for each pseudo-host, a real HostName is provided, and an IdentityFile is also provided. This tells the SSH agent that once we attempt to SSH to a listed Host, substitute that host with its real HostName, and authenticate using the IdentityFile associated with the host. Since Git usually pushes over SSH, combining this part with the former part allows an user to push to Heroku using any of her many Heroku accounts.

However, you’ll have to add the correct keys to their respective Heroku accounts, either from its administration interface, or from the command line after following the part that follows.

Overloading ~/.heroku/credentials: managing Heroku apps under many accounts

Since pushing is not where all the development happens, we’ll have to make Heroku’s gem ($ sudo gem install heroku) work with multiple accounts. (Un)fortunately, Heroku stores credentials in plain text under ~/.heroku/credentials, so swizzling it makes the gem work with multiple accounts. Check out hero.rb on GitHub.

For example, to add many keys to their respective Heroku accounts (assuming that you have got hero.rb and all the keys):

$ hero ev@iridia.tw
$ heroku keys:add ~/.ssh/ev_iridia_tw.identity.pub

$ hero base@iridia.tw
$ heroku keys:add ~/.ssh/base_iridia_tw.identity.pub

That’s it.

Announcing lib.tidyCJK.js which pseudo-kerns Chinese, Japanese and Korean passages by properly inserting a space between CJK glyphs and Latinate / numeric glyphs in them. Clone it or fork it on GitHub.

It’s an early alpha, so might be full of bugs. With imminent field application, its quality and accuracy will likely improve. tidyCJK uses Unicode¹, so it needs to run in an environment that supports JS 1.3+.

Why use lib.tidyCJK.js

For the exactly same reason why Cappuccino is strong: standard bodies move slowly, and despite that CSS3, a work in progress, already has much in store, we need similar capabilities now. And we often have to interact with existing material, which comes from all places in all sorts. Better post-process everything and make them look good than wait for everyone to conform.

Finding a character’s code easily

Add this little cute recursive JavaScript method if you’re targeting JavaScript 1.5+ ², so you say String.hex instead of String.hex() ³:

String.prototype.__defineGetter__("hex", function() {

    var response = [];

    for (i in this) {

        var charCodeString = this.charCodeAt(i).toString(16);

        response.push("\\u" + (function(stringToWrap, finalDigits, padding){

            if (stringToWrap.length >= finalDigits) return stringToWrap;
            return arguments.callee(padding + stringToWrap, finalDigits, padding)

        })(charCodeString, 4, "0"));

    }

    return response;

});

And call String.hex — for example:

>   "f(*^%)g".hex
["\u0066", "\u0028", "\u002a", "\u005e", "\u0025", "\u0029", "\u0067", "\u0066"]

Happy Kerning!

Barker is updated with a jQuery-based replacement method (we added a lazy-loading mechanism with a callback) so now it works with Chrome.

Don’t quit your day job

Word. But maybe untrue.

Design mixes idealism and realism. Despite that there are no leather buttons “in the real world” [sic], we use it sparingly. The key, undoubtedly, is “sparingly”. Kitsch? It is necessary if it works nice.

Quoted,

The passive (or as Apple calls it: “lean back”) tablet format suggests creating limited information architecture with linear use modes. In comparison to a website, an iPad app is like a closed egg.

[This] is one of the main challenges iPad app design poses to interaction designers. How do you make navigating on iPad as easy as breaking an egg? And in particular, how do you measure information on a device without static scrollbar?

In order to make the user feel in control of an iPad app you either need a strong and simple structured overall content model that is consistent with the mental model of most users (like the brilliant Marvel application)—or you need to re-invent the way information is measured and orientation is given.

We’ll see.

Why teamwork is not always a fine choice

Depends on whether the goal is to develop or maintain something.