The second solution I turned to, and the one that I have been using and fine-tuning for the last eight months, was VoodooPad. Despite some unique drawbacks of its own, VoodooPad offers near-perfect synchronization, a daily log that far surpasses Together’s in usefulness, and the ability to append text to practically anything. The only downside is that VoodooPad is less flexible about what it can store (and how you can retrieve that info later) because everything is text-based whereas in Together you can toss whatever you want into your scratchpad, be it a PDF, image, bookmark, etc.

Components

To setup your own scratchpad using VoodooPad, you’ll need three things:

• VoodooPad 4.2+; the lite version just won’t cut the mustard, and as of 4.2 the Pro version is rather anachronistic
• LaunchBar, Quicksilver, FastScripts, or some other easy way to invoke Applescripts
• The Scratchpad Template (that’s a download link)

If you wish to synchronize your scratchpad between multiple computers, you’ll also need MobileMe or any other WebDAV-based server.

Installation instructions are included with the scratchpad template; the key thing to remember is that your scratchpad has to be open in VoodooPad and be the only document with the word “scratchpad” (case insensitive) somewhere in the document’s name or the Applescripts won’t work.

What it does

The scratchpad uses enriched plain text to accomplish its organizational goals. Similar to TaskPaper, all of the text you enter in the scratchpad is without formatting of any kind. However, thanks to VoodooPad’s automatic linking of terms associated with a document page the text is enriched with links that lead you to various useful, automatically generated pages. (It’s worth noting that VoodooPad does support rich text; the scratchpad defaults to plain text because plain text is more portable if you decide to change scratchpad solutions and is also easier to export for the web. You can definitely switch the scratchpad to rich text if you like, but it’s untested.)

The most basic idea for the scratchpad is the textual tag. A textual tag is nothing more than a VoodooPad link, but the page it links to is special: it automatically collects all of the lines in the document that contain the page’s title and displays them in a list. This is a handy way to gather data from across the document without needing to do any work on your part. For instance, I create a textual tag for every one of my clients, so that when I need to review all the daily log entries associated with them I just click the client name in a recent log entry and am instantly provided with every other log entry for that client. You could also use textual tags similar to the way TaskPaper does and organize tasks with them.

A handy way to automatically create textual tags is to use any word prefaced by an @ symbol when using the daily log or quick note Applescripts (for example, “@today”). These will automatically be converted to textual tags (if they don’t already exist) without any work on your part.

There are other special scratchpad pages, as well: any page (including auto-generated pages) can be designated an inbox, which allows you to append information to it using the quick note Applescript; you can create index pages for listing tag pages, logs, etc.; and composite pages gather the full contents of other pages and display them in a long list (useful if you want to view all of the daily logs for a given month, for instance).

These special pages are all created the same way: you just add a new page to the document like you normally would (typically by selecting some text and choosing Edit → Make Link), and then attach a special Voodoopad page tag to the page. A VoodooPad page tag, unlike a textual tag, is applied to an entire page using the VoodooPad palettes. You can feel free to use VoodooPad’s page tags however you wish as long as you only use reserved tags like “tag”, “inbox”, and “composite” to designate special scratchpad pages.

Once you’ve added one of the special page tags to a page, the auto-generation script will populate the page contents the next time you open it. There are also several meta keys you can use to customize what is displayed on a given page, the order of items, and so forth. Full documentation is available within the scratchpad itself.

How I use it

Unlike my Together scratchpad of yore with its handy shelf, I interact with my VoodooPad scratchpad almost exclusively through Applescripts invoked via LaunchBar. When I finish a task or have something else that I want to log as a timestamped note, I hit control-space to open LaunchBar, type “dl” (for Daily Log), hit space, type my log entry, and hit enter to save it. VoodooPad typically is running in the background, so the whole operation takes a few seconds at most.

If I find a link or something else I want to save, I copy it, invoke LaunchBar, type “QN” for Quick Note, hit space, and paste in the URL or type whatever note it is that I want to save. I then hit enter, choose from the list of inboxes that the Applescript provides me with, and when I’m on my personal computer I can then check those inboxes to see if there’s anything I need to process.

I rarely use the automatically generated textual tags (although I thought I would originally) because I much prefer the clean @-less textual tags that I create by hand (which additionally can include space characters and so forth).

Additional deliciousness

Though my main usage of my scratchpad has tended over time to focus a lot on daily logs and—to a lesser extent—noting URLs or things I want to think about/remember when not at work, you can easily use your scratchpad in more interesting ways. For instance, the web export system is setup to automatically generate a nice-looking version of the scratchpad, including well-formatted daily logs, with everything else formatted using Markdown if you want to share it with someone.

Setting up a TaskPaper-like task manager would not be particularly difficult, either, since you can specify tag pages to be inboxes as well as tags (useful if you want to track quick notes right alongside relevant daily log entries, for instance).

I’m sure folks will come up with their own unique usages, too; I’ve tried to keep things flexible and simple enough that it can appeal to numerous different workflows. The page auto-generation and web exporting is controlled by a pair of reasonably simple Python scripts and a page that controls the web export template, so those should be easy to modify or tweak if you so desire and are comfortable with Python.

Caveats and downsides

