- The Flower Kings, “The Truth Will Set you Free”: One of the superlong Flower Kings opuses – in fact, the first thing by the Flower Kings that I ever heard.
- Solas, “Pastures of Plenty”: a stunning version of the old Guthrie song, played by one of my favorite Irish bands. It’s a brilliant cover – the original song is clearly there, and yet its embedded in a reel.
- Valley of the Giants, “Cantara Sin Guitara”: truly fantastic post-rock. Valley of the Giants is the first PR ensemble that I think really
stacks up to Godspeed.
- Jadis, “Standing Still”: neo-progressive rock, produced by
Marillion’s guitarist. It’s a bit on the poppy side, but after listening
to it a bunch of times, it’s really grown on me. Jadis’s songs tend to have
decent poppy hooks, but they’ve also got a lot of complexity, and they
have the ability to keep surprising you with their changes even after
- Riverside, “Volte-Face”: more neo-prog. But this time, it’s a band that I love without reservations. Riverside is the greatest new band that
I’ve heard in a very long time. Highly recommended.
- Keith Emerson Band, “The Art of Falling Down”: the great Keith Emerson is back. Emerson is a really brilliant keyboardist, and I used
to love his stuff with ELP. But then ELP fell apart; he tried to bring it back a couple of times, with results ranging from mediocre (Emerson, Lake and Powell) to piss-poor (Three). Then he went off to do mediocre movie soundtracks. And now, he’s back with a new prog-rock band. And they’re good. They’re not ELP, but they’re better than any other post-ELP work that he’s done.
- Cynic, “Evolutionary Sleeper”: What do you get when you mix up
death metal, neo-progressive rock, and jazz fusion? That’s the best
description I can come up with for Cynic. I gave Cynic a listen based on
a suggestion from a reader after I raved about Gordian Knot; Cynic includes
Sean Malone, the genius behind GK. They’re really excellent.
- Darcy James Argue’s Secret Society, “Transit”: another hard to describe group. Modern big-band jazz, with influences from classical
music. Very interesting stuff. Not my favorite, but definitely very cool and well worth a listen. I suspect it will grow on me with time.
- Van Der Graaf Generator, “The Sleepwalkers (live)”: Wow.
- John Corigliano, “Fantasia on an Ostinato”: Corigliano is one of my favorite modern classical composers. This is an intimate little piece for solo piano. Very beautiful, very stirring, and yet very delicate.
And as a special bonus, this irresistible video of two dancers playing Bach’s Tocatta and Fugue on the giant piano at FAO Schwartz.
As an alert commenter pointed out, I left out one really important thing in
my earlier post about finger trees. That’s what I get for trying to write when
I’m sick :-). Seriously, this is a point that’s implied by the post as it stands, but never explicitly stated – and since it’s really important, it
should be stated explicitly.
The monoid-annotated tree structure doesn’t replace the original
data structure: it’s superimposed on it.
So, as I said: cons-cell style lists are ubiquitous and beloved by
functional and non-functional programmers. In finger trees, you’re
not getting rid of them. The point of finger trees is to let
you keep the convenient data structure, with its basic operations
and properties intact, and to augment it with a tree that lets you search it efficiently.
To illustrate: here’s the number list example from yesterdays post. The
original list is at the bottom, with green pointers representing the
original cons-list next-pointers. The monoid-annotated tree is on top,
with red pointers. The combination of the original list with the
monoid annotated tree is a finger tree.
The point of this is that you’ve still got your cons list. All of the
beautiful recursive/iterative algorithms that walk the list continue to
work exactly the way that they would in the traditional cons-list: for code that walks the list, the fact that there are finger-tree pointers
sitting on top of the list is irrelevant – and, in fact, completely invisible. For algorithms that want to search the list, the tree structure is there,
and allows the searches to be performed much more quickly than they could be on
the traditional list. The superposition of those two structures is the
genius of the finger tree.
For ages, I’ve been promising to write about finger trees. Finger trees are
an incredibly elegant and simple structure for implementing sequence-based
data structures. They’re primarily used in functional languages, but there’s nothing
stopping an imperative-language programmer from using them as well.
In functional programming languages, lists are incredibly common. They show up everywhere; they’re just so easy to use for recursive iteration that they’re ubiquitous. I can’t think of
any non-trivial program that I’ve written in Haskell, Lisp, or OCaml that doesn’t use lists. (Heck, I’ve wound up using cons-cell libraries a couple of times in C++.)
Of course, lists aren’t perfect. In fact, for some things, they absolutely suck. Suppose I’ve got a really long list – like a list of names and phone numbers from a telephone book. My local phone book has 600 pages of names; and the pages are incredibly dense – there’ve got to be at least a couple of hundred names per page. So in a phone book for a suburban region of New York City, the list of phone numbers will have 120,000 names. Now imagine that I want to look
up one name in that list – on average, I’m going to have to chase through 60,000 pointers. 60,000 isn’t a huge number for a computer, but still, chasing 60,000 pointers is a pretty big deal. If I stored them in an array, it would be a lot less convenient for some tasks, but I could use
binary search to find names, and I could find any name in no more than 16 comparisons – and the whole shebang would be contiguous, so I wouldn’t even be chasing pointers.
What finger trees do is give me a way of representing a list that has both the convenience
of the traditional cons list, and the search efficiency of the array based method.
Continue reading Finally: Finger Trees!
In general, I try to keep the content of this blog away from my work. I don’t do
that because it would get me in trouble, but rather because I spend enough time on work, and blogging is my hobby. But sometimes there’s an overlap.
One thing that’s come up in a lot of conversations and a lot of emails it the idea of cloud computing. A lot of people are interested in it, but they’re not really sure of what it is, or what it means.
So what do we mean when we talk about “cloud computing”? What’s the cloud? How’s it different from good old-fashioned client/server computing?
Continue reading Cloud Computing
In my Dembski rant, I used a metaphor involving the undescribable numbers. An interesting confusion came up in the comments about just what that meant. Instead of answering it with a comment, I decided that it justified a post of its own. It’s a fascinating topic which is incredibly counter-intuitive. To me, it’s one of the great examples of how utterly wrong our
intuitions can be.
Numbers are, obviously, very important. And so, over the ages, we’ve invented lots of notations that allow us to write those numbers down: the familiar arabic notation, roman numerals, fractions, decimals, continued fractions, algebraic series, etc. I could easily spend months on this blog just writing about different notations that we use to write numbers, and the benefits and weaknesses of each notation.
But the fact is, the vast, overwhelming majority of numbers cannot be written
down in any form.
That statement seems bizarre at best. But it does actually make sense. But for it to
make sense, we have to start at the very beginning: What does it mean for a number to be describable?
Continue reading You can't write that number; in fact, you can't write most numbers.
Over at Uncommon Descent, Dembski has responded to my critique of
his paper with Marks. In classic Dembski style, he ignores the
substance of my critique, and resorts to quote-mining.
In my previous post, I included a summary of my past critiques of
why search is a lousy model for evolution. It was a brief summary of
past comments, which did nothing but set the stage for my
critique. But, typically, Dembski pretended that that was the entire
substance of my post, and ignored the rest of it. Very typical of
Dembski – just misrepresent your opponents, create a strawman, and
then pretend that you’ve addressed everything.
Continue reading Dembski Responds