Unix and The Command Line

Beeswax: Free Productivity App in the Spirit of Lotus Agenda

Merlin — Sat, 28 Jun 2008 16:34:22 -0400

Wow, this looks like a really interesting project to watch — a GNU-licensed, command line productivity app that ﬁnds inspiration in a bona ﬁde classic:

Beeswax is an information management system inspired by Lotus Agenda. It aims to recreate Agenda’s ﬂexibility and efﬁciency in a clutter-free, text-based (ncursesw) user interface with vi key bindings. Beeswax views & reports will have speciﬁcations for sections, columns, ﬁltering, and sorting…

The relationships between items of information are highly ﬂexible. An item can be easily assigned to several different categories and the view immediately displays the new relationships. An item can just as easily be detached from categories. As you move items through Beeswax, their relationship to each other remains highly ﬂexible.

You still hear a lot of people saying Agenda is the closest they ever got to their dream productivity app. And, depending on who you ask, Agenda’s endless ﬂexibility was either incredibly powerful or inﬁnitely ﬁddly.

Beeswax is a very young application, but I’ll deﬁnitely be giving it a spin. There’s certainly a long-standing itch for Agenda that lot of folks would love to have scratched.

The Question to You

Any of the old hardcore Agenda folks tried out Beeswax yet?

[via Anarchaia]

”Beeswax: Free Productivity App in the Spirit of Lotus Agenda” was written by Merlin Mann for 43Folders.com and was originally posted on June 28, 2008. Except as noted, it's ©2009 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"

Michael Buffington: iGTD + Quicksilver + subversion

Merlin — Thu, 28 Jun 2007 07:00:53 -0400

by Michael Bufﬁngton

This is the second entry in a multipart series about my recent obsessive love affair with GTD, the iGTD application and Quicksilver.

In the last entry I put the emphasis on getting my tasks written down quickly and out of my focus into a system I could trust. I could choose to spend some time later to review my tasks and do what I like to call “iGTD gardening”, where I check up on all my projects and do a bit of weeding of duplicate or irrelevant tasks, and fortify those tasks with whatever information comes to mind as I’m looking at them.

Since I’m now in the habit of pushing new tasks to iGTD and immediately forgetting about them I have the refreshing ability to work on a task without ever thinking about anything else. iGTD then becomes my set of instructions to follow when I need guidance, and if I’ve tended my task garden well, it’s a rich set of instructions with a lot of tedious thinking already ﬁnished.

This system works out alarmingly well until you’re possessed by SSD (severe stupidity disorder) and delete your iGTD database without even a whiff of lingering vapors. Immediately you’ll be consumed by a profound and unshakable dread as you realize your tether has been severed from the mother ship and you begin to drift into outer space, your Tang to be divided up amongst your colleagues (even the ones you loathe).

Luckily for most of us, iGTD makes database backups upon starting up the iGTD app and for a couple of other events, and luckier still, most of us don’t suffer from SSD very often.

But I often do, and don’t leave anything to chance.

Rather than risk losing my entire brain to an episode of SSD I employ a SMP (scheme of massive paranoia). It might seem quite heavy handed, but I send a backup of my iGTD data to a subversion repository whenever the iGTD database changes. In a nutshell, it means I have a comprehensive history of every save ever done to my iGTD database, and am nearly assured that I’ll be able to save myself from myself with only the smallest amount of data loss.

Now I’ll be the ﬁrst to admit that what we’re about to look at is a bit Rube-Goldberg-esque, and I’ll admit there’s a certain joy in that as well.

A few things to know before we move on:

I’m doing this all on Tiger, which means I have both Ruby and sqlite3 installed out of the box.
Your paths to both Ruby and sqlite3 might differ from mine.
This code likely has bugs. I whipped it up in a few hours.

Also, worth noting - I’ll be adding to this body of code as I move on with more blog posts about iGTD. What may look a bit like an empty shell now will get some more meat as we go along.

And ﬁnally (I promise), all the code I talk about in this series will be downloadable at some point.

Create some Ruby!

Create a ﬁle called iGTD.rb in /usr/local/lib/ruby (or /opt/local/lib/ruby if you’re using the Macports version of Ruby like me).

Write the following code:

class IGtd

    def self.capture(string)

        i = IGtd.new

        i.push_to_igtd(string)

        puts string
 end