Overall, I’ve been extremely happy with my VoodooPad scratchpad. Certainly it isn’t as flexible as Together, but it’s also been far more stable. However, it is not without downsides:

• Because auto-generated pages are only refreshed when you open the page, things can quickly get out of date if you leave pages open. Currently the only way to update every page in the document is to do a web export.
• As your scratchpad grows larger, opening auto-generated pages will grow slower. Mine is eight months old with hundreds of pages and still moving pretty snappy, but the slowdown is inevitable thanks to the way that I have to parse through every page in order to autogenerate others.
• The Quick Note Applescript relies on your inbox index page being up-to-date; sadly there is no way to request all pages in a tag from VoodooPad via Applescript, so you’ll need to close and reopen your inbox index whenever you create a new inbox.
• The lack of easy-to-define smart pages or collections is also unfortunate, although I’ve found the meta-information based approach to work reasonably well for me.

Make it your own

I’m providing this template because I’ve found having a digital scratchpad that I can easily sync among multiple computers to be extremely handy. If you end up using it, I’d love to hear how you find it useful or limiting! I’ll definitely be updating the scripts and so forth as I continue to use and refine it myself, and I’ll share any significant improvements (updating will likely be a matter of copying and pasting a couple of pages into your personal scratchpad and maybe updating the Applescripts).

Good luck, and enjoy the scratchpad!

Resources for the scratchpad:

• VoodooPad
• The Scratchpad Template
• LaunchBar, Quicksilver, or FastScripts

The exciting part about OpenMeta is that developers finally have a standardized way to assign and read tags on files (other than the less-than-ideal Spotlight comment hack of yore) which has the potential to free users from getting tied down to a particular solution. Aside from Tags and Deep (the first of which is compatible with OpenMeta, the second of which was the first program to use it), MailTags is also in the process of joining the OpenMeta bandwagon (not available in public builds yet, unfortunately). Hopefully software like Together, EagleFiler, and others of that ilk will also begin to incorporate OpenMeta, allowing users to tag and find files across the system and their various tagging programs without needing to keep all of those programs running.

For the past few weeks I have been investigating software that might serve me as a scratchpad. Although I have not yet developed the perfect solution, I would like to share my first, somewhat flawed solution using Together from Reinvented Software. Together gets almost everything exactly right, but falls short for me thanks to the buggy and error-prone synchronization of MobileMe. Despite the shortcomings of its synchronization, however, setting up a scratchpad in Together is extremely easy and for people who don’t rely on synchronization (or perhaps just have better luck with MobileMe sync services than I) Together is an excellent choice for a scratchpad.

Update Sept. 2009: at long last I’ve published part two of this series describing my VoodooPad-based solution. Check it out!

Parts of the goal

When I set out to build myself a scratchpad I had two things I wanted:

1. Easy storage, synchronization, and retrieval of info
2. A daily log

The first is well covered by Together’s built-in tools for capturing files and so forth, complemented by some simple tag-based organizing and a couple of smart folders.

The second required a bit more custom work. The idea of keeping a daily log is one that I first discovered when Chris Bowler described his custom log file. Although his solution wasn’t really what I was looking for, the idea of keeping an easily updated, timestamped log of what I’ve done throughout the day grabbed my imagination. When I’m focused on a task, I rarely remember to switch to my time tracking software and enter details about what I’ve just completed, but adding a line of text to a daily log would be another matter since I could use my favorite tool LaunchBar to easily make a note without switching applications or getting out of the flow.

Setting up the scratchpad

To set up your scratchpad, you’ll first need to create a Together library for it (you could use your current library, of course, but you’ll have that much more data to sync). To add and manage libraries, choose Together → Library Manager. I named mine “Scratchpad”, but the name doesn’t really matter. If you’re going to be synching your library with MobileMe you may as well turn that on now.

You’ll have more luck with synching if you sync hourly (or less frequently). You can change how often MobileMe syncs in the System Preferences.

Aside from daily logs, whether your scratchpad is useful will rely on how you organize using groups and tags. Because I’m using two computers, one for work and one for personal use, what works for me is to start with two root level folders (I work for a company called Tierra Interactive; you could call the folder “Work” or the name of your employer just as easily):

As you can see in the screenshot, I’ve opened up the Group Info window (accessible by right-clicking a group and choosing Show Group Info or by choosing File → Show Group Info). One of the big reasons to have two root-level groups (aside from making it easy to focus in on those two areas) is that you can use them to automatically assign tags to any item that is added to that group using the Group Info window. This makes adding items to your library and being able to utilize intelligent smart groups much easier because you can either:

1. Add an item to the Personal folder when you import it to have it automatically show up in any smart groups targeting the “personal” tag.
2. Add it anywhere else, but manually assign the personal tag to make sure it shows up in smart groups targeting “personal”

This may seem redundant (in the first scenario, you’re effectively categorizing something “personal” twice), but consider the following: what if you find a link to a piece of software that you want to install on both your computers? If you found it at work, you may not have time to do it right then, so you’ll want to make sure it ends up in your work folder. However, you also want it in your personal action items. If you were relying solely on folder-based organization, you’d have to either duplicate the item or create an alias, both of which require more effort and thus make it less likely you’ll use the system at all.

