A few users reported that Chrome choked on the bookmarklet. I found that the bookmarklet builder does not produce the output that Chrome expects. I was using Chrome 15.0.874.54 beta.

For example, take this simple script.

(function () {
  // what is 1+1?
  alert(["1+1=",(1+1)].join(''));
})()

Gruber’s script produces this bookmarklet: Example 1

javascript:(function%20()%20{alert([%221+1=%22,(1+1)].join(%27%27));})()

If you drag this example to your bookmark bar in Chrome, it will produce this error when invoked.

Uncaught SyntaxError: Unexpected token %

What happened? If you edit the bookmark, you will see that Chrome double-escaped the string,

javascript:(function%2520()%2520%7Balert(%5B%25221+1=%2522,(1+1)%5D.join(%2527%2527));%7D)()

I believe this happened because the string contained some non-escaped characters such as parentheses.

Gruber points out in a footnote that his script intentionally leaves some characters unescaped for the purpose of readability.

It’s unclear to me what characters must be escaped in a bookmarklet URL. Some sources suggest that other punctuation characters, such as brackets and semicolons, ought to be escaped, too, but I can see no practical reason to do so. If you want to be really conservative and escape just about everything, change this line:

uri_escape_utf8($bookmarklet, qq('" \x00-\x1f\x7f-\xff));

to:

uri_escape_utf8($bookmarklet);

Personally, I prefer to keep the bookmarklet URL itself as readable as possible.

With this change, we get this bookmarklet: Example 2

javascript:%28function%20%28%29%20%7Balert%28%5B%221%2B1%3D%22%2C%281%2B1%29%5D.join%28%27%27%29%29%3B%7D%29%28%29

It may not be as readable as “Example 1″, but it works.

Find my modifications to Gruber’s JavaScript Bookmarklet Builder on GitHub

There are, of course, readily available implementations of OAuth in python, even some specifically engineered for App Engine with lovely persistence and caching and KILL ME NOW.

I gave up after a couple hours of staring at this nonsense. I grew so displeased because my app doesn’t need 95% of what these libraries offer. I only need to sign requests with a fixed oauth_consumer_key, oauth_consumer_secret, oauth_token, and oauth_token_secret. However, this simple task would require me to subclass or instantiate several object with Culver’s library, and I can’t even begin to fathom what I’d need to do with Knapp’s offering.

(Aside: if you want to authorize and build access tokens for your app, I highly recommend this excellent OAuth test client)

I finally teased apart the core function of signing requests, thanks in large part to the great reference example. If all you need is to access a protected resource, this will get the job done with a single function call, no object-orientation required.

Source code and unit test of short and sweet OAuth.

I present the IPA (International Phonetic Alphabet) TTS (text-to-speech) bookmarklet. (Source)

Bookmarklet: IPA TTS (drag to your bookmark bar)

How to use: select any text that contains IPA and click on the bookmarklet. Wait a second for the iframe at the bottom of the page to load.

Try these examples: /ˌɪntəˈnæʃnəl/, /ˌɪntɚˈnæʃnəl/

How does this work?

The bookmark creates a POST request to the AT&T Natural Voices® Text-to-Speech Demo with the IPA text in SSML. The AT&T demo has modest support for IPA, but often fails. If you know of another IPA TTS engine, please let me know or fork the bookmarklet and add it.

[1] Wikipedia Signpost: Role of hidden categories under discussion

This model rules Yelp. A review on yelp is a measurement of the distance between the reviewer and the reviewed. The review will be favorable if and only if the reviewer is nearby the reviewed in the model.

A restaurant (e.g., Bite) gets good reviews because the people that review it know or can guess, before they go there, that they will like it. If they didn’t, the place wouldn’t have such stellar reviews.

So why do some places get terrible reviews? I see cases that would cause this. First, if a new nightclub (e.g., Universal) is still “figuring itself out,” it might attract a lot of people expecting one thing and getting another. In other words, they are not near the place in the model, but they visit it anyway because they think they might. Likely, because the place is so new, many people are testing it out, so you can expect the reviews to be unfavorable, even by the people who are supposed to like it, because the presence of outsiders ruins the whole experience.

In another case, a super-exclusive bar might only cater to a very narrow range of clientele. In other words, you have to be unusually close to this bar in the model in order to like it. Perhaps it only supports one or two cliques of regulars, and everyone else is shunned.

In this example, the radii correspond to the ability of a bar or restaurant to support a wide or narrow section of people.

John Resig’s jQuery uses a standard technique of anonymous function closures to namespace its internal functionality.

(function(){
  // jQuery stuff goes here...
})();

This is all well and good until you want to inline this code under some of your application code, as I did while working on Eventful’s MySpace application. Consider this example, written in standard Javascript style.

var foo = function(bar) {
  console.log("foo");
  return bar;
}

(function(){
  console.log("bar")
})();

What do you expect this code to print? If you say “bar”, you’re wrong. It prints “foo bar” because in this context the anonymous function closure becomes a call to the function that prints “foo” and returns the function that prints “bar”, which is then called.

Most of us probably wouldn’t notice what just happened because we are so used to Javascript interpreters automatically inserting semicolons after function definitions.

The danger is assuming, as John Resig and hundreds others have, that your anonymous function closure is the first token in a new line. In my case, it wasn’t. The solution? Either start meticulously sprinkling semicolons in your application code, or just add a single semicolon before your parenthetical block, guaranteeing it’s the first token in the line.

;(function(){
  // jQuery stuff goes here...
})();

Here are a few examples. A couple’s answers their friends’ questions. A researcher’s or expert’s revblog answers questions from others in her field. A CEO’s revblog answers his company’s employees. Changing the parameters around may allow anybody to ask and answer (a forum) or only the author to ask (a traditional blog), but keeping in the spirit of “questions” and “answers.”

For instance, imagine this were a reversed blog where I come up with silly ideas and you tell me if they suck or not. Would that be a good idea?

Update: As pointed out in the comments, this idea has now been implemented by Stack Overflow and its brethren: Super User, Server Fault, and Math Overflow.

At first I thought an extension was the way to go, but its turns out extensions are aimed at tweaking Firefox’s interface, not fussing with the page. Greasemonkey is perfect for the job, since it basically just executes a script on every page that matches a given pattern. Plus, users don’t have to go through the hassle of downloading crap and restarting the application.

This screenshot shows link underlining, headers, and boldface (i.e., embiggening). I haven’t figured out how to handle styling as the page is edited, though, but once that’s out of the way the rest should just be a matter of regex hacking.

Here is a quick WikiSyntax demonstration.