malvasia bianca

More changes at my sudoku site of choice:

First, they’ve added a new tool to help you solve puzzles: they’ll highlight all squares where you’ve filled in a given number (either as the only choice for that square or as one of the possibilities for that square). Which I appreciate: for one thing, it helps the algorithm that I use when starting to solve a new puzzle, and for another thing, it eliminates some of the mindless searching in the middle of solving a puzzle, where you just haven’t noticed that a square that used to be 134 is now just 14 because you’ve since filled in a 3 in the same row.

They’re doing a very good job of allowing me to eliminating the parts of filling out sudoku that I don’t enjoy (making stupid mistakes like two 4’s in the same row, mindless searches for numerical conflicts) while still leaving me enough to do that I have to spend some time thinking. I also find that I enjoy being the person who actually fills in the number that must go in a square: they have another optional feature “auto pencil marks” which fills in the possibilities for each square using a naive algorithm (eliminating all numbers that would conflict with the given row/column/block); I don’t use that, because I assume it would find a unique solution for several of the squares, and I want to find those unique solutions myself! So I’m willing to trade some amount of tedium for that feeling of accomplishment.

After my first sudoku post, Chris commented that he didn’t do them because he didn’t like puzzles that he could write a Perl script to solve. Which is a quite reasonable point of view, but it turns out that what I like is puzzles where I could write a Perl script to do a fair amount of the automation while leaving me with most of the thinking.

The second recent change is that they’ve gone from three to four to five difficulty levels. Honestly, I didn’t notice a big difference when they went to four (a little difference, but not a big one), but today is the first day with five difficulty levels, and, for the first time, my standard algorithms didn’t let me solve the puzzle. (Or at least the first time recently: previous puzzles have forced me to add to my bag of tricks.) So I had to figure out a new algorithm to get past that one; fortunately, the new algorithm was made easier to carry out by the “highlight all squares with a given number” feature.

The upshot is that I can still do their hardest sudoku more quickly than I could have done it when their hardest was significantly easier but I didn’t have as much automated help, and that I enjoy it more because I’m spending less time doing tedious searching and more time thinking. And it’s less of a time sink. A win all around.

(Enough with the sudoku posts, I know.)

Gosh.

I just read On Talking Terms with Dogs: Calming Signals. Its core is a list of about thirty different signs that dogs do when trying to calm themselves or each other dog. Some of which make sense in retrospect, like not walking straight at a dog if you don’t wan tto make it nervous (arc around it instead), but some of which I never would have realized (yawning, licking your nose).

Apparently the signals work on dogs when humans do them, too. (At least some of them; it’s kind of hard for humans to lick their noses.) Which is the main reason I got the book: Yosha was barking quite a lot a few months ago (he’s gotten somewhat better recently, mercifully), and I’m willing to try things to calm him down. I’ll be quite impressed if the techniques work on him, though: he is quite the bundle of nerves.

Even if they don’t, though, it’s an interesting way to look at dog behavior. If nothing else, I’ll spend the next few weeks paying more attention to when my dogs lick their noses.

(Not available from Amazon, for some reason, but you can get it here.)

As I said last month, we’ve finally started doing a full planning game; we did it again this month. And I’m really glad we did: for one thing, November’s planning rubbed in our faces some of the things we were doing wrong.

One basic issue, as I see it, was that we were focusing too much on using real units for our planning. We were doing lots of measurements, but at the end of it, the main thing we got out of our measurements was that, in a week, we spent a week working. Which isn’t very useful!

So now we’re giving up on measuring actual time; we’re simply estimating our tasks in points, but not measuring how much actual time a point takes us to do. Instead, we total up the points in the cards we finished that week, and there’s our velocity. Simple, much more useful than what we’d been doing.

The other improvement is that we’re getting a lot more serious about breaking up large stories into smaller ones: we’ve basically given up on the idea of a 3-point story (which was a story that we thought that a person could get done in a week doing nothing else), so now all our stories are either 1/2 point, 1 point, or 2 points. (A geometric progression; I don’t think that’s an accident.) This seems to greatly reduce our errors.