Depending on how you use your scratchpad, having two folders (with tags available in case you decide to use smart groups in the future) may be enough. You could, if you desired, use the two folders to track items for work vs. personal, and once you’d dealt with an item either move it out of the folder and back into the library to archive it, or just delete it entirely. However, I wouldn’t be me if I didn’t suggest one further refinement: a simple system of tagging to make retrieving and acting on items even easier.

Taking action

When I was setting up my scratchpad, I realized that there are two basic types of items that I’m going to be storing:

1. Things I want to take action on
2. Things I want to remember

With this in mind, I decided to use a tagging system that allowed me to filter for action items and, if I needed, search for specific types of items using descriptive tags.

Although a simple “action” tag would work fine, I ended up using tags that look like this: “action: install”, “action: blog”, “action: evaluate”, etc. For some people, this may be needless complexity. For me, though, it provides a simple way to remind myself what I wanted to do with the item without needing to add a note or some other piece of metadata that would require something more than the Together shelf. Why did I bookmark that page? Oh, I wanted to blog about it.

Remember: the fewer tags you assign to an item, the more likely you’ll be able to maintain your tagging system. I generally only assign two or three tags to any given item: a descriptive tag or two and an optional action tag. (And Together automatically adds “personal” or “work”.)

For other items, I simply attach a descriptive tag to it: “password”, “big web client”, “idea”, etc. I’m not currently using any of these tags to filter my items, but simple descriptive tags will likely be useful down the road if I need to filter the increasing number of items in my scratchpad to, say, find all URLs pertaining to a specific client.

In order to be able to easily focus on my action items, I have two virtually identical smart views (only difference is filtering based on work vs. personal tags):

The first rule uses a feature of Together that I didn’t know about before I set out to create a scratchpad. In Together rules, you can use an asterisk as a wild-card, which came in real handy for my “action” tags. The other rules should be self-explanatory, although the label is new. The meaning a label assigns can usually be duplicated with a tag, but I often find labels useful for marking priority or status because they colorize items. I opted to archive items with a gray “Archived” label in order to visually separate out the items that I’ve acted on from the ones that await action when viewing either my folders or the root library group. An additional benefit of using a label to archive items is that I don’t have to lose information; if I deleted the “action” tag, then I would have to rely on memory to recall why I wanted that particular item in the scratchpad at all.

Once you’ve got your folders and smart groups set up, you’re ready to start using your scratchpad. However, if you want a daily log there’s a couple more steps.

Setting up a daily log

Personally, I prefer the idea of keeping a folder full of daily logs rather than just tossing everything into an ongoing text file (easier to append text files than parse them, if I need to switch down the road), so I wrote an Applescript that will look for a file named based on the current date, create it if it doesn’t exist, and then add a timestamped log entry. The Applescript actually doesn’t require Together, so if you feel like running a daily log without Together feel free to give it a look-see, as well.

Download Together Daily Log Applescripts

Whether you’re using Together or not, you’ll need to create the folder for the logs to live in before running the script. In the earlier screenshot of my folder structure you can see I have them living in “Tierra/Logs” in my Tierra library.

Once you’ve got the folders set up, open the Applescript in Script Editor (or the Quicksilver version, if you’re a Quicksilver user) and change the property declarations at the top of the file to point the script toward the right folder (see screenshot below). Once you’ve done that, save the script and you’re in business.

Assuming that you’re running Together, it should automatically import the log files when they are created (just make sure you have “Auto import files added to library folders” checked in the Import preferences). If automatic importing isn’t working, try relaunching Together and creating an empty text file using the Finder to kick-start Together (this worked for me, but if you’re having trouble please refer to the Together support).

Here’s my daily log workflow: I’m using LaunchBar and have it set to scan the scripts folder in my Library, so I put Daily Log.scpt here: ~/Library/Scripts/Applications/Together. To add an entry to the log, I invoke LaunchBar, type “dl”, hit space, type my log entry, and hit return. Easy, quick, and then a log of what I’ve been doing during the day is available when I need to fill out my timesheet.

I’ve been finding Together an excellent choice for a scratchpad that includes a daily log; hopefully you will find it just as convenient (or at least have found some food for thought in my approach to some simple tag-based organization).

Downsides

I’ve been using Together as my scratchpad for a couple of weeks, and overall have really loved it. As I mentioned above, MobileMe’s significant issues with keeping even a simple Together library in sync have convinced me that I need to look elsewhere for my perfect solution, but if the synching were consistent and painless I’d have no qualms using Together for the long haul.

That said, there are some potentially significant downsides to this system, particularly for people with an eye on their budgets. MobileMe is not a cheap service, and because it’s the only way to sync Together it’s definitely necessary for anyone who’s interested in a scratchpad they can access from multiple computers. For an optimal workflow with the daily log you’ll also need LaunchBar or Quicksilver, and although Quicksilver is free, LaunchBar is far superior in my experience (and has the additional benefit of not having been abandoned by its developer).

It’s worth mentioning, too, that a computerized scratchpad like the one I’ve outlined here is completely worthless for some folks. Unless you’re on your computer for most of the day, you’ll likely find a pad of paper and pen far more useful.

Other options

