Introduction

What a ride it has been since my last post. I continue to be stunned at the power of Doom, org-mode, and org-roam, and the progress I’ve made towards the most functional working environment I’ve ever used has been staggering.

Configuration Nation

One of the powers that org-mode enables is Literate Programming¹. In essence, you write an org-mode document containing code blocks, explaining/documenting each in natural language, then point the code blocks to where they should be “tangled.” Once instructed to “tangle” your code blocks are exported into usable source. There are a lot of advantages to this, which you can read more about {here}.

In the case of Emacs, this can be applied to writing well-documented configuration files that are easy to work with using org-mode’s tools. Doom provides an option to enable this out of the box with a single line in init.el, instructing Emacs that a file called config.org should be automatically “tangled” into config.el for Emacs to actually load.

My own config file was ugly and disorganized, and I was curious about the concept in general. So, I took inspiration from the excellent Doom Configs of Derek Taylor, aka DistroTube². An hour later, I had a configuration file that was fully organized into neat sections, providing useful references for my future self as I continue to evolve.

Advanced Org-anization

At the time of my last post, I had a todo.org, containing tasks that I wanted to work on, and a thoughts.org, where I was stashing stray thoughts for later review using a capture template. My plan for maintaining my Roam was to have a weekly review session, where I’d trawl back through files I referenced in Thoughts and Todos, updating, re-filing, archiving, etc. to keep the information useful and fresh.

However, as I continued to use it, it quickly became apparent that once-weekly was not enough. I had a number of empty files, texts I planned to read, fragmentation between projects, not to mention the divide between Thoughts and Todo.

In addition, I’d been doing some reflection on my previous Obsidian vault and my use of the roam so far, and one of the things that stood out was the littering of random one-off to-do lists all over the place.

The solution I finally hit on was to create a single, multi-node file called brain.org. My capture templates are now pointed at sub-nodes called “Inbox” and “Tasks” to merge the usefulness of both into a single file pointed to my org-agenda. With the nature of tag inheritance and the filtering tools of the agenda, I can now simply open a view that shows me exactly what I want to look at and focus on.

The Inbox is for anything that is not related to whatever I’m working on at the time and not yet a concrete task, so that I can review those in a central location. If they turn into a task, I can refile them into Tasks and change the to-do keyword, and if they need their own node, I can simply insert a node reference inside the task itself.

Temporary, one-off lists that are more than a checklist in my Daily, but less than a full-on project now have their own node within this Brain file, again incorporating them into my agenda if needed. Once finished, they’re easily archived so as not to clutter up my Brain.

Ongoing projects that don’t have a clear finish line (like my Emacs setup) also get their own node. This allows me to see what I have going on, and if “Inbox” items are more relevant to one of these, they can be moved into the related sub-heading.

To me, this feels much better. My growing comfort in hopping around org files and filtering them out to other things means I can see as much or as little as I want, and the malleable hierarchy feels organized but not so inflexible as to need an entire re-do if my thinking changes.

Not All Who Wander Are Lost

One of the biggest things I needed to be able to do in Emacs was write. I write a lot - short stories, nonfiction works, these blog posts, even a little technical documentation. Most of these things were already possible, albeit a little under-configured, but there was one gap.

I’ve recently had a desire to take another run at finishing a full-length book. I’ve made attempts in the past, but have fallen flat every time due to a lack of clarity and planning. It seemed to me that org-mode might enable this a little more, but I wasn’t sure how it could work with my current setup.

With this in mind, I found this excellent write-up about using Emacs to write prose. There wasn’t a single useless line in the post, but some key things stood out.

The first was something that was already beginning to dawn on me - taking full advantage of org-mode’s outlining superpowers. With this, I could organize everything relevant to a writing project into one file. My previous scattering of “Notes,” “Planning,” “Characters,” and “Main” files could now be in one place. No more tabbing around or having four open in tiny tiles - if I need to look at something somewhere else, I can just hop to it in a few keystrokes. And, when the time comes to actually write, scenes or chapters can just be filled in under their relevant sub-headings.

The second was actually just a passing mention of something called The Snowflake Method. I won’t go into the full detail here, but essentially it’s a sort of fractal-based approach to planning and writing a novel. You start with short, broad ideas, and then make repeated passes over them to gradually develop a very detailed outline of your entire novel. Org-mode seems almost tailor-made for this, mostly as described in the point above.

The third was another thing I’d just begun to use effectively - tags. Scenes can be tagged with characters and locations, notes can be tagged with concepts, etc. This essentially just provides another way to look at exactly what I want, and find connections I would otherwise miss.

The actual project I’ve started working on is beyond the scope of this post and will likely get its own series, but suffice to say that in just the three days I’ve been pursuing a snowflake I’ve written over six thousand words.

Ever Onward and Ever Doom-ward

While my current setup is already extremely useful, there are still a number of things I want to do.

I haven’t yet set any of my own custom keybindings, and I’ve begun to use functions that aren’t bound from other packages. I’m still brainstorming how exactly I want to set this up and how much I want to do, but having a consolidated key-subkey for the things I do most is in the works.

My capture templates also still need a bit of work. My “Inbox” template doesn’t always file under the right heading for some reason, and none of my templates include all the things I’d like to automatically fill in. I’ve also built up an outline of everything I want for the structure of my Dailies, and I plan to make a template so that I’m not filling that in by hand every morning.

The last thing I’d like is a bit more of an endeavor - some way to log whatever and then have a way to get useful data out of that. Right now I’m just using org-habits to track a couple things I’m trying to do every day, but ultimately I’d like a more flexible log with an associated capture template, and a dynamic block or graph function to get an overview of these logs.

Closing Notes

I continue to be astounded by Doom Emacs. I have never found a piece of software more inspiring and powerful, and the productivity boost I’ve seen in my short time with it so far is staggering.

Much love to everyone who’s taken part in writing any of the things I’m using here, I can’t be more grateful for the extensive body of work that’s enabled me to use such power so effortlessly.

Many updates in the days to come, but that’s all for now!

Stay tuned, do good work, and be kind.

Thank you for reading.

~Sonar