Erik L. Arneson — Writer and Software Developer

Process Automation for an Oregon Charitable Foundation

2026-05-22T00:00:00+00:00

The Oregon Scottish Rite Education Foundation awards scholarships annually to students across Oregon who are entering into college or trade schools. Over the past few years, their foundation has grown, requiring them to distribute more scholarships than ever. However, since the foundation board is small and composed entirely of volunteers, they were looking for some way to automate their application process to reduce the number of manual steps required.

Initial Approach

Members of the board approached me with a wish list of features and requirements. They wanted a system to integrate seamlessly with their website, while incoming applications should be automatically checked, sorted, and categorized by county. They already had a spreadsheet system for tracking applicants as well as a cloud storage system for storing supporting documents; they wanted the automation system to integrate with these existing components.

Since the board was already utilizing Google Business products for cloud documents and storage, I decided that the best approach would be to lean into Google Cloud services. Following their list of requirements, I implemented a Google Cloud Run service in Go that processed incoming applications from their website, then updated the spreadsheet while preparing their cloud storage system for each application’s supporting documents. The spreadsheet now contained all the application data, including a link to an automatically generated PDF version of the application and a link to the cloud storage location.

This initial approach cut out an enormous amount of manual work. Previously, applications were submitted via the website and emailed to a board member, who then manually sorted them by county and generated PDFs for storage and later distribution.

Implementation Challenges

The application submission window for the Oregon Scottish Rite Education Foundation runs from December through March of each year, which gave us a limited amount of time to observe incoming live data and how the automation was performing.

My initial approach worked fairly well, and handled 94% of incoming applications properly. However, the last 6% ran into various problems that prevented correct processing. One error arose from a misspelling in a county name, which was caught early and corrected. Another series of errors arose from processing errors with the Google Sheets API, which has both rate limiting and more mysterious, inexplicable errors. I added additional error correction and error checking, but there was still some additional manual work to enter data from a handful of applications.

By the end of the application period, we had managed to reduce the amount of manual data entry and processing by a large percentage, maybe as much as 60%. After discussing the current process automation with the board, we began to see opportunities for further automation and improvement.

Additional Development

After the first year’s application submission window, I began working with one of the board members to plan out how the process could be improved even more. My list of improvements were primarily on the backend, and involved robuster error detection and reporting, as well as a backup data store that would allow the automation to recover from the Google Sheets API errors more elegantly.

The board proposed an additional feature set that would further reduce manual data processing, by allowing applicants to upload supporting documents such as letters of recommendation and high school transcripts. These uploaded documents would then be processed and stored in the proper cloud storage location, thus reducing the amount of manual file management required by volunteers.

Implementing these two new features went very smoothly. It required the development of a new frontend, using Typescript and Svelte. This frontend allowed applicants to upload their supporting documents via a unique link given to each of them by automated email. It used both Google Cloud Storage and the Google Drive API to store these files.

The improvements on the backend used Google Cloud Datastore and a more robust error recovery system. It now backed up all incoming scholarship applications until they could reliably and more slowly be added to the spreadsheet with the Google Sheets API, thus nearly eliminating all rate limiting errors. In addition, progress reports and error output could now be viewed using a new frontend administrative interface.

Results

This round of improvements produced significant results. Over the entire span of the second year of application submissions, error rates dropped from 6% to just one unrecoverable error. While I had been hoping for improvement, even I was surprised by how much of an improvement we achieved!

The board reported that the amount of manual processing was reduced by another 80-90%, with only a few applicants resorting to email for sending in their supporting documents. While we have discussed further improvements to the process automation for the next application submission window, the board is satisfied with the improvements provided by the level of automation implemented so far.

Lessons

This project benefited a lot by reviewing requirements and expectations frequently with the client. They were great at providing me with very clear goals from the beginning, and as we progressed and it became clear where the most volunteer time was being spent, we were able to identify more tasks for automation.

On the development side of things, three things were clear. First, cloud services really make the development and deployment of process automation tools like this a breeze. Costs can be kept low while still providing robust infrastructure for hosting.

Second, I learned once more the importance of unit tests. I wrote unit tests for most elements of the automation software, which allowed me to catch breaking changes and test features very quickly. Test-driven development can be a great way to run a project, and though I did not follow all of its parameters strictly, that particular philosophy did guide my decision.

Third, once more I was reminded of how the best-planned software runs into difficulties when it collides with the real world. I failed to anticipate the Google Sheets API issues and did not implement enough comprehensive error correction early on. That is not an error I shall repeat again!

Finally, I learned that even with a project that seems as straightforward as this one, it is important to control expectations early. This turned into a multiyear project because we saw room for improvement. I think it is important for a business or organization looking for process automation to understand that it can be an ongoing series of improvements; not everything will be accomplished or perfected after one pass.

Overall, I found this to be a rewarding project. I enjoyed working on software that was aiding a good cause: helping high school graduates fund their education. It was also very nice to work for a charitable foundation instead of a for-profit business; it made all of my programming feel a lot better. I hope to work for more charitable foundations in the future.

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.

An Emacs Application Launcher for Regolith

2025-11-19T00:00:00+00:00

I run the Regolith Desktop Environment on my laptop, which I love because it provides a convenient GNOME wrapper and interface for the i3 tiling window manager. Regolith relies on a program called ilia for application launching, and sometimes ilia gets caught in some kind of CPU-churning state that locks up my whole system. I have not been able to figure out what is causing it, so I (of course) turned to Emacs for a solution.

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.

Interviewed on "Prot Speaks"

2025-08-18T00:00:00+00:00

Well-known Emacs package creator Protesilaos Stavrou interviewed me for his video podcast series, “Prot Asks.” We talked about a wide variety of topics, from Emacs to podcasting to Portland to public transit. I thought it was a great time, and perhaps you will like it, too!

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.

maybe: A command-line tool that succeeds sometimes

2025-02-13T00:00:00+00:00

I just released version 1.0.0 of maybe, a command-line utility that succeeds some of the time. It is written in Go and is not very many lines of code, but I do hope that it can be useful for people.

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?

Many Posts of Interest for January 2024

2024-01-18T00:00:00+00:00

Once again, I have collected far too many links over far too long a period of time. Anyhow, here is a collection of blog posts and links from around the web that I found to be good reading over the past couple of months. Is it too late in January to say Happy New Year?

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!

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!

Posts of Interest for November 2023

2023-11-16T00:00:00+00:00

I was planning to make posts like this more regularly, but I entered into a period where I was thinking, huh, I am not collecting very many links. But I was wrong, I was collecting links. I collected too many. And now look at everything you have to read! I am sure these links will keep you occupied for a while.

Security

Tech CEO Sentenced to 5 Years in IP Address Scheme (BrianKrebs) [Security] This is an interesting story: five years in prison for stealing IP addresses! I guess you shouldn’t do that.
Defense in depth: Layering your security coverage (Sue Poremba) [Security] Security isn’t just at the edge. Layers are very important, as this article reminds us.
How The Thompson Hack Worked (jcs) [Security] Aaaah! This is an amazing look at Ken Thompson’s 1983 Turing Award lecture. How can we trust software? Do we trust software? You’ll enjoy this one and it will tickle your inner computer nerd.
Pentesting vs. Pentesting as a Service: Which is better? (Josh Nadeau) [Security] What is pentesting and how does it work? Well, now you can know.

Emacs