Although Together was one of my first picks for scratchpad software, I did investigate other options. Evernote as an idea was extremely appealing, but in execution the service only seems worth using if you’re on the road a lot and need to store info (particularly images) via your cell phone. The desktop Evernote program is simply too clunky for someone who is always at the computer like myself, particularly given the existence of several excellent file libraries.

I also considered just using plain text files and making a daily log that could double as a scratchpad, a la Chris Bowler’s solution, but I wanted a simple organizational method (in this case using tags), which was not possible with plain text. Tossing URLs that I want to visit into my daily logs would just be throwing them into a black hole; I doubt I’d bother to take the time to review them when I switched computers.

Together’s competitors, Yojimbo and EagleFiler, were worth consideration, but neither could handle the workflow that I desired (EagleFiler because of its lack of any kind of easy-to-use synching, and Yojimbo because it doesn’t offer any good way to append text to a file/library item so far as I could tell). For people who want a scratchpad for a single computer, however, EagleFiler might be worth a second glance (particularly if you own it and don’t own Together).

Looking forward

As you may have figured out from my dissatisfaction with Together’s synching and the “part one” in the title, my quest for a scratchpad is not yet over. I’m currently in the early testing stages of an alternative solution using VoodooPad Pro 4 that has fantastic synching support but requires a bit more gruntwork on my part to get up and running. I’ll be sharing my second scratchpad solution once it’s finished, but in the meantime I hope that my work with Together will benefit some other folks who have been battling with the same mind-overflow issues that I’ve been facing.

Resources for the scratchpad:

• Together
• Download Daily Log Applescript
• LaunchBar or Quicksilver

This tells me my system was a good one. Aside from not needing to expand the tag cloud, most tasks I only need to assign 1-2 tags per task, and and tasks inherit one more based on which project I stick them into. My tag filter bar is clean, and small enough to be useful even in lists with lots of tasks. When I posted the list in the Things wiki I got some very positive feedback. But having used the list religiously for a couple months, I have realized something: about 80% of my tags are completely useless.

This is because, up until now, I haven’t brought myself to noticed the obvious:

Tags are only useful if you need to find something.

Of course, it’s hard to tell when you’re first starting to tag whether you’ll actually use those tags down the road to find items easier. That’s actually one of the benefits of tagging: whether or not you use them, they’re easy to add.

The tricky bit is striking a long-term balance: if you tag willy-nilly with the assumption that it’s better to have lots of tags that you might search for someday than to have a few that you’ll definitely search for, you’re very likely to stop tagging sooner rather than later. Tagging may takes very little time but it adds up, and feeling obligated to attach a bunch of tags that you know you’ll never use is a quick route to tagging disillusionment (oh, the horror!).

So what’s to be done? Something really simple: look backwards.

You won’t be able to do this until you’ve been using a tagging tool for a while and you certainly don’t need to do it often, but every once in a while when it comes time to tag something, take a quick break and consider the tags you were planning to use. Have you ever searched for them? Have you even searched for tags similar to them?

When I planned out my grand Things tagging system, I included a subset of tags that described the type of task. I’m a web designer most of the day, so these were tags like “markup”, “styling”, “coding”, “research”, etc. Although I’ve faithfully used these tags with every task I’ve entered, I have never once filtered my list of tasks for any of them.

If I hadn’t taken a moment to look backwards, I might never have noticed this and would have kept wasting my time tagging tasks with tags that aren’t actually relevant to the task’s completion.

Of course, this example isn’t useful in all situations. Particularly in public and collaborative tagging systems, using tags that you’ve never searched for and might never search for can help others. Sometimes it’s a good idea to tag descriptively without worrying about the utility of your tags. But especially if you find yourself using a piece of tagging software that you originally loved less and less often, take a look backwards and ponder whether some of your tagging habits are just cruft that’s weighing you down. When you begin to tag things out of habit and not because the tags are useful, it’s the beginning of the end.

For visitors from 43 Folders exploring Tagamac for the first time, welcome! you might want to check out Tagging best practices (the site’s most popular article to date), Easy choices (a short counterpoint to some of the thoughts from the 43 Folders article and my previous “The what” article), or the software reviews. There is also a list of the most popular articles in the archives.

This tendency also translates into my advice on tagging. When I came up with the idea of “the what“, it was because I had sat down and tried to think of the most efficient way to tag. The article didn’t come from a system; the system came from the article. But mine is not the only way.

Arnaud Leene notes that “the what” is a very formal way to tag. He’s right; identifying “the what” is a step-by-step process focused on consciously crafting a consistent tagging system. It’s not fun. It’s not flashy. It’s plodding and onerous. When I myself take the time to sit down and identify the attributes that I’m tagging, I feel like some sort of robot. Hello-I-am-tag-o-tron, well-oiled-machine.

I have to admit, though, that not everyone in this world is addicted to logic or methodically moving from point A to point B. In fact, I suspect that most people turn to tagging because they find it easier than using single folders or categories. When you’re tagging, you can just toss any jumble of words on something in the hope that it’ll make finding things easier in the future. Choosing a tag isn’t a life-or-death, here-or-there choice. It’s naming a possibility.

