But in the annals of the golong-nuts mailing list I eventually found out about runtime.Caller(). This returns a few details about the current goroutine’s stack, including the file path.

The context of my problem was opening a data file in a shared package. What I cooked up was:

Sending 1 to runtime.Caller identifies the caller of runtime.Caller as the stack frame to return details about. So you you get info about the file your method is in. Check the docs for more in-depth coverage.

It’s not quite as elegant as __file__ but it works.

I’ll include an example project file in this post that runs manage.py test --noinput as the build command. In order for this to work with the current implementation of build systems, the project file must add the Django project dir and the virtualenv’s site-packages directory to the PYTHONPATH.

Note a couple of things:

• In the project file, ${project_path} refers to the directory in which the project file exists: I created mine in the virtual env directory (the directory with the bin/ and lib/ directores for the virtualenv). For more info on other possible substitutions see the docs (note that I couldn’t get substitutions to work in the “env” dictionary)
• My placeholder text django_project_dir stands for the directory that contains your Django project files inside of the virtualenv
• This doesn’t use the python binary in your virtualenv — so your mileage may vary

One final thing to note is that I’ve added the lib/python2.7 directory as a folder in the project file. This is not related to the build system. It simply includes libraries in my “Find in File…” searches, allowing me to easily search for, e.g., Django classes and usages alongside my own. (SublimeRope is also a helpful tool for exploring.)

Anyway, here is the example project file:

There is only one way (update: two ways) I’ve found to do this. They both involve the inspect module. (There are obvious ways to do it that don’t work with decorators.)

You can’t assume that the first argument in a function always refers to its class because that would break in the case that the function was not a method. However, the strong convention in Python is to name the first argument of methods ‘self’. Relying on this convention, we can easily tell if a function includes such an argument with the inspect module.

The inspect module’s getcallargs function will map the parameter names from a function’s signature to its arguments. Given a function fn that your decorator wraps, you can call inspect.getcallargs(fn, *args) at runtime and discover that the first positional argument is the ‘self’ parameter defined in the method’s signature!

Now, the use of ‘self’ is such a strong Pythonic convention that it’s good enough in most cases to use the presence of such a parameter in a function to know that it’s a bound function (again, a class method), and you can then inspect the ‘self’ argument for its class using __class__.__name__.

Here is an example decorator that will print out the class name of a decorated bound function:

Update: In Python 2.6, which does not include inspect.getcallargs, you can use inspect.getargspec to similar effect:

These included:

• Better code wrapping (gq)
• Go to last edit ('')
• Go to file in Ack search output
• Display full path to current file (:echo expand('%:p')<CR>)
• Jumping back and forward through files

However, Sublime Text 2 has a great Python API and I was able to whip up plugins for these tasks that perform just as well as in Vim. Update: I also found the navigationHistory plugin, which does a pretty good job of back/forward jumps.

Better code wrapping

Vim’s reformat text command (gq) can take multiple paragraphs and text in comments and flow them to the current textwidth setting. Some people don’t care about this, but I prefer to keep lines of code less than 80 characters wide, so I can open multiple files side-by-side. (Also, Pep-8.)

Sublime Text 2 had a “wrap” feature, but it failed to intelligently wrap comments, it joined separate paragraphs together and it wouldn’t reflow selected text (only the paragraph around the cursor).

The plugin I wrote creates a Wrap Code command (mapped to gq in Vintage mode) that works reasonably on commented lines of code (and uncommented lines), multiple paragraphs and selected text, thanks to the codewrap.py module written by Nir Soffer.

Download the WrapCode plugin on Github.

Go to the last edit

I’m used to typing '. in a buffer in Vim to move the cursor to the last edit. Great feature. Totally underrated.

If you use Vintage mode in Sublime Text 2, you’ll quickly discover that this command does nothing — worse than nothing, in fact, as it seems to refocus your cursor somewhere other than the text of the buffer, forcing you to use your mouse to recover.