Whatever happened to Guile-based Emacs? [Emacs, Mastodon] This thread on Mastodon has some insights into what ever happened to a Guile-based Emacs.
Andrey Listopadov: You don’t need a terminal emulator (Andrey Listopadov) [Emacs] Andrey Listopadov explains how he stopped using a terminal emulator because he’s all about that Emacs. Nice!
Emacs Line Wrapping (jcs) [Emacs] For several years, I have been dealing with a line-wrapping annoyance in Emacs that I just couldn’t figure out. It turns out it was filladapt, a package that apparently isn’t used often anymore, but I hadn’t noticed. I disabled the package and everything just works the way I want it to. Arrrgh!
Does Working From Home Damage Productivity? (jcs) [Emacs] I have mostly worked from wherever-I-want for the last 14 years, and I’d have it no other way.

Games

Kensett: A Free 19th Century Urban Cartography Brush Set for Fantasy Maps (K. M. Alexander) K.M. Alexander shares a lot of cool brush sets for creating maps for fantasy games. I have been trying to figure out how to use them, and this one really caught my eye. Check out all of their brush sets!
Lovat’s Genesis: City of Darkness (K. M. Alexander) I am once again running a D&D game, with a homebrewed campaign, so I think it will be fun to include a few RPG-related posts every once in a while. Seeing how others get their inspiration is really helpful when I need to find some of my own.

History

The Silent Treatment: Solitary Confinement’s Unlikely Origins [Pub 20231101] A very curious history of solitary confinement and its origins, presented by the Public Domain Review. This is worth a read.
What Emoji Tell Us About the History of Tea I love the strange history of tea, and the Smithsonian has managed to tie this history to tea emoji. So that’s cool.
Divide and Concur: A Radical Plan for Peace in Europe (1920) [History] This is an amazing and bizarre plan for bringing peace to Europe in the 1920s. It is worth looking at and puzzling over.

Posts of Interest for 13 October 2023

2023-10-13T00:00:00+00:00

This is the second of my “posts of interest” posts. This week, I have also included some interesting Mastodon posts, because the Emacs community on Mastodon is thriving like crazy. It is really a blast to see so much interest in Emacs and so much activity.

If Mastodon interests you, find me there!

Programming (1)

Scheme in the browser: A Hoot of a tale – Spritely Institute Yes, SCHEME IN THE BROWSER. This is pretty cool, go check it out.

Emacs (6)

Text showdown: Gap Buffers vs Ropes [Programming, Rust] Troy Hinckley has been working on building the core of Emacs in Rust. This sounds like a very difficult project, and it is informative and interesting to follow along. The latest entry in his saga involves various ways of storing and working with text buffers, along with many benchmarks. This is an interesting read!
ELPA and Emacs Zine (September 2023) The new ELPA and Emacs Zine has released its latest issue, with some pretty interesting stuff about the current state of tree-sitter and how development is progressing.
Emacs Macros [Mastodon] Emacs macros remain kind of a mystery to me, but they were presented in an interesting way recently: these are ways to provide a high level of automation in Emacs without learning how to program Emacs Lisp. Well, they are worth checking out, then!

Taking advantage of tree-sitter [Mastodon] This is a really cool Emacs function that takes advantage of tree-sitter to copy the current function. I think it might need something to detect if tree-sitter is active, and error out if not.

(defun my-copy-function-name-with-ts()
  (interactive)
  (let ((funcname
         (substring-no-properties
          (treesit-node-text
           (treesit-node-child-by-field-name (treesit-defun-at-point) "name")))))
    (kill-new funcname)
    (message "Copied name: %s" funcname)))

XMPP in Emacs [Mastodon] Fabio Natali on Mastodon reports that his XMPP usage would be more consistent if Emacs supported it better. In particular, he misses E2E encryption support. I’ve also had a lot of difficulty with moving to XMPP.
Alex Schroeder: Posting to Oddµ from Emacs (Alex Schroeder) Alex Schroeder provides a simple, straightforward way to use the url package in Emacs to post stuff to another service. In this example, he uses Oddμ.

Security (4)

C-suite weighs in on generative AI and security (Chris McCurdy) More on the adoption of generative AI and security risks. 96% of business leaders say adopting generative AI makes a security breach likely in their organization within the next three years! That’s certainly something to think about.
10 years in review: Cost of a Data Breach (Jonathan Reed) Data breaches are dang expensive! We all know that. This piece explores some of the most important factors in preventing and mitigating data breaches. There have been some changes in recent years, some of which are caused by the rise of importance in AI. That means you should probably read the article.
The fraud was in the code (Molly White) In the SBF court case, they actually used a code review to show fraud.
Bounty to Recover NIST’s Elliptic Curve Seeds (Bruce Schneier) Here is a delightful story about the history of NIST elliptic curve cryptography and how things came to be. Also, a cryptographic puzzle about where they may be going!

Posts of Interest for 6 October 2023

2023-10-06T00:00:00+00:00

This is my first attempt at using elfeed-curate to collect interesting blog posts and share them. I have also attempted to subscribe to the RSS feed for the #Emacs hashtag on Mastodon, but that doesn’t seem to be working correctly yet. I’ve seen other blogs do similar things, but is this useful for my blog? I don’t know! Let me know what you think.

Computers (4)

The intriguing announcement of Cloudflare Fonts (Bryce Wray) [Programming] Oooh, this is cool. Bryce Wray talks about the introduction of Cloudflare Fonts!
What to know about new generative AI tools for criminals (Mike Elgan) [Security] Generative AI is still a minor concern for security professionals, but the threat is rising! This is an interesting look at the state of the art and current means for addressing the threat.
Alex Schroeder: 2022-03-20 Torchbearers and bodyguards (Alex Schroeder) [Emacs] Alex Schroeder continues his exploration of running tabletop RPGs using Emacs. Check out the other blog posts in the series—they are a lot of fun. I have been playing with Emacs for running TTRPGs, as well. Someday I’ll explain my methods.
Elfeed-curate (jcs) [Emacs] Elfeed-curate sounds like a really neat package. This is my first annotation using that package, which I will soon attempt to export.

Portland (1)

Tour of Untimely Departures – SOLD OUT! (lfadmin) The Tour of Untimely Departures is an annual event at Lone Fir Cemetery in Portland. But guess what? It’s already sold out! It sold out a while back, but I didn’t notice because my RSS feed for the Friends of Lone Fir was broken.

Configuring Emacs 29.1 for Go Development

2023-08-01T00:00:00+00:00

Now that I have installed Emacs 29.1, I needed to get it set up for Go development for a project. I was interested in taking advantage of both the new Tree-Sitter integration, and the new Eglot language server client. However, they were mildly tricky to set up! Here is what I did.

Configuring Tree-Sitter for Go

If you follow the excellent How to Get Started with Tree-Sitter instructions from Mickey Peterson, you will have a great head-start on getting Tree-Sitter working for most of your favorite languages (and probably Java, too). However, those instructions didn’t cover everything I needed for Go. When I tried running M-x go-ts-mode, Emacs complained about a missing gomod module. Baffling!

I couldn’t find any information in the Emacs documentation about where to find this missing module. I looked around on the net and found Camden Cheek’s tree-sitter-go-mod, and added that to my list of recipes. My treesit-language-source-alist then looked like this:

(setq treesit-language-source-alist
 '((bash "https://github.com/tree-sitter/tree-sitter-bash")
   (cmake "https://github.com/uyha/tree-sitter-cmake")
   (css "https://github.com/tree-sitter/tree-sitter-css")
   (elisp "https://github.com/Wilfred/tree-sitter-elisp")
   (go "https://github.com/tree-sitter/tree-sitter-go")
   (gomod "https://github.com/camdencheek/tree-sitter-go-mod")
   (dockerfile "https://github.com/camdencheek/tree-sitter-dockerfile")
   (html "https://github.com/tree-sitter/tree-sitter-html")
   (javascript "https://github.com/tree-sitter/tree-sitter-javascript" "master" "src")
   (json "https://github.com/tree-sitter/tree-sitter-json")
   (make "https://github.com/alemuller/tree-sitter-make")
   (markdown "https://github.com/ikatyang/tree-sitter-markdown")
   (python "https://github.com/tree-sitter/tree-sitter-python")
   (toml "https://github.com/tree-sitter/tree-sitter-toml")
   (tsx "https://github.com/tree-sitter/tree-sitter-typescript" "master" "tsx/src")
   (typescript "https://github.com/tree-sitter/tree-sitter-typescript" "master" "typescript/src")
   (yaml "https://github.com/ikatyang/tree-sitter-yaml")))

Note that the package is named go-mod but go-ts-mode expects it to be named gomod. I wish this were documented somewhere! In any case, I was then able to use M-x treesit-install-language-grammar for both go and gomod. Finally, M-x go-ts-mode worked!

After going through this process, I found Robert Enzmann’s post about automatically using Tree-Sitter. He has created the treesit-auto package, now available on MELPA, that does most of this work for you. It is a much faster way of solving the gomod mystery, so give it a shot!

Configuring Eglot for Go

I’d been using lsp-mode for ages, but with Emacs 29.1 including Eglot, I decided to make the switch.

In my Go project, I ran M-x eglot and was immediately met with an error:

[eglot] Server reports (type=1): Error loading workspace folders (expected 1, got 0)
failed to load view for file:///path/to/my/project: err: go command required, not found: exec: "go": executable file not found in $PATH: stderr: 

I’ve got Go installed in /usr/local/go, and /usr/local/go/bin is definitely in my exec-path variable in Emacs. It looked like Eglot wasn’t propagating exec-path down to its subprocesses. How annoying! I did a quick search through the list of Eglot-related variables and the Eglot documentation and no solution seemed immediately forthcoming.

So I took the cheap way out and made a symlink. In my shell, I ran:

sudo ln -sf /usr/local/go/bin/go /usr/local/bin/go

It is a dumb trick, and I am sure there is a better way to solve it. Do you know of one? Please comment and let me know!

What Else?

My exploration has revealed that there’s a lot of work left to do in the Emacs Tree-Sitter world. There are plenty of languages major modes that don’t yet have a ts-mode equivalent, and plenty of others that still need a lot of work.

It’s too soon for me to say if this setup is preferrable to my previous configuration. But I am really looking forward to playing around with Eglot’s features and exploring the capabilities of Tree-Sitter.

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.

Pattern Matching and Tail Recursion in Emacs Lisp

2022-11-19T00:00:00+00:00

Functional programming offers a bunch of really cool programming patterns. Two that I really enjoy are tail recursion and pattern matching, especially how they are implemented in OCaml. However, I spend a lot of time writing Emacs Lisp now, and I was wondering if I could find a way to use these patterns in that language.

It turns out that it is possible, thanks to named-let and pcase. It isn’t as pretty and elegant as OCaml, but at least I get to keep excercising those parts of my programming brain. Maybe next I’ll try to figure out currying in Emacs Lisp.

Note that this blog post includes some really dumb examples, because that’s usually how I learn these things best.

Pattern Matching with `pcase`

Most programmers will be familiar with the granddaddy of pattern matching, the switch/case construct. This is present in many, many programming languages, especially those in the ALGOL family.

However, pattern matching can be so much more! Instead of simple equality checks, pattern matching extends the switch/case concept to include testing for all kinds of patterns and conditionals.

Lisp programmers will already be familiar with cond, which can be used to sequentially test for conditionals. However, functional language programmers have probably fallen in love with a more mature and sophisticated form of pattern matching that cond doesn’t totally satisfy.

Fortunately, Emacs Lisp has pcase, the pattern-matching conditional. Here is an example of its use to duplicate car, which is the dumbest possible example I could think of.