def push_to_igtd(string)    
    `/usr/local/bin/sendtoigtd "#{string}"`  
end


end

That’ll start off our iGtd library with something basic. It seems totally superﬂuous when you think about it, but remember, we’ll be adding to this at a later date.

The newest version of iGTD (v. 1.4.5) comes with a command line utility that allows you to pass your task along the same way you push tasks into iGTD through the Quicksilver plugin. The above code simply wraps some Ruby around that command, executing it when we call it, which we’ll come back to in a moment.

Now we’re going to take advantage of a Quicksilver feature that you might not see documented many places - you can pass text to Ruby scripts saved as action in ~/Library/Application Support/Quicksilver/Actions. Up until recently I assumed you could only have AppleScript actions, but that’s not the case.

Let’s see some of that Action in action. Create a ﬁle called gtd.rb in ~/Library/Application Support/Quicksilver/Actions that looks like this:



!/opt/local/bin/ruby

require 'iGTD'
IGtd.capture ARGV.join(" ")

This script takes whatever commands are passed in, joins them back up as a single string, and hands them to the IGtd.capture method we wrote above. Note that we join the string back up because Ruby splits up command line arguments into an array wherever it sees a space. So we simply reverse that process by adding the spaces back in.

Make sure you make the ﬁle executable. chmod ug+x gtd.rb should do the trick.

Once that’s saved you should be able to invoke Quicksilver, press period to invoke text mode, hit tab, then type gtd. Your gtd Ruby script should show up in the list (if it doesn’t you might need to restart Quicksilver [CTRL-CMD-Q]).

Now, despite the fact that you’re using your own Ruby based action instead of using the iGTD Quicksilver plugin, your task will end up in iGTD.

Neat, but we’re missing the paranoia. Let’s add subversion commits into the mix.

At this point I have to assume that you’ve managed to get your iGTD.sql ﬁle located at ~/Library/Application Support/iGTD into a subversion repository, hopefully offsite. I’m gambling on the fact that you have some knowledge of subversion if you have any desire to do this at all.

Because the iGTD.sql ﬁle is binary, we want to dump it as raw text to be a bit more efﬁcient with subversion. subversion only keeps track of differences between revisions with ASCII ﬁles, but keeps entire copies of binary ﬁles (which might not seem like much, but for a ﬁle that’s in the 60-80k range, 6000 changes can turn into a 500MB subversion repository).

Having the iGTD.sql as an ASCII dump helps increase portability as well. You can rely on simple text editors to see your data with an ASCII dump, and in the worst scenarios, viewing raw SQL statements can be quite comforting if the alternative is viewing nothing at all.

Let’s add the following method to our iGTD library (note that when you see a ↵ symbol that what should normally be on a single line is wrapping to ﬁt the page - make sure you ﬁx those lines if you’re copying and pasting):

class IGtd
    def self.capture(string)
        i = IGtd.new
        i.push_to_igtd(string)
        i.commit_to_svn
        puts string end

def push_to_igtd(string)    
    `/usr/local/bin/sendtoigtd "#{string}"`
end

def commit_to_svn
# tidy up some of the paths
igtd_data_path = "/Users/mike/Library/Application Support/iGTD"
svn_path = "/opt/local/bin"
sqlite_path = "/usr/bin"

# dump the sqlite db to an ascii backup file
`#{sqlite_path}/sqlite3 "#{igtd_data_path}/iGTD.sql" &crarr;
    .dump &gt; "#{igtd_data_path}/iGTD.sql.automatic.bak"`

# commit it to svn
commit_msg = `#{svn_path}/svn ci "#{igtd_data_path}/  &crarr;
  iGTD.sql.automatic.bak" -m "Automatic backup of  &crarr;
  iGTD.sql backup file done: #{Time.now}";`

# if no changes were made, svn won't output anything - it'd &crarr;
be nice to know that we at least tried.

if commit_msg == ""
  commit_msg = "Nothing to commit, therefore no svn commit was done."      
end

# now send the message to growl
`echo "#{commit_msg}" | /usr/local/bin/growlnotify`    
return commit_msg


end
end

Now, whenever you push tasks from Quicksilver to iGTD through our gtd.rb action, subversion will commit the changes. I’ve added the luxury of being notiﬁed by Growl when the commit happens. Pay special attention to the paths in the script and make sure you’re pointing to the proper places.