No matter how much you take my advice on finding “the what” (or anything else) to heart, when you’re tagging things in everyday life you should always remember that tagging is about making easy choices. If you find yourself freaking out about what tag to assign to your photo of Aunt Sally, then you may as well not be tagging because you’ll be wasting as much energy and time as if you had thrown the photo in a random folder and then had to search for it later. If you think about “the what” more than you tag, then that system isn’t working for you.

Whether you lean more towards sober planning or random free-loving tag-fests, if you’re able to find the method that makes assigning tags to an item nothing more than several easy choices, you’ll be reaping the benefits of tagging in no time.

Tagging guidelines

1. Tagging best practices
2. A singular question
3. Replacing spaces
4. More to life than tags
5. The what

Creating a consistent tagging system is like baking a perfect pie crust: it makes you salivate to think about, but some days it just doesn’t work out. Fortunately, consistent tagging (unlike a perfect pie crust) isn’t affected by humidity; all you need is some careful attention to detail. And perhaps the most important detail to keep in mind while you are tagging is “the what”.

Quite simply, the what is just your answer to a two-part question: what item and what attributes? Despite the simplicity of the question, knowing the what is a vital part of creating a consistent tagging system. You can take or leave my SLS guidelines, but if you really want consistency you’re going to have to ask yourself about attributes.

What item?

The first part of the what is usually pretty obvious: are you tagging photos, email, journal entries, characters in your novel, or something else entirely?

Obvious as it may be, deciding what items you are tagging can still require some thought. Although you can generally delineate items based on their file format, there are some exceptions to think about. For instance, JPEGs, PNGs, and GIFs are all images while Word, Pages, and RTF documents are all text documents. When answering “what item?” you’ll need to decide what items to group under a larger heading and which to separate out on their own.

Keep in mind that if you are grouping items you’ll want to use only the most generic groups. Thinking of Pages and Word documents as essays is not useful, even if you only ever write essays in Word and Pages. You may in the future write something in Word that is not an essay, and then your whole way of thinking about tags will get fouled up. When you aren’t using items inside specific programs or individual file formats, use the most general categories of items that you can.

If you’re having some trouble thinking of what items you’re tagging, here’s a list of common ones to get you started:

• Photos (or images) — JPEGs, PNGs, TIFFs, etc.
• Text documents — Word, Pages, RTF, etc.
• Bookmarks (or web pages)
• PDFs
• Email
• Other program-specific items

Once you know what items you are tagging, you can figure out what attributes to tag.

What attributes?

Knowing what attributes you are tagging is the heart of the what, and the key to crafting a consistent tagging system. Basically, you want to identify what you think of when you think of a given type of item. You can do this by looking at items that you have tagged in the past to see trends in what kinds of tags you’re using or by brainstorming out a list of an item’s attributes (or for best results do both).

For example, perhaps you tag text documents based on their status (unfinished, first draft, revised, etc.), their genre (nonfiction, fiction, poetry, etc.), and their type of writing (essay, short story, fragment, etc.). If so, then status, genre, and type of writing are the attributes that you are tagging, and you should try to use them for all text documents (to the extent that it makes sense).

The attributes that you’ll use will differ based on the type of item, so you’ll have to come up with a unique list for each item type. Make sure not to use any attributes that are already available in the item’s metadata (after all, there’s more to life than tags).

Once you have your list of attributes for each type of item, you’ll need to decide which attributes on the list are worth tagging. After all, if you think of a text document’s subject but are never going to search for text documents based on subject then there’s no reason to use a subject tag.

At last, though, you should have an idea of what attributes you want to tag for any given type of item, and then all that’s left is to consistently tag based on those attributes. This will help you in two ways: first, you don’t have to waste time and energy when you’re tagging new items trying to figure out what tags to use because you’ll know which attributes you should tag. Second, you’ll know what kind of tags to search or browse for to find different kinds of items. And perhaps best of all, you’ll have a set of general guidelines based on your unique way of thinking about tagged items that will stay consistent over time.

There will of course be cases where you’ll not use an attribute for an item or will use another attribute, but in general knowing the what will allow you to keep your tags much more consistent than if you were just throwing tags on items based on your feelings and thoughts of the moment.

Finding the what

There’s no one correct way to find the what. Some people may want to sit down before they start tagging at all and deliberately map out a list of attributes for each type of item they will tag. If you do this, you’ll likely have a very consistent and well thought out tagging system. However, you could also just keep the what in mind while you’re tagging and observe what attributes you tend to use. It’ll be sloppier, but you’ll still end up with a more consistent tagging system than you would otherwise.

One last thing to remember is that the what will change over time. New software will come out and you’ll think of new ways to organize items or begin to think about tagged items differently. Even if you take the deliberate road and create a list of attributes to tag, you’ll need to be flexible. Putting some effort into figuring out the what early on will certainly be worthwhile, but there is ultimately no fighting the vicissitudes of time and the human brain.

Tagging guidelines

1. Tagging best practices
2. A singular question
3. Replacing spaces
4. More to life than tags
5. The what

I’ve said it before and I’ll say it again: tags are an extremely flexible way to organize the mad rush of information that is your computer. As you no doubt have picked up (from the existence of this blog, if nothing else), I have a bit of a love affair with tags.

