DEV Community: Rudolf Olah

AI for Less Popular Programming Languages

Rudolf Olah — Sun, 28 Jun 2026 22:57:55 +0000

AI agents are quite popular, from Claude Code to Cursor to Codex, they all can write code for the most popular programming languages such as TypeScript and Python. However, less popular programming languages have their own nuances that can make an AI agent spin its wheels and burn through far more tokens than necessary.

AI Agents vs. Emacs Lisp

I had this happen when using OpenCode and Junie to write an Emacs plugin that had only one file. I sometimes use Emacs as text editor for distraction-free coding, in addition to VS Code, and part of the power of Emacs and other IDEs is in the plugins. Writing new plugins for Emacs or modifying the useful ones requires using the Emacs Lisp programming language.

Balancing Parentheses

Where in a language like TypeScript or Python we assign variables and call functions like this:

test = 123
hello_world(test)

In Emacs Lisp we do this:

(let ((test 123))
  (hello-world test))

Notice the parentheses wrap the variable assignment and the function call? That is what the AI agents kept getting tripped on. It did not matter which AI model I used, they all had issues with unbalanced parenthesis and other syntax errors. As part of the AGENTS.md prompt, I mention ways to check for this with built-in function, check-parens and byte compilation. Unfortunately, while the AI agents could check for this issue, they looped and burned tokens on custom scripts to pinpoint exactly where in the file there was a missing or extra bracket. Remember, this is for a one-file plugin, imagine how bad this could get with more files.

OpenCode with GLM 5.2 wrote custom Emacs Lisp to pinpoint within the file where the missing or extra bracket could be. It rewrote the custom code to check various parts of the file. Each of those is a tool use and many, many tokens burned. The next step is to turn those custom scripts written by the AI agent into a tool to speed up the process, or a skill that shows how to use other tools to speed up the process.

Packages and Dependencies

Another issue is that the AI agents, no matter the model, favoured writing custom code. When pointing out that Emacs packages and dependencies can be added, they needed an addition to the prompt to tell the user of the plugin that the dependency needs to be installed, and to let them know if a fallback is being used.

This could be helped by adding an MCP or tool that queries the Emacs package repository sources. I worked around it by searching for packages myself and then adding them to the prompt. For instance, I mainly use ansi-term as the terminal in Emacs. When I asked the OpenCode AI agent to fix terminal rendering, it tried to configure and fix ansi-term instead of suggesting that more modern terminals such as eat and vterm exist.

For less popular languages that are newer and in rapid active development, the popular packages for them could change from one month to the next. Without a way for an AI model to check for the latest packages to use, the code becomes legacy as soon as it is written.

AI for Less Popular Programming Languages

Which brings us back to how do we optimize AI agents for less popular programming languages. If using AI agents to write a plugin for a text editor that has been around for decades with plenty of code examples, documentation, and tutorials runs into issues, will less popular programming languages require much more effort to be usable?

Here are a few ideas:

Pack more context into the prompt.
Use RAG (Retrieval Augmented Generation) to add relevant examples to the prompt.
Create tools that AI agents can use to speed up linting, formatting, and compilation instead of having them "re-learn" it every time.
Create skills that codify common patterns of testing, debugging, and documenting.
Map one language to another. Instead of using a syntax that can trip up the AI agent, use a different syntax that can then be mapped and transformed into the other language.

Focused Work, Distraction-Free Coding

Rudolf Olah — Sun, 24 May 2026 20:06:00 +0000

With the age of AI agents giving everyone a heightened sense of speed in shipping code, it is valuable for engineers to focus deeply on technical work. The distraction of mobile phones and social networking have been replaced by the distraction of checking what Claude Code is doing, or asking Grok or ChatGPT questions.

The idea of "writer decks", a minimalist computer, is making a comeback as a way to create a distraction-free environment to be able to have a focused work session. One writer set up a laptop with no GUI (no desktop or window manager), and only a text editor with a wiki system and a way to back up the files. You can create the same by finding a quiet spot (or wearing noise-canceling headphones), disabling the wifi on the laptop, and closing all programs so it is just you and the writing. This applies for coding, though you will need a way to look up API documentation. Having a different browser you do not typically use where every website is logged out can reduce distraction.

Distraction-Free Writing