With this in place, not only are my backups effortless, but they’re comprehensive. And because my subversion repository is on a remote server, I can reconstruct my task list as long as I have a computer and an internet connection. Given enough time to think about it, I’d probably get paranoid about my subversion server keeling over too. Entertaining those thoughts to their ﬁnal conclusion would require I hire stone carvers and buy a large granite mountain to chisel my lists, so at this point I’m content with the offsite backup.

This extreme paranoia with an admittedly heavy handed solution helps increase my trust level with iGTD, but it also opens the door to doing other automatic tasks whenever I enter a task through my custom gtd.rb ﬁle.

In the next entry in this series I’ll show you how you can enter a task in iGTD once and have it travel to both Stikkit and Basecamp with a few additions to the iGTD Ruby library discussed here, and even grab new tasks from Stikkit.

Following that entry will be something I consider quite special - getting tasks into iGTD from your mobile phone through SMS. Assume the bullﬁghter’s stance and repeat after me: ¡muy emocionante!

About the Author

Michael Bufﬁngton - A serial entrepreneur and creative technological consultant, Bufﬁngton most recently served as the Community Advocate for Values of N, makers of Stikkit and iwantsandy.com. He’s now secretly building games for the masses.

”Michael Buffington: iGTD + Quicksilver + subversion” was written by Merlin Mann for 43Folders.com and was originally posted on June 28, 2007. Except as noted, it's ©2009 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"

Hand-picked, artisanal, remaindered links, 2007-06-04

Merlin — Sun, 03 Jun 2007 12:34:14 -0400

These are lower threshold links to stuff I’ve recently enjoyed.

The Macalope On MacBreak Weekly - “Yes, it’s true. The Macalope will be on next week’s edition of MacBreak Weekly.” The MBW crew seems to remain convinced that I am the Macalope. Tune in this week, and we shall see…
Daring Fireball: iPhone SDK, iPhone SDK! Wherefore Art Thou iPhone SDK? - Gruber’s analysis seems spot-on to me: with a product this big, it pays to manage expectations and hold out the possibility of an unpromised lagniappe or two.
How to talk to the press | fortuitous - Mathowie talkes to the press a good bit more than I do, so I learned a lot from this. Love the tip about listening for frenetic typing.
Jonathan Coulton » Blog Archive » How I Did It - JoCo tells the story of how he got where he is with his music and the internet. Essential reading for those who want to go indie on the web today. Would love to see more of these from other folks as well.
Rosetta Stone for Unix - (PDF) - Ginormous table that lets you compare commands between different ﬂavors of Unix. (via: adurity’s bookmarks on del.icio.us)
MailTags 2.0 leaves beta, goes ofﬁcial - The sine qua non Mail.app plugin goes 2.0. Can’t imagine using Mail without this guy plus Mail Act-On.
Twitter Blog: Are You Twittering @ Me? - “In other words, if somebody Twitters “@biz liking the new Replies tab!” it will get saved at Twitter.com/replies.” I love this feature. I can’t keep up with the (gulp) 2,300 folks who’ve been kind enough to “friend” me, but at least now I can see when they’re saying something in my direction. Very cool.
Facebook | Merlin Mann - In related news. I succumbed. Largely because of this awesomeness. (links require Facebook membership)

Submit your ideas for links to del.icio.us, and be sure to include the tag “for:43folders.”

”Hand-picked, artisanal, remaindered links, 2007-06-04” was written by Merlin Mann for 43Folders.com and was originally posted on June 03, 2007. Except as noted, it's ©2009 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"

Vi commands in all your Cocoa apps

Merlin — Mon, 05 Feb 2007 04:50:59 -0500

Jason Corso - Vi Input Manager Plugin

Vi Input Manager seems like a godsend for Mac (or more accurately, Cocoa) users who have Vi commands permanently installed in their ﬁngertips.

This bundle patches the Cocoa Text System to add a Vi-like command mode. After entering command-mode (typically, by hitting escape in Vi), ordinary Vi commands can be typed and the text ﬁeld will be updated accordingly…

Right now, you should be thinking – “you mean the editor in XCode will behave like Vi?” Answer: Yes.

Reminds me it’s about time for another round of trying to learn Vim.

[ via: Vi Input Manager - The Unofﬁcial Apple Weblog (TUAW) ]

