Erik L. Arneson — Writer and Software Developer

Emacs as the Freelancer's Command Center

2026-04-10T00:00:00+00:00

Freelancing for small businesses and organizations leads to a position where you are juggling a number of projects for multiple clients. You need to keep track of a number of tasks ranging from software development to sending emails to project management. This is a lot easier when you have a system that can do a bunch of the work for you, which is why I use Emacs as my freelancer command center.

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.

Writing Experience (Emacs Carnival)

2025-07-07T00:00:00+00:00

This is my contribution to month two of Greg Newman’s Emacs Carnival. The topic this month is “Writing Experience,” which is perfect, since I write in Emacs all the time. In fact, I am writing this blog post in Emacs right now!

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.

EmacsConf 2023 Retrospective

2023-12-04T00:00:00+00:00

This past weekend was EmacsConf 2023. It was held entirely online, which was great because I could attend in my pyjamas! Since it happened on Eastern Standard Time and I live on the Pacific coast, I found the pyjama-enablement to be quite conducive to an excellent conference experience. Here are some things I learned by waking up at 5:30 in the morning this weekend!

Before getting into the good stuff, I should add that I did not spend a lot of time taking notes during the conference. Instead, I usually jumped straight into my Emacs configuration and started tinkering and fooling around. This means that I’ve probably left out some great stuff.

Emacs Advocacy

There were a couple of talks about Emacs advocacy, but the one that I paid the most attention to was Mentoring VS-Coders as an Emacsian by Jeremy Friesen. I think the big takeaway was that he got more mileage out of showing the power of Emacs than he did by trying to argue with users of other editors. Emacs users tend to already understand the power and flexibility of the tool they are using; just show it off, let it do the work.

However, another topic that was brought up in a number of talks was that having all of your projects available in the same tool seems to enable a better, richer type of thinking. Being able to both write effectively and program efficiently in Emacs helps generate more complete thoughts. It also seems to spur creativity and help people conceptualize projects better. This may be a big part of advocacy, as very few other programming editors are also good at writing and note-taking, which leads me to …

Writing

I do a lot of writing in Emacs, and I’m not the only one. James Howell gave a talk about authoring and presenting university courses with Emacs. I have also written and presented lectures and classes using just Emacs. It has the power to create slides, lecture notes, and even handouts from the same source. There were a few more great talks about writing, including another one by Jeremy Friesen (he seems to do a lot of cool stuff).

Howard Abrams talked about playing table-top role playing games (TTRPGs) in Emacs. He focused on how the pandemic had encouraged him to look into solo TTRPGs, which led him to Ironsworn. Howard then created a full Ironsworn system in Emacs that allows him to play the game on its own. I am including this under the “Writing” section because solo TTRPG play is a lot like writing fiction, it’s just that you use rules and randomness to help you figure out where the story goes. One of the best things about this talk is that the pre-recorded video was produced by his son. It looks great!

Hyper Things (Hyperbole and Hyperdrive)

I watched a talk about Hyperbole again this year. This is an Emacs package that I would really love to figure out how to use, but it just doesn’t integrate cleanly into my configuration nor my workflow. I tried it last year and got kind of annoyed at it. I gave it another try during Rob Weiner’s talk, but this time I couldn’t even get Hyperbole to properly set itself up. Anyhow, I gave up on it again. Until next year, Hyperbole!

Now Hyperdrive, on the other hand, was something new and interesting. Joseph Turner and Protesilaos Stavrou gave a talk on hyperdrive.el: Peer-to-peer filesystem in Emacs. Set up was extremely simple; it just worked. I was quickly able to share hyperdrive files and links with others. It remains to be seen what my use-case for Hyperdrive will be, but I look forward to watching this project develop.

EMMS

Yoni Rabkin gave a talk on the Emacs Multi-Media System (EMMS). I like EMMS, but I don’t use it as regularly as I should. However, Rabkin’s talk encouraged me to give it another chance. I am currently listening to Information Society in EMMS while I write this blog post. I suspect that like most people, I don’t really dig into my old MP3 collection as much as I should. This is a good excuse! Rabkin was also happy to remind the audience that EMMS can handle streaming online music sources and playing pretty much every kind of media. It’s worth exploring EMMS again!

Overall Impression

I loved EmacsConf this year. I also loved it last year. The organizers and moderators did such a great job running this conference, and it seemed to have a lot of attendees. I followed along on IRC and on Mastodon, and there was a ton of great talk happening. In addition, the Q&A sessions that I saw were filled with enriching conversation. I’m really looking forward to next year. Maybe I’ll find something on which to present!