However, while tag-love is a special and beautiful thing, if you are going to create a really great tagging system one of the most important things you have to know is when not to tag.

Remembering that there’s more to life than tags is sometimes difficult, particularly if you’ve just discovered tags and had that little “ah-ha!” moment when you realized that folders are not the only way (if you haven’t had this moment, take it from me: it’s a good one). Many converts to tagging, in their zeal to jump into a new system of organization, forget a simple fact: tags are the least effective metadata you have available to use.

This is because most metadata comes in key / value pairs. The key is what the information is (for example, the date a document was created), and the value is the information specific to the item (for example, I have a text document on my computer that was created on Dec. 17, 2005). Key / value metadata is really useful, because you can search a specific key based on a specific value, so you know exactly what kind of items you should find. Custom searches can be targeted very effectively using key / value metadata.

Tags, unlike most metadata, are just a value. Unless you get tricky with your tagging, a tag contains no information about what it represents. If I tag a photo “paris” it could be the city or the celebrity, and until I’ve looked at each of the photos that my search turns up I won’t know.

Because searching through key / value metadata is far more effective than searching through tags, you need to make sure you know what kinds of metadata are already attached to the items you are tagging. Unless you’ve made a conscious effort not to duplicate information from key / value metadata in your tags, you may well discover that tagging and finding items is more of a head-ache than it’s worth.

There are several ways you can find out what metadata is attached to an item before you begin tagging. The Finder’s Get Info window is an excellent place to discover the basic, automatic information that gets attached to every file on your computer. You can also choose File→New Smart Folder in the Finder to see some of the information that you can easily search. Third party Spotlight extenders like FileSpot can help even more in this regard. In iPhoto, you can find the large amount of information automatically attached to photographs by selecting a photograph and choosing Photos→Get Info or hitting command-I. Most other programs that include tags have some sort of key / value metadata attached to items, as well. You just have to find it. (The shortcut command-I is fairly prevalent for getting such info; if you’re at a loss, just try it to see what happens.)

Once you’ve figured out what metadata is already attached to a type of item, then when you’re tagging those items you should make a conscious effort not to duplicate that metadata.

Tags are amazing and flexible, but unless you know when not to tag they will make your life needlessly complicated.

Defining tagging

1. The parts of tagging
2. Tag browsers
3. The realms of tagging

Tagging as a popular phenomenon was developed online, where many tagging systems feature tags created by the members of a site. Thanks to this phenomenon, a lot of the intellectual thought about tagging centers around “folksonomies” and other ideas of collaborative tagging.

However, there are actually three distinct realms of tagging, and each requires you think about tagging in a slightly different way: private, public, and collaborative.

All three realms are hopefully somewhat self-explanatory, but there are some interesting things to note about each.

Private

A private tagging system is one where a single individual tags items, searches for items, and browses for items. This is the single easiest type of tagging, because it requires the least thought. You can tag things the way you think about them without worrying how other people may think.

Private tagging systems are most often found in desktop software, but occasionally do make their way online. A lot of the early advice that I’ve published on Tagamac assumes that you are crafting a personal tagging system because of my early focus with Tagamac on desktop tagging.

Public

A public tagging system is created and maintained by a single individual, but other people can search and browse the tags. An excellent example is the tags on every Tagamac article: I’m in complete control of them, but they are intended for the benefit of other people.

Public tagging is trickier than private tagging because besides being consistent, you also have to consider how the other people will use tags when browsing and searching, and tag accordingly. For example, my advice to keep tags singular may not be a good idea in public tagging, where people tend to think of tags as categories rather than information attached to a specific item.

It’s worth noting that you may well make different choices when tagging if the other users are searching or browsing for tags. In a browsing system, you don’t have to worry quite as much at what might be the terms that come first to mind for your visitors, because they’ll have all the terms in front of them. If it is a searching system, though, you’ll have to keep the ways your visitors might be thinking firmly in the forefront of your mind.

Collaborative

In a collaborative tagging system every user tags items. This kind of system is fairly prevalent online. “Folksonomy” is often used to refer to collaborative tagging.

Collaborative tagging has a lot of strengths, but consistency is usually not one of them. Because everyone tags differently, tags can quickly become a giant mess. On the other hand, if the user base is large enough items tend to be tagged more thoroughly than in either a private or public system. Generally, if you are contributing to a collaborative tagging system (such as del.icio.us or Flickr) you should try to keep your personal tagging system consistent (to maintain your own sanity) and also try to consistently use the tagging conventions that have evolved in the tagging system you’re using.

Tagging guidelines

1. Tagging best practices
2. A singular question
3. Replacing spaces
4. More to life than tags
5. The what

Sadly, not all tagging software is coded equal. Sometimes tags are thrown in as just one more bell or whistle, intended to plump up a feature-set without being particularly useful. Other times developers don’t understand tags themselves and end up implementing them in a way that is not as friendly as it should be. Sometimes supporting spaces in tags causes other problems (such is the case when trying to roll your own tagging system using Spotlight comments).

In any case, you may well run across a piece of tagging software that does not allow you to use spaces in your tags, which can be a major pain in the nether regions. What you do about it is really up to you (although of course I have some suggestions), but when you decide remember the tagging mantra: consistency, consistency, consistency. Pick something and stick with it.

