The fact that the entire Ubuntu community seems to have dived into this microblogging craze disturbs me.

Actually, “annoys” could be a better word. I occasionally get into this with fiction, like movies and TV series: “Okay, this is kind of decent, but definitely not the masterpiece I was told it is. So what did everyone find in this overrated piece of drivel?” And then I start ranting about it, in the hopes of provoking a discussion and an opportunity to vent.

Technology is sometimes the same for me. A new fad strikes the entire Internet, I fail to see what’s so special about it or what it’s even for, yet the fact that everyone talks about it all the time annoys me enough that I often intervene with complaints that “I don’t get it”.

I honestly tried to get it. I read articles on it, including the Wikipedia one, watched video explanations on YouTube. This diagram, obviously, completely clarified the situation. But seriously…
* Random thoughts? IRC. Saying something that bugs me on an appropriate channel will inspire a more fulfilling response than a mess of short posts ever would. Or I could just write it in my blog—I have nothing against one-liners being there.
* “What I’m doing now”? Well, who the heck cares what I’m doing at the moment? And if someone does care (I can see why my parents and coworkers would, hypothetically, but not beyond that), why would they trace it over the Internet? The fact that someone might actually be interested in reading up-to-the-minute status updates in daily life—and that someone can actually care to update—sounds kind of disturbing by itself. Like virtual voyeurism. This sounds really far-fetched. Using the Internet to trace your son’s meal or finding friends having a party at the moment? Seriously?

From what I’ve seen on screenshots, signal-to-noise ratio of a typical Twitter feed (how do I subscribe to the bloody things anyway? Is it like RSS, via a URL displayed somewhere?) is disturbingly low. You need to trace on the particular service the person is using. That’s just unwieldy.

Maybe I just don’t lead the kind of life where microblogging becomes useful, but then it’s concerning to be different in this aspect from seemingly everyone else in the Ubuntu community.

“I don’t get Twitter” returns 23,500 Google results. For a technology that’s supposed to be simple and intuitive, that’s disturbingly high. Without the “I”, I stumbled onto this phrase: “If you don’t get Twitter [or other similiar sites for that matter], then it’s not for you.” Maybe I should just bitterly follow this statement and disclaim it as “not my thing”?

But dang.

(Added: Someone came to this page from the horrendously designed Planet Ubuntu Twitter page. The irony.)

One of Jaunty’s more controversial new features was the new notification server. It’s easy to decry as something Canonical pushed unilaterally, breaking a lot of GUI software and requiring fixes for unclear gain.

I’ll admit: I can see areas in which notify-osd can use improvement. At least the bubble background and text color should be customizable (not everyone likes black), as well as their position—they should at least be bindable to any of the four corners of the screen.

Yes, Jaunty shipped with an uncustomizable notification server that, at first sight, seems like a major regression from notification-daemon (no custom positioning, no actions, no clickable links…) and requires a custom GNOME session to replace. But while it may not have been completely polished on Jaunty release, from my (a mere user’s) point of view, I believe it’s a step in the right direction.

First, let’s be honest here: many applications, especially outside of the official GNOME set, didn’t have a well-thought-of concept of usability regarding notification bubbles. I pretty much agree with most of the usability concerns put in the notify-osd wiki articles. For me, a notification bubble is a signal that “something of interest happened”. I don’t usually read into them—I just scan them quickly with my eyes and switch to the application. Displaying a notification bubble indefinitely and expecting a user to click a button is just unwieldy.

Second: uniformity. I can’t stress enough how important this is for a professional feel. I know there are people for whom free software means, first and foremost, freedom of expression. So let’s have ten widget toolkits, five notification systems and innumerable icon themes that all look at odds with each other. The consequences of such a mindset can be seen most prominently in, ironically, Windows. With even Microsoft changing its aesthetics radically with every release (compare different versions of Office and Visual Studio), if the king does not lead, how can he expect his subordinates to follow? Add independent proprietary software developers each trying to make their application visually stand out with bling, older software retaining the Windows Classic theme, and we have a recipe for an eclectic mix that doesn’t feel like a cohesive desktop environment at all.

But let’s head back into the desktop Linux world. There are GTK and Qt, plus various more obscure toolkits—they’re of little interest to me, especially given that some (like wxWidgets) act as wrappers around the mainstream toolkits or emulate their look. But even two toolkits are troublesome on their own—how are you going to explain to Aunt Jane why that shiny DVD creator she has just installed looks so different from the rest of the desktop? That’s why, as a GNOME user, I regard the inclusion of qgtkstyle in Qt 4.5 as probably its single most important improvement in the X11 version. Common GTK users will have their uniformity by default, advanced users can install qt4-qtconfig and go from there, and for KDE, of course the issue is backwards.