”Vi commands in all your Cocoa apps” was written by Merlin Mann for 43Folders.com and was originally posted on February 05, 2007. Except as noted, it's ©2009 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"

Fun and functional ways to trick out your htaccess file

Merlin — Wed, 22 Nov 2006 10:39:05 -0500

Stupid htaccess Tricks « Perishable Press

This is a terriﬁc collection of tricks for hacking on your Apache htaccess ﬁle, including some very useful ways to save bandwidth, control site access, and generate havoc.

I have been known to do some “creative” forwarding based on referrers from time to time, and if you’re in the mood to play a bit of psychedelic trafﬁc cop with your own hosted site, there’s enough here to keep you busy through the holiday weekend.

This one’s an old favorite, from which bandwidth can be conserved, leeches can be smote, and hilarity can ensue:

Stop Hotlinking, Serve Alternate Content

To serve ‘em some unexpected alternate content when hotlinking is detected, employ the following code, which will protect all ﬁles of the types included in the last line (add more types as needed). Remember to replace the dummy path names with real ones. Also, the name of the nasty image being served in this case is “eatme.jpe”, as indicated in the line containing the RewriteRule. Please advise that this method will also block services such as FeedBurner from accessing your images.

# stop hotlinking and serve alternate content
><IfModule mod_rewrite.c>
> RewriteEngine on
> RewriteCond %{HTTP_REFERER} !^$
> RewriteCond %{HTTP_REFERER} !^http://(www\.)?domain\.com/.*$ [NC]
> RewriteRule .*\.(gif|jpg)$ http://www.domain.com/eatme.jpe [R,NC,L]
></ifModule>

”Fun and functional ways to trick out your htaccess file” was written by Merlin Mann for 43Folders.com and was originally posted on November 22, 2006. Except as noted, it's ©2009 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"

Undo branches in Vim 7

Merlin — Wed, 20 Sep 2006 06:30:36 -0400

All about Linux: A visual walk through of a couple of the new features in Vim 7.0.

Version 7.0 of Vim has some sexy new features under the hood, including the ability to jump back in time – you can undo your work to where you were a few minutes earlier, for example. As explained by All about Linux:

In Vim 7.0, a new feature has been included which allows a user to jump back or forward to any point of editing. For example, I am editing a document and after a couple of minutes (say 10 min), I realise that I have made a mistake. I can easily take the document to a point 10 minutes back by using the command :

:earlier 10m

Or for that matter, move to a point 5 seconds ahead by using the command:

:later 5s

Seems like once you got the hang of it, this would be insanely useful.

Also, new to me: Vim, explained in 6kb. Nice.

”Undo branches in Vim 7” was written by Merlin Mann for 43Folders.com and was originally posted on September 20, 2006. Except as noted, it's ©2009 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"

FMP: Ruby script for text lists

Merlin — Tue, 02 May 2006 07:54:42 -0400

My Fiendish Master Plan

For you plain text nerds, Nick Fagerlund has developed a nifty little Ruby script called “Fiendish Master Plan” that helps with managing your lists of tasks or what have you.

The basic idea is to capture anything you need into one text ﬁle, with one item per line. He (and I) recommend using a Quicksilver trigger to append to that ﬁle of your choice as you work. When adding an item, you use a “category” tag (as in “^category”) which you type at the beginning of each line you. Ala:

^write thank Jaime for delicious basket of kittens
^errand take blood-stained poncho to French Cleaners
^chore ﬁnd source of smell under clown’s house

Periodically, you then run Nick’s script (either manually, via the command line, or by cron would work), and the magic happens. All the tagged items from your master list are appended to separate text ﬁles matching the name of the one-word category. In the above, for example, my thank you note to-do is added to my “write.txt” list, and off I go.

I haven’t spent too long with FMP, but it installed ﬁne for me (with his “I don’t know Unix” directions) and worked for the few test items I ran. I like that you could use this for GTD contexts, as well as for reference materials and running lists – e.g. “^getmusic Sonic Youth - Rather Ripped” would write to a ﬁle of records you want to listen to called “getmusic.txt.”

Simple script that does a simple (but very handy) thing – the ultimate life hack.

”FMP: Ruby script for text lists” was written by Merlin Mann for 43Folders.com and was originally posted on May 02, 2006. Except as noted, it's ©2009 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"