Developers disallow spaces in tags for any number of reasons. Some, such as the difficulties with Spotlight comments, are totally legit and you just have to work around them. Others, such as the idea that tags should only ever be a single word, merely show that they don’t really understand tagging (sometimes it is impossible to use a single word; for instance, when I’m using Cha-Ching to file my financial expenses, I need to tag some of them “one crayon” so I know it’s a One Crayon business expense; thankfully, Cha-Ching is friendly about spaces). In these cases, file those feature requests!

Whatever the reasons, we’re living in the present and not some perfect world of the future, so your best option is to use some character to substitute for a space.

I highly recommend the underscore. Underscores have been a standard space replacement online for quite some time; it looks kind of like a space, it’s about the same size as a space, and it doesn’t really have any other practical usage now that typewriters are out of fashion.

Other good options are the hyphen and the plus sign, but they are less desirable for two reasons: 1) they are more intrusive when it comes to reading the tag, and 2) they are sometimes used for more powerful searching. Of course, if the software developer disallowed spaces, then they may well not support AND/OR and NOT searching, but you never know what the future may hold.

Another option, of course, is to go wiki-style and use camel case (for example: “ShortStory”). I personally advise against this because it opens up an even nastier can of worms than normal in the lowercase/uppercase debate (do you capitalize the first word or not? What about for proper nouns?), but it is as always up to you.

If you are lucky, of course, the software will be friendly enough to substitute an underscore when you hit the spacebar (instead of completing the tag). But if not, go with the underscore anyway. It’s a winner.

I will try to get some software recommendations and reviews written in the near future, but it may be some time before I’m able to jump headfirst into real workflows. In the meantime, I’d like to offer some good resources elsewhere on the web that you can use to get your tagging system off the ground. Sadly, I haven’t been able to locate many good resources (which is a big reason I started Tagamac, actually), but at least there’s a few.

Probably your best bet when thinking about tagging is The Apple Blog’s wonderful, step-by-step overview of file system tagging using Quicksilver and Default Folder X. Here are the links to the complete five part series:

• Part One: Using Metadata Effectively
• Part Two: The Tools
• Part Three: Screencast
• Part Four: Answering Screencast Questions
• Part Five: Wrap Up

If you are interested in collaborative or public tagging (through services such as del.icio.us), then you may find Wired’s Tips from Top Taggers or TechSoup’s Thirteen Tips for Effective Tagging interesting.

I’ve found some other articles on tagging, but they tend to either focus on very limited tagging systems (such as those on a single website), or not provide much of use. If you know of any other great articles or websites that offer good tips on tagging, please let me know! I don’t want to leave anyone out in the cold while I’m working on my great crusade to create a full and complete tagging resource, but I certainly don’t have encyclopedic knowledge of everything that’s been written about tags.

To download the plugin and for more info, visit the UTW-RPC and AutoTag download page.

Tagging guidelines

1. Tagging best practices
2. A singular question
3. Replacing spaces
4. More to life than tags
5. The what

Since I published my advice on tagging best practices, the most common question I’ve received has been something along the lines of “why the heck would you use singular tags?” Everyone agrees that consistency is the name of the game, and it’s hard to argue with succinctness. Some people disagree with using lowercase tags, but quite honestly it’s mainly personal preference (unless the program uses case-sensitive searching).

Whether or not to use singular tags, though, is a much more open question, and I’d like to lay out the reasons that I included a recommendation to stick to singular.

First I should mention that I don’t think every tag should be singular; whether or not you use singular tags is highly situational. For instance, if you have a photograph with a group of people in it, then tagging it “person” is utterly ridiculous. When I advise using singular tags, my hope is that people will try to stick to singular tags only when appropriate. If singular tags are the baseline, then searching for “people” as opposed to “person” means you get two different sets of items rather than one set of items that includes both. (Of course it can work the other way if you use plural tags as your baseline, too. Whatever makes the most sense to you is what matters.)

Second, a major assumption that I held going into the best practices article was that you are tagging items in a desktop program for personal usage. In this case, there is no question over what you will search for because you have complete control over all three parts of tagging. However, if you are tagging items so that other people will find them (the case in most online tagging), you will need to think about tags differently. Sticking to plural tags may actually benefit you more for online tagging, because people tend to think of tags online as categories. Neglecting to mention that my SLS guidelines are most appropriate for personal use was an oversight of mine; there are large differences between personal, public, and collaborative tagging.

Ideally, of course, your tagging software would permit creating synonyms for tags. Unfortunately, we don’t live in an ideal world, and this is pretty rare (might even be non-existent; off the top of my head I can’t think of any software that supports tag synonyms).

At base, whether you tag by default with singular or plural really relies on how you think about tags: are you tagging what an item is or what an item is one of? In the first case, you should use singular as much as you can. In the second, you should stick to plural. For example, I could tag this article “clarification” because I am clarifying an earlier argument. Or I could decide that my “clarification” tag is more like a category; it contains multiple items, each of which is a clarification. In that case, I would tag this post “clarifications”.