Even among a single toolkit, guidelines exist to ensure that applications behave consistently. You can have varying opinions on the GNOME HIG and its practical implications, but you can’t really deny its clarity, internal consistency, and logic. There is nothing in GTK itself that stops you from placing the Help menu on the leftmost side of the menu bar, but should you really? Similarly, when I open the About menu, I have every right to expect that I’ll be shown the standard GTK about dialog, not the developer’s custom creation. This is actually important enough for me that I started filing bugs about HIG non-compliance, and some time ago joined gtkpod’s upstream development specifically to revamp its aesthetics, including the icons, about and preferences dialog, to make it feel more in place in a GNOME environment.

So, we have the GNOME HIG for general application behavior, the Tango guidelines for icons (I don’t use the default Tango or Human theme, but a custom ones following the guidelines, and it integrates well), and freedesktop.org standards for interoperability, including the notification specification. I don’t understand why KDE has its own notification system instead of implementing the standard, although they might have a good reason—but this doesn’t help interoperability. But the specification only defines what applications can expect, not what they should and shouldn’t do to be consistent. As it turns out, many fail even at expecting: they expect a specific implementation, notification-daemon. The Ubuntu developers weren’t out hunting for “non-compliance with notify-osd”—from what I understand, they were out finding such implementation assumptions, such as expecting support for actions, and making the applications behave with different implementations, including notify-osd.

In fact, I’m seeing the Notification Design Guidelines as Canonical’s more important contribution to this area—that is, more important than notify-osd. Why did they define these guidelines? Because nobody did it before, and nobody had a clear idea how notifications should be used. This is an important step on the way to a uniform, cohesive desktop, no matter what notification implementation is used.

As for notify-osd itself, it’s a question of taste. I hope it will eventually become configurable enough to mitigate some of the common complaints, and of course the default behavior of affected applications could use some improvement. I don’t know anyone who would like the proverbial example of Update Manager popping up—the old behavior with an icon and notification bubble seems more sane to me, even if the bubble is unclickable now. What notify-osd really succeeds in is making notifications looking consistent with each other and, let’s face it, slick. While it’s hard to define what a slick desktop or application is, for me, it means sensible intuitive layouts, with eye-capturing graphics and putting emphasis in accordance to how important or commonly used the information is. For applications most prominently following this kind of philosophy, of those I know, I can name Qt Creator, Brasero, GNOME Do, and now notify-osd—all displaying stark contrast to traditional “Windows-like” layouts.

On my quest for consistency, I’ve started looking for ways to make all notification popups go through notify-osd. That’s why I welcomed the experimental Firefox notify extension, why I’m looking for the Thunderbird one to exclude notifications of Gmail spam so I can actually start using it, and why I rebuilt Quassel without kdelibs to enable support for freedesktop.org notifications. Because order matters.

Apparently I’m a Canonical employee now… At least in the wild imagination of the Boycott Novell folks. A friendly tip: before calling to boycott anyone in particular, get your facts straight first.

LucidFox: but surely Canonical have made a secret backroom deal with Microsoft over making directhex a MOTU

(Heh, and as I was writing this, the author corrected it—with a strike tag. Apparently he thought everyone with an @ubuntu.com address was Canonical staff.)

I’ve created a new 2048-bit key and switched to SHA-256 digests, following the earlier posts here. On a somewhat amusing note, the new key’s ID is 12666C01—good thing I’m not superstitious!

The original page at debian-administration.org seems to be undergoing a Slashdot effect. I used the Google cache to resolve the problem, but even then, the page kept loading forever and only appeared when I put Firefox in offline mode. Weird.

Today, for the first time, I noticed that the Russian localization of Quassel used gender-specific language in its IRC log views. It was jarring to see the nickname of a known female user followed by the masculine form of the verb “changed”. I’ve made a patch for the .ts file in git and sent it upstream, but I noticed that Gajim was also an offender at least with the “Away” status—not sure about Pidgin, I’ll need to check it.

Now, Russian is a highly gender-specific language—verbs in past tense singular are always gender-specific, for instance. Translators need to dance around these issues. Yes, it’s hard, but it pays off.

I’m not on a political correctness crusade, I just have an issue with the very concept of “default gender” that most Russians seem to accept without question. In these days of rising gender awareness in FOSS (if the recent posts on Planet Ubuntu are anything to go by), presuming that online users are male by default is simply unacceptable. I’d like to see users recognize the ways choice of language affects human interaction and report questionable uses, and upstreams be cooperative in fixing their localized UIs correspondingly.

