My work has me using a Mac on one of the projects. At first, despite the well designed interface, I was infuriated by how the keyboard shortcuts were different from the common Windows/Linux standards.

However, after dicking around with ~/Library/KeyBindings/DefaultKeyBinding.Dict with some success and much frustration, I found a program that solves all my problems:

http://pqrs.org/macosx/keyremap4macbook/

Here is how to use it to replicate PC style keyboard (mostly... I'm sure I'll run into other frustrations):

1. System Preferences -> Keyboard -> Modifier Keys -> Remap CapsLock to Command
2. Install KeyRemap4MacBook.
3. Here are the settings I'm using right now:
   • Command+Arrow to Option_L+Arrow
   • Command+Delete to Option_L+Delete
   • Use PC Style Home/End
   • Use PC Style PageUp/PageDown
   • Use PC Style Control+Up/Down/Left/Right
   • Use PC Style Delete-Last-Word

I'm still kind of torn between making my CapsLock -> Command or CapsLock -> Control.

Making CapsLock->Control preserves shortcuts in terminal and X11 apps, but breaks them in native apps, though Keyremap4Macbook does allow you to remap many common native shortcuts from Command to Control...

Anyways, this makes Mac usable and pretty palatable again.

Use com.google.common.cache.CacheBuilder from guava-libraries with strong-reference keys and soft-reference values.

WeakHashMap is inappropriate, as weak-references are collected too quickly to be an effective cache. [1] Soft references seem designed for caching. [2]

CacheBuilder also allows you to specify a method to compute and store cache misses transparently:

    Cache graphs = CacheBuilder.newBuilder()
       .concurrencyLevel(4)
       .weakKeys()
       .maximumSize(10000)
       .expireAfterWrite(10, TimeUnit.MINUTES)
       .build(
           new CacheLoader() {
             public Graph load(Key key) throws AnyException {
               return createExpensiveGraph(key);
             }
           });

[1] http://www.codeinstructions.com/2008/09/weakhashmap-is-not-cache-understanding.html

[2] http://download.oracle.com/javase/6/docs/api/java/lang/ref/SoftReference.html

I'd read before that programming is like writing, but pg. 56 from The Writing Life has really persuaded me:

First you shape the vision of what the projected work of art will be. [...]

Many aspects of the work are still uncertain, of course; you know that. You know that if you proceed you will change things and learn things, that the form will grow under your hands and develop new and richer lights. But that change will not alter the vision or its deep structures; it will only enrich it. You know that, and you are right.

But you are wrong if you think that in the actual writing, or in the actual painting, you are filling in the vision. You cannot fill in the vision. You cannot even bring the vision to light. You are wrong if you can take the vision and tame it to the page. The page is jealous and tyrannical; the page is made of time and matter; the page always wins. The vision is not so much destoryed, exactly, as it is, by the time you have finished, forgotten. It has been replaced by this changeling, this bastard, this opaque lightless chunky ruinous work.

I love Annie Dillard.

Often we will want to iterate through multiple lists simultaneously. Say we are programming a game, and have a list of technologies and a list of research allocations.

Python:

techs = ["Propulsion", "Weapons", "Armor"]
allocations = [0.1, 0.5, 0.4]

Here is the old, and worse, way of iterating through both lists:

for i in range(techs.length):
  print techs[i] + " " + allocations[i]

Seems reasonable for this trivial case, but managing indices is often annoying and or dangerous. Moreover, indices are blatantly wrong for data structures without constant time random access.

Here’s a more awesome way to do it:

for tech, allocation in zip(techs, allocations):
  print tech + " " + allocation

Okay, so what does zip do? Best way is to illustrate by example on the interactive interpreter:

>>> x = [1,2,3]
>>> y = [4,5,6]
>>> zip(x,y)
[(1, 4), (2, 5), (3, 6)]

It makes a new list composed of the elements of the old list put into tuples together. So iterating through both lists simultaneously is completely natural. This works for an abitrary number of lists in Python, and is also very handy for list comprehensions.

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> z = [7, 8, 9]
>>> t = [10, 11, 12]
>>> zip(x,y,z,t)
[(1, 4, 7, 10), (2, 5, 8, 11), (3, 6, 9, 12)]
>>> [a+b+c+d for a,b,c,d in zip(x,y,z,t)]
[22, 26, 30]

The reason it works so naturally in the for loop is because of the tuple unpacking, which looks like this if the above is still confusing:

>>> a,b = (1,2)
>>> print a
1
>>> print b
2
>>> for a,b in [(1,2), (3,4)]:
...   print a
...   print b
... 
1
2
3
4

I’ve long known about and resisted adopting OpenID for one reason: I feared that I would be at the mercy of whatever company I chose as my OpenID provider, be it Google, Yahoo, Verisign, whatever…

If that company went out of business, decided to “realign with core competencies”, start charging exorbitant fees for using the OpenID, I’d be screwed, as my digital identity for all these sites would be under their control.

The alternative is running your own OpenID provider, but that’s a good amount of work, and kind of defeats the purpose of OpenID (if everyone has to run their own provider).

I learned today that there’s a great solution to this problem, called ‘delegation’. How it works is that you put an html fragment in the HEAD section of a webpage you control, and suddenly that URL can act as your OpenID, with the actual authentication delegated to a party of your choice.

If say, I have an OpenID with Verisign (I do), I put this fragment in the HEAD section of URL I control:

<link rel="openid.server" href="http://pip.verisignlabs.com/server" />
<link rel="openid.delegate" href="http://tommycli.pip.verisignlabs.com" />
<link rel="openid2.provider" href="http://pip.verisignlabs.com/server" />
<link rel="openid2.local_id" href="http://tommycli.pip.verisignlabs.com" />
<meta http-equiv="X-XRDS-Location" content="http://pip.verisignlabs.com/user/tommycli/yadisxrds" />

So now when I go to login to an OpenID page, I can just put in: tommycli.keepword.com, or whatever webpage I choose to put that fragment above on – and my OpenID is: tommycli.keepword.com.

So if Verisign becomes ghey, I can always switch to a new OpenID provider – I just have to change a page on a domain I control. Essentially – I can keep my OpenID so long as I can keep my domain name: I am only dependent on the integrity of domain name property rights on the internet, and if that collapses, so does the internet at large, and I won’t even need an OpenID.