The upshot is that, in November, we included a significant slush factor for mistakes in our estimates and still didn’t get close to accomplishing everything that we’d planned, while in December we included no slush factor and are slightly ahead of schedule.

Some of that, to be sure, is due to external factors: in November, we were working in a bunch of new areas, so in retrospect it’s not surprising that we had pretty high startup costs. And then in December we were working on the same areas and made our estimates just before we started getting comfortable with them; as a result, several tasks that we estimated as 2-point tasks ended up being more like 1-point or even half-point tasks. (To be sure, there were still some estimation errors in the other direction. I’d be worried if there weren’t estimation errors…)

I’m also really pleased that we did a good enough job of preparing cards in advance that our Customer could pick all the cards for us to work on instead of him having to say “this sounds like a good thing to work on, pick 5 points to work on once you’ve got cards worked out”, and could do so in about an hour and a half. One of my top priorities before Christmas is to make sure we’ve done enough ground work so that we’ll be able to do the same thing in January.

The Customer also wrote three story cards during the December planning meeting, as a result of our insisting that he pick all the cards. (He’d also written a few cards before then in a previous meeting.) And all three cards have proven useful: two of them turned out to be for things that we thought software we were integrating could do but it can’t do, so I’m very glad we learned that now! And the other involved something that we’d implemented incorrectly and which had slipped through unit testing; oops.

And while we’re on slipping through testing: we’re still running into situations where we realize we haven’t written enough acceptance tests for a feature, we write an acceptance test, and it turns up bugs. I’ve loved my unit tests ever since I started writing them; now I love acceptance tests, too. If you’re ever programming with somebody else, the single most useful thing you can say is “should we write a test for that?”

I was pretty excited to get Sid Meier’s Pirates!: I’ve spent many a pleasant hour with the various Civilization games, and the reviews talked about how you couldn’t put the game down, how you’d find yourself playing it at two in the morning.

The reality wasn’t so great, however. Its resemblance to Civilization was very faint, certainly no more than its resemblance to many other games. And while it is true that it’s hard to put the game down, the reasons for that have nothing to do with its quality.

The game is a mishmash of various genres: fighting, dancing, rpg, strategy, turn-based combat, probably others that I’m not thinking of at the moment. You’re a pirate, sailing a ship around the Carribean. You recruit crew members, upgrade your ship, capture new ships. Capturing new ships is mostly done with a sword-fighting mechanism, occasionally combined (I hesitate to say augmented) with Shenmue-style QTE’s and ship-to-ship battles. You can dance with governor’s daughters; you can go on quests to find people and treasures. And you can conquer cities, and get special items to improve your skills.

The problem is, these genres are all done in an extremely sketchy fashion, and the game doesn’t combine them in a particularly interesting way. The swordfighting system is very basic. There’s almost never a reason to use your cannons. There’s almost no plot; in particular, the goals that you carry out over the course of the main quest are completely random, and the side quests aren’t any more satisfying.

This lack of plot is why it’s hard to put the game down: you never have the feeling that you’ve just accomplished something big (or even medium), so you don’t have the traditional video game cues to consider stopping. It’s like playing solitaire: sure, sometimes I end up playing game after game of solitaire later into the night than I should have, because it’s always tempting to play just one more game, but that’s hardly a virtue.

I bought a Nintendo DS; the triggers were that we’re going on vacation soon, plus the release of the new Mario and Luigi RPG and the new Animal Crossing. We also got a puzzle game called Meteos, which seems decent so far, and which at least uses the input mechanism well.

My registrar was having problems yesterday, so name lookups for bactrian.org and gobooks.info weren’t working. Seems to be fixed now.

Anybody have any good Thomas Merton recommendations? I really liked his autobiography, and I get the impression that he’s the sort of person who might well have written more books that I’d like, but neither New Seeds of Contemplation nor Zen and the Birds of Appetite did much for me.

