Herewith gleanings from a circle of browser tabs facing inward at the world of technology. Some are weeks and weeks old: Amber Road, Clojure, tail recursion, cloudzones, deep packet inspection, and key/value microbenchmarking.

Don’t Mind Saying “I Told You So” · Per the Reg’s Sun’s Amber Road traffic picks up, it seems I’m not the only person who thinks those Open Storage boxes are the hottest product we’s shipped in years. I still think they’re being underestimated. Transparent Storage was my take last year on one of the reasons this stuff is so nifty.

Lisp ♥ JVM · Clojure 1.0 has shipped. I don’t even like Lisp much, but Clojure pretty well knocked my socks off at last year’s JVM Languages Summit.

Tail Recursion Bah · Guido van Rossum writes about tail recursion and Python in Tail Recursion Elimination and follows up with Final Words on Tail Calls. I have to say I was irritated by all the Functional-programming geeks intoning snottily about how He Just Doesn’t Get It; while Guido has been known to be wrong, he’s as accomplished a programming-language implementor as walks the planet.

I think I understand tail recursion reasonably well, just like anyone else who’s been to first base with Erlang. And I really dislike it.

I don’t mean I dislike the idea: it’s easy to appreciate the functional-programming benefits of that style of constructing a loop, and the closely-related benefits of Erlang’s immutable “variables”. But gimme a break, dressing the loop up as a function call, and the special variables up as function arguments, is just a great big fat stinking lie. A light is being hidden under a bushel.

Cloudzones · Check out Mark Harrison’s Virtualization, ZFS and Zetaback. I’ve never been much of a virtualization weenie, but since I landed in the cloud space earlier this year, I’ve become more and more convinced that lightweight v12n is a really big deal. I’m not sure Mark’s hit exactly the right sweet spot, but I think there’s one out there.

Deep Packet Inspection Sucks · You probably knew that already. But in case you didn’t, or wanted to feel comfier about your position, check out this Collection of Essays on the subject commissioned by the Canadian Government’s Office of the Privacy Commissioner.

Key/Value Microbenchmarking · Brendan O’Connor reports on Performance comparison: key/value stores for language model counts and it’s interesting, but the data set is too small and the problem is too specialized. What this does highlight is the need for some serious work on understanding the differences between all these fascinating new postrelational storage options. (Relatedly, back in March, I ran across How Fast is Redis?)


Comment feed for ongoing:Comments feed

From: Fred Blasdel (May 12 2009, at 00:02)

You *really* don't understand the argument for TCO if you're going to trot out the "just loops" canard. Tail-call optimization is what makes Continuation Passing Style plausible, and CPS is significantly more novel than you appear to comprehend.

Python's lack of TCO isn't really for ideological reasons, but because it'd be a pain in the ass to implement pythonically, and code written to use it is absolutely dependent on it -- it is *not* an implementation detail (one of the many idiotic things about Common Lisp).

Also, the numbers in the "key/value performance comparison" are both awful and nonsensical. I suspect that there's some combination of poor setup, odd problem, and crappy computer.


From: Markus Freericks (May 12 2009, at 06:41)

Tail optimization is the functional "goto". Some algorithms simply cannot be implemented efficiently any other way.

For example, if you have to implement a large state machine (say, a byte code interpreter, or a lexer) efficiently in Java, you have to create a huge switch statement. Since you are limited to 64k byte code per method, this is not always possible. Modelling each state as a method/function that is called at tail position, you have no such problems (and the code looks is better understandeable).


From: Seth Gordon (May 12 2009, at 07:21)

The bloger "Abstract Heresies" ( did a series on tail call optimization. One of his big points is that it's *not* just a way to rewrite loops as recursive function calls. It's also useful for the Visitor pattern, for example.


From: James Abley (May 12 2009, at 13:58)

+1 for the Abstract Heresies series response to Guido. You need to read all of them to appreciate the well-constructed argument contained therein.


From: Paul Boddie (May 13 2009, at 14:05)

I don't agree with GvR on numerous matters Pythonic, but with the widespread success of Python, I think he has earned the right to say whether or not he finds some feature or other worthwhile enough to make it into the only implementation of his language over which he has any practical measure of control. (Personally, I don't really buy his argument, but I can see why he isn't interested in doing anything about this particular matter.)

It says a great deal that Lisp devotees, for example, either lobby for the inclusion of various features from that language in Python or scoff at Python for not having feature X, Y or Z and not supposedly being a "complete" language, all whilst the community of their own language of choice withers on the vine.


author · Dad · software · colophon · rights
picture of the day
May 11, 2009
· Technology (77 fragments)
· · Coding (98 more)
· · Internet (103 more)
· · Java (123 more)
· · Storage (26 more)

By .

I am an employee
of, but
the opinions expressed here
are my own, and no other party
necessarily agrees with them.

A full disclosure of my
professional interests is
on the author page.