FOSSY 2023 was Excellent

2023-07-18T00:00:00+00:00

This past weekend, I had the pleasure of attending the inaugural FOSSY conference in my home town of Portland, Oregon. FOSSY focuses on free and open source software, and included tracks on community, containers, compliance, diversity, gaming, and education. I got a chance to connect with friends and make new friends. It was an excellent event, and in this post I’ll just focus on some highlights.

Writing and Machine Learning

Software developers may get a lot of attention in FOSS spaces, but a lot of different types of contributions are required to create a successful open source project. The most significant contributions I’ve made to a large open source project have been writing for Kubernetes. Projects also need community leaders, software architects, web designers, publicity and marketing experts, and quality assurance technicians. There is plenty of space for additional contributions in almost every open source project.

FOSSY had some excellent sessions on writing, both from the point of view of a contributor to open source projects, and in examining how various open source projects can help the writer. Paco Nathan gave a very informative talk about language tools available for creators, focusing on machine learning, graph technology, and natural language processing. I also really enjoyed Kyle Davis’s talk on writing for open source projects. He discussed issues of style guides, adjusting your writing voice, and differentiating between marketing copy and open source writing.

Containers, Containers, Containers

The Container Days track was deeply technical and educational. I didn’t get to attend as much of this track as I would have liked, because there was too much to focus on across the conference. However, I did manage to catch Josh Berkus’s excellent talk, “The Cloud Native Burrito.” In it, Josh explained the composition of a fully cloud-native application using a delicious metaphor. Kubernetes is the tortilla of your application, while other essential components such as your container runtime and virtual network are the rice and beans. The metaphor went on—and yes, it was before lunch—until eventually though your stomach rumbled, Kubernetes made more sense.

There was also a talk on Development Containers that I really wanted to attend, but there was just too much!

Open Source Philosophy

The most thought-provoking talk I attended was “FOSS in World Affairs” by Delib. This talk deconstructed the philosophy of open source until it could be applied more broadly to larger social issues such as abuses of capitalism and the breakdown of social contracts. It generated a ton of discussion, including talk about how a corporation could be completely open-sourced, in a way that would welcome both collaboration and competition. I came away from this talk with a lot to think about.

I also attended a talk by Keith Bergelt on mitigating patent risks in open source projects. He introduced me to the Open Invention Network, which I feel I should have known about before. This organization seeks to cushion large open source projects from patent litigation through various means such as building a “patent non-aggression community”. Bergelt was careful to point out that there are plenty of companies out there who seek to stall open source by leveraging patents.

Conclusion: Do it Again

FOSSY was great. I hadn’t attended an open source conference in years, and it was really enjoyable to be around so many like-minded nerds. I hope they do it again next year! I’ll endeavor to attend again.

Update: Org to DOCX with Citations

2023-06-20T00:00:00+00:00

Last year, I wrote about converting Org to DOCX with pandoc. Well, that particular method has needed some improvements. I needed to also support converting Markdown files, and more vitally, I needed to support the new-ish org-cite citation format.

The first thing I did was update to the latest version of Pandoc. Next, I had to learn how Pandoc’s citations work. Note that you have to enable the citations extension as well.

For citations to work, you need to have a Citation Style Language (CSL) file. Zotero comes with a ton of them, so check your Zotero installation for examples.

In the updated fish shell function below, you will want to update both refdoc and csldoc to point to your reference DOCX file and your CSL file, respectively.

function org2docx --description 'Generate a DOCX file using a custom reference document'
    set -l refdoc "$PATH_TO_REFERENCE_DOCX"
    set -l csldoc "$PATH_TO_CSL"
    set -l fromfmt (string match -r '(?:org|md)$' $argv)
    set -l base (basename -s .$fromfmt $argv)

    echo Generating $base.docx ...

    pandoc --from "$fromfmt"+citations \
        --citeproc --csl $csldoc \
        --reference-doc $refdoc -o $base.docx $argv
end

And there you have it! Now you can convert both Org files and Markdown files to DOCX. And I am sorry that you have to use DOCX!

Writing and Reviewing Jupyter Notebooks

2023-05-18T00:00:00+00:00

A recent project involves delivering a finished product as a collection of Jupyter Notebooks. This process involves using Emacs for writing, Git for version control, and a slightly tricky process for enabling non-Jupyter, non-Emacs users to perform document review.