For that matter, any other Christian book recommendations? (Should I read Augustine’s Confessions; if so, which translation?) As background, I’m an atheist with a soft spot for mysticism who is particularly down on the big monotheistic religions. Which is probably biased by the environment that I live in, where the evil that they produce gets rather more press than the good that they produce. (It would be interesting to see a foreign policy based on turning the other cheek…) Or any recommendations for books about Sufism? The latter seems like a form of Islam that I would find particularly congenial.

And now you can see the video games I’ve played recently.

There’s still a little bit of refactoring to do on the code that I’ve checked in, and a little bit more code to write. But the previous constructs held up reasonably well; easy enough to add the new item types (video games, game consoles, game developers) through a mix of cutting and pasting, reusing existing classes, and one class extraction. A shade more cutting and pasting than I’d like, but I’ll deal with that soon enough. Or at least try; I suspect that I’ll run into more places where C++ templates would be more useful than Java generics.

One interesting non-parallel between books and games is the way I plan to handle series. (I haven’t yet added series of games yet; next weekend.) Some book series are quite straightforward: the books are named Series, volume N. In others, the book names aren’t so predictable, but at least there’s a straightforward order and notion of volume number.

You’d think it might be the same way with video games – surely Resident Evil 4 counts as the fourth item in its series? Well, no: the games in the series so far are Resident Evil, Resident Evil 2, Resident Evil 3, Resident Evil: Code Veronica, Resident Evil 0, and Resident Evil 4. Plus some spinoffs and ports, some of which (the GameCube and forthcoming DS versions of the original) are remakes with more significant changes. So there’s no useful notion of “volume number” in a video game series; you might as well just sort them by release date. Also, different games in a series can be published on different consoles and even made by different developers, so there’s no attributes of a game that you can glean from its presence in a series.

For that matter, even the definition of a series isn’t well-defined – if you take the original Super Mario Brothers, Super Mario Sunshine, Paper Mario, and Mario and Luigi: Superstar Saga, how many different series are they part of? I can imagine any number from 1 to 4 as an answer. So while I think I will add the notion of a video game series, there won’t be the same structure as in the book case, where I had classes BookLike, Book, Volume, and Series in a sort of V-shaped inheritance diagram.

There are a few features I’d still like to add, most notably links to blog posts, but they’re all relatively straightforward. I should really spend more time learning about SQL and Ruby, so I can play around with changing the underlying implementation.

Okay, now I understand, at least a little. It would seem that, if A depends on B, using a part of B’s implementation that, say, returns an object of type C, then modifying C doesn’t cause the depend task to rebuild A unless you set closure to be true. Which is a little weird – I would think of that as being enough to cause A to depend directly on C.

So that’s why, without setting closure to be true, you don’t get the right stuff rebuilt. Having said that, closure also causes tons of extra stuff to be rebuilt – why not use a more useful notion of dependency to begin with? Does it have something to do with the structure of class files? What is the notion of dependency that the task is working with?

I finally have dependency checking right; I don’t know how I missed ant’s depend task before, but I’m using it now. I’m still a little surprised that the tutorials that I looked at didn’t point it out, and that it’s an optional task; on the other hand, there are enough C and C++ build systems with incorrect dependencies that I suppose the rest of the world doesn’t take this as seriously as I do. (Hint: gcc -MD -MP is your friend.)

There’s still one thing I don’t understand: the depend task’s ‘closure’ attribute. It defaults to false; if turned on, and if A depends on B which depends on C and C changes, then A gets rebuilt. (In addition to B, of course.) I don’t understand why this is necessary, though: thinking about this in C++ terms, it sounds like B’s implementation depends on C, but A doesn’t either directly depend on C or depend on those parts of B’s interface which mention C (if any). In that case, why would we need to recompile A? So there’s something that I’m missing here. I’m leaving it turned off for now; if that causes problems, I’m pretty sure my tests will let me know, at which point I’ll learn why you want to turn it on.