While I couldn’t bind my plugin to the '. command without forking Vintage mode, I bound it to Super+' and it works the same as Vim’s.

Download the GotoLastEdit plugin on Github.

Easily open search results

Another thing I missed about Vim was its Ack plugin. The “Find in Files” feature of Sublime Text 2 is great, but it didn’t provide an easy way to quickly open a file listed in the search results via the keyboard (you can double-click on a line to open it, though).

So I wrote a plugin that, in a Search Results window, allows you to do one of the following via the keyboard:

• On a “matched” line in the search output, open its file at the line of the match
• On a file path in the search output (without a line number), open the file in a new tab

Download the OpenSearchResult plugin on Github.

Display full path to file in status bar

I use Vim in OS X’s full screen mode, with no tabs or status line. Working this way, I don’t have reference to the path of the current file. Of course, I know the name of the file because I usually typed it, but sometimes the full path is important; e.g., if I have two Mercurial branches of the same code in different directories.

So, I have a command mapped to ,F that displays the full path. Then it silently goes away after a moment. I love that command.

I couldn’t find an ideal way to implement this in Sublime Text 2, other than to create a command that would toggle displaying the path to the current file in the status bar. It works well enough for me, however.

Download the FilenameStatus plugin on Github.

Jumping back and forward

One of Vim’s most awesome features is Control-O/Control-I to jump back and forward — maybe I can generalize to say that all of Vim’s jump commands are part of its “killer app” status.

Sublime Text 2 doesn’t have a feature like this, but someone on the internet has packaged a version of Martin Aspelli’s navigationHistory plugin, which comes close.

Download the navigationHistory plugin on Github.

Installing the plugins

You install these plugins the same way as other Sublime Text 2 plugins, by downloading the files and dropping them into the Packages directory.

See this documentation for more details if you need additional help installing plugins.

The default key bindings are intended for Vintage mode and are oriented for OS X.

I agree that there is a challenge inherent in the new ease with which publishers may release versions of a text, but the challenge I see is different than the one Carr suggested. Data about the chapters that readers skip and areas that cause people to abandon their reading will only help publishers create better, more relevant content, just as this data has helped web site authors do the same. It is our response, as readers, to the possibility of frequent (and silent) revisions to text that I worry about.

Movable Text

As a summary of the key difference between print and electronic publishing, Carr described electronic publishing as having replaced Gutenberg’s movable type with “movable text.” For centuries, once set and printed, the text of a book remained the same. Today, with web sites and now ebooks, publishers may change the text at any time, introducing multiple divergent copies or, if the distribution method supports it, even changing the copy you are reading as you read it.

Carr wrote about the downside of this change that,

The promise of stronger sales and profits will make it hard to resist tinkering with a book … adding a few choice words here, trimming a chapter there, maybe giving a key character a quick makeover.

– Books That Are Never Done Being Written

What is wrong with this? While some readers may finish every book they start, I have dismissed dozens of books in my life, at various points in their stories, after having read one too many missteps of voice or plot, or simply because I was bored. Life is short. There are more books to read than I have time for. So why should I read a poorly written book, and what do I care for the “shape” of a book (to quote Carr quoting Updike) if I can’t connect with it?

Creators and publishers who release work on the internet can get faster and more in-depth feedback from consumers than in traditional publishing — not just through comments but through analytics about a reader’s behavior. Analytics can show what people look for in a text and different ways they respond (e.g., most people stopped reading on page two). As anyone who has written a blog or maintained a web site will know, this information is extremely valuable as way of testing what people want to read and what they don’t.

The same will now be true for books. As readers, our reactions to books, not just the fact that we purchased them but more intimate details like how long we lingered on a page and where we stopped reading (if it wasn’t the end), will place us in tighter feedback loops with authors. How is this a “bane”?

Authentic Text

