blog.s11n.net

Ubuntu: “it just works”

Okay, it’s time to evangelize a bit…

The past few weeks i’ve been considering buying a netbook (sub-notebook). Not because i particularly need one, but because they’re so damned cute and they’re relatively cheap nowadays. In my various train trips i’ve always found a laptop too be more trouble than they’re worth - heavy, battery-hungry, and i only end up getting 1-2 hours of use out of them per trip. i figured with a smaller device i could once again justify taking my computing on the road with me.

This morning i got up and walked about 8 miles around town, visiting just about every computer/electronics shop in central Munich (about 12 shops in total). i found only one shop which had netbooks without Windows preinstalled, and those models had only 4GB of SSD storage. Since my Dropbox has about 14GB of stuff in it, i need at least that much space on my netbook. So i gave up on the idea of buying one which came without Windows, and figured i could use an external CD drive to install Linux on whichever one i ended up getting.

After going through about a dozen stores, i ended up buying an Acer Aspire One (colored dark blue). When i got home i started puting it together and was sorely disappointed to find that it cannot read my external CD drive (which i bought for my oldest laptop, which has a flaky internal drive, and which i use to install Linux on that laptop). After a bit of googling i found a page explaining how to transfer an Ubuntu installation CD to an SD card. Some more googling revealed Ubuntu-specific pages for getting an Acer Aspire One to work, and i was a bit underwhelmed at the amount of manual hackery which was reportedly needed to get it running (or running optimally). Not really interested in spending two days hacking to make it work, i decided to try a vanilla Ubuntu install using the SD card method “just to see what happens.”

An hour later, i was online with Ubuntu 9.04 on my new netbook. i’m writing this post from the netbook, in fact, and the only thing which bugs me so far is that there is no END key (you’ve got to tap Fn-PageDown to simulate the End key).

The Windows XP installation is still there (Simone insisted that i allow it to live, so that she can use it for some of her work-related activities), and everything’s living in harmony on the spacious 160GB drive.

What surprises me the most is:

• WLAN works as-is with no driver module parameter tweaks needed. i had noticed in the Windows setup that it has a Broadcom chipset, and i’ve heard bad things about them vis-a-vis Linux, so i didn’t expect it to work. Works for me, though perhaps a bit more slowly than i would expect. Update 2 May 2009: i take that back about being slow - my speed problems appear to have been transient in nature, and i’m now getting the speeds i would expect.
• Bluetooth works. i’ve just got to press the little Bluetooth button, the hardware activates, and Ubuntu starts up a bluetooth management tool which allows me to connect to, e.g., my mobile phone. i don’t use bluetooth at all, but i love that it works.
• Even on a tiny 1024×600 screen resolution, it looks damned good. Screen space is somewhat tight, but it looks surprisingly good nonetheless.
• OMG, the builtin webcam even works using Cheese (who’s author is one of the few OSS developers i’ve had the pleasure of meeting in person).

So, chalk another one up to the Ubuntu team. And to Linus. And Daniel (author of Cheese). And the tens of thousands of people who have hacked the OS and Gnome and all these other parts over the years.

Now let’s go read up on what the optional hacks for optimizing the Acer Aspire entail…

Happy Hacking!

Extending the Google v8 JavaScript Engine

Hi, all!

In late February i happened to come across a very interesting open source project, Google’s v8 JavaScript engine. Being a long-time hacker of add-ons for the Mozilla SpiderMonkey engine, i felt compelled to try it out.

After a couple of days i was convinced that v8 was a cool platform to work with and put together a project page for my v8-related hackings:

http://code.google.com/p/v8-juice/

v8-juice (the v8 JavaScript Userland Integratable Components Emporium) is its name.

If there are any other C++/JavaScript half-breeds out there, the project is looking for talented hackers to improve and expand it.

Happy hacking!

OMFG: i am on the cover of Dr. Dobb’s Journal #416 (Feb 2009)!