One of our thanksgiving desserts was the “Marquise au Chocolat Taillevent”, from Patricia Wells’ The Food Lover’s Guide to Paris. A book that has served us well, though I hope she comes out with another edition before the next time we go to Paris, if only to find restaurants there that serve a decent raclette. The recipe is quite good, quite easy; use good chocolate, of course.

The cookbook pairs it with a pistachio sauce; we’ve never tried that, because it seems like rather more work. Though probably we can get shelled pistachios at the Milk Pail, which would help somewhat.

Marquise Au Chocolat Taillevent

9 oz. (280 g) bittersweet chocolate, broken into pieces
3/4 cup (100 g) confectioners’ sugar
3/4 cup (185 g) unsalted butter, at room temperature
5 eggs, separated
pinch of salt

Melt the chocolate in a double boiler. Add 1/2 c (70 g) sugar, the butter, and the egg yolks, in that order, stirring to mix after each.

In a small mixing bowl, beat the egg whites with a pinch of salt until stiff. Add the remaining sugar; beat another 20 seconds, until glossy.

Remove the chocolate from the heat. Fold in a third of the egg white mixture, then the rest of it.

Rinse an 8 1/2 inch (22 cm) springform pan with water. Leave it wet, and fill it with the mixture. Refrigerate for 24 hours.

Remove from refrigerator about 30 minutes before serving.

Anybody have any good podcast recommendations? I’ve been listening to them for a few months now; the only ones that have stuck are agile toolkit, which can be very interesting but which doesn’t get updated very often, and the Mercury News video game podcast, which I enjoy but might well not listen to if I didn’t want to support my local paper’s video game coverage.

So: any good ones out there? Not necessarily just talking – I’m happy to get music recommendations as well. Whatever’s interesting to listen to. I don’t want to spend all my time listening to them, but I’d be happy to have a couple of hours a week of podcasts.

Thanksgiving dinner was quite pleasant, and surprisingly painless, given the amount of food. There were eight people eating dinner at our house; the food included a dish that could be labeled as a main dish if you wish, four side dishes, and two desserts. Which sounds like a lot of work, especially if you’re only just toying with the idea that you might be healthy, and especially if you’re a little tired mentally from having steam-cleaned carpets two of the three previous weekends (different carpets on different weekends, they don’t get dirty quite that fast, and our grime tolerance is really very high) and have to pick up a guest from the airport on Thanksgiving day, but it really wasn’t bad at all.

One thing that helped was that guests brought two of the side dishes. Another thing that helped was that we did some of the cooking on previous days. Which is a double-edged sword: we’re not exactly perky and bustling with energy evenings after work, so it’s not always a good idea to offload work to weekdays. In this case, though, it was the right move: on Tuesday, Liesl made cranberry-orange relish, which basically means dumping cranberries, an orange, and sugar in a food processor. And on Wednesday, Liesl made the dough for the pie crust (I didn’t realize how easy that is), and I made the marquise au chocolat (I should post the recipe for that some time; like many good chocolate desserts, it’s a simple preparation of high-quality ingredients), neither of which took as much as half an hour.

So on Thanksgiving all we had to do was finish the pie (pecan pie, so basically dump a bunch of things together, mix them, and put them in the pie crust), make the other side dish (a spinach dish that was made much much easier by our buying pre-cleaned baby spinach. We should get into the habit of making fresh spinach dishes much more often, given the availability of that stuff), and make a double recipe of the following:

Beef Birds, from Molto Italiano, by Mario Batali.

2 pounds skirt steak, about 1/2 inch thick, cut into twelve 4-inch-long pieces
12 slices prosciutto
12 fresh sage leaves
1 pound pancetta, cut into 1-inch cubes
olive oil, salt, pepper
skewers

Put a piece of prosciutto and a sage leaf onto each slice of steak. Roll them up, and put them on the skewers, alternating with the pancetta cubes. Brush with olive oil; season with salt and pepper. Grill or broil, turning once, until the beef is medium-rare, about 3 minutes per side.