Obsidian
- Zen plugin for Obsidian is a "focus mode" for the Obsidian note-taking app.
- Without a plugin: Close the sidebars and only have one tab open.
Emacs
- writeroom-mode activates fullscreen mode, hides all toolbars and the scrollbar, and disables the mode line.
- olivetti that positions the text in the middle of the screen. M-x package-install RET olivetti then M-x olivetti-mode to activate it.
- Without a plugin: Only have one buffer open, hide the scrollbar and toolbar. I usually have two buffers open for word-wrap and for taking notes in the second scratch bufer.
neovim
- zen-mode
Freewrite has a collection of devices for distraction-free writing

How to Write Code Without the Internet

Programming environments such as Python and Ruby have the ability to print out helpful documentation. Python's interactive shell has the help() command to look up the functions and documentation for libraries. Pry is a Ruby shell that can browse the methods in a package and the documentation for those methods.

PyCharm and VS Code can show auto-complete suggestions with documentation and function parameters.

eBooks, PDFs, HTML Saved Locally

If you are writing bash or zsh scripts, you can use manpages to look up the documentation. For Unity game development, you can download all the documentation locally. Rust also has a way of downloading documentation and generating documentation for all packages used in a project. Many programming libraries offer a way to download HTML or PDF versions of their documentation.

You can buy and download PDFs and ebooks. While books do not have the full API for a library or package you are using, they contain code snippets that can be built upon.

Offline API Viewers

There are offline API documentation viewers that display "docsets":

Dash for MacOS (proprietary, paid) has the documentation for over 200 APIs and over 100 cheat sheets, and the ability to generate documentation for packages for Swift, Python, Ruby, PHP, Java, Go, Rust, Scala, Dart, Haskell, Hex, Clojure.
Velocity for Windows (proprietary, paid) does much the same as Dash does.
Zeal (open source, free) is a free/libre/open source docset viewer that runs on Windows, Linux, and BSD. While it is possible to build Zeal for MacOS, the recommendation is to download Dash.
DevDocs (open source, free) is a local offline documentation viewer. There is a hosted version that can be used offline in a web browser.

Engineering Management Tools: My Top Picks

Rudolf Olah — Sun, 01 Mar 2026 14:35:00 +0000

Engineering managers have a different workflow than ICs (individual contributors), and though we often use the same tools, their layout and integration into our workflow are different.

Calendar: Google

The most essential tool is the calendar, and Google Calendar is great. As a manager, creating recurring events such as daily standups or bi-weekly sprint planning meetings is standard.

Creating and subscribing to multiple calendars is a good feature. Depending on the number of projects and teams, creating a separate calendar for recurring events can make sense. Many organizations have a separate calendar for engineering department meetings and presentations. Any meetings affecting multiple departments or teams within a department could be on a shared calendar. Office hours are another candidate for a shared calendar across the organization. Multiple shared calendars are useful in keeping the main calendar manageable.

For ICs, setting up “focus time” in the calendar is a good way to let engineering managers know when they can schedule meetings to avoid interrupting focused work time. Subscribing to multiple calendars is also great for keeping track of holidays and out-of-office time, which can affect capacity planning and on-call schedules.

Tasks, to-dos: Todoist, Google Tasks

There are many task management and to-do list tools out there. Previously, I used Todoist for task management and tried out a few different tools.

The best to-do list is close to the other tools you use for managing a team.

If you live in Google Calendar, then Google Tasks is a good choice since it integrates directly into the calendar, and like calendars, you can create multiple to-do lists. You can set tasks to repeat, a good reminder that appears in the calendar without taking up a block of time. Tasks are a good reminder for various preparation work for project planning and roadmapping.

Notes: Notion, Obsidian, Google Docs, Slack

For short-form notes, what I’ve found works best is using whichever tool is available. If I’m in a meeting on Google Meet or looking at the calendar, I can use Google Keep for notes. If I’m in a Slack huddle or see something in a channel or thread that I want to write a note about, I use the “Direct Message to self” feature of Slack as a note-to-self. I use Notion or Obsidian for long-form notes or for turning short notes into long-form ones. Writing notes and creating links between them is very useful. The links between notes make it easy to refer to past notes about meetings or additional notes about documents.