What is wrong with this model is that we must change our idea of the persistence and security of human knowledge to fit it. We have to create new mechanisms to ensure the authenticity of texts. There are measures we can take to accomplish this:

• Creators should have control over changes made to their works, to protect themselves from publishers introducing alterations based on sales data.
• Readers should have access to all released versions of a text. Each authorized edition of a text should have its own ID that is registered with a trusted authority. And if the publisher releases a new version of a book that is already on our ebook readers, we ought to have the right to approve whether or not we update to it.
• A trusted organization of the public good should house a copy of each version of released texts, to reduce the chance that individuals, companies and governments can alter or destroy the source files.

In the traditional publishing model, a printed edition of a work with an ISBN is a “known good” source copy. It is authorized by someone. Multiple editions of a book may exist, but as readers and historians we can examine our authorized copies of these editions. We can protect them.

As we move toward using and relying on digital text, we must develop new means of protecting the authenticity of this information. The bane — the sharp edge — of “movable text” is not the ease with which we may change our books after we publish them. It is that our mechanisms for protecting ourselves from such change are outdated.

I wanted to try using them together, by setting iA Writer as the external editor for Notational Velocity, but after doing so I noticed that iA Writer would not open with the keyboard shortcut (Command-Shift-E), and it was grayed out in the ‘Note->Edit With’ menu.

After tinkering, I found that Notational Velocity’s note storage must be set to plaintext files and the file extension must be ‘.txt’ (or ‘.md’, which is iA Writer’s default file extension). The rest of this guide will assume you want to use ‘.txt’ as the file extension for notes.

Full Requirements

So, the full requirements to use iA Writer with Notational Velocity are:

• Set iA Writer as the External Editor in Notational Velocity
• Use plaintext file storage for notes in Notational Velocity
• Use the ‘.txt’ extension for note files

Set iA Writer as the External Editor

• Open Notational Velocity’s preferences
• Click ‘General’
• Choose ‘iA Writer’ in the External Editor drop-down

Use Plain Text Storage for Notes

• Open Notational Velocity’s preferences
• Click ‘Notes’
• Click ‘Storage’
• Choose a folder to save and read notes from in the ‘Read notes from folder’ drop-down (I suggest a Dropbox folder)
• Choose ‘Plain Text Files’ in the ‘Store and read notes as:’ drop-down
• Highlight ‘txt’ in the Extension list and click the check-box to make it the default extension

Changing Existing File Extensions

If iA Writer is still grayed out in the ‘Note -> Edit With’ menu or fails to respond to the external editor keyboard shortcut, make sure that the notes you are editing have the ‘.txt’ extension.

All of your notes should now be stored as individual files in the folder you chose in Notational Velocity’s preferences. To change the extension on these files, open that folder in Terminal or Finder and rename the files so that they end with ‘.txt’.

Batch Renaming Files in Terminal

If you have tons of notes and need to change all of them to a new extension, open Terminal and cd to the folder you chose for note storage in Notational Velocity. Then run the following command (assuming the original extension of the files was ‘.wiki’, which it was in my case):

    for old in *.wiki; do mv "$old" "`basename $old .wiki`.txt"; done

Done… Bonus Round?

You should be set now.

However, iA Writer uses the Markdown format, so as an extra bonus you could add a Markdown plugin to Vim, allowing you to easily edit the same text files in Notational Velocity, iA Writer and Vim, which is of course the greatest text editor of all time.

There was always a marked difference between Vim on my Mac and Vim on Linux. Scrolling with the movement keys (j/k in particular) was blindingly fast on Linux, but plodded along on my Mac so slowly that I began using Control-F and Control-B most of the time.

It turns out there was a simple cause for the problem: key repeat settings. The setting was too low for me.

You can change Key Repeat settings in System Preferences -> Keyboard. Tweak the Key Repeat and Delay Until Repeat settings to find a good speed. I had to restart after changing these settings to see any effect.

Now, the vanilla options helped some, but in order to get really fast scrolling speed, I had to take two more steps:

