Before I made the switch to linux, my only computer was a single macbook. Great machine, and in addition to not being able to (really) use Awesome, I was pretty frustrated by the lack of screen space. I was (and do) need to filter through lots of different kinds of documents and I felt like I was spending half my time sorting through any of the several dozen (!) windows that I kept open. As a result one of my chief requirements for the new system was having the ability to run a 2 monitor (dual head) setup.[^DH] I was even willing to sacrifice¹ some raw power for this.

So here I was with a dual head setup, and a sort of lackluster idea of how to use all this new space, aside from the visceral knowledge that needed more room. I’ve tried a few things to try and use the space, but I continue to feel as if I haven’t found the right way to use this space.

I should preface this by saying a word about my window management software: it revolves around the notion of “tags,” which are similar to virtual desktops, so while I only look at 1-5 windows on each monitor there are many more than 5 windows open and running at anyone time.

My first attempt was to create task-centric virtual desktops, so that there were tags for windows that had to do with work, tags that had to do with fiction writing, tags for browsing the web, tags for chatting, tags for interacting with the system and so forth. This was an epic failure, as the joys of a multi-tasking operating system are that they allow you to have a number of different processes running in parallel, and if you have you window manager setup to constrain your to one task per screen then you’ve basically shackled your computer into only being able to do two things at once. Which is both distracting (as you end up hiding needed windows, or disregarding the established tagging systems. I also found that in an attempt to use both windows, I ended up using the middle half of each monitor more than I used the outer half.

My second attempt was to have a primary/secondary monitor setup, with my keyboard in front of the left screen which had most “action” related tasks (writing, email, etc.) and the right screen was for reference materials (web, chat, pdfs, etc,) and I’ve tried both organizing tags based on task/sphere, and also based on window type (so that “work” happened in more ad-hoc spaces). Neither works particularly well.

My current attempt is still largely based on the main/reference mode of operation, except I’ve made things a bunch less rigid, and mixed things up a bit to see if this makes things a bit easier to work with. I have background processes on the left monitors: email, web, file management on the left; org-mode files, and chat on the right. And then, I have writing spaces and adhoc workspaces on the left, with work and some project-specific workspaces on the right.

I’m not sure that this is the best thing. There’s a dynamic workspace/window tagging library, but I haven’t really tried it out, and I want to test things out on the laptop (one screen) first.

There’s got to be a better way of doing this. On one level this is a problem of riches, (how do I use all this space I have), but on another it’s a much more simple problem that addresses focus and the way that we present/organize information on our screens Thoughts?

Onward and Upward?

The last time I talked about org-mode, I covered a number of my “beginner mistakes,", this time I think it’d be a bit more productive to explain how I’m actually using org-mode. For those of you playing at home this is one of those systems I talked about.

I’m going to try and avoid including bits of code/lisp in this post, as I don’t want to confuse “what I’m doing,” with “how I’m doing it.” We’ll get to that point in time, and there’s plenty to talk about.

At the moment the features of org-mode that I use the most are:

• org-agenda-mode
• checkboxes
• org-remember-mode
• and org-mode outlines

I also store org-mode files in a git repository that lives in my home folder of all machines that I use with any regularity. I’m running emacs-23 (ubuntu package: emacs-snapshot), generally in server-mode, with two frames open, one has “the thing I’m writing” and the other has the org-mode-agenda and some org-mode file in the other window.¹

System Layout

At the moment I have 9 org-mode files:

1. A file the novel project, that contains background notes, and outline of the story, as well as project management stuff.

2. A file that contains notes for blog posts. This is mostly organizational, and I just add ideas as I have them and check them off and archive them when I’m done.

3. A general “codex” file, that I dump links. I’ve had a file like this for a number of years, and I generally find that having a catchall like this is productive.

4. A general fiction file, for project management issues related to the fiction projects that aren’t the novel. I’ll probably split this up as needed in the future.

5. I have two files to manage web development/design projects that I’m working on for myself.

6. One file to manage my academic/research project. Includes notes/content as well as todo items.

7. A “technology” file that contains lists of tweaks and other technological projects that I need to undertake (like switching to OpenDNS).

8. A file for work projects and notes
9. A journal file, for tracking activities and accomplishments.

Org-Mode Features

The features that I use:

Outlines and Checkboxes

This is a no brainier, but it makes sense. Org-mode is at it’s core an outlining program, but I think it is important to underscore this. It’s an outlining program. use it to create outlines. All of the talk and videos that I’ve seen explaining and demonstrating org-mode talk about the cool agenda functionality, or the table feature (which are great tools) but this washes over the fact that it’s an outlining program.

Why am I stressing this? Because the agenda commands and all the other functionality actually works better when you have a bunch of files with outlines in them. When you have outlines to deal with, you can tag the items that are truly “actionable” with “TODO” (or other action words) and include them with your agenda items. Or if an item/heading on your outline is time sensitive you can use the org calendar system to toggle deadlines/schedule points. And lists below headings can have checkboxes, which is a great boon, as well. But, if you work backwards and attempt to anticipate what agenda is going to do, then you’re loosing some of it’s functionality.

Brainstorm. Write notes. Add TODO flags to items that require attention. Add deadlines or schedule points if they’re time sensitive. But don’t organize the outlines for anything other than their utility as a reference document. Org-mode does the rest with….

Agenda

The org-agenda mode is the glue that makes the whole system work, as it aggregates items together from all your org-mode files. I’ve set mine up so that it displays a weekly agenda with all open TODO items. This way I can see everything that needs action, without needing to add deadlines to tasks which didn’t have deadlines so much as “don’t forget me” status.”

There’s all sorts of stuff that one can do with Agenda to generate views that filter based on tags or some such, but I’ve not gotten there. It’s really flexible.

Remember

Remember is a feature that originated independently, but has been enhanced to work with org-mode. Basically you trigger it with a key-binding and it pops up a temporary window which allows you to select a template and then add notes and other items, trigger save, and it disappears and writes to the relevant org-mode file.

One of the great pains of digital systems for note taking and organization is that if you have an idea, it is often hard for us to find a way to record these notes quickly before the moment leaves us. Remember changes that, and it’s great.

Next time? Code. Cheers!

I’ve not posted very much about the cats in a week, and I want to remedy this. As you probably know I got two kittens at the end of May. I’d been vaguely looking for cats for a while, what with “reality” setting in around me. A friend adopted a cat who had a litter of kittens somewhat unexpectedly, and I said that I would take one. Well turns out that there was a remaining kitten that had been unclaimed, and my family has generally enjoyed getting kittens in sets before. So it wasn’t a hard sell.

These cats have been something of a journey. We spent the second night that we had them at the emergency vet because Merlin was lethargic and crying a lot. This was bad. Turns out the poor thing was constipated and had a slight fever and maybe a little dehydrated. So the vet gave him a little bit of fluids and I talked them into giving us syringes so that we could shoot water into his mouth. Turns out he hadn’t really grasped drinking. In the subsequent months we have noticed a general unburdened intelligence in this animal, despite his very pleasant demeanor.

The pecking order of the cats has been pretty fun to observe. It seems that Kip, the shrimper kitten has sort of established himself at the top. This happened with the last kittens too. Very strange, though last time, the alpha kitten was also the most personable. While Kip is friendly and relaxed, Merlin is clearly the more affectionate cat. Merlin’s response to being picked up or held is basically to go completely limp. Which makes carrying him around interesting. He’s a bit bigger, but feels much more heavy as he makes himself all dead weight.

They’re now 9-10 months old, so we think that they’re mostly done growing. Merlin is 13-14 pounds, and Kip is probably 10ish pounds. The other large cat in the house--Nash--is 20 pounds. We were, for a while, concerned that we were going to end up with another couple 20ish pound cats. Which isn’t a bad thing, so much as an overwhelming thing.

I’ve never really had a cat that is as well adjusted as these. All previous cats have been shelter cats, because that’s just been what makes sense. And since these were from a friend’s cat, and she let them stay for as long as they needed to. They’re very well adjusted, and very affectionate, and nothing really bothers them, which is nice. We’ve had a lot of neurotic cats over the years.

While I really enjoy having kittens around, there is a point where the constant playing and activity can be tiring. I look forward to the day when I can wear headphones in the house without risking that the cats will chew them to shreds, and the day that sight of my toes underneath the covers doesn’t raise the “attack,” instinct. I mean, for now it’s great, but I enjoy headphones and my toes.

The only other thing of note is the fetching thing. Merlin first, and Kip to a lesser degree, adore playing fetch. Merlin will find some toy, carry it to you in his mouth drop it and then bat toward you. And then he sits and watches you until you throw it, at which point he’ll tare after it, play with it for a moment and then bring it back. Repeat. Repeat. Repeat.

This is cute, and a fun trick, it is however, a bit of the problem when I’m on the phone with coworkers and clients.

But that goes with the territory. And it’s good territory after all.

Onward and Upward!

I’m a big fan of outlines. I wrote this post about tightening outlines about my approach to making outlines better that I’ve been using most recently. This post, in turn is more about execution.

The issue, that I think causes a lot of people to be less into outlines, is the fact that outlines sort of dreary to write from. Which is to say, that the cool thing about writing (for me at least) is the feeling I get when I immerse myself in a world and characters' and I’m able to record the feeling of that experience. When it works that’s really satisfying, and while I don’t think it’s required for “being a writer,” it is certainly nice when it happens.

I suspect I’m not alone in finding this aspect of writing to be pleasurable and the thing about it is, of course, that it’s hard to both “slipstream” into the writing world and also follow your outline. The end result is that while I’m pretty rigorous about creating my outlines I’m not particularly rigorous about following my outlines.

This isn’t, as far as I’m concerned, a bad thing. For a couple of reasons.

1. The act of creating an outline is useful onto itself. It walks you through the story once so you know what’s going on, and you can figure out or avoid writing yourself into corners. Also the more familiar you are with the whole story when you start writing at the beginning, the less likely you are to have a story that takes a few chapters to “get off the ground.”

2. If you review your outline sporadically while you’re writing, you’ll probably be able to recall the important memories of “what you were thinking when you wrote that part of the outline, and then and be able to get to that part of the story, and write from there. You needed follow what you said in the outline very closely--lots of great ideas come up when you write, but having a road map makes it harder to get lost.

Ok, that’s what I keep telling myself. The truth is that I’ve been toiling in chapters 4 and 5 of this novel for a few weeks now, and my outline isn’t doing me a lot of good. And at least on number two above, I’ve not been very good at keeping up with my outline.

I’m not even sure how to articulate my issue with the story at this point. Part of the issue, is that I juggled some scenes around in chapter three that required pushing a few other things back, and having been thrown off the rails, it’s hard to figure out the pacing of what I’m trying to do right now. I think that gets it pretty closely.

So I’m going to spend some time this week, taking a bit of a breather from working on the actual text, and working on doing a little more outlining, and work on other projects, so I feel a little bit less like I’m grasping around in the dark.

Because I’m nothing if not reasonable.

Onward and Upward!

Systems. This is an extension of exploratory writings about information management, and related ideas. When I talk about “systems,” I mean whatever technological or intellectual methods we use to store information and get work done. If you use Microsoft Outlook and Word with an Access database for citation management, that’s a system, what I’ve hacked together for myself with git, BibTeX, emacs, LaTeX, org-mode, and Markdown is a system. There are others.

Many are pretty bad, as computer tools are designed with a task in mind, and the truth of the matter is that what most of us need isn’t exactly what they do. With a few exceptions. Like a lot of people use Excel but most of us use to make lists of tabular data, but few of us use it to store numbers, let alone do any sort of calculations with that data.¹ And lets not get started talking about Microsoft Word² or any of the myriad of task management organizational software packages.

So when I say “the system” I’m really talking about that magic step between the world your trying to represent in some sort of software application. And we all do some crazy stuff here, like scheduling appointments to manage tasks, or using a system of filters and secret email addresses to take notes. Not that I’ve done either of those things. Ahem

This set of practices and informal logical rules are interesting, not intrinsically but insofar as they are at the heart of the human-computer (cyborg?) interaction. While this isn’t specifically a problem of open source/free software/hacking, thinking about cyborg-issues dovetail with the software-freedom ethic of knowing your technology: so it makes sense.

Playing around with different systems, is one of those things I do, and have done for a while, but it’s something that I try to avoid. Because it takes a lot of time, it gets in the way of getting things done, and while I derive some perverse pleasure in it, I like to keep from being quite so meta. But the sad truth is that as we learn about new tools, as technology develops, as our projects develop, as we learn more about ourselves and our work-flows systems need to change.

Sometimes this is as simple as moving some files around (changing the informal logic) or getting a new system and importing data. Sometimes it’s more intense.

My blogging about org-mode recently, is as part of one of these system changes. I’d been using a private wiki for most of the last year, and while I really liked the system, it got to be non-trivial to adapt he system (my internal representation the organization of the files) to add content to the wiki in a way that made sense. Maybe other people are a bit better at this than I am, but after many weeks of just not touching the files, I realized that I needed a better system. So I’m trying something else. It’s a good thing. Not to happen casually, though. The good thing that happens when you do a “system review,” is you get a chance to clear out cruft bad or antiquated logic from your system, and that’s almost always a good thing.

I’ll be in touch.

My post about information buckets got me thinking, thanks to some other things that have filtered through my awareness in the last few weeks, about integrated development environments.

See, a couple years ago, I used everything buckets like mad, they were the application of the future, the software that seemed to just scratch every itch. I don’t know that I used them as general databases for everything but I did all of my writing and research-related tasks in them, and it was great.

The articles I read where there, along with the notes that I made, along with citation information, along with the final paper. Along with all of my previous papers and articles. I never had to go look for things again, it was all there.

This is similar to an IDE, or integrated development environment, which is a class of applications that have some measure of popularity amongst computer programmers. IDE’s generally (and I’m not clear on this, as I’ve never used one) provide tools for managing large projects and integrate with code-compilers, debugging tools, version control tools, multi-file project managers, and code browsers which allow you to find related parts of code across an entire project without scrolling through a lot of files. I think there’s probably some debate on weather these are good things for programmers (objections would include that they make for lazy/poor practices, and that IDE components do lots of things poorly) but generally I suspect they are good things. And as it turns out most of our beloved text-editors have a lot of IDE-like functionality anyway.

In a way, the information bucket provides an IDE-like environment for the information worker or writer. And that’s sort of a cool way of looking at this. Indeed, I think writers need better integrated environments, there are a lot of tools that I think we could benefit from. While I’ve been working on these posts, I’ve also been working on posts about the emacs org-mode, and while they’re ultimately not directly connected, I think something like org-mode is a great boon to writers and information workers. Integrated systems that manage citations, references, and notes are essential, as well as other helpful features that might include managing output, structure, and version control.

I hack most of these features together in emacs with some help from LaTeX, git, and BibTeX, but I recognize that this isn’t ideal or for everyone. There are other applications that aren’t “information buckets,” but provide writing environments that aren’t hacked from programing tools (emacs) or desktop publishing tools (MS Word). For example: Scrivener that provides a clever way to write longer form documents with structure, and Celtex that provides all sorts of screenplay writing tools (outlines, storyboards, character databases) and script management tools. Celtex even calls itself an “Integrated Media Pre-production” tool.

I’m not sure that these are the ideal tools for this task. Any of them. I’m partial to my solution, but I end up having to do a lot of informal organization to make it all stick together. So I wonder, what kind of software do other writers to keep all their ducks in a row?

More later. Of course.

It takes me a while to adapt to new things with the computer. While I pick things up pretty quickly, I’m aware that it takes a while for me to adapt to new ways of working with the computer. I like to settle into a system before I start changing the key bindings or writing scripts (which I always think will be more successful than they are). This seems reasonable, and is generally something that I’d recommend to other people looking to learn “cool new stuff.” Go slow.

In light of this realization this post will be a review of some of my more recent adventures with org-mode. For the uninitiated, org-mode is really a subsystem of the emacs text editor.¹ It’s really powerful, and has a lot of disparate features that combine to do something really kind of magical. On one level, org-mode is just an outlining program: it provides some shortcuts and interfaces that make writing structured text really productive and pleasurable (e.g. easy navigation, block folding). On another level, org-mode is a fully featured calendaring and task/project management tool. The brilliance, is that it isn’t just and outliner or a task manager, but it provides accessory tools (like a great calendar, and even a table/spreadsheet functionality) that integrate the environment.

I found about this two months ago, and I’ve slowly started to ease into using it. This past week, however, I think I crossed some sort of boundary, because I started using org-mode for most of my note-taking and project planning/organization work. And now that I’m here, I think a small series of blog posts is in order.

I’ll start, I think with “mistakes I made,” as I couldn’t hope to explain everything the system does, and explaining how I’m working right now isn’t nearly as interesting.

My first approach was to keep an org-mode file in all of my project directories, so that the .org file would be close to the files where the actual work was going on.

Wrong.

Turns out, keeping all your org-mode files together seems to work a lot better. Org’s calendar/project planning features work by generating “agenda views” of todo items and time-specified events. While the system could pull from a half dozen different project directories. Keeping things centralized means that you can add new files willy-nilly, it makes it easy to keep things synchronized between machines.

My second approach was to keep one org-mode file and divide projects using the hierarchical nature of the file to keep things straight.

Wrong.

Turns out, that while we can represent all of our projects hierarchically² beyond a certain level it doesn’t make a lot of sense to implement “categories” or project headings in this way. Org-mode provides a tagging infrastructure and the aforementioned agenda tool to tie together files, so while you can go overboard in creating new org files, you’re probably not incredibly likely to for a while. Use outline hierarchies to represent information, use files and tags to categorize and sort your headlines.

When I discovered the agenda capabilities, I made todo items out everything and started giving all of my tasks dates so that they’d be sorted into the agenda view.

Wrong.

Turns out, you can get agenda to generate a list of undated todo items before the agenda view, and that--at least for the way I work--setting soft deadlines and scheduling tasks just confuses the point rather than facilitating action. Org-mode also has a system for task priorities--which I haven’t felt the need for--but I think the larger lesson here is don’t attach arbitrary information to items in your org-mode files. Let the agenda mode do it’s work, and you do yours, and it’ll work out.

I started my ~/org/ directory³ by creating .org files for all of the major projects in my life. Fiction writing, day-job, the blog, academic work, so that I’d be able to collect similar kinds of notes and todo-lists together in files.

Wrong.

Turns out, that while some of the setting up big sphere-based org-mode files is unavoidable, the truth is that given the power of the agenda filter, putting a lot of information that is only casually connected in the same file doesn’t make much sense when tagging can provide needed meta-data. There’s a happy medium between “dividing things too much to the point where there’s too much ‘system’ to manage,” and “not dividing enough so that you have to build informal systems in the outline which complicates the organization.” In my experience “too much division” is much harder to reach, and “not dividing enough,” is quite easy.

I’ll be blogging more about org-mode in the coming days and weeks. Stay tuned :)