One of my workflows involves using Slack and Notion. I use Slack for a summary that can be copied/pasted to various channels and threads and Notion for a longer-form note with more details that I rewrite later for different formats (e.g., a technical spec, engineering brief, a company-wide presentation, or during a 1:1). The same applies to Teams, Google Docs, or other tools.

Obsidian Plugins

There are many plugins for Obsidian to help you with note-taking and creating a knowledge base:

Checklist: This plugin gathers all checklists, to-do lists, and tasks across all pages and puts them in the sidebar. It makes it easy to create checklists in daily notes and keep track of which ones are completed later.
Note Refactor: This plugin enables you to select text and extract it into a new page. Do you have a long page with many notes about different topics written while you were in the flow? That’s no problem; you can branch out into new pages with the Note Refactor plugin.
Periodic Notes: This plugin will create weekly, monthly, quarterly and yearly notes for you at the click of a button. This makes it easy to summarize your week or month. As an engineering manager, I found that a monthly list of what the team got done last month and what was upcoming was great for communicating the value the team was delivering. The quarterly notes can tie into organizational goals.
Iconize: add icons to files and folders; this plugin is good for highlighting very important pages with a visual cue.

1:1s and Career Goals: Lattice

Lattice is incredible for this. The software formalizes what’s usually in spreadsheets or in document templates. For 1:1s, I encourage ICs to add topics; it’s a checklist to ensure we cover each topic. There’s also a checklist of “action items” for the IC and myself to ensure we follow up with concrete actions based on our conversations. Another great feature is the career track and career goals. The org can set up the templates for the career track, and I can work with an IC to turn those into specific goals. Lattice makes it far easier to collaborate with an IC on their goals and to ensure there’s accountability from myself and the IC on accomplishing things that not only move the company or projects forward, they move the IC forward in their career.

Diagrams: Lucidchart, Drawio

Lucidchart and Drawio are great diagramming tools. Lucidchart has many great templates to use as starting points, such as user journeys, use case diagrams, sprint retrospectives, roadmaps, and cloud architecture diagrams. Drawio also contains many great templates and can be downloaded locally. I primarily use Drawio for engineering architecture diagrams.

Both Lucidchart and Drawio can be used for quickly sketching out diagrams. The user interfaces are well-designed. Lucidchart has a good collaboration mode, where you can share a diagram and build it out with your team.

SQL Database and Codebase Tools: JetBrains

JetBrains suite for professionals — from IntelliJ IDEA to PyCharm to https://www.jetbrains.com/datagrip/, each tool makes it easy for engineering managers to explore and understand a code base, data models, and database schema.

I use IntelliJ IDEA to get up to speed on a codebase by searching the code or clicking through to see the usage and definitions of methods and classes. The integrated debugger works great for Python and Ruby codebases, and the autocomplete and code navigation for TypeScript codebases are fantastic.

The database tools in JetBrains IDEs allow you to connect to various data sources, from DynamoDB to PostgreSQL to ClickHouse to Redis and SQLite. The tool lets you run queries and edit records and rows within the editor, which is good for checking data and modifying it during testing. It’s also possible to sort, filter, and search the data locally and to compare data.

While there are other database tools, having an integrated database viewer in your IDE that sits beside the code that creates and updates that data is very useful.

Password Management: 1Password, Bitwarden

1Password and Bitwarden are solid choices for password management. Both feature vaults that can be shared with team members and across departments. They both feature Single Sign On, which enables your IT department to control access to the vaults. Bitwarden is also open source, with the core code licensed under the GPL.

For software engineers, IT, and DevOps, the CLI, and APIs offered by 1Password and Bitwarden allow for the automation of secrets management and vault management.

Learning Coding from High Skilled Professional Programmers

Rudolf Olah — Sat, 06 Sep 2025 14:29:54 +0000

So, to be a prolific programmer, what does it take? In the past, we would have to sit beside the programmer or have them describe their workflow to us. With streaming platforms, we can observe how software engineers approach problem-solving and learn from their approaches, which can help improve our own.

Live Stream Programming

I was watching a few videos from the George Hotz streaming archives on YouTube. George Hotz, more popularly known as geohot, is a prolific programmer who has jailbroken the iPhone and PlayStation 3, built open source semi-autonomous car software, and, more recently, founded a machine learning startup. What's interesting is his approach to tackling challenges, such as building a neural net chess engine.