• Switch to iTerm 2 for my terminal. Terminal.app, even Lion’s, couldn’t cope with faster key repeat settings – Vim was still slow, though a bit faster.
• Tweak the repeat values even more with KeyRemap4MacBook.

The magic KeyRemap4MacBook values for me were:

• [Key Repeat] Initial Wait: 15 (Update: 500)
• [Key Repeat] Wait: 35

I’ve found that such automation is most useful when switching between branches in source control. Without automation, you have to manually kill and reconstruct any Django shell and development server instances for each branch (and sometimes the database shell, too).

While my examples are geared toward Django development, the approach I describe works equally well with Rails and other frameworks.

Tools used:

• Tmux, a terminal multiplexer like GNU Screen
• Tmuxinator, a nice Ruby gem for automating Tmux
• Virtualenv, a tool for creating isolated Python environments
• Virtualenvwrapper, a set of extensions to virtualenv
• My tmux.conf

By the end of this post, you will have a new command available in your terminal that will create a Tmux session with multiple views into your Django project.

Why Tmux?

First, a quick note about Tmux.

Until earlier this year, I had used GNU Screen for managing persistent terminal sessions. It worked well. However, I grew dissatisfied with the pace of development in the project, the lack of new features, and the inconsistent availability of vertical splits across different platforms. So, I tried Tmux, and I haven’t gone back.

If you are a Screen user, then I suggest you try Tmux, but you can probably achieve a similar method to the one described in this post using Screen and one of the automation scripts designed to work with it.

Virtualenv and Virtualenvwrapper

My example uses virtualenv and virtualenvwrapper. Note that you do not need to use either of those tools to set up or tear down a Django development environment with Tmux. They just make working with multiple Python projects easier.

If you don’t use these tools, remove the venvwrapper && workon my_project portion of the examples.

I will skip explaining how to install those tools or use them, since many tutorials on those subjects exist already, in addition to the virtualenv docs and virtualenvwrapper docs.

After this point I will assume you have created a virtualenv for your Python code in a directory named my_project and have configured virtualenvwrapper so that you can execute workon my_project to activate the virtualenv.

Install Tmux and Tmuxinator

Install Tmux with your package management software of choice. It’s available in apt-get, MacPorts, etc.

Next, install Tmuxinator (instructions here).

As a side note, I recommend using RVM to manage your Ruby versions.

Create a Project File

Before taking this step, make sure you’ve followed the Tmuxinator installation instructions and have exported your EDITOR shell variable, e.g.:

$ export EDITOR=vim

Now, use Tmuxinator to create a “project file” (a YAML file containing shorthand configuration settings for Tmux).

$ tmuxinator new my_project

A file should now open in your text editor. The Tmuxinator docs use a Rails-inspired example. The following is a Django example in which I create a Tmux session with multiple windows (an explanation follows the example).

A Django Example

# ~/.tmuxinator/my_project.yml
# you can make as many tabs as you wish...

project_name: my_project
project_root: ~/
tabs:
  - zsh: ls -l
  - shell: venvwrapper && workon my_project && cd my_project &&  ./manage.py shell
  - database: venvwrapper && workon my_project && cd my_project && ./manage.py dbshell
  - server: venvwrapper && workon my_project && cd my_project && ./manage.py runserver
  - logs:
      layout: even-horizonal
      panes:
        - tail -f /opt/local/var/log/nginx/access.log
        - tail -f /opt/local/var/log/nginx/error.log
        - sudo python -m smtpd -n -c DebuggingServer localhost:25

Explanation of the Example

The example creates a Tmuxinator project file named my_project.yml, which generates a my_project.tmux file and creates the command start_my_project that you can use to start the Tmux session.

The example assumes that a virtualenv exists in a directory named my_project and the env directory contains a directory named my_project (e.g., in my case, ~/envs/my_project/my_project). Obviously, this should match whatever directory structure you actually use for your virtualenvs.