Writing—just like programming—ideally includes a review process before anything is delivered to the client. Even first drafts need at least two readers before delivery. I’ve previously discussed how I use Org Mode and Pandoc to deliver DOCX files, and DOCX or ODF files unfortunately remain the easiest way to track changes and edits among word processor users.

Since Jupyter Notebooks are basically JSON documents, the best way to keep track of changes and revisions is using some kind of version control. Here is one process using Git and GitHub.

When my notebook files are ready for review, converting them to DOCX files is pretty straightforward.

First, I use the jupyter command line tool to convert to Markdown, like this:
```
jupyter nbconvert --to markdown *.ipynb
```

Next, I use Pandoc to convert to DOCX using a reference link.

for file in *.md
    pandoc --reference-doc $path_to_refdoc -o $file.docx $file
end

Renaming files with Dired

At this point, I needed to rename all of the DOCX files and move them to the proper shared folder, so my reviewer could get to them and know what’s going on. We have a naming format for filenames that helps us track project and versions, so all of the files needed to have at least a v1 in them.

Emacs has a file manager called Dired, which contains powerful features that allow you to modify directory contents just like any other buffer. I now had a bunch of files that ended in .md.docx that needed to instead end in -v1.docx. Here is the process I used to easily rename them.

In Emacs, use M-x dired to open the directory.
Use C-x C-q to run dired-toggle-read-only.
Use M-% to run query-replace, and replace .md.docx with -v1.docx.
Finish “writing” the directory with C-c C-c.

All done! It was nice and simple. The DOCX files were finally properly named and ready for review.

An Org-mode to DOCX Pipeline

2022-10-26T00:00:00+00:00

Freelance writers need to deliver documents in the format requested by clients. However, frequently the requested format is not the writer’s preferred working format. I like to write in Org Mode, but many clients prefer delivery in Microsoft Word’s DOCX format.

This is how I generate DOCX files for my clients.

What is Org Mode?

Org Mode is an Emacs package for writing and working with Org files. Org files are highly structured plain text files that may appear to be a text outline, but can do so much more. Org Mode is incredibly versatile, and can be used to track projects, manage schedules, write outlines, and even create documents.

Choosing between Org Export and Pandoc

Org Export runs inside Emacs and is capable of converting Org files to a variety of other formats. While it is very powerful, it also has its idiosyncrasies. For instance, when converting Org files to DOCX files, it uses its own style names such as “Org Title” and “Org Heading 1”.

A second option for converting Org files to DOCX files is Pandoc. Pandoc prides itself on being the Swiss army knife of document format conversion. It handles an impressive variety of document formats and handles a dizzying collection of configuration options.

Since the DOCX files that I create need to be shared with other writers, editors, and reviewers, I need to make sure that they are easy to work with. This influenced my decision. Since Pandoc uses more standard style names, I decided to use it for Org conversion.

Setting up Pandoc

To use Pandoc to generate nice looking DOCX files, you will need to configure a template document. The recommended method for doing this is to generate a default template using Pandoc, and then edit it in Word. I used LibreOffice Writer for this, and it worked just fine.

Install the latest Pandoc using these instructions.

Run the following command to generate reference.docx

pandoc -o custom-reference.docx --print-default-data-file reference.docx

Open reference.docx in your word processor and edit the styles so they meet your needs.

Converting from Org to DOCX

One option for running the conversion is to take advantage of the ox-pandoc package for Emacs. If you will always be using the same configuration for your exports, this is a great option.

However, I need to use a number of different configurations for converting documents, so I tend to run Pandoc from the command line. Recent versions of ox-pandoc support passing options via Org headers, but I still haven’t bothered to set that up. It should be very easy to template this using Yasnippet, though.

I use a custom fish shell function that looks like this:

function org2docx --description 'Generate a DOCX file using a custom reference document'
    set -l refdoc "$PATH_TO_REFERENCE_DOCX"
    set -l base (basename -s .org $argv)
    echo Generating $base.docx ...
    pandoc --reference-doc $refdoc -o $base.docx $argv
end

From my fish shell command line, I can then just run org2docx whatever.org to generate whatever.docx.

I have not found a level of automation that makes my converted DOCX files completely perfect, unfortunately. After conversion, I always open the new file in my word processor to make final tweaks and fixes.

Have fun converting files!

The method I’ve outline in this blog post is straightforward and fits my needs. There are definitely improvements to be made, such as using templates to pass the proper options to Pandoc. Switching to ox-pandoc would mean one fewer reason to leave Emacs, after all.

