With these ideas fresh in my mind, I decided to reproduce Mark C. Chu-Carroll’s Go prime sieve in JavaScript with goroutines and channels as my toolset instead of conventional JavaScript idioms. Find my translation on GitHub.

I chose JavaScript because it shares many traits with Go, such as multiple threads of control, but doesn’t have a notion of channels.

Background: goroutines and channels

A goroutine is an independent concurrent thread of control.

A channel is a mechanism for two concurrently executing functions to communicate by passing a value. A channel has two methods, read and write, which are synchronous by default. That is, a write blocks until there is a read to consume it, and a read blocks until there is a write to consume.

JavaScript implementation

Goroutines are rather trivial to implement, a simple setTimeout will schedule an independent thread of control.

function go (fn) {
  setTimeout(fn, 0);
};

Synchronous channels will require a queue of reader and writer callbacks. I decided to call the reader callbacks before the writers, but I don’t think it matters.

var chan = function () {
  this.readers = []; // [cb, ...]
  this.writers = []; // [[value, cb], ...]
};

chan.prototype.read = function (cb) {
  if (this.writers.length) {
    // consume a writer
    var writer = this.writers.shift();
    cb(writer[0]);
    writer[1](writer[0]);
  } else {
    // queue the reader
    this.readers.push(cb);
  }
};

chan.prototype.write = function (value, cb) {
  if (this.readers.length) {
    // consumer a reader
    var reader = this.readers.shift();
    reader(value);
    cb(value);
  } else {
    // queue the writer
    this.writers.push([value, cb]);
  }
};

I also pass the writer’s value to its callback because it could be useful.

The prime sieve

Mark’s Go sieve begins with an integer generator.

func generate_integers() chan int {
    ch := make(chan int);
    go func(){
        for i := 2; ; i++ {
            ch <- i;
        }
     }();
    return ch;
}

The problem here is that the channel write (ch <- i) blocks inside of a loop. In JavaScript, we "block" by passing a callback that is called once the procedure can continue. Here, the producer function passes itself as the callback to write.

function integers () {
  var ch = new chan();
  go(function () {
    var producer = function (i) {
      ch.write(i + 1, producer);
    };
    ch.write(2, producer);
  });
  return ch;
};

This Go function excludes multiples of a given prime from the given channel.

func filter_multiples(in chan int, prime int) chan int {
   out := make(chan int);
   go func() {
      for {
         if i := <- in; i % prime != 0 {
             out <- i;
         }
      }
    }();
   return out;
}

We can rewrite this with another recursive callback, but this time we only have to block when we do a write.

function filter_multiples (ch, prime) {
  var out = new chan();
  go(function () {
      var consumer = function (i) {
        if (i % prime != 0) {
          out.write(i, function () {
            ch.read(consumer);
          });
        } else {
          ch.read(consumer);
        }
      }
      ch.read(consumer);
  });
  return out;
};

The sieve in Go will chain a series of channels to exclude multiples of all the primes we have seen.

func sieve() chan int {
   out := make(chan int);
   go func() {
      ch := generate_integers();
      for {
	     prime := <- ch;
	     out <- prime;
	     ch = filter_multiples(ch, prime);
      }
   }();
   return out;
}

We achieve the same in JavaScript with another recursive callback.

function sieve () {
   var out = new chan();
   go(function () {
      var ch = integers();
      function iteration () {
        ch.read(function (prime) {
          out.write(prime, function () {
            ch = filter_multiples(ch, prime);
            iteration();
          });
        });
      };
      iteration();
   });
   return out;
};

Mark's program simply reads from the sieve channel and prints out each prime number.

func main() {
  primes := sieve();
  for {
    fmt.Println(<-primes);
  }
}

Mine uses another recursive callback to do the same.

function main () {
  var primes = sieve();
  function iteration() {
    primes.read(function (i) {
      sys.puts(i);
      iteration();
    });
  };
  iteration();
}

main();

Demo

Go-flavored JavaScript: Prime Sieve

Discussion

Note that the call to main() returns (practically) immediately, since the goroutine in sieve(), which hasn't executed, has not yet written anything to the channel, so the read inside iteration just pushes the callback onto a read queue and returns. Once the main thread of control stops, the event loop begins running the goroutines, which drive the rest of the program. (Please correct me if I'm wrong.)

That functions return quickly is generally desirable, in JavaScript or Go, because a caller should not have to wait for a function to do some "hard work" before it returns. Instead, the hard work should occur in a separate thread of control and passed back to the caller by some layer of indirection.

JavaScript programmers typically solve this problem with callbacks which receive result of the hard work. The Go language offers synchronous channels between independent threads of control as a more sophisticated solution. These tools are easily ported to idiomatic JavaScript based on callbacks. Although unconventional, these tools are simple and may be very powerful when composed.

I hope this toy example borrowed from Go inspires JavaScript programmers to consider the unconventional.

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

Here are some quick examples to get you started.

Ringo

    #!/usr/bin/env ringo
    print("ringo");

Narwhal

    #!/usr/bin/env narwhal
    print("narwhal");

Node

    #!/usr/bin/env node
    require("sys").print("node\n");

JavaScriptCore

    #!/usr/bin/env jsc
    print("jsc");

JavaScriptCore nightly added support for shebangs on 6 December 2010.

Since Node and JavaScriptCore are binaries, you can use the full path instead of env.

Anonymous closure module pattern

My example module will be implemented as an anonymous closure. It will have one public class and a private member.

    (function () {
      var PublicClass = function () {};
      var PrivateMember = new Object();
    })();

I will incrementally add support for each environment by detecting whether that environment is present.

Web browsers