Coding Questions

Another interesting selection to watch is from Neetcode, videos that walk through solutions to LeetCode problems.

For example, in one video, it begins with a review of the question, followed by a diagram to map out the inputs and steps to achieve the expected output, and then the coding is presented.

No matter the question, this is the overall process for coding interviews. Where it gets interesting is the code implementation. As it's walked through, take note of where there's a pause and where the solution is checked and stepped through. The debugger can help step through code.

AI Pair Programming

Gene Kim paired with Steve Yegge, an incredible engineer and writer, on chat-oriented programming, basically AI pair programming. You can find Yegge's writings from 2005 to the present, and they're all good stuff. Within many essays, there are a few lines that can have a significant impact on how you write code and approach problem-solving. In Yegge's essay "Innovation 101," for example, there's a section on why he writes essays.

The video walkthrough effectively demonstrates the process Yegge uses to work with an AI copilot and how knowledge transfer and training occur.

Open Source History Class

There is a wealth of open source code out there to learn from. There are even two great books that discuss the architecture, system design, and code for various open-source projects. However, this focuses on the code at a certain point in time.

An interesting way to learn is to attend history class. By going through the past commits in a project, you can see how the code got into its current shape.

The llm command line tool provides an instructive example. The code for llm is written in Python and began with prototyping, with the first commits made on April 1st, 2023. The first commit sets up a GitHub Action workflow to test and publish the Python package; it also has one command. From the start, it's possible to use the tool, test it and publish a package to distribute it more widely.

The initial design of llm is documented through the open GitHub issues. One of the issues opened was "command for browsing captured logs", and it contains a few ideas on implementation. The expectation is revised and then closed out with a pull request. What's interesting is that this is still the initial part of the journey to building a new command-line tool. The issues are used as documentation and then quickly closed out with an implementation.

Let's think about the alternatives to this. If we start a project and create a comprehensive list of tasks using issues, we may reconsider our approach and close many of the issues. What about beginning with no issues listed and only documenting through pull requests? This approach can work; however, the design will already be in place, and we may not see the complete set of techniques that have been tried. By opening issues that are going to be worked on soon (within a day or within a week) and commenting on them, a trail of code and design breadcrumbs is created, along with a place to document the various approaches tried. Commenting on the design and leaving notes for yourself (and your team) about considerations that changed the design helps you in the future when looking back at how and why the implementation is the way it is.

Books and Courses

Books and video courses from highly skilled engineers are worthwhile to read and watch, because they can contain insights on how to improve the effectiveness of your problem solving skills.

Zed Shaw has written a few books on learning to program in Ruby, Python, and C, plus video courses on those. In "Learn Ruby the Hard Way", exercise 7 has a set of study drills: write a comment for each line of code, read it out loud to find errors, keep track of any mistakes you've made in the code, try to avoid repeating the mistakes in the next exercise. This is valuable advice and can help clarify your understanding of the code base and when reading through merge requests and other people's code. Many books and video courses contain these valuable productivity tips and insights about the author's workflow but you may need to dig through to find them.

From Your Software Engineer Coworkers

In the above, I've covered the ways you can learn from great developers who develop in open source or stream their coding sessions. You can apply some of that to learning from your coworkers. Read through their code and code commits, read through what they comment on code reviews, and ask them about their workflow. They may utilize many keyboard shortcuts or use specific extensions and plugins for their IDE. When they plan their work out, they may use a TODO comment in the code or a simple list in a notepad or another method. Whatever their strategies, processes and systems thinking they use, you can ask and learn from them.

Debian GNU/Linux in VirtualBox on MacOS M1 to Practice Kubernetes

Rudolf Olah — Sun, 11 May 2025 16:45:13 +0000

When studying for the CKAD (Certified Kubernetes Application Developer) exam, I practiced using the Killer Coda CKAD scenarios and the Killer Shell Exam Simulator. The exam simulator sets up a remote Linux XFCE desktop environment with a browser and terminal.

When practicing various Kubernetes commands, I used minikube and colima to set up Kubernetes with Docker. However, this isn’t the same experience as navigating a desktop with a specific resolution, set of tools, and slightly different keyboard shortcuts. To get the same experience, without being limited to a few exam simulator sessions, I looked into VirtualBox and Vagrant. VirtualBox is a virtualization system, and Apple Silicon chips became supported by VirtualBox in September 2024.

