Spacehog RIP (sigh)

Well, it’s probable that the RIAA wasn’t behind the breakup of the band Spacehog, but it sucks anyway.

Their first big album (and really, the only big one) was Resident Alien, which was followed by some rather less popular albums, then the band split up. Reading various newsgroups, it’s apparent that bad behaviour in hotel rooms and with drugs isn’t a thing of the past with bands.

Oh well. There’s some music on the site (B-sides and stuff) that looks pretty good, and now I can stop looking for the group’s next album on my twice-yearly visit to Tower.

[Aside to Tower & the record industry: Lower your prices, and I’ll visit more often.]

Squeak

Squeak is a version of Smalltalk … no wait, it turns out that Squeak has actual bits of SmallTalk-76 in it (well, copies of them, anyway). The Squeak swiki site says:

Some bits in this Squeak are descended from Smalltalk-76. They have been loaded and saved in a ‘core image’ many times. It is, theoretically possible to start from nothing (since it has been done in the past, back before the earth cooled), but t’ain’t easy.

Squeak looks way cool…

More Patently Stupid Patent Enforcement

According to various sources, SBC is enforcing a patent on the use of frames in a user interface. Use of tabs in a frame, where the frame doesn’t disappear as you navigate — that kind of thing.

Insert the usual rant about obviousness of the application and the cluelessness of the U.S. Patent Office. These bozos dreamed up a patent around the way that frames were intended to be used in the first place.

“Wow, there are tires everywhere. They look pretty useless on their own, so I’m going to patent a method for attaching them to cars and moving around on them…”

* * * *

So, there’s this patent on network standard byte order, which is about an obvious idea as you can find in the field of internetworking. There’s been prior art forever (well, since ArpaNet, anyway). In 1988 or so I went over to the patent branch office in Sunnyvale and got a copy of it, and confirmed that it was about as bad as the Usenet flames were saying.

A few years later, I worked with someone who knew the guy whose name is on the patent. Apparently the recipient said (when he received it), “I can’t believe they gave that patent to me.”

Hearsay, yes.

A few years after that, I was more or less forced to apply for a patent on an RPC mechanism that probably would have had Java RMI infringing on most of it. If anyone from Sun is reading this, PeopleSoft owns that particular IP now.

The whole stupid game needs to be stopped, before someone patents breathing or the Return key and it’s all over except for the lawyers, coming for your soul in the dead of night….

The Enron of Library Leasing

This sounds really nasty. A few months ago my wife and I noticed that some of the books at our local library were marked as leased property, not property of the library. It turns out that some libraries do indeed lease their material — including books and periodicals — from suppliers, rather than buy material outright. There are various companies that do this; in 1998 one of them, Faxon, with over a hundred years in the business, was in financial trouble and was acquired by RoweCom in 1999, which was in turn absorbed by devine Information Services about a year ago.

In December, RoweCom/devine decided to spend its money on reducing its debt, rather than on material for its subscribers, and now they’re looking to sell the serial-leasing business. As a result, many subscribing libraries are out of hundreds of thousands of dollars, for a total of 80 million or more. Huh, I had wondered how that whole leasing thing worked in practice.

Here’s an article in the Library Journal on it, and another with links to more information. It sounds desperate and really sucky. The official press announcement contains echos of press announcements by other dotdom flameouts (“Trust us, the Management Committee is working on it,” yeesh).

“Limited Operations” = “We’ve got your money and we’re working out how to spend it without giving you much of anything.”

The Chicago public library system was about to send devine/RoweCom/Faxon a check for $1.6M when this happened. Fortunately, in this case a slow bureaucracy saved them a bundle of cash. Other libraries weren’t as lucky. As usual, guess who’s paying the bills on this?

SIOD

If you haven’t seen it before, here is the world’s tiniest (well, maybe) Scheme interpreter, SIOD (it was originally written as a lark, and called Scheme in One Day). It used to be a lot smaller, without things like sockets or MD5 (like Windows, or to be fair, Linux, things have a tendency to grow. “Add a little to a little and you have a lot.”)

You can get some serious work done using SIOD.

(Two really good Scheme repositories are at indiana.edu and cmu.edu).

More T, Please

I should probably explain why I’m so fascinated with functional programming languages like Lisp. You should know that I’ve never really shipped a product using one, I just like to think that it’d be a nicer experience than shipping something written in C++ in one of today’s programming environments.

[I used to think that a registry of name-value pairs would be a good idea. That was years before my dealings with the horror, the utter, black, unutterable dispairing horror of the Windows registry. Likewise I could be utterly naive about using Lisp or something like it. But it’s nice to fantasize and criticise the existing crap. Onward.]