And even a doubled recipe of that is really easy, especially since I wasn’t, say, sweating about the fact that my pieces of beef were all different sizes. Really good, too, in ways that I’m not used to. For one thing, it’s the first time I’ve cooked with thick slices of pancetta. We had to go to a butcher to get it (we got the steak there, too); first time I’d been there, but I’ll be happy to do so again in the future. Thick pancetta turns out to be a quite different beast from the thin slices I’m used to: much more of an aroma, and you just can’t ignore the fact that, at times, you’re biting into a big chunk of fat. Which, normally, is a huge downer for me, but it wasn’t in this dish. Probably because of the broiling, which is something that we almost never do; the skirt steak was also much fattier than I’m used to cooking with, but I didn’t notice its fat at all while eating.

We had the meat too close to the broiler’s heating element, so it smoked up the place; fortunately, our smoke alarm is not hyper-sensitive. (No way to turn it off, and it’s wired to the townhouse complex, so if it goes off you will at a minimum annoy your neighbors and at a maximum, if you don’t get on the phone soon enough, have fire engines at your doorstep.) Because of this, the beef ended up being a lot more rare than medium on the inside (though the outside looked lovely); it tasted delicious nonetheless. We really should use the broiler more.

So: easy food, which I think was more than good enough to stand up to almost any Thanksgiving I’ve had. And quite nice company. Followed by three more days of weekend. (Not that I don’t enjoy work, but the occasional break has its benefits.) And no gifts. What more could one want from a holiday?

I started playing around with Google Reader over the weekend, and I think I’m going to stick with it as my RSS reader. I don’t have any reason to believe that it’s better than other web sites for that purpose, but it’s good enough for me, and is a significantly better RSS reader than Gnus, which is what really counts for me. In particular:

• It understands Atom. There are a couple of blogs out there that I like that only provide Atom feeds; sensible people are convinced it’s the way to go, so who am I to argue?
• Gnus has a per-feed cost: different feeds show up as different groups but without the number of messages shown, so I have to enter each one to see if it has any new messages. This discourages me from subscribing to blogs that only get added to, say, once a month, which is bad.
• Gnus has to download the feeds each time I use it, which takes a while; Google operates out of cache.
• In Gnus, I have to click on a link to see the entry in a web browser; the entries frequently look just fine the way Google displays them, and if they don’t, I can bring up the original just by typing a key, with no mouse usage required.

Having said that, Google reader needs some polishing. (No surprise; they don’t claim otherwise.) Some examples:

• When I went through my initial orgy of subscribing, Google sometimes wasn’t able to carry out my requests. It told me to try again in 30 seconds, which didn’t work; trying again in a few hours did.
• Its search functionality is surprisingly bad: for several of the blogs that I’d already subscribed to, I ended up having to type in the feed address by hand instead of finding it through the search engine. (Though the flip side is that it did know about feeds for some blogs whose feeds aren’t listed on the blogs’ main pages…)
• I don’t like the way it presents new articles. For one thing, if you go to it when there’s one new article to read, then the left column makes it look like you’ve read all the articles. So it would be nice if it only cleared the “article read” mark after you had moved off the article in question, instead of when you select the article. For another thing, if there are a bunch of unread articles, it starts you off at the newest instead of the oldest.
• It claims that a couple of the blogs I read have no articles in them. I was going to say that I’ll be curious if new items from those blogs show up, but I just checked: one new item has been posted to one of those blogs, and it didn’t show up. Oops. For all I know, the RSS feeds may be malformed, though.

At first, I wasn’t sure I liked the way it handled starred items – they easily get buried in the list on the left – but now I’m fine with having to click on the “Starred” link.

One question: do I ultimately want my feed reader to be built into my browser or a separate web site? The former has the advantage of being able to read feeds that aren’t on the global internet; the latter has the advantages of fast startup and accessibility from multiple computers. (The latter of which I used over the weekend, since I spent some amount of time in (gulp) Windows XP, downloading podcasts via iTunes.) For now, the question is academic: I would prefer to stick with Galeon, which doesn’t have a feed reader. I will try to avoid giving in to the temptation of using Google Reader at work…

I added a book index. Pretty straightforward cutting and pasting, followed by some refactoring.