As Karmic has opened for development, my primary concerns for now are:
* Patch gtkpod to detect and use libmp4v2 dynamically, and thus eliminate the need for a separate gtkpod-aac package in multiverse. The patch will go upstream as well.
* Get handbrake into Ubuntu already, in cooperation with John Dong.
* More Java! First of all, package Execute Query. It depends on two Java libraries that are currently not in Ubuntu; browserlauncher2 is on REVU, and liquibase is going to join it soon.

First of all: good work on the release, everyone! I’ve been using unstable Jaunty for most of its development cycle, but upon release I did a clean reinstall and was surprised to see how slick everything looked. In particular, the updated partition manager, timezone selector and GDM login screen are pure eyecandy, giving a professional feel—kudos to the artwork team!

The reason I did a clean install in the first place was hoping to fix my chronic problems with PulseAudio from a hardy -> intrepid -> jaunty upgrade: random hangups, hiccups, muting, and flat-out refusing to work. Now it seems to work like a breeze—we’ll see.

Between the release of Jaunty and the opening of Karmic for development, I’ll direct my energy to unofficial updates of software I’m interested in, adding it to my new PPA. I’ve started with Arora 0.6 and Qt Creator 1.1.0.

To the delight of all Ubuntu users who have been complaining about Tomboy being a resource hog, thanks to Mackenzie ‘maco’ Morgan, I’ve discovered a Mono-free alternative: Gnote, which is basically a port of Tomboy to C++. It’s blazingly fast and, from her experience, integrates better with the GTK theme setting in KDE.

It is regretably not in the Ubuntu archive yet, but I’ve asked Vadim Peretokin, who has it available in his PPA, to contribute the package to karmic once it opens.

As it turned out, the day I found enough confidence to resume contributing to Ubuntu was coincidentally the last day before feature freeze. Luckily, I had some upstream version updates of interest to me prepared, so on this last day I’ve updated gtkpod, gtkpod-aac, smplayer, smplayer-themes, and qdvdauthor. Not enough time for REVU, unfortunately, and I regret all the time I missed due to silly personal insecurities.

That’s the public version of the post, can’t really afford to post the other one to a heavily-visited aggregator like Planet Ubuntu.

Everything written below comes from personal experience of maintaining a Java CMS written by our predecessors, who gave us next to no instructions regarding that pile of code.

• Don’t use an ORM library. If someone calls you on it, tell them that there were no ORMs available in 2003. Instead, write your own ad-hoc, bug-ridden object mapping layer that only works with Oracle.
• Don’t use reflection to automatically handle POJO classes being mapped without writing boilerplate code. Instead, ensure that every class has a corresponding DAO class consisting entirely of copy-pasted code to insert, fetch, and update database records on the JDBC and SQL level.
• As such, for every new database table, add three new classes and two interfaces.
• In the base class for all those, use a primary key field of type Object. Ensure that it can really mean BigDecimal, Long, or Integer depending on the context, even for the same class, so to actually get the number value of the primary key, you have to write something like Long.valueOf(obj.getPK().toString()).
• Pass all data in non-generic Lists (admittedly, generics weren’t invented yet) without any comments about what type these Lists actually contain.
• Ensure that the core CMS library, the individual websites, and the utility application used for copying the database between hosts all use different technologies. For bonus points, make the utility application use pure JDBC on the lowest level possible.
• Use a helper library written by your predecessors whose source code is lost, so your successors will have to decompile it first.
• Depend on an application framework but never use its core features, rather only helper classes and tag libraries.
• In JSPs, use nondescriptive names for temporary variables holding objects being rendered, such as “obj” or “list”.
• Instead of using the traditional MVC pattern and letting the controller select the view, link to JSPs and let these JSPs call “pseudo-controller” classes that do all the parameter processing and redirection.
• Start the name of such a pseudo-controller class with an arbitrary letter combination and ensure that nobody knows what it means (such as “PL”). Give all instances of these classes an identical and equally arbitrary name (such as “UC”).
• In said pseudo-controllers, don’t use POJOs to represent submitted form data. Instead, use a self-written form-parsing library that requires to create a member object for every request parameter. Make all these fields public and refer to them from JSPs, better several of them at once.
• Inherit these pseudo-controllers, so that you can’t tell what form fields are being handled without going all the way to the top of the class hierarchy.
• Include JSPs in other JSPs, and in the included ones, reference objects declared in the outer one.
• Create new sites by copy-pasting old ones, so that common functionality added along the way ends up being spread instead of consolidated in the core library. Ensure that every new UI-related feature requires modifying every site in which it’s already implemented.
• Hardcode application logic into JSPs, or into the obscurest classes you can find in random places.
• Tie the core library to the common admin panel, requiring it to be redeployed every time something changes.
• Make said admin panel ridden with editable features that don’t actually work because they weren’t implemented for this particular site but nevertheless can’t be disabled in the admin panel.
• For every feature, write two classes in different packages that do the same thing but slightly differently.
• Use lazy singletons everywhere. Inherit them and initialize them in the strangest of places so that everything breaks down if an include is forgotten.
• Use a self-written authentication system that randomly clears the session upon authentication for an unclear reason, and make the authentication so mind-boggling as to make that particular quirk as unfixable as possible.
• Make the admin panel (which every application depends on) cache the page tree for every single site that exists in the system upon loading, and write that part as inefficiently as possible, so that the server spends minutes reloading the application when it starts fetching page structures from the database.
• Have three different ways of sending mail and make each application use one that its developer liked the most.
• Upgrade the built-in proprietary JavaScript-based text editor with major pain, then downgrade it when it turns out that the customer bought the wrong version by accident.
• Make the menu handler return URLs that end in ”.jsp” even though such JSPs don’t really exist and are all handled by one three-line JSP per page type.
• Require restarting the target server every time the utility copy application is used.
• Hardcode full URLs in the database, so that a text replace function has to be built into the utility application specifically to replace those.
• Make error messages that the end user sees as non-descriptive and user-unfriendly as possible. They’re sure going to be fascinated when trying to register an account to find out that “NAME_EXISTS”.
• Hire a web designer who insists on using table layouts, tag soup HTML, split images and no doctype on the grounds that everything should be compatible with IE5. In 2008.