The Tmuxinator docs describe everything that you may configure with a project file. There are more options available than the ones in my example, but I use this relatively simple configuration for my day-to-day Django work, and it saves a bunch of time.

Here is an explanation of the options the example uses:

• project_name: the name of the project; this becomes part of the command you use to launch a Tmux session, e.g., start_my_project
• project_root: the starting directory for each command that you tell Tmuxinator to execute
• tabs: each item in this list represents a named “tab” or Tmux window in which one or more shell sessions will run
• zsh: I like to have a shell opened and pointed at my home directory for random commands
• shell: activate the virtualenv and load the Django shell for my project
• database: activate the virtualenv and load the database shell for my project
• server: activate the virtualenv and start the Django development server for my project
• logs: create a three-pane split using Tmux’s even-horizontal layout (each pane is an even height) to display logging output from nginx, which is running my dev machine and proxying requests to the Django dev server, and a Python SMTP debugging server (because I like to see HTML/text dumps of emails generated during development)

Now, assuming you followed the Tmuxinator docs and have the following line in your zshrc/bashrc (…):

# Tmuxinator
[[ -s $HOME/.tmuxinator/scripts/tmuxinator ]] && source $HOME/.tmuxinator/scripts/tmuxinator

… You can run start_my_project from your shell of choice to open a Tmux session with all the tabs you configured.

Making this Really Useful

Instantly summoning a development environment is great, but where this approach really shines is when you need to switch branches in your project.

In a single day, I might work on two or three different branches in one project. Before using Tmux and Tmuxinator, I would have to constantly kill and restart various commands each time I switched to a different branch. Now I just do the following:

• Issue the kill-session command within a loaded Tmux session (Ctrl-b : kill-session <CR>)
• Back at the shell, run my start_project command again

Two commands to restart an entire session from the new branch. Handy! And, if you have other sessions loaded, kill-session preserves them by killing only the session you are currently in (kill-server kills all sessions).

Summary, Other Resources

Tmux is great, and automating session creation has saved me a lot of time. I hope it saves you a few precious minutes (hours?!), too.

If you’re a Screen user who has read this far, I encourage you to try out a similar approach with Screeninator. Of, if you just want to get some tabs up in your terminal app, try Terminitor.

Addendum: Multiple Sessions

One thing I love about Tmux is that you can have multiple sessions open. So, for example, while I’m working I usually have two sessions open: my Django project session and a session for system administration that has my Chef repository (using LittleChef) and a few SSH tabs open:

# ~/.tmuxinator/work.yml
# you can make as many tabs as you wish...

project_name: work
project_root: ~/
tabs:
  - zsh: ls -l
  - chef: venvwrapper && workon kitchen
  - qa: ssh username@my_qa_server
  - prod: ssh username@my_prod_web_server
  - (several more ssh sessions here)

This is nice because I can quickly switch sessions within Tmux with Ctrl-b s.

I also have other sessions for Clojure projects and so forth that I’ve configured for hacking around on the weekend. Go Tmux!

When I first read “Self-Reliance,” these words sunk into me, but I must have skimmed the rest of the essay. Emerson’s style and vocabulary put me off, an experience which I attributed to 150 years of drift in the English language. The problem only got worse as I read his other essays: I kept wondering when he would get to the point, or worse, if he had a point worth getting to (see: “English Traits”).

Recently I pulled down from the shelf a used, still-beautiful American Library hardcover collection of Emerson’s works I’d been lugging around, and decided to give him a second chance, starting with “Self-Reliance.” This time, the essay had a more powerful effect. Themes that were obscure before — the challenge to find original thought, Emerson’s pleas for the reader (or perhaps the writer) to avoid conformity — now seemed to apply to my life in unexpected ways.