VirtualBox 7.1

Here are the steps I took to run a Debian desktop environment in VirtualBox:

Download version 7.1+ of VirtualBox for macOS / Apple Silicon hosts
Download an ARM64 ISO for the Debian GNU/Linux distribution
Install VirtualBox
Start VirtualBox
Drop the Debian .iso file onto VirtualBox
1. You can “skip the unattended installation”
2. Set the hard disk size, base memory, and number of processors
Adjust the amount of storage in the settings for the virtual machine
Go to Settings > Display for the virtual machine and change the “Scale Factor” from 100% to 200% (or larger)
Go to Settings > Network and change “Attached to” from NAT to Bridged Adapter, the Adapter Type to “Intel PRO/1000 MT Desktop (82540EM),” and the Promiscuous Mode to “Allow All.” The network settings must be fixed if the network mirrors do not work correctly during the installation process.
Start the virtual machine and follow the usual steps for a Debian installation

For Kubernetes, you can install kubectl and minikube via apt-get:

# kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl"
chmod u+x ./kubectl

# minikube
curl -LO https://github.com/kubernetes/minikube/releases/latest/download/minikube_latest_arm64.deb
sudo dpkg -i minikube_latest_arm64.deb

# test the installation
minikube start
kubectl get po -A

You may need to unset the following VirtualBox global setting because it could cause issues with spinning up a virtual machine on Apple Silicon:

VBoxManage setextradata global "VBoxInternal/Devices/pcbios/0/Config/DebugLevel"

Vagrant

Many of the above steps are manual and can be done through the VirtualBox interface. You can use Vagrant to automate the steps. Vagrant makes it simpler to reproduce a working virtual machine environment.

Install Vagrant using Homebrew:

brew tap hashicorp/tap
brew install hashicorp/tap/hashicorp-vagrant

For the manual steps above to change the storage and network settings, this is how you would automate the configuration with Vagrant:

config.vm.provider "virtualbox" do |vb|
  # ...
  vb.customize ["storagectl", :id, "--name", "VirtIO Controller", "--hostiocache", "on"]
  vb.customize ["modifyvm", :id, "--nictype1", "82540EM"]
end

DNS resolution can be provisioned with this:

config.vm.provision "shell", inline: <<-SHELL
  echo 'DNS=8.8.8.8' >> /etc/systemd/resolved.conf
  systemctl restart systemd-resolved
SHELL

Task Runners for Projects

Rudolf Olah — Thu, 26 Dec 2024 18:43:04 +0000

Many projects need to run arbitrary commands and tasks.

In some projects, this is done by creating commands within an IDE such as JetBrains Intellij or VS Code for common tasks such as running tests or building a project.

JavaScript and TypeScript projects can use:

Depending on familiarity with the tools, the simplest task runners are:

shell scripts
Makefiles

Other task runners:

just, stores tasks in a file similar to Makefile format, has CLI completion support and loads .env files
mise, task runner that uses TOML files or standalone files

Keeping Skills Up-to-Date as a Software Developer

Rudolf Olah — Thu, 19 Sep 2024 02:34:44 +0000

Software developers need to stay up-to-date within their specialization and in the general field. If you’re a frontend web dev, you will want to keep up with how frameworks are evolving. If you’re into devops, you’ll need to be up-to-date on the latest build and deploy tools and IaC.

These are my recommended sites for keeping your skills up to date:

O’Reilly Online Learning: features many books, audio books, and video courses along with sandboxes for running code.
LinkedIn Learning: offers a wide range of video courses and is good for a refresher or for getting started quickly with a new tech. It also has business-oriented content if you need to get up to speed on non-coding subjects.
Coding Challenges features a list of self-directed challenges that you can code in any programming language. Some of the challenges include building your own Memcached server and building a Docker container. There’s a nice variety of challenges and by working through them you can learn about data structures, algorithms, and the specifics of a programming language, library or framework.
roadmap.sh - Developer Roadmaps gives you direction to learn parts of the tech stacks for different positions in the field. They also feature lists of projects you can work on to upgrade your skills.
Association for Computing Machinery: ACM members get access to O’Reilly Online Learning, Skillsoft Percipio, and Pluralsight. You also get access to the ACM Digital Library which contains a wealth of information of computer science and software engineering research.