My txt setup

Merlin — Mon, 12 Dec 2005 08:39:42 -0500

The explications continue.

It’s been a while since I talked about how I’m using text ﬁles, and my post a while ago on Quicksilver appending reminded me of a few little changes I’ve made over the past year or so that my fellow text geeks might ﬁnd interesting.

Reviewing: Why text?

Like a lot of geeks and aspirational geeks, I do as many things as possible in plain text ﬁles. I’ve endlessly sung the praises of text on 43F, but in a nutshell, they’re portable, efﬁcient, tiny, and almost endlessly mungible. They’re the lingua franca of Unix and most of the civilized world.

As you’ll see, I use text ﬁles for any variety of things, although my favorite use is for making and maintaining lists. The aforementioned append functionality lets me quickly add items to any ﬁle with nothing but muscle memory and a few keystrokes. Best thing ever.

I also write in text ﬁles as well as store large amounts of reference information. Text is very easy to swap into HTML (I keep almost everything in Markdown format), and text is wonderfully searchable, whether using Spotlight, Find & Replace, or just via incremental search from within the editor.

Point being: I use applications like OmniOutliner, iCal, and (formerly) Entourage to organize the relationships between silos in my life; but text ﬁles are the living repositories for as much of the actual information as I can manage.

Getting a system

Like everything, this text system beneﬁts from a loose organizational framework that lets me quickly create and change ﬁles without having to worry too much about what it’s called, where it goes, and how I’ll ﬁnd it again. So here’s a few high points from my text world.

One and only one place

I’ve whittled down to a single folder for all my active text ﬁles with just two sub-directories, “Archives” and “Old.”

“Old” is simply where I dragged every text ﬁle I was pretty sure was dead or obviated (but you never know), and “Archives” is where I put the dearly-departed since making the move to the one folder to rule them all. Archiving is done…well…whenever I feel like it or notice that the top txt directory is starting to seem a little wooly.

Everything else sits in one directory. I use a little system of “meta symbols” and intuitive naming to keep things organized in the one big folder.

A smart name

Nearly all my ﬁles are named according to this structure:

Metasymbol SphereOfLife Project UniqueIntuitiveFilename VersionNumber.txt

where:

Metasymbol tells me whether the ﬁle is a running list, a reference ﬁle, or a static document (more on this in a minute)
Sphere of Life is simply something like “work” or “home” or “43 folders” – any über-silo that represents, say, 20% or more of your time and attention (hint: abbreviations are good here)
Project is what it sounds like: “Make-Articles” or “Johns-Site” or whatever (hint: abbreviations are good here too)
The unique ﬁle name is the ﬁrst and most intuitive name that pops into my head, sometimes augmented with redundant acronyms, etc. For me it’s important to be able to ﬁnd stuff quickly in Quicksilver, so I leave big fat hooks that account for whatever I’m likely to be looking for in the future
Version number is a slick little trick of mine. When I start a new version of a document, instead of adding a “2” or “3” to the most recent copy, I simply duplicate the document, then timestamp the old one – ala “+ work haa site design proposal-2005-12-12_08-16-34.txt”. That way I always know the unversioned copy is the most recent, but I still have backups I can roll back to any time. Neato.

Meta symbols

I’ve discovered I have three basic kinds of text ﬁles, and chose a simple method for marking the type of ﬁles they are for quick visual cueing.

This is super helpful for winnowing ﬁle names in Quicksilver: I start by typing one of these unusual (non-alpha-numeric) characters, and I can instantly pop to just a list of the types of ﬁles I want to see.

Running lists

Running lists are the majority of my ﬁles. They’re the kinds of lists that I mentioned in the appending article – ongoing places to park ideas of any kind over time. They begin with a “>”. This is, as with all these, purely my own convention, so you should feel free to pick symbols that make sense for you. This yields ﬁle names like:

> broken.txt - items or functionalities in my world that need repair or ﬁxes
> mom birthday gift ideas.txt - ways to delight the one what brung me
> webdav wish list and questions.txt - little projects for my newfound favorite technology

Reference

Reference items are evergreen and reusable content that I update fairly infrequently and refer to as needed.

^ work resume.txt
^ 43f site bio.txt
^ work domains I’m not using.txt

Static ﬁles