The refactoring was a little different from normal. For one thing, it was my first experiment with writing generic classes in Java. (I’d written a generic function before, but not a generic class.) I learned a little more about what you can and can’t do; it turns out that you can’t construct objects of a type given by a generic parameter (not surprising – you don’t even know what arguments the constructor will take, if any) or check if a type is an instanceof a generic parameter (doesn’t work because of type erasure – they need to provide a single implementation, basically, and the implementation wouldn’t work if you replaced the parameter by Object). Too bad, though, since my code would have been a little shorter if I’d been able to use those features.

For another thing, I made more mistakes than normal. I’ve avoided learning to use a Java debugger so far; with TDD it’s rarely necessary. But I did make one mistake that took me a while to figure out; I ended up undoing some refactorings, redoing them, and using printfs, but it would have been a lot faster if I’d gone into a debugger. So next time this happens, I really should learn how to use one. (My problem was that I was doing something complicated in a constructor before the object was fully initialized; I should know better than that. It’s always hard to find the right balance when writing a class that basically exists to calculate a single value, though: what goes in the constructor, what goes in the other member function?) And then I ran into a bug that my acceptance tests caught that had slipped through my unit tests, and of course I wasn’t sure when I’d last run the acceptance tests, so I didn’t know when I’d introduced the bug. Fortunately, I found the bug after thinking about it for just a couple of minutes, but I was starting to regret that I wasn’t regularly saving the output of svn diff on my source tree, like I do at work.

And getting the balance of the classes just right, and figuring out which should be nested classes and which wouldn’t, took a while. I like what I ended up with, though; in fact, it was a strange refactoring in that it didn’t save me many, if any, lines of code, but it did clarify the code nicely. So the next time I implement an index, it will only be three or five lines shorter than it would have otherwise been, but I’ll know exactly what I need to type.

I also used the new code to help me generate the list of books by an author. It turns out (I’d realized this a week ago) that that code had a bug in it: if I had two books with the same name by the same author, they would have only shown up once. Which would sound a bit far-fetched, except that books in the database largely represent physical objects; so if I wanted to enter both of my copies of Delany’s The Mad Man in the database, they wouldn’t have both shown up everywhere. But now they will! The same bug still exists in a couple of other ways: multiple series with the same title, mutiple volumes in a series with the same number. There, it’s not so clear to me how to come up with realistic examples, so I’m not worrying about it for now. It’ll probably all get naturally fixed when I move to an SQL representation of the database, anyways.

Esteban Freaking Loaiza? A 33-year-old pitcher for three years at more than 7 million dollars a year? Was he as good as any member of the A’s starting rotation last year? Sigh…

I recently lamented the design that I came up with for outputting HTML: I was combining a class accumulating HTML together with static methods that spit it out as text, leading to an unhappy marriage that I thought I knew how to deal with in C++ but couldn’t in Java.

As I said at the end of that post, though, I thought that I could come up with a reasonably elegant solution using functor classes. And thinking about it more before going to sleep earlier this week convinced me that that should work. So I tried it.

I got halfway through implementing it, though, and it just didn’t seem like it was going well. So I svn reverted, and am leaving things as is for the time being. (Nice to have a source control system that makes it easy to discard abortive experiments.) I did learn something from the experiment, though: I realized that the functor classes that I was building up was really an ungainly representation of the HTML tree. So the new solution was, in a weird way, actually moving away from the accumulating parameter solution: I wasn’t spitting out any HTML until I’d created a big, fat parse tree. It was, ultimately, a lot more like the static string solution: a bit more structure, perhaps, but the structure wasn’t easy to get at.

Which suggests yet another solution: I should separate the presentation of the HTML from its structure. So (given that there’s no performance reason that I need to spit out a textual representation of the HTML as we go), I should have static functions that, instead of returning a string representation of the HTML, return an abstract tree representation. And then I should have a Visitor that turns it into text, doing whatever prettifying it wants (indenting, turning relative links to absolute ones, etc.) at the same time. And there could be other Visitors for the parse structure – e.g. I generate a header and a title that look the same, except that the title can’t have HTML in it, so I could have a remove-elements Visitor that traverses the header to produce the title.

