The video above depicts an insertion sort implemented through Romanian folk dance.

See also: bubble sort, selection sort, and Shell sort.

So clearly this results in a pretty cool set of images. What I’d really like, though, is a 3-d graph depicting signal strength on a 2-d field.

Imagine if we replaced the rod with a disc composed of a set of concentric circles of lights. Suppose the number of circles that light up correlates with the strength of the signal, so that more signal => more light. Head to the city park, wander around in a grid pattern with this device, point the camera down from a building, and take a long exposure of the results. Signal would be represented as pools of light.

Someone go do this for me. Send me pictures.

RFC 2324 defines the Hyper Text Coffee Pot Control Protocol. HTCPCP is built on top of HTTP, implementing a range of new headers and errors (418 I’M A TEAPOT) that enable the intercommunication of networked coffee pots. Manufacturers, take note — standards-compliance grows the market.

Tupper’s self-referential formula describes a function whose graph (for inputs within a certain range) is the formula of the function itself.

Links: Wolfram, Wikipedia.

Hofstadter should probably be informed.

First, we need to talk about memoization (if you’re familiar with memoization already, feel free to skip along a bit). Suppose we want to write a function to calculate the n^th Fibonacci number. We might first write a naïve recursive function:


def fib (n):
     if n < 2:
         return n
     else:
         return fib (n - 1) + fib (n - 2)


This does the job (assuming we give it appropriate input), but it's actually terribly inefficient. Check out the call tree for fib (5):

We've got a few redundant calls here (notably fib(2) and fib(3)), and for higher values of n they really start adding up. As it turns out, this Fibonacci implementation is O (2ⁿ). Our elegantly simple algorithm is awful, just awful.

But we can salvage it! If we were to record our calculated values (using a closure, say) we could make this thing phenomenally more efficient.


def memoized_fib (n):
     values = [0, 1]

     return fib_helper (n)


We're creating a list called values, for which each entry contains the Fibonacci number associated with its index, starting with the first two. After we've recursed all the way down the first time, we build up the list as we pop functions off the stack, so subsequent calls to fib_helper() don't really need to do any recursion at all — they can just look up the appropriate value in values. The list values is hidden inside a closure, so it's protected from the outside world. Certainly we could have implemented memoization using a global variable, but why would we if we we don't have to? Our closure provides an equally efficient and more elegant solution to the problem.

Just to drive home the efficiency gain, memoized_fib(500) takes 0.014s to run on my machine; fib(500) is still calculating an hour later. Which makes sense, since we've replaced an exponential algorithm with a linear one. Nice.

I’ve recently started seriously digging into Python, though, and I think it’s going to be the Imperative Language That Makes Me Cry The Least. It’s got the holy higher-level trinity of map, reduce, and filter, syntactically-sugary list comprehensions, lambda expressions, and it even uses ** as the exponentiation operator, as God and Fortran intended.¹ It also has closures, which are magic if you haven’t seen them before, so I’m going to yammer on about them for a bit.

To be fair, I’m probably not the best person in the world to tell you about lexical closures. You really want Wikipedia. In brief, though, a closure is a function that can access and change state in the environment in which it was defined. Kinda like object-oriented programming without the objects: the way methods can access private data is kind of analogous. Let’s just look at an example: ²

def makePowerFn (power):
     def powerFn (base):
         return base ** power
     return powerFn

cube = makePowerFn (3)
print map (cube, [1, 2, 3, 4, 5])


Executing the above code applies our cube function to every item in the list and prints out [1, 8, 27, 64, 125].³ Neat, right? The magic part is that cube was effectively able to access power because it was defined within the enclosing lexical scope.

The concept of closures is pretty deeply embedded in serious-business functional languages like Haskell and the various dialects of Lisp,⁴ but lots of relatively modern mostly-imperative languages like Ruby and JavaScript have adopted them, too. I seem to recall that there’s been a ongoing attempt to get closures into Java, but I’m not going to hold my breath.

Anyway, closures! Now you know!

¹ Python still can’t make metaprogramming trivial the way Lisp does, though. But I guess we can’t have everything. =P
² Example adapted from defmacro’s rather nice functional programming discussion (near the bottom).
³ Notice how I got to use both map and ** in there? Awww, yeah.
⁴ “Haskell and the Lisps” would be an awesome band name, you guys.

• Russian speakers, who have more words for light and dark blues, are better able to visually discriminate shades of blue.
• Some indigenous tribes say north, south, east and west, rather than left and right, and as a consequence have great spatial orientation.
• The Piraha, whose language eschews number words in favor of terms like few and many, are not able to keep track of exact quantities.
• In one study, Spanish and Japanese speakers couldn’t remember the agents of accidental events as adeptly as English speakers could. Why? In Spanish and Japanese, the agent of causality is dropped: “The vase broke itself,” rather than “John broke the vase.”

…in recent studies, MIT students were shown dots on a screen and asked to say how many there were. If they were allowed to count normally, they did great. If they simultaneously did a nonlinguistic task—like banging out rhythms—they still did great. But if they did a verbal task when shown the dots—like repeating the words spoken in a news report—their counting fell apart. In other words, they needed their language skills to count.

Just what the title says. Featuring Carl Orff, naturally.

It would appear that Benoît Mandelbrot passed away yesterday. =\

Weather balloon + video camera. Why haven’t we done this?