(defun ela/car (lst)
  (pcase lst
    (`(,head . ,_)
     head)
    (_
     nil)))

You can see that pcase has a backquote syntax for matching various constructs, such as with the `(,head . ,_) piece. This matches a cons cell and binds the CAR to head while ignoring the CDR.

The next case is just _, which is a catch-all matching operator.

In the real world, you’d probably want some type checking and error correction, but I promised very simple examples. Check out the full range of matching capabilities for pcase, and then read about all of the backquote patterns you can also use.

Tail Call Optimization with `named-let`

Tail call optimization (TCO) is the programming language feature that allows efficient tail recursion without overflowing your stack. It is increasingly common in languages today, though from what I’ve seen, it always involves caveats.

In Emacs Lisp, the easiest way to use TCO that I’ve come across is the named-let macro. With it, you define a function that can get “unrolled” inside another function. For example, here is a simple function that calculates a factorial using tail recursion.

(defun ela/fact (in-num)
  (named-let rec-fact ((accu 1)
                       (num in-num))
    (pcase num
      ((guard (< 0 num))
       (rec-fact (* accu num) (- num 1)))
      (_
       accu))))

In this example, you will notice that rec-fact is the locally named function that gets called at the end of the first pcase pattern. This is a tail call! It will get optimized.

You can check this out by running something like (ela/fact 5) and getting 120 as the result. Try using a ridiculously big number and see if you get a stack overflow! You shouldn’t.

Another Example: Summing a List

This is just a nostalgic example, since it’s probably the first tail recursive pattern matching function I ever wrote when learning OCaml a zillion years ago. This function will take a list of numbers and then add them all together. There are much better ways to write this in Emacs Lisp, like with apply.

(defun ela/sum (numbers)
  (named-let sum-list ((accu 0)
                       (lst numbers))
    (pcase lst
      (`(,head . ,tail)
       (sum-list (+ accu head) tail))
      (_
       accu))))

You can then call it like this:

(ela/sum (list 1 2 3))

And you will end up with exactly the result you expect. I was amused to see that the documentation page for named-let has a different implementation of this function that doesn’t use pcase.

Oh heck, let’s get fancy and rewrite apply using this approach.

(defun ela/apply (fn &rest arguments)
  "Apply FN to each element of ARGUMENTS and return the accumulated result."
  ;; Set up accumulator to the right type.
  (let* ((arguments-flat (flatten-list arguments))
         (initial-value (pcase (car arguments-flat)
                          ((pred integerp) 0)
                          ((pred stringp) "")
                          (_ nil))))
    (named-let apply-rec ((accumulator initial-value)
                          (input-list arguments-flat))
      (pcase input-list
        (`(,head . ,tail)
         (apply-rec (funcall fn accumulator head) tail))
        (_
         accumulator)))))

I am certain this version of apply has bugs, but it works for + and concat, so that’s good enough for a simple example. And it uses pcase twice!

Hopefully this has been a useful blog post for somebody out there. Let me know in the comments if there are other fun things you have done with TCO and pattern matching in Emacs Lisp!

Arduino Planetary Hours library

2017-05-01T18:30:35+00:00

I am finally announcing my PlanetaryHours library for the Arduino. This library uses the sun_rise() and sun_set() functions from the avr-libc time.h library to calculate planetary hours.

Download v1.0 Here

Planetary hours are an old method of figuring out which planets are “in charge” at any moment. For more information on planetary hours, check out these resources:

You can set up a PlanetaryHour object by passing it a time zone offset in hours, a latitude, and a longitude. The following example might help.

#define MYZONE -7

PlanetaryHour ph(MYZONE, 45.5, -122.7);

Then, you can check the ruling planet of the current day and hour with an RTC or other time-keeping mechanism.

time_t timer = utc.unixtime() - UNIX_OFFSET;
uint8_t dayPlanet = ph.dayPlanet(&timer);
uint8_t hourPlanet = ph.hourPlanet(&timer);

The return value of dayPlanet() and hourPlanet() is a number from 0 to 6, corresponding to the Chaldean planetary order.

#define SATURN 0
#define JUPITER 1
#define MARS 2
#define SUN 3
#define VENUS 4
#define MERCURY 5
#define MOON 6

I’ll be posting an article on the Arnemancy blog outlining a project I just installed using this library and some NeoPixels. I really look forward to seeing what others end up doing with this code!

Download v1.0 Here

Raspberry Pi GPIO with Erlang

2017-04-10T17:23:14+00:00

Raspberry Pis are super cool. One of the neat things about them is that they have a ton of general purpose input/output (GPIO) pins, so you can use them to control all sorts of external devices. Unfortunately, most of the examples and applications are written in Python. I know, a lot of people really love Python, but it’s just not my cup of tea.

Enter the Erlang πGPIO library by Paolo Oliveira! This is a simple, straightforward library that implements the RPi GPIO stuff for Erlang. Using it, I have created an Erlang library to control a 28BYJ-48 5V stepper motor with a ULN2003 controller board.

Check out the library here.

https://www.instagram.com/p/BSp2ZdSA0cg/?taken-by=pymander

Using Amazon S3 as a Nette Service

2016-10-26T22:17:16+00:00

Nette is a popular web application framework for PHP. It is mostly pretty well documented and easy to use. Recently, I needed to upload media from a Nette application to Amazon S3. This is how I created an S3 service for my Nette application. You will need to be familiar with Nette and have an existing Nette application to follow along.

Installing the Amazon Web Services SDK

Before anything will work, you will need to install the AWS SDK using Composer. Run the following command from your Nette project directory.

php composer.phar require aws/aws-sdk-php

The S3Uploader Service

Next, create the file app/model/S3Uploader.php and edit it to look like the following. You can also download my version from this link.

<?php

namespace App\Model;

use Nette;
use Aws\S3\S3Client;

class S3Uploader
{
    /** @var \Aws\S3\S3Client */
    private $s3client;

    /** @var string */
    private $bucket;

    public function __construct($bucket, $accessKey, $secretKey)
    {
        putenv("AWS_ACCESS_KEY_ID=$accessKey");
        putenv("AWS_SECRET_ACCESS_KEY=$secretKey");

        $this->s3client = new \Aws\S3\S3Client([
            'version' => 'latest',
            'region'  => 'us-west-2'
        ]);

        $this->bucket = $bucket;
    }

    /**
     * Upload a file to an S3 bucket
     *
     * @param string $key The key used for the uploaded object
     * @param string $file The filename to be uploaded
     * @param string $contentType The file's content type. This defaults to "application/octet-stream"
     *
     * @return string A URL to access the file publically.
     */
    public function uploadPublic ($key, $file, $contentType = 'application/octet-stream')
    {
        $result = $this->s3client->putObject([
            'Bucket'     => $this->bucket,
            'Key'        => $key,
            'SourceFile' => $file,
            'ContentType' => $contentType,
            'ACL'        => 'public-read'
        ]);

        $url = $this->s3client->getObjectUrl($this->bucket, $key);

        return $url;
    }

    public function getClient () {
        return $this->s3client;
    }

    public function getBucket () {
        return $this->bucket;
    }
}

Configuring the Configurator

Finally, the tricky part. You need to configure the Nette Configurator so it knows about your new service. Follow these directions.

Open app/config/config.neon with your favorite text editor. At the end of the services: section, add the following line.
```
s3client: App\Model\S3Uploader(%s3client.bucket%, %s3client.access_key%, %s3client.secret_key%)
```
Open app/config/config.local.neon. Find the parameters: section and add this block to it. Replace “ACCESS_KEY” with your AWS access key, and “SECRET_KEY” with your AWS secret key. Set “BUCKET_NAME” to the bucket you’ll be using for your uploads.
```
s3client:
   access_key: ACCESS_KEY
   secret_key: SECRET_KEY
   bucket: BUCKET_NAME
```

Using S3Uploader

Open up the presenter file that will be using the S3Uploader service. You just need to add a few new lines.

Near the top of the file where you’re loading libraries, add this line.
```
use App\Model\S3Uploader;
```
You will need to change your constructor definition to include S3Uploader. Assuming you haven’t changed your constructor function too much, it will probably look like the following.
```
public function __construct(Nette\Database\Context $database, S3Uploader $s3)
```

Finally, you can call the S3Uploader with a simple method call.

$objectUrl = $s3->uploadPublic($objectKey, $filePath, $contentType);

Good luck with S3Uploader. Please let me know in the comments how it is working for you. Note that this is an example and the finished product will probably be more sophisticated. However, this should get you started with using Amazon S3 in your Nette applications.

Alternate Ways to Call wp-cron

2016-03-05T17:09:28+00:00

WordPress includes a job scheduling system called wp-cron. The default method for scheduled jobs is for wp-cron to be checked on each page load, which has the potential to slow down your website while background jobs are run. Check out these other options that help maintain the user experience on your WordPress site while still running important tasks in the background.

Using ALTERNATE_WP_CRON

The ALTERNATE_WP_CRON method uses a quick, nearly invisible redirect to direct an incoming user to a new request while the old one continues running, executing background jobs. This is an easy, effective method and it works really well if you don’t have access to crontab on your hosting site. Even though this method adds some elements to the page URL, it’s only triggered when background jobs need to be run. To enable it, follow these instructions:

Open your site’s wp-config.php in your text editor.

After the lines containing your database credentials, add the following lines:

/** Use alternate WP_CRON method with redirects. */
define('ALTERNATE_WP_CRON', true);

Using Crontab

If you have access to a shell on your web host and can run cron jobs, this method might be the best. It ensures that background jobs will get run, even when your website isn’t getting any visitors. It also runs background jobs without requiring a redirect or any additional delays that will be noticed by users. Here’s how you do it.

Add a Crontab Entry

Run crontab -e

Add the following lines to the end of your crontab file:

# Call wp-cron regularly
*/15 * * * * curl http://www.example.com/wp-cron.php > /dev/null 2>&1

Make sure you replace “www.example.com” with your website’s hostname. The */15 specifies that wp-cron.php will be called every 15 minutes. If you would like to change this, replace the 15 with a different number.

Disable Built-in wp-cron

The next step is to disable the built-in call to wp-cron in WordPress.

Open your site’s wp-config.php in your text editor.

After the lines containing your database credentials, add the following lines:

/** Disable built-in cron in favor of system crontab */
define('DISABLE_WP_CRON', true);

For more details on this method, check out this page on EasyEngine.

OpenPGP for WordPress Now Supports Contact Form 7

2016-01-20T16:54:43+00:00

OpenPGP Form Encryption for WordPress now supports Contact Form 7. You can download version 1.4.0 at the WordPress plugin site and start using a safer contact form on your website today!

Pono Rez WordPress Plugin

2016-01-18T17:52:32+00:00

Together with Commerce Collective, ((I started working with them last year, remember?)) we have built a WordPress plugin to allow Activities & Attractions Association of Hawaii (A3H) to quickly and easily integrate activity bookings and sales into their WordPress websites.

We still have more features to add to the plugin, but it’s a solid start that will save A3H members a lot of time. It is written in PHP ((Like all WordPress plugins, of course.)) and JavaScript, and uses the Pono Rez SOAP interface to integrate activity data into a WordPress page.

Check out the plugin page here!

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!

Send Secure Email with Entrypt.to Service

2015-06-08T15:48:03+00:00

While my OpenPGP plugin for WordPress might be very helpful, the Encrypt.to service allows you to quickly send encrypted email with just one click. It looks powerful.

You can click here to send me encrypted email or visit the source code.

A Look Back on the History of Cryptography

2015-06-01T15:30:02+00:00

In May, I taught a class on the History of Cryptography at Portland Underground Grad School. I’m extremely grateful to PUGS for asking me to teach, because I’d never done it before. It was a great experience. My students were intelligent and the discussion was good. I learned quite a few things in the process.

Teaching Isn't the Same as Lecturing

I have a lot of experience with public speaking. I spent time in Toastmasters International and have given many lectures. In fact, here’s a video of me giving a lecture on the art of memory back in 2013. (( I embedded this video just to exploit a neat WordPress feature. ))

https://www.youtube.com/watch?v=-WpxbPHkq4A

I knew that teaching would be different, but I didn’t know what to expect. Luckily, Douglas Tsoi, the mastermind behind PUGS, helped me design my four-week curriculum and gave me a lot of advice. The two main differences that I noticed are that, first, teaching is a lot more like a conversation, and second, you continue following up week after week. Conversation and continuity!

Douglas’s help was invaluable. He’s the reason that PUGS is able to bring in experts without teaching experience while providing a rich educational environment.

It's Hard to Boil Down Experience

"There is so much to learn! I enjoyed being able to ask questions at will and go deeper into the subject with a knowledgeable instructor." -- An anonymous student

A PUGS class lasts four weeks, and there’s only one class per week. That’s not a lot of time to cover a complicated subject. Going into the class, I just didn’t realize how difficult it is to cram decades of experience into just a few weeks. In our third class, while discussing Phil Zimmerman and the creation of PGP, I realized that I’d been learning about cryptography for over 20 years.

The learning curve in cryptography is staggering. I didn’t realize that going into it, but it’s really difficult to introduce things like the Diffie-Hellman key exchange protocol to people who had just learned to do an alphabetic substitution cipher for the first time. All of my students were very intelligent people, but none of them were computer scientists or mathematicians. My curriculum is going to take some adjustment.

Teaching is Fun

Through this class I met many interesting people. While preparing for the class, I had to brush up on a lot of dusty knowledge. In the process I learned a lot. The entire thing was mentally engaging, socially stimulating, and a blast. I hope that PUGS will have me again, because this class is only going to get better.

If you enjoy learning, you owe it to yourself to take a class at the Portland Underground Grad School. Go check them out!

New Release of OpenPGP for WordPress

2015-05-13T18:16:07+00:00

Version 1.3.0 of the OpenPGP Form Encryption for WordPress plugin is now available. It’s important to upgrade. It includes the following changes.

Updates OpenPGP.js to version 1.0.1
Tests the plugin against WordPress 4.2.2
Ensures that the browser can support OpenPGP.js

There are a few new features planned for this plugin. Expect a major version release in the next few months.

Check out the plugin page on the WordPress Plugin Repository.

Please Use Version Control

2015-04-09T03:07:44+00:00

Stack Overflow released their 2015 Developer Survey this week, and it has some interesting results. There are plenty of articles being written about their findings, so I’m only going to focus on one of them: version control.

9.3% of Respondents Don't Use Version Control

StackOverflow says that almost 10% of developers still aren’t using version control. This is terrible. If you happen to be one of the developers who hasn’t adopted version control yet, make it your next priority!

Version control, also known as source control or revision control, is vital to best programming practices. It provides an incremental backup along with comments and notes on changes that have been made. It provides a view of changes and all kinds of handy features, such as handling conflicts between changes, release tagging, code branches, and more. If you aren’t sure what version control is, check out Ilya Olevsky’s post, “Why Version Control is Critical to Your Success,” and then come back here.

Essential to Collaboration and Continuity

If you are looking to hire a freelance developer, make sure you hire one that uses version control. It is essential to maintaining a healthy history of code releases, project updates, and bug fixes. What if you only need to use your freelancer every once in a while? What if you decide to add more developers, or change developers all together? Without version control, this becomes a nightmare.

A client recently brought me a project that had been built by another developer a couple of years ago. They wanted to move their web application from one host to another. However, there was a lot that needed to be cleaned up before the move could happen, including some outdated PHP code and odd database settings. In the project’s main directory, there was a mess of old, unused source code files. Just the index.php file had multiple versions:

index2.php
index3.php
indexold.php
index.php_old
index.php_bak

In all, there were 598 unused files that were unnecessary backups of old, broken code. This type of mess is easily avoided with version control. Please stay sane, keep your customers happy, and your source code easy to navigate. Use version control.

Getting Started with Version Control

If you’ve decided to make the right move and start using version control, you will see that there are many to choose from. However, if you’re just going to learn one, you should start with Git. As you can see from the survey, it is the most widely used. The best place to start is probably in the free e-book offered by the Git development team. Click here to get started.

If You're Doing It, Thank You

The first time I encountered a team that wasn’t using version control, I was shocked. The second time, I sighed in exasperation. Now, I am thankful that over 90% of developers are using it, and I look forward to the day that every project I join comes with a git log command. If you are using version control, I hope you spread the word and make sure that your fellow programmers are doing it, too. Save the rest of us some pain!

As a bonus, here’s my favorite git log command. Add it to your aliases.

git log --oneline --graph --all --decorate

The featured image for this post is a pile of logs, to remind you that logs are important, and a vital part of version control.

Link Rodeo: Go Package Management and Boring Technology

2015-04-06T15:47:00+00:00

Here are a number of interesting topics for you to think about this week.

I’ve been learning the Go programming language recently, and in the process I’ve been having conversations about it with friends and colleagues. Go has a unique package management system that has already caused me a number of headaches. The recommended method for taking care of package dependencies is lacking, at best. Over at Nerdbucket, my buddy Nerdmaster has written a thoughtful piece about it.

While I’m talking about new technology, I’d also like to contradict myself by agreeing with Dan McKinley’s great piece, “Choose Boring Technology.” He argues that a project should be careful about adopting lots of new tools and technologies. It reminds me of a time recently when I was looking for a Node.js programmer, and one of the replies I got back was, “For us, Node.js is glue. Its ecosystem is still too young to support anything long-term. Libraries and packages move too fast to build a product that will need actual maintenance.” I’ve had the same feeling about many technologies I’ve wanted to try, such as Ocsigen for OCaml, which has a build system and API that is always several steps ahead of its documentation.

This post’s featured photo is courtesy of Flickr user MunicipioPinas.

Create a Document From Twitter with TweetBook

2015-04-01T17:48:56+00:00

I just released TweetBook, a web application to transform a Twitter stream into a simple document that can easily be turned into a photo album.

The Problem

A client came to me complaining that there was no available solution to export a Twitter feed as a document filled with images. There are various other Twitter-to-document converters out there, but they all focus on the text. The client asked me to build a tool to fill this void.

The Solution

Since I’ve been working with Google App Engine a lot lately, I used Go to write a tool that retrieves Tweets from a search or timeline. It provides a number of formatting options, and then creates a simple document suitable for exporting into an HTML or PDF file.

Try It Out!

As of 2022, this application is seven years old and probably doesn’t work anymore.

The client told me to do whatever I wanted with the code, so I’m making it available for use! Click here to try TweetBook! If you find it useful, please consider funding further development by contributing a small amount with this button:

Do You Have a Suggestion? A Bug Report?

If you have additional ideas for TweetBook, please visit my Contact page. I’m eager to hear your feedback and get suggestions and bug reports!

Don't Modify the Clipboard with JavaScript

2015-03-02T16:42:53+00:00

Recently, I was reading an article about a newly published book that I’m interested in. However, the article didn’t include a link to the book, so I copied the title by highlighting it with the mouse and hitting ‘Ctrl-C’, and opened a new browser tab to do a search. However, upon pasting, I saw the book title along with an annoying addition: “To read more, visit our website at [redacted].”

This sort of website behavior is not okay.

I’ve seen the behavior on a number of websites, and it is among my least favorite trends in web development. The user is probably using his clipboard for one of two reasons. First, the website has a UX problem, and it has neglected to link to something important. Second, the user needs the text either for a quote, or to look up an unrelated term. For instance, this sentence has the word “bucolic” in it, and that’s an uncommon word that you might want to look up.

But you can’t easily, because I’ve included JavaScript on this page that modifies your copy buffer. Do you see how annoying that is? Please don’t go mucking about in your users’ copy buffers.

If you want to see what happens when you try to copy and paste on this page, highlight some text on the page and hit ‘Ctrl-C’ (or ‘Cmd-C’ for OS X users). Then go to the handy text area below and paste with ‘Ctrl-V’.

That’s really obnoxious, isn’t it?

This post was updated in 2022 to use Jekyll to load custom JavaScript instead of a custom WordPress plugin.

The image for this post comes from Flickr user Shimelle Laine.

Pansophie Online Color Test

2015-02-23T16:46:52+00:00

Pansophie Personality and Color is focused on mapping personalities to colors. Alexandra Hall wanted an online testing platform with flexible questions, testing mechanisms, and report generation. I built a full-featured web application to meet Pansophie PC’s requirements. This was one of my early Zend Framework projects, but it ended up with some neat features.

A private administrative interface
Seamless jQuery-backed test interface with few pageloads
Custom PDF reports, generated on the fly
A customer database with contact information
API endpoints for test generation
Integration with 3rd party e-commerce system

Pansopie PC isn’t currently doing business.

Prime Number Service on Google App Engine

2015-02-20T22:37:41+00:00

As I mentioned earlier this week, I’ve decided to learn the Go programming language. I’ve also been very interested in Google App Engine, which lets you deploy applications to the cloud from a development sandbox. It’s like magic for web and mobile applications!

Since I’m so fond of prime numbers, I thought I’d build a web service for calculating them. It does some other fun stuff, too, like figuring out if a number is happy. It also caches primes in the Google Cloud Datastore with some minimal statistics. If you’d like to see the source code for the prime number service, it’s available on GitHub.

The next thing I did was write the simplest of all WordPress plugins to query the service and return the latest prime number in the sequence. This all happens in a post using the [[nextprime]] shortcode. ((Including this information has the side-effect of revealing how much traffic this page gets.))

[nextprime]

You can also visit the app itself and read about querying the service to get prime numbers for your own web page!

Learning Go and writing for the Google App Engine has been really fun. I’m ready for a new challenge! If you have a web application in mind, contact me and let’s figure out how to build it!

How to Enable XPath in Internet Explorer

2015-02-12T17:13:32+00:00

Yesterday, I shared a little bit about using a virtual machine to test frontend code under Internet Explorer (IE). My goal was to use Wicked Good XPath to add the proper XPath features to IE so that EPUB.js would work correctly, thus making the Philalethes E-Bulletin Online Reader work on all major browsers.

Well, I’d been thinking about this problem for a while, but had delayed working on it because I just didn’t want to fiddle with IE. While I’d been thinking about it, the EPUB.js instructions were updated with IE-specific steps. I didn’t have to look far.

After loading wgxpath.install.js in the header, I just had to add this bit of JavaScript before anything important happened:

// Internet Explorer workaround.
if (!window.XPathResult) {
    EPUBJS.Hooks.register("beforeChapterDisplay").wgxpath = function(callback, renderer){
       wgxpath.install(renderer.render.window);

       if (callback) callback();
    };
    wgxpath.install(window);
}

You can see on line 2 that I test for window.XPathResult instead of looking for a user agent or anything like that. That’s because it’s not really IE I’m interested in detecting. I want to find out if XPath is both available and somewhat standard. User agents are unreliable. Always test for feature availability instead!

The results are good enough for now: the Online Reader works in IE, but it’s not perfect. The cover image doesn’t load full-size and fonts don’t seem to be loading correctly. IE users account for only 10% of the traffic on the website, so obviously I need to work on the EPUB.js cross-browser support. For now, though, it works. And it looks great on Chrome, Safari, and Firefox.

How to Test Your Frontend Against Internet Explorer Without Booting Windows

2015-02-11T19:15:26+00:00

Internet Explorer (IE) has been frustrating me. I want to use stronger words than that, but it would be unprofessional.

I recently launched the Philalethes E-Bulletin Online Reader, which uses EPUB.js and an implementation of XPath that, for some strange reason, isn’t available in IE. I found a few solutions which would work, but all of them require testing in IE. Of course.

This seems like it wouldn’t be a problem, except that I run Linux all the time. All of my work happens on the Linux side of things, so booting into Windows just to run IE for one tiny bug fix is an inconvenience and a chore.

A friend of mine pointed me to modern.IE. Microsoft has graciously released virtual machines usable under MacOS and Linux for running IE and testing. Be warned, however, that the license only lasts 90 days.

I downloaded the 3.5GB virtual machine image and loaded it up in VirtualBox. This might be unusual, but I don’t do a lot of work with virtual machines on my development box. I was immediately greeted with this: [caption id=”attachment_269” align=”aligncenter” width=”530”] Don’t worry, the loading time was a lie. It only took 5 minutes.[/caption]

This solution is not the best for my setup. My computer is getting long in the tooth, so VirtualBox runs neither quickly nor smoothly. However, in this situation, I only needed to test a few lines of code, so it worked.

In my next blog post, which should be coming out shortly, I’ll talk about how I got the Philalethes E-Bulletin Online Reader working for IE.

When to Develop Apps From Scratch

2015-02-03T20:56:10+00:00

I haven’t had time to write anything interesting for the blog this week, so instead check out Sebastian Green’s article, “A transparent box: the case for developing from scratch,” which has been published over at Developer Drive.

Mr Green makes some great arguments for developing from scratch. Good software takes good planning, no matter what.

Integrating Cedexis Radar with WordPress Sites

2015-01-26T20:00:52+00:00

Cedexis Radar is a real user monitoring (RUM) system that collects millions of metrics every day. It’s used to measure the health of networks in order for Cedexis Openmix to make intelligent routing decisions for web service users.

I put together a simple plugin to add Cedexis Radar tracking codes to a WordPress website. I’m not yet sure how much of an overlap there is between WordPress users and Cedexis Openmix users, but if you’re using both, check out my new plugin.

Sometime between 2015 and 2022, Cedexis was purchased by Citrix and no longer exists.

Web Page Size is Vital

2015-01-19T20:05:17+00:00

When I first learned how to program a computer, optimization was a big deal. Figuring out how to squeeze every bit of performance out of a subroutine was difficult but rewarding. Articles were frequently written about how to best go about optimizing source code.

In the late 1990s, I began working on my first web applications. Bandwidth was expensive, so we worked on ways to make our websites more compact. We compressed web pages and figured out ways to strip out whitespace. However, today websites have quite a bit going on in the front of the house. There’s a lot of JavaScript and CSS that gets passed to the browser, and as a result, web applications are transmitting more data than ever.

Tammy Everts writes a blog called Web Performance Today, where she follows trends in web application development. It is essential for web developers to pay attention to the amount of data they send to users and how that affects application performance.

https://twitter.com/tameverts/status/555780016563564544

Ms Everts has shown over and over that web pages are growing. She points out that the average web page has grown 186% since 2010, and it shows no sign of stopping. I believe that every responsible web developer owes it to himself ((Or herself.)) to follow Ms Everts’ blog.

Please, fellow web developers, pay attention to how big your web pages are getting. Let’s reverse this trend.

Hypothes.is Web Annotation Tool

2015-01-14T23:38:13+00:00

While working on the Philalethes E-Bulletin Online Reader, I came across a useful web-based annotation tool called Hypothes.is. It’s worth checking out. The tool uses a browser plugin to provide a number of cool features.

Annotation
Discussion
Tagging
Sharing
Privacy Control

It also provides an annotation stream that allows you to view public annotations as they’re being made all over the web.

Philalethes E-Bulletin Online Reader

2015-01-12T22:33:11+00:00

I began working on the Philalethes E-Bulletin in the Fall of 2013, and published the first issue in January of 2014. The E-Bulletin is published quarterly in EPUB and MOBI formats.

It’s been a great learning experience. Not only have I learned a lot about editing, but I’ve really had to dive into how electronic publishing works. The intricacies of electronic book formats have become well-known to me.

The Philalethes Society isn’t entirely comfortable with modern technology, however. Most complaints about the E-Bulletin came from those who didn’t have e-book readers and weren’t comfortable installing software on their PC to handle a new file format. Because of this, I built an online e-book reader specifically for the E-Bulletin.

The online e-book reader is based around the excellent EPUB.js library, with additional backend code written in PHP.

Click here to visit the Philalethes E-Bulletin Online Reader.

An English-language Stemmer for OCaml

2014-12-29T16:47:38+00:00

A stemming algorithm attempts to reduce words to their stem. For instance, “swimming” would be reduced to “swim”, and “avocados” would become “avocado”. This is useful in a number of situations, most especially in searching text. This library is a direct port of the Porter English stemming algorithm.

It was one of my first OCaml projects. I wrote it back in 2003, when I was still new to the language. I had been spending a lot of time writing C libraries that were being called by Perl scripts for my day job. Perl has, or had, a cumbersome, messy interface to C that made such interfaces very difficult to write and maintain.

When I discovered how easy it was to link C libraries into OCaml, I was overjoyed! This was my first attempt. Before reading further, check out my ocaml-stemmer library on GitHub.

Updating the Code

Recently, while overhauling all of my publicly-available code, I decided to update my English-language stemmer for OCaml. It’s not a very large piece of code, but its age really shows. It wouldn’t compile cleanly with the latest version of OCaml. It looks like the code of somebody who hasn’t really grokked functional programming yet. Just look at this.

let rec replace_end word (rule_list : (int * string * string * int) list) =
  match rule_list with
      hd :: tl ->
        if (match_rule word hd) then
          let (rule, _, _, _) = hd in
            (rule, apply_rule word hd)
        else
          replace_end word tl
    | [] ->
        (0, word)

Ouch, right?

I decided that the scary code would stand as a good message ((Or maybe I should say a good warning.)) to future functional programmers. For now, I just wanted to get this code to compile and not look messy. That ended up being easy.

Finding The Bug

Once I got it compiled cleanly, however, I found a bug. Back in 2003, I was big on test-driven development. I wrote tests for lots of code. The OCaml stemmer, it turns out, has been broken for quite a while. It doesn’t handle words with apostrophes correctly!

I thought that fixing the bug it would be a challenge. However, I quickly I discovered in the OCaml manual that the or operator was deprecated, and that || should be used instead. Embarrassingly, the or operator was deprecated back in 2002. That never should have been in the code! You can view the commit which fixed the bug here.

My Stemmer Library is Now on OPAM

This is my second library on OPAM, including my prime number library. You can view it on OPAM here.

Official Release of Libbucket 1.0.4

2014-12-18T18:56:02+00:00

I’ve tagged version 1.0.4 of libbucket over on GitHub. You can download a tarball at this link. If you’d like to read more about libbucket, see my post from earlier this week.

Very handy edit:

You can download version 1.0.4 of libbucket and an OpenPGP signature here:

libbucket-1.0.4.tar.gz
libbucket-1.0.4.tar.gz.asc

[caption id=”attachment_184” align=”aligncenter” width=”300”] I never realized how much bucket clip-art existed.[/caption]

Small Team Software Change Management

2014-12-18T01:45:51+00:00

Until October, I’d been using a paid GitHub account to manage source code changes and issue tracking for private projects. GitHub is a software-as-a-service (SaaS) product providing a web-based interface for source control management and various project tracking tasks. Some people love it and some aren’t fond of it.

My software development clients are typically small companies wanting fairly simple web applications. They hire me because having a developer on staff doesn’t fit into their budget or business plan. They don’t usually care what the source code for their project looks like, but they do care about tracking issues.

Because of the scope of these applications, it’s rare that I work with other programmers. This meant that I wasn’t using any of the special features of GitHub for private code repositories, so in October I cancelled my subscription.

My private repositories are now self-hosted, and I browse them using GitList, which bills itself as “an elegant and modern git repository viewer.” It looks nice, and I’ve got no complaints. For issue tracking, I use Freshbooks, a SaaS accounting system. With Freshbooks, I can not only keep track of bug reports and issues, but I can record time spent on bug reports, feature creep, and other client-related issues.

GitList and Freshbooks isn’t a perfect solution. At some point, I will be working with another developer, and we will need a way to track bugs and issues internally. When that happens, I plan to deploy Gitolite and find some new issue-tracking solution.

By the way, another reason I stopped using paid GitHub features is because they’ve already made plenty of money, and I’m not sure they’re doing the right things with all of that money.

I’m curious about what others are using. How does your incredibly small team track code changes and issues? Are all of your software issues internal, or are you developing for clients? I’d love to hear some ideas.

Modernizing libbucket

2014-12-15T16:45:55+00:00

If you’re here to learn about my experience in software development, you’ve probably poked around my GitHub page. One the older projects on there is libbucket, a very fast dynamic string buffer library. I originally wrote it while working for Musician’s Friend, and was given permission to release it as an open sourced library in 2005.

Recently I decided to update the build system in the library, which was using an old version of autoconf and automake. I haven’t worked with those tools in a number of years. They are solid and flexible, but they’re also a confusing tangle of m4 macros and crazy shell scripts. Also, they change a lot.

A few important things had changed. For instance, aclocal wanted to read from configure.ac instead of configure.in. In addition, the AM_INIT_AUTOMAKE macro was completely different, but the tool was nice enough to point me to the relevant part of the automake manual.

Building a library is also a little different now than it was in 2002. GNU Libtool is a great program for building dynamic and shared libraries correctly for Unix systems, but its usage is different now. Luckily, it spit out all of the information I needed to update things.

One thing I didn’t quite figure out is how to get automake to recognize the README.org file as satisfying its README requirement. I ended up with an initialization block in configure.ac that looked like this:

AC_INIT([libbucket], [1.0.4])
AC_CONFIG_SRCDIR([src/bucket.c])
AC_CONFIG_MACRO_DIR([m4])
AM_INIT_AUTOMAKE([foreign])
AM_CONFIG_HEADER(config.h)
AM_MAINTAINER_MODE

You can see the unpleasant “cheat” on line 4. Sorry about that, world.

After all of that mess, there were just a couple of small fixes to the documentation, which is written in GNU Texinfo, and the library compiled just fine.

Unfortunately, I don’t have any tests. When I first developed libbucket, we had a proprietary test interface for C and C++ libraries at Musician’s Friend. That never got open sourced, so I had to remove it all before making the libbucket code public. Maybe tests are next.

If you’d like to take a look at the changes I made, here’s the Git commit.

PunchlinePDX Event Manager

2014-12-08T17:23:17+00:00

PunchlinePDX is a slow-motion video booth for events and parties based out of Portland, Oregon. Earlier this year, I helped them develop event management software that would allow them to upload and curate video.

This was their first experience hiring a software developer, so I had the opportunity to walk them through the entire process. We started by outlining requirements and coming up with a solid plan with application screens, functions, and things to meet their business needs. We then brainstormed additional features and came up with something pretty amazing.

These are a few of the interesting things we came up with:

Cloud-backed storage for all videos
Text messaging interface
Smart social media sharing
Contact management
Event and sharing privacy

The best part was the testing process. While I ran them through their new software, they made slow-motion video of me and used the software to upload and manage it. Check it out!

Your browser does not support the video tag.

You should seriously consider booking these guys for your holiday party.

Camlprime Now on OPAM

2014-12-02T22:19:09+00:00

My first OCaml Package Manager (OPAM) submission has just been accepted. You can now find Camlprime, a prime number library, on OPAM here.

Handy Tools for the Bourne Again Shell

2014-12-01T16:38:30+00:00

If you’re a Unix geek, you’ve probably used bash, the Bourne-Again Shell. If you’ve been around a while, you’ve probably spent a lot of time customizing bash.

Back when I worked for Yahoo!, my friend Bryan gave me a great directory stack for bash. I loved it, so I rewrote it and have been hacking on it and using it ever since. Observe.

[user@host:~]$ cd /tmp
[user@host:/tmp]$ cd /var/log
[user@host:/var/log]$ dl
1   ~
2   /tmp
3 * /var/log
[user@host:/var/log]$ go 1
1   /home/user
[user@host:~]$ go log
3   /var/log
[user@host:/var/log]$ 

In addition to the handy new go command, it also includes b and f for moving backwards and forwards on the stack. It was inspired by pushd and popd, but it’s so much more.

If you’d like to check it out, take a look at my bashtools repository on GitHub or just download version 1.0. I don’t change it very often, but I’m thinking of hammering out a long-standing bug in the directory stack code.

N.B. If you use all of my scripts, you’ll get some great prompts for your xterms. You’re welcome!

Website: Bruno San Rafael's Home for Former Trapeze

2014-11-24T17:29:56+00:00

Back in 2012, I had the pleasure of working with my good friend Joel Barker on his amazing project, Bruno San Rafael’s Home for Former Trapeze. This project is a collaboration between Joel, a bunch of musicians, a photographer, and a web developer (me!). My contribution was probably the smallest of the bunch, but it was a lot of fun.

Please check out the website by clicking on the screenshot below. If you use “View Source” in your browser, you can see every line of code I used to finish the site. It’s one simple, medium-length monolithic HTML file with JavaScript and CSS thrown in.

I now work with Joel regularly at Word Lions, where I write and do a little more website development.

Prime Number Library for OCaml

2014-11-13T17:08:39+00:00

A couple of weeks ago, I cleaned up my prime number library for OCaml. This library has a number of primality-testing methods in it, but my favorite is the Miller-Rabin primality test. It’s fast and rather accurate.

If you’d like to take a look at the library, please check out the camlprime GitHub page. The library is pretty easy to use. If you download and compile the library, you’ll end up with a toplevel that you can play with.

The test.ml file has some examples of how to use the primality tests. However, my favorite thing about this library is that it includes a lazy list implementation of prime numbers. The following example shows how to set up a lazy list of prime numbers proved using the MR algorithm in the toplevel.

# open Num ;;
# let prime_list = Prime.make (Prime.miller_rabin 500) (num_of_int 500) ;;
val prime_list : Num.num LazyList.t = LazyList.Node (Int 503, <lazy>)
# Prime.nth prime_list 500 ;;
- : Num.num = Int 4363

The library is pretty fast, even for really large numbers. I’ve tested it on 300-digit prime numbers, and I’m sure it will scale to sizes much larger than that.

Any thoughts or improvements? Let me know in the comments.

Erik L. Arneson — Writer and Software Developer

Process Automation for an Oregon Charitable Foundation

Initial Approach

Implementation Challenges

Additional Development

Results

Lessons

Emacs as the Freelancer's Command Center

Organization with org-mode

Freelance.org

Clients/*.org

References and Linking

Email with mu4e

Writing Code

Writing Words

Track All Changes with Magit

Thinking Music with EMMS

And the tools I have missed

An Emacs Application Launcher for Regolith

Turning to consult-omni

Adding an ilia fallback

Drawbacks

Interviewed on "Prot Speaks"

maybe: A command-line tool that succeeds sometimes

Some History

The Future of maybe

Many Posts of Interest for January 2024

Security

Emacs

Programming

History

EmacsConf 2023 Retrospective

Emacs Advocacy

Writing

Hyper Things (Hyperbole and Hyperdrive)

EMMS

Overall Impression

Posts of Interest for November 2023

Security

Emacs

Games

History

Posts of Interest for 13 October 2023

Programming (1)

Emacs (6)

Security (4)

Posts of Interest for 6 October 2023

Computers (4)

Portland (1)

Configuring Emacs 29.1 for Go Development

Configuring Tree-Sitter for Go

Configuring Eglot for Go

What Else?

FOSSY 2023 was Excellent

Writing and Machine Learning

Containers, Containers, Containers

Open Source Philosophy

Conclusion: Do it Again

Pattern Matching and Tail Recursion in Emacs Lisp

Pattern Matching with pcase

Tail Call Optimization with named-let

Another Example: Summing a List

Arduino Planetary Hours library

Raspberry Pi GPIO with Erlang

Using Amazon S3 as a Nette Service

Installing the Amazon Web Services SDK

The S3Uploader Service

Configuring the Configurator

Using S3Uploader

Alternate Ways to Call wp-cron

Using ALTERNATE_WP_CRON

Using Crontab

Add a Crontab Entry

Disable Built-in wp-cron

OpenPGP for WordPress Now Supports Contact Form 7

Pono Rez WordPress Plugin

CenturyLink AppFog Tutorial

Read the Tutorial

Send Secure Email with Entrypt.to Service

A Look Back on the History of Cryptography

`Freelance.org`

`Clients/*.org`

Turning to `consult-omni`

Adding an `ilia` fallback

Pattern Matching with `pcase`

Tail Call Optimization with `named-let`