In recent years, more and more clients are asking for files to be delivered via Google Docs. So far, I have yet to find a good conversion pipeline to get Org files into Google Docs easily. My method right now takes too many manual steps. That’s a problem I would love to solve.

Do you have a conversion pipeline for documents that works for you? Leave me a comment and let me know!

Yasnippet and Emacs for Writing

2022-09-28T00:00:00+00:00

As a freelance writer, I need to be ready to deliver high quality copy in a timely fashion. My editor of choice for writing is Emacs. I have found that Yasnippet templates have streamlined my writing process.

What is Yasnippet?
Installing Yasnippet
Markdown and Jekyll
- Bonus Snippets
Org Mode Templates
- org2blog and Podcast Show Notes
- More Bonus Snippets
Writing Faster is Writing Smarter

What is Yasnippet?

As a templating system for Emacs, Yasnippet is well known by programmers. It can quickly expand function definitions, control structures, and other templates into blocks of source code. Source code is just text.

Since most of my writing originates in text format, templates are great for speeding up document creation and avoiding common errors and omissions.

Installing Yasnippet

With use-package, you can get started quickly with Yasnippet by including the following in your Emacs init file.

(use-package yasnippet
  :ensure t
  :config
  (yas-global-mode 1))

(use-package yasnippet-snippets
  :ensure t
  :after yasnippet)

For more detailed installation instructions, check the Yasnippet documentation.

Markdown and Jekyll

This blog is primarily written in Markdown for Jekyll, which means that each file needs a YAML block at the top with specific information. I have a template that looks like this:

# -*- mode: snippet -*-
# name: blogtop
# key: blogtop
# --
---
title: ${1:Title}
author: "Erik L. Arneson"
layout: post
permalink: `(format-time-string "/%Y/%m/")`$2
comments: ${3:$$(yas-choose-value '("true" "false"))}
tags:
    - $4
---

$0
<!--more-->

Not only does this template save me from needing to remember the format of the YAML block, but it ensures that frequently forgetten items are included, such as the permalink setting and the  tag.

Bonus Snippets

The official snippet collection contains a bunch of extra Markdown templates. Check them out here.

Org Mode Templates

My Org Mode files are more complex. Many writing clients expect deliveries in Microsoft Word files, but I also frequently find myself needing to produce OpenDocument files, HTML, and even Markdown. The headers for these files need to support all of these options.

I use the following template to support all of the Org Mode configuration and options I require.

# -*- mode: snippet -*-
# name: header
# key: header
# --
#+TITLE: $1
#+LANGUAGE: ${2:en}
#+AUTHOR: ${3:$$(yas/choose-value '("Erik L. Arneson" "Some Other Name"))}
#+EMAIL: ${4:$$(yas/choose-value '("list-of-email-addresses"))}${5:
#+DESCRIPTION: $6}${7:
#+KEYWORDS: $8}
#+OPTIONS: num:nil toc:nil
#+ODT_STYLES_FILE: ${9:$$(yas/choose-value '("list-of-template-files"))}
#+bibliography: /path/to/MyLibrary.bib
#+cite_export: csl ${10:$$(yas/choose-value '("chicago-fullnote-bibliography.csl" "modern-language-association.csl" "apa.csl"))}
#+WWG: ${11:$$(yas/choose-value '("0" "250" "500" "1000"))}

$0

org2blog and Podcast Show Notes

I also use Org Mode to publish to WordPress websites using org2blog. For one of these websites, I write show notes for podcast episodes. I use a template that looks like this.

# -*- mode: snippet -*-
# name: podcast
# key: podcast
# --
* $1
  :PROPERTIES:
  :POST_TAGS: $2
  :BLOG:      arnemancy
  :CATEGORY:  Podcast
  :POST_DATE: `(format-time-string "[%Y-%m-%d %a %H:%M]" nil nil)`
  :END:

$0

** Links

** Credits

#+begin_export html
Support me on Patreon: <a rel="payment" href="https://www.patreon.com/arnemancy">https://www.patreon.com/arnemancy</a><br>
#+end_export

This template reminds me of important items I need to include in all show notes, like links, credits, and a Patreon link.

More Bonus Snippets

The official snippet collection also contains a bunch of Org Mode snippets. Here is the whole list. Since Org Mode contains so many complicated structures like source blocks and optional keywords, these are great time savers. There are also snippets for supporting org-reveal.

Writing Faster is Writing Smarter

Don’t let your tools get in the way of your writing. Frequently, Emacs is portrayed as cumbersome and filled with obscure keybindings and weird commands. However, I have found that it is an excellent tool for writing. Yasnippet templates let me get started on new documents quickly without fretting over different syntaxes for configuration.

And Yasnippet is just one of the tools I use when writing with Emacs. I will discuss more of these tools in the future.

Slides on a Stick with Raspberry Pi Zero W

2017-10-15T19:38:19+00:00

If you give presentations often, you will know that one of the biggest headaches is managing slides. You have to figure out software, hardware, and connectors. I’ve usually resorted to bringing a USB thumb drive with my slides in PDF and ODP format, but then I came across an even better idea: the Raspberry Pi Zero W (or RPi0W).

Previously, I had been playing with using Erlang on the RPi0W to control stepper motors, but this seemed more useful. Follow along to see how I created a portable presentation machine that’s about the size of a pack of gum.

Hardware Used

I purchased the RPi0W as part of a kit so it would have a nice case and all of the connectors I needed. I also wanted a good way to control it, so I found an inexpensive mini wireless keyboard and mouse on Amazon. You can follow my example or find your own alternatives.

Installing and Configuring Software

I’m not the first person to think of using a Raspberry Pi for slides and presentations. Rob Reilly wrote a great article on this topic for Raspberry Pi Geek which provides some great tips and recommendations. However, I wanted to create a presentation machine that was even faster and more portable.

I used Raspbian Stretch with Desktop, but knew that I would run into memory and performance issues on the RPi0W. It only has 512MB of RAM, so I would need to use small, efficient applications and cut out unnecessary services and applications on the device. It’s really important that the machine boots up fast and gets running quickly.

Quickly I gave up on the idea of running LibreOffice Impress. Instead, I would use a lightweight full-screen PDF viewer. I tested out a number of the smaller PDF readers available on Raspbian before finally settling on apvlv. This reader is tiny, fast, and configurable. It also requires some additional setup.

Install apvlv on your system with the following commands.

sudo apt update && sudo apt upgrade -y
sudo apt install -y apvlv

These commands might take a while. When you are done, edit the apvlv preferences file. You will probably do this using the command nano ~/.apvlvrc but you might want a different text editor. Edit to look like this.

set fullscreen = yes
set zoom = fitwidth
set continuous = no
set scrollbar = no
set content = no

Displaying Slides

You will need to get your PDF slides onto the RPi0W. I usually use a webpage to download them, or copy them over via scp. Do whatever feels best to you.

Simply use the apvlv command from a terminal or the menu to load your PDF file. The interface is a little arcane, but easy to get the hang of. You can use the up and down arrows on the mini keyboard to go forward and backward one slide. To exit, hit q and to go to a specific slide type :go <number> and replace “<number>” with the slide number.

The RPi0W still takes a little while to boot, but you now have an extremely portable device that plugs into any HDMI screen or projector and displays your slides with as little fuss as possible!

CenturyLink AppFog Tutorial

2016-01-15T17:26:41+00:00

Recently I wrote a tutorial with Word Lions for CenturyLink Cloud that teaches how to build and deploy a Node.js application to CenturyLink AppFog. The tutorial and application were really fun to build and write. It was my first Node.js project, and my first experience with CloudFoundry. The tutorial uses the following CenturyLink Cloud products:

AppFog is CenturyLink Cloud’s CloudFoundry system. It is really powerful, and it appears to be more flexible than Google App Engine.

Read the Tutorial

The tutorial walks you through building a document storage system with a built-in PDF reader and comment storage. It also includes user authentication and some other neat Node.js tricks. You can follow the tutorial from the following links, which will include all of the information needed to get you up and running on AppFog with Node.js. Enjoy!

Now Working with CommerceCollective!

2015-05-26T15:02:27+00:00

I am now working with my good friends at CommerceCollective! CommerceCollective is a web presence management company located here in Portland, Oregon, and they are great at SEO and social media stuff. They also are really talented web designers. If you’re looking for a full website solution, from design down to the nuts and bolts, we are the place to go.

I’ll be supplementing their services with full-stack web development, IT consulting, and a little bit of copy writing. Read more about our team here!

Successful Article: Symbolism in Masonic Rings

2014-11-17T17:16:59+00:00

I just checked Google Analytics, and over the last 18 months, my online article “Symbolism in Masonic Rings” has had over 6,000 page views. That’s excellent!

If you’re interested, you can read it on Transformason.org. Please excuse the website. There’s a reason I outsource web design tasks.