The Power of Tries, Data Structure Optimization in Emacs

Rudolf Olah — Thu, 19 Sep 2024 02:10:33 +0000

The following article, originally published in 2009, was a combination of both prose and code, written in Emacs with a tool called "noweb". I have updated it to not use the special syntax of TeX and noweb. Noweb is a "literate programming" tool, where the usual interplay between comments and code is changed into a complex layering of code and explanations and deep-dives. With the noweb tool, you can export the code into an assembled ordering. This prose/code text can be run through the noweb tool and produce an emacs lisp file. The code that's exported was in blocks that begin with <<>>= and end with @. This updated version includes the assembled code at the end. Zencoding was a way to rapidly generate HTML using CSS selectors.

zencoding-trie

To improve the performance of zencoding-mode, caching/memoization of previously entered input needed to be done. At first, a naive hash-table implementation was chosen and this greatly cut down the speed with which zencoding generated HTML. Then it was realized that a trie data structure would be more efficient as the hash-table was storing partially entered input as well. A trie could store the partially entered data when needed and use less space than a hash-table.

A trie is a tree where each node represents a character in a string. When you reach a leaf node, a word or sentence is spelled out. Each node can contain a value.

Important: the key is not stored in the node, but in the parent of that node.

The only operations we require for our trie are retrieve value and insert value.

A node is a sequence of two elements. The first element is some value, in our case the cached version of zencoding's AST (Abstract Syntax Tree) output. If this is NIL then there is no value stored in this node. The second element is a sequence of branches (more nodes).

