A Trifle Absurd

NewtonScript

I read through the Newton programming book I mentioned last week. Interesting stuff–not just NewtonScript itself, but its environment, too, especially the persistent-object database system (the “soup”).

NewtonScript is (intentionally) very similar to Self, except for its inheritance model. Where Self has arbitrary multiple inheritance, NewtonScript has dual inheritance. A frame (i.e. object) can inherit from up to two other frames: a “proto” and a “parent”. Each serves a distinct purpose and has different inheritance rules. In practice, the “proto” is a prototype object in the usual sense, while the “parent” is the parent widget in the GUI widget hierarchy.

Walter Smith, one of the main developers of NewtonScript, has some articles and pointers to more Newton developer information.

Adjusting to Abundance

Today, apt-get informed me that the libraries-and-headers package I was installing would take up 28 MB. Twenty-eight megs! That’s HUGE–oh, wait, I have eighty gigs of storage, even on this not-so-current machine. Twenty-eight megs is a drop in the bucket.

I’m still adjusting my mindset to match the abundance of resources on today’s machines, relative to ten or twenty years ago. Maybe I should post an affirmation above my monitor to recite five times a day: “I have plenty of disk space and can afford to waste it”.

And it’s not just disk space: processor cycles, memory, bandwidth, all of it is exploding. “So what?” you say. “It’s just Moore’s Law in action.” I wonder how many of us have internalized it, though. I know I haven’t: too often I think of shaving off a few bytes here, saving a handful of instructions there. That’s the scarcity mindset, but for personal-level (as opposed to enterprise-level) applications, we live in a world of abundance.

Tags and Connectivity

I know I’m late to the party on this one, but Merlin Mann’s I Want a Pony, a blue-sky feature list of the ideal productivity app, is well worth a read, as are the comments. I see three groups in his list: Cocoa, connectivity, and tags.

Cocoa I don’t particularly care about yet, since I’m not a Mac user. But I suppose it’s possible I could fall head over heels in love with it, once I get a Mac. (Buying a Mac has turned from “if” to “when” for me; the question at the moment is whether to wait for Tiger.)

Connectivity includes having hooks into whatever apps and services you use, so you can organize your information in the midst of whatever you’re doing. It also includes sharing data by syncing with a server, and by generating RSS feeds. These, I think, are all important. The more ways you can access and process your data, the better.

Tags cover not only simple labeling, but things like nested collections and automatic retagging. To me, tags are the heart of what we need. They’re the means of escaping the location-based metaphors that are holding us back.

Trifle will be focused on tags and connectivity, and in that (implementation) order. It may not ever become Merlin’s ideal productivity app, but I hope that it becomes mine. Now if I only spent as much time building it as theorizing about it…

Programming with Prototypes

Since it looks like I’ll be programming in JavaScript for a while, I thought I’d read up on prototype-based languages. (Prototype-based means, more or less, object-oriented minus classes. That is, there are no classes, only objects.) JavaScript is the best-known such language, but there are other examples out there, like Self, NewtonScript, and Io.

Self was a major influence in the designs of NewtonScript, JavaScript, and Io, and there are plenty of freely-available papers about it. Programming as an Experience, a retrospective paper, is the best place to start. Lisp and Symbolic Computation (v.4, no. 3) packages up several other Self papers.

Some of the niftier tricks for organizing programs without classes in Self don’t apply to JavaScript, since JS only has single inheritance. On the plus side, though, you don’t have to decipher Self’s tricky name-conflict resolution rules.

I don’t know much about NewtonScript, other than the snippets I’ve picked up here and there. It was inspired by Self, but adapted to fit the needs and constraints of the Newton. A couple of days ago, I came across Programming for the Newton in the library, and I’m looking forward to reading it. (Sometimes it’s a good thing for libraries to be stocked with outdated computer books…)

So why am I reading about all these other languages instead of just JavaScript? Part of it is just that I’m a language junkie, and so I need little excuse to go learn about obscure languages. Another part, though, is that I want to swipe useful techniques for programming-in-the-large from other prototype-based languages.

Tags Everywhere

