Programming

Below are all of the posts with the Programming tag. A post tagged with Programming means that it is about Programming. If a post references Programming but does not have the tag, then the post will not be in the list below. If a post has the Programming tag or mentions Programming, then it will be in the Glossary for "Programming".

I have ordered the posts from newest to oldest:

2026-09-13 Many Small Steps Make Pivoting Easier
Introducing small changes, step by step, to ensure that pull requests are small and easily understood, thus minimizing potential overloading other team member’s review capacity and context.
2025-12-23 Serializing Somewhat Large Emacs Alists
Creating a bespoke process to dump and load data in manageable chunks.
2025-12-10 Extending Core Emacs Bookmark Package
Revisiting yesterday’s implementation and refactoring towards a bookmark implementation.
2025-12-09 Extending Emacs to Play Mythic Bastionland
Swapping out bookmarks while playing #MythicBastionland then restoring when finished. Also opening PDFs to random pages to simulate rolling on #RandomTables.
2025-12-05 Managing Light/Dark Scheme in MacOS and Linux
A code walk through of toggling dark/light scheme in Emacs.
2025-04-17 Automating Adding Books to My Org-Mode Document
This post describes an #Emacs workflow I designed and developed around scanning books into my book-tracking #OrgMode document. It has, what I consider, a not-oftend-detailed use of org-capture.
2025-04-11 Extending consult-notes Package to Add Draft Blog Post Candidates
In this post, I walk through using #Emacs #Lisp variable binding to reuse what might, in other languages, be hard-to-re-use code.
2025-04-10 Extending Org-Mode Export to Include Acronyms Section
Background on my #OrgMode export ecosystem and changes I made in #Emacs to export acronyms and their names to #LaTeX (and PDF) documents. I also speak to some of the “why” of my personal glossary of acronyms.
2025-04-09 Tending to my Writing Ecosystem and Existing Notes
In this post I walk through my thoughts around removing outdated #Denote functionality in #Emacs, which meant updating a dependency, that fixed a long-standing “bug”, and moving towards an already established daily #OrgMode pattern.
2025-04-08 Adding Actionable Indicators to my Emacs Mode Line
An overview of my present #Emacs mode-line and a walk through of adding an actionable indicator to that mode-line.
2025-01-22 On Elfeed and Backups
A walk-through of the “perks” of using the #Elfeed #Emacs package for reading my #RSS feed. Then a quick overview of my back-up process, using habit stacking and #SyncThing. Finally, a reflection on what this is all meaning to me.
2025-01-18 Forking from a Step in a Stacked Habit
Taking a personal #writing habit and mapping it to the realities of work; with a goal of helping keep my work goals salient throughout the quarter.
2024-12-28 Adding Color and Style to HTML Elements in Emacs's SHR/EWW
Creating an #Emacs macro to apply faces to named #HTML elements. All in service of conveying the semantic intention of the HTML when rendered as “plain text”.
2024-12-18 Adding HTML5 Display Block Elements to Emacs’ SHR (and EWW) Tag Rendering
A quick adjustment to improve my in #Emacs web browsing experience.
2024-12-17 Extending Built-In Emacs Bookmark Package
Walkthrough of (temporarily) replacing a misbehaving package with a basic replacement of one of the core functions I use.
2024-12-07 Add Work Link Type to Org-Mode
A walk through of building more functionality into my #OrgMode bibliography. Namely citations akin to #HTML cite-tag. This post has lots of #Emacs code.
2024-12-04 Auto-Exporting My Book "Shopping List" as Part of Org Capture
The ongoing refinement of my Bibliography in #Emacs’s #OrgMode. And a reflection on the #Serendipity of perusing book shop shelfs.
2024-12-04 Refining My Quotation Capture Process
A quick tweak to my Org-Mode capture function. One that positions to just after a headline’s metadata (e.g. properties and drawers).
2024-12-03 Monkey Patch Fix for Bookmark+ for Emacs 30
Reading some source code along with some manual testing, leads to what appears to be a workable fix.
2024-12-01 Re-Wiring My Epigraphs Functionality to Leverage My Bibliography File
A detailed walk through of extending Emacs’s Org-Mode link functionality to add a new link type.
2024-11-27 Extending My Bibliography for an On The Go “Shopping List”
A quick post writing about building out more functions on my “bibliography.”
2024-11-27 Refining My Personal Bibliography and Epigraph Process
A walk through of my consolidated Bibliography and Epigraphs. I describe the anatomy of the file; walk through the org-capture templates I use; the functions I wrote to improve the capture process; and the overall benefits I’m noticing of a consolidated file.
2024-11-25 Exploring the Reworking of a Blog Page
Thinking through how I can move the canonical version of my personal bibliography into my personal knowledge manager; and then export something similar to what exists. A benefit is that the process I’ve explored creates opportunities for richer processes for the books I read.
2024-11-08 I Consider Myself a Writer Who Codes
A post in which the title sprang forth and I though a bit more about it. Plus, a bonus Haiku!
2024-11-05 Guarding Against Hugo's Breakage
Thinking about removing Hugo from my build chain; in part because I have guards against its breakage. I’m curious about what the alternative might/will bring. And I’m exploring with caution.
2024-11-01 Adopting Gomponents for Work Project
Working through a programming design pivot; from template to page object. This post discusses some observed gotchas, perceived tooling advantages, and a bit of Emacs sugar.
2024-10-31 Hacking on Mastodon Emacs Package to Narrow Viewing
A quick post and some code that helps me more easily read Mastodon toots.
2024-10-22 JSON Data for a General Structure and Specific Structures in Go-Lang
Learning about json.RawMessage as a means for having a general and specific parsing to leverage heterogenous data.
2024-10-04 Extending Emac’s Go Tree Sitter Mode’s Imenu Function to Include Test Run
For my day job, I’ve been writing Go-lang tests. And I found myself wanting an overview of scenarios within the test. Today, I extended Emacs to index those scenarios as akin to the index for functions.
2024-09-30 Duplicating Go Lang Struct Tag Functionality for Tests
This post walks through adding functionality to mirror a resource-heavy dependency. This functionality leverages Go Lang’s reflect package and struct tags.
2024-08-29 Go Interfaces, Dependency Injection, and Test Coverage
This post I walk through writing up interfaces to hide the implementation details of 3rd party packages. And in doing so, introduce creases for dependency injection while preserving a high-degree of test coverage.
2024-08-11 Exporting Org Mode Elfeed Links
I write up a use case around exporting elfeed links and then provide some code that implements that use-case, wrapping up with a quick overview of the other types of links I’ve implemented in Org-Mode.
2024-07-27 Variad Function Parameters as Options for Go Lang
A bit of Ruby code then a few iterations of Go code, all working towards optional parameters with meaningful defaults. Plus a bonus discussion on reviewing generated documentation and using that to guide further refactoring and updates.
2024-06-21 Using the Link Hint Package to Extend Eldoc Functionality
A quick walk through and code example to improve the usability of inline documentation provided by the active language server.
2024-06-08 Adding a Consult Function for Visualizing Xref
A quick write-up of using the Emacs consult package to preview xref locations.
2024-06-01 A Structured and Unstructured Log Wrapper for Go Lang That Works with Go Swagger Generated Files
A blog post outlining and approach and some reasoning behind implementing a Go-lang logging wrapper that supports both formatted and structured logging.
2024-05-28 Adding a Project Search Option to Ignore Swagger Generated Files
In this short post, I highlight using ripgrep to generate a list of files to omit from a later ripgrep call.
2024-05-19 Adding an Emacs Command to Summarize Headlines with Chosen Tags
In this post I talk about using Emacs to help facilitate a session. I then introduce a function that helps summarize my notes for quick review.
2024-05-18 A Quiet Morning of Practice to Address an Observed Personal Computering Workflow Snag
I spent 90 minutes pairing with someone I haven’t previosly paired with. I appreciate their thought processes and also used that time to note that I should practice additional window management strategies in Emacs.
2024-05-17 Modifying Emacs link-hint Package Open URL Behavior for Local Repositories
A blog post that introduces org capture to clock, but is really about how I’m intercepting the opening a URL in a browser by first checking if that file might be in a local repository. And if it is, opening the local file instead.
2024-03-20 Refactoring a Ruby Module Mixin into a Class
In this post, I provide some task background that was indicating a helpful refactor of code. I then provide the end state of what it looks like, followed by generalized steps and a conclusion; namely that refactors need not make better the code, just not make them worse. And can be used to describe and learn about the codebase.
2024-03-17 An Emacs Function for Wrapping Ruby Functions
An Emacs function that wraps either a region or a function by leveraging the built-in treesitter functions.
2024-03-16 Completion at Point for Org Macros
Spending an hour to write up a new completion function to help in writing blog posts and documents.
2024-03-02 An Evening Reading Documentation Leads to Discovery
I explored the Ripgrep package for Emacs, which lead to learning about persisted and named searches exposed in the package’s menu.
2024-02-28 Configuring Consult Imenu Narrowing for Ruby
A quick walk through of a configuration for exposing another means of searching/navigating within code.
2024-02-24 Making Hyrax Factories Available to Hyku and Other Implementations
A technical walk through of leveraging upstream FactoryBot factories and how I went about modifying and extending them.
2024-02-06 Renaming Files Using Denote Schema in a Dired Buffer
A quick walk through of a dired function to loop through marked files and prompt for how to rename them.
2024-02-04 Revisiting the Side Note Enhancement for My Blog
Further refinement of an accessibility feature I added to my website, with a brief mention of the aria-expanded and aria-controls HTML attributes.
2024-02-02 Writing a JavaScript Progressive Enhancement for My Sidenotes
I write a bit of background on a reported usability issue. I then provide a bit of JavaScript I wrote to resolve the reported issue.
2024-01-29 Ruby and ImageMagick to Fetch Tiled Images and Reconstitute
A quick walk through of using a Ruby script and ImageMagick to convert numerous image tiles into one image.
2024-01-23 Creating an Emacs Command to Rename Files per Denote File Naming Schema
A quick introduction to the Denote file naming convention, then a function to rename any file using the Denote naming convention.
2024-01-08 Using Automation and Checklists to Diff Across Three Related Projects
A walk through of some automation scripts I wrote to help with a complex multi-repository merge. I also discuss the utility of making checklists for those; especially for those that are likely to experience disruptions.
2024-01-07 Advising Denote Function for Removing Diacritics from String
Steps I took to remove diacritics from a string. This involved creating a map of diacritics to their simplified letters; writing a function to replace those diacritics; and last advising Denote to use the diacritic removing function.
2024-01-03 Emacs Macros Continue to Amaze Me
A walk through of recording another Emacs macro, detailing how I can start from one buffer and then move to other files where I perform different tasks. I’m simply in awe of long-standing functionality this is lost in “modern” systems.
2023-12-17 Introducing Extensibility with a Macro, a List, and a Reducer
A walk through of adding a new feature to an Emacs package. I layout the original state and walk through the three concepts that improved the code cohesion and also improved it’s maintainability and extensibility.
2023-12-03 Mentoring VS-Coders as an Emacsian
I presented “Mentoring VS-Coders as an Emacsian” for Emacs Conf 2023. I go through my approach (at my best self) and being curious about how folks are using their editors and the “bumps/hiccups” they encounter along the way.
2023-12-03 Emacs Turbo-Charges My Writing
I presented “Emacs Turbo-Charges My Writing” at EmacsConf 2023. I walk through my writing setup for Emacs, going through the workflow of writing in Org Mode syntax with Denote; and then exporting to Hugo. The text of this post pairs with the recorded conference talk.
2023-10-28 Observed Subtle Pitfall of Capybara and Cypress
A quick observation about the precarcity of UI driven testing; especially as the reflexive test preference.
2023-10-27 Ruby Bundler Tooling for Exploring a Breadth of Gems
A couple of quick functions that came about after a conference workshop. These two functions help track down files and code across the myriad of “bundled” libraries.
2023-10-25 Test Driven Debugging
A presentation for Samvera Connect 2023 where I went over a real world scenario of resolving a bug by way of writing tests. This involved refactoring to improve the state of the code while also demonstrating expectations around the given solution. From this, I generalized an approach for fixing bugs within an application; and provide guidance on how to submit those changes upstream.
2023-10-15 Copilot and the Art of Distraction
I have found Copilot detremental and distracting to my programming process. It offers up solutions that are not 100% accurate, but more damning than that expands the context of writing code to one that involves writing, editing, and reading code in many small bursts. Which I have observed accelerates my mental exhaustion, because I’m now more rapidly context shifting.
2023-10-05 Using Checklists for the Win
A walk through of using Ruby and diff to help generate a checklist of tasks for reviewing and remediating files.
2023-10-04 Adjusting Emacs to Shift with a New Project Organization Strategy
A quick walk through of adjusting the projectile package to use fast file finding and not include git submodules in those file lists.
2023-10-01 Calculating Default Stat Arrays for Errant
A quick post about default attribute arrays for pre-made characters and determining what that array should be for Errant’s attribute generation of rolling 4d4 four times. Hint, it is 12, 11, 9, 8.
2023-09-27 Emacs Function to Calculate an Errant's Movement Dice
In this post, I share Errant’s Chase procedure. I then write out the mathematics of calculating the movement dice. And from there provide an Emacs function for calculating movement dice. The chase subsystem is too interesting to ignore the movement dice. The underlying question is “should we care about the movement dice in combat?” I think so, because those dice add to the unpredictability of the game.
2023-09-03 A History of the Text Editors I've Used
I take a tour of the text editors I’ve used and why and when I moved on from them. Along the way, I write up some further insights into what I’m looking for and how I practice and explore a new to me editor.
2023-08-31 Working with a Software Stack that Involves Many Repositories
Given that modern software builds on many small components, when troubleshooting across those components, I find it helpful to have a local copy of many of those components. I also find it useful to have a versioned copy, so I can review the historical state of the component. In this post, I go through some of the pros of having local clones of component repositories.
2023-08-25 Using Emacs’s Tramp to Edit Files on a Rancher-backed Kubernetes
In this post I walk through a problem I had regarding editing remote files. I describe an interim solution and then how I used kubectl and tramp to later edit the files “locally.”
2023-08-24 Testing a Method Outside of the Application Test Suite to Speed Up Iterations
A walk through of building fast RSpec tests to iterate on a low-level function. This post talks about the idea of using test tables to help provide examples of both given inputs and expected outputs. I also walk through a refactoring.
2023-08-18 Github Merge Request Strategies for Incorporating Changes into Main Branch
Some research and background around Github merge strategies, along with a recommendation based on the discussion.
2023-08-15 Emacs Functions to Navigate Ruby Files by Method Comments
Questions about idiomatic code lead to thinking about how I might use that idiom for navigation; which meant “Time to hack on Emacs” and write up some functions for navigation.
2023-08-12 Skipping Your Parent to Go to Your Grandparent: Leveraging Ruby's super_method Method
A walk through how to get the super of a Ruby method’s super; or grand super. And more importantly how to skipping calling super and call the grand super by using Method#super_method.
2023-07-30 Implementing Changes to Org-Mode Time Tracking
A walk through of my functional adjustments to my time tracking in Org Mode. These adjustments leverage functions that I had already developed and align with other existing processes.
2023-07-29 Revisiting My Org-Mode Time Tracking and Laying out a Different Direction
Working through my existing note-taking and time-tracking approaches and outlining a new direction; favoring thinking and task cohesion over easier time-reporting.
2023-07-28 Dynamic Org Agenda List Based on Denote Keywords
Porting some Functions for Org-Roam to Denote
2023-07-15 Refactoring to Understand a Code-Base
A Few Strategies
2023-07-14 Decorating a Ruby Exception to Provide Further Context
A Quick Hack to Expose More Details
2023-05-17 Unfurling of Issue Reference Abbreviations in Github and other Git Forge Issues
Making it Easier to Minimize Risk of Information Loss
2023-05-17 Configuring Emacs to Automatically Prompt Me to Define the Type of Commit
Adding a Function to Help Establish a Habit
2023-05-07 These Are the Tools I Know I Know
Have Toolbox, Will Share
2023-05-07 Completion at Point Function (CAPF) for Org-Mode Links
Leveraging cape and org-element-map
2023-04-16 I am Presenting at Rails Conference 2023
Come Join Me and Share Your Tools
2023-04-03 Responding to “Things Your Editor Should Have”
Invest in Your Tools
2023-04-02 Make the Feedback Fast
…Then Get the Fast Feedback
2023-04-02 Take on Recursion Redux
Thanking a Reader and Adding Some Recursion Testing Strategies
2023-03-27 Expanding on using Tree Sitter in Emacs for Getting Qualified Ruby Method Name
Minor Refinements of a Recently Created Function
2023-03-26 Responsible and Sustainable Overrides in Ruby and Samvera in General
My Presentation for Samvera Connect 2022
2023-03-26 Closing the Knowledge Gap and Lightening the Load
Somedays You Just Can’t Get Rid of a Bomb
2023-03-26 Determining All of the Descendents of a Ruby Class
A Real World Example to Help Understand a Data Model and Possible Discrepency
2023-03-25 Using Built-in Emacs 29 Tree Sitter Package to Get Qualified Ruby Function Name
A Rainy Day Coding Practice Session
2023-03-18 Creating an Emacs Function to Create Yardoc Stubs
When One Pathway Fails, Try Another
2023-03-08 Coloring Regular Expression via Modus Themes for Treesit Faces
Adding a Bit More Color to My Baseline Theme
2023-02-28 Utilizing Ruby’s Delegate Method
Working with the Principle of Least Knowledge
2023-02-28 Adding Consistent Color to Emacs Mode Line and iTerm Tab for Various Projects
An Evening of Hacking to Provide Visual Clues for Varying Contexts
2023-02-25 My Lesser Sung Packages of Emacs
Spending a Bit of Time Sharing Some Perhaps Lesser-Known Packages
2023-02-13 Adding Complex Keyboard Modifications via Karabiner as an Emacs Experiment
Drawing Inspiration from Others
2023-02-11 Custom Org-Mode Capture Function for Annotating Bad Code
Something Borrowed, Something Old, and Something New
2023-02-10 Thinking Through Capturing and Annotating “Bad” Code
First Steps in Following up on Morning Coffee Talk Inspiration
2023-02-07 To Rob a Fox…
In Programming, Don’t Let Clever Trample Understanding
2023-02-07 Refactoring a Ruby Module to a Class
Setting up a Few Straw Dog Examples
2023-01-31 Building on My Project Notes and Dispatch Emacs “Package”
Accretion of Functionality Through Crafting and Extending
2023-01-29 Emacs Windows Configuration Desired State
From Deliberation to Liberation (in the Minutia of My Tools)
2023-01-26 SoftServ - Software Services for Life Science Research Companies
Proud to Be Part of Scientist.Com
2023-01-12 Using the Git Interactive Staging as a Moment to Facilitate Synthesis
Revisiting Past Writings, Further Describing Personal Workflow, and Issuing and Admonition
2023-01-10 How to Grow Programmer Instincts to Help You Avoid Bad Pathways
Or, How Does One Share Lessons Now Internalized?
2023-01-09 Reflections on the Skills That Have Helped Me Continue as a Developer
Hint, It’s Not About Chasing New Technology
2022-12-18 Walkthrough of my Project Workspace Functionality
Moving Quickly to Project Work Spaces
2022-12-14 Using Git Bisect and Other Commands to Determine When Something Was Removed
Quickly Sleuthing through a Code Base
2022-12-09 Playbook Article for Upgrading a Gem within a Ruby Application
Leveraging Checklists to Guide the Work
2022-11-19 Project Dispatch Menu with Org Mode Metadata, Denote, and Transient
Creating a Means of Quickly Navigating Amongst a Projects Important “Pages”
2022-10-24 Adding a Function to Carry Forward an Org-Mode Agenda Item
Delving into org-mode and org-element-map
2022-10-16 Adding Another Function to My Workflow
Going down the Blogosphere Rabbit Hole to Find Further Inspiration
2022-10-16 Revisiting the Principles of My Text Editor
My Text Editor Must Facilitate My Engagement with the Ever Evolving Digital Aspect of My Life
2022-10-12 Analysis and Preliminary Work for Importing Functionality from Another Project
Adventist Analysis for AARKD ID (Slugs) Work
2022-10-09 Denote Emacs Configuration
A Literate Configuration
2022-10-06 On Breaking Down Larger Projects
A Meditation on a Question Often Asked of Me
2022-10-04 Analyzing Rails Application Code to Consider for Extraction into a Gem
Lifting the Custom Slugs Functionality from one Application into a Generalized-ish Solution
2022-10-03 Public and Private APIs versus Public and Private Methods
Using API Declaration to State Intention
2022-10-03 Ruby Memoization and Checking if Defined
Exploring the Implementation Details of Instance Variables
2022-10-02 Migration Plan for Org-Roam Notes to Denote
Laying Out a Game Plan
2022-10-01 Exploring the Denote Emacs Package
Some Analsysis of Features
2022-09-28 Leveraging Commit Messages as Pull Request Text
Favor Information in Commit Messages over Web Conversations
2022-09-27 A Walk Through of a Code Sleuthing Exercise
Using a myriad of tools to orient
2022-09-26 The How of Take on Rules
An Overview of How I Make this Site
2022-09-06 Org Mode Capture Templates and Time Tracking
Sharing My Workflow and Tooling
2022-08-24 Everyday Custom Git Commands
Paying Attention to What I Repeat…And Documenting It
2022-08-23 Differentiating Ruby’s Classes and Objects
Delving into the Foundational Distinctions
2022-08-22 Joining Scientist.com's SoftServ Team
A Quick Introduction to my Role and the Technology
2022-08-01 Today I Learned about Difftastic
Adding Another Tool for Code Review and Comparison
2022-07-30 Commit Messages Do Matter
Responding to Those Who Say They Don’t
2022-07-20 On Ruby Keyword Args, Structs, Splat, and Double Splat Operators (Oh My!)
Dissecting an Approach to Solving a Coding Challenge I Encountered in the Wild
2022-07-15 SQL Proof of Concept for Collating Different Article Feed Selection Criteria for DEV.to
Scratching Down Some Ideas to Share
2022-07-06 Responsible Monkey Patching of Ruby Methods
Steps for Patching in a Responsible Manner
2022-07-03 That Time When the Only Test and Development Environment Was Production
If You Can Habitualize One Thing as a Developer It Is Create Quick Feedback Loops
2022-06-15 A Second Walk Through of Composing a SQL Query
Showing my Work as I Query a Forem Instance
2022-06-12 Walk Through of Using Postgresql and Blazer to Generate a Cohort Report
Step-wise Composing Larger Queries from Smaller Queries
2022-06-05 Redefining Ruby Instance Methods at Runtime
Or With Great Power Comes Great Responsibility
2022-06-04 Leveraging Instance Variables in Ruby Classes
Hint - Prefer Methods over Instance Variables
2022-06-03 Adding Reproducible Randomization to SQL Queries
Or How I Spent an Afternoon Building Out More Creases for Extensibility in Forem’s Feed Query
2022-06-01 Using Ruby to Merge Traveller and Stars without Number System Generators
Or How to Use Your Hobby to Keep your Professional Skills Sharp
2022-05-14 Benefits of Having a Call Method for Your Ruby Object
Exploiting Ruby’s Object Model to Ease Collaboration
2022-04-29 On Sharpening Your Tools
Using a Tool and Knowing Its Uses Are Not the Same
2022-04-28 Working on Open Source Community Software Is My Job
And How to Hopefully Create Win/Win/Win Scenarios
2022-04-23 Diving into Dev's Relevancy Feed Builder
SQL Composition by Configuration
2022-04-02 Org-Mode, Git Logs, and Org-Babel for Running Reports
Feeding the Personal Knowledge Management System
2022-04-01 Application Exception Handling in Rails
A Quick Tour through (Some of the) Layers of Propagation
2022-03-31 Today I Learned - Carrier Wave and How to Test Uploading a New Image to a ActiveRecord::Base Model
Managing Object State is Hard
2022-03-29 The Three Caches of Forem
A Quick Tour of Our Favorite Performance Enhancing Pain Point
2022-03-19 Regarding Documentation: A Letter to My Earlier Selfs
Apologies, Confessions, and Meanderings
2022-03-17 The Why and How of Yardoc
Inching Along the Never Ending Path of Improving of Documentation.
2022-03-13 Further Into Emacs with Pcase, Backquotes, and Commas
The Continuing Adventures of Writing to Learn
2022-01-17 Switching from Company to Corfu for Emacs Completion
Thinking Through the Principle of Discovery
2022-01-13 Emacs Packages to Get Stuff Done
Recording and Replaying Keystrokes
2022-01-11 Resolving an Unable to Resolve Link Error for Org Mode in Emacs
Documenting to Share a Solution
2022-01-03 Forem Feed Experiment One
January Results
2021-12-20 The Serendipity of Pairing with a New Developer
Learning as I Watch Others Navigate Their Toolbox
2021-12-02 Ruby Script to Find Local Branches with Deleted Remotes
Pivoting from One Strategy to Another
2021-11-29 Keeping the Stakes Low while Breaking Production
Using Existing Tooling to Make Changes Reversible
2021-11-18 Gently Embracing Different Regular Expression Approaches in Ruby
A Straight-Forward Problem with Three Different Approaches
2021-11-13 Send Anything in OS X to Emacs for Editing
Hacking Away with Hammerspoon and editWithEmacs
2021-11-10 Further Hacking on Emacs for Github Pull Requests
You Ain’t Emacs-ing if You Ain’t Always Hacking Your Config
2021-11-05 Emacs Function to Open Magit Log PR at Point
A Quick Hack to Help My Code Spelunking
2021-11-03 Building and Documenting a Nuanced ActiveRecord Approach
Or How I’m Working to Improve the Feed Relevance of DEV.to
2021-10-28 Practicing Postgresql and Postulating (Im)Provements
Returning Again to Databases
2021-08-28 Whipping Up a Quick Emacs Helper Function for Hugo
Continuing to Build Out Utility Functions
2021-08-26 Adding More Tag Rendering Functions for SHR in Emacs
Adding More Default Styles of Browsers
2021-08-23 Diving into the Implementation of Subject Menus for Org Roam
It’s Macros, Functions, and Property Lists…Oh My!
2021-08-22 Ever Further Refinements of Org Roam Usage
Leveraging Some Org Roam Version 2 Changes
2021-08-03 Using Magit Built-in Functions for Workflow
Improving on a Hacked Together Function Using Magit
2021-08-02 Emacs Script to Review Git Status of Repositories
Generating a Quasi-TODO List for a Common Mental Model Task
2021-06-17 Amplifying the Blogosphere (v2021-06-17)
Campaign Play, Mystery, and Group Mythology
2021-06-08 Further Molding Emacs to Reinforce Habits
It Ain’t Emacs if You Ain’t Hacking on Your Config Daily
2021-06-07 Amplifying the Blogosphere (v2021-06-07)
A Mix of Old and New Gaming and Software
2021-06-07 Molding Emacs to Reinforce Habits I Want to Develop
But Also, Don’t Go Out and Implement a Bunch of Things
2021-05-20 Emacs Function to Rename Hugo Blog Post
Writing a Function to Practice Lisp and Complete an Uncommon Task
2021-05-17 Responding to “How to be a senior Engineer?”
For me, it’s about Communication and Mentoring
2021-02-20 Technology Doomed to Repeat Itself
Second Verse, Same as the First, Just a Little Bit Worse
2021-02-11 Posts that Caught My Attention
Two Dots Daring Me To Connect Them
2021-02-05 To the Ghosts, Haunt Elsewhere
This Blog and My Coding Image Is Not For Sale
2021-01-27 On Plain Old Boring HTML
And The Hubris of Disruption
2020-12-28 Probability of Stabilizing the Dying in “Stars without Number”
Another Foray into Probability and Computations
2020-12-20 Many Small Tools Make Light Work (in Emacs)
Stiching Together YASnippet, Hugo Short Codes, Shell Commands, and YAML Files in Emacs
2020-11-11 Synchronizing OSX, Terminal, and Emacs Dark/Light Appearance
Composing Shell, Applescript, and Emacs Eval
2020-10-30 Reducing Duplication in my Emacs Config
Learning from One Small Refactor
2020-10-24 Visual Changes to Take on Rules
Minor Tweaks to Colors and Hover State
2020-10-18 Why I Chose Emacs as My New Text Editor
Hint: I Took the Time to Build What I Needed
2020-05-25 Principles of My Text Editor
Once Again Exploring a Different Solution
2020-05-20 Today I Learned (May 20th 2020 Edition)
Learning Some New Distributed Tech
2020-05-20 Connecting to Bridgy for backfeed and POSSE service
Using Standards to Connect Conversations
2020-05-09 Documenting Decisions to Build Buy-In
Don’t Rely on a Group’s Memory, Write It Down
2020-05-05 Pushing Simplicity Around
Or the Old Adage: There’s No Such Thing As a Free Lunch
2020-05-04 The Joys of a Simple Site
Keeping Simple So It Doesn’t Become a Burden
2020-05-02 Adding Webmention Features
Providing a Framework for Citation and Conversation
2020-05-01 Hugo Tips and Tricks #1
Transforming Dynamic Data via Dispatch Strategy and Set Logic
2020-04-26 Free Time During a Pandemic: Three Weeks Later
Writing Software, Retelling Folktales, Reading Camus and Leiber
2020-04-19 Software to Migrate Data from Square to Shopify
I wrote some custom migraiton software for Square to Shopify. Let me know if you’re interested.
2019-12-20 Influences on my Blog's Design
Waxing philosophical about marginalia, unique and durable tables, pedantic tests, javascript, and updates.
2019-09-05 Why Hugo when I'm A Rubyist
2019-08-24 Exposing More Metadata for Take on Rules
2019-08-17 Ruby Script to Extract Post for RPGGeek
2019-08-07 Adding a “Stars without Number” Dataset for gm-notepad
2019-07-26 Introducing GM Notepad: A Command Line Tool for GM-ing
2019-07-14 The How and the Why of Indices of Game Crunch
I posted my Index of Allowed Classes, Races, Cultures, and Backgrounds on Reddit. And someone asked the following:

Am I missing something here? This is just a list of various races and subclasses for use in your game? Maybe something about why you chose these would be good.
Good question, let me go over the why and the how.
2018-12-18 Building Scripts for my Website
2018-11-20 Own Your Tools
2018-10-31 My Blogging Engine
2012-04-16 At the Intersection of Work, Play, and Learning
2011-06-15 It's Only a Model