(defun make-zencoding-trie-node ()
  "Creates a vector of two elements. The first element is some value, the second element is a character table for storing more branches of the trie. The value is initially NIL."
  (vector nil (make-char-table 'trie-table)))

We need some functions for setting and getting the values of our node type. All of the functions accept a node as an argument which must be a sequence type with at least two elements. The value argument can be anything, typically something non-NIL. The branch-key argument must be a character.

(defun zencoding-trie-node-value (node)
  (aref node 0))

(defun zencoding-trie-node-set-value (node value)
  (aset node 0 value))

(defun zencoding-trie-node-branches (node)
  (aref node 1))

(defun zencoding-trie-node-branch (node branch-key)
  (aref (zencoding-trie-node-branches node) branch-key))

We need a function to access a particular branch in a node. If the branch does not exist, it will be created.

(defun zencoding-trie-node-create-branch (node branch-key)
  (aset (zencoding-trie-node-branches node)
    branch-key
    (make-zencoding-trie-node)))

(defun zencoding-trie-node-brancher (node branch-key)
  (let ((branch (aref (zencoding-trie-node-branches node) branch-key)))
    (if branch
    branch
      ;; branch doesn't exist, so create it and then return it.
      (zencoding-trie-node-create-branch node branch-key))))

The retrieval function is given a string s to search for and the trie to search within. Where n is the length of the string s, the argument i is bounded like so: 0 < i <= n.

We are moving forward through a string till we reach its end. The current character is s[i - 1]. If the current node we are visiting in the trie contains the current character as one of its branches, then we have to visit it.

When the end of s has been reached, i = n, then we have reached the correct node and can return it (it will be created if it doesn't already exist). Before this, we will have to keep on searching for the right node.

If we reach the end of the trie before the correct node has been found, we return NIL.

The traverse function is a generalized version which includes a function argument, f, telling us how to select the next branch to visit.

(defun zencoding-trie-traverse (s trie i f)
  (if (null trie)
      nil
    (let ((branch (funcall f trie (aref s (1- i)))))
      (if (or (null branch) (= i (length s)))
      branch
    (zencoding-trie-traverse s branch (1+ i) f)))))

(defun zencoding-trie-retrieve (s trie)
  (zencoding-trie-traverse s trie 1 'zencoding-trie-node-branch))

Next we have a function for inserting a string and its value into a trie. The pre-conditions are that s is a type of string, value and trie are non-NIL.

We use the previously defined retrieve operation to find the final node and then insert the value there. Fortunately for us, the retrieve operation takes care of creating new branches if necessary.

(defun zencoding-trie-insert (s value trie)
  "`s' is the string used to navigate the trie (each character is a node in the trie). `value' is the value we want to insert. `trie' is the node where we start the insertion."
  (zencoding-trie-node-set-value
   (zencoding-trie-traverse s trie 1 'zencoding-trie-node-brancher)
   value))

The final file looks like this:

;;; zencoding-trie.el --- A trie data structure built for zencoding-mode
;;
;; Copyright (C) 2009, Rudolf Olah
;;
;; Author: Rudolf Olah
;;
;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;;
;; This file is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
;;

(defun make-zencoding-trie-node ()
  "Creates a vector of two elements. The first element is some value, the second element is a character table for storing more branches of the trie. The value is initially NIL."
  (vector nil (make-char-table 'trie-table)))

(defun zencoding-trie-node-value (node)
  (aref node 0))

(defun zencoding-trie-node-set-value (node value)
  (aset node 0 value))

(defun zencoding-trie-node-branches (node)
  (aref node 1))

(defun zencoding-trie-node-branch (node branch-key)
  (aref (zencoding-trie-node-branches node) branch-key))

(defun zencoding-trie-node-create-branch (node branch-key)
  (aset (zencoding-trie-node-branches node)
    branch-key
    (make-zencoding-trie-node)))

(defun zencoding-trie-node-brancher (node branch-key)
  (let ((branch (aref (zencoding-trie-node-branches node) branch-key)))
    (if branch
    branch
      ;; branch doesn't exist, so create it and then return it.
      (zencoding-trie-node-create-branch node branch-key))))

(defun zencoding-trie-traverse (s trie i f)
  (if (null trie)
      nil
    (let ((branch (funcall f trie (aref s (1- i)))))
      (if (or (null branch) (= i (length s)))
      branch
    (zencoding-trie-traverse s branch (1+ i) f)))))

(defun zencoding-trie-retrieve (s trie)
  (zencoding-trie-traverse s trie 1 'zencoding-trie-node-branch))

(defun zencoding-trie-insert (s value trie)
  "`s' is the string used to navigate the trie (each character is a node in the trie). `value' is the value we want to insert. `trie' is the node where we start the insertion."
  (zencoding-trie-node-set-value
   (zencoding-trie-traverse s trie 1 'zencoding-trie-node-brancher)
   value))

(provide 'zencoding-trie)

;; test code
(let ((x (make-zencoding-trie-node)))
  (zencoding-trie-insert "ha" 1 x)
  (zencoding-trie-insert "hi" 2 x)
  (zencoding-trie-retrieve "ha" x))

Docker Compose Develop Watch and Syncing Files from the Host Container to a Service

Rudolf Olah — Fri, 12 Jul 2024 14:02:19 +0000

This thread has helped me better understand the "develop" behavior with Docker Compose

The Docker Compose documentation of "Example 1" in "Use Compose Watch" does a pretty good job explaining things. Perhaps part of it should be added to the Compose File - Develop page instead of hidden by links?

After the service is up, the watch mode starts monitoring the target directories and files. Then, whenever a source file in the web/ directory is changed, Compose syncs the file to the corresponding location under /src/web inside the container. For example, ./web/App.jsx is copied to /src/web/App.jsx.

Once copied, the bundler updates the running application without a restart.

Unlike source code files, adding a new dependency can’t be done on-the-fly, so whenever package.json is changed, Compose rebuilds the image and recreates the web service container.

The "Rebuild Everything" Method

This appears to be the ideal process:

build the image with the current state of files copied into it run compose with watch
whenever a file changes, rebuild the image so it has the updated state of files within it

The "Sync Files Manually" Approach

Alternatively, outside of Docker Compose for syncing files (and based on the suggestions in the thread):

build the image with the current state of files copied into it (use a "watch" or "reload" command built into whatever app you're running)
run compose (do not use develop or watch)
run docker compose cp ./src app:/src this should trigger the watch/reload command within the container

The "Volume Mounting" Method

Another option is to build a base image that does not include source code and only builds an environment in which the source code can be built or run. Then, a volume can be mounted into the container with the latest source code from the host environment, and the code can be run.

Something like this:

build the image with the environment
run compose with a volume mounted
run the steps in the container to build/run the source

It all depends on your developer workflow and what is understandable and can be used daily with minimal disruption to the developer feedback loop.

Things to consider:

how often are dependencies changing? should they be re-installed within the container or should the image be rebuilt (since one of the steps is installing dependencies)?
is there a "watch" or "reload" command that reloads your app based on files changes?
how much time does it take to rebuild the image? is it acceptable to yourself and to your team to wait for a rebuild on every set of source code changes? does it slow the developer feedback loop too much?

Incredible Updates in VS Code 1.91 (June 2024)

Rudolf Olah — Fri, 05 Jul 2024 17:49:07 +0000

Version 1.91 of VS Code is out now and has some incredible updates:

You can now install a specific version of extensions without downloading the latest version. This is useful if there are issues with newer versions or if everyone on the team is running a particular version of an extension.
Override a theme's color or border if you don't like it. You can set it back to "default".
TypeScript 5.5 is included. It enables regular expression syntax checking in JavaScript and TypeScript.
Python: VS Code now uses python-environment-tools to discover all Python installs and virtual environments.
Run "code actions" when saving a file, such as for automatically fixing lint issues.

In-Project Python Virtualenvs in Poetry

Rudolf Olah — Sat, 01 Jun 2024 17:54:43 +0000

Poetry is a dependency and package manager for Python.

You can list the Poetry configuration with poetry config --list
You can set a Poetry configuration option with poetry config $setting $value, for example poetry config virtualenvs.path /path/to/cache/directory/virtualenvs

When a Poetry project is created, the default configuration will create a virtualenv in another directory.

Change where the virtualenv is created by adding this poetry.toml file to your project before you run poetry install:

# poetry.toml
[virtualenvs]
create = true
in-project = true

The documentation for Poetry advises not to check in the poetry.toml into version control since it can contain user-specific settings. You can add poetry.toml to the .gitignore for a repo.

New shell scripting language, a new tablet, and in-product messaging

Rudolf Olah — Fri, 24 May 2024 16:15:26 +0000

Shell scripting times a million

Amber is a new programming language that allows you to write code converted into BASH shell scripts. The language's syntax is a mix of JavaScript, Python, and something else (Kotlin? Rust?). The idea is to write in a language with a modern syntax, type-safety, and safety features.

One of those safety features forces you to write code to handle failures whenever you run a shell command.

The syntax also makes it more apparent that command failures are being handled:

let files = ["config.json", "file.txt", "audio.mp3"]

loop index, file in files {
    $mv {file} {index}{file}$ failed {
        echo "Failed to rename {file}"
    }
}

If you're only occasionally writing shell scripts, Amber may not be a priority for you. In such cases, linting tools like ShellCheck could be more beneficial. However, if you find yourself frequently writing shell scripts, to the point where you're considering Python or Ruby for better re-usability, then Amber is definitely worth your attention.

In-app tour guides are marketing

In "The Slippery Slope of In-Product Messaging," designer Matthew Ström explains that in-product messaging, those product tours you see in web apps, could be a symptom of a "bad" design.

It's an interesting take, though I can't entirely agree. In-product messaging helps guide users/customers through new product features, regardless of whether the new feature's user experience is well-designed.

In-product messaging is another marketing touchpoint that informs the customer about a feature that may not be part of their typical workflow. Not to mention, once a customer/user has seen them, they won't reappear. Think about it this way: from a B2B SaaS perspective, the customer gets an email about a new feature release, logs into the app, and sees a small notification icon or a banner on the page about the new feature release. They go to some other page and get invited to go through a tour of the feature. This kind of repetition is needed even for well-designed user experiences.

A tablet you might use every single day

The Daylight Computer is a mix between the Kindle and the iPad. The screen resembles the Kindle screen, and it has the form factor of an iPad, including a stylus. It is extremely interesting that the screen's refresh rate is much higher than the typical ebook reader. It's high enough to be a tablet.

The Daylight Computer, DC-1, runs Android, so you can run any Android tablet app on it with a kinder and gentler screen for the eyes.

Screen glare is not a problem with the DC-1.

I've bought a few tablets before and used them for reading, watching movies (and sometimes video games and coding). I use them once in a while. I also have a Kindle and use it every day.

It will be interesting to see whether the DC-1 lives up to the hype.