If I want to be fully human, I need to create my own ideas — I can’t merely adopt ones I find lying around. Coming from Emerson, this otherwise bland message is a sharp reminder that even when I think I’ve worked something out, I still need to maintain the “integrity” of my mind, through the proper care and feeding of my ideas. Take veganism, for example: I can decide, given some evidence and critical thought, to eat a vegan diet, but pretty soon I may start calling myself a vegan, which means opting in to the vegan community. And that is quite a mixed bag, in Emerson’s view. Claiming membership for oneself in such a group poses a problem: what if I act not because I still believe in the shared values of the group, but because I want to continue to belong, to be known as, a vegan? The question evokes Foucault’s analysis of the Panopticon, a prison in which the prisoners know they are being watched, but do not know when. A human being living a busy, highly-connected life can find him or herself in this role far too often, I think, and the result is that our actions mean different things than we pretend they do. If we act with the warden on our back, then the meaning and our ultimate experience of our act changes; ideals may become prisons.

All that aside, I can’t claim to be a perfect vegan. After a year or so of trying to eat a vegan diet, I’m enthused and especially happy to live closer to an ideal that Peter Singer originally drove home for me. On some occasions I’ve called myself a vegan and have been called one. But have I been 100% consistent? No. Every once and a while I eat something that I know or suspect has dairy in it. Usually this happens when someone offers me food as a gift, or when I’m at a restaurant and I forget to ask. At these times I have competing values. Sometimes I value generosity from another human being more than I value my decision not to eat animal products. Likewise with waste: I can’t ever send food back; I hate wasting food.

I suspect that the desire to remain consistent in action, despite feeling conflicted, is a problem other vegans face. The world is complex, and we respond to it with principles that sometimes compete. Emerson would probably find that acceptable. The integrity of my mind is more important than achieving 100% consistency. After all, if the primary reason I eat tofu instead of cheese on any given day is that I wish to identify as a vegan, and not because I consider tofu healthier for the planet, then I will have lost my integrity, even if I remained consistent in action. As Emerson wrote, “I ask primary evidence that you are a man, and refuse this appeal from the man to his actions.” Not only my actions, but also my intentions, create the evidence that I am truly human.

Of course, what occurs to me as examples of “foolish consistency” may not occur to you. In my day-to-day life I think most about my family, technology, and food politics. A healthy critique of IT industry wisdom would do me good, but not you, perhaps. Instead, I will only encourage you to read “Self-Reliance.” And then, join me in re-reading it, some years from now, after the dust has settled, so that we can snap to attention once again.

Kim wasn’t fond of Fred Meyer, either, so we hatched a plan to limit how much time we spent at the supermarket, and how much we bought, by buying groceries in bulk once for the entire month. Since we’d need a car for the monthly trip, we bought a membership at Zipcar, which has a hybrid available to rent for $7/hour. We had joined a CSA program through Helsing Junction Farms, which we would rely on for our weekly produce; and on the weekends we would buy a couple of items, like Dave’s Killer Bread (PS, this bread has an awesome story), at a local farmer’s market.

The plan has worked out so well that I’m not sure how we ever put up with the supermarket circus four times every month.

With all the time we’re saving not wandering the dizzying aisles of the supermarket, I’ve had time to reflect on why our experience buying directly from farmers, both at the farmer’s market and through our CSA, has meant so much to me.

I grew up in the suburbs of California and Oregon, shopping with my parents at all the popular big-box megastores. As an adult, I often gravitated back to these stores to avoid the hassle of traveling to multiple places to buy my food and household items. Fred Meyer (AKA Kroger’s), for example, sells produce, bulk food, socks, shoes, computers, toiletries, pharmaceuticals, vacuums, jewelry, bikes, plants, Christmas trees — the list is effectively endless, and I could always get 90% of what I need there.