Onward and Upward!

Alex wrote this article about “everything buckets” that got me thinking. And you know how dangerous this can be.

I’ve been thinking about “everything buckets,” as “information buckets,” and I think this term is a little more apt, given how these systems work. Basically the “everything” bucket, is a program that provides a database interface on top of our files in the effort of keeping us better organized. Features common to the information bucket, genre of programs are meta data and tagging interfaces, easier/integrated editing environments, more advanced search abilities, and easier input features. All wrapped up in one nifty package.

Alex’s article makes a rather important critique of these programs, and one with which I mostly agree. He argues that the “buckets” themselves are non-free/closed source (bad for your data,) and that they abstract the organizational problems of organizing files rather than actually resolve those problems. Alex suggests that the best way to deal with this is to give up learn how to organize files on the file system itself and use better tools to store data.

Pragmatically I agree with him: I use structured formats to store most of my data, and have a simple but effective means for storing my data. It works, and I’m sure if you spend enough time talking about information management stuff with me, you’ll hear more than you ever wanted to know about how I store and use information.

But the “information bucket” approach has a lot going in it’s favor, and my approach isn’t a really broad solution. Here’s what’s good about this approach:

1. If you store your data in one bucket then there’s only one place that your data could be, which makes it much easier to find any given thing when you’re trying to look for something that you just know you saved somewhere.

2. If we’re left to our own devices to develop structured data a couple of things happen. First is that we don’t give it enough structure, so we end up with a few hundred files in a directory and no good way to make heads or tails of them. Then, to compensate for this, we create folders has a way of bookmarking specific bits of data, and end up with (potentially) too much structure that doesn’t convey productive information.

I agree that the OS X information bucket isn’t an ideal solution to this problem, but I think there is a substantive problem here that need some sort of unified solution. I’m not sure what that unified solution is, or even if there’s going to be a one-size-fits-all response for all users. But I think it’s a question that we need to begin to think about.