So, I recently saw some more updates on the Gnome Live wiki regarding the evolution of a ‘Semantic Desktop’. I have some bad news people: Its not going to happen. Now before everyone spends 20 minutes explaining all the ways it could, let me clarify my point. It’s a largely unattainable goal, which if it ever were to complete, would be a horrible user experience. I think somewhere between RDF, FoaF, and ObjectRank we lost sight of the original goal of a Semantic Desktop. We wanted to organize, present and store data in a fashion more congruent with the human mind. The general effort behind the Semantic Web and Desktop movements was to reduce the ‘multiplier effect’ of communication. (Take for example one e-mail sent to a mailing list, the file and data is now duplicated a hundred times over, and each receiver must filer or classify the e-mail with relationship to themselves). On the scale that communication takes place over the web, this effort is still crucial, but in the desktop world, where we operate on a billionth of the scale, that problem is not nearly as pervasive. No doubt the advances made in understanding and structuring the mass hysteria of the web will benefit desktop users, but I think forcing that structure onto the desktop is not only impossible, but counter-productive.
In my opinion the options are clearly laid out before us:
1) Move the desktop into the structured realm of a million and one tags/categories/color filters/labels/folders
- Or -
2) Get rid of it all. And just know what the user wants. (Ok, not really all of it, but instead of adding more hierarchies, we add more in-place understanding)
I know, its a bold statement, but somewhere between my tags, stars, labels, folders and emblems I realized that all these efforts we were making towards ease of use and understanding are just obfuscating things even further. These elaborate systems that require users to squeeze into sub-par standards like iCal exacerbate the problem even more, and ignore the efficiency of simple systems, like a pad of paper. (Yes, props to Tomboy). The problem is, many times a blunt-simple interface requires significantly more work on the programmers side (to actually understand the data entered) than a more traditional tabs-and-forms approach. I think we are demanding too much from users, how many people actually keep their address book completely updated? Or tag all their photos, or keep every document in the right folder? Even those who are vigilant eventually fall behind, and that’s because users already know what the material they are filling is, but still have to spend time explaining to the computer which items are related and where they belong. Especially for users with large sets of desktop data (Few thousand docs,e-mails,photos, and songs) the time can add up. Instead of asking users to commit even more time for data integrity and organization with more tagging systems.
The way I see it, we can count on 2 skills from a Desktop user.
1) Searching ( ThankYou Google!! Most people are quite comfortable with search phrasing!) or more accurately, knowing what they are looking for
2) To use their computer even when they aren’t looking for something (ie content generation, surfing the web, chat etc.)
These are the common denominators that we should be reaching for. We shouldn’t be trying to make the user classify their relationship with each person in their address book, we should just always be there, identifying the relationship based upon their level of interaction. And on a higher level than traditional approaches have taken us. After working on the Beagle Project for some time, the incredible weight of maintaining the backends to communicate with each mail client, each rss reader and each chat client almost seems to drown out the gain from having the data in a central and unified place. I mean, each time it was just someone talking to someone else right? Why have we taken simple actions and tried to codify them, when the complexities of human behavior are so great any Psychologist would tell you its a guessing game anyways. I think we should start with the disorganized mess that is someones workday at a computer and ask for nothing else. Reverse the system, take all of our analytical energies and structure, and use it for ourselves, in the backend, and just have the users use computers.
The best example of this is the phenomenon of tagging. Basically associating like objects via keyword-phrases. The problem is tags restrict themselves, lets say I have created a blog post about web browsers, while the tags ‘html, web, mozilla, ie’ may indeed be the most accurate 4 words from my point of view, they in no way approach the whole set of meanings and connotations carried by all their synonyms, let alone the entire post. In the realm of multimedia, tags are more useful, as images and videos are harder to extract contextual value from, but there is a better way….
Lets be smart! Instead of trying to stem the tide of data to make it more manageable, we ride the wave! Data is very rarely stagnate on a machine, people send photos to friends, edit each others papers, and share music all the time, there is a wealth of information in the chat I have with a friend while he listens to the new song I sent him, we just need to grab it!
I have specifics and even a little bit of code for my next post, but until then, I want feedback, do people agree? I mean, yeah, a million and one more ways for me to catalog and store my data, but when I’m actually looking for something the tags never seem to help much. While tags and folders do help with the clutter problem, I want to propose the idea that we move completely beyond presenting the hierarchy to the user, and start determining how (from the most basic of usage data) we could better present/organize information. Is the ubiquitous search box the only UI system that fits? What about something like Dasher meets lowfat, powered by an incredible datastore, but for files?
Author Archive for Kevin Kubasik
So, I think most of the open source world has agreed that the DRCS model fits our working style better than the traditional model pushed by SVN and CVS etc. And in this DRCS world we have rallied around 3 main tools: Bzr, hg, and git. And in an even greater display of complacency we have given those 3 tools quick and general classifications that became obsolete almost a year ago. Bzr is user friendly but slow and technologically inferior, hg is the champion of the middle but with slow development and a lackluster community, git is wicked fast and ‘The Right Way’TM but a pain to use.
Really? Come on guys, those molds were cast almost a year and a half ago, isn’t it time we looked at things again? Git has an entirely new interface, hg has a slew of plugins/extensions, and bzr has a completely new repo format, and network protocol, resulting in a massive speedup. Now I’m not claiming to be some unbiased source, and comparing 3 incredibly robust tools is not my job, but given the amount of support that Git receives from its very vocal supporters makes me feel a need to give props to my favorite DRCS system: Bazaar.
That’s right, Bazaar (or bzr) is awesome. Sure, git is awesome too, and so is mercurial, but I have found myself loving bzr. I’m not going to attack other DRCS tools, I just want to extol the awesomeness that is bzr.
1) Bzr is Python-Tastic! - As a python hacker, being able to utilize a robust API and plugin system is a cool plus, this also generates lots of powerful and complete plugins, which leads me to the next point.
2) Bzr has a ton of plugins! - Plugins like bzr-avahi (allows the discovery of branches on a local network, great for sprints/hackfests), bzr-svn (makes working with upstream repositories easy as pie!), quilt and gtk tools.
3) Bzr works on Windows - Yeah, I’m not a huge fan of accommodating Windows users, but it makes collaboration easier, I don’t have to make my roommate boot into Ubuntu to lend a hand with some CSS bugs.
4) Bzr is easy to share - The ability to push branches to some central repo is a big component of distributed development. While patches work in some cases, most of the time, having access to a branch makes the whole system work better. Both Git and Hg require a bit of work to set up a new repo and push a branch, bzr supports a ton of protocols and can create the target directory/repo with one command. Sharing is easy!
5) Bzr is fast - Maybe others are faster, maybe it could be a million times faster, I dunno. What I do know is the only thing I seem to wait on is my net connection… I realize that many people need more than that. So here you go. http://bazaar-vcs.org/Benchmarks
6) Bzr is small - In my development model (a shared repo with branches inside of it) bzr is compact and aware of disk space, without repositories it might be huge, I dunno.
7) Bzr is clear about whats happening - I can follow what Bzr is trying to do with my code. A branch is a new directory, and I can always see my code. Not only is this comforting/reassuring, but I often utilize IDE’s like Wing, Eclipse, or Monodevelop when working on code, and while they can handle other systems, directories for branches translates to every editor and works well.
Bzr is reliable - A massive suite of unit-tests and a commitment to their excellence offers some comfort that I won’t be left holding half of my code in one hand and an ugly binary blob in the other.
9) Most of all, its a feeling. Its hard to explain, but I don’t notice bzr. Its just there, and I just have my code. I rarely take notice of it, and don’t focus on it. I spend 99% of my time coding and every 30 min I enter a terminal for a few seconds to do all my DRCS stuff. Maybe its why people who use Bzr aren’t very vocal about it. Its not a revolution in revision control, and I don’t do a million cool things in it. I just write code, and bzr is there, doing whatever it does.
If your in the greater Salt Lake area and love python swing by the meeting this evening! We’re doing a python editor head-to-head, should be fun!
So I noticed that one of the accepted proposals for the Mono project is to create a LINQ provider for SQLite. Major props to this (its something I totally want to see!) and I’m glad to see that LINQ in Mono is going to be its own beast, I love it when the FOSS community just takes a technology and runs with it! Anyways, I wanted to try and get in touch with the mentor/student of this project and share my experience (as the author of the current LINQ to SQLite component ). But contact info seemed hard to come by, so I thought I would post what I had learned.
First, people really want this, and there are several half-complete implementations floating around, including mine (read only, no commit/update/delete support) and this one.
Second, support for just queries is quite easy. Support for complete CRUD, tedious but not to difficult (lots of examples already exist). Support for the generation/mapping/reflection of a database to real Linq objects, this is the tricky part (specifically the UI elements when unable to just piggyback the Visual Studio work).
Anyways, all the luck in the world to this GSOC project, I would really like to see a working implementation come from this!
So, if you live in the greater Salt Lake City area, there’s a pretty cool low key (and free!) conference coming up, the Utah Code Camp. I’ll be doing a little talk on getting data out of HTML with Python (utilizing lxml and twill). If your interested, you can register here.
So if your like me, you’ve been suffering through some painful sound problems in Ubuntu Hardy, apparently its a known kernel issue, so just sit tight. However, if your like me (or 90% of nerds) then you need some sort of music to code. A little digging revealed that I did not in fact have any of the alsa kernel modules installed for my current kernel. apt-get left me high and dry (also without an nvidia driver yet, but that’s an easy fix).
The simple remedy is to just build the alsa modules yourself, a pretty painless task. The problem is, if you want to have any hope of keeping your install halfway clean, then you need to get those files tracked by dpkg so we avoid conflicts when the modules are fixed. There’s a simple solution:
sudo apt-get install module-assistant
sudo m-a update
sudo m-a prepare
sudo m-a a-i alsa
This utilizes the handy module-assistant package to automatically build alsa for you. 
Reboot and enjoy!
So I just returned from my massive onslaught of travel that started with PyCon, took me from one US coast to the other, a Carribean island, and then back home to Washington D.C. I’m on Spring Break for the rest of the week, and hope to get some good blog posts in reguarding the awesomness that was PyCon 2008!
So the more I work with Django the more I long for a solid development environment to work in. I use Wingware for much of my python development, with its rockin debugger and code completion, its more than I could ask for. Until the curse of the Java class. This quarter I’m taking a Java projects course, most of the class uses Eclipse but a few use Netbeans. My problem is, I got spoiled so fast by the incredible templates support, content suggestions, quick fixes and always dead on code completion. Going back to Wing feels like a halfway-there IDE. I know that pythons interpreted nature makes source completion much more difficult, now I would argue that with an interpreter, you could actually step through the code to some extent. However, I respect that dynamic objects are never gonna be easy to support. My beef is with the lack of support for super-popular frameworks (this goes for everybody!) Ruby on Rails has literally dozens of solid IDEs and a few that are just spectacular (see Aptana, or Netbeans). Why can’t I get even basic highlighting support for my Django templates? Why can’t I get any completion options on Models except my own?
Its just frustrating, Django is still a pleasure to develop in, even with just Gedit and a terminal, but is it really out of the question to consider providing a big pretty environment for those of us that like that?
I did dig up this and this. I guess its a step in the right direction, but its almost embarrassing next to the Rails environments.
So I just finalized my registration for PyCon and booked my flight! I can’t even begin to express my excitement! If anyone else plans on attending, I made a wiki page for you to add your name to!
See you there!
So I attempted to migrate my blog from Wordpress to Movable Type Open Source. I’ll go into specifics later, but suffice to say that it was a miserable failure. Problems with planets, constant admin interface crashes, extremely spamable, and most of all, just unusable.
As a result of my reversion back to Wordpress, I have lost a few posts, I will try to migrate them back, but its possible I’ll just do a major ‘things that we have missed’ post in a bit. Anyway, more updates coming soon.
Ok, I replaced our original autocomplete system with something a little more reserved, and based on a Gtk.Entry. Stealing heavily from a little-known F-Spot widget, I concocted a simple tagbar. Tab cycles through the completions and Enter selects. To give a rough idea of whats going on I made a quick screencast.
Let me know what you all think, if this is what we want to base our work on, then I’ll clear out the almost 500 lines of commented code from our past revisions. If we need to try something new, we can do that to.
Alright! Some cool news! The Mono Hackfest at the Novell OSTC in Provo, Utah was a success ( I would say, people showed up and we talked about features 
) And while I took several photos in the hope that I might have another photo-riffic blog post, but alas, my flash wasn’t on, and they are all pretty much worthless. That aside, it was pretty cool to root around more of the Novell OSTC campus.
As a by-product of the ‘Hack’ing portion of the hackfest, I am happy to report the enabling of tagging in Tomboy, while we are still working out the specifics of the tagging interface, a super-experimental version of our newest iteration (based somewhat strongly on the Blogger.com tagging interface which we all agreed was somewhat well designed). While this is mostly implemented, there are a few issues (mostly based on my lack of Gtk knowledge/experience) with some of the autocomplete logic. I basically created a new Gtk Window which is composed of a ListView and hovers over the entry area (actually a GtkTextView, as a GtkEntry wouldn’t handle text markup). There are 2 real problems at the moment.
- I need to handle keyboard input intelligently enough to allow selection of an autocomplete option, I just need someone more familiar with how keypress events are handled to take a look at my code and figure out what widgets I should listen to the keypress events on etc.
- I need to get the autocomplete popup widget to show in the right place (should be easy enough to get, again I just need someone a little more familiar with the Gtk API so I don’t spend another hour looking for the window positioning information.) and the widget needs to close when a note is closed. (Right now the autocomplete box hangs around, should again just be subscribing to a window destroy event, but my previous attempts have resulted in some messes.)
Anyways, if anyone has the time to offer a hand/check any of this out, just drop by #tomboy (I’ll be in and out due to exams, but I’ll do my best to answer any questions) or feel free to just fix it right off the bat Here’s a quick and dirty screenshot of the problem as it exists (you can see the autocomplete dropdown isn’t quite right).
In addition to traditional tags, we have added a new little tidbit for Addin Developers, the concept of System Tags. In short, any tag added to a Tomboy note with the system: prefix will not be displayed. While this seems a little stupid at first glance, this allows us to easily implement things like Tasks, and allow Addins to associate their own data with tags while not implementing their own data store, and still maintaining backwards compatibility. For example if I wanted to implement ‘Contacts’ in Tomboy (NOT A FEATURE THAT SHOULD BE IMPLEMENTED IMHO) I could simply add the following tags to store all the information I needed for my Addin:
- system:Contact
- system:FirstName:Kevin
- system:LastName:Kubasik
- system:EMail:KevinAtKubasikDotNet
And so on, anything with the ’system:’ prefix will be hidden from the user, but still stored with each note.
Well be hacking it up tonight at 6:00PM MST at the Novell Open Source Technology Center. The rough TODO for the night seems to be Tags, Tasks and maybe even a backend to query Beagle. ;) Anyways, if your in the greater Salt Lake City area, come on down! If your a little further away but want to join in anyways, join in on #tomboy!
See you tonight!
Ok, so some of you may have noticed I’ve been a little quiet lately, over this time of non-blogging I built up a dozen great ideas for entries, and collected the photos to flesh them out. However, I am far to lazy, so you all get this little summary post instead. Let me apologize upfront, these were all taken with a cruddy phone. I’ll have another post with my technical musings later this week.
- Who knew Utah was so cool! After attending the Ubuntu-Utah group meeting, I was floored at how active the area was! Not only was the user group active, social and plenty fun, but I quickly learned about the Utah Open Source Foundation, which is (for lack of something more elegant) just plain awesome, the guys that run it could not be doing a better job. It was at a Multi-Distro Release Party (graciously hosted by Novell at their Open Source Technologies Center) that I caught this amusing moment, after Ubuntu is Linux for Human Beings, there aren’t age limits
- Some (hopefully legal) shots of the Novell Provo campus, its quite nice:
- Another fun tidbit about Salt Lake City, they have not only the best burrito joint on earth, but random neon orange flags at street crossings…
So, I’ve heard a lot of hype about the upcoming 1.2.6 release of Mono being faster, leaner, and more stable then ever before (due largely to Novell’s acquisition of a QA team dedicated to Mono). Beagle has always gotten flack over memory use, and as a result, we are relentless in our hunt for abused memory. And while it is wonderfully satisfying to reduce memory usage, its really hard to beat dropping megabytes of resident memory for free :). I’m running Ubuntu Gutsy and its 1.2.4 release of Mono, but in my quest for some real numbers to back up all this talk I built the current SVN trunk of Mono.
Even my most optimistic expectations put our potential benefit around maybe 2 or 3 MB resident less than beagle running under Mono 1.2.4. On my test setup, Beagle 0.3pre consumed (after my recent Opera backend fix) around 110 MB of VM and 36 MB of RSS (averaged over a 2 hour run).After building and installing Mono 1.2.6, the same 2 hour run was averaging 72 MB of VM and 27 MB of RSS! Its still far from perfect, but free memory reduction is just plain cool :).
Some observations about the general pattern of allocation and collection under 1.2.6, it ‘idles’ much lower than 1.2.4. While some actions always push the memory usage up, 1.2.6 *appeared* to return to its lower memory point much faster, and more regularly.
Anyways, I just wanted to say, props to everyone on the Mono team for rocking my socks.
Recent Comments