During my early 20s, I began to have misgivings about this kind of store. Driving out to visit my parents in Gresham, I thought the concrete and retail blight of outer Portland was an eyesore compared to the Columbia River and the trees along the Washington border. These negative feelings peaked in 2006, after I returned from a trip to Ghana. While there, I had experienced a completely different approach to life than what I’d grown up with. One of the most notable differences was the central market. In Tamale, Kumasi, and Accra, Ghana’s major cities, I roamed immense central markets that twisted and surged with life. These markets were like cities within cities, and were constantly filled with people who came to buy food and supplies, in many cases directly from the people who ran the farms and from the tailors and craftspeople whose shops lay hidden like bright jewels within the catacomb of the market. These places were all the more beautiful because they appeared to be the creation of the Ghanaians who lived in those cities: over the years, new things — baubles, plastics and electronics — had all been grafted onto the timeless root at the center, the market.

Ghana showed me a way of life I never knew in the United States. The memories I had of Ghanaian markets lingered when I came back to Portland and had to interact, once again, with huge megastores owned by corporations that had no real stake in the cities in which they did business. Where were all the people selling food and things they worked to harvest or create? What kind of stuff was I buying, really? Most of it was factory-churned, bland, out-of-season, over-priced stuff harvested and created by, in many cases, low-paid workers, and the profits of the sales flowed directly out of Portland, Oregon. I know that my memory of Ghana was not informed by years of observation — I had my rose-tinted tourist glasses on — and the story there can’t really be too different from the story here (I’m sure not all of those people were selling stuff they had made, or food they’d harvested!). But, being there, and then returning home, helped me to realize an ideal I had for the way commerce should happen.

I wanted to incorporate parts of the Ghanaian lifestyle into my life, somehow; maybe not everything, but the good stuff, including the way I bought my food and supplies. Doing so proved hard. On my own, it seemed like I couldn’t really make a difference, even with something that appeared to be simple. Then I met Kim, and for a while, all the fun we were having getting to know each other led me to forget some of my ill feelings. Kim and I regularly shopped at Target, buying imported goods; we purchased electronics at Best Buy, furniture at Ikea, and groceries at Fred Meyer. My dissatisfaction with the American retail and food machine had not gone away, though. It only smoldered quietly.

Skip ahead to 2010. Kim and I weren’t exactly planning to drop out of mainstream American culture, but that is what seems to have happened. Over the past couple of years, we moved twice, each time closer to the inner-city. Pretty soon, we’d ditched our car for bicycles; we’d become vegetarians, then vegans, and had started buying mostly organic, local food. I resisted some of these changes, at first — especially buying organic and going vegan — while, at the same time, the more Kim read about the food industry, the more unhappy she felt with how we ate. All the cheap, factory-produced food; bland, imported produce; chemical-enhanced, boxed and double-packaged goods! I was like, “I can’t change. I don’t want to change!” But, once Kim got excited about finding an alternative, I started to feel excited, too, and before long we were creating for ourselves the kind of life I’d dreamed about since coming back from Africa. We bought more organic and local food, explored farmer’s markets, and shopped at local-farm-friendly stores like New Seasons.

Now, I know what I want from the experience of buying food and supplies:

1. Cut out the middle man — buy direct when possible
2. Support Willamette Valley, Oregon, and Washington farmers
3. Do business in a community-owned and -operated space (not a corporate market)
4. A fun atmosphere, a place of joy

In Fred Meyer, the bulk of our purchases were in a single produce aisle and a small island of “health food” hidden between a dozen aisles of beer, wine, cookies and cake. We usually locked our bikes at the opposite end of the store from the food, due to the direction we were coming from, which meant that we had to walk through half a mile of cluttered superstore nonsense, listening to elevator music and dodging lots of unhappy-looking people. Now, we have a much more enjoyable time buying organic food grown locally and responsibly, without hurting animals and without factories: once a week, Kim rides her bike to a house in our neighborhood to pick up the CSA box, and every Saturday we visit the farmer’s market at Portland State University where we buy food directly from farmers growing in the Willamette Valley and elsewhere in the Pacific Northwest.