When mass-renaming video files for Mai-HiME (which I recommend to anime fans out there, unless anything involving magical girls in any way is not your thing; but not the point), I made a mistake in the mv command, which caused all files to be moved to a single destination. I quickly pressed Ctrl-C, but the first four files were lost.

I immediately Googled up an instruction on undeleting files on reiserfs, which (to my dismay) involved unmounting the partition and running reiserfsck—rebuild-tree -S as root. My first thought was: “What a fool I was to choose reiserfs! Surely ext3 can handle undeletion much more gracefully!”

Anyway, I dropped to the root shell, unmounted /home, and in about three hours, it finished. Free space on the partition decreased by about 4 GB, and I found a lot of files in /home/lost+found, many of which turned out to be familiar. I copied files roughly within the size range to a different directory and found three of the four videos (thanks to Nautilus happily displaying thumbnails), but the fourth seemed to be lost.

In retrospect, I should have probably just waited until Monday and asked the guy to whom I lent the DVDs to return them. (And of course, I had no other backup—a lesson to be learned here.) As I remounted the partition and loaded GNOME, minor inconveniences began to pile up.

• The Tomboy applet failed to load at the first login, but subsequent logins fixed it.
• The custom GNOME theme (modified Murrine Brave) became corrupted, and I had to restore it from a UFD (where I copied it to bring it to another computer).
• Thunderbird now just crashed at startup without opening any windows. Luckily, I migrated from POP3 to IMAP Gmail a while ago and moved all my sent mail from the local folders, so just killing the profile was a good option.
• OpenOffice.org and Gajim preferences were reset.
• An Eclipse workspace lost all projects and I had to reimport them. Then it turned out that some Java and C++ projects in this workspace now refused to build because reiserfsck restored them at their previous locations, rather than in lost+found! I had to redelete them.
• Worst and strangest of all, the GTK file dialog now takes a minute to pop up. (Nautilus, mc and the Qt dialog all work fine.) I deleted everything from /home/lost+found and cleaned up the home directory, but the problem still persists…

Was all this worth a partial recovery of deleted files that I could obtain from elsewhere? If it was crucial data, probably… but it wasn’t.

But at least reiserfs has some kind of undeletion—slow, intrusive, problem-prone, but it works. Partially. It turned out ext3 didn’t have even that (while ext2 actually had nicer undeletion).

Maybe I should split the file dump from the home partition and migrate it to ext2…

Three binary packages of note, which I was involved in, have recently entered Intrepid for the first time in Ubuntu.

The Batik SVG library and FOP, the XSL-FO processor, have been in the Ubuntu archive since Warty, but always failed to build. Thanks to the efforts of Onkar Shinde (slytherin) and me, the build issues have been resolved and the binary packages have entered Intrepid.

As a whole on the Java front, I sure hope that its activity will increase with the addition of OpenJDK to Ubuntu and Debian. Note to prospective maintainers: if you’re out of things to package, package Java libraries! This is an area where both distributions are severely lacking. You could start with the dependencies of Execute Query, a database administration tool written in Swing. (Batik was one of them – thankfully, we have that covered now!)

The Code::Blocks IDE, version 8.02, was packaged by Michael Casadevall (NCommander). I already had a package lying on REVU before that, but I figured that someone actually interested in the software would make a better maintainer than someone who packaged it “just because it wasn’t there before”.