I personally prefer to use singular tags as my default because I think of tags as terms that describe a specific item. For me, a tag says, “This item is a [blank]“. I am not sorting items into categories; rather I am attaching descriptive terms to items. The wonderful thing about tags, though, is that if thinking about tags like this makes no sense to you, you don’t have to follow my advise.

I knew when I included both lowercase and singular into my little “SLS” scheme that they were mostly reliant on individual preference. The reason that I included them, however, is because both the capitalization and plurality of your tags are things you must consider when you are building a tagging system. I don’t care whether you tag things the way I do; what I care about is that you think about the issue before you start tagging inconsistently and causing a lot of pain for yourself.

I hope this has helped to clarify my standpoint on the plurality of tags! If you have any thoughts on the matter, I would love to hear from you!

Defining tagging

1. The parts of tagging
2. Tag browsers
3. The realms of tagging

I like to think that tagging is straightforward. It may seem like a strange way to organize and find information at first, but once you get used to it the whole process is not that complicated.

However, even when a subject is not particularly complicated, it can still be difficult to talk about. I have found in my journey through life (and academia, which are not one and the same no matter what they tell you) that one of the most important parts of any discussion of a topic is solid definitions. As a result, I am going to try to break down using tags into simple definitions over the course of several articles. This article is the first, and defines the three actions that you will perform when working with tags:

Tagging: the act of attaching a tag to something. This is probably what you think of first when you think of tags. Tagging also refers to maintenance of your pool of tags; removing tags, renaming tags, organizing tags, adding new tags, etc. Tagging is the creative portion of using tags, because you have to think up which tags to use (also when you are thinking of using the SLS system or not).

Searching: the act of using tags to find specific targeted items. You could also call this “filtering” if you wanted. Searching is what you do when you know what you are trying to find, and you use tags to locate it. An example would be if I wanted to find that picture of my friend Suzy that I took in New York, and searched for items with the tags “suzy” and “new york”. Searching also covers using saved searches to sort and locate items.

Browsing: the act of using tags to find related items. Unlike searching, browsing doesn’t target any specific item or subset of items. Instead, when you browse tags you are usually looking for related items. For example, I might browse my “suzy” tag to see all pictures of Suzy. Closer to home, the tags attached to each article on Tagamac are best suited for browsing because while they do not supplement the search system (and are thus not very useful for locating specific articles), they do make it easy to find articles that are related.

Tagging guidelines

1. Tagging best practices
2. A singular question
3. Replacing spaces
4. More to life than tags
5. The what

In all honesty, best practices for tagging vary greatly depending on the type of tagging system and tag browser you are using. Additionally, because tags are so flexible, how you use them also relies a lot on what makes sense to you. There are still some things you should think about when you tag, though, and I think they’re important enough that I’m posting them now before I dive more in-depth into tags.

First off is tagging’s golden rule: be consistent. You can disregard every other piece of advice I give you, but consistency is the single thing you must strive for when tagging. Everything else is window dressing. That said, here are three things that I think almost every tag should be, regardless of what program or system you’re using: succinct, lowercase, and singular.

Succinct

Of the three, this is the one that is absolutely necessary. Tags must be short, simple, and memorable. Always pick a single word over a phrase. Pick a word that is the most descriptive you can think of, but is also one you will remember later. Never use a complicated word when a simple one will work.

A succinct tag is easier to remember when you are tagging later items or searching, quicker to comprehend when you’re scanning through tags, and improves your sex appeal.

Alright, so good tagging and sex appeal aren’t actually related; you get the point. Be succinct.

Lowercase

Keeping all of your tags lowercase is a really, really good idea, but you won’t be struck by lightning or anything if you capitalize them. The main reason to stick with lowercase is consistency. Not only are tags generally lowercase by convention (which means some programs may have difficulties with upper case letters in tags), but lowercase is a better default.

For one thing, if you keep all your tags lowercase, then it is impossible to have problems with a program mistakenly matching the case of a tag. For another, it is easier to maintain consistency if you always use lowercase letters. Capitalizing only proper nouns may work, but down the road you may change which words you capitalize or use capitalization inconsistently with some words. And hey, lowercase letters are just quicker to type.

You don’t have to keep everything lowercase, but I strongly recommend it (grammar-Nazi that I am, when I first started using tags I capitalized proper nouns; then I sat down and thought about it and realized I was being a bit silly).

Singular

Of my three best practice guidelines, this is the one that you’ll ignore the most. The reason that I include it at all is that you should only use plural tags when absolutely necessary. If you stick to singular words by default, then it reduces the questions you may have when searching your tags. “Did I tag that photo ‘people’ or ‘person’?” is a question that wastes your time and adds unnecessary difficulty to tagging.

By consciously making an effort to keep everything single, you will improve your ability to find exactly what you are looking for, which is what tags are all about. There are certainly times when you should use a plural tag; just make it count.

Consistency

At root having “SLS” tags is really all about consistency. By keeping your tags succinct, lowercase, and singular, you’ll be making it easier to search them and tag similar items consistently.

There is, however, a lot of variation in how to tag an item. Whether you use specific or general tags, more or fewer tags, and redundant or distinct tags has more to do with the software you are using than anything else. But that’s a topic for another time; for now, I hope you will find the idea of SLS tags useful!