Web browsers do not support importing into a local namespace, so I simply add PublicClass to the global window namespace.

    (function () {
      var PublicClass = function () {};
      var PrivateMember = new Object();

      if (typeof(window) !== 'undefined') {
        // browser
        window.PublicClass = PublicClass;
      }
    })();

Client must first include the module with a script HTML tag.

    <script type="text/javascript" src="sample-module.js"></script>
    <script type="text/javascript">
      var instance = new PublicClass();
    </script>

CommonJS

CommonJS is a pattern implemented by some server-side JavaScript engines such as Node and Narwhal. In this model, a module assigns its public interface to a special exports object.

    (function () {
      var PublicClass = function () {};
      var PrivateMember = new Object();

      if (typeof(window) !== 'undefined') {
        // browser
        window.PublicClass = PublicClass;
      } else if (typeof(exports) !== 'undefined') {
        // commonjs
        exports.PublicClass = PublicClass;
      }
    })();

Clients require the module, which returns the module’s exports.

    var PublicClass = require('./sample-module').PublicClass;
    var instance = new PublicClass();

JavaScriptCore

JavaScriptCore (or “jsc”) does not follow the CommonJS pattern. Instead, when a file is included with the load function, the last value in the file is returned to the caller.

I return an object literal from the anonymous function which simulates the exports object in CommonJS. Since the anonymous function is executed as the last statement in the file, the exports are returned to the client. This case doesn’t rely on any special variable such as window or exports, so I will make it default rather than detecting the JavaScriptCore environment.

    (function () {
      var PublicClass = function () {};
      var PrivateMember = new Object();

      if (typeof(window) !== 'undefined') {
        // browser
        window.PublicClass = PublicClass;
      } else if (typeof(exports) !== 'undefined') {
        // commonjs
        exports.PublicClass = PublicClass;
      } else {
        // jsc (default)
        return {
          "PublicClass": PublicClass
        };
      }
    })();

Clients load the module, which returns the module’s exports.

    var PublicClass = load('sample-module.js').PublicClass;
    var instance = new PublicClass();

Why not use a global variable?

There is another JavaScript module pattern that declares a global variable to contain the module’s public interface, as in this example.

    var PublicClass = (function () {
      var PublicClass = function () {};
      var PrivateMember = new Object();
      return PublicClass;
    })();

This pattern will work perfectly in web browsers and JavaScriptCore, but it also pollutes JavaScriptCore’s global namespace. Since JavaScriptCore supports local imports, global variables should be avoided. Furthermore, this pattern does not support multiple public interfaces, e.g., a single anonymous closure that exports two public classes.

Example: GraphJS

GraphJS is a JavaScript module of mine that uses the module deployment pattern I described. It works with Node, Narwhal, Ringo, JSC, and in web browsers.

Wrapper screen

I log in to the machine that will host my screens and start the wrapper screen.

  screen -S wrapper -c .screenrc_wrapper

The wrapper screen’s configuration just specifies the interrupt key.

  escape ^Ww

I create a screen window in wrapper for each terminal window I want to use, as many as four. Each terminal window will run one of the wrapper windows.

SSH agent

I use SSH agent forwarding to log in to my screen host, but if you don’t then you might need to run ssh-agent inside the wrapper screen before starting the ssh screen.

  exec ssh-agent bash
  ssh-add

This is necessary for the next step where I ssh into a bunch of other machines. I have already installed my public key on the destination machines.

SSH screen

I start the ssh screen from inside the wrapper screen.

  screen -S ssh -c .screenrc_ssh

The ssh screen’s configuration creates a bunch of windows that ssh into other machines I want to work on. I like to have at least two windows for each machine.

  escape `` 

  screen -t "host 1" ssh host1
  screen -t "host 1" ssh host1

  screen -t "host 2" ssh host2
  screen -t "host 2" ssh host2

  screen -t "host 3" ssh host3
  screen -t "host 3" ssh host3

  select 0

Inside the other wrapper windows, I attach to the running ssh screen.

  screen -x ssh

At the start of the day, I open up a few terminal windows, log in into the screen server, and attach to the running wrapper screen. This is simplified with an alias.

  alias wrapper='screen -x wrapper'

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.

This is fine unless you really want to friggin’ strip out the tags, like I needed for Emend. The following is my solution.

Source code for stripping tags with html5lib and unit test.

For example,

>>> from strip_tags import strip_tags
>>> strip_tags('<p>foo</p> <script>bar</script>')
u'foo bar'

Thanks go to Edward O’Connor for pointing me towards html5lib in the first place. It’s a huge improvement over HTMLParser.

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.

“You cannot build character and courage by taking away man’s initiative and independence.”

–Abraham Lincoln

The foremost subject on which today’s babies lack direction is the ability to direct themselves. Too long have we coddled, pampered, and babied our nations babies. After all, if you give a baby a bottle, the baby will drink for a day, but if you teach the baby how to open up a miniature refrigerator, that very same baby will also drink for a day but also allow you to watch re-runs of Seinfeld in peace.

I present to you, the baby crib refrigerator! (US Patent Application No. 11/248,929)

From the Abstract

Before the parent goes to sleep for the night, they can prepare a snack, and store it overnight in the snack box. When the infant wakes up in the morning, they can retrieve the snack by themselves, after a few days’ training, without crying. This will permit the parent to sleep longer, because they will not have to wake up prematurely for delivering the morning snack, and then wait until it is consumed.

Status of this patent

Still pending, it has been rejected multiple times and is now awaiting appeal. The patent examiner cited the following two patents as prior art: US Patent Application No. 10/044,362—Juvenile Stroller with Cooler and US Patent No. 4,545,211—Cold Box for Motor Vehicles

Verdict

Spare the fridge, spoil the child?