Programs as data. Languages like Java and C# have introspection (and C# has user-definable attributes), which allows the running program to dig into itself and make decisions (“Ah, I’ve got two inline wheels today, I’ve probably got bicycle-nature.”). But it’s not totally wonderful, the metaprotocol for getting at the information still reflects the baroque nature of the syntax.

It’s possible to generate code on-the-fly for incorporation into the running system, but this is generally seen as something dodgy. But there are situations where this is perfectly reasonable (most often in development, to foster quick turnaround).

When you want to do static manipulation of programs — and who doesn’t do this in a large project? — you’re up the creek. Parsers for C-like languages are pages and pages long (a good C++ parser is probably on the order of 50-100 pages). If you want to write tools that manipulate programs, you’ve got a lot to worry about.

[What kinds of things might you want to do? Well, query tools on programs: “Find me all local variables of type X,” since you’re about to change type X and you want to estimate your modification’s impact. This should be a really simple question to ask, but most development environments can’t handle it, or if they do, the answer gets stuffed as text into a dialog box somewhere, where another program can’t get at the data, thanks a lot.]

Macros that Make Sense. There are a lot of reasons to deprecate the standard C preprocessor, nearly all of them good. You can extract a lot of power from simple expansion and stringization, but you can’t do general purpose computation, and you can’t debug the expansions short of the moral equivalent of “printf debugging”.

The less we say about C++ templates, the better. I limit it to this: For some reason, my brain has associated templates and HP Lovecraft’s novella At the Mountains of Madness. Maybe I was reading a book on templates and some old Lovecraft the same day, once.

I look at Lisp-style macros, and I weep. They’re structured, they’re hygenic (meaning that you don’t have formal parameters tripping over each other), they’re trivial to write.

Post-Facto Modern Runtime. I have news: Lisp got un-slow in the 80s. You can reasonable expect its memory management to compete with Java or C#’s garbage collection, and decent compilers are available. [You probably can’t use straight Lisp for an embedded system … but if you’re using anything but C for a small target platform, you’re probably losing left-and-right anyway].

* * * *

I do have some criticisms.

You need a decent editor to help you indent your code (or else discipline). This is the most often voiced (or maybe just the first expressed) objection to the family of Lisp languages, that getting all of those parenthesis correct is a nightmare. I attribute this to “forced feeding” by most colleges: Exposure to Lisp as a problem set to be solved in some survey course, rather than as an environment for getting work done.

I honestly don’t know if CLOS is a great thing or not.

Memory footprints are probably not totally wonderful. They are comparable to Java or C#; not great for the masses, unless you take a stripped-down approach.

It can be hard to excise your application from the development environment, if you want to shrink-wrap it. (Smalltalk, my other favorite language, has this problem too). The boundary between application and tool is blurred, and again you need to have discipline. On the other hand, this is probably no worse than “DLL Hell” and the “Nightmare Installer from Heck” on Windows platforms.

* * * *

I would seriously consider a stripped-down Scheme (or something like it) as an embedded system scripting language, rather than “super emasculated mobile Java” (which is still probably 100K of stuff). Mark-and-sweep collection in a small heap has been demonstrated to work well, debuggers are pretty easy to write, and bringup time for such a system would be a fraction, probably a miniscule fraction, of the time to bring up a Java or C# system.

I guess the problem remains that most engineers just don’t like Lisp.

As the guys who did Viaweb said, “An advantage that your competition doesn’t understand is the best kind.”
[Somehow we’re back to Paul Graham again 🙂 ].

T

Thanks to my friend Munch [it’s a long story, and I don’t really know it] for this pointer to the history of the T language. It has some good pointers to folks who have done work on functional language runtimes as operating systems.

Sometimes I wish I had a couple of years to work on something like that. Dang.

LISP Machines

I was 20, in college, and lusting after Lisp machines. One of my favorite books was a copy of the Lisp Machine Manual that my best friend brought home from MIT one spring break. I had devoured Allen’s book Anatomy of Lisp, and wrote a Lisp interpreter in which I wrote my first project in the U of Maryland’s introduction to programming course (long story, maybe boring, more on that later anyway 🙂 )

Anyway, the Lisp Machine Manual is online (along with a bunch of other really cool old documents).

These days, making a special-purpose computer to run Lisp programs would be like building a special-purpose vehicle to go grocery shopping. But in its day, the CADR was very, very cool. When Atari was falling apart, I had to box up a bunch of LispMs that were sitting in the corporate research digs. It was kind of sad, but they’d had their day (I think that Symbolics packed it in just a few years later).