DEV Community: Rudolf Olah

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.

React Router has merged with Remix, should you use a different router?

Rudolf Olah — Fri, 17 May 2024 03:18:02 +0000

At ReactConf 2024, the Remix framework team announced merging the Remix full-stack framework into React Router. They reasoned that Remix was becoming a very thin layer over React Router.

Overview of React Router and Remix

React Router Basics

If you're unfamiliar with it, routers provide a way to render a React component based on the URL and URL parameters. That's the most essential feature. The more advanced features of a frontend router include data loading, loading indicators, and server rendering.

Introduction to Remix

Remix is a full-stack framework for React. It consists of a compiler, a server-side HTTP handler, a server framework, and a browser framework. This framework provides server-side rendering, data fetching from the server, progressive enhancement, and state management. Since Remix provides full-stack data flow, it can handle state management, removing the need for libraries like Redux, React Query, and Apollo. Progressive enhancement means that users who have JavaScript disabled for whatever reason can still click links, submit forms, and use the web app.

The Merger Announcement

Critical Reasons for the Merger

The Remix team decided to merge with React Router because they created a framework based on React Router, they believe that all React developers (who use a framework) should enjoy from automatic code splitting, simplified data loading, and server rendering.

Impact on Existing Projects

The Remix team provided an upgrade path that made it easy for React projects using React Router to use Remix. The next version of Remix is now React Router v7. They will likely provide documentation on upgrading from React Router v6 and from Remix to React Router v7, as they have in the past for upgrading from React Router v5, Reach Router, and RouterProvider. Watch for upgrade documentation and news of an upgrade path in the next six months.

Evaluating Your Options

If you are happy with React Router v6 and have been using some of the features that Remix has through other libraries, you should evaluate the current Remix framework and see what it provides compared to what you already have. It may make sense to look forward to an upgrade to React Router v7 (aka Remix v3).

You should take into account the level of effort it would take to upgrade and whether the code base is existing or a new project. If it's a new project, you can evaluate React Router v7 as a framework choice amongst Next.js and other React framework choices.

Suppose all you need is a router for your React pages and components, and you want to avoid any advanced features that React Router v7 will provide. In that case, you should evaluate sticking with React Router v6 or considering the following alternatives to React Router.

Alternatives to React Router

Wouter

Wouter is a well-maintained routing library for React. It has minimal dependencies, is small (2.1 KB gzipped), and has the same basic components as React Router (Link, Switch, Redirect). It provides hooks for the location, the route, and the router, and the API is simple.

TanStack/router

The TanStack/router is a React router written in TypeScript so it's typesafe and it includes built-in caching. It is lightweight (12 KB) and has a lot of functionality. It goes beyond what wouter provides and has overlaps with features that React Router provides such as nested routes, file-based route generation, and automatic route prefetching.
They provide a migration guide from React Router to TanStack/router that you can follow.

Update: TanStack is creating their own React framework powered by TanStack Router, it's called TanStack Start.

Conclusion

The JavaScript and React ecosystems move very fast. The merging of React Router with Remix is one such change. Another change is the encouragement of using frameworks when creating new React projects, deprecating the previous way of using create-react-app. The frameworks modernize the React developer experience and introduce new possibilities for frontend engineers to build great web apps. However, each change also needs to be evaluated before it's implemented, perhaps your project doesn't need all the features provided by a framework, maybe another router instead of React Router works better for your use cases, or possibly it's time to commit to a framework instead of cobbling together random React libraries.

Staying up to date in the tech industry is vital. If you are using React, check out the React blog, the blogs of your favorite React framework, and the GitHub code repos for the React libraries that you use.

Check out ReactConf; it can provide insight into where the industry is going.

There's a blog post about fullstack frameworks and Laravel (a PHP framework):

...JavaScript frameworks do the front-end really well. But you need a back-end, too, for routing and server rendering, which is why things like SSR in Next.js and Remix, and more recently—React Server Components—are born.

Update: The official React docs recommend Vite, Parcel, or RSbuild if you're starting from scratch and do not want to use a full-stack framework like React Router v7 or Next.js.

Kubernetes and Docker Desktop for Fast Local Development

Rudolf Olah — Wed, 08 May 2024 15:11:33 +0000

Docker Desktop can run a Kubernetes node that is accessible locally. It enables you to build and re-build local Docker images and have them available to Kubernetes pods for deployments.

For typical deployments in Kubernetes, you will want to specify a version tag for a Docker image.

For local development with Docker Desktop and Kubernetes, you can set the tag of the image latest or development, any tag without a version number.

You must also set the deployment's restartPolicy to Always and the container's imagePullPolicy to IfNotPresent. This ensures that Kubernetes can pull the image from Docker Desktop, and that it will always restart with the latest updated image.

Then you can run kubectl rollout restart deployment $DEPLOYMENT_NAME to restart the pod and pull the latest development image.

The iteration cycle looks like this:

Write code
Build the image with the development tag
Restart the deployment

You can use fswatch or some other watch tool to monitor changes in source code and kick off the Docker image rebuild and then the Kubernetes deployment restart.

For monitoring the local Kubernetes cluster, I have been using Headlamp which is available as a Docker Desktop extension.

Check "Understand permission requirements for Docker Desktop on Mac" if there are permission or port issues.