Other Bookmark Systems

There are a number of different approaches to bookmarking in existence, which is itself a problem. All bookmarking schemes aim to do exactly the same thing: capture some basic information about online resources and then provide a mechanism to organize them for easy use.

The very fact that a simple operation like this has many competing implementations betrays a lack of clear thinking on the part of application developers. Bookmarks are relatively simple chunks of data and lend themselves to standardization. Below are some of the current approaches.

Browsers

Each browser implements their own method to capture bookmarks. What they all have in common, however, is the fact that the bookmarks themselves are buried within the browser application. They are not files or data owned by the user, they are extensions of the software. This means they are locked in to whatever browser the user is currently using – a limited and outmoded approach.

Although the mechanism for storing bookmarks vary quite a bit there is some common ground. Over time application developers have realized the benefit of allowing users to import entire bookmark collections from other browsers. Many modern browsers, therefore, offer an export function whereby their proprietary links collection is exported to some neutral format, often HTML – itself a display language, lacking the semantic detail needed in a system intended to capture what is essentially meta data.

Other browsers can then read this exported file. This typically involves programming the software to read another browser’s proprietary output. Naturally, imported bookmarks are nothing more than a static list; if a user wants to work with two or more browsers then the clunkiness of the import/export approach soon becomes obvious. They are bookmark collections frozen in time, and as you add new links they gradually move out of sync.

Similar to the export-then-import approach, some browsers will simply grab a bookmark collection straight from your default browser; often an option that is presented when you first install a new browser. This approach inherits many of the problems noted above, and, more annoyingly, often does a poor job or preserving the original hierarchy. The bookmarks are typically dumped into a sub folder, and can even lose the original running order or visual separators. Therefore, they fetch your original bookmarks in some sense, but they often fail to reproduce them faithfully.

Current browser implementations, then, are little more than a minor nod to the notion that a user may occasionally try a new browser, and that the process should be as rigid as possible, presumably in an attempt to discourage people from leaving a given system. This is old-fashioned to say the least, and it ignores a main plank of modern computing: that information, in whatever form, belongs to the user or owner of the system, not to the people who design software.

It clearly makes more sense to adopt a universal standard that any browser can read. This is more flexible for the end user as it allows them to try different browsers without having to worry about importing or exporting bookmarks. We wouldn’t expect a media player to convert our music files into a special format that is tied to the software because the music itself belongs to us and we expect the software to simply read it.

A universal system like UMarks has the supreme advantage of allowing anything to use the same set of bookmarks, and browser developers would be able to advertise the fact that, in time, users can coordinate a single UMarks file on their desktop computer using a variety of applications as well as other devices like mobile phones; a very strong selling point for internet software in an era of cloud computing.

Independent and online systems

Some independent systems do exist. These aim to free up bookmarks from computers and allow a single bookmark file to be stored centrally (usually online) so multiple browsers can sync from it. A typical example might be a user’s browser at work and at home pointing to the same file, and therefore ending up with the same set of bookmarks.

While these are a step in the right direction they still have a number of limitations. The most obvious is that they tend to be browser-specific; the systems are written to read from and write to a specific browser. This still ties the user to a limited choice of one browser only, and doesn’t acknowledge that bookmarks have to travel not only between different browsers on desktop computers, but should work on different devices too. As noted above, bookmarks capture simple chunks of text for the most part, and any modern system should aim to exploit this, freeing up the user to access their own bookmarks wherever they like.

Some systems have been adapted to work with multiple browsers, usually via plugin models that many modern browsers have adopted. The main barrier here is technical: non-technical users don’t really think in terms of plugins and add-ons to browsers, and the transparency needed to make bookmarks truly flexible is lost. This approach has limited impact because it is simply too clunky.

The most advanced systems seek to offset this complexity by providing a more complete service. Although users may have to download and install a bookmark syncing plugin, it is allied to an online service that invisibly handles the backups and sync for the user. These are another step in the right direction, offering a relatively simple method to backing up and syncing, despite the overhead of extra software.

Their weakness, however, is that they don’t solve the underlying problem that current bookmark systems have. They perpetuate the reliance on proprietary methods tied to individual applications. The service offered is relatively simple, but the user has little real control; it inevitably involves extra steps to make the same set of bookmarks work on many devices, for example. The real solution is of course to make the software do all the work, and for all the software to do the same thing. That is to say, all the software should support the same standard. Then it won’t matter what device or software the user has.

In addition, there are real privacy concerns with using off site services. Bookmarks can be highly personal, and certainly should be treated as personal data. The only sure method to ensure privacy is for the user to encrypt a bookmark file before it leaves their computer. This would then be inaccessible to anyone else, no matter where it is stored. Again the stress here should be on software invisibly handling the technical elements (encryption and syncing), with the user having little technical involvement except clicking ‘sync’.

Conclusion

What all of these approaches lack are the elements that are the guiding principles of UMarks, namely portability, simplicity and openness. Without these factors they are nothing more than an awkward extension of yet another system, whether it’s a browser or a specific bookmark application – the very problem that needs to be solved.