There’s a flurry of discussion on tags going around the blogosphere, touched off by Technorati’s announcement of a tag search service. Tim Bray has some good thoughts, and there’s a thoughtful and energetic discussion over at Many2Many spanning several posts by several authors. Clay Shirky’s rant (warning: non-PG language) is a highlight:

… in the period between the invention of the printing press and the invention of the symlink, we were forced to optimize for the storage and retrieval of objects, not ideas. Now, though, we can scrap the stupid hack of modeling our worldview on the dictates of shelf space.

That, in a nutshell, is what’s good about tags: they’re simple to use and understand, yet far more flexible than schemes based on a location metaphor (like the file system).

Most of these posts talk about tags on a group level, as used by Flickr, del.icio.us, and Technorati. Often overlooked, though, is the value of tags on a personal level. (To be fair, Many2Many is about social software, so you would hardly expect them to be talking about the individual case.) I’m convinced that applying tags to private personal stuff is just as important as applying them to shared stuff. That’s why I’m building Trifle: I want to organize my stuff.

More Notes on the New Site

Credit my wife Elizabeth with inspiring the color scheme of this new site. I was originally planning a simple green-and-white scheme, but she found it boring. One thing led to another, and we spent an evening trying out different colors together. Both of us like the end result a lot better than the original, and we had a lot of fun collaborating along the way.

About comments: I’m using Colin Devroe’s Optional Comment Moderation plugin. Posts less than seven days old have comments open, but older posts have comments moderated (and thus they won’t show up right away, since they’re held for my approval). I’ll probably also add a rel=”nofollow” plugin soon.

Tomorrow I’ll get back to something less self-referential than the design of my blog, I promise…

New Site

Well, it’s done, or done enough, at least. This is the new home of my blog, and thanks to WordPress, it enjoys a host of new features that the old one didn’t: comments, trackbacks, and search, to name a few.

All of the posts from my old blogspot site have been copied over, and the transition was in general surprisingly easy. Of course, then I had to complicate things by insisting on building my own WordPress template. Still, WordPress has been really good to me so far–it’s done everything I’ve needed, and with a minimum of fuss.

Front End First

I’ve been experimenting with back-end technologies for Trifle, from databases to web servers. But I’ve been looking at it backwards. I don’t need to first implement a back-end web service and then the front-end client. I should do the opposite: implement a Javascript front end with its own (slow) tag-database implementation, and then, when I need to scale up, add a Web-service back end.

This means I don’t need to guess what kind of services the front end will need while building a prototype back end. Instead, the functioning front end will make the back-end requirements clear (it’s like writing unit tests first). Or, put another way, the client-side tag database will be a prototype for the server-side Real Solution.

This also cuts through the knot of what language, server, or database to choose. I don’t need to worry about any of that yet. Right now, I get to crank out some Javascript, which sounds like fun. Javascript is a surprisingly nice language, and you can do some cool things with it.

Microformats

I’m intrigued by the idea of microformats: simple, tiny vocabularies for encoding semantic information in modular XHTML. Unlike, say, RDF and OWL, microformats like XOXO reuse existing markup, so they’re easy to edit, generate, embed, and render using existing tools.

XOXO is a good example. To represent lists, it uses ol, ul, and li. To represent name-value pairs, it uses dl, dt, and dd. Dirt simple, and way general to boot–it’s a beacon of sanity in a WS-saturated world.

Perhaps Trifle’s tag database should be a Web service returning XOXO or something similar. Standardizing the transport format would enable not only multiple clients, but multiple server implementations as well.

Moving Macwards

As Jeremy Zawodny joins the majority by switching away from his Mac, I’m contemplating the opposite move. More accurately, I’m salivating over Apple’s website at every opportunity, and trying to reconcile my desires with my budget.

Still, it’s good to temper my enthusiasm with the occasional bucket of cold water, such as Jeremy’s post. I’m not dissuaded by it, though. Several of his points simply don’t apply to me, and the ones that do (a slow feel to the GUI, keyboard access) seem to have at least partial solutions (see the comments).

More than anything, I’m ready for something different. I thought Linux would fill that need, but I’ve been worn down by all the little things that don’t work. Printing is continually iffy, OpenOffice is plagued with small but annoying infelicities, audio CDs don’t play, etc. It’s just not worth it to me to spend my time dealing with this stuff.