Here’s a sample, buggy program:

(define myreverse
  (lambda (ls)
    (if (null? ls)
      '()
      (append (myreverse (cdr ls)) (cons (car ls) '())))))

(define mylist (cons 1 (cons 2  (cons 3 (cons 4 5)))))

(display (myreverse mylist))

Let’s try loading it in Chez Scheme.

$ scheme
Chez Scheme Version 8.0
Copyright (c) 1985-2010 Cadence Research Systems

> (load "example.ss")
Exception in car: 5 is not a pair
Type (debug) to enter the debugger.
>

Obviously, (debug) invokes the debugger. Once we get in there, however, it’s fairly cryptic.

debug> ?
Type i  to inspect the raise continuation (if available)
     s  to display the condition
     c  to inspect the condition
     e  or eof to exit the debugger, retaining error continuation
     q  to exit the debugger, discarding error continuation
debug>

Usually, inspecting the continuation is the most helpful thing to do, because once we’re in there, we can get a stack trace to find out where the error occurred. The command to print out the stack frames is sf.

debug> i
#<continuation in myreverse>                                      : sf
  0: #<continuation in myreverse>
  1: #<continuation in myreverse>
  2: #<continuation in myreverse>
  3: #<continuation in myreverse>
  4: #<continuation in myreverse>
  5: #<system continuation in map>
  6: #<system continuation in compile>
  7: #<system continuation>
  8: #<system continuation>
  9: #<system continuation in dynamic-wind>
  10: #<system continuation in dynamic-wind>
  11: #<system continuation in $reset-protect>
  12: #<system continuation in new-cafe>
#<continuation in myreverse>                                      : 

Knowing the stack trace, we can move down the stack frames using down, which is important if the debugger drops you in an error handler under the actual source of the problem. This information is often enough to debug your program. From here, we know that the error occurred when we were five instances deep in myreverse, so the problem was with the end of the list. But if you wanted more specifics, you can type s for show:

#<continuation in myreverse>                                      : s
  continuation:          #<continuation in myreverse>
  procedure code:        (lambda (ls) (if (null? ls) (quote ()) ...))
  call code:             (cdr ls)
  free variables:
  0. ls:                 5

Now we know for certain that we attempted (cdr ls) but ls was actually 5, and (cdr 5) is wrong.

Let’s try example2.ss:

(define pass-me-a-closure
  (lambda (thunk)
    (break)
    (thunk)))

(pass-me-a-closure
  (lambda ()
    (let loop ((x 5)
               (a 1))
      (if (zero? x)
        a
        (loop (sub1 x) (* a x))))))

Notice that we’ve set a breakpoint in the code using (break). This triggers the debugger, but only if we’re running Scheme interactively. If you try running scheme example2.ss directly, it will exit when it hits the breakpoint.

At the break point, we do the usual inspect and sfow frames.

[erjiang@silo ~]$ scheme
Chez Scheme Version 8.4
Copyright (c) 1985-2011 Cadence Research Systems

> (load "example2.ss")
break> i
#<continuation in pass-me-a-closure>                              : sf
  0: #<continuation in pass-me-a-closure>
  1: #<system continuation>
  2: #<system continuation>
  3: #<system continuation in dynamic-wind>
  4: #<system continuation in dynamic-wind>
  5: #<system continuation in $reset-protect>
  6: #<system continuation in new-cafe>
#<continuation in pass-me-a-closure>                              : s
  continuation:          #<system continuation>
  procedure code:        (lambda (thunk) (break) (display (thunk)))
  call code:             (break)
  free variables:
  0. thunk:              #<procedure>
#<continuation in pass-me-a-closure>                              :

Right now, it doesn’t actually tell us what thunk is besides just #<procedure>. We need to rnspect that particular free variable by its number or name by issuing r 0 or r thunk and then printing the code.

#<continuation in pass-me-a-closure>                              : r 0
#<procedure>                                                      : c
(lambda () ((letrec ((loop (lambda (...) (...)))) loop) 5 1))     :

Notice that the let-loop form has been expanded (remember, the macro expander has already run) and on top of that, the part we actually care about has been elided. Also, the current object is now the code, instead of #<procedure>. Because of that, we can pretty-print the current object, and it will pretty-print the entire object.

(lambda () ((letrec ((loop (lambda (...) (...)))) loop) 5 1))     : p

(lambda ()
  ((letrec ([loop (lambda (x a)
                    (if (zero? x) a (loop (sub1 x) (* a x))))])
     loop)
    5
    1))

You can always go back up to the parent object from here.

In Chez Scheme, inspect is also available as a procedure that will launch the debugger and inspect whatever is passed to it. For example, writing (inspect thunk) into the above code would immediately launch the debugger on thunk. Likewise, doing (call/cc inspect) will launch the debugger and inspect the current continuation (which you can then trace).

Now you should know how to enter the debugger, inspect the stack frames, and inspect variables inside the stack frames, including the procedure code and call code. When in doubt, randomly hit keys or ask for help? Expect a pop quiz over this.

There’s no reason why the left side is better than the right side. Convention, however, says that you must choose one way and live with it, or else you’ll be forever forced to constantly convert between left-handed and right-handed traditions. Just ask anyone who’s ever had to write low-level networking code. When sending an integer, it doesn’t matter whether the big end or little end goes first, but if you don’t agree with the other party, your message will come out garbled.

So imagine my discomfort when I have to sort files in Nautilus or sort processes in System Monitor.

For comparison:

and Wikipedia:

Why don’t I just look at the files to see if they’re the way I want them? Because the whole point of having that little arrow there is to quickly indicate to me which way things are sorted. I’d rather have no indicator than a confusing indicator, and besides, if you had to look at your window’s title bar every time you wanted to close a window, you would be frustrated too.

If you had files sorted by name is ascending order, you would get the first one first.

Alpha.txt
Beta.txt
Gamma.txt

Everybody else uses △ up arrow, but GNOME represents this sort with a ▽ down arrow. If you’ve ever written SQL, you’ll know that this alphabetical sort is what you’d get if you said ORDER BY filename ASC. Ascending is △ upwards. Like an elevator.

There are more ways to look at it. If you’re sorting numbers in ascending order, you would get

1
2
3
⋮

The biggest number is at the bottom. With the △ up arrow, the biggest end is at the bottom. This is like when you learned about the numerical comparison operators in preschool: 1 < 3, 9 > 7, or 5 ▷ 3 and 2 ◁ 4.

Score 0 for GNOME, score 2 for everybody else?

Some GNOME defenders point out that using a ▽ down arrow for ascending sort can make sense if you interpret it as an arrow pointing in the direction in which things are ascending. (e.g. in “1, 2, 3, 4,” the numbers are “going” ▷ right). The GNOME Human Interface Guidelines, however, don’t even justify their decision. They simply say that the “Natural” order is ▽ down arrow and the “Reverse” order is △ up arrow. There’s nothing supporting the connection between “Natural” and ▽ down arrow.

We’re not doomed forever though. This was raised as an issue in the GNOME bug tracker, and people generally support changing the guidelines to follow the general convention. Just give them another year or two or six and they’ll bring GNOME in-line with our expectations for how sorting should be indicated.

The real lesson here is that, when the choice between two things is essentially arbitrary, do some research and consider how everybody else does it. As Danny Cohen wrote (about network endianess),

It may be interesting to notice that the point which Jonathan Swift
tried to convey in Gulliver’s Travels in exactly the opposite of the
point of this note.

Swift’s point is that the difference between breaking the egg at the
little-end and breaking it at the big-end is trivial. Therefore, he
suggests, that everyone does it in his own preferred way.

We agree that the difference between sending eggs with the little- or
the big-end first is trivial, but we insist that everyone must do it in
the same way, to avoid anarchy. Since the difference is trivial we may
choose either way, but a decision must be made.

It seems like the default Venturer shell, when you choose “Navigation”, looks for SDCard\MobileNavigator\MobileNavigator.exe and runs it. Thus, if you want to replace the software that gets run, you should place the executable at that path. In addition, the GPS device is on port 1 with a baud rate of 4800, at least according to a working config file I found. For reference, that was in SDCard\MobileNavigator\sys.txt with the section
[gps]
port="1"
baud="4800"

It’s not a perfect paper and gamers might roll their eyes at reading a description of what an MMO is. There are surely some things that I would revise if I had the chance, but the version presented here is untouched from my original, save for formatting. It’s not a journal paper nor is it a book review, but I hope that some find it interesting. There is a lot that has been written on this subject, and there is much more that could be written. This is just a piece towards the theory that the core components of a fun game are readily identifiable and, with that knowledge, anybody can assemble a fun game.

Some quotes from the paper
Profit Versus Play: Business and Gaming in MMOs (application/pdf, 87 KB):

On whether MMOs qualify as games in a traditional sense:

David Golumbia, who is incidentally among such de-
tractors, could not examine this issue without first defin-
ing the French word jeu in the context of Jacques Der-
rida’s deconstruction of “play.” Fundamentally, Golumbia
establishes jeu as both “play” and “games” (and not con-
trivances like “freeplay”) and this paper will assume the
same: that “games” and “play” are merely different parts
of speech referring to the same concept without carry-
ing any intrinsic differences. And, as we’ll see, MMOs
like Ultima Online and EverQuest are certainly games in
the traditional sense as they fit like clockwork into Roger
Caillois’ categorization of games.

On the never-perfect divide between game and real:

This “contagion of reality” that plagues MMOs has
been and will continue to be money. “The minute you
hardwire constraints into a virtual world, an economy
emerges,” explained Castronova to Wired. “One-trillionth
of a second later, that economy starts interacting with
ours.”

And on harnessing Nietzschean behaviors:

It’s this type of accumulating points system that
Golumbia described as an exploitation of Machtelgust, or
the “lust for power” from Nietzsche’s writings. Golumbia
colored computer games in general as being deceptively
simplistic and degenerate. A single-player first-person
shooter (FPS) like the classic sci-fi game Half-life, while
appearing to offer freedom and a story to the player, is re-
ally a very rigid, pre-scripted experience of just shooting
anything that moves with a superficial and shallow plot
tacked on. Likewise, he wrote, MMORPGs are mostly
single-player experiences, despite the name, filled with
repetitive quests in a “surprisingly rigid, uncompromis-
ing, and even authoritarian” world.

Here’s an example in which the same display: block style is applied to an h3, a span, and a legend tag, each sitting in identical divs.

Gecko renders the legend tag as a block element correctly, and it fills up the div.

WebKit does something special about the width, and so it fails to fill up the div.

Given WebKit’s lineage, it’s not surprising that KHTML does even worse at the exercise.

Try it for yourself: legend width js-fiddle. Other people have had similar issues as well: StackOverflow: Cannot add margin to Legend element in Safari & Chrome.

A number of events and coincidences have reminded me about functional programming and parallelism lately, especially an example I saw of Clojure’s pmap:

pmap
function
Usage: (pmap f coll)
       (pmap f coll & colls)
Like map, except f is applied in parallel. Semi-lazy in that the parallel computation stays ahead of the consumption, but doesn’t realize the entire result unless required. Only useful for computationally intensive functions where the time of f dominates the coordination overhead.

I’ve heard, for a long time, the argument that functional programming offers a programming style better suited for parallelism. After all, MapReduce is perhaps the ultimate form of famous-brand massive parallelization. In a typical map operation, you don’t have to worry so much about all the nasty little parallelism problems since your code, by convention, is side-effect free.

parallelmap

So, as my contribution to the world of JavaScript hackery, here’s parallel map in JavaScript:

parallelmap(proc, tasks, callback)

where proc is a function that takes one argument, tasks is an array of things, and callback is a function that will be called with the results when processing has completed. The computation will occur in parallel and show dramatic speedups on processing-intensive tasks.

You can try the jspmap.js benchmark for yourself (if you have a recent build of Chrome) in a little test runner that I put together. If the test runner says “This isn’t going to work on your browser”, then it isn’t going to work on your browser. Sorry. There are a lot of details in the standards that haven’t been completely worked out yet, so I have to count on vendor-specific implementations to do what I want them to do.

My completely artificial benchmark shows close to a quadruple speedup on my quad-core machine.

var fun = function(x) {
    var q = 3;
    for(i = 0; i < x*300000; i++) {
        q *= 3.1;
        q = q % 10000000;
    }
    return q;
}
var list = [];
for(var i = 0; i < 50; i++) {
    list.push(i);
}
map(fun, list); // a lot of milliseconds
parallelmap(fun, list, alert); // a lot fewer milliseconds

Time to publish? Just don’t let anyone see the downsides:

• High overhead
• Relies on not-yet-standardized behaviors
• Relies on unintended usage (some would call it abuse) of not-yet-standardized behaviors
• proc must be serializable
• proc can’t use browser’s native functions
• proc can’t refer to variables outside of itself
• List items and result items must be serializable
• Insane

parallelworkers

The parallelmap function is admittedly a hack, but there’s also a more practical function included called parallelworkers(url, list, callback) that creates a Web Worker in the more natural way of specifying an external script to run. There’s the overhead of fetching another object, but it’s a lot more practical for writing complex scripts and parallelizing them, and it has the same freedoms and limitations as regular Web Workers.

parallelworkers("modulo.js", [1,2,3,4,5], alert);

How it works

The thing works by using Web Workers that only process one thing. A trivial that squares a number might look like:

self.onmessage = function(event) {
    self.postMessage( event.data * event.data )
}

The test runner simply tests multiplication, so each worker multiplies one number and returns the result. The main thread (browser thread) handles assigning work and collecting the results. Note that we don’t have to worry about the typical problems associated with concurrency—no need for locks or mutexes or similar tricky stuff. The implementation handles the gory message-passing details, and the main thread is just a single thread anyways. The architecture of web workers also means there is zero resource sharing—no object references get shared and the workers have no access to the main thread’s data.

Being able to pass in a function to parallelmap is just a dirty illusion, however. Browsers will happily convert a function to a string for you, and even pretty-print it in the process. Thus, attempting to do the following won’t work:

Math.sqrt.toString()
// function sqrt() { [native code] }
parallelmap(Math.sqrt,
    [1,2,3,4,5],
    alert)
// SyntaxError: Unexpected identifier

var x = 5
var fun = function(y) { return x*y }
fun.toString()
// function (y) { return x*y }
parallelmap(fun,
    [1,2,3,4,5],
    alert)
// ReferenceError: x not defined

Because Web Workers can only be created with a URL that points to the JavaScript to run, we have to look at special URLs to get around this. In parallelmap, we create a “blob” object with the (serialized) code. Blobs let us store arbitrary binary data client-side like this:

var bb = new BlobBuilder()
bb.append("Hello world!")
var url = window.URL.createObjectURL(bb.getBlob())

We’re given an identifier that looks like blob:http://notes.ericjiang.com/733d29b6-65ce-4318-9d41-9b6c893c2c6a. That satisfies the requirement for Web Workers (at least in Chrome), but other browsers may have a different idea of what constitutes “same-origin” for a Web Worker, and might refuse to play along with this stunt. The parallelworkers function is more practical, if you don’t mind the overhead of fetching another resource over the network (more overhead!).

Source code

If you’re still reading, the jspmap.js code can be found on GitHub. It provides map, parallelmap, and parallelworkers.

I think my ants are losing faith in me, as I haven’t uploaded a new version of my AI to the official server for a couple days now. New things are still in the pipeline, but I’ve lost my last 3 matches (though my opponents were ranked higher than me and probably deserve it too).

IU now has more than 5 people with active submissions, but the upcoming CS Club Hackathon will change that! I’m excited to co-organize the hackathon, which will consist of an all-day coding party dedicated to writing an ants AI. Dustin and I, as organizers, will be running matches and generally running things, and since we already have entries in the competition, we’ll be helping other aspiring antlords to get their own AI up and running.

Thanks to the school, we should have a competition server up and running soon, as opposed to running an unofficial TCP server. Prizes will also be offered to our hackathon winners, so I hope to see some creative strategies. I expect that there will be somebody wanting to use Haskell or JavaScript, but we’ll see how far they get.

Of course, I’ve been thinking about people’s choices of languages in the competition. The top-ranking bots are mostly “industry” languages like C++, Java, and Python, but there are a couple bots written in Go, OCaml, and Pascal up there. There’s definitely a trade-off between compiled languages like C and C++ and higher-level languages like Java and Python. In this competition, time is becoming a sticking point on many bots—you simply can’t run A* on as many ants in Java as you can in C. On the other hand, the time I’ve spent debugging memory errors could have probably been spent on improving my AI strategies.

Language designers are working to pull together this gap between productivity and speed: Google’s Go combines garbage collection and better concurrency models with the spirit of C, and Rust is another interesting but young language out of Mozilla. In the meantime, Java bot writers in the competition are just making do with timers to keep track of when to stop their calculations.

A good sort to know (not really) is bead sort. Imagine you have a bunch of beads on rods, like an abacus, and cross-wise they represent numbers. If you simply tilt the whole thing over, then gravity will let them all fall and they’ll sort themselves. For example, we have the numbers 3, 2, 4, and 2 read horizontally. When they fall, we get 2, 2, 3, 4. Easy!

Another sort, “random sort,” “shuffle sort,” or the more common name “bogosort” was suggested as a good example of an O(∞) algorithm. But, as people have pointed out, if the quantum many-worlds theory holds, then you could sort in O(n) time: Use true quantum randomness to randomize the list and if the list is not sorted, then destroy the universe. The only universe that remains will have a sorted list.

Finally, Graham showed me the wonders of sleep sort. I’ll just leave the bash source code here:

seq="1 9 2 3 5 6 4 7"
for i in $seq; do
    (sleep $i;echo $i)&false;
done

Given that Git and Mercurial are isometric for most intents and purposes, this baffled me. Clearly, this could not be some special Git-exclusive functionality. I dug into the git-dude source code and found out it was little more than a single bash script that pipes some git commands through sed and awk.

A few minutes later, I made hg-dude, which offers similar functionality for Mercurial. There’s a couple things that aren’t supported. Git-dude offered special notifications for tags and branches, and I didn’t translate them to Mercurial because the concepts, even though they have similar names, don’t quite match up. Regardless, it is still as useful as git-dude for commit notifications, which I expect is the primary usage.

Some may notice the irony of hosting a Mercurial tool on Github, but that was the easiest way to preserve its history from its git-dude days. Bitbucket fans can check out hg-dude’s Bitbucket repo.

Get hg-dude at Github or Bitbucket.