But that’s all a long ways off, and I may never end up doing it; I think I understand the situation well enough that it’s not bothering me any more, so until a story comes along that provides an external motivation for this split, I’ll leave well enough alone.

I just got back from jogging, for the first time in about three months. Quite a three months it has been; I can’t remember whether the first cold or the massive lice invasion came first, but both started with Miranda and were passed to Liesl and me in short order. Then Miranda came down with what we thought was another cold; when Liesl got it, it seemed more serious, keeping her home from work for much of a week (and putting a dent in our lice removal activities); when I got it, it was clearly a full-blown flu. (Doubtless it was clear to Liesl earlier that she had the flu; it’s easier to tell from the inside.)

Fortunately, the lice was in remission, because I was in no shape to help with its removal (or, for that matter, to have my hair combed: staying vertical for showers didn’t sound too smart). Then I got better, then I got dramatically worse, then it turned out I had pneumonia. I missed three weeks of work, and wasn’t up to near full strength for another four weeks. During this time, we also discovered that we hadn’t gotten rid of all the lice, so we went through another couple weeks of treatments (trying different chemicals this time).

But now I feel decent – I can imagine feeling a little better, but I don’t need much imagination to know that I could be a lot worse. There’s a strange wheeze at the end of my cough that wasn’t there before; if it doesn’t go away soon, I might go back to the doctor, but I’m not too worried for the time being. I think we’ve gotten rid of all the lice; we looked over Miranda’s hair the other day and found four eggs, but our optimistic theory is that they all contain dead lice. We shall see.

The extended family has a ways to go: I really hope the doctors can find something that will help my brother, because he’s not having much fun right now.

We ♥ Katamari is a sequel to the excellent Katamari Damacy. (I have finally given up and started spelling the second word the same way as its US publisher.) And it is everything that you’d expect from a sequel: quite good, several minor improvements, slightly worse in many ways (largely but not entirely because of the lack of novelty).

They kept the same basic gameplay, of course. And, like the original, there are core levels where you’re trying to get large enough within a time limit, as well as other levels where you have some special rules (the most common of which is that what counts is the number of items of a specific kind).

This time, they’ve added a few new special rules, some of which are kind of fun as a lark (e.g. the one where you’re on a race track and never stop moving) and some of which are annoying (the one where you’re on fire and, if you don’t pick up anything for a certain length of time, you lose). Almost all of the levels come in an easier and harder version, which is good; the main levels also come with a “double your size in a short amount of time” variant, which is bad (see below). They increased the number of places to roll in, which is good; there are only five core levels instead of the fifteen in the original, which is bad. And there’s no way to unlock an unlimited-time variant of the levels, which is bad.

Basically, they broadened the range of options, at the expense of underemphasizing the core gameplay. And, ultimately, I like rolling around well-designed levels, getting really big, and while I don’t mind a reasonable time limit, that’s not the most important thing to me. So what I want the most is the old core gameplay, where you get used to certain environments, being gradually allowed to explore larger and larger areas for longer and longer times, and where you ultimately get to unlike an unlimited time variant. So I’d trade all of the extra variants in the sequel for more and better core levels.

The cut scenes are perhaps even more pleasantly bizarre.

And then there’s the music. The original had an incredibly catchy theme, reused in many ways, with some other quite nice pieces thrown into the mix. Hard to top; it remains the only video game CD that I’ve bought. And of course it’s impossible for the sequel to live up to that, simply because it will keep the same theme instead of trying (and almost inevitably failing) to come up with a new, incredibly catchy theme. Having said that, the music is solid, and Liesl and I are big, big fans of Everlasting Love. Which might be better than any song from the original, and might (I’m not sure yet) be enough to get me to buy the CD for the sequel, too.

All in all, still a quite good game, and I’ll be happy to go another round of sequel. But I hope they emphasize the core gameplay more next time.