One for the Morning Glory

My blog has moved.

2007-11-30T20:46:00.000-08:00

My blog is now hosted over here:

http://algebraicthunk.net/~dburrows/blog

Facebook comments

2007-11-21T18:31:00.001-08:00

My blog is syndicated on Planet Debian, Planet GSLUG, and Facebook (through their "notes" system). I occasionally get a comment about one of my posts over on Facebook, and every time I do I remember one of the reasons I avoid that site.

[someone] made a comment about your note "note title".

To see the comment, follow the link below:
[link to Facebook]

What's missing here is of course the actual text of the comment. Blogger does this right: the actual comment is emailed to me. Not only does this impose the annoyance of having to click on the link, but I often read my email offline, and so a message like this is worse than useless for me. (worse as I have to postpone it for later, which means I need to deal with it twice) It would be even better if I didn't have to click to reply, but with a Web service you kind of expect that. (one of the reasons that I'll be setting up my own blog at some point: I can use software that actually allows me to compose replies offline)

I don't know why Facebook does this, but my guess is that either (a) they haven't thought about it, or (b) they want to drive up page views and make it annoying for me to not use their site. If it's (b), then that apparently works for a large swathe of the population, but it makes me want to avoid them like a bad cliche.

[EDIT] This post is attracting spam; closing comments.

Good ideas in customer service: kill the hold period

2007-11-21T18:09:00.001-08:00

The lender for one of my student loans has apparently started using a rather cool system to manage incoming customer service calls. If all the call-takers are busy, then instead of forcing you to sit there listening to a call telling you how important your business is to them, they let you request a call-back. They ask you to enter a phone number where they can reach you, then give you a time window in which they'll be calling (in my case I think it was about two minutes wide). When my turn came up, they called me and I was able to speak with a human immediately.

This is such a huge improvement over the typical call center experience that I'm amazed it hasn't caught on more broadly.

It's presumably good for them since they don't have to pay for a long incoming toll-free call, particularly when most of the call is just muzak.
It's great for me, because instead of sitting by the phone like a hawk in case I miss the customer service rep, I can go do something useful for a few minutes until the time the call is scheduled for.

I'm guessing that this option will be available in more and more places as companies computerize their telephone systems. Another nice twist, if there are any telephony guys reading this, would be to allow me to request the customer service call from a Web page, eliminating the toll-free call altogether and presumably saving some expense for the company.

An interesting question for me is how they generate those estimates of when they'll be able to help you. I'm guessing that they use some queueing theory to estimate the most likely wait time for the next incoming customer, but this is something I have only a fuzzy awareness of. However they did it, the estimate seemed accurate enough to me.

cwidget gets a Web page

2007-11-20T21:28:00.000-08:00

I spent some time last weekend putting together the infrastructure to generate a basic Web page for cwidget. The Web page is generated by Ikiwiki (thanks to the incomparable Joey Hess for a really nice piece of code there) and doubles as the cwidget documentation; it will be included in the next upload of libcwidget-doc. It can be found in the source tree under doc/ikiwiki.

It's currently a bit skeletal: in particular, it really needs some tutorial/HOWTO material for new users. But it at least has all the basic information that I personally expect from a project Web site.

I was playing with ikiwiki for a week or so prior to setting this Web site up, and the more I use it the more impressed I am. When I get my new Slicehost instance set up (probably next weekend), this blog will probably migrate to an ikiwiki installation over there. Being able to edit my posts offline (about half my hacking time is offline), being able to expose a change history for posts, and not having to maintain an installation of a monster PHP program (as the docs put it, if you don't run the CGI then ikiwiki has the security implications of cat(1)), are all absolutely killer features for me, and I look forward to expanding my use of this tool. Joey has struck gold yet again.

[UPDATE] This post is attracting spam and no real comments. Closing comments.

ANNOUNCE: cwidget

2007-11-11T18:41:00.000-08:00

I've just uploaded the first release of libcwidget to Alioth and NEW. libcwidget is a high-level C++ library for developing user interfaces that run in a terminal using curses as the display and input layer. It uses widget abstractions similar (but of course not identical) to those found in GTK+ and Qt, with signals and slots provided by libsigc++.

Background

Back when I started writing aptitude, I had one general goal:

Just because it runs in a terminal doesn't mean it has to suck.

I tried to apply this in the user interface, but I also applied it internally. The curses programs I looked at before writing aptitude all had very ad-hoc UIs. In many cases the code was structured with each "view" that appeared mapped to a custom C function call; if the author was feeling ambitious, similar-looking screens might be abstracted into a single function call, but the basic structure of the interface still reflected the call graph of the program.

aptitude had a primitive interface abstraction layer from the get-go; over the years, I borrowed ideas from GTK+ and restructured this layer into a full widget set. libcwidget is this code, disentangled from the guts of aptitude and slightly cleaned up. Because of its history, it is missing widgets that aptitude doesn't need (like a multi-line text editor), but it provides an extensible base that you can build upon.

Getting cwidget

The cwidget library is available (both as source and as an i386 .deb) from the cwidget Alioth releases page. There is also API documentation automatically generated from the upstream repository, which, while it is woefully incomplete, should provide some information: I've tried to write Doxygen tags into most of the code I've added in the last 4 years or so.

The upstream code repository is in git (because what fun is a new project if you don't learn a new VCS?) and available here. To retrieve a copy of the repository for yourself, run this command:

git clone git://git.debian.org/git/cwidget/head cwidget

Building rails

2007-11-05T19:20:00.000-08:00

In the 1860s, in the middle of one of the largest wars America has ever been involved in, a 690-mile railroad was built in a period of seven to nine years (depending on how you count), a rate of about five days per mile of track. Now, it's certainly true that this was accomplished through labor practices that were, by today's standards, more than a little bit questionable. However, I still am amazed that it's apparently going to take us twenty years to construct fifty miles of track in the Seattle area. By my count, that's a hundred and forty six days per mile of track. And I haven't even mentioned the harsh environmental conditions the transcontinental line faced, which a line in the Seattle metro area by and large does not.

I haven't decided how or whether to vote in the election tomorrow, but the timescale they're projecting is ... astonishing.

Lessig at the University of Washington

2007-11-04T11:58:00.000-08:00

On Friday 2007-11-02, I watched Larry Lessig give a presentation at the University of Washington entitled Is Google (2008) Microsoft (1998)? Since it was Lessig, the talk was articulate and thought-provoking, and he used his slides very well (unlike many presenters who just read bullet points).

The argument he made is that Google is like Microsoft in some ways (and so are other companies like Facebook). In his analysis, the problem with Microsoft was that so many companies made themselves Microsoft-dependent, which both forced other companies to follow suit (due to network effects) and gave Microsoft leverage they could use against everyone in their ecosystem (e.g., Netscape). According to Lessig, Microsoft was not evil to use this leverage, but you have to recognize that Microsoft will do what is best for Microsoft, and this may not be what is best for you. He then suggested that we should be aware of the potential for the same thing to happen; in support of this point, he quoted excerpts from the terms of service from the APIs of Google and Facebook, which contain typical statements like we reserve the right to terminate your use of this service for any reason or for no reason, and asked: What if Microsoft had written this license agreement?

But it seemed to me that this wasn't his main point. He was using this observation as a springboard to talk about issues revolving around competition and public policy. Specifically, he feels that we should work towards a more just model of interaction between companies and users whose work makes the company more valuable (by contributing to a software ecosystem, by posting content on the Web site, etc). But the correct way to do this (he says) is not via competition, after-the-fact litigation, or voluntary codes of conduct: competition may not be around to enforce good behavior (as we've seen with Microsoft), litigation may be too late and ineffective (again, see Microsoft), and voluntary codes of conduct will disappear as soon as they get in the way of the bottom line. The correct approach, he argued, is across-the-board regulation so that all the companies have to play by the same rules.

From there he went on to talk about governmental corruption. He said (quoting Robert Reich's book Supercapitalism) that the reason we consistently look for solutions in the market and in voluntary compliance is that our governmental system is broken and does not effectively regulate corporations in the public interest. But Lessig is optimistic that we can change things (he joked that his publisher was unhappy with this point of view, because his brand has been built on pessimism). In his view, the politicians in Washington, by and large, want to be honest and do good, but they aren't able to within the current political system. For instance, on the few occassions that he managed to get access to lawmakers to discuss copyright issues, it was often the first time they had heard that there was more than one side to the argument. He thinks we need a national political movement that will shame politicians into being less corrupt.

This is all a simplification of what he said, of course; unfortunately, I wasn't able to find a recording of this talk on Lessig's Web site, or I'd point you at primary source material. I don't know if this is because he chose not to post it, or because it just hasn't been made available yet.

My view

In general, I thought that the speech was very interesting and well thought out. But as much as I'd like to buy into his optimism that we can fix our system, I don't think it's well-founded, for two reasons.

First, he argued that competition will resolve some of these problems (that was before and after he said we can't rely on competition, which I found confusing and may indicate that I misunderstood something). His evidence for this seemed to be that when Microsoft was dominating the world, users responded by reducing their dependence on Microsoft products and by switching to alternatives such as Linux. But, in fact, although more people may be using Linux than in the past, virtually everyone is still only using Windows, it's still almost impossible to find a programming job that isn't Windows-only, and Microsoft is still raking in money hand over fist; indeed, they're doing so well that they're planning to expand their workforce by a third. To take just one data point of many: I ride the bus to Seattle and back, and I regularly see other people using laptops as they commute. Virtually all the laptops run Windows. Occasionally I'll see a Mac, and every few months I'll see a guy running Linux on his laptop; I say "a guy" because it's the same guy every single time. So by my estimation, use of Linux on laptops in buses on the 545 route from Redmond to Seattle is way below 1%, with Macintoshes somewhere around 5%.

To broaden my point, I think Lessig has fallen into a trap that highly intelligent people, particularly those in academia, tend to fall into. In academia, you are surrounded by people who value learning and thinking deeply about the world. These are people who will give serious and unbiased consideration to questions like what is the social effect of my acceptance of the Facebook Terms of Service? and If I become dependent on this service, will that possibly affect me in five years if the company decides to act against my interests? The problem with this is that these people are not representative of the population at large. The population at large thinks why is this check-box getting in the way of me sending pictures to my friends? And I have no doubt that any kid who, e.g., refuses to sign up for Facebook as a protest against their TOS will be roundly mocked in their social circles for being a weird antisocial nonconformist. (of course, this may not apply to the small minority of people like myself whose social circles consist of weird antisocial nonconformists)

Second, Lessig's optimism about the political system seemed to be based on his observation that the people in government are, by and large, not venally corrupt: they want to do good, but the system is constructed in a way that makes this impossible. To me, that's a tremendously disheartening statement. If our problem were simply a few, or even many, corrupt politicians, this would be a solvable problem: even nowadays, Americans have some ability to choose who gets elected, and I believe that a sufficiently well-coordinated campaign could replace bad politicians with good ones.

But if the problem is that the system is corrupt even when the individuals are honest, it's a much deeper problem and frankly one that I don't know how to solve. While individuals have some direct control over who gets elected, we have no way to directly change the system that produces the corruption; the levers to do this are in the hands of the politicians elected through that broken system. It's unlikely that the politicians themselves will fix the problem, because they've benefited deeply from it: if the system is left as it is, well over 90% of Congress members will keep
their jobs in the next election cycle, and any effective change seems likely (by definition) to disrupt this cushy arrangement.

On the other hand, running new candidates for office will not fix the problem. After all, if the problem is that the system is corrupt even when the participants are honest, then putting more honest people into government will have no effect. In order to get elected, these new politicians will have to become just as corrupt as the old ones, because that's how the system is set up. So we might change the faces, but we'll have the same old problems.

I recall two specific concrete proposals that Lessig made to make the system more responsive. First, he suggested shaming politicians who engage in corrupt behavior -- presumably taking large donations from interested parties. I don't see how this will help. Americans generally have a very low regard for the political class as it is; will pointing out particular examples of politicians taking money really make a difference when it comes to votes? And if it doesn't, will it really produce any change in their behavior? Politicians are motivated by votes the same way corporations are motivated by money; unless they stand a chance of losing their job (which is virtually impossible in any event), there's no reason for them to change how they behave.

His second proposal was for a system of contributions where it's impossible for any individual to prove they had donated a particular amount of money to a particular candidate. Even assuming it could be implemented perfectly, I don't think this will really solve the problem, for two reasons. First, it's not generally a secret what moneyed interests want. Politicians who want to attract large donations can just take positions that they know will appeal to donors of that sort. The donors themselves can make this easier on the candidates by, e.g., posting public position statements on issues of the day. Secondly, and this is far more insidious, even if politicians honestly represent their positions, then because success in running for office is so tied to the amount of money the candidate can raise, only candidates who hold opinions favorable to large corporations and wealthy individuals will be able to get elected. In fact, for all I know this is what happens already!

But with all that said, it was a really interesting talk and Lessig tied together some things you might not think would go together. If a video or Flash presentation becomes available, I would recommend watching through it. And hopefully my pessimistic predictions will be wrong; it's certainly happened before.

Mail

2007-10-31T05:57:00.000-07:00

Amusing tidbits you pick up in the mailing industry...

No, you can't mail running chainsaws. At least I'm pretty sure about that; I don't know a specific regulation against them, but USPS takes a dim view of anything that puts its employees and machinery at risk.

On the other hand, you can mail live scorpions if you package them appropriately. Note that, however, that this is limited to the US; apparently doing so in Australia is not a good idea. The same page also gives the rules for mailing baby chicks (which must be not more than 24 hours old) as well as adult chickens (Express Mail only, please; and no refund if the chicken dies in transit unless the container was damaged).

Here we go again...

2007-10-30T21:02:00.000-07:00


[10/30/2007]
Version 0.4.7                               "Where did all these
                                             balloons come from?
                                             And why am I wearing
                                             a fake nose?"

- New features:

  * The options dialogs have been completely replaced by a new
    interface, based on a top-level list view.  This fixes many
    deficiencies of the old interface: it handles long strings more
    gracefully, avoids many of the focus-handling bugs that the old
    dialogs had, and should generally be better-behaved.
     (Closes: #197976, #331200, #424708)

  * Prompts that ask you to enter text will now wrap to multiple lines
    when the text gets long, rather than hiding parts of the string.

  * The online help and other Help-menu itmes are now top-level views,
    which should make them somewhat more usable. (Closes: #434349)

  * Support for the "Breaks" field and for trigger states (thanks to
    Michael Vogt and Ian Jackson for patches and prodding).
    (Closes: #438543)

  * Two new styles, "PkgDowngraded" and "PkgDowngradedHighlighted",
    are provided to control how downgraded packages look.  By default
    these packages look like any other installed package.
    (Closes: #434442)

  * aptitude can now display homepage URLs stored in the Homepage
    field of packages.

There are bug-fixes too, but those aren't as fun. So instead I think I'll include some diffstat output. Everyone likes diffstat!


daniel@alpaca:~/programming/aptitude/head$ hg diff -r 0.4.6.1:0.4.7 | diffstat
 .hgtags                                       |    1 
 NEWS                                          |   92 +
 b/src/apt_config_treeitems.cc                 |  477 ++++++
 b/src/apt_config_treeitems.h                  |  156 ++
 b/src/generic/util/browser.h                  |   42 
 configure.ac                                  |   20 
 doc/en/aptitude.xml                           |  187 ++
 help-fr.txt                                   |   10 
 po/ChangeLog                                  |   24 
 po/dz.po                                      |  188 +-
 po/es.po                                      |   82 -
 po/gl.po                                      |   19 
 po/ne.po                                      | 1277 +++++++++--------
 po/pt.po                                      |   20 
 po/ru.po                                      |   97 -
 po/sv.po                                      | 1854 ++++++++++++--------------
 po/zh_CN.po                                   |   23 
 src/Makefile.am                               |    2 
 src/apt_info_tree.cc                          |    4 
 src/apt_options.cc                            |  598 +++++---
 src/apt_options.h                             |   12 
 src/cmdline/cmdline_action.cc                 |    6 
 src/cmdline/cmdline_check_resolver.cc         |    2 
 src/cmdline/cmdline_do_action.cc              |  134 +
 src/cmdline/cmdline_prompt.cc                 |  124 -
 src/cmdline/cmdline_search.cc                 |    4 
 src/cmdline/cmdline_show.cc                   |   20 
 src/cmdline/cmdline_why.cc                    |   64 
 src/defaults.cc                               |    4 
 src/dep_item.cc                               |    1 
 src/desc_parse.cc                             |    2 
 src/generic/apt/apt.cc                        |   32 
 src/generic/apt/apt.h                         |   30 
 src/generic/apt/aptcache.cc                   |   54 
 src/generic/apt/aptcache.h                    |   21 
 src/generic/apt/aptitude_resolver_universe.cc |   28 
 src/generic/apt/aptitude_resolver_universe.h  |   57 
 src/generic/apt/infer_reason.cc               |   22 
 src/generic/apt/log.cc                        |    8 
 src/generic/apt/matchers.cc                   |  531 +++++--
 src/generic/apt/matchers.h                    |   28 
 src/load_grouppolicy.cc                       |   25 
 src/menu_tree.cc                              |   12 
 src/pkg_columnizer.cc                         |   19 
 src/pkg_grouppolicy.cc                        |   27 
 src/pkg_grouppolicy.h                         |    9 
 src/pkg_info_screen.cc                        |   10 
 src/pkg_item.cc                               |   31 
 src/pkg_item.h                                |    7 
 src/pkg_subtree.cc                            |   22 
 src/pkg_subtree.h                             |   12 
 src/pkg_tree.cc                               |    4 
 src/pkg_tree.h                                |    1 
 src/pkg_ver_item.cc                           |   31 
 src/pkg_ver_item.h                            |    5 
 src/pkg_view.cc                               |   24 
 src/reason_fragment.cc                        |   10 
 src/solution_fragment.cc                      |    5 
 src/solution_item.cc                          |   76 -
 src/solution_item.h                           |   14 
 src/ui.cc                                     |  179 +-
 src/vscreen/fragment.cc                       |  140 +
 src/vscreen/fragment.h                        |   40 
 src/vscreen/ref_ptr.h                         |    5 
 src/vscreen/testvscreen.cc                    |   20 
 src/vscreen/vs_editline.cc                    |  310 +++-
 src/vscreen/vs_editline.h                     |   33 
 src/vscreen/vs_tree.cc                        |  113 +
 src/vscreen/vs_tree.h                         |   40 
 src/vscreen/vs_treeitem.cc                    |    4 
 src/vscreen/vs_treeitem.h                     |   21 
 src/vscreen/vs_util.cc                        |    1 
 72 files changed, 4853 insertions(+), 2754 deletions(-)

Just rub it in, why don't you!

2007-10-30T20:35:00.001-07:00

One of my co-workers told us about a message he saw posted on a British message board about Royal Mail. For people whose job does not involve postal systems, Royal Mail is the semi-governmental semi-monopoly that handles mail in the UK; it's a little like the USPS in the States.

The funny thing about the message had little to do with the mail: apparently the poster was saying that Royal Mail's standards have deteriorated because he can no longer pick up his mail at 9:30 AM, before he goes to work. Dude! You don't even have to leave for work until 9:30 and you're complaining about when your mail comes?

I bet he gets four weeks of paid vacation, too, and then complains about how that isn't enough.

Mercurial repositories for the aptitude Debian tree now publically accessible

2007-10-13T19:50:00.001-07:00

Since I switched the aptitude repositories over to Mercurial, I've been using hg-buildpackage to produce Debian packages. I wasn't sure at first if it would work out, so I didn't publish the repositories, and then I got swamped with work. But I've had good luck so far with hg-buildpackage, so I've uploaded the Mercurial trees to Alioth. You can find the upstream branch here:

http://hg.debian.org/hg/aptitude/debian-upstream

and the Debian branch here:

http://hg.debian.org/hg/aptitude/debian

Monad.Reader

2007-10-13T14:16:00.000-07:00

The Reader monad is a simple and easy-to-use structure from the Haskell library that solves a common problem.

Very often, it's the case that you have a lot of functions that all need to use the same values. For instance, you might be laying out some text on a page, and you need to keep the details of the page size around in all your layout algorithms. Typically, you handle this situation by adding a new parameter to all your functions which represents the state. So,


layoutPage :: Text -> Page

becomes


layoutPage :: PageLayoutParams -> Text -> Page

This works just fine, but it can get really ugly. Every single function gets a new parameter, which must be threaded through to every related function that it ever calls. This causes visual clutter, particularly for functions that don't actually use the parameter themselves but just pass it on.

A function written in the Reader monad is augmented with a hidden parameter. For the hypothetical example above, we would write:


import Control.Monad.Reader
type LayoutFunc = Reader PageLayoutParams

layoutPage :: Text -> LayoutFunc Page

Note that the Reader monad is partially applied here. The result, LayoutFunc, is a new monad that adds a parameter of type PageLayoutParams to any code that runs inside it.

So, now that we have this monad, how do we use it? The "ask" operation retrieves the parameter that's hidden in the monad:


ask :: Reader a a

or, specialized to LayoutFunc:


ask :: LayoutFunc PageLayoutParams

In order to remain close to the example in question, I will provide specialized type signatures for the rest of the library functions. You can find the generic type signatures in the Haskell library documentation for Control.Monad.Reader.

Suppose that layoutPage started out like this before it was moved into the monad:


layoutPage st txt =
  let width = pageWidth st
  ...

In the Reader monad, this becomes:


layoutPage txt =
  do st <- ask
     let width = pageWidth st
     ...

As you can see, we've gone from one line of code to two. As this is clearly unacceptable for a clutter-reducing device, the Reader module provides a convenience function encapsulating the above pattern:


asks :: (PageLayoutParams -> a) -> PageLayoutFunc a

This allows us to simplify the monadic implementation to:


layoutPage txt =
  do width <- asks pageWidth
     ...

It's quite common, when multiple functions share context information, to invoke a function in an altered context. For instance, we might have a layoutSubPage routine that changes the page width:


layoutSubPage st newWidth txt =
  doLayout (st {pageWidth = newWidth} txt)

The Reader equivalent of this idiom is the function "local":


local :: (PageLayoutParams -> PageLayoutParams) -> LayoutFunc a -> LayoutFunc a

local executes an operation in a context modified by its first parameter. For instance,


layoutSubPage newWidth txt =
  local (\st -> st { pageWidth = newWidth }) txt

Finally, to actually invoke a computation in the Reader monad, use runReader:


runReader :: LayoutFunc a -> PageLayoutParams -> a

main = showPage (runReader defaultPageParams someText)

For much more information on the Reader monad, see All About Monads, or the Haskell library documentation.

Science: who does it, why?

2007-10-10T18:37:00.000-07:00

On the topic of "why so few scientists are women", I recently came across a rather thought-provoking article (thanks Erinn). It's worth a read, especially for anyone (man or woman) that's thinking about heading into academia.

Feline Love

2007-10-03T20:40:00.000-07:00

Coding while a cat kneads your chest: awkward.

Coding while a cat sleeps on your face: difficult.

Coding while a cat nibbles on your fingers: painful.

Coding with a cat snuggled up against your side: adorable.

What were they thinking?

2007-09-04T07:46:00.000-07:00

If you're going to build a computer case that looks like a media player ...

and if you're going to include a big volume control and an LCD player on the front ...

then aren't some buttons like "play", "next", and "pause" also a good idea?

I ask because I was browsing computer cases at the store yesterday, and apparently no-one working for the companies that design these things has thought of including some control buttons on front. To me, this seems like it would rank somewhere in the top 10 most obvious ideas ever, somewhere below "eat when you get hungry" and above "don't pick a fight with a grizzly bear", but clearly I'm missing something.

Seattle LUG meeting

2007-08-30T20:31:00.000-07:00

The Seattle Linux user's group has been defunct for the last two years or so, but an effort is underway to renergize it. This Saturday, the group will be meeting for the first time in years. The meeting will take place at the North Seattle Community College beginning at high noon -- check the official Web page for more details. TBH, the presentations don't look that interesting to me, but it's always fascinating to meet people who actually use Linux...

Yes, I'll be there, but I'm not giving any of the presentations, so please don't let that keep you away. ;-)

Do not install aptitude 0.4.4-4b+1!

2007-07-01T18:12:00.000-07:00

Apparently someone decided to resolve the dependency problems with aptitude in unstable by doing a blind recompile and NMU of the package, presumably because of my horrible laziness in not doing an upload to unstable yet. The problem, as I wrote in the bug reports regarding the need for a recompile, is that this produces a package that's totally unusable, which is why I didn't do it myself. If you are running unstable, you should either not upgrade the apt system, or install the experimental aptitude (either using "apt-get install aptitude/experimental" or by going here). These packages are not perfectly stable, but they also aren't totally unusable.

I apologize for the inconvenience -- if I can get some time this evening I'll rebuild the aptitude in experimental and throw it kicking and screaming into unstable.

Jealousy

2007-06-21T22:30:00.001-07:00

I've been suffering for a while from mild jealousy of the people who have a spare week of vacation time to make it to Edinburgh for DebConf. (is there a support group for this? :) ) But now I read that some people apparently have so much time off that they travelled to Edinburgh a full week ahead of time, just because, y'know, they could. Darn Europeans.

But then, I only have to work for another year and a half before I qualify for another whole week of vacation time, raising the total to three weeks off per year. Maybe I can make DebConf 2009, assuming that President Hillary doesn't invade Luxembourg or something...

Fun with Functions

2007-06-19T20:31:00.001-07:00

Pete Nuttall writes about the fnreduce function:

fnreduce :: [(a->a)]->a->a
fnreduce [] value = value
fnreduce (a:as) value = freduce as $ a value

A shorter, although not necessarily clearer, expression of this function would be

fnreduce as value = (foldr (flip (.)) id as) value

This just says that to apply a list of functions to a value, we first compose all the functions by folding down the list, then apply the result to the value. The important thing here is (flip (.)), which says to compose backwards; it means that fnreduce [f, g, h] returns (h . g . f . id) instead of (f . g . h . id). An interesting side note is that it doesn't matter (from a semantic point of view) whether I use foldl or foldr, since function composition is associative:

f . (g . (h . id)) = ((id . f) . g) . h

But "flip" here feels a little confusing. A clearer approach would be to reverse the list instead of reversing the operator:

fnreduce as value = foldr (.) id (reverse as) value

This might be less efficient, but it says in a much clearer way what I'm doing.

Yet another option is to eschew the use of function composition:

fnreduce as value = foldl (flip ($)) value as

Here ($) is the application function; (f$x) applies f to x. So if we reverse it (call this $$), we get (x$$f) applies f to x. Folding this from the left down the list [f, g, h] gives us (((value$$f)$$g)$$h), which is exactly what the original fnreduce did.

I think this is maybe the best fold-based solution to the original problem, because it models what's happening (repeatedly transforming a value with a series of functions) directly. To use a right-fold, you have to remove the flip and reverse as (the reason this is necessary is left as an exercise to the reader).

Pete also asks whether this can be done for heterogenous lists in a type-safe manner. The core problem is, what is the type of our list? It can't actually be a list: in order to check that it's OK to combine the output of one function with the input of another, we would need the elements of the list to have different types. You can't do this in Haskell, even a crazy ghc-extended Haskell.

So, we could try something like this:

module Test where

data TransformList a b where
    Nil   :: TransformList a a
    Cons  :: (a -> b) -> TransformList b c -> TransformList a c

apply :: TransformList a b -> a -> b
apply Nil         = id
apply (Cons f fs) = (apply fs) . f

This lets us do stuff like

> apply (Cons (\x -> x + 1) (Cons (\x -> show x) Nil)) 5
"6"

This is cute, but I don't know that it's really that useful. After all, how is it any better than the following?

> ((\x -> show x) . (\x -> x + 1)) 5
"6"

Everything the above code lets you do with TransformList could just as well be done with the humble compose operator. The only benefit would be if we could somehow do "list-like" stuff with a transform list. For instance, say we want to write the following function:


traceIntermediates Nil        x = (x, [])
traceIntermediates (Cons f l) x = let x'        = f x
                                      (x'', ss) = traceIntermediates l x'
                                  in
                                    (x'', (show x'):ss)

This won't compile, because we don't know that x' is a member of the Show typeclass. And there is no way to fix this in a reusable way using any technique that relies on building a type parameterized on the input and output types: the problem is that we need to say something about the types of the intermediate values, but their type variables are inaccessible.

In other words, there isn't any way to write down a constraint on the type "TransformList a b" that constrains the intermediates. So I've just wasted a lot of typing duplicating the compose operator. Yay.

On the other hand, it's entirely possible to do this if you don't mind some boilerplate code.

data ShowTransformList a b where
    Nil   :: (Show a) => ShowTransformList a a
    Cons  :: (Show a, Show b, Show c) => (a -> b) -> ShowTransformList b c -> ShowTransformList a c

traceIntermediates :: ShowTransformList a b -> a -> (b, [String])
traceIntermediates Nil        x = (x, [])
traceIntermediates (Cons f l) x = let x'        = f x
                                      (x'', ss) = traceIntermediates l x'
                                  in
                                    (x'', (show x'):ss)

apply :: ShowTransformList a b -> a -> b
apply Nil         = id
apply (Cons f fs) = (apply fs) . f

Now I can do this:

> traceIntermediates
    (Cons (\x -> x + 1)
          (Cons (\x -> x * 2)
                (Cons (\x -> x - 5)
                      (Cons show
                            (Cons (read :: String -> Double)
                                  Nil))))) 5
(7.0,["6","12","7","\"7\"","7.0"])

Freudian slips in commit messages

2007-06-17T21:53:00.000-07:00

changeset: 700:d8308a89c519

user: Daniel Burrows

date: Sun Jun 17 16:22:43 2007 -0700

summary: Call pre_package_state_changed() before undoing, to resent the dependency resolver; call package_state_changed() after an undo if necessary.

aptitude development moves to Mercurial, back to Alioth

2007-06-16T21:51:00.000-07:00

Short version: the aptitude development tree is now maintained using Mercurial, go here to fetch it.

aptitude development has been using darcs as a version control system for the last two years. Darcs is a distributed version control system with many great concepts -- but it has one huge, glaring, enormous flaw, which is that innocuous operations, like merging one branch into another, can require practically unbounded amounts of time and space. And once two branches get screwed up in this way, there is nothing, nothing at all, that you can do to get yourself unwedged; the cause is a design flaw in darcs that no-one seems to know how to fix or work around.

Recently, I made the mistake of changing some files in both the Debian branch of aptitude and the head branch, and when I tried to merge the two branches to upload a new upstream release, darcs went off into la-la land. So, I figured that it was probably time to switch version control systems.

I'd like to say that I did extensive research on the matter, but the truth is that I chose Mercurial based on the fact that (A) a lot of ex-darcs users have written nice things about it, (B) git and arch-derived systems always feel ugly to me, and (C) John Goerzen implemented support for mercurial on Alioth. Yes, I am so a follower.

So if you want the up-to-date aptitude source, you should go to http://hg.debian.org/hg/aptitude/head. You can also fetch an RSS feed from http://hg.debian.org/hg/aptitude/head?style=rss.

You can fetch a copy of the repository with "hg clone http://hg.debian.org/hg/aptitude/head aptitude-head". To update, I recommend putting the following lines in ~/.hgrc to enable the "fetch" extension:

[extensions]
hgext.fetch =

Once you've done this, just run "hg fetch" and it should download and merge the latest code. You may want to install kdiff3 to get a better merge tool as well.

To commit a patch locally, run "hg commit". Unfortunately, there doesn't seem to be any easy way for people to send patches back within the VCS like there is for darcs (one of many nice features I had to give up in favor of being able to actually get work done -- what, me bitter?), but it looks like you can get somewhere with "hg bundle <file>", then mailing the resulting file off.

Dear Lazyweb: Mercurial Python API

2007-06-10T21:33:00.000-07:00

So, in the midst of trying to convert some Darcs repositories to Mercurial repositories (see here for the reason), I hit an "interesting" bug: tailor processes "rename" patches by deleting the renamed file. A little debugging later, I get to this simulation of what tailor does:


>>> from mercurial import hg,ui
>>> uio = ui.ui(debug=True,verbose=True)
>>> r = hg.repository(ui=uio, path='.', create=True)
>>> f = file('A', 'w')
>>> f.write('Some data\n')
>>> f.close()
>>> r.add('A')
>>> r.commit(text='Add A')
A
'i\xe9\xb4\xc8\x9d\xb8\xeb<\xbe\xb1k\xae\xb1\x182\xa9ao\x80\xd0'
>>> r.copy('A', 'B')
B does not exist!

Huh? Of course B doesn't exist, that's why I want to create it! So, we look at the code in localrepo.py to handle copying...


    def copy(self, source, dest, wlock=None):
        p = self.wjoin(dest)
        if not os.path.exists(p):
            self.ui.warn(_("%s does not exist!\n") % dest)
        elif not os.path.isfile(p):
            self.ui.warn(_("copy failed: %s is not a file\n") % dest)
        else:
            if not wlock:
                wlock = self.wlock()
            if self.dirstate.state(dest) == '?':
                self.dirstate.update([dest], "a")
            self.dirstate.copy(source, dest)

Double huh?

Why is this method checking whether the destination exists before it does anything? It appears to me that this is actually necessary; just disabling this test leads to a crash later.
How does mercurial work at all with such huge breakage in its core code? Does /usr/bin/hg use a different implementation of the repository code than mercurial.hg?
Why, in the name of $DEITY, is this a warning and not a fatal exception? One example of what happens when you don't signal to your users that you're ignoring them is this bug: tailor happily goes ahead and removes the original file, safe in the knowledge that mercurial has copied it to the new location. Except, of course, that mercurial hasn't actually copied it. Whoops.

I'm hoping that someone will tell me that it's just too late at night for me and I'm being an idiot. Please tell me this. It would make me very sad if code like that was in my VCS.

:-( <--- sad Daniel

Closing bugs just because they're old is not cool

2007-06-10T11:11:00.000-07:00

Two bug reports that I wrote were recently closed with the following explanation:

Last message was posted nearly three years ago. Considering abandoned and closing.

Whoops, I thought, I must have missed a request for more information. So I went to the bug page and, nope, the only message on the bug was my initial report.

Let me repeat that: the total sequence of interactions on these bugs was:

I report a bug in 2004
Someone closes it in 2007 because it's "too old".

Now, there are times when it's at least somewhat excusable to close old bugs without verifying that they're fixed (or even knowing that they might not be). When a package has hundreds of bug reports, closing old bugs that can't be reproduced can be a good thing: even if the reports are valid, keeping reports that can't contribute towards a fix around is arguably less useful than cleaning out the bug list so it's usable.

In my case, though, the package in question has only 20 or so bug reports, an easily managed number. Worse, both bugs I reported could be trivially reproduced. One of them was arguably not a bug, but the guy who closed my bugs did not argue that; as far as I can tell, he didn't even look at my bug report.

Notice that I haven't mentioned the maintainer of the package? That's because he didn't close the bug. In fact, the person who closed the bug is not a member of Debian, nor is he in the NM process. Evidently he's just a random user who decided that old bugs offend him, so they should be closed.

So please, everyone, exercise a modicum of common sense when it comes to closing bug reports. This will keep the BTS useful for all of us and keep blood pressures at a reasonable level. :)

Blogger annoyingness

2007-06-08T21:01:00.000-07:00

Two days ago, I noticed that a post from last year about my wallet getting stolen had attracted over 60 spams. So I went in, deleted all of them individually (because I can't select multiple comments to delete in Blogger), then closed comments on the post.

This morning, I caught up on my Planet Debian email, and discovered that Blogger had decided to make that post "new", so it showed up on Planet again! Argh!

So don't worry, I didn't lose my wallet again. Blogger is just nuts.

The virtues of limited terminal width

2007-05-23T20:41:00.000-07:00

I've noticed that a great benefit of reading mail in an 80-column X terminal is that it acts as a simple filter: if a thread drifts so far to the right that I can no longer read the Subject: line, it's probably not worth my time to read it and I can kill the whole thing.

I wonder what sorts of gains in free time and productivity I could realize by shrinking my terminals to widths of 70, 60, or even 40 characters wide?

System 76

2007-05-15T21:49:00.000-07:00

I've got a new desktop system, after going two years without a desktop at all. My last desktop, which served me well for about five years, was one that I built myself from parts. This time, though, I was feeling a little lazy, and I decided to order a computer from System 76, one of the few companies that will assemble and ship a computer to you with Linux (in this case, Ubuntu) preinstalled.

The cats were curious about something new appearing in our apartment. They were even more excited when they found out it was full of cat toys! Sadly for them, though, I confiscated all the styrofoam peanuts and stuck them in a cat-proof trash can.

The usual box of random CDs still exists when you have preloaded Linux. I was surprised to discover that it did not include an Ubuntu CD or five, which seems to me like a no-brainer.

Of course, this post wouldn't be complete without a picture of the actual box. It looks just like it did on the system76 web site; no surprise there.

I used the included Ubuntu install for a little while, and it looked like everything was configured reasonably well. The one piece of weirdness was that Ubuntu uses a program called network-manager to configure the network; while it has some nice features (like doing network discovery for wireless, letting programs easily get notifications when network devices go down or come up, etc), these are offset, at least for me, by the fact that it likes to randomly break the computer's network access. This isn't exclusively an Ubuntu problem, of course; etch also installs and configures network-manager by default, and I had the same problems on etch until I purged it. I assume that network-manager works for someone, so probably something to do with the network environment here breaks it.

The system is currently running Debian etch, with Xen domains booting testing and unstable that I use for development. Even without the NVidia graphics drivers and with one of the Xen domains running a computationally intensive job, it's quite snappy; a lot snappier than any other desktop system I've owned recently. And while it's doing this, it's one of the quietest computers I own.

So, in summary, I'm quite happy with this system and I'd suggest System 76 as an option for anyone who wants a Windows-free computer.

Wikified aptitude TODO list.

2007-04-21T11:59:00.000-07:00

I've been able to crib more time lately for Debian, so I'm hoping that I can stop just keeping my head above water (barely) and start on the pile of new work that I'd like to do. For a while I've been accumulating a mental list of stuff that sucks in aptitude, but mental lists have the drawbacks that no-one else knows about them and that they never seem to be available when I want them.

I've now got a nice page in the Debian wiki holding aptitude's current TODO list. The entries range from changes that are trivial but will improve the user experience, to deep and difficult changes that no-one will notice. Since I don't expect a team of magic pixies to do the coding for me, I figure I might have the majority of the design and coding done in a year or so.

How not to impress your customers.

2007-04-15T08:28:00.000-07:00

So, today I tried to sign up for a service online (unidentified for reasons that will become obvious briefly). This is a service that, had I successfully signed up, would be withdrawing monthly subscription fees from my bank account and handling some data that's fairly important to me. But when I hit the button to start the registration process, I got back...

[TCX][MyODBC]You have an error in your SQL syntax. Check the manual that corresponds to your MySQL server version for the right syntax to use near ''7GDiSp=E8-Mgvgo\', Now() )' at line 9

SQL = "INSERT INTO [REDACTED] ([REDACTED], FieldName, FieldValue, update_dt ) VALUES ( 10724, 'PASSWORD', '7GDiSp=E8-Mgvgo\', Now() )"

The password I tried to enter, for the record, was 7GDiSp=E8-Mgvgo\#dEwb8m7Ec_e~z0myAAj. This is at best inexcusable sloppiness and at worst a security hole, and I don't want a company that does either anywhere near my money and data. (sadly, there probably are already many such companies near my money and data, but I try to avoid the ones I know about)

coq's -ness-nesses

2007-04-12T20:33:00.000-07:00

In response to Stefano's reply to my post about Coq:

toy-ness

Usually such pieces of software are more seen as academic toys, seeing it promoted as a geeky software is a joy to me.

I really hate to detract from your happiness -- but I definitely had the word "math" implicitly stuck before "geek toy". :) Most coders that I've met are, at best, indifferent to mathematics, outright hostile at worst, so I doubt that coq will get far outside of small niches where the benefits are irresistable (security software, maybe? -- and of course pure math). I read up on this stuff despite it being utterly useless for anything I'm likely to be paid to do (unless I return to academia) because I'm a hopeless weenie loser who likes math. :P

programming-language-ness

Coq is not really a programming language (even if the CoqArt book says so, to attract the developer community), it is mainly a proof assistant; i.e. a software in which you give definitions, state theorems and prove them.

Well, this all depends on how you define programming language, which is one of those never-ending definitional questions. But using my general conception of what a programming language is, I actually have noticed two programming languages inside Coq.

The more interesting one (IMO) is the proof language they call "Gallina" and the "Vernacular", in which you construct proofs by reducing your goal to a tautology. The goal here seems to be to compute a well-typed term in Coq's core calculus, and you generally construct programs interactively: Coq shows you the current program state (expressed as one or more goals and a set of local hypotheses) and you manipulate it by (e.g.) applying lemmas to yield new known facts.

I think this language is fairly weak viewed as a programming language. It's completely unreadable and the proofs generated don't correspond to the reasoning process one normally follows when working out a proof. I am less annoyed by it now that I've learned how to do forward reasoning :), but it seems like backwards reasoning is really pushed, and that just seems .. well .. backwards to me. There's also a strong tendency to use implicitly generated names for things and to just "know" what the state of the system after issuing a command will be; as far as I can tell, the only way to understand a Coq proof is to step through it in coqide.

While it's nice to be able to "trust the kernel", it would also be nice to be able to "read a proof" directly. Among other things, their inscrutability makes me think that Coq proofs would be annoying to maintain over time. This is not necessary for stuff that's part of Principia Mathematica, but seems likely if you're developing a new theory -- in particular, I would shudder (theatrically) at the mere thought of including embedded Coq proofs in my programs.

Some additional brief comments on this were written by Nick Benton and put on the Web under the title of Machine Obstructed Proof.
The other sense is that Coq directly embeds a strongly normalizing variant of System F (I think? -- at least the simply typed LC with some type parametricity) with primitive recursion over inductive structures. This isn't Turing-complete (of course!), but I would certainly call it a real programming language.

As you note, though, this is less interesting unless you want to prove facts about your programs.

OCaml-ness

Regarding the synergy of Coq with OCaml: yes, you can prove in Coq the correctness of OCaml program, but actually not more than you can do with programs written in other programming languages

I was specifically thinking about Concoqtion; I have no idea how other projects compare, and I apologize if I incorrectly summarized it!

Wikipedia is case-sensitive, who'da thunk?

2007-04-11T21:28:00.000-07:00

This is part of my ongoing series of posts wherein I am the last person on the planet to discover various things. (this is not a planned series, it's just how life is. :) )

If I ask Wikipedia about Virtual Server, I get an article about a Microsoft Hproduct. If I ask it about Virtual server, I get a page on server virtualization. Presumably if you know enough Wiki-lore, this makes sense.

Unsurprisingly, neither article gives me a clue about how I might go about renting a virtual server to avoid the hassle of maintaining hardware or which providers (if any) are reasonably trustworthy.

Latest Shiny Geek Toy: coq

2007-04-09T20:27:00.000-07:00

So, one of the reasons I've been a bit uncommunicative the last few weeks is that I've been getting my head around Coq, maybe one of the most fascinating pieces of software I've played with in a long time.

What is Coq? I don't know if I understand it well enough yet to give a complete description (the Coq tome only arrived in the mail on Friday and I have yet to make it past the introduction, what with taxes and so on). Here's my best shot:

Coq is a programming language where you write proofs as functions taking proofs of their preconditions and producing proofs of their results. That is, a proof that "If X is an integer, then X-1 < X" becomes a function that accepts a proof of "X is an integer" and produces a proof of "X-1 < X".

You can manipulate logical expressions more or less the way you expect. For instance, if you have in your hands a set S of natural numbers and a proof that "forall nonempty sets T of naturals, T has a least element", then you can bang these together to produce the least element of S (or rather, a proof that it exists).

I don't think this describes the theoretical underpinnings of Coq, but it does describe my experience of actually using it to prove stuff.

To get the hang of Coq, I'm working my way through basic automata theory -- regexps are done, but I couldn't work out how to express some finiteness constraints on FSMs without generating a lot of extra typing; hopefully the Coq book will have some hints. Once that's done, I'm actually tempted to try something more ambitious. [snip long digression] We'll see ... watch this space :).

It was a real rush, though, to code up these theorems and watch the computer verify them. What really fascinated me was how close to being a practical tool this is. Coq isn't at all a toy -- without quite getting all the theory yet, my intuition is that it can probably cover anything you can express in the predicate calculus (with sufficient amounts of typing, anyway), and while there are a few shortcomings, it's almost (IMO) at the point where anyone who knows some formal logic and has a little patience can prove interesting stuff. Even more suggestive of possibilities, there's a project (which I sadly haven't had time to look at) that integrates Coq with OCaml, so you can have proofs about your OCaml code verified at compile-time!

I could go on and on ... anyway, this is a really cool tool and I'd encourage any mathematically-minded person to give it a spin. The only sad thing is that I doubt I'll ever have the opportunity to explore this stuff in my day job unless/until I go back to school :-(.

Shortcomings of Coq specifically and the whole concept of correctness proofs on programs generally have been moved to a future blog post that may never appear depending on how ambitious I'm feeling this week. Rest assured that I'm aware of (some of) them, I just hit my self-imposed length limit.

[0] the reason being that I could only prove correct the formal underpinnings of the resolver; in practice, a lot of the bugs are in the interface to apt, or in apt itself, and I can hardly prove that code correct.

On emailing me.

2007-03-28T20:27:00.000-07:00

Verizon has apparently decided that BOTH of my forwarding addresses, dburrows@debian.org and Daniel_Burrows@alumni.brown.edu, are actually spammers, and is randomly rejecting some emails sent to them. I have given Verizon as large a piece of my mind as they allow: they do not provide an email address, and instead put up a form where they graciously allow you to type a 70-character (!) message. This will presumably go straight into the bitbucket, but we'll see.

If you want to email me, please send mail directly to Daniel_Burrows@verizon.net.

Does anyone know of a broadband ISP serving Redmond that doesn't suck? As far as I know, my only alternative to the telephone monopoly is the cable monopoly.

Where have all the bytes gone?

2007-03-12T20:50:00.000-07:00

Here's an "interesting" phenomenon I noticed on my new (not-Linux-hating) 4GB portable music player:

daniel@jeeves:~$ df -h /media/IAUDIO
Filesystem Size Used Avail Use% Mounted on
/dev/sdb 3.8G 3.8G 0 100% /media/IAUDIO
daniel@jeeves:~$ du -hcs /media/IAUDIO
2.3G /media/IAUDIO
2.3G total

Just in case "df" and "du" had different notions of how large a gigabyte was, I asked them to tell me the number of bytes instead, with about the same result.

I won't comment on the fact that I paid for 4GB but got 3.8GB; that's typical (whoops, I just did). But where'd that extra 1.5GB go? FAT can't seriously be imposing a >50% overhead on file size, can it?

The end result here is that on my 4GB music player, I can store only a little more than 2GB of music. Boo. :-(

[UPDATE]: running fsck revealed that I had 1.5 GB in lost clusters on this filesystem and gave me my space back. Since this device is almost brand-new, I'm puzzled about how this happened...but oh well, it seems to be fixed easily enough.

Project get-in-shape

2007-02-04T20:07:00.000-08:00

My project the last few weeks has been to start exercising at a gym regularly. While I could stand to lose a few pounds, I'm more interested in feeling less lousy than I have lately -- among other things, I've been feeling tired and having trouble concentrating, and my back has been hurting again. I don't know for sure if getting into shape will fix these problems, but I figure being more healthy couldn't possibly make them worse.

In other news, I've finally done what all the cool kids were doing in 2002 and started a Flickr album. Right now it mainly contains cat pictures like this one:

I Sansa no more

2007-01-30T22:20:00.000-08:00

Well, I did it. My Sansa e280 is now once again the property of the Bellevue Circuit City. The gadget had pretty sweet hardware (holding my entire music collection in the palm of my hand was a cool thing), but I have no real need for it -- certainly nothing that would be worth putting up with Sandisk's attitude regarding non-Windows computers.

I'm currently trying to decide whether to remain portable-less for now (on the theory that portable media players are likely to advance ridiculously in the next few months), to buy a simple 4GB or 2GB Flash player, or to give up on Flash for the time being and get a hard disk-based player. I'm leaning towards waiting until the 4GB model of the Cowon D2 becomes available in the U.S., and then ordering it -- its feature set is pretty amazing, and hopefully 4GB will be enough storage capacity (especially considering that you can insert an SD flash card to get more storage space). In the meantime, I can cover most of what I was using the player for with a combination of podcasts, .oggs of my music, and borrowing Kate's portable FM radio. Less convenient, but entirely workable.

PR techniques

2007-01-29T20:32:00.000-08:00

It was recently reported that the scientific publishing industry had hired a PR heavyweight to attack the movement for the free and unencumbered dissemination of scientific results. I was especially struck by the slogan he supposedly recommended to the publishers:

Open access equals government censorship.

Just read that one a few times. I've found it gets funnier every time you do.

The Internet generation's lament

2007-01-29T20:28:00.000-08:00

For people who read my blog and not Planet Debian, I have to quote this comment on one of Biella's recent posts, by Luis Villa:

The world is producing interesting things for me to read faster than I can read them.

This is so, so, so true.

Sandisk doesn't want your money for a music player unless you run Windows

2007-01-27T08:33:00.000-08:00

I bought a Sansa e280 last weekend to replace my aging and bulky Neuros (the last straw was when I lost the charger for the Neuros). It's nice to have such a small, light music player, and having 8GB of space is a big bonus. But when I went to the Sandisk web site to get a new firmware, I discovered that they only provide a .exe of a magic firmware download program. This is despite the fact that, as you can find by searching on the Web, the actual firmware upgrade procedure is just "copy the firmware file onto the device".

So, I wrote to support, mentioning that I don't have a running Windows installation and asking if they could provide an alternate means of updating the firmware. Here's the response:

Please be informed that your Sansa e280 is supported on Windows XP. If the operating system of your computer is not Windows XP, if you have just bought your Sansa e280, we do recommend that you contact the store where you purchased it and inquire about replacements that can be supported on your operating system or if that store honor refunds, please do ask for it. Please do provide the proof of purchase and packaging for verification purposes.

Now, I can work around this problem -- but after reading that brush-off I think I might just take their advice; as it happens, I saved the packaging just on the offchance something like this came up. Can anyone recommend a decent, small, flash-based media player that works well with Linux? Must-have features are:

FM radio (this eliminates, e.g., the Archos).
Some support for non-encumbered file formats.
Support for installing firmware upgrades from Linux.
Support for syncing music from Linux.
Either .ogg support or a lively (even if unfinished) Rockbox port. (Rockbox is actually preferred, since I'll probably just switch over to it if possible; this was one of the deciding factors in my purchasing an e280)

I still haven't made up my mind: I might hang onto the e280 out of inertia and wait for the Rockbox guys to figure it out (it looks like they're making pretty good progress). But if there's a better vendor out there that actually wants my money, I'd love to hear about them.

Package management usability

2007-01-23T21:46:00.000-08:00

[UPDATE: I'm closing comments on this post, because the spammers have discovered it -- dnb]

Lars says:

The uncomfortability of Synaptic may be partly due to the fact that it is
a different model from Windows: you get all your programs from one place,
instead of anywhere on the Internet, partly due to just not using Synaptic
much at all, and partly due to Synaptic not being perhaps as easy to
understand as possible. I personally find Synaptic to be very nice, and
use it regularly, but I am biased by having used Debian package managers
for over a decade.

Now, synaptic is a lot nicer for users than scary console frontends like aptitude. But it's really a tool for "power users". Here's a quick list just of what I see when I start it (bearing in mind that my UI design skills suck):

The "quick introduction" screen that pops up is way too long. The fact that it needs to be so long is already bad.
There's a huge, and I mean HUGE list of sections down the left. What are these? Which one do I look in? For that matter, what is "gnome", and are "shells" programs for the seashore?
If I want to find software for processing video, do I look in "graphics" or "multimedia"? (and what are these funny "(contrib)" markers?) Which of the huge number of packages in each section do I want? From the point of view of a new user (especially), this categorization is useless, not to mention often wrong or misleading.
The four buttons in the lower-left, which change the display, are a good idea, but they don't say what they do. A label saying something like "Group By" would go a long way here.
I think the version numbers in the main display probably provide too much information for a novice user. They won't really know what to make of them, and if they need the information it can be provided on demand; as it is, it's just one more distraction to sort through while looking for what they really want. The extra space could, e.g., be used to provide more room for the status column (currently labeled "S").

So much for superficial observations. There are a few more things that I see that are worth more discussion.

Mechanics of selecting packages

To change the state of a package, you click on the unlabeled little box to its left, then select the correct option from a list containing "Unmark", "Mark for Installation", "Mark for Upgrade", "Mark for Reinstall"...you get the idea. Even if only one option is valid, the menu still appears with all but one option grayed out, and you have to select the one you want.

This is complicated, cumbersome, and surprising. It also introduces terminological confusion, since "Unmark" isn't really what you think of when you go to cancel an installation or whatever.

The best option I can think of here is a pulldown menu (which I believe the GTK+ list widget (god, I almost wrote "control") supports). The menu should default to the current state, e.g., "not installed", and should have options that describe what will be done with the package, e.g., "install", and so on. Only valid actions should appear on the menu. The Package menu should probably adapt in the same way as you select packages. I don't recall offhand how GTK+ menus work, but if possible commonly used commands like "remove" should be closer to the mouse when the menu appears than uncommon commands like "reinstall".

Another choice I can see, if you want to avoid menus, would be something like this: have two checkboxes, one for "install" and one for "upgrade". "install" would be checked for installed packages and not checked for not-installed packages. Checking or clearing it would mark packages for installation or deletion. "upgrade" would mark or unmark packages that were installed for upgrade. Of course, this introduces a redundant column for not-installed packages, which I don't like. It also seems to me that it would be less obvious what's going on for new users. But it would be more efficient for power users (who should all be using aptitude anyway ;-) ).

Progress bar madness

I haven't extensively used synaptic, but several core misfeatures of apt and our archive pretty much guarantee that if it displays progress bars for key operations like loading the cache or updating the package lists, the progress bars either run multiple times (i.e., don't actually tell you how close to finishing you are) or actually go BACKWARDS -- yes, BACKWARDS.

The great package hunt

Maybe the biggest problem is that unless you know what package you're looking for, basically all our package interfaces are useless. There are lots of fancy searching features you could add, but actually a quick test in synaptic suggests to me that this would be going in the wrong direction. Unlike aptitude, synaptic includes descriptions, and searches for stuff users might actually want (like, say, "burn CD") seem to turn up relevant results (i.e., software that burns CDs).

I'm sure the search algorithm could be improved (with inexact matching, better indexing (a package description suffix tree?), etc), but the big problem I see is that you tend to get back several dozen results, many of which are libraries, development packages, command-line software or software that doesn't work; some of the other software is software that can burn CDs but whose purpose is not to burn CDs (e.g., backup software).

How can we solve this? The first thing that springs to mind for me is to use popularity-contest data to weight the list. I know it's not terribly accurate, and it has some skewing problems (stuff in the default install will be favored), but I suspect it would greatly bias the results in terms of software that's useful to many people (using the "recently used" tallies might especially help here).

I don't have many other good ideas on the searching problem; I've seen vague suggestions of counting reverse dependencies, but this doesn't seem like a good metric of useful software to me; trying to extract more information from the short and sometimes inaccurate package descriptions seems like a really hard problem to me. (Google can do cool statistical analysis partly because it has so much data to work with AIUI; even a single Web page typically has orders of magnitude more information than a package description)

Another issue is the problem of finding related software once you've installed one piece. We have "suggests" and "enhances", but they aren't exactly displayed in a prominent or easy-to-understand way by any frontend. I think it might be good to display a clickable list of suggested packages somewhere visible (e.g., at the top of the description box) when the user has selected a package for installation. We could even display a little bar, like on (eg) Amazon: "Debian suggests installing these packages..." ;-)

It might also be interesting (if this is considered acceptable; since the data is anonymous I don't see a problem) to analyze the popcon data to find out what packages are being installed in tandem. I don't know if we have enough information to do it, but it could turn out to be really useful to be able to click on a package and see other packages that are popular with users who installed that package. Going back to online stores again, those "other people who bought 'Types and Programming Languages' also bought 'Introduction to Category Theory'" links are amazingly useful, and something similar would probably be a big help in Debian.

How to Breathe, Functionally (part 2)

2007-01-21T09:20:00.000-08:00

In a previous post, I pointed out some ways that you can acheive the "compute this, now save it and compute this, ..." style of coding in a functional language such as Haskell without going mad. This is a continuation of that post.

There's one other purely syntactic feature of Haskell that I rather like for readability: Haskell lets you define variables after you use them.


GoToTheNextTrickyBit someVal
   where someVal = DoThisAndThisAndThat...

Although it isn't always appropriate to do this, there are times when I find it extremely intuitive to define my variables after they're used. For instance, to take a "practical" example, compare


mailTo customer =
   let customerName = getCustomerName customer
       customerAddr = getCustomerAddr customer
   in
       makeMailingTo customerName customerAddr

with


mailTo customer = makeMailingTo customerName customerAddr
   where
      customerName = getCustomerName customer
      customerAddr = getCustomerAddr customer

I don't know about anyone else, but when I read the first definition I mentally go "huh. Why are we extracting the customer name?", then skip down to where the name gets used, and finally re-parse the name in that context. The "where" form lets me write the code in the same order that I would read it, giving the code a natural flow. It's very important, of course, to keep the number of auxiliary definitions small; otherwise you leave too many "open questions" for the reader of your code to carry around as she works her way down to the definitions.

But it isn't all roses at the low syntactic level. IMO, the biggest practical problem with writing Haskell code is the syntactically significant indentation.

Python, of course, also has significant whitespace -- but it works mainly because it's extremely simple. Any line ending in a ":" introduces a new block, and statements within a block have the same amount of indentation. In contrast, Haskell's rule...well, just read that link above. You can write code that has the same meaning under any indentation, but it's not idiomatic to do so -- and worse, since the statement terminators are not obligatory, a missed terminator might work fine, might change the meaning of your code, or might fail to compile in an obscure way.

A side effect of the complicated indentation rules in Haskell is that the Emacs Haskell mode doesn't work very well at indenting my code. It usually chooses an indentation that I don't want, and often one that doesn't even compile. I'm sure Emacs could do better, but I would be willing to live with a little more punctuation if it meant that the code was easier for programming tools to process correctly. Functional coding advocates assert, correctly IMO, that side-effects are problematic because even smart programmers will write more bugs in their presence. I think the same logic should apply to syntax: making the language harder for humans and machines to parse has negative overall effects, even if it is possible with sufficient effort to parse it correctly.

I think that conceptually, Haskell is a great language -- the problems I see with it are issues of syntax, tool support, libraries and speed (laziness has a high price). Oh, and also the fact that, as with most programming languages that are pleasant to use, you can't get a real paying job writing in it unless you have a PhD. :-(

How to Breathe, Functionally (part 1)

2007-01-21T08:44:00.000-08:00

David Welton writes that the problem with functional languages is that you don't get to mentally "catch your breath" between computations; piling function invocations on function invocations makes it hard to understand what's actually being calculated. He has an amusing summary of how functional code can become unreadable:

Do this with the result of this with what this produces when given this input that is derived from this function which takes the result of this other thing after calculating the result of something that is derived from the output of a function that ...

Indeed, I've seen functional code like this (much of it written by myself). Here's a particular gem:


f splitPoints = map fst $ tail $ scanl (flip ($) . snd) ([], toSplit) $
          map splitAt splitPoints

I wrote this code a year ago, and I don't know what it does! It's hard to read and hard to understand. So, however, is imperative code that says

Add 5 to A, now if B is not zero we jump to where we subtract one from B and if C is less than 3 we add 4 to C otherwise we divide C by 2 and then add it to A, then we ...

The reason both pieces of pseudocode are hard to understand is that they don't use the abstraction features built into the language. Good imperative code uses meaningful variable names, uses the structured-programming primitives the language provides, and abstracts complex operations into functions.

My rule of thumb (which is, heh, not always religiously followed) is that a piece of program structure that does more than about 3-6 things is probably too complicated; it seems like that's about as much local context as I can hold in my head comfortably (and the number is more 3 than 6 these days, if you get my drift). As David puts it,

If you'll bear with a poor comparison, sometimes programming is like a song. You do the tricky section, then you go back to an easier section and catch your breath for a bit.

The problem seems to be that people trained on imperative languages, when they're tossed into the ocean of functional coding, can't find the guideposts and landmarks that would help them impose some structure on the water. Should I put this complicated expression inside a "let", or break it out into another function? When do I use a higher-order function to unify two dissimilar pieces of code? Should I write this code in terms of higher-order library functions or directly? It's easy to wander off down a chain of nested invocations of anonymous higher-order functions, or composed partially applied library functions, just "because you can" and end up forgetting what you were trying to do in the first place.

Luckily, some of the basic rules of keeping your code readable remain more or less the same: assign intermediate results to variables with meaningful names, and abstract complicated operations into separate functions. To tackle David's example:

You get sections with DoThisAndThisAndThatWithTheResultsOfSelectThisFromTableXYZ that you have to slow down to think through.

...

GoToTheNextTrickyBit where ManyThingsHappen.

All in all, you wind up with a sort of ebb and flow that works out pretty well if you're in tune with the code being written, going from intense calculations, to a line or two where you do no more than store things in a variable, take a breather, and prepare for the next important stanza.

The way to "take a breath" in a functional language is generally to assign an intermediate result to a variable, or to extract a complicated operation into a function and give it a meaningful name. One Haskell approximation to David's example is


do DoThis
   AndThis 
   results <- SelectThisFromTableXYZ
   someVal <- AndThat results
   GoToTheNextTrickyBit someval

If you're writing pure functional code, you might write


let
   results = SelectThisFromTableXYZ
   someVal = AndThat results
in
   GoToTheNextTrickyBit someVal

Of course, this will become unreadable if you write a huge complicated nested "let" expression in place of "AndThat". For a truly dreadful example of this kind of coding, check out the Gnucash Scheme code that generates the "Cash Flow" report (warning: read this in short bursts, or you WILL go blind). This is exactly analogous to writing too many nested loops and conditionals in imperative code, and the fix is the same: find logically distinct bits of code and extract them into separate functions.

I have a few more thoughts, but this post is getting too long, so I'll inflict them on the world in another post. The rule that short things are easier to understand applies to blog posts as well as code. :-)

Via C7: it goes fast AND slow!

2007-01-18T08:09:00.000-08:00

The low-powered system I assembled recently is based on a Via Epia board and a C7 CPU. I spent quite a bit of time when I was setting it up trying to get the C7's speed stepping to work. I loaded a number of cpufreq modules without luck; crawling around on the Web only led me to discussions about how the C7 couldn't be speed-stepped in Linux and maybe the centrino cpufreq driver would work.

Well, yesterday I randomly searched again -- and poof! There was a discussion from early January about how maybe the ACPI cpufreq driver would work. I loaded it, set up powernowd, and was rewarded with


daniel@jeeves:~$ cat /proc/cpuinfo 
processor       : 0
vendor_id       : CentaurHauls
cpu family      : 6
model           : 10
model name      : VIA Esther processor 1200MHz
stepping        : 9
cpu MHz         : 400.000

Sweet. Now all I need is for the Debian kernel folks to package a version with a vt1211 lmsensors driver so I can shut down or slow the fans, and I'll be all set. (I could probably hack it in myself, but according to what I've read on the Web, the next kernel release will have a working driver)

[UPDATE: I disabled cpufreq after only a day or so, because Linux got horribly crashy with CPU scaling turned on. Hopefully the kernel will be fixed sometime in the future :-/ ]

Cuckoo!

2007-01-17T20:35:00.000-08:00

The most unique Christmas present I got this year was the cuckoo clock from my father's parents. There's something very cool about mechanical clocks that work by means of weights and gears instead of electronics: when the cuckoo goes off, you can actually watch energy being transferred from the weight to the cuckoo device, as the weight that powers it drops precipitously!

Unfortunately, the clock seems to lose about half an hour every twelve hours. Does the Lazyweb know any techniques for getting mechanical cuckoo clocks to keep better time? I don't mind resetting it once a week or so, but twice a day is a little excessive.

Mini-Review: mythtv for non-TV viewers

2007-01-17T20:11:00.000-08:00

Several months ago, I set up a low-powered box to act as a fileserver and media center. I don't get cable TV and I have no interest in doing so, so I don't need a PVR. However, I do have a rather large music collection (and new speakers to play it on); I want to be able to put Internet radio on in the background (since we can't get NPR over the air), and a quick-and-dirty slideshow program for my digital camera photos could be nice too. So, I decided to try out the free media center, mythtv. I've summarized the notes I took here for the benefit of other people who don't watch TV.

Setup was fairly straightforward -- I installed the packages from debian-multimedia.org and configured them. I had a bit of trouble getting myth to actually start, but looking over the documentation apparently resolved it (my notes contain no details).

Mythtv has some very well-thought-out aspects. By all accounts, it makes an excellent PVR; since I don't watch TV, this is the last time I'll mention PVRs in this post. :) The interface looks exactly the way you want a TV-based system to look, with bright colors, big fonts and big interface elements. There's even a cute OpenGL mode with fancy screen transitions (I left them disabled because my video driver is unstable even without 3d effects running -- thank Via).

However, it became painfully obvious after a bit of use that MythTV is really meant as a TV program, with everything else being an afterthought. Here are just a few of the problems I noted:

MythTV can't play internet radio; the functionality simply doesn't exist.
You can do only one thing at once. Perhaps this is fine for TV, but given that it is not uncommon that I want to, say, play music while reading the news, or while ripping another CD, this is a gaping hole in functionality for me.
MythTV can display news (RSS) feeds. However, the news feeds aren't in alphabetical order in either the viewer or the setup screen (where you pick what to see). This makes it rather painful to pick the feeds you want out of the dozens of presets.
The built-in browser crashes with SIGABRT on startup, making the news feeds useless anyway.
The built-in support for ripping flac files is confusing to activate (you have to pretend you're making an Ogg and choose "Perfect" quality!) and doesn't give you control over the process (for instance, replaygain can't be added to the ripped files).

That's just a small sampling of the problems I ran into. I ended up just setting up a normal desktop system with a wireless keyboard/mouse, and I'd recommend the same thing for anyone else who doesn't need a PVR. The non-TV features in Myth have a strong smell of being extras for people who occasionally switch away from the TV, rather than a well-integrated media system in their own right.

The US isn't the only country with crazy politicians

2007-01-10T06:07:00.000-08:00

[UPDATE 2007-10-01 22:43: It appears that Erich wrote an expanded and better-translated post while I was at work]

Erich Schubert writes that

Nach aktuellen Plänen der CSU wäre der Vertrieb von Debian GNU/Linux illegal.

Auch zahlreiche andere Distributionen währen wohl davon betroffen: Alle, die sogenannte "Killerspiele" vertreiben...

For non-German speakers, I provide the following approximate translation:

CSU wants to make Debian illegal

The current plans of the CSU [Christian Social Union] will make the distribution of Debian GNU/Linux illegal.

In addition, many other distributions will be affected: specifically, those that distribute so-called "killer games"...

For instance, Overkill (Debian also includes, e.g., Tremulous and OpenArena, which are based on the Quake3 engine and have 3d graphics...)

(hopefully I got the gist of Erich's post without mangling it too badly!)

What I don't know is how serious this is. The CDU (Christian Democratic Union) is IIRC the current ruling party in Germany; however, according to Wikipedia, the CSU is some sort of local affiliate in Bavaria. Does it have the clout to get this proposal made into law?

Why comments are closed on my blog.

2006-12-28T10:06:00.000-08:00

This is belated...anyway, I'm taking a day off work to get ready for our vacation this weekend, and I remembered (after writing some other blog posts) that I meant to chime in on a Planet Debian discussion about closed vs not-closed blogs.

My reason for closing comments was quite simple: blogs are spam-magnets. While I was a student and/or unemployed, I didn't mind spending a few minutes a day purging spam messages from my blog. But when I started working full-time, it became a real chore, especially since the amount of spam I got increased with the number of posts on the blog.

One thing that would change my point of view here would be the option to automatically close comments on posts that are more than (say) 60 days old, or perhaps that haven't got a (non-deleted) post newer than 60 days. This would keep the spam problem down, since my biggest problem was ancient blog posts that no-one had commented on (at least for months or years), but that suddenly got picked up by spammers. This might be available if I ran my own blog, but I don't have the time at the moment to administrate a home server, so I'm stuck using someone else's software.

I'm a top contributor too!

2006-12-28T10:01:00.000-08:00

Adrian von Bidder notes that he got a message from a random survey group asking for feedback.

[...] we analysed the debian mailing list archives, especially the debian-devel mailing list, as it is a good representation of the whole network. [...] we identified the 100 main actors and therefor came across your email address.

So, somebody who talks quite a bit on the mailing lists, but really only maintains one package is already one of the top 100 "actors" in Debian? I seriously doubt it.

It gets better. In the last couple years I've barely posted on any public Debian mailing lists at all. And yet I'm apparently also in the top 100 "actors". Say what?

Microsoft: Copyright law is for other people?

2006-12-28T08:33:00.000-08:00

Unsurprising, sad, but still amusing: this guy photographed talks given at a computer conference and released them under the Creative Commons Non-Commercial Attribution license. A Microsoft senior program manager copied his work as part of an advertisement, without attribution.

Try violating Microsoft's copyrights and they'll bury you under lawyers and moral outrage. But catch them violating yours and it's laughed off as no big deal (some of the huffy responses from Softies on the blog post I referenced are pretty funny).

Of course, in a real sense, it isn't a big deal: "might makes right" is a dreadful moral principle but a largely accurate summary of how the world actually works. But exposing the hypocrisy of the powerful at least forces them stop pretending that they are anything but overgrown, sanctified, self-righteous bullies. (this doesn't actually make anything better (even if you get rid of one bully, he'll just be replaced by another one), but at least it means you don't have to gag on hypocrisy every time they open their mouth)

urlscan 0.5

2006-12-16T11:33:00.000-08:00

If, like me, you use the mutt mailreader, you may at some point have tried out the urlview program to quickly jump to URLs in emails. urlview is a nice concept, but it has a few limitations, the worst of which is it doesn't decode quoted-printable emails (so, e.g., CGI urls containing equal signs get escaped and become useless).

With the increasing number of dynamic URLs and quoted-printable emails out there, this has rendered urlview more or less useless for me. A couple weekends ago, I got annoyed enough to do something: I wrote a quick-and-dirty Python replacement for urlview, called urlscan. I'm not proud of all the code, but thanks to Python's great standard library, it can decode just about anything you throw at it; it also extracts some context around each URL, so there's less guesswork involved in picking URLs.

I've uploaded urlscan to unstable (it just went in today), in the hopes that someone out there will find it useful. Enjoy. :-)

DRM: "If there is hope, it lies in the proles^H^H^H^H^Hpols"?

2006-12-09T14:02:00.000-08:00

In response to my recent mistaken post about Samsung and DRM, Adrian von Bidder wrote that

I think this battle will have to be fought in politics7. Battling the vendors is fine, but will be endless, the real goal should be to anchor a broad [4]right to tinker in the bill of rights which also extends to non-commercially used information.

On one level, this is probably true. But this amounts to the government passing laws that increase the liberty of its citizens and decrease its own control over them, while at the same time exposing the corporate interests that sponsor the government to increased competition. Governments almost never do this, for obvious reasons -- probably the only example in recent American history that I can think of is the Civil Rights Act of 1964, over forty years old now, which addressed inequalities that the average person could understand easily and was preceded by significant popular unrest (much more than a few guys dressing up like hazardous-waste-disposal crews and walking around outside computer conferences).

In fact, the most likely outcome of the government getting involved in the DRM situation, in my opinion, is a bill making DRM mandatory for all hardware devices and requiring software (or at least software that can run on mass-market computers) to go through a process of certification that attests that it respects DRM. This will be the final nail in the coffin for the free software movement, and I don't think we want to hasten its arrival.

I think the best we can hope for in this context is the prayer from "Fiddler on the Roof":

Lord, bless and keep the Congress

... far away from us!

Apologies to Samsung

2006-12-09T13:50:00.000-08:00

I need to learn not to write blog posts after 9pm, given that my brain starts fogging up around 8:30pm.

Apparently the only reason I couldn't play DVDs is that I had forgotten to install the DVD decoder library. Doh. And apparently the reason the DVD wouldn't play yesterday is that the video program was trying to get the drive to decode the DVD for it -- which I can understand Samsung not wanting to do, since it would get them in legal hot water. (what ticked me off was that it looked like they were going beyond the minimum and keeping me from even reading the encrypted DVD data)

So, the problem is that Daniel is a doofus. I want to apologize again for being a little trigger-happy last night -- especially since this is syndicated, it sucks to have put incorrect information out there.

Hungarian notation is a human-checked type system, redux

2006-12-09T11:21:00.000-08:00

A while ago, I read an article that advocated the use of Hungraian Notation for purposes that can easily be folded into the type system and automatically checked. I wrote a blog post in reply that gave a rough sketch of a solution to the fundamental problem in Haskell. Well, someone else apparently read the same article and had the same idea; the only difference is that the solution he produced is infinitely superior to mine and everyone should go read it instead.

Hardware manufacturers to avoid: Samsung

2006-12-08T20:43:00.000-08:00

[UPDATE 2: the problem is of the form "Daniel is an idiot". See this post for details. DRM is still evil, though.]

I recently assembled a little Mini-ITX system, mainly for use as a file server/desktop replacement/music server. However, it has a DVD drive, and it has a hardware MPEG2 decoder. So today, feeling a bit lazy, I decided to try displaying a DVD on the box instead of using the DVD player. This is when I discovered that my computer's new DVD drive is defective.

hdc: command error: status=0x51 { DriveReady SeekComplete Error } hdc: command error: error=0x54 { AbortedCommand LastFailedSense=0x0 5 } ide: failed opcode was: unknown ATAPI device hdc: Error: Illegal request -- (Sense key=0x05) Read of scrambled sector without authentication -- (asc=0x6f, asc q=0x03) The failed "Read 10" packet command was: "28 00 00 00 01 c0 00 00 02 00 00 00 00 00 00 00 "

Yes, you read that right.

So, I won't be buying any more Samsung hardware until they figure out that I am their customer, not the MPAA. I realize this is an utterly futile gesture, that Samsung won't even notice my lack of custom, that this will make not even a dent on the juggernaut of DRMed/TPMed/locked-down hardware/software systems that are coming in the future, and that the end result is that I quit using computers entirely and go raise chickens...but you know, right now I think I'm mad enough not to care.

PS: Even worse: based on some discussions I found online, I ran a quick check of the CD reading speed -- and it appears that the drive now refuses to read CDs any faster than 2-3X! This is absolutely the last dollar that Samsung is getting from me, and if the store's return policy allows it, this sucker is getting RMAed tomorrow.

[UPDATE: the store I bought the drive from in October has a 30-day return policy, so I'm stuck with the one I've got. Probably I won't bother with getting DVD functionality on my next optical drive, it's not worth the obnoxiousness.]

Things I miss about being an Undergrad.

2006-12-05T20:41:00.000-08:00

So, it's been about 4.5 years since I got my ScB, 1.5 years since I got my MSc, and 1 year since I started working at Satori. Seems like an ideal time to look back on the halcyon simplicity of college, right? Here are a few things that I really wish I had appreciated more in 2000.

(1) Getting enough sleep.

I was just about the only well-rested student I knew in college. When other people (who stayed up past midnight regularly) would complain that they seemed to spend lots of time working withotu getting anything done, I occasionally suggested that they try getting more sleep. Hah.

So, in grad school I developed some bad, bad habits -- staying up past midnight, sleeping in erratically, etc. (I like to blame my girlfriend, who refused to get up before 9-10am when she was a student ;-) ) I started to sort of get a handle on that, and then I got a full-time job.

The problem here is this: you know how they say that to figure out how much sleep you need, you should sleep until you wake up naturally and feel rested? If I go to bed at 9PM, I wake up naturally at 7-8AM or so. That's -- count it -- 10-11 HOURS OF SLEEP. As a student, I had the luxury of sleeping 11 hours straight (since I had no social life). As a working drone with an hour-plus commute, that would leave me with 3-4 hours to fit in all my non-work activities (like, say, eating; personal hygeine; etc). The fact that I tend to get heartburn if I lie down within 2-3 hours of a meal, and that I usually have to cook my meal before I can eat it ... well, this just isn't gonna work.

So, to get enough time to actually live a bit outside work, I end up curtailing my sleep schedule to "only" about 7-8 hours. I know that's enough for some people. I wish I was one of them. The result for me, though, is that I go through most days feeling dazed, tired, sleepy, and with an on-and-off headache. I can generally hold it together well enough to get through the work day (although yesterday I collapsed on the couch halfway through), but once I get home I lack the energy to do anything but feed myself and idly browse the Web. Trying to do anything intellectually challenging (hence interesting), like say learn Cantonese or category theory, is right out. (I can just about say I want to eat, and I got as far as power categories before getting horribly tired and confused)

(2) Breaks.

One great feature of college is that you get time off of it. In addition to some random vacations during the semester, you usually break for several whole weeks between semesters, and then break again in the summer. Even if you have a summer job, this is a great way to recharge the batteries.

In the working world, I get exactly 1 day off per month -- if I want a decent-sized break, I have to go several months with no days off at all (except the paid holiday day every other month or so that the company gives us in its beneficience).

(3) The cafeteria.

College students like to make fun of cafeteria food. They don't know how good they have it. You get three hot meals a day, plus you don't have to do ANY cooking or cleaning up? Sign me up!

When I get home at 6:30 PM and I'm starving, the first thing I have to do is get out the raw ingredients for my dinner and toss them in a pot, then gnaw on some cheese or something to take away the hunger pains until they're done. By 7:30, I might have some food in me, hopefully. I'm thinking about switching to a frozen-food diet (ew), although that doesn't help clean the dishes.

(4) There's no commute in college.

To get to work, I have to walk 10 minutes, ride the bus for about 30-40 minutes, then walk another 20 minutes or so. In the evening I have to do the reverse. That's 2-3 hours of my life sucked up by just getting to work and back. If my brain wasn't too fried to study any of the interesting books I've optimistically purchased (see (1) and (2)), it might be bearable...but when I just want to get some food and rest, it really sucks. And it sucks especially when I have no good alternative (living in Seattle is EXPENSIVE, and it would give Kate an even worse commute in the other direction).

(5) Having the time and energy to study topics or write software just for the heck of it.

This really incorporates all of the above. It seems like all these factors conspire to suck my time up, then suck up the energy I have in the little time left to me. Meh. For instance, right now (at 9PM) I am getting very sleepy and should get to bed, yet I've done nothing since I finished eating (at 7:30PM) but skim Lambda the Ultimate and a few linked articles sites (slowly) and write this blog post. Blah.

Lest I give the impression that I completely hate work, let me add that there is one very, very important thing that I enjoy about it relative to my student, free-software-hacking days.

(1) NOT BEING FLAT BROKE.

I believe this one is self-explanatory; and so far it still makes up for the rest (I wonder how long this will continue). It's too bad I can't get paid to just sit around doing whatever I feel like and then giving it away, but then it's also too bad I can't wave a magic wand to get a pony and a few dozen acres to keep it on.

Digging for Conspiracies?

2006-11-28T06:46:00.000-08:00

While I appreciate the research and legal commentary over at Groklaw, the tendency of PJ and the regular posters to imagine vast conspiracies makes me more than a little uneasy. Yesterday I came across a truly jaw-dropping example that would be offensive if it wasn't so laughable; and since I happen to know more about the situation, I felt I should comment on it:

I have some questions about this group, BELUG, who did the article, I gather. There is no info on the site to be more informed. Anyone in the Seattle LUG know anything about this new group in Bellevue, 5 mins. from Bill Gates' house?

...

I don't like to be a cynic, and maybe they are a Linux user group, but if so, maybe the Seattle LUG can give them a hand.

Of course, we all know that the Microsoft corporate campus has an enormous mind-control ray mounted on Building 1 that turns everyone living on the Eastside of Seattle into mindless Gates-worshipping zombies. Part of Bill's personal security plan, dontchaknow. That's why BELUG starts every meeting with a round of "All Hail Gates, Lord of All That Is Electrified".

She goes on to complain about "major confusion" in their description of free software. At a quick read, I can only see two glaring problems with this page: first, they describe free software as being both "free in a monetary sense" and able to be sold (which is actually true but sounds like a contradiction without more explanation that they don't provide); later, there's some weird wooly-headed stuff about revolutionizing entire economies and societies. I don't know what they're talking about, but they certainly can't be accused of lacking enthusiasm.

Finally, she quotes a section of the FAQ that suggests that Microsoft professionals should learn Linux and vice versa, since the world is heterogenous and getting more so. I don't think that's controversial, so I think she must be referring to this question:

Q: Why does BELUG dislike Microsoft?

A: That is a complete misunderstanding. BELUG does not dislike Microsoft. Microsoft is our neighbor, and many of our friends and relatives work there. Both Microsoft's headquarters and Bill Gates' house are located just minutes away, and Microsoft's world sales headquarters is currently under construction nearly adjacent to BELUG's meeting location. BELUG merely believes in friendly competition and that competition can benefit everyone, including Microsoft. This is what a free market economy and the American system is (supposed to be) all about, and this is what has helped make the U.S. a great country.

The statement that Microsoft is nearby is nothing but geographical fact (I could walk about fifteen minutes from my apartment and be on the MS campus; does that make me an MS mole?).

As for the rest, I really don't see anything to complain about. I know some people like to rhetorically shred Microsoft at every opportunity, but if you're trying to attract members in Microsoft's hometown, it's wise to keep your comments polite. It's also true that Microsoft benefits from competition (even if they don't see it that way); I don't think it's a coincidence that their products started sucking drastically less as OSX and Linux became reasonable alternatives to Windows. And the fact that we can have friendly competition (as opposed to the cut-throat, take-no-prisoners style that's popular in some quarters) is exactly one of things I like about Linux. You will notice, however, that the Q&A carefully doesn't mention what sort of competition Microsoft engages in. I think anyone who knows anything about the company knows the answer to that one.

Here's the kicker, though: I actually attended a BELUG meeting a few months ago. It seemed pretty much like what I'd expect from a small group of volunteers: one guy gave a talk about hooking ALSA up to a digital audio receiver, another guy showed off a Unix kernel he had written for classic MacOS (it ran as a user process and presented a Unix-like interface to the Mac), someone passed around cookies, and people talked a bit about using Linux and so on.

The poor quality of the Web site and the lack of a mailing list probably reflect the fact that there are a handful of people organizing the thing who all have day jobs and other committments, not some vast Microsoft conspiracy to undermine Linux from the inside by setting up fake LUGs. PJ never said they were fakes outright, but it was a clear subtext of her comment, and the Groklaw regulars who replied knew exactly what she was getting at. If she really thinks they might be fakes, then I think she needs to take a break from watching SCO (which could make anyone paranoid and suspicious) and enjoy the holiday season instead.

Close Encounters of the Automotive Kind

2006-11-12T10:21:00.000-08:00

I got run over by a car on Wednesday.

Well, that's an exaggeration. My foot got run over by a car on Wednesday. I was trying to cross, in a crosswalk, in front of a red SUV that was stopped at a stop sign (my first mistake), when the driver suddenly decided to make a quick right turn. Luckily, I saw him start to do it and was able to jump out of the way of his vehicle -- except that I couldn't get my left foot out of the way in time. THUMP. And a few seconds later there was a SMACK as his passenger-side mirror creamed me, snapped off, and fell into the road.

The driver immediately realized what had happened and stopped to apologize. He offered me a ride; after quickly checking that my foot was NOT a mess of broken bones or a bloody pulp, I asked him to drive me to the bus stop. I was pretty shaken up from having just escaped death or major bodily injury by a matter of inches, so I didn't get his insurance information, name, phone number, or even license plate. Second mistake.

So, I got on the bus, flipped open my laptop to see if I could play a video game or something to calm down, and discovered that the screen of my practically new laptop was smashed. Probably it got hit by the passenger mirror -- and since I have no idea who hit me, I can't even politely ask him to pay for replacing it, let alone demand.

That's the bad news. The good news is that I went to a doctor and got a confirmation (with xrays) that no bones are broken in my foot. My foot and back are sore, but they're already quite a bit better than they were (I'm barely limping at all now) and the doctor said they should be fine in a week or two if I take it easy.

I suppose the whole thing was my fault, really; yeah, I had the legal right-of-way, but I should know by now that this is a meaningless concept; a driver who isn't signalling to you is always a potential hazard, especially in Seattle at rush hour.

The upshot of this, for people seeing this on Planet Debian, is that I probably won't be doing as much Debian work in the near future. I was using my laptop on the bus to catch up on emails and work on "easy" bugs, and I don't have the money to replace it right now (I probably won't until at least January, according to my back-of-the-envelope figuring). I can get some work done on weekends, but at an even more reduced pace than I've been able to since I got a paying job. :-(

Things that Don't Suck and Things that Do

2006-10-27T18:52:00.000-07:00

Since I sometimes worry that my blog is turning into a gripelog, I'd like to highlight a very positive experience I recently had with a company. I wanted to buy some decent desk chairs for my apartment, and due to getting a higher-than-average computer desk, I needed chairs that were fairly tall (seats around 30" from the floor).

I finally converged on a lab-stool that I found at office-chairs-discount.com and placed an order for two instances of it. They arrived a few weeks later in boxes with fairly simple assembly instructions. Unfortunately, and here's where it gets interesting, one of the chairs was broken -- the ring of plastic that was supposed to secure the foot-rest to the chair's main support was broken. After I sent an email describing the problem to their support address, they said that all I needed to do was take a picture of the broken part and they'd mail out a replacement. A few weeks later, the replacement arrived and I was able to assemble the second chair. They even were very polite when I bugged them about why the part hadn't arrived when it already had (UPS apparently didn't leave a notice for me). All in all, I was quite impressed with this company and I'd definitely buy from them again if I needed more chairs.

So, now on to less happy things. People with a mathematical background are familiar with the principle of transitivity; basically, this says that if A is less than B and B is less than C, then A is less than C. This isn't just an arcane mathematical property, though; it has important practical consequences. For instance, if you want to quickly find a word in a list of words, having the words in sorted order is a huge benefit. You can do this because, among other things, the "less-than" relationship between words is transitive (without transitivity, even the idea of a "sorted order" is somewhat peculiar).

Why do I mention this? Well, because in C#, the following inequality holds:

"Y-" < "Y'" < "-Y-" < "Y-"

That's right: by default, Microsoft's C# implementation compares strings in a non-transitive manner, contrary to all expectations that any sane programmer would have. This bit me yesterday, when I was trying to sort a rather large array of strings and then perform searches in the array. Words that I knew perfectly well were in the array (I could even see them in the debugger!) weren't being found by the search. Why? Because the list wasn't in sorted order, even after calling Array.Sort() on it. Why? Because (see above) there is no such thing as a sorted order using the default C# comparator!

At first, I hoped this might just be a bug. But in the manual, I found a nice little explanation that the default sort doesn't perform a standard lexicographic comparison, in an attempt to provide a more "human-friendly" sorting. (they give the example of sorting "coop" next to "co-op", which confuses me since those two sort next to each other in any even. But whatever.) Instead, you have to use a method which is confusingly called "CompareOrdinal" instead of "DontSuckCompare".

Of course, after reading this, I guess nothing Microsoft does can really surprise me any more. Interestingly, Mono doesn't seem to have copied this particular "bug" (although I only tested one case with it). I don't know if this is good or bad: after all, it's probably only a matter of time before a piece of software that unintentionally depends on .NET's weird string comparisons comes into being.

ACLU & tagged-URL emails

2006-10-17T18:16:00.000-07:00

I recently got on an ACLU mailing list that they use to send out requests to sign on-line petitions and so on. Today, while skimming over another one of these "alerts", I noticed something amusing. The email contains several links to the ACLU site, requesting that users sign a petition opposing a recent nasty piece of legislation; for instance,


Please help broadcast our message across the nation: Sign our "This
November, I'm Voting My Values" pledge:
http://action.aclu.org/site/R?i=5dopkpJQPaNbn4A_kyuMzA..

and


To do that we must make civil liberties one of the top issues as
people head to the polls next month. Sign our "This November, I'm
Voting My Values" pledge.
http://action.aclu.org/site/R?i=ByYHnSn7ZbByadWPVPRB0X..

Note that these are from the textual version of the email; in the HTML version, the URLs are linked from the "Sign our ... pledge" text.

See anything there? That's right: each of the "sign the pledge" links goes to a different URL! Since someone had to go to the effort of making all these links go different places, I have to wonder whether an ACLU server is collecting statistics on how many paragraphs each user read before they clicked the link, and analyzing these stats to target and refine their marketing campaigns. I suppose this sort of thing is standard practice these days, but it's still a bit ... odd ... to see one of the main organizations that advocates for privacy perhaps engaging in this sort of clandestine information-gathering.

[EDIT: In case it's not clear from the above, I don't know and I'm not suggesting that anything nefarious is going on; I just thought this was a funny idea and wanted to share it with people. My brain is weird that way, but sometimes not everyone gets the joke, so I thought I'd add this postscript here to make it clear. :-) ]

When good spamfilters go bad.

2006-09-30T21:02:00.000-07:00

From: secretary@debian.org
To: Daniel Burrows 
Subject: Acknowledgement for your vote

Spam detection software, running on the system "jester", has
identified this incoming email as possible spam.  The original message
has been attached to this so you can view it (if it isn't spam) or label
similar future email.  If you have any questions, see
the administrator of that system for details.

Content analysis details:   (5.8 points, 5.0 required)

 pts rule name              description
---- ---------------------- --------------------------------------------------
 1.0 NO_REAL_NAME           From: does not include a real name
 1.5 RCVD_NUMERIC_HELO      Received: contains an IP address used for HELO
 1.0 BAYES_60               BODY: Bayesian spam probability is 60 to 80%
                            [score: 0.7536]
 2.3 EMPTY_MESSAGE          Message appears to be empty with no Subject: text

The original message was not completely plain text, and may be unsafe to
open with some email clients; in particular, it may contain a virus,
or confirm that your address can receive spam.  If you wish to view
it, it may be safer to save it to a file and open it with an editor.

(but what if the editor is Emacs and it has a Lisp virus?? ;-) )

Kitties

2006-09-02T11:12:00.000-07:00

Kate and I have been thinking for a while now about maybe adopting cats once we were settled into our new apartment. Two weekends ago, we went to a local cat shelter and adopted a pair of kittens. Photos below; the brown one is a female named Diana, and the orangish one is a male named Mars.

Not only are they INCREDIBLY CUTE, but they're very sweet-tempered and affectionate, at least when they can spare the time from chasing cat toys and play-fighting with each other. There's really nothing like having a pair of purring cats curled up on your lap together.

Kittens make everything better. :-)

(PS: more kitty pictures are available here)

Dynamic typing strikes again.

2006-08-12T15:12:00.000-07:00

Traceback (most recent call last):
  File "/usr/bin/reportbug", line 1731, in ?
    main()
  File "/usr/bin/reportbug", line 1471, in main
    listcc += ui.get_multiline('Enter any additional addresses this report should be sent to; press ENTER after each address.')
TypeError: argument to += must be iterable

BTW, for anyone who reads my blog and not Planet, this has a simple fix.

Giving away secrets

2006-08-12T14:47:00.000-07:00

Erich Schubert writes that

Oh, and I actually doubt that ATI would give away much secrets if it would allow distributing the existing opensource X drivers. It's not as if the specs of their CPU would be a huge surprise to Nvidia. Some actually say nvidia builds the better graphics cards. And Intel does even give away source code. We're not talking about chip design here, or driver optimizations. Just the plain registers and ports.

-- note: what follows is just my opinion and I'm wrong on a regular basis, so take it with a grain of salt --

The problem here is you aren't thinking like a corporation. As far as I can figure, the corporate view here is that you have two options:

(a) Keep the secrets you have. This is the status quo, you know how to make money here, and no-one else can benefit from your secrets even if you yourself can't.

(b) Give away your secrets. This always carries a risk that someone else will find a more clever (=profitable) way to use your secrets than you; thus, companies try to avoid this unless they absolutely have to.

I personally agree that the risk to ATI appears small. However, just to throw out a hypothetical, giving away their register specs would allow other companies to build cards that are register-compatible with ATI's. (Remember the ne2000?) Obviously this would be good for you and me -- but it's almost certain to drive down ATI's profits at least a little by providing more direct competition in the market for graphics cards; thus it's not good for ATI. This may be a far-fetched or overblown concern, but ATI will need a reason to "go uphill" against it when their current strategy seems to be doing just fine.

Intel, on the other hand, is in a different situation; as far as I know, they generally are playing catchup in the graphics area to NVIDIA and ATI, and as a result, they have more to gain and less to lose by opening their specs. [UPDATE] And as I mentioned in my previous post on this topic, the types of cards Intel sells are probably more interesting to free software users than the cards ATI sells. (I'm sorry you don't have any Intel cards -- they seem to have come automatically with most of the new computers I've seen lately, so I assumed it was a trend!)

Explaining Network Neutrality

2006-08-12T11:07:00.000-07:00

One of the problems with network neutrality is that people outside the technology industry often can't follow the arguments back and forth because of the complexity of the terms involved. On my vacation last week, I found myself discussing this topic with my ~80-year-old grandparents. Now, Grandpa and Grandma have no clue about technology, but they aren't dumb; they are both retired educators and follow current events (especially politics) with a strong interest. In my effort to explain just what the fuss is about, I had a sudden brainstorm and came up with the following analogy, which I post here for anyone who cares to use it:

Imagine that your power company decides that it wanted to open a line of supermarkets. At the same time, it sends out an announcement that supermarkets (due to their refrigeration requirements) are particularly heavy users of the electrical system, and as a result, the power company will add a 15% surcharge to the power bills of any building that it deems to be a supermarket. Of course, the power company's own supermarkets are exempt from this fee. When the existing supermarkets complain, the power company says that they're asking for special treatment and trying to get electricity "for free" and that if they don't like its terms, they should buy their power from someone else.

Obviously this greatly simplifies the technical issues involved, but it's the best illustration of at least one aspect of the problem that I've been able to come up with. I've enabled comments for this post, so feel free to add your own suggestions.

We aren't ATI's market.

2006-08-12T09:14:00.000-07:00

Erich Schubert noted that ATI is holding onto their closed drivers. While it's unfortunate, I don't think this should be surprising to anyone. NVIDIA and ATI make their money by selling cards for gamer types, who make an art out of trying to get the latest super hardware to play the newest snazzy games on. They don't give a hoot about source code access -- after all, they're probably running proprietary games on a proprietary operating system anyway.

Free software enthusiasts, on the other hand, spend their free time hacking code and so don't have time to play the massive productions the game industry puts out nowadays; frozen-bubble or Wesnoth are about as much gaming as we have time for. As a result, we can do just fine with a video card capable of displaying Emacs, a couple xterms, and maybe a graphical Web browser -- and the built-in graphics card (usually Intel) on the motherboard is just fine for that. We also tend not to run Windows or OSX, where 99% or so of graphically intensive games come out, so even if we HAD free time for gaming we wouldn't be able to do it on a free system.

As a result, while I'd certainly like to have free ATI drivers, I think it's unrealistic to expect them anytime soon. ATI is a company, not a charity, and they will not provide source code or specs until it will clearly benefit them more than it hurts. If you don't believe me, try walking into your manager's office and saying "hey, I have a great idea! Let's give away all our secrets without any clear way to make money off it!" and see how he reacts. (note that this experiment may not apply to the 1-5% [0] of readers lucky enough to work in academia)

[0] this statistic determined by the HIGHLY SCIENTIFIC method of picking a small number at random.

Amazing the things you learn when you fiddle

2006-08-01T23:43:00.000-07:00

I recently bought a new laptop, specifically a Fujitsu P7120 (based in large part on Joey's plug for it). I'm generally happy with it, but I haven't been able to get the headphone jack to work.

Today I had a few minutes and was fiddling around with it, when I noticed that there was an extra column in alsamixer labelled "headphone jack mode". This isn't a volume bar; it just displayed the text "50". Just on a whim, I tried hitting "up" on it, and quickly cycled through "80", "Line In", and then "Line Out". Jackpot! All of a sudden, sound started piping out of the headphones.

So, just in case anyone else is puzzling over this problem, make sure you've checked ALL the knobs alsa lets you turn!

I still wonder why alsa is defaulting to using a headphone jack as a microphone input...but I'm not so curious to, say, stay up even later trying to figure it out.

People suck, news at 11

2006-07-30T13:12:00.000-07:00

Continuing the saga of the lost wallet, it turns out that my uneasy premonitions about "Sidney"'s phone message were entirely correct.

He called me up at work, gave me a long spiel about how I should be glad he came from such a "respectful" family, mentioned that "someone" had gone through the wallet and taken the cash, and then asked again if there was a reward. Rude, I thought, but hey, rewards for wallets aren't unheard-of and he is doing me a favor...so I said, sure, I'll give you $20. There was a long pause, and then he said "that's really insulting, you know?" Taken aback, I asked what he was thinking of, and he said that he was thinking of more like a few hundred dollars.

A FEW F**ING HUNDRED DOLLARS?

That isn't quite what I said, I just said "No" and "I don't know what makes you think that's a reasonable amount." At this point he started asking again about "don't you want your wallet back?" and making vague threats about what would happen if it got into the "wrong" hands. I made one mistake, raising my bid to $40 (I shoulda just cut him off there), but finally told him I had to get off and get to work. He wouldn't give me a number to contact him at but said he'd call me later.

So, at this point it was obvious that a pretty nasty character had my wallet, so I double-checked that all my important cards were cancelled and started ordering duplicates of the remaining ones. I called my apartment manager (since my provisional license had my home address on it) and warned them to keep an eye out for suspicious people hanging around my apartment, just in case.

I did try calling the police; however, they were just as useless as you'd expect (considering I didn't know how to get in touch with the wannabe extortionist). The only thing they could suggest was that I try making arrangements to collect the wallet, then arrange to have a police officer arrest the guy when he showed up. Given the fact that I have no actual evidence of the extortion, though, I figured the main result would be to leave someone that I already know is a bad character, and who has my personal information and address, a grudge to hold against me. Not a good long-term move.

What depresses me most about all this is that "Sidney" is far more representative of the average person than I am, or (I assume) most readers of my blog; and he may very well be better adapted to the world than I am. People suck, life sucks, and the world sucks; I should be grown-up enough at age 25 to not care by now, but I still do. :-(

Wallet arghness

2006-07-26T20:53:00.000-07:00

This morning, when I got up, I couldn't find my wallet. I had it yesterday when I got on the bus (I pulled it out to pay my fare), and I went straight home from the bus, so I figured I might have left it on the bus. I called the lost & found office, and they said nothing with my name on it had been turned in to them.

When I got home I had a message on my answering machine from a guy named "Sidney":

"Hi, Daniel, my name is Sidney, and I, uh, found your wallet here, and just want to know ... is there a reward for it, or, uh ... you can reach me at (206)*BEEP*"

So, yay, I get to change my bank card number while hoping that the question above was intended more innocently than it sounded. And the new card won't arrive until after I leave town for a week, so this should be an interesting vacation (luckily I'm staying with family the whole time so money shouldn't be too much of a problem outside the airports). Meanwhile, I can see if I need to replace all the less important cards that I didn't get back, or if I can retrieve them from the guy who has the wallet. Obviously that last bit will require him calling me back and giving his entire phone number.

The one bright spot is that I just got an official Washington driver's license on Saturday, so my "real" license will hopefully arrive in the mail in the near future...that would be the most painful thing to be missing.

Meeting the Wisconsin state bird in Washington

2006-07-16T09:26:00.000-07:00

In Which our Intrepid Heroes Scale (or trudge along) Mountains While Defending Their Precious Bodily Fluids From The Local Fauna.

This is a continuation of my previous post about how I spent my holiday weekend. Yes, it took my a while to get around to it, why do you ask?

Day 1

On our second day in Leavenworth, we decided to hike up to Stuart Lake. This is a nine-mile round trip up the side of a mountain, culminating at an alpine lake; we figured it would make a nice site for a picnic.

The trip up was fairly smooth for about two-thirds of the way, at which point we discovered what we had forgotten in our preparations. Somehow, the fact that mosquitos can live on a mountain had escaped both of us, and we'd left the bug repellant at home!

The next couple hours were a nightmare of swatting, itching, and trying to move fast enough to leave the horde of bloodsuckers behind. We did make it to the lake, but only stayed long enough to take a picture and gobble down a sandwich while doing the Mosquito Dance (where you run in circles while flailing one arm wildly to repel the little nasties). As soon as we were done, we conceded the field and fled back down the mountain to less infested areas.

We got back at about 5, ate the remaining sandwich for dinner, and nursed our wounds until we fell asleep. The whole thing wasn't so bad for me, but Kate seems to be particularly sensitive to mosquitos, and by the time we made it back her whole arm looked like one big bite.

Paintings make the room pretty.

2006-07-04T16:30:00.000-07:00

<rant>
In my last post, I linked to the Wikipedia article on "kitsch". I generally use this to describe art that's in egregiously bad taste -- plaster sculptures of women with exaggerated breasts holding beer bottles, animal-shaped clocks whose eyes wobble with the pendulum, etc. I want to make this clear, because the Kitsch entry in Wikipedia suffers from a case of advanced artistic pinheadism. In short, their definition of Kitsch reduces to

It's pretty and people buy it.

For instance, Thomas Kinkade (the self-styled "painter of light") is disposed of with the offhand comment that his pictures are

scenes of stone cottages, lighthouses, cobble stone streets, rustic villages, and other vistas, with emphasis on the glittery ornamentation in the play of light and natural foliage. His work is meant to be sentimental, patriotic, quaint, spiritual, and inspirational.

While I'm a bit put-off by Mr. Kinkade's aggressive marketing, the quote above could only be considered a serious insult by people who describe the origins of the scourge of kitsch as follows:

Kitsch appealed to the crass tastes of the newly moneyed Munich bourgeoisie who, like most nouveau riche, thought they could achieve the status they envied in the traditional class of cultural elites by aping, however clumsily, the most apparent features of their cultural habits. ...

... in being “too beautiful” and democratic it made art look easy, non-involving and superficial. ...

In some sense the goals of democratization succeeded, and the society was flooded with Academic art, the public lining up to see art exhibitions as they do to see movies today. Literacy in art became widespread, as did the practice of art making, and there was a blurring between high and low culture. ...

The subjects and images presented in academic art, though original in their first expression, were disseminated to the public in the form of prints and postcards.

In short, "wasn't art great back when the only folks who could have it were rich aristocrats, back before those grubby ungewisserei [0] got their grubby hands on it and grubbied it up?"

I am reminded once more why I never took a single art course in college, and took only one English course (and that to fulfill a degree requirement). The worlds of "serious" art and literature seem to be about standing around in a circle telling all the other people in the circle how cultured and sophisticated you are, and how intellectually impoverished and shallow all the people outside the circle are.

Why are you sophisticated? Because you said so, and you ought to know. And be forwarned: any attempt to invoke logic will be refuted with an assertion that our thought systems are inherently socially constructed and there is no absolute truth anyway, except that we are far more intellectual and sophisticated than you.

This has gotten a bit long -- but in short, anyone who looks down on another human being because they would rather have this hanging on their wall than this has frankly given up any right to be offended by the term "self-important pinhead".

[0] This may not be proper German, but as I am apparently an inferior man-child for not seeing instantly how awful kitsch is, how can I possibly be expected to get any language but my own right anyway?
</rant>

Not Bavaria, but still fun.

2006-07-04T15:15:00.000-07:00

With today being a federal holiday, Kate and I decided to take a four-day weekend and head to Leavenworth. This is a little town up in the Cascades that calls itself Washington's Bavarian village, and seems to be part of the complete Seattle experience -- everyone around here has visited it at least once. The short description is that while the Bavarian theme is a bit of a gimmick, there's good hiking in the area and some good food (if you don't mind the touristy atmosphere).

NOTE 1:

Why is this post written in the present tense? 'cos I felt like it.

NOTE 2:

For the convenience and sanity of people reading this on aggregators like Planet Debian, this saga is broken into segments.

Day 0

We get a late start leaving Redmond and drive along some pretty spectacular scenery on Highway 2 East ... although after living here for a while, I've become somewhat inured to spectacular scenery. Another craggy mountain with snow-spotted alpine meadows, thousand-foot waterfalls, and blankets of pine forest? You woke me up for THAT? But even by the standards of the Pacific Northwest, this is a scenic drive.

Kate has picked out a short hike about halfway to our destination, but when we pull up to the trailhead we learn that a Northwest Forest Pass is required to park. We decide to cut out that hike and make a note to buy a pass when we get a chance. Probably they're sold in Leavenworth. Further on we see a little picnic area with a path going back into the woods. We decide to stop there for lunch and follow the trail, which turns out to be a pleasant loop through a patch of forest and up to a decent-sized waterfall.

We arrive in Leavenworth in the afternoon. The town has done an impressive job of building a city center of half-timbered buildings in what looks to me like a reasonably German style (bearing in mind that my last visit to Germany was about ten years ago when I was in high school). They even have a two- or three-story clock tower. After checking into the bed-and-breakfast where we're staying, we head downtown to explore.

Leavenworth, at least in the city center, looks very Bavarian from the outside. It's a little less impressive when you actually go in the buildings. Most of the shops sell generic American tourist junk -- shirts that say I can only please one person per day. Today is not your day. Tomorrow doesn't look good either., kitschy statues (women holding beer tables on their breasts), etc. However, while I see very little that's recognizably Bavarian in town, there are some stores with nice selections of work by local craftsmen and artists.

After looking around a bit, we head to the Andreas Keller Restaurant for dinner. We have a nice meal of jägerschnitzel, spätzle, red cabbage and knackwurst while listening to (live!) accordian oom-pah. I am surprised to see the Chicken Dance mixed in with the rest of the performance, but Wikipedia says that this was composed in Switzerland in 1950s for the accordion under the name Der Ententanz. Live and learn.

After finishing dinner, we walk back to the bed-and-breakfast and get an early sleep.

Seth Crosson, are you out there? Your mother would like to speak with you.

2006-06-24T16:48:00.000-07:00

Ever since I hooked up my phone line, I've been getting calls for someone named "Seth Crosson". The first call was fielded by my answering machine, and I figured it was a wrong number. The first two calls were from schools, and I figured maybe they just had an old number. But a few weeks later, I started getting calls from this guy's friends and family, wondering where he had gotten to.

Seth, whoever you are, if you by any chance happen to read this, please call your mother and let her know where you are. Also, please tell your family what your new number is so they stop calling me and asking for you. If you give me your new phone number (preferably by calling your old Redmond number), I'll be happy to redirect people to it.

And, next time that you move, please tell people that you are moving and where you're moving to, so they don't have to call the poor guy who gets assigned your old number.

Thanks.

Unsubscribing from most Debian lists.

2006-06-18T09:06:00.000-07:00

After six (seven?) years of being almost continuously subscribed, I have decided to finally remove myself from most Debian mailing lists. While I don't intend to actually unsubscribe, I even doubt I will continue reading -private. No, strike that. I especially doubt I will continue reading debian-private.

This is not a decision that I wanted to make or took lightly, but two ongoing problems, combined with my own lack of free time, have convinced me that it is the best route:

(a) Virtually all the traffic on the lists is useless. I don't think this was the case when I subscribed, but it certainly is now. The few interesting technical or procedural tidbits that I can find are buried under (and within) piles of messages that are useless flames, off-topic discussions, kooky threads, or mails that combine two or more of the above.

(b) The tone and content of the lists is increasingly hostile, personal, and aggressive. Based on what I see on the lists, Debian is not a friendly project these days. I'm sad to say it, but being able to block the rest of the Project (except bug reports, of course :) ) out will not only increase the time I have for Debian, it will increase my motivation to work on it. A lot.

The straw that broke the camel's back here was that after finally getting my Internet access back a couple weeks ago, I decided to catch up on Debian list mail this weekend. After spending a significant fraction of my free time just wading through the sludge and reading the most useful and interesting-looking of the mail that people had spewed onto the lists, I realized that I would have been far better off doing something more useful, enjoyable, and productive with my time ... like, say, picking lint out of my carpet by hand, or committing Postal Service regulations to memory.

I'm still of two minds about the whole issue: while I blamed the lists above, there are plenty of major contributors to Debian who have full-time jobs and still manage to not just read all the garbage on the lists, but actually reply to a lot of it. So I can't help feeling this is partly due to my own inadequacy or advancing decrepitude (I turn 26 in just a few months; isn't that about when your brain atrophies? ;-) ) -- but regardless, I think that I personally can't justify the "expense" of staying on the lists in terms of the benefits I get from doing so.

Still Not Dead Yet

2006-05-17T20:30:00.000-07:00

If it looks like I've fallen off the 'Net recently, it's because I have. In addition to the usual problem of having relatively little free time since I started working, I've been spending the last month or so moving into a new apartment. Much of my free time has been occupied by either planning what to buy and put in my apartment, shopping for stuff to buy and put in my apartment, hauling stuff home from stores into my apartment, and (in the case of IKEA) assembling the stuff I just bought in my apartment.

On top of that, I haven't hooked up an Internet connection yet. This is partly because I'm dissatisfied with all the available options -- which, in my area, seem to be Verizon and Comcast. Since I'm not interested in cable TV, the cheapest choice is Verizon, and I just finally got them to officially hook my phone line up. This was a more complicated process than you might think; they require you to fax them both sides of your driver's license before they'll activate a phone service (presumably to make the NSA's job a bit easier as they snoop on your traffic). It also looks like I probably can't get DSL service until I receive my first phone bill and get a phone number I can enter into the DSL request form on Verizon's website, so I won't be properly connected for another few weeks.

I think that Kate wants me to get off the computer so she can use the internet, so I'll cut off here. More later, maybe.

No More Retail Electronics Stores

2006-03-25T13:45:00.000-08:00

So, to wrap up the hardware saga I posted in the last few weeks, my memory chips finally arrived yesterday (after being delayed in Oregon for three days by "inclement weather"). I swapped them for the bad ones in about ten minutes, turned the computer on, and it worked. After I played a couple missions in Homeworld 2, I rebooted and let the memory test run all night, just to be totally sure. No problems :-).

Sadly, we seem to have lost the receipt from when we returned the first bad batch of RAM, so Fry's may get to keep Kate's money. Regardless, they've certainly managed to lose one or two customers, at least when it comes to computer hardware.

Memcheck good; Fry's not so good

2006-03-18T21:15:00.000-08:00

So, after finding a CD that had memcheck on it, I ran a memory test on the new system I had assembled but couldn't get working. Unsurprisingly, it produced a bunch of errors, especially in test 8. I tested the memory modules one at a time, and confirmed that one of them reliably failed test 8 with, while the other survived multiple passes of memcheck's whole arsenal of tests without skipping a beat.

OK, no biggie; I got a bad RAM chip, I'll return it. So we take it back to Fry's, I explain that I ran a memory checker on one of the chips and it came up bad (I even helpfully gave them a note indicating which of the two seemed to be the problem), and asked to exchange it for a new chip. The customer service guy vanishes, then comes back a while later with a different chip in a box. As we're preparing to leave, Kate notices that the "new" box is opened. "Why's that?" she asks. "Oh, testing," the customer service guy says.

Testing. That's good, right? So we shop a little, take the chips back, and I plug them in. I figure, hey, never hurts to be too careful, and boot up memcheck. BAM! Within half a second the screen turns red with errors. In comparison, with the first set of chips I had to run the tester for up to fifteen minutes before I got a test failure. Trying the chips individually, I discover that 300MB on one is just (as far as I could tell) gone. It fails every single test. The other one survives the first few checks, but fails test 8 just like the other bad chip I had. [UPDATE: it's actually not that bad; it does seem to have problems, but it doesn't fail on every single run of test 8, and it was able to run the Kororaa live CD]

Now, as I see it, we have the following possibilities:

(a) My luck sucks and I just got three bad chips in a row.

Possible, but I've bought at least a half dozen memory chips in the past (not counting ones that came in preassembled systems) and I'm pretty sure this is the first, maybe second time I've seen a bad one. Three in a row? That's ridiculous.

(b) I screwed up and blew out the chips while installing them.

Unlikely for the same reason as (a). I may be shaky on some hardware stuff, but I know how to install DIMM chips. Killing one might be in the realm of possibility; killing three out of four? Don't think so.

(c) The chips aren't compatible with my motherboard.

The chips are listed as being DDR400, which ought to be perfectly compatible with the motherboard. They are installed in the proper configuration (according to the motherboard's manual); besides, one memory chip worked just fine.

Assume that (b) and (c) are indeed false: the chips are really bad and I didn't destroy them. This, combined with the fact that Fry's "testing" didn't catch the blatantly obvious problems with one of the new chips, make me wonder if

(d) Fry's decided to save costs by handing me a pair (maybe even two pairs) of chips that another customer had returned, on the theory that returns are on average spurious.

The main problem with this theory is that I don't see why they wouldn't have resealed the package; maybe they just suck at testing memory or didn't bother to. On the other hand, I have seen a number of complaints online about Fry's and other big retailers engaging in this practice. (e.g., Google for "Fry's restock")

Either way, whether it's deceptive practices or just plain incompetence, I'm afraid this hasn't left a particularly good taste in my mouth about Fry's, and I'll probably just try to get a refund and buy the memory elsewhere. The only downside is that "elsewhere" more or less means "online", which means no instant gratification. However, since "instant gratification" in this case has been more like "instant non-gratification", I'm willing to live with that.

Windows stupidities

2006-03-18T10:05:00.000-08:00

As I've had to use Windows on a daily basis, I've found that I am no longer able to maintain my air of detached tolerance for the foibles of the system. In fact, I'm starting to get really infuriated with the utter boneheadedness of so many facets of it. Not so much things that are broken, as things that are done badly, and done so in the face of widespread examples of how to do it right.

Here are two simple examples that are emblematic of what Windows users have to suffer through.

(a) Mandatory file locks.

On Windows, every access to a file, by default, acquires a mandatory lock on it. Want to recompile the program you're working on? Sorry, you have to track down and kill all its running instances. Want to read that file on the network server? Sorry, you'll have to run around the office and ask all the people using it to close it.

Last week I got an email asking me to unlock a directory on our local fileserver so it could be renamed. It turned out that I was running an acroread process to view a PDF file...and that locked the directory from being renamed. Because, of course, the universe would implode if someone were to rename a file I had already loaded into memory. This is, however, better than how shared libraries are treated; trying to register a new version of a shared library with the system (the Windows version of ldconfig) will silently fail if programs have the old version mapped into memory. WTF? No, really, WTF?

Windows users get around this by having tools to find out which processes have a file open so they can terminate them with extreme prejudice. This is considered normal and acceptable behavior for a computer in the Windows universe. After all, in the real world two people can't use the same document at once, so why should they be able to do so on a computer?

(b) C# events.

They've been invented many times. Signals, events, hooks, whatever you want to call them, they're collections of function objects that are invoked when some particular condition occurs. It's a great way to make it easy to connect together objects that don't know about each other, they're simple enough that your average CS sophomore could implement them in a half hour, and the concept is so obvious (besides having dozens of examples of working and deployed implementations) that there's no way to screw it up, right?

Wrong.

Now, C# is generally a somewhat clunky language, but this is nothing to do with that (I am not, for instance, surprised that it's cumbersome to bind extra parameters to an event in a language that has little support for higher-order programming anyway). No, this is one of those utter idiocies that just make you scratch your head and go what the *@&# were they on when they did that? You see, when you call an event with no attached listeners, C# throws an exception. Just, you know, as a friendly way of letting you know that you didn't connect to that event.

But wait! It gets better! In order to test whether the event has any connected delegates (the Microsoft term for a function object), you ... compare it to the null pointer. Yes, that's right. Every time you call an event, you have to do this:

if(Event != null)
    Event();

...because, of course, an empty collection of events is clearly the same thing as a nonexistant object.

I really wish I could be a fly on the wall at the meeting where this was decided. My imagination supplies a scene along these lines:

Scene: A smoke-free office somewhere deep in the sterile labyrinth of the Microsoft campus

Programmer 1: "...and we call this bold new innovation 'events'! It's a way for you to perform method calls without knowing which method you're calling. We've found that it's amazingly useful when doing UI programming. I'm sure that introducing this new idea to the world will be yet another chapter in the Microsoft story of advancing technology!"

Programmer 2: "Have you checked the corner cases? What happens if there is no method available to call?"

Programmer 1: "Oh, of course! In that case, the list of methods is null, so we throw a NullPointerException. We thought about adding an IsEmpty property, but who would want to look up properties on the null pointer? Besides, hardly anyone will ever want to create an event that might not get connected to."

Programmer 2: "Uhhh, sure, that makes sense to me."

...!!!?!?!?!

So close, yet so far away...

2006-03-17T22:58:00.000-08:00

So, thanks to Marc's helpful advice yesterday, I took another look at my power supply, and lo and behold, there was a second four-pin power cord that I hadn't seen!

Allow me to explain. In my previous post, I mentioned that I had been doing something "wrong" with the power cable. You see, the case we picked out (an Antec Sonata) has a 24-pin power cable of which 4 pins can detach for older systems. At first, I misread the manual and thought this was for newer systems, so I detached it and plugged it into the handy 4-pin plug next to the CPU. Doh. Having corrected that (without the extra 4 pins in the main plug, not even the fans turned on), I was under the further mistaken impression that the 4-pin plug on the motherboard was the backwards-compatibility plug. I did actually check for an extra 4-pin PSU connector, but I must have overlooked the one that existed.

In my defense, here's what the manual states about the power connector:

This motherboard provides two power connectors to connect ATX12V power supplier.

NOTE: This 24-pin power connector "ATXPWR1" is compliant to the former 20-pin type. Pay attention to the orientation when attaching the power cord. (Pin-11, 12, 23, and 24 should be left un-connected).

Note: It is recommended to connect to a power with 350W, 20A +5VDC capacity at least for heavily loaded system, and a 2A +5VSB capacity for supporting wake-up features.

Not exactly crystal-clear on what needs to be connected under what circumstances. The case manual is at least correct if you follow along carefully, and they even found someone who can speak the language. Unfortunately, this section is phrased in a way that's highly prone to misunderstandings, particularly if you have an incorrect idea lodged in your head to start with:

Connect the 24-pin Main Power Connector and the 4-pin +12V connector to your motherboard as needed. If your motherboard uses a 20-pin connector, detach the 4-pin attachment on the 24-pin power connector.

You have to read that quite closely to realize that there are two 4-pin connectors involved!

Anyway, so I can actually get the machine to post and boot. Unfortunately, it's highly unstable once it does boot. It runs for up to several minutes, but then exhibits various sorts of erratic behavior: freezing, spontaneous reboots, random error messages, that sort of thing. I've made sure all the cords are plugged in tightly and reseated a couple components (particularly the memory); about the only thing I haven't checked is the CPU+heatsink mess, which would be a real pain to disassemble and re-assemble.

Still, it's nice to make some progress. Maybe tomorrow I'll discover some other cable I forgot to plug in that will make everything work (hey, I can dream).

I Hate Hardware Redux

2006-03-16T21:54:00.000-08:00

After my last experience, you'd think I'd have learned. But nope, when my girlfriend needed a new desktop system, I enthusiastically offered to build one for her. Hey, this time it's desktop hardware, and I know desktop hardware, right? I built my last machine myself, and I've replaced a couple motherboards and done various other work on computers since then.

Well, it seems there were a few changes since my last computer. First of all, there's the whole business of heatsinks. I don't remember spending any time on the heatsink last time around. I suppose this is because it was pre-attached to the chip or because the assembly process was "place the heatsink on top of the CPU", but I don't remember which. For the Athlon 64s, the heatsinks are so ginormous that you couldn't place the CPU into its slot if it was attached to the heatsink. So there's no option but for them to ship the two separately and have the user assemble them.

Problems? Well, consider the documentation. The store sold us a supposedly complete CPU box packaged by AMD which, when I opened it, contained a stern warning not to attach the heatsink without first applying a thermal material. Contradicting this, though, was the fact that there was something that looked suspiciously like thermal material already on the heatsink, and after quite a bit of research I decided that the warning was for people who want to overclock their systems or replace the stock thermal compound. Nowhere in the documentation does it say whether the heatsink comes pre-treated with thermal compound, though, and since I have no desire to let the magic smoke out, I wasted a lot of time checking up on this.

A second problem with the documentation is that it suffers from severe Lowest Common Denominator syndrome: the installation instructions are entirely word-free. For simple purposes this might suffice, but it took me a lot of squinting and several incorrect tries to figure out WTF the diagrams were telling me to do; in fact, I didn't really figure out what to do until I found an annotated version online with actual words. AMD, there's a reason we quit using cave paintings and invented written language. Please use the stuff, it'll make the rest of us much happier.

On to the practical problems: it's apparently necessary to attach the heatsink so tightly that you need a latching mechanism the size of Wyoming to hold it onto the motherboard, and actually activating it seems to take several metric tons of force. OK, I exaggerate, but just this step (attaching the heatsink assembly to the CPU) took me at least an hour of prying at the latch mechanism to lock it down. In fact, I didn't finish until I finally gave up using my fingers and used a screwdriver to apply a good portion of my weight. Predictably, of course, the screwdriver slipped as I secured the latch, bouncing off the motherboard. More on that in a moment.

The motherboard (an Abit K8N) had better documentation than the CPU, but not by much (this is apparently a pattern with computer components that most consumers never mess with). I had to make educated guesses about the orientation of several connectors, especially some of the case connectors, and it took me at least a dozen reads to understand what I was doing wrong with the power cable.

Once I got all my initial stupidity worked out, I flipped the switch and watched some of the fans turn on and the hard drive spin up...and that was it. Nothing. Nada. No beeps. No POST. Not even a blank video signal (although the video card's fan runs just fine).

So, my best guess is that I killed the motherboard dead with my screwdriver, which means I get to go buy a replacement and install it. And, of course, disassemble all the stuff I carefully assembled already. Including the CPU assembly. And the thermal material on that probably won't be good any more, so I'll have to replace it with what's left over from when I rebuilt my laptop. And there's always the possibility that it's actually the CPU that's dead (although I can't imagine why)...in which case I could waste a lot of time and effort replacing the motherboard needlessly. Blah.

I begin to think that it might be worthwhile to pay the store to install the critical components for me, or even just buy from a real PC vendor. At least then I'd avoid wasting my time and (presumably) get my money back if they screwed up.

Windows in 1998

2006-02-18T09:08:00.000-08:00

In response to Jeff Bailey's blog post, "David" wrote:

Surely the answer is in the question. Linux is at the state of Windows in 1997 or 1998. So why would users go back almost a decade?

The last time I used Windows for much was in 1998. Of course, to actually get paid for my work I had to agree to work on Windows again, full-time. After a month and a half it seems to me that aside from crashing less, Windows is at the state of Windows in 1998.

Arguments that are difficult to refute.

2006-02-18T09:04:00.000-08:00

I was recently discussing the merits of free vs not-free software with one of my coworkers, when he pointed out that my position was self-defeating, since without non-free software programmers like us would be unemployed and broke in Greenland. Well, he didn't add "in Greenland", but it did a pretty good job of shutting me up anyway.

How much speed are you willing to give up for pretty code?

2006-01-29T12:24:00.000-08:00

After experimenting a bit with Haskell and using it for some toy projects, I decided to see if there was any chance it could be used for a non-toy task; i.e., one where it might one day be necessary to actually have fast code. As a proxy for this, I decided to try a very simple task: counting the number of lines in a file. As input, I generated a file with a million lines of random data and an average of 40 bytes per line; all the Haskell programs were compiled with the current GHC in Debian unstable and with optimizations enabled.

The baseline is, of course, our friend "wc":

real    0m0.084s
user    0m0.043s
sys     0m0.040s

(this and all other timing data was taken after "cat /tmp/testwc.txt > /dev/null" to ensure that the file was cached) Now, it's probably too much to hope that a Haskell program will run as fast as a C program does, since the C program can run in a tight loop. But it seems reasonable that it should be possible for Haskell to be competitive with the trivial Python implementation of this program -- after all, Python is interpreted and Haskell is compiled.

import sys
n = 0
for line in sys.stdin:
   n += 1
print n

Running this simple Python program under "time" produces the following statistics, a bit less than 10 times slower than the C version:

real    0m0.698s
user    0m0.643s
sys     0m0.050s

The trivial Haskell program to count the lines of its input is:

main = do c <- getContents ; print $ length $ lines c

Note that this is basically identical to the Python program, but expressed in a functional style. Pretty, but how does it stack up?

real    0m6.744s
user    0m6.426s
sys     0m0.213s

OW! Ten times slower than the Python code, and a good 80 times faster than "wc"! The gap can be lowered to "only" 50 times with the following program --

do c <- getContents; print $ length $ elemIndices '\n' c

-- but surely it's possible to do better. I'd expect that the expense here is in the use of lazy streams for IO; eliminating them gives us the following code:

wc :: Handle -> IO Int
wc h = do a <- mallocArray bufSize :: IO (Ptr Word8)
          loop a 0
    where loop a n = do amt  <- hGetBuf h a bufSize
                        elts <- peekArray amt  a
                        (if amt == 0
                         then return n
                         else loop a $! n + nlCount elts)

At this point, we're basically using Haskell as a (bad) imperative language. This function allocates a buffer, repeatedly reads into it, and counts the number of newlines in the buffer (I dropped some auxillary code to keep the post short). The $! is important; without it, even though this routine is tail-recursive, Haskell will still allocate an unbounded amount of memory to store the return value. (because, of course, it's terribly important to remember that you're actually returning "1+2+3", not "6")

So, how does this unreadable, hand-optimized version of the code perform?

real    0m1.980s
user    0m1.757s
sys     0m0.094s

That's right -- I've eliminated most uses of higher-level functional techniques, and the Haskell version is still two times slower than an ultra-high-level interpreted language, while also being uglier and harder to read! Ouch. It appears the old performance albatross of functional languages is not quite dead yet.

Gainful employment rules

2006-01-05T20:11:00.000-08:00

In December or so, I finally got offered a job with a small software company based in Seattle, starting on January 3rd (Tuesday). This means that I have income again (yay) and I have health insurance for the first time since September (more yay), but it does also mean that my time to work on free software, and Debian, and my blog, will be pretty limited, especially for the next few months.

Speaking of which, I am still looking for someone else to work with me on aptitude, particularly as I'd like to spend my no-longer-copious free time working on other stuff in a language that doesn't suck (probably Haskell). Any vic^H^H^Hvolunteers?

Legibility, A Brief Thought Regarding

2005-12-09T22:28:00.000-08:00

On a lot of web sites, the printable version link should be relabeled legible version.

Linguistic Contortions

2005-12-01T12:43:00.000-08:00

I thought I had seen everything when it came to ways of resolving the problem of gender-specific pronouns in English. But on the way back from Wisconsin yesterday, I read a copy of David Brin's Sundiver (otherwise an interesting story) and was proved wrong.

Usually the problems you run into with English revolve around the pronoun he: its use in a gender-ambiguous context is disputed and there are various ways of avoiding it. The word man has similar problems, although it's a lot easier to find acceptable gender-neutral replacements. But in this story, Brin actually used man in situations where the person indicated was known to be female! This leads to such eye-popping lines as:

He took her arm and introduced her to Fagin and Jacob.

Sophonts, this is Helene deSilva, Confederacy Commandant here on Mercury, and my right-hand man. ...

And if that doesn't strike you as odd, here's my personal favorite:

Occasionally a man, male or female, would lean forward and peer at some detail on a screen, ...

Ow! I had to read that sentence three times before I was sure I hadn't mistaken the words.

Music for everyone

2005-11-24T19:21:00.000-08:00

Several years ago (it seems like more than three) I was a student at Brown University. In addition to studying computer science and mathematics, I also took a bunch of courses in the music program, including three years of piano lessons. When I graduated, I gave a recital for friends and family, plus any members of the public who happened to wander in (not many did). And, this being the 21st century, we recorded it and I got a CD of the recording. I edited it, split it into tracks, and handed some copies out to my friends and professors as a going-away present.

Now I'm no longer a student of any sort, and Brown seems a lifetime away, but the music is still sitting on my hard drive. I've always meant to make it available for download, but I couldn't figure out how to get past technical issues of space or bandwidth. A few days ago, though, I had a rather belated bright idea: maybe the Creative Commons project would have links to places where you can host your music for free. Lo and behold, it turns out that the Internet Archive lets anyone upload audio to their server! Better yet, they're even willing to store lossless encodings -- more than willing, actually; FLAC is the preferred encoding of uploads.

So, to make a long story short, click here to hear my bad piano playing. :-)

Lentil-based protesters

2005-11-24T18:15:00.000-08:00

NPR just mentioned that some protesters camped outside Bush's ranch are having lentil soup and rice for Thanksgiving to show their solidarity with the Iraqi people. Which I found amusing to listen to while eating my evening ration of lentil soup. Here I thought I was just a cheapskate, when all along I've been participating in superficial solidarity with the bombed-out people of Iraq! :-)

Thread pattern recognition

2005-11-23T23:19:00.000-08:00

After reading the dpkg-sig thread, I finally realized that I could have saved a lot of my time by I taking Joey Hess's advice on thread patterns and deleting or at least ignoring most of its subthreads.

A type-system hack

2005-11-21T09:15:00.000-08:00

WARNING: nothing in this post has been implemented or tested, except maybe at a minimal proof-of-concept level ("it compiles!"). It's just some musings on how you can make the computer do your work for you.

I was reading a defense of Hungarian notation when I started to get a familiar notion tickling the back of my brain. The author was explaining that the original idea behind Hungarian was not to replicate type information in variable names, but rather to include some sort of usage information: one example would be giving a string value holding a value that is untrusted the name utName. While it's more reasonable than lpschwzMyVariable, this suggesion made me suspicious that the author was really hacking around suckiness in the C language.

Tagging values with usWhatever and then verifying that you never mix usBlah with Blah isn't just tedious and error-prone, it smells a lot like doing work by hand that the computer ought to do for you. It seemed to me that it ought to be possible to "tag" unsafe values at the type level and let the language's type-checker sort things out. The simple approach is of course to define something like this:

newtype Unsafe t = Unsafe t

NB: I'm using Haskell because it was the first language that sprang to mind when I thought "type system hack".

This newtype declaration lets you attach an Unsafe tag to any type. Presumably the type signatures of routines that return untrusted data (such as a hypothetical getHTMLFormValue or a routine to retrieve previously entered form values from a database, if they aren't sanitized first) should be modified; for instance, if the signature of getHTMLFormValue was

getHTMLFormValue :: HTMLForm -> String -> String

it should instead read

getHTMLFormValue :: HTMLForm -> String -> Unsafe String

To create a new Unsafe value you simply apply the Unsafe constructor to the value:

getHTMLFormValue = Unsafe (oldGetHTMLFormValue)

To unwrap Unsafes you use pattern-matching:

let (Unsafe unwrapped) = wrapped in ...

So, this sort of works, but it's unsatisfying on several levels:

It allows the creation of types such as Unsafe Unsafe Integer and even Unsafe [Unsafe Integer]. If a value is already unsafe, how can it be "more unsafe"? And what in the world is an unsafe list, or an unsafe list of unsafe values?

Unfortunately, this is probably a limitation that any scheme that relies on type-tagging will have. You can get around it by either explicitly defining each new unsafe type:
```
newtype UnsafeString = Unsafe String
```
This is arguably a good idea anyway, since virtually all unsafe values (in the sense the previously linked article mentiones) are likely to be strings, and as I note later, it's not clear how to "sanitize" a non-string. OTOH, placing unnecessary type restrictions feels un-Haskellish to me, and it seems likely that you can trust the programmer not to pile up Unsafes.
This scheme makes it very tempting to strip off the unsafeness of a value and lose the fact that you did so.

Since the only way to strip off unsafeness is via pattern-matching, it seems to me that it would be tempting to pattern-match away the unsafeness in function declarations:
```
foo (Unsafe x) = ...
```
This may be just fine, but my preference would be to forbid pattern-matching altogether (by not exporting the constructor directly to other modules; just export a normal function that constructs an Unsafe value) and instead providing two routines to remove unsafety:
```
escapeData :: Unsafe t -> t
unsafeExtractRawData :: Unsafe t -> t
```
The first routine encodes the data into a "safe" form, while the second simply fetches the wrapped value:
```
unsafeExtractRawData (Unsafe x) = x

foo x = doSomeStuffWith (unsafeExtractRawData x)
```
The rationale here is twofold: first, by giving the dangerous extraction routine a scary and hard-to-type name, you remind yourself to think twice before invoking it (cf unsafePerformIO); second, you can easily audit all the locations where the unsafety is "stripped away" with a textual search.

There are some issues involving the safe encoding -- you probably ought to make a typeclass of things that can be safely encoded from an Unsafe value; not too hard and this entry is already too long.
The final issue involves manipulation of Unsafe values. So far you can pack and unpack Unsafes; however, this seems like it would get a bit annoying if you had to do any significant operations on them. For instance, searching in an unsafe string for a substring seems like it would be a pain and a bit error-prone (since you'd have to remember to wrap the string back up in an Unsafe). You might think that ideally, all normal String operations should work directly on an Unsafe String or pairs of Unsafe Strings -- you just shouldn't be able to convert between the two.

Unfortunately, I can't see any way of doing everything that you'd want to here. For some types you can. For instance, the following definitions let you compare values wrapped in Unsafe in the usual way:
```
instance (Eq t) => Eq (Unsafe t) where
    (==) (Unsafe v1) (Unsafe v2)   = v1 == v2
    (/=) (Unsafe v1) (Unsafe v2)   = v1 /= v2
```
This admits (Unsafe t) to the Eq class, and looks reasonable enough (assuming that it's safe to compare unsafe values, of course). However, for probably the most important Unsafe values -- Unsafe Strings -- I can't see how to do this. The problem is that String is not a typeclass, it's a synonym for [Char], a list of characters. The important string operations are either defined directly on the String type, or generically on [t]; i.e., "a list of anything". Because there is no typeclass, you simply can't overload these operations to apply to unsafe strings as well as regular strings.

One way around this is to provide an "unwrapping combinator":
```
liftUnsafe :: (t -> t) -> Unsafe t -> Unsafe t
liftUnsafe f (Unsafe v) = Unsafe (f v)
```
This would automatically convert string operations to unsafe-string operations; not ideal, but reasonable enough. Operators are still a little annoying, but you can mangle their names:
```
(++u) :: Unsafe [t] -> Unsafe [t] -> Unsafe [t]
(++u) = liftUnsafe (++)
```
So you have to use ++u instead of ++ to concatenate unsafe lists; not too bad.

While it may not be perfect -- it only makes sure that you don't accidentally violate safety, and doesn't stop you from deliberately doing something dumb -- this approach feels a lot safer to me than ad-hoc mangling of variable names. I used Haskell because you can do type hacks fairly easily in it, but I don't see why you couldn't play a similar game (albeit much less conveniently) in C++, or even in a dynamic language like Python. Of course, Python would give you runtime errors about safety violations instead of static ones, but that still beats getting runtime security holes.

I would add as a hypothesis that it should be possible to express just about any variable-name-mangling technique whose goal is to "make wrong code look wrong" in the type system, provided your type system doesn't suck; and that doing so is preferable to doing it manually, since it means that a lot of repetitive error-checking can be handled by the computer. And since the computer is better than you are at verifying formal invariants, forcing it to handle them whenever possible is always a good idea.

On the usefulness of advice.

2005-10-13T12:19:00.000-07:00

A few of the points stressed by sites that peddle advice on finding a job include things like "never send a resume without a cover letter" and "avoid the one-liner cover letter that says 'please consider my application for this position'".

Oddly enough, of the three employers that have actually responded to my applications, I didn't send any cover letter at all to one, and I sent the Forbidden One-Liner to another. Nearly every application that I've slaved over to produce a well-written cover letter (going by the common wisdom I get from just about everyone) has apparently gone straight to /dev/null. I'm beginning to think I should just quit wasting my time on these things and aim for quantity rather than quality.

Announce: leafsmtp

2005-10-11T22:26:00.000-07:00

I recently redid my whole mail setup to use mutt and modular programs for sending/receiving mail. Since I've generally found a full-fledged MTA to be overkill and an unnecessary pain to configure for a personal system, I tried out a "simple" SMTP relayer called esmtp. It was OK (aside from my configuration confusion), but it has a few small deficiencies, esp. the fact that it doesn't manage a queue, thus forcing all deliveries to run in the foreground. Having determined that Python modules exist to run the client (and, in fact, the server) end of an SMTP session, I decided that it can't be that hard to write my own implementation of these programs with just a bit more oomph.

Happily, I turned out to be right. After three days of hacking, I now have a fully-functional...or at least functional enough to relay my email around...email system in a mere 736 lines of Python. It can put messages into an on-disk queue directory (~/MailQueue by default); the benefit here is that it makes it totally safe to background the delivery process, which is nice if you happen to have a slow SMTP server or (when using it as a delivery backend for getmail/fetchmail) run a lot of time-consuming spam checks. Without sticking the mail on the disk while it's being delivered, there is a chance that you'll lose mail if the delivery fails, especially if the delivery process has forked into the background. And unlike complete MTAs such as exim, this all works without needing anything to run as root (unless you want to deliver to the mail spools of other users).

There is no Debian package. In fact, there isn't a proper source package, but you can pull down the upstream repository with

darcs get http://people.debian.org/~dburrows/darcs/leafsmtp

You'll have to either pass the --set-scripts-executable parameter to darcs, or run "chmod +x" on the leafsmtp executable once it downloads. There's only a little documentation, but hopefully it's enough to get you going.

Oh, and the name: it is, of course, indicative of the fact that this is meant to be a reasonable mail system for leaf nodes on the Internet. It's a little inaccurate, since a leaf node could receive mail directly, but it sounds a lot nicer than most of the other things I thought of :-).

More lines-of-code nonsense

2005-10-07T16:18:00.000-07:00

After my last post about lines of code in aptitude, I was wondering how the program has grown over time. Plus, someone pointed out that I ought to be using sloccount to get a more accurate picture, since it ignores blank lines and comments. So, with a bit of hacking around to extract information about past aptitude versions, I present the aptitude-over-time graph:

The "zigs" in this graph represent overlapping development cycles of the program. It's interesting to note that about 1/3 of the source lines in 0.3.4 are ignored by sloccount because they contain only comments or whitespace.

A PostScript version and the raw data are also available (the last column is the supposed number of person-years it would take to produce the program according to a formula which, in the words of an IRC denizen, "is useful to convince your boss you need a pay raise").

P-E-B-C-A-K

2005-10-06T17:43:00.000-07:00

If you want to set up your email so that you send it using esmtp and mutt, be sure to put "set use_envelope_from=yes" in your mutt configuration, or dreadful things will happen and your mail will end up in the ether between the worlds. Really.

Actually, I wonder how many of my problems with using "real" mail transport agents and mutt would have been avoided had I known about the existence of this simple option. Oh well, live and learn.

A cry from the bitbucket

2005-10-06T10:43:00.000-07:00

Well, I've pretty much come to the conclusion that I cannot send mail to many important @debian.org addresses. I know my mail is working because I can email myself (including @debian.org), and mail I've sent to anywhere except @debian.org works. However, since a few days ago, all my mails to bugs.debian.org, whether bug submissions or additional information on bug reports, just vanish (other people's mails are going through, so the system isn't broken); repeated (GPG-signed) requests to changes@db.debian.org to update my SSH keys have gone unanswered and un-acted-upon; and several mails to the lists have vanished into the ether. I've emailed a few role addresses about the issue, but I wouldn't be surprised if those emails get dropped on the floor as well.

Since it appears this is about the only way I can contact Debian people, could someone with admin access to our mail system please tell me why I'm shut out? This started when I changed how I send mail, so it's possible I misconfigured something (although I'm just forwarding through my smarthost using ESMTP), but I need to know what it is in order to fix it!

aptitude goes distributed

2005-10-05T00:17:00.000-07:00

As I've hinted at in a few recent emails to the BTS, I've moved the HEAD of aptitude development to the distributed revision control system darcs. In my case, the draw is not so much being able to coordinate a large developer pool; the main advantages of darcs are that (a) it has sane branching and merging (as opposed to, say, SVN), and (b) I get disconnected operation for free (highly useful when your main development machine is a laptop).

Oh, and distributed revision control is New And Shiny[tm]. That too.

The new repository can be fetched with the following command:

darcs get http://people.debian.org/~dburrows/darcs/aptitude

Once you've checked out the source, you can use it the same way you'd use the Subversion source tree. To merge any new patches from my public tree into your local tree, run:

darcs pull

Now, the fun thing about darcs is that the checkout you just made is also a perfectly fine repository. So, for instance, if you make some changes, you can run

darcs record

in your copy of the repository. When you finish answering the prompts, your repository will now have an extra patch committed. You can now push it to other repositories, let other people pull it (if your repository is public), or email it using

darcs send

If you have a working sendmail setup, this will use it to send me a patch. If not, you can either pass --sendmail-command to "send", or use

darcs whatsnew

to see what you've changed.

The Operation Was A Success (and the patient lived!)

2005-10-05T00:07:00.000-07:00

Well, I've done it. I took a laptop apart, reassembled it, and not only did I live to tell the tale but (more importantly) so did the laptop! Even better, as soon as I turned it on, I could tell that the fans were working far more effectively -- the noise level is so much lower it's ridiculous. I haven't run any games....umm, I mean tests yet to see if the performance is better, but I'd be happy even if I could just cut down on the noise pollution around here.

The only slightly worrying thing is that I have one more screw than I did before I started all this madness. However, the laptop appears to be not falling apart. Hence, I conclude that the screw can't be that important ;-). (and certainly not worth tearing the whole thing apart to replace!)

Hopefully this will last for at least a few months -- by a few months after I first bought this, I was already noticing severe performance problems that in retrospect were the first onset of the dust-clogging-the-fans issue. Maybe if I keep the environment more dust-free (i.e., clean and vacuum more regularly) I can delay a recurrence, though.

I'd like to thank everyone who emailed me with stuff to try or handed out helpful advice on IRC. It was immensely helpful to be able to pick the brains of people who are a bit more conversant with hardware hacking than I am.

Did I just do that?

2005-10-04T16:22:00.000-07:00

So, back around the beginning of August, I decided that since I was temporarily (hopefully :) ) unemployed anyway and I wasn't in immediate financial peril, I'd spend some weeks working on aptitude full-time, so I could shift some of the ideas in the "things I'd like to do but that take too much effort" pile into the "things I've done" pile. I had already done a bit of work right around graduation, and another good chunk in June. But I didn't expect what I just discovered when I went to bring my resume up to date.


daniel@sleepingbeauty:~/stuff/txt$ darcs whatsnew
{
hunk ./resume.tex 42
-  47,000 lines of C++ code and 9000 lines of DocBook XML
-  documentation)\footnote{Statistics refer to version 0.3.2, released
-    May 1 2005.}.
+  70,000 lines of C++ code and 10,000 lines of DocBook XML
+  documentation)\footnote{Statistics refer to version 0.3.4, released
+    September 30 2005.}.
hunk ./resume.txt 26
-   47,000 lines of C++ code and 9,000 lines of DocBook XML
-   documentation -- statistics taken from version 0.3.2).
+   70,000 lines of C++ code and 10,000 lines of DocBook XML
+   documentation -- statistics taken from version 0.3.4).
}

Now, a certain amount of that was adding GPL copyright boilerplate to files that lacked it. A lot of files already had it, but still at 20 lines per file for 282 files, that comes to about 5,000 lines. Some more can be credited to whitespace and ritualistic C++ syntax that was introduced when I broke some of the more horrible and grotty pieces of source into bite-sized pieces. Still, that's a lot of lines of bloa^H^H^H^Hcode.

[UPDATE] and I apparently hit "publish" instead of "save as draft". Whoops! Enjoy, world :-)

Give me a lever of 6" length and a place to sit...

2005-10-03T23:43:00.000-07:00

Well, I finally got the CPU off the heatsink. The solvent didn't do it (it might have helped, but it wasn't critical); neither did freezing the CPU or heating it or even just Yanking Really Hard. I finally managed to separate the two things by wedging the tip of a screwdriver under the CPU and gently applying pressure until it separated from the cooling apparatus.

Queued up for tomorrow: get the right thermal material (the stuff I have is very prominently labelled "not for attaching CPUs to heatsinks"...whoops) and put the laptop back together. I halfway expect that it'll fail to boot once it's reassembled, after what I've put the poor thing through, but nothing ventured nothing gained.

I Hate Hardware

2005-10-02T21:09:00.000-07:00

About a year and a half ago, I bought a laptop. While it isn't the greatest computer ever, it has generally served my needs. However, I've been having more and more trouble with it lately. The first sign of serious trouble was when the computer shut itself down while I was playing bzflag, leaving a message in the system log about the temperature exceeding 90 degrees Celcius. After that, I of course took precautions to ensure that it was well-ventilated, even to the point of buying a special laptop cooling device (basically an elevated stand with two enormous fans mounted in the bottom). However, the condition of the system has continued to deteriorate. I felt pretty confident that I knew the cause -- dust buildup in the ventilation system, and so yesterday I pulled out a set of screwdrivers and set out to clean every last dust bunny out of the system. Sure, I said to myself, I've never opened a laptop before, but I've assembled a desktop, so I'm totally qualified!

Ha.

My laptop is currently in pieces all over the floor of the apartment. Taking it apart wasn't too bad, aside from the fact that you have to remove about 20 tiny screws, most of them totally inaccessible. Even getting the CPU out wasn't too bad, and when I did I found (as predicted) a huge wad of dust wedged between the heatsink and the fan.

But here's the fun part: there is no way to reattach the CPU to the motherboard! The problem is that the fan/heatsink assembly on this thing is huge -- it covers almost a quarter of the area of the case. To reassemble everything, I need to open the socket, insert the CPU, and close the socket again -- however, if I insert the CPU while it's attached to the assembly, it blocks access to the socket's open/close control. So it appears that the only way to put the CPU back onto the motherboard is to remove it from the heatsink, stick it into the slot, and then reattach the heatsink.

And (joy) I can't get the heatsink off the CPU or out of the fan assembly; they all seem to be practically welded together. When pulling didn't work, I headed to Fry's and bought some nasty-smelling solvent that's supposed to dissolve the thermal adhesive holding the CPU to the motherboard. All it did was give me about a half hour of ventilating the area while I waited for the lightheadedness to wear off. I'm currently seeing what happens if I leave the whole mess in the freezer for a while; several people have told me that might work (presumably because the various components shrink away from each other as they cool).

Once I get the CPU back in, all I have to do is reapply thermal adhesive, attach the heatsink+fan assembly to it, then find all 30 or so screws I took out and figure out where each one goes. At this rate, I'll be amazed if the whole thing works even if I do get it all back together in one piece.

aptitude 0.3.4 uploaded to experimental

2005-10-01T17:36:00.000-07:00

I've just uploaded aptitude 0.3.4 to experimental. At this point all of the destabilizing changes I wanted to squeeze into 0.4 have made it into the source tree and seem to work, so this is a release candidate for 0.4 once the translators catch up. Please go test it!

Relative to the version in unstable, this version has UTF-8 support, a new dependency resolution algorithm, threading (e.g., the program is responsive while a download is going on), and a whole bunch of smaller bugfixes and new features (including some of the most annoying bugs in previous versions).

[UPDATE] I was just reminded that not everyone is familiar with how packages get into our archive. Packages don't go into the archive immediately upon being uploaded (which is why installing aptitude directly from experimental doesn't work yet); they first have to sit in an "incoming" queue until the once-a-day archive maintenance script runs and moves them into the archive.

In brief, aptitude will be available in the usual way at around 4-5PM EDT tomorrow, or you can get it from the following URLs (which will be removed around 3PM EDT tomorrow):

Usertags fun

2005-09-25T17:16:00.000-07:00

I just spent the afternoon playing around with usertags and the other recent BTS changes. It looks like a really useful addition to debbugs, and I'm sure we'll see a lot of interesing uses pop up. I immediately went and used it to mark bugs that have been fixed in the aptitude SVN by using a quick-and-dirty Python script to extract them from the ChangeLog; with some help from AJ, I even came up with a URL that separates these bugs out from the completely unresolved ones.

So that was pretty easy. Having done this, the next logical thought was, of course, "if I can extract bug numbers from the ChangeLog on my computer, couldn't an SVN hook script do the same thing?" A bit of hacking around later, I now have a script that does exactly this. To use it, download it and (optionally) the sample configuration file, and then add the following line to your post-commit hook:

path-to-svntag.py "$1" "$2" path-to-svntag.conf

The script looks for text like "Closes: #nnnnnn" in a file called "changelog" and sends appropriate tagging messages to the BTS when it's spotted.