Hello Kitty(-barf)

Awww maaaan--the cat barfed on one of my high-school art-projects.

Bast!

Modulus

Apparently, -1 mod n in C is -1, not n-1.

Contrast with Python, where it's n-1.

That's why that code wasn't working right.

The funny thing is..., I was reading over the code, and I said to myself:

Hunh--clever. I didn't think I would have thought of doing that at that point.

I guess I wasn't quite as smart as I didn't remember being, after all.

Release 0.1.1

I just posted my first bugfix-release.

More-compact LZMA-compressed archives, along with GPG signatures, are also available in the directory:

http://www.rozzin.com/VisualIDs/

I've also decided to post the patches that enable VisualIDs in various versions of Nautilus (2.18 thru 2.24):

http://www.rozzin.com/VisualIDs/nautilus-patches/

If you're using a Debian-based system, using the Nautilus patches is even easier than usual:

• apt-get source nautilus
• Copy the 99VisualIDs.patch file for your version of Nautilus into the debian/patches/ subdirectory of the Nautilus package's source-tree.
• cd into the source-tree and build Nautilus, e.g.:
  • dpkg-buildpkg -rfakeroot -b -us -uc
• Install your new VisualIDs-capable Nautilus, e.g.:
  • sudo dpkg -i ../*nautilus*.deb

Note that my patches for Nautilus are still somewhat crude at this point--I haven't learnt to use GConf yet, so the way that you enable/disable VisualIDs at run-time is to create/remove the ~/.icons/VisualIDs/scalable directory (which is where the VisualID SVG-files will be cached).

VisualIDs Visualisation

I've started hacking on an editor-application for the VisualID glyphs:

All of the parameters of a VisualID glyph can be adjusted dynamically with real-time feedback. Ultimately, this should become something that end users could utilise to tune their VisualIDs experience to their liking; but something like this can also be extremely useful as an exploratory design-tool for me, to help visualise the implications of choices that that I make in code. I can play with with parameters and see, for example, how well the 2:1 line-to-border ratio actually works in a variety of situations. I can look for trends, and I can even instrument the system to help me spot the trends. Then I can improve the algorithms.

In the hands of an end user, the editor could obviously assist on a case-by-case basis (e.g.: `Oh--I don't like that, maybe if I tweak it like this...'), but repeated use of the editor could also actually teach the system to better match the user's aesthetics in future glyph-generation by logging the user's edits to a statistical database. Well, maybe.

As it stands right now, the editor... needs some work before I post the code (it's pretty rough, right now), but here are some preliminary screenshots--the following images show a single VisualID producer being reparameterised several different ways:

Initial Public Offering

I've posted `version 0.1' tarballs, along with a Bazaar repository; it's all available at:

• http://www.rozzin.com/VisualIDs/

I've got what I believe are working patches against a couple different versions of Nautilus, copies of which have been given to few people for preliminary feedback.

I guess I should work up the gumption to post the nautilus-patches publicly, soon.

Computing Similarity, and Computing Difference

Way back in June or July, I had dinner with Chris and Allli, and I got to do a little demo to show-off my VisualIDs-in-Nautilus work as far as it had progressed at that point. Since I'd just started thinking about the problem of identifying similar files in a global context, and was (somewhat stupidly) proud of myself for having come up with a way of seemingly making it easier than I'd initially expected it to be, I raised it in conversation; regrettably, this (along with the talk about my new job) resulted Chris and I marooning Allli in geekspeak....

When I initially read the essay, this part (like so many other parts) looked great (`on paper', as they say?). When I initially dug in as an implementor, this part (like so many other parts) looked more half-baked: deriving icons in a group from the same source made fine sense, but how were the groups to be formed?

But then I thought about it some more, and it occurred to me that, since I was keeping a cache of VisualIDs and the names to which they belonged, I could just scan through the cache whenever a new VisualID needed to be generated, see if I could find an appropriately-similar base-ID, and then go from there--this would be where the `longer than 3 characters' part of the matching-algorithm came in. All I would need to do in order to guarantee that this actually worked was to ensure that all of the VisualIDs were generated synchronously, which actually turned out to be easy enough in Nautilus--I ended up hooking into the thumbnail-generation subsystem, which was already synchronous anyway.

Chris posited the obvious flaw in this scheme: if one has multiple computers, wouldn't one want the icons to be consistent across all of them? If the consistency breaks down, then doesn't the utility break down?

But, unless we have some way of coordinating between the distinct systems, this looks like a hard problem: we can't just use the `ouija-board navigation' technique, we actually have to come up with some sort of consistent algorithm for gleaning some sort of meaningful structure of free-form file-names. Chris didn't think it'd really be that hard of a problem. I'm not convinced that it's anything like easy.

It looks like I can actually punt, though--I can say:

If you want multiple computers to synchronise their repertoires of VisualIDs, then just synchronise their cache-directories--how you do it is outside the scope of this project; you should be able to use whatever mechanism you use to synchronise other files between computers.

And, for the time being, that's what I'm doing: I just added my .icons/ directory to my Unison configuration, and now it gets synchronised between my laptop and my desktop along with the rest of my home-directory. It works--it actually works really well. And it would work using any of the other zillion synchronisation-systems available; for GNOME, it might make sense to do it via Conduit--it probably works just using whatever generic file-synchronisation mechanism Conduit provides, but it looks like a specific `Synchronise Icons' option would be easy enough to add.

So, every aspect of grouping similar icons together is really pretty easy, at least as far as I can see.

Where it looks like things get difficult is actually in reverse: guaranteeing that different and unrelated things actually look *different*, and that things don't end up with similar icons just-by-happenstance. How can that be managed? Can we just assume that the PRNG will make it work out that way?

If anyone has any specific thoughts on either issue, I'd love to hear them....

Opossum #2

Sitting on my front stoop, just minutes ago, I heard a rustling in the leaves to the side of me. There was no person over in that direction, and the invisibility of the noisemaker as the noise drew closer to the stairs had me expecting that perhaps it was one of the usual stray cats, but fearing that perhaps it was one of the usual stray skunks.

To my surprise, an opossum climbed up onto the top stair. It looked at me, and I looked at it. Into each other's eyes we stared. I raised my teacup toward it and said (somewhat timidly..., as I suppose is fitting for a man wielding a cup of Hu-Kwa as the most fearsome weapon at his disposal...), `Go away. You scare me...'. Much to my relief, the animal obliged.

It actually wasn't nearly as scary as the first time that I saw one.

Porting to from Nautilus 2.20 to 2.22

So far, I've been working with Nautilus 2.20, because that's what Debian is shipping in Lenny. Mainline Nautilus is actually up to 2.22, and there have been significant changes to the APIs between 2.20 and 2.22. In particular, nautilus-icon-factory.c, which is where the bulk of my patch applies..., has been /removed/. Luckily, it's easy to find where the code went--and most of it is still even substantially similar, just in a different file. So, the port to 2.22 should be fairly easy.

My patch for Nautilus actually didn't end up being that big, anyway--it basically just changed the default behaviour of the thumbnailer-subsystem.

Do You Know Where I Am?

16:51

Kier Dullea is reading this, on the radio, right now:

 <http://www.seattleweekly.com/2002-10-16/food/do-you-know-where-i-am.php/>

Sherman Alexie's story, `Do You Know Where I Am?', a story about human being relating to each other, journeying together, lying to each other, loving each other, and coming to grips with what all of those things mean. This follows the `This American Life' episode, `Something for Nothing', in which a mother and father divorce because she cannot accept the mindset that induces him to eat the heart (of watermelon, literally; of life, metaphorically), and he cannot understand the mindset that induces her to refuse it.

Petting the cat, the other day, I thought about an episode of `On Point' in which Tom Ashbrook spoke with two psychologists about Leona Helmsley's to split her Will between her dog and `the dogs of New York and beyond'--Ashbrook had used the term "unconditional love", if I recall correctly, and both of the psychologists agreed that... that wasn't really what it was; that it wasn't really `unconditional love' that was going on but that:

They bring out the best in us, and they enjoy the benefits.

And I see this in my relationship with our cat. Walking by, I glance over at the cat, and then I stop and stare, and smile, at the cat--and she stares back. I ask of her, "What do you want?". She seems almost to smile, though cat's don't literally smile, and she rolls over while her eyes remain fixed droopily on me.

"Ah."

So I oblige, and I think--and I even /say/--"Awe, you're such a good cat. I love you.". `But what does that mean?', I ask myself. What exactly is she doing that's so good? Simply accepting affection is sufficient. That's it. And it's amazing, I think, that this is the sort of relationship that we have with our pets--that this is the nature of humanity, even: that we really want so much to love that it's enough for something, or someone, to simply /accept it/.

If I offered you my love, would you accept it?

Yes.

Then I offer you my love.

Wouldn't the world be a better place if we humans could (consistently) relate to each other like that?

Similar VisualIDs for similarly-significant files

I've finally started-in on implementing the `similar icons for similar files' logic--so far, I've got the weighted-least-common-substring logic working, which searches through the (ever-growing) cache of VisualIDs for a base-icon. I haven't worked out a system for `mutators' yet, so sufficiently-similar names actually result in the /same/ icon..., but it's getting to be quite a nice demo.

Oh--I've also implemented the `around a shape' and `relaxed inside', and `along a path' generators. The presence of these additional options means that all of my icons have changed. Alas--it's no longer generating turtles. It /is/ generating other interesting things, though.

I think that, before I call it `done', I'm going to want to add some way for the user to specify constraints for which generators are used, and how the random selection of generators should be weighted.

In the mean time, here's another (updated) screenshot:

Economic Simulus 2008

So, tried calling the IRS, today... to ask them if we can official refuse our Economic Stimulus Payment--give it back, lodge a protestation, etc. Because we really, collectively, don't have the funds for this--we can't spend all of our money as a nation and not take any in.

It's all just a lone, any way you count it.

Collectively, it's a loan from China. And I'd really like to register a complain to the effect of:

Look, if I need a loan, I can take my own loan out from a local lender. Please do not take a loan out for me from the bank of China.

Even only counting individually, I'm sort-of expecting that we'll be taxed more heavily next year to make up for. That's how I remember my first Bush `tax relief' going....

So, the IRS put me on hold until I gave up.

In the mean time, they offered canned answers to lots of questions like "When will I get my cheque?", "What can I do with my cheque?", "How much will my cheque be?", "What do I have to do to get my cheque?"..., etc.

There weren't any questions like "How can I help buy my country back from China?"

But I'll try again. Maybe I'll find an answer after all.

Wall-E

We saw Wall-E, tonight, and it's amazing: I now have a clear and profound comprehension of why cats chase laser-pointers, and how and why my wife can look at my googley-eyed while I'm working-on or explaining something Important.

The whole `it's robots' thing lends to some wonderful brechtian moments, but the characters are so remarkably emotive (with a 3-word vocabulary!) that it's impossible to avoid identifying with them at other times, and the whole thing is remarkably stimulating both emotionally and intellectually. It's uplifting, and terrifying, and charming, an enlightening. It's the greatest love-story ever told, with the accidental messiah courting Sleeping Beauty, and a trip through the wonder of childhood to remind us how amazing and wonderful the every-day mechanics of reality are.

Underwear

I wish my underwear had pockets.

Remote VisualIDs

Yet another interesting thing that just 'falls out' of the way that VisualIDs work: they work just as well for displays of remote data as for local data; and, because of the way that they work, generation is fast for remote files.

Here's a screenshot of VisualID-enabled Nautils browsing ftp://ftp.gnu.org/:

After looking at the previous screenshots, how quickly can you find the README file?

VisualIDs are also showing up (as if by magic) in the Nautilus 'Scripts' menu. I can't figure out how to get a screenshot of that....

It's Alive!

It looks like I've actually got it working, automatically generating and caching VisualIDs wherever thumbnails aren't possible.

Here are a few random directories on my computer:

One bit of behaviour that's different now, and that's bothering me, is that the VisualIDs aren't showing up as WM-icons for Nautilus-windows anymore. I was really getting to like seeing VisualIDs when switching between windows--it's so helpful that I'm tempted to go ahead and hack my window-manager so that I can have VisualIDs to help distinguish between windows of any application (e.g.: the bazillion Epiphany or Emacs windows that I have open).

Hm. I had to change the way that I 'reported' VisualIDs in Nautilus in order to get icons to automatically update upon completion of 'thumbnail'-generation (where I was initially hooking into ~/.icons and reporting icon-names that GNOME would resolve to file-paths, now I'm directly reporting file-paths); I wonder if that's what caused this....

Items in Nautilus' "Scripts" menu are still getting VisualIDs, which was (is) another nice side-effect of this.

Of course, I still have to add the gconf toggles and similar-IDs-for-related-files (the latter is going to be interesting...), do some general code-cleanup (now that I understand what I'm doing), and maybe see about adding some more generators.

I did try implementing 'relaxed inside' and 'scribble', but they had... problems...: 'relaxed inside' just doesn't look right, and 'scribble' is ridiculously inefficient (a pen orbiting a set of gravity-wells? seriously?).

I'm pretty sure that I could implement 'scribble' more efficiently by just telling Cairo to run curves between the attractors--should I bother?

*My* VisualIDs

I'm trying to put together a demo-collection of the VisualIDs that I've generated, because they look a good deal different than the ones shown in the essay. I'm not sure how to present them all..., but here's a go:

I've hacked my GNOME icon-theme so that, in addition to the usual sources, it also pulls icons from a preliminary VisualID-cache. The 'cache' is populated manually, by copying in the VisualIDs that I got by running make test (which generates a tree of SVG files that mirrors the code-files in my VisualID source-tree)--I still haven't quite figured out how to hook automatic VisualID-generation into Nautilus..., but I at least get a believable demo:

There's that turtle, at the bottom.

And take note of the 'README' and 'src' icons--those are classes of files that tend to show up all over the place....

My Centenarian Grandfather

We celebrated my grandfather's 100th birthday with him and the rest of the family, this weekend.

Pam just found the photographs that he took after liberating the Dachau concentration-camp: they're in the Israeli Holocaust Memorial, which is online at http://www.yadvashem.org/. Unfortunately, I can't link to them, because yadvashem.org us using some sort of session-cookie system....

"I work for MIT"

My wife just wanted me to tell the world that. She's very proud. I think she's very silly.

Paper Dolls

Here's a JavaScript/CSS2 example of my painting-process. It's a little like making paper dolls: the white `buttons' indicate layers that are active, and the black onesindicate layers that are inactive. Click on the links to toggle the visibility of the layers. I have a script that produces these from a GIMP XCF file, but I'm probably generally just going to post links to XCF files, when I get my gallery back online.

Turing Tar Pits.

I dug up both major incarnations of my web-site from when I was in high school & they're both... much more interesting than what I currently have; & even on an absolute scale, still intriguing.

I had image-galleries with links to source-code for the POV-generated ones, poetry-compilations, extravagant CSS styling everywhere, including on every poem like Blake would have done.

But what blows my mind, now, are the parts that are the same--

• the menu-system that was manually replicated through every page--no CGI or SSI or anything.

• the multipage galleries with every page generated by hand. & cross-page consistency checkd by flipping back & forth between buffers in Emacs.

The weblog maintained manually as one big HTML file is particularly interesting--with a comment-form that would e-mail comments to me so that I could moderate & hand-integrate them.

I wouldn't even think of doing that kind of manual labour, these days--which could be good, but /isn't/ when the result is being stuck in the turing tar pit where, if something cant be automated, it sn't worth doing--where the primary task is the automation & the task being automated is of only secondary import.

What am I to do, now?