I would like to share some of the tools and workflows I use in Emacs to help me keep on top of multiple clients’ needs and expectations.

Organization with org-mode

It should be no surprise that at the center of my Emacs command center is org-mode. I have already written about it a lot. Every org-mode user seems to have their own way of keeping track of things, so please don’t take my organizational scheme as some kind of gospel. A couple of years ago, I wrote about how I handle to-do lists in org-mode, and I am still using that method for to-do keywords. However, file structure is also important. I have a number of core files.

Freelance.org

This top-level file contains all of my ongoing business tasks, such as tracking potential new clients, recurring tasks like website maintenance and checking my MainWP dashboard. I also have recurring tasks for invoicing, tracking expenses, and other important business things.

This file is also where I have my primary time tracking and reporting. Org-mode already supports this pretty nicely, I just use the built-in clocktable feature.

Clients/*.org

Clients that have large projects or ongoing business get their own file. This makes organization a lot easier. All tasks associated with a client and their various projects end up in these individual files. The important part is making sure that these files are included in the time-tracking clock table and your org-mode agenda, so you can see what is going on every week.

References and Linking

I have C-c l bound to org-store-link and use it all the time to link to various files, directories, URLs, and even emails. I can then use those links in my client notes, various tasks in my to-do list, and so on. This helps me keep my agenda organized even when my filesystem and browser bookmarks are a bit of a mess.

Email with mu4e

I have been reading and managing my email in Emacs for over 25 years. There have been a few breaks here and there where I have tried out other software or even web mail clients, but it has always been a headache. I return to Emacs! Long ago, I used VM (which seems to have taken on new life!), but currently I use mu4e.

This gives me a ton of power and flexibility when dealing with email. I have custom functions to help me compose and organize my email, and I can use org-store-link to keep track of individual emails from clients as they relate to agenda items. I even have a function to convert emails that I have written in Markdown into HTML email, and one that searches for questions in a client email to make sure I haven’t missed anything.

The ability to write custom code to both process and create email is extremely powerful and a great time saver.

Writing Code

I don’t know what else to say about this, I use Emacs for doing all of my software development. I make sure to use Eglot whenever there is a language server available, and I try to leverage all the fancy features offered by Emacs whenever possible. The vast majority of projects for clients are PHP (thanks WordPress), Go, JavaScript, and TypeScript.

Writing Words

Previously, I have shared quite a bit about writing in Emacs. I like to start everything in org-mode, but I also write quite a bit in Markdown. Emacs has become a powerful tool for writing. I use the Harper language server along with Eglot to check grammar and spelling.

Track All Changes with Magit

Version control is essential, a lesson I have learned over 30+ years of software development. While Git is not part of Emacs, the software I use to interface with Git is. Magit is a Git user interface that runs entirely in Emacs. I use it to track my writing, my source code, and even all of my org-mode files. Using version control is so essential that I have a weekly repeating agenda task reminding me to check all of my everyday files to make sure I have checked-in my changes for the week.

Thinking Music with EMMS

I like to have some soothing background music when I am programming, writing, or otherwise working on my computer. However, if that background music has lyrics, it can be really distracting. It is easy to make a playlist for various suitable SomaFM channels to load into EMMS (the Emacs Multimedia System) using the command M-x emms-play-playlist.

Try saving the following into playlist.el somewhere, and using it the next time you are writing:

 ;;; This is an EMMS playlist file Play it with M-x emms-play-playlist
 ((*track* (type . url) (name . "https://somafm.com/synphaera.pls"))
  (*track* (type . url) (name . "https://somafm.com/gsclassic.pls"))
  (*track* (type . url) (name . "https://somafm.com/sonicuniverse.pls"))
  (*track* (type . url) (name . "https://somafm.com/groovesalad.pls")))

And make sure to check out SomaFM’s selection to find some good background music that suits your tastes!

And the tools I have missed

There are undoubtedly Emacs tools that I have missed in this brief overview. I have been wracking my brain as I write, trying to see what I have forgotten or overlooked. Frankly, Emacs has become such a central part of the organization for my freelancing that there are probably many tools, packages, and processes that I use every day without thinking about it too much.

Emacs makes it possible for me to freelance for multiple clients and small businesses without losing my mind with organization and task management. The tools it provides allow me to stay on top of multiple projects, handle client relationships, and keep track of years worth of tasks, communications, and projects. Without it, I’d be sunk!

What Emacs tools are you using to manage your freelance business? I am always looking for ways to improve or streamline my process.

The featured image for this post comes from Agostino Ramelli’s Le diverse et artificiose machine (1588). Read more about it on the Public Domain Review.

Turning to consult-omni

Armin Darvish has created a powerful Emacs package called consult-omni, which provides a wrapper around consult for searching through any number of information sources. I believe consult-omni was originally intended to query web search engines and document databases, but Darvish has also provided a search mode for your local desktop applications, and can act as an application launcher.

Darvish provides an example application launcher in his consult-omni YouTube tutorial. The source code is straightforward, but I wanted to tweak it just a little. You can view his original on the project’s wiki on GitHub. You can watch him explain his technique below.

After a few tweaks, here is what I came up with.

(defun consult-launcher ()
  "A launcher suitable for use from a window manager."
  (interactive)
  (let* ((width (floor (* 0.6 (display-pixel-width))))
         (height (floor (* 0.6 (display-pixel-height))))
         (left (floor (* 0.2 (display-pixel-width))))
         (top (floor (* 0.2 (display-pixel-height))))
         (params `((name . "omni-launcher")
                   (width . ,(cons 'text-pixels width))
                   (height . ,(cons 'text-pixels height))
                   (left . ,left)
                   (top . ,top)
                   (minibuffer . only)))
         (frame (make-frame params)))
    (with-selected-frame frame
      (select-frame-set-input-focus frame)
      ;; If i3 is running and there is a control socket, let's tell
      ;; it we are a floating frame.
      (if (getenv "I3SOCK")
          (call-process "i3-msg" nil nil nil
                        (format "[id=%s] floating enable"
                                (s-trim (shell-command-to-string "xdotool getactivewindow")))))
      (unwind-protect
          (progn (consult-omni-apps-static ".*" (propertize "> " 'face 'consult-omni-path-face))
                 nil)
        (progn
          (when (frame-live-p frame) (delete-frame frame))
          nil)))))

I made two changes to get this to work nicely with i3. First, I removed the yequake dependency. Second, I added a call to i3-msg that sets the launcher frame as floating, which makes it much nicer to use. Like Darvish’s version, you can run this from the command line:

emacsclient -e '(consult-launcher)'

Adding an ilia fallback

Don’t tell all the other Emacs users, but I don’t have Emacs set up to launch automatically when I start my computer and log into X11. I probably should, huh? Also, there are times when I (gasp!) shut down Emacs, usually to restart it or fix something that I have broken. When those times happen, I want to be able to launch applications, so I need a failsafe in case consult-launcher isn’t available!

To solve this, I created a simple shell wrapper script, which looks like this:

#!/bin/bash

# Check if Emacs server is running by looking for the server socket
# Default server name is "server", but you can change this if needed
SERVER_NAME="${EMACS_SERVER_NAME:-server}"
SERVER_FILE="${XDG_RUNTIME_DIR:-/tmp}/emacs/${SERVER_NAME}"

if [ -S "$SERVER_FILE" ]; then
    # Emacs is running, use emacsclient to launch your application
    emacsclient -e '(consult-launcher)'
else
    # Emacs is not running, fall back to ilia
    ilia -p apps
fi

If you want to use this, the important part is that SERVER_FILE points to the socket that your Emacs server uses. Make sure that emacsclient and ilia are both in a reasonable location so your shell can find them, then bind this command to whatever you usually use to launch ilia.

By the way, if you are using Regolith’s normal method of launching ilia, you can add your shell script to your Regolith configuration pretty easily. Open $HOME/.config/regolith3/Xresources in your text editor, and add the line:

wm.program.launcher.app: /path/to/your/launcher.sh

You can then run xrdb -override $HOME/.config/regolith3/Xresources and it should work! Good luck.

Drawbacks

One of the nice things about ilia is that it keeps track of applications your run frequently, so they tend to bubble up to the top of its application listing. The Emacs method doesn’t do that. I don’t mind so much, I always end up typing in application names. It is fun to use Emacs as an application launcher, and I hope that it helps me avoid the CPU-churn problem that ilia has been experiencing far too often.

Have I come up with a clever solution, or a lazy workaround? I’m looking forward to hearing your thoughts.

With 10+ years building WordPress sites, I’ve seen the same problems tank small business budgets: slow load times, security vulnerabilities, broken plugins, and sites that just stop working.

What I’m Offering

See the full list on my WordPress services page. Here is a quick rundown:

• Quick-turnaround emergency WordPress rescue
• Site speed optimization
• Security hardening
• Plugin customization

I am also available for monthly WordPress support retainers.

First-Time Client Special

Free 30-minute WordPress site audit (normally $75)

What you’ll get:

• Speed analysis with specific fixes
• Security vulnerability check
• Plugin bloat assessment
• Prioritized action plan

No obligation. Just honest feedback on what’s holding your site back.

Between the lines

I’m based in Portland, but work with businesses anywhere. Projects are priced for value and speed—not hourly rates that incentivize me to work slowly.

The bottom line: If your WordPress site is slow, insecure, or broken, you’re losing money every day. Let’s fix it this week, not next quarter.

What next?

Contact me on my WordPress services page, or using the form below.

Questions? Feel free to DM me on LinkedIn.

You can read and view the video on Prot’s website and blog, or you can go straight to YouTube, or you can watch it embedded here below.

Note that Prot is looking for people to talk to on this series! You can join in by signing up on his website.

P.S. In the video, I promised that I would do another Emacs Carnival blog post, and I will, I swear! It is in my org-mode to-do file.

Emacs Writing History

I do not know how long I have been writing in Emacs, but I have documents written in LaTeX from the early 2000s that were definitely written in Emacs, and I know those weren’t the first. I guess what is interesting about my writing experience in Emacs is how it has developed over the years. Where I originally wrote everything in plain text or LaTeX, over time I moved to org-mode and Markdown.

Writing LaTeX in Emacs taught me to view documents and writing the same way I view source code. Since all of my writing was in text formats, I could easily use version control software to store archives full of text. I began by using Concurrent Versions System (CVS), but eventually moved to Git. I have a few Git repositories with writing, but my biggest dates back to 2009. Those early commits are all LaTeX and plain text files.

commit c64500897e2509bc3316d252cda10a9119384933
Author: Erik L. Arneson <pXXX@XXX.XXX>
Date:   Sat Dec 5 10:51:06 2009 -0800

    Initial import of an old repository.

The oldest org-mode file in my writing repository dates to December 27th, 2010, and is titled “Beer and Pizza.” The commit message indicates that I pulled some writing over from another repository in this commit, so obviously I had been writing with org-mode for quite a while. I know, for instance, that “Beer and Pizza” was an article that I wrote for an early incarnation of Southern Oregon Magazine, and my notes are dated back to February of that year.

Org-mode Is A Life-changer

You have probably read other people’s experience with writing in org-mode in Emacs, so instead of sharing an exhausting list of all the life-changing, writing-improving things that it has brought me, here are a few bits that I really love about it.

It is fantastic at organizing writing projects. From being able to shift around headings and blocks of text, to combining to-do lists with writing projects, to being able to create macros and include different files—all of these things make org-mode perfect for working on medium and large projects. I write everything from blog posts to podcast scripts to books in org-mode, and it helps me stay organized.

I do not have to write in Word or Google Docs. The export functions in org-mode do a great job creating Word files, ODT files, HTML files, and all kinds of formats. If org-mode’s export abilities aren’t good enough, it can also interface with pandoc to cover all the other cases! This means I get to use all of my familiar tools and processes when writing, and I don’t have to worry about awful word processing software!

Everything I need to write can happen in org-mode! I have several websites that are built entirely out of org-mode. When I need to create slides for a lecture, I do it in org-mode. When I write adventures for Dungeons & Dragons, I do it in org-mode. When I need to whip up a spreadsheet to handle my household budget, I do it in org-mode. When I need to write a formal letter, I do it in org-mode. Frankly, it is so expressive and flexible, that I don’t need to use other tools for writing. It’s all Emacs and org-mode.

Emacs Can Be Distraction-Free

I have a hotkey connected to writeroom-mode, which plonks me right into a full-screen, distraction-free writing mode. Easy as pie! This means that when I really need to get down to business and get a lot of writing done, I don’t need to switch to a new app, leave my familiar tools behind, or go through any extra trouble. It’s just right here, built in.

No Going Back

I’ve been writing with Emacs for decades. It is my comfortable writing spot. I honestly cannot see myself abandoning it for another writing tool, because it works for me. I just used a couple of commands to check my three biggest writing repositories, and I have approximately 630,000 words written in org-mode between them. That’s a commitment!

I am aware that there are a lot of people out there using Emacs for writing, so I am excited to see what others share. I’m very pleased with Greg Newman’s choice for this second writing topic.

Edit: I realized that what I was calling my second biggest writing repository was actually my third biggest. I updated some numbers to reflect another 130,000 words of writing I found.

Some History

I recently got a Korg Volca Drums drum synthesizer. It has a sequencer that allows you to program the probability of a particular instrument playing on a particular step, and I thought that was a really cool feature. This inspired me to think about cron jobs that happen only some of the time. Maybe the cron job would run, maybe it wouldn’t.

This inspired me to write maybe, a command-line utility that returns either success or failure, based on flags you pass it. It defaults to succeeding 50 percent of the time, but you can change that. This means you could make a cron job like this, which would run do-something.sh 40 percent of the time.

# At midnight every Sunday, do something sometimes.
0 0 * * 0     maybe -chance 40 && do-something.sh

The Future of maybe

I don’t think I will stop at version 1.0.0. I have already considered what may happen to maybe in the future. Here are some things that I would like to do:

• Add cryptographically secure randomness. There is no reason to use Go’s default random library. Let us try to be as random as possible.
• More granularity to the randomness. What if you want to run something 40.5 percent of the time?
• Experiment with GitHub actions, such as building binaries for every operating system that maybe should support.

As you can see, the opportunities for improvement are many. And maybe (ha ha!) you will see improvements soon!

Perhaps this is a good time to visit maybe on GitHub and star the repo so others can find it?

Setting up a remote storage system is outside the scope of this server. Orgzly Revived works well with Dropbox, ownCloud, and nextCloud, though support for the other two is nicer as it can support automatic syncing in more situations. The Orgzly Revived documentation has an excellent description of how that configuration works.

Note that to keep things simple, I keep my Orgzly Revived files and only those files in a directory on my remote server. On my computer, the location for these files is ~/org/orgzly/, which is how I shall refer to it later on.

Configuring Orgzly Revived Auto-sync

To configure the auto-sync capabilities in Orgzly Revived, go to the settings screen in the app and then navigate to Sync > Auto-sync. Ensure that the following options are toggled on:

• Auto-sync
• Note created
• Note updated or deleted
• App started or resumed

This ensures that Orgzly Revived is constantly checking your remote storage and both fetching and uploading changes.

Configuring Emacs and Org-mode

On my computer, I want any changes that Orgzly Revived has updated to be automatically loaded into Emacs. Since I always leave Emacs running, that means it needs to detect changes on the disk for those particular files. I use two different methods to do this. First, in my init file, I have the following piece of code:

(setq orgzly-directory (expand-file-name "~/org/orgzly/"))
(add-to-list 'revert-without-query (rx bol 
                                       (eval orgzly-directory) 
                                       (+ (not "/")) ".org" 
                                       eol))

This uses the rx macro to easily create a regular expression that matches any filename ending in ".org" in the directory containing Orgzly Revived files. You may need to play around with the regular expression to get the right match. By adding those files to revert-without-query, Emacs will not bug you with extra questions and confirmations when changes are detected. However, this only works when auto-revert-mode is enabled!

At first, I thought there may be a way to enable auto-revert-mode on a file-by-file basis, but quickly realized that this could cause too many problems with creating new files in the Orgzly Revived app. Eventually, I realized that the solution would be to make a .dir-locals.el file in ~/org/orgzly/. Open that file in Emacs, and stick the following in it.

((nil . ((eval . (auto-revert-mode 1)))))

That ensures that any file in that directory will have auto-revert-mode enabled.

Once you have done this, you can add task files or inbox files in ~/org/orgzly to your org-agenda-files variable, and they will show up in your agenda views as usual.

Hopefully these instructions work for you. Please let me know if you can see any improvements or problems with the way I have implemented this. Happy task tracking!

Well, I have tweaked a WireGuard configuration until it seems to work.

I searched the Web for quite a while to find a good solution, and there seemed to be a general feeling that the MTU needed to be adjusted. Lots of people offered various solutions.

Through some experimentation, I discovered that on the client-side WireGuard configuration, the maximum transmission unit (MTU) needed to be set to 1280. Apparently this is a significant number because it’s the lowest possible MTU for an IPv6 network. Setting the MTU so low will impact performance, but if you are going through a WireGuard VPN, performance probably isn’t your biggest concern.

In the end, your client-side WireGuard configuration, which is located in /etc/wireguard/wg0.conf if you are on Linux, should look like the example below. Note in particular the MTU and AllowedIPs line.

[Interface]
PrivateKey = <your private key>
Address = <your ip address and netmask>
DNS = <your DNS server>
# This MTU line is the important one!
MTU = 1280

[Peer]
PublicKey = <your public key>
PresharedKey = <your pre-shared key>
Endpoint = <your endpoint>:51820
# This is important for client-side routing!
AllowedIPs = 0.0.0.0/0, ::0/0
PersistentKeepalive = 25

This became important to me because I’ve been shifting over to using a secure travel router when I am out and about. The router I chose to go with is the GL.iNet GL-SFT1200 Opal, and it has built-in WireGuard support that you can enable with a switch on the side. It is very cute and effective. This allows me to use WireGuard to create a VPN tunnel back to my home network, which gives me the ability to use my dual pi-hole setup from anywhere in the world!

If you have been struggling with that pesky xfinitywifi network and its weird settings, I hope this helps. It took me too long to find the right solution!

Many people have already written about why Org-mode is a good choice for this, so I am not going to. I will just mention that many years ago, perhaps around 2007, I read Getting Things Done by David Allen and got inspired to implement something like it in Org-mode. The system has slowly evolved over the years, but it has also become unweildy.

For the past few years, I had been tagging my tasks with the states TODO, NEXT, and DONE, primarily. I had some extra states sitting around for things that got canceled or delegated, and at some point I added a WAITING tag for when I needed somebody else to finish something, first. But the problem was, the TODO items really piled up. They became uncomfortable to sort through.

Inspired by a blog post by Sacha Chua earlier this week, I cleaned up my to-do states. I added STARTED and SOMEDAY, then went through the big list of outstanding items and re-evaluated their proper states. SOMEDAY won in 80% of cases, which really cleaned up the list. Now I can begin my day with a custom agenda command that looks for just NEXT and STARTED tasks, so I know what is most important. And I can end my day looking at TODO tasks to see if any should be switched to NEXT.

Here is what my configuration looks like now. First, I configure org-todo-keywords to handle the various states that my to-do items need. I am hoping that someday I’ll pare this down, but for now, this works.

(setq org-todo-keywords 
      '((sequence "TODO(t)" "NEXT(n)" "STARTED(s!)" "WAITING(w@/!)" "|" "DONE(d!)")
        (sequence "SOMEDAY(o)" "|")
        (sequence "|" "DELEGATED(g@/!)" "CANCELLED(c!)")))

I then added a “daily driver” command to my agenda to let me see the most important tasks today. This would probably be a good place for add-to-list instead of setq, but it’s just an example!

(setq org-agenda-custom-commands
      '(("n" "Next tasks" ((todo "STARTED")
                           (todo "NEXT")))

Next, after Sacha suggested it in a post on Mastodon, I configured to-do items to automatically switch to the STARTED state when I clock-in to them.

(setq org-clock-in-switch-to-state "STARTED")

Finally, I have been playing around with configuring org-stuck-projects to be more useful. I tag all of my projects with a @project tag, and then have my to-do entries underneath them as keywords. I do not think that this works as intended yet. I don’t think I will be able to figure out the proper settings here until I have another stuck project; let’s hope that never happens, and I never need this report.

(setq org-stuck-projects '("+@project/-DONE-SOMEDAY"
                          ;; Keywords to identify non-stuck projects
                          ("TODO" "NEXT" "STARTED")
                          ;; Keywords to identify stuck projects.
                          ("WAITING")
                          ""))

The only lesson that I can really hope to share with you, dear reader, is that it is a good idea to examine your task management system regularly to fine-tune it to your needs. What I have noticed is that I can come up with great task management plans, but the implementation rarely survives contact with the real world.

If, upon reading this, you have questions or suggestions, especially for org-stuck-projects, I would love to hear about it in the comments, or on Mastodon. Thank you for reading!

2024 has been a pretty weird year for me so far. I spent the first couple weeks of the year in isolation, and then Portland got hit with a Snowpocalypse (I love how that’s a regular thing now), followed by freezing rain. This is the third day in a row that the sidewalk outside my front door is basically an ice skating rink. That means it’s a great time to do some reading!

Security

• Privacy is Priceless, but Signal is Expensive [Security] I really appreciate this incredible breakdown of Signal’s costs and how they use donations. Signal is cool. You should be using it. For real.
• Breaking Laptop Fingerprint Sensors (Bruce Schneier) [Security] Do people actually use their laptop fingerprint sensors? I hate mine. I just disable the dang things and use a password.
• Surveillance by the US Postal Service (Bruce Schneier) [Security] To Catch a Thief, starring Cliff from Cheers.
• Senator Ron Wyden of Oregon opens discussion of push notification surveillance by Apple and Google (Rick Turoczy) [Security] There is some interesting legal stuff going on around the ability of tech companies like Apple and Google to use push notifications to capture user data that could be used for nefarious purposes. Definitely a story to keep your eye on!
• Holding NSA’s Feet To The Fire (jcs) [Security] Here is a second post about Senator Ron Wyden. He appears to be fighting the good fight! Go Senator Wyden!

Emacs

• Transient for convenience with emms [Emacs] Tory Anderson shares a really convenient EMMS control panel that uses the new version of transient.
• Talk to Emacs with a GPT4 Co-Worker [Emacs] Gallagher Pryor shares a method he has for speaking to Emacs using ChatGPT-4. This is from back in November, so perhaps he has a package now!
• Jeremy Friesen: Mentoring VS-Coders as an Emacsian (Jeremy Friesen) [Emacs] I really enjoyed this talk about moving people away from VS Code and toward Emacs. The big takeaway for this talk seemed to be that demonstrating what Emacs could do was going to be more effective than just arguing. Let Emacs win just by letting it do what it does.
• Jeremy Friesen: Test Driving a Campaign Status Document (Jeremy Friesen) [Emacs] This post has some superb ideas for running a TTRPG campaign from Emacs. I’ve been doing this for a while, but my documents get really messy. I need something a bit more structured.
• EmacsConf backstage: Using Spookfox to publish YouTube and Toobnix video drafts (Sacha Chua) [Emacs] I love how crazy this is: using spookyfox to work with YouTube’s crappy interface to do things to videos. Go Sacha!
• Charles Choi: Improving Emacs isearch Usability with Transient (Charles Choi) [Emacs] This is pretty cool. I recently learned about how rich the isearch feature set is, but I haven’t played around with it a ton yet. Another thing to add to my Emacs to-do list!
• William Denton: Basic citations in Org (Part 1) (William Denton) [Emacs] This is an excellent introduction to how citations work in org-mode. There are four parts in the series so far, so keep reading!

Programming

• Pike’s Rules Of Programming (jcs) [Programming] These are some good rules, even if they can make some parts of programming a little less exciting.
• Variations on styling variables in SSGs (Bryce Wray) [Programming] I am still using Sass a lot more than the vanilla CSS stuff that should be replacing it. Also, I am starting to see that this is a change I’ll need to take in my future WebDev adventures.
• Firefox on the brink? (Bryce Wray) [Programming] Bryce Wray is warning (or predicting?) that Firefox may be in a very dangerous spot in its loss of user share. This is really disappointing, given how evil Chrome continues to be. And it’s only going to get more evil. Convince your friends to run Firefox!
• Zachary Kanfer: Numberdle! (Zachary Kanfer) [Programming] This is a really fun browser game for people who enjoy numbers more than words. Move over, Wordle!!

History

Finally, here’s something fun to share with the kids.

• The Teddy Bear Was Once Seen as a Dangerous Influence on Young Children Before gifting stuffed animals to the wee ones in your life, consider that bears are dangerous!