These are things like blog posts, articles, and any kind of nonce content that will be used once, and then probably not needed again (making them very quick to archive every month or so).

+ 43f post new text setup.txt (this document)
+ 5ives post ﬁve ways to make the party all about you.txt (potential list for 5ives)
+ work letter larry tate 2005-10-23.txt

So that’s my current system. It’s actually not as byzantine as it sounds. It really comes down to:

fast creation
fast addition
fast archiving
invisibility and intuitiveness

Your mileage will certainly vary, but I hope this stuff helps if you’ve been working to tame your own text beast.

”My txt setup” was written by Merlin Mann for 43Folders.com and was originally posted on December 12, 2005. Except as noted, it's ©2009 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"

GeekTool's new Tiger compatibility (and using it to build your own _Batcave_)

Merlin — Tue, 04 Oct 2005 09:52:48 -0400

Mac Geekery - Geektool and Bash One-Liners

I’m an old-school fan of GeekTool, a smart little PreferencePane that lets you trick out your Mac’s Desktop background with a variety of customizable stats, photos, and status info. Most folks’ favorite use is to display the output of shell scripts and simple CLI commands (e.g. “cat ~/todo.txt” or “tail -n 10 /var/log/crashreporter.log”)

To be honest, I hadn’t used GeekTool in a while, but apparently there were some Tiger compatibility issues that were vexing fans. Now Mac Geekery’s rupa deadwyler points to a branched version (2nd item) that provides ﬁxes for Tiger.

He also writes up a good post on a few of his favorite uses for GeekTool:

Processes

There’s a few ways to run this. Right now, I like:

ps -cm -U username | awk '/:/ && $5!~/Dashboard/'

c omits the full path of each process, m orders the processes by memory and -U username shows all processes owned by that user. Plain ps only shows processes run through the terminal, ps -A gives me more than I want to see, ps -U was pretty good, I thought. Replacing the m with r orders the processes by CPU usage, I haven’t really decided which one I like better.

My own favorite feature? Probably the least tech-y thing you can do with it: GeekTool can pull photos from the web on a regular schedule, which makes it easy to see weather, trafﬁc, and web cam output right on your desktop (my Desktop, ca. 2004-11).

With a little bit of creativity, experimentation, and poking around, GeekTool can help you put together your own Information Batcave.

”GeekTool's new Tiger compatibility (and using it to build your own _Batcave_)” was written by Merlin Mann for 43Folders.com and was originally posted on October 04, 2005. Except as noted, it's ©2009 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"

Life inside one big text file

Merlin — Wed, 17 Aug 2005 07:28:02 -0400

O’Reilly Network Weblogs: Living in text ﬁles

Giles takes one of the biggest, geekiest leaps you can—moving all of his stuff into a single big-ass plain text ﬁle.

As Danny O’Brien discovered during his research into effective organizational habits of geeks, text is the simplest, most platform-independent, fastest-to-search format we have for storing information. So everything I need - from todos, blog posts in progress, article ideas, addresses, my list of books to read, the shopping list, and much more besides, lives in just the one ﬁle. In effect, I live in that ﬁle. When I’m sitting in front of my computer, it feels like home.

This ambitious strategy—usually only whispered about among the lower geek echelons in which I dwell—seems to require a lot of conﬁdence, planning, and familiarity with your favorite ﬂavor of text editor. Mine’s currently TextMate, but, given what I’ve seen people like Danny do with Vim (and its incremental search-on-steroids, scripting functions, and endless shortcuts and conﬁgurability), this really reignites my resolve to hit the book and thumb through all my bookmarks again.

So. Questions for people who are already living in one text ﬁle:

What tips do you have for people considering the big move?
What tricks do you use to organize, automate, and move around in your huge-ass text ﬁle?
How do you decide where new stuff goes within a mutli-thousand line document?
Are you using section and sub-section headings to jump around?
How do you handle versions and multiple drafts of subsections (like, say, blog posts)
Got any sweet Vim tricks to share?
Any point where this approach starts to fall apart?
Have you found you think about your work differently when you work inside only one ﬁle?

Spill whatever you like about your one-ﬁle system (and, curious folks, feel free to ask questions).

Related Stuff

”Life inside one big text file” was written by Merlin Mann for 43Folders.com and was originally posted on August 17, 2005. Except as noted, it's ©2009 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"