Back in October i briefly met Mr. Jonathan Erickson, editor of Dr. Dobb’s Journal, and spoke to him a bit about the presentation he had made at the Qt Developer Days conference in Munich, Germany (primarily about concurrency). After he returned to the States we shared a few emails and then went around our business. He had, in one email exchange, asked if i would fill out a short questionnaire for a column DDJ does now and then to briefly present random programmers they meet. Not one to miss a good opportunity to write, i of course answered. That was, incidentally, on October 30th (my father’s birthday and the two year anniversary of my cancer diagnosis), and i hadn’t given it any thought since then. But i just learned that all that time, Jon was busy plotting…

A couple hours ago my mother called me to tell me that (A) she loved me, (B) the latest edition of DDJ had arrived (my subscription is sent to her to save the overseas shipping costs), and (C) that i was on the cover.

What? i beg your pardon? i seem to have a small mammal in my ears, interfering with my hearing. i thought you just said that i’m on the cover of DDJ. The DDJ.

No, seriously. The cover is my face. It’s the same picture from my home page. Only a lot bigger. Huge, one might say. (For the curious, the picture was taken in Sylt, Germany, in August of 2006, by my girlfriend, Simone.)

The articles mentioned on the cover have absolutely nothing to do with me (nor i with them) except for the little blurb on the bottom/right:

Freelance Programmer Stephan Beal, see page 12

No, seriously.

My mugshot certainly isn’t going to help them sell copies, so why that picture for the cover, of all the lovely and beautiful images they could have used? Your guess is as good as mine. My only theory at the moment is the visual association of a cloudy sky (which is mostly cropped out of that copy of the image) with the headline article, entitled “Computing in the Clouds” (but, again, i’m not associated with that article). Well, and maybe because my clothes match the overall color scheme pretty well. No idea, really.

Unfortunately, the February edition of DDJ isn’t online yet, so i can prove to you not one word of what i just wrote. i can’t post the scanned copy my mother sent (for copyright reasons). So it’s my word against… well, against someone’s, certainly.

So here’s how we can settle this: if you’ll go to your favourite I.T. news stand right now, you might just find me waiting for you! If you’re a DDJ subscriber, i’m already there.

Happy hacking!

PS: Thanks again, Jon! That really made my day!

Four reasons to take a closer look at the Fossil SCM

This post was originally made to the mailing list of the Fossil source control system on January 11th, 2009, with the subject line “A letter to the new or unconverted fossil user”. After reading it over again, i figured i could recycle it as a blog post to evangelize Fossil a bit. It might also make good food for the 200+ spambot suscribers to this blog from @mail.ru.

…

This is addressed those of you who are new to fossil and those who have used it for a while but just aren’t quite sure whether they like it or not…

Sometime in late 2007 i came across a link to fossil on sqlite.org. It was a good thing i bookmarked it, because i was never able to find the link again (it might have been in a bug report or something). The reasons i first took a close look at it were (A) it stemmed from the sqlite project, which i’ve held in high regards for years (e.g. i wrote JavaScript bindings for it: http://spiderape.sourceforge.net/plugins/sqlite/), and (B) it could run as a CGI. That second point might seem a bit archaic, but in practice CGI is the only way most hosted sites can set up a shared source repository with multiple user IDs. (i’m not about to give out my only account password or SSH key for my hosted sites, no matter how much i trust the other developers, and none of my hosters allow me to run standalone servers or add Apache modules.)

So i tried it out. The thing which bugged me most about it was having to type “commit” or “com” instead of “ci” for checking in (as is custom in all other systems i’ve used), despite the fact that fossil uses “ci” as a filter in things like the timeline view. Looking back now, i have used fossil for about about 95% of my work in the past year (http://blog.s11n.net/?p=71), in over 15 source trees, and i now get tripped up when i have to use svn or cvs.

So, having got over typing “fossil com -m …”, here’s why i love fossil so much…

Point #1: CGI

Again, this sounds archaic, but fossil has allowed me to share source trees which i cannot justifiably host in other projects i work on (they don’t belong to those projects), which i cannot host in Google Code (because google code doesn’t allow/recognize Public Domain as a license, and i refuse to relicense just to accommodate them), and for which SourceForge is overkill (and way too slow). With fossil i can create a new repo, have it installed on my hoster (http://fossil.wanderinghorse.net), and be commiting code to it within 5 minutes.

Point #2: Wiki

i hate wikis. i really do. Always have. They all have a different syntax and the content tends to get really disorganized really quickly. Their nature makes it difficult to reorganize them without replacing old pages with lots of “has been moved to [TheNewPage]” links. i’m one of those “code for tomorrow” coders (i.e., code such that it’ll be easy to reorganize/refactor later). i like to document the same way, and wikis make that problematic. Then again, no documentation system is really good in that regard.

That said, fossil has made me love having a centralized, common documentation platform. Whereas i used to document everything in the API docs (header files) and often include an ODT file for a library manual, fossil has become my preferred platform for non-API documentation because it’s just so easy to do. No matter where i am, i can log in and write (i write a lot). The added ability to export my wiki pages, edit them in xemacs, and re-import them just makes it nicer, as i can tweak as much as i want without ending up with 10 “updated wiki page SoAndSo” messages in the commit log.

Point #3: running a server locally

Fossil runs not only as a CGI, but as a server. i don’t WANT to host my own server (and don’t have the rights to on my hosters). i hate server-side maintenance (a hate born from years of administering systems). But the server has other uses. When working on the wiki, bug reports, etc., the local server is the way to do it. It’s blazingly fast and much more productive. When you’re done, just run “fossil push” and everything’s synced.

Point #4: the single-file repository

Having all controlled content inside a single container file has been a godsend when it comes to backups and copying/moving a repository. There are no access or file ownership issues, which are often problematic with other server-side systems (at least on the initial install). For about 5 years i administered a CVS repo for a company for, and every time someone added a directory to the (huge and dynamic) source tree i had to log in and “chmod 4775″ the directory before others could commit to it. Fossil’s model inherently eliminates that type of problem, and i’m a *huge* fan of solutions which inherently (that is, due to their very nature) avoid certain foreseeable problems. The single-file repository model’s flexibility would seem to become more problematic for massive repositories (a few hundred MB+) with many users with differing levels of access (e.g. OpenOffice, Firefox, or the Linux Kernel), but 99.9% of projects never reach anywhere near that size or complexity. (For that level of project, it would seem the world is quickly migrating to git.)

In summary:

i remember my first reaction to fossil being, “this will be an excellent solution for small projects [like the dozens we've all got sitting on our hard drives but which don't justify the hassle of version control].” A year of daily use in over 15 source trees has confirmed that, and i continue to heartily recommend fossil to other developers i know who also have their own collection of “unhosted” pet projects.

Even if fossil stagnates today, never adds another feature, and never gets another bug fix (what bugs?), this is a tool i see myself using for many years to come. (No, honestly, i don’t know what bugs you’re talking about.)

Happy hacking!

Happy New Year! A hacker is born!

Hello, all!

On this day in 2004, i made a post with the subject line “3… 2… 1.0!” to announce the release of libs11n, which had been in heavy development for almost 18 months at that time. A year later, 1.2.0 was released. Since then, libs11n’s 1.2.x branch has been fairly stable and has undergone only relatively minor updates and a few bug fixes.

This year i don’t have a new libs11n release to make :`(. That library is stable and useful, and the improvements i’d like to make would require some significant rearchitecting in areas where (A) i’m simply not the right man for the job (e.g. i118n/wide character support) and (B) i have little interest and therefore correspondingly little drive to work on them.

But that doesn’t mean i haven’t been coding. In hindsight, 2008 has been a record year for me in terms of number of lines of code produced, on par with 2004 (when i would sometimes spend 60+ hours per week hacking on s11n - one particular week saw about 100 hours of hacking and less than 20 hours of sleep). Quite unlike 2004, where i expended 100% of my energy on libs11n (and its supporting code/subprojects), 2008 saw the birth of several new pet projects.

So, though i don’t have another 1.0 (or 1.1, or 1.5) release to present at the end of this year, i thought i’d post a bit about what software i’ve been working on this year. This post is not to brag, but does serve a few purposes:

• i won’t deny it: publicity for new personal projects which might be of interest to some other hackers out there.
• i’m trying to justify to myself why i spent so little time with my family (Simone and Baako) this year. Likewise, my parents and friends probably wonder why i’m so uncommunicative.
• Help me internally sum up what’s just passed, to help me sort out what comes next.
• We all started coding somewhere, and we all draw inspiration from different places. It is my hope that some young hacker out there may be inspired to explore his love of computing. With some effort on his part he may someday surpass us all in ability.
• And lastly, to set up the scene for my “coming out” at the end of this post.

So, here it goes…

(In case you’re more interested in a quick summary, just read the text marked in bold.)

The first half of the year was quite slow, in terms of coding. i had just moved back to Munich and was settling in. On this very night one year ago we didn’t yet have a flat in Munich, and were stuck in a hotel room so small you could practically step into the bed from the doorway.

The code i do remember working on includes what i now call whprintf, a custom printf() implementation which i took from the sqlite3 source tree and refactored so that it can send its output to an arbitrary destination (e.g. a GUI widget, stdout, a socket, or a memory buffer) via a callback mechanism. Aside from that, i mainly experimented with utility classes for C, such as managed memory buffers and hashtables (i couldn’t code my own hashtable from scratch, but i hacked quite a lot on one written by Christopher Clark).

In April or May of 2008 i came across PEGTL, a C++0x library for creating PEG parsers using C++ templates. PEGTL inspired me tremendously, and PEGTL’s author (Dr. Colin Hirsch) and myself exchanged over 100 emails on the topic inside of a month or so. Unsatisfied with some of his design decisions, i of course took it upon myself to take a crack at the problem. My first attempt, named parse0x, was also a C++0x library. It did almost everything pegtl did and i was happy with it. i was, however, unhappy that i couldn’t use parse0x in real projects because it requires C++0x support, which is still far from leaving beta status in the next generation of C++ compilers.

So i sat down to approach the problem from C++9x, and hacked out parsepp, which is similar to both pegtl and parse0x, but nowhere near as powerful as libraries like Boost.Spirit.

And all was good. Two projects behind me and the year not quite half over, i got a sudden urge (for reasons i don’t remember), to rewrite an old program of mine for playing boardgames on the PC (tactical/strategy games are a hobby of mine, though i haven’t actually played any in some years). So i spent much of June getting back into Qt by writing QBoard. As is usual with Qt apps, QBoard grew way beyond the minimalistic app i wanted to write (Qt just makes it easy to keep adding features), and within a month or two it was doing 90% of everything i would probably ever want it do, and QBoard now sits quietly, awaiting the next urge to hack on it. If you use (or are aware of) libs11n, it might interest you to know that libs11n was originally written to support the rewrite which would become QBoard. That is, QBoard is largely the reason libs11n ever came into existance.

The last time i did any significant work on QBoard was September, after which i was again enchanted by the idea of PEG parser generators…

In the end of 2007 i got involved on the fringes of the Fossil project, where i contribute patches now and then. Fossil re-awakened my interest in C (which i used heavily in 1992-1995, but not since discovering higher-level languages), and since early 2008 i have spent a significant amount of time banging out little C libraries, both to get back into practice and to build up components for other planned projects. That re-emergence of interest in C, combined with my fascination of the concept of PEG parsers, led me to try tackling the PEG problem again, but from a much different direction than before.

And thus pegc was born. pegc was to be my third PEG parsing library in 2008, but this time it was implemented in C (and in fact has turned out to be somewhat more interesting than the C++ variants). As far as i have been able to determine, pegc is the only C library of its kind (there are some C code generators for PEGs, but no C libraries). After getting pegc to a “90% there” point, i put it down for a while to put some more thought into a few of the internals, and didn’t hack on it for a couple months. Unaware that anyone else knew about pegc (other than google, of course, but i thought he could keep a secret), another coder surprised me by sending me an email in which he explained that he had implemented a LISP-based PEG generator using pegc as the back-end. That has (yet again) re-awakened my interest in PEGs, and there is certainly more work to be done in this area in 2009.

The year was a couple months short of ending and i had accomplished much coding and solved some problems which interested me. But, as i would later find out, the year was far from over. My two greatest challenges were to be found hiding in the bushes up ahead…

Encouraged by pegc’s development, i decided to expend some effort on a problem which i had original discounted as “too much trouble to be worth the effort” - the generic serialization of objects in the C programming language. (Ouch!) So in late October i sat down to hack. Within a few days c11n was born. While c11n cannot reach the ease of use levels of C++ serialization libraries (because C is not “dynamically expressive” enough to do so), it does work and wasn’t nearly as difficult to implement as i had initially anticipated (it was simply a matter of finding (err… stumbling across) a useful model).

It was sometime in early December, the year almost over, when i got the itch to work on yet more C code.

There’s a problem i’ve contemplated for years but never really knew where to start - a virtual/embedded filesystem. Google reveals little non-commercial activity in this area, so there aren’t many decent starting points to study. This type of problem is C’s bread and butter, and having lost much of my previous distaste for C, i took what i’d learned over the previous year and tried to apply it to what was (in my mind) my most challenging C program yet. Truth be told, i was largely anticipating a crash-and-burn coding session, at the end of which i would be so frustrated as to leave C forever.

After a day or two of hacking i had the basic filesystem generator in place, but wasn’t happy with the i/o model (based on the C-standard (FILE*) API). So i scraped out the i/o layer API from c11n (which i had grown quite happy with), extended it to support random-access devices, and forked that to create the whio i/o library. The primary reason for this step was so that the VFS could use arbitrary back-end storage (provided it’s capable of random-access), and to that end i added implementations for treating standard file handles and in-memory buffers as i/o devices.

With whio in place i reimplemented the embedded filesystem (now called whefs) around it, and within a week or ten days i had gotten the rest of the significant bits in place. As of a few days ago i’ve got a working embedded filesystem library, which is like my little Christmas present to myself (just a few days late). Now i’ve just got to find a use case for it. (That said, googling has revealed very little open source code in this area, so there is potential for whefs to become a useful niche market product.)

Whew!

And now i’m tired and have sworn not to program a single line of code for the rest of 2008. All 4 hours and 39 minutes of it. I might write some documentation, but i’ll (somehow) avoid the temptation to code. i think i can do it. Wish me luck.

It wasn’t my intention to turn 2008 into a running hackathon, nor to set a personal record, but that’s essentially how it turned out. Truth be told, little of this is code which i will use on a regular basis. Nonetheless, i immensely enjoyed hacking on these projects, and some of them will certainly see continued development for some time (namely c11n, pegc, and whefs).

According to David Wheeler’s SLOCCount, it would have cost a company around half a million dollars to get it all written and out the door, whereas a garden variety hacker can do it all from the comfort of his living room using nothing more than freely-available tools like XEmacs, GNU Make, gcc, and google. Though he also isn’t likely to get paid for it.

And speaking of hackers…

(Now for the “coming out” announcement…)

Per long-standing traditions, programmers are never to call themselves hackers until another hacker calls them a hacker. This is fair and respectful, and in deference to this ideal i have always been careful about who i publically dub to be a “hacker.” i have in fact been called a hacker by other hackers, but i don’t normally proclaim myself to be a hacker. Part of the reason is the misinformed public opinion that a hacker is one who breaks into computer systems (something i’ve never had an interest in and certainly never done), where as we (that is, anyone who would read so far into this blog post!) all know that a hacker is someone who not only loves working on software, but is also particularly good at it. Another reason i’ve avoided using the word in reference to myself has been because i have not always felt that i am quite qualified to wear the title. i won’t claim to be a guru in any given area of computer science (and i’m certainly a zero in many areas!), but i can confidently say that i am a fairly good general-purpose programmer.

But i’m also now convinced that i am indeed a hacker. The past year i somehow managed to implement three programs in particular (c11n, pegc, and whefs) which i would have thought impossible (for me) half a decade ago. That might be reason enough to be dubbed a hacker. The more compelling reason, however, has nothing to do with lines of code or architecture or the number of functions in one’s API. Simone has sometimes asked me, “how can you be so tired from your six hours at work, and then sit here for 12 hours programming?” The answer took me some time to find (as i had never given it any thought before), but is in principal simple. Everything we do requires an expenditure of energy. Working as a Unix system administrator (my current job) takes a lot of energy. It sucks me dry at times. Programming, on the other hand, not only takes relatively little energy (per unit of time), but often literally gives more energy than it takes. That has convinced me that i may unashamedly use the title Hacker (though i’ll use a small “h”, to keep it in proportion ;).

So, there you have it. i’ve just written the world’s longest “i’m a hacker” post.

Happy hacking!

PS: i’ve still got 3 hours and 14 minutes before i may hack again.

Update: 1 hour and 47 minutes

Writing PEG parser generators in lisp

Hi, all!

i’m no lisp programmer. Though i’ve used some variant of emacs as my primary editor since 1996, i’ve never bothered to learn lisp (the linga franca of emacs). But today i got a bit more interested in it…

First we need to briefly introduce pegc, a PEG (Parsing Expression Grammar) parser generator library for C (it’s not a code generator). A few months ago i spent some weeks working on pegc, mainly just to see how far i could stretch/push/mold that model using only the C language (it’s been demonstrated many times over in C++ and other high-level languages, but AFAIK pegc is the first C library of its kind). It was an interesting problem with interesting implications and future uses, but not something i really needed “right now.” So, in short, pegc is a beta piece of software which i wrote but which i’ve never actually used (only in pegc test code!), so i haven’t gotten around to figuring out what needs to be refined/changed. So it surprised me when i got an email about pegc today.

With that in mind…

A couple hours ago i got a mail from Zajcev Evgeny (a.k.a. “lg”), a member of the SXEmacs project, where he revealed something pretty impressive. As part of the SXEmacs project he’s integrated pegc with lisp, such that people can write parser generators in lisp, and those parser generators will use pegc for the back end. (His intention is to use it to implement a syntax highlighter.) As an example he says:

yeah, i’ve done this on Emacs Lisp level, you can specify either raw
ruleset like this:

(setq pp (pegc-intern-ruleset
    '((sentence (and (opt article) subject verb
                     (and (opt preposition) (opt article)
                          (or object (and object preposition)))))
      (article (and spaces (or (str "the") (str "the two") (str "a"))))
      (preposition (and spaces (or (str "on") (str "at") (str "to")
                                   (str "with"))))
      (subject (and spaces (or (str "man") (str "men") (str "dog")
                               (str "dogs") (str "cat"))))
      (verb (and spaces (or (str "sat") (str "saw") (str "shot")
                            (str "gave"))))
      (object (and spaces (or (str "cannon") (str "hat") (str "mat"))))
      )))

and then use it like:

(pegc-parse (pegc-create-parser “the cat sat on the mat”) pp)

which assumes first rule in ruleset as start symbol

Or otherwise you can use user friendly expression like this:

 (setq pp #<peg sentence    -  article? subject verb
                                 (preposition? article?
                                   (object / object preposition object))
                  article     - spaces ("the" / "the two" / "a")
                  preposition - spaces ("on" / "at" / "to" / "with")
                  subject     - spaces ("man" / "men" / "dog" / "dogs" / "cat")
                  verb        - spaces ("sat" / "saw" / "shot" / "gave")
                  object      - spaces ("cannon" / "hat" / "mat")>

which produces the same interned ruleset as previous raw
specification.

Pretty cool, in my humble opinion. i was extremely impressed with what he’d accomplished, but also extremely surprised that pegc could do the things he’s doing. The exchange went like this:

Stephan Beal wrote:
> Holy cow! You got all that working with the existing pegc code??? And
> it works!?!?

yes, actually pegc is quite solid and extensible.  I did not modified
a bit in pegc code to implement this.  I just created two levels of
abstractions - 1) low level - is direct FFI to pegc code and 2) high
level - is written to omit low level details and just do what user
wants

Just what a software developer wants to hear! :-D

When i started pegc, i never envisioned the possibility of using it as the back-end for parsers in any language other than C. Now that the proof of concept is out there, the possibilities would seem to be pretty limitless. We could theoretically use SWIG to generate bindings for just about any scripting language.

Just what i needed - yet another interesting project to divide my time amongst!

Back to hacking!

—– stephan beal, 23 Dec 2008

My Technology Pick of the Year 2008: Dropbox

i’ve never really done anything like this before, but let’s give it a try…

2008 is almost at its end and there’s one product/technology which has been so exceedingly helpful to me the past six months, that i thought i’d spend some time evangelizing it and giving it the completely unofficial title “My Technology Pick of the Year 2008″.

Dropbox (http://www.getdropbox.com) has revolutionized the way i do backups. It’s not just useful for backups, but for transparently keeping files synchronized across several machines.

Dropbox provides free access to up to 2GB of storage. For a nominal fee, 50GB of storage can be had (curiously, there are currently no packages between 2GB and 50GB, nor more than 50GB).

For backups, i used to reserve a second hard drive, run a makefile once a month or so, and create huge tarballs of selected directories. For the files i wanted to keep synced across machines i’d use subversion. Subversion is all fine and good, but (a) i don’t like using it for large groups of binary files, (b) i hate having to manually sync the trees, do commits, etc., and (c) it’s dog slow for large repositories.

In comes Dropbox. Dropbox is a daemon process which runs on your PC (Windows, Linux, or Mac). During the installation you choose a specific directory (a.k.a. your “dropbox”), and everything under that directory is automatically/transparently synchronized with your dropbox account. When you change a file in your dropbox, it will be transparently synced at some point.

You can currently link up to five computers to one account, so that you can synchronize your files across up to five machines. By “you can synchronize”, i mean “you copy a file into your dropbox on machine A and it will magically appear on machines B, C, and D.”

One of the most useful aspects for me has been sending myself files over the web interface. For example, i’m at a buddy’s house and he has a file for me. From his PC i can upload it to my dropbox via the web interface. When i get home, the file is literally already on my hard drive (in my dropbox folder). Convenience at its finest.

Dropbox also has features which i haven’t personally used but are obviously useful in certain cases, such as sharing a dropbox folder with multiple dropbox users, and sharing a photo album (i personally use Google Picasa for that).

The only annoying thing about dropbox is that the developer’s haven’t yet documented their data protocol (they claim they will eventually get around to documenting it), so i haven’t been able to start writing a CLI client for dropbox. They do distribute a GNOME-based file manager called Nautilus which has dropbox support built in (e.g. it can show you which files are synched and which are not), so in theory we have the information we need to write our own apps, but separating the file manager code from the dropbox code is tedious. Once they open up their protocol specs, i expect we’ll see a flood of useful dropbox add-ons, up to and including a dropbox filesystem driver (to allow one to mount a remote dropbox as a filesystem).

If you haven’t tried Dropbox, try it out. i fell in love with it inside of 27 seconds, and there hasn’t been a day since then which i haven’t been thankful for dropbox.

—– stephan beal, 23 Dec 2008

How KDE and Kubuntu lost a devotee

Ever since the middle of 1998, i’ve been a KDE user (it was right before the 1.0 release, if i recall correctly). KDE was, at the time, light years ahead of other Unix window managers, and it still is to this day. Or was, until KDE 4.0 came out.

i was recently (due to a hard drive problem) prompted to upgrade from Kubuntu 8.04 to 8.10. Part of that change is the switch from KDE 3.x (which is essentially Desktop Nirvana for me) to KDE 4.x. Man, am i disappointed.

KDE 4… here’s what i have to say about it:

• It’s frigging slow. Even with the proper graphics drivers and everything set up properly, every single thing about it is dog slow. My PC isn’t slow. KDE4 is slow.
• It’s got fewer customization options than even GNOME has. That is, next to none.
• The desktop is now unusable. i can only add new “plasmoids” to it, and i don’t frigging need to have my weather forecast on the desktop. The new folder views are a half-ass attempt at approximating a desktop-within-a-desktop, but it fails miserably, IMO. i want folder and application icons on my desktop. i like icons. KDE won’t let me do that simple thing.
• It took me 5 minutes to figure out how the new GUI (Graphical Unusable Interface) for configuring the panel is supposed to work. It’s extremely non-intuitive and only marginally logical.
• Try dragging an application to the panel (to create a quick-launch button for it). All find and good. Now try changing that app’s icon from the default “gear” icon to something more useful. This most utterly basic feature is missing - it is impossible to visually differentiate quick-launch apps added to the panel this way (and i haven’t yet seen another way to add apps to the panel).
• They went all out on look and feel and put an inverse amount of effort into usability and functionality. i’m sure some KDE 4 applications are (or will be) pretty cool, but KDE 4 as a desktop environment cannot do anything useful except sit there and look good. Try to use it, and it will fight you.
• The Konsole app (where i spend about 20% of my computing time) no longer saves its sessions, meaning i have to re-setup some 6 or 8 terminal sessions when i log in.
• To paraphrase Terry Pratchett: whoever developed the UI concept for KDE4 had apparently heard of the desktop idiom before, but had never actually used it. (While some do not like it, i do like the conventional desktop idiom.)
• KDE4 should still be labeled as Beta. It should not be the default desktop for any distribution just yet.

After fighting with KDE4 for a few days, i have given up on it. Kubuntu 8.10 doesn’t have official repos for KDE3, so i did the unthinkable and switched to GNOME. GNOME is not a bad desktop, really, but for power-users it needs about 3x the number of customization options. i’ve never used GNOME on a regular basis because (A) the lack of customization options is insulting to me and (B) i have some deep philosophical differences with some of GNOME’s underlying architecture.

Nonetheless, given the useless state of KDE4, and the impending obsolecense of KDE3, it would seem to be time to move on to other (though not necessarily greener) pastures…

[i originally wrote this post on 27 November 2008, but didn't post it because i try to avoid posting flame-bait or "bad mood" posts. Two weeks after writing it, however, i've decided i still agree with all of the above points, and i am quite certain that i wasn't just in a bad mood when i wrote it.]

Update: 26 January 2009:

According to http://www.linuxworld.com/news/2009/012209-open-source-identity-linux-founder.html?page=6, Linus Torvalds has also dropped KDE for GNOME. i unfortunately can’t quote it here because the fuckers use an image for the article text, as opposed to something one can copy/paste. Linus does say, however, “… the whole ‘break everything’ model is painful for users and they can choose to use something else… I suspect that I’m not the only person they lost.”