Personal notes after three months of switching from Vim/Neovim to the Helix editor: covers Helix’s built-in language-server support, superior repository search, keybinding translations from Vim, configuration examples (including a Python example using pyright and black), annoyances (reflow, lack of persistent undo, manual reloads, occasional crashes), and the author’s terminal-based workflow and simple config.
A practical guide for non-C programmers on compiling C/C++ programs with make: install a compiler, install native dependencies, run ./configure when present, run make, and fix compiler/linker errors by passing flags via environment variables (CPPFLAGS, LDLIBS, CXXFLAGS). Includes tips for building single targets, using implicit make rules, and packaging hints (Homebrew/Nix).
A deep-dive into ANSI/terminal escape codes: what they are (input vs output sequences), the existing standards and documents that define them (ECMA-48, xterm control sequences, OSC codes), and the historical compatibility layer terminfo/ncurses. The author explores why some programs rely on terminfo while others hardcode a "common" set of sequences, highlights interoperability/friction caused by fragmentation (and TERM user-agent style issues), and argues that clearer standardization and better testing across emulators could make terminal features more reliable and usable.
Practical step-by-step instructions for adding a directory to your PATH across bash, zsh, and fish: detect your shell, find the right config file, locate the directory installers place binaries into, add the directory with shell-appropriate syntax, restart/reload your shell, plus troubleshooting tips for common issues (wrong binary order, non-shell contexts like cron, duplicate entries, history behavior) and notes on source and fish_add_path.
A summary of a 1,600-person survey about terminal frustrations that categorizes respondents' pain points — top issues include remembering syntax, switching systems/SSH, color/theme inconsistencies, keyboard shortcuts, copy/paste, discoverability and a steep learning curve, shell history and scripting pain, bad documentation, and scrollback problems. The author reflects on methodology and the broader implications for terminal UX and tooling.
The author outlines what a “modern” terminal setup entails (features like multiline paste handling, persistent history, rich prompts, 24‑bit colour, clipboard integration, good autocompletion, theming and keybindings), describes how the shell, terminal emulator, editor and apps each play a role, and gives practical advice (use fish or zsh/oh‑my‑zsh, pick a 24‑bit terminal emulator, try neovim or newer editors, use base16 themes). The post discusses common pitfalls (shell defaults, editor configuration time, app‑specific quirks, tmux integration) and recommends making incremental changes to avoid breaking the environment.
A developer-focused blog post cataloguing common conventions terminal programs follow (e.g., Ctrl-C/Ctrl-D behavior, 'q' to quit TUIs, limiting to 16 ANSI colors, readline-like keybindings, disabling colors when piping, and using '-' for stdin/stdout), explaining why these conventions exist (POSIX defaults, signal handling, input modes, libraries) and noting common exceptions.
Explains why piped commands can seem to “get stuck”: many programs use block buffering when stdout isn’t a terminal, so slow, incremental output (e.g., tail -f piped through grep) may be held in buffers until they fill. The post describes how programs decide buffering (isatty, libc BUFSIZ), lists commands and language-level ways to disable buffering (grep --line-buffered, stdbuf, unbuffer, python -u, etc.), covers Ctrl-C behavior and flushing, and offers practical workarounds.
Practical guide to importing frontend JavaScript libraries without a build system. Explains the three kinds of distributed JS files (classic/UMD globals, ES Modules, and CommonJS), how to inspect an NPM package and package.json to find them, and concrete approaches: include UMD via <script>, use ES modules with type="module" and importmaps (or download-esm/jspm), and convert CommonJS with CDNs like esm.sh or local tools like esbuild. Includes examples (Chart.js and two Bluesky OAuth libraries), tradeoffs (many files vs bundling, CDN trust), and tooling suggestions.
The author added a new TIL (today I learned) microblog section to their site to collect short, tweet-like notes and links. They created a /til/ folder, custom styling, a Rake task to create posts quickly, and a separate RSS feed, and discuss POSSE, email lists, and which social content they want to archive versus keep ephemeral.
An explainer of how the 33 ASCII control characters behave in Unix-like terminals: which codes the OS terminal driver handles (signals, erase, kill), which are passed to applications (readline, TUI apps), canonical vs noncanonical modes, remapping with stty, DEL vs Ctrl-H/backspace history, and practical debugging (strace, a Python echo-key script). The post highlights historical quirks, platform differences, and practical implications for terminal application authors.
Julia Evans traces an out-of-memory problem in Mess With DNS caused by an in-memory IP→ASN table. She experiments with SQLite (reduced memory but very slow), a trie (worse memory and speed), and then profiles the Go program. By deduplicating ASN metadata into a pool and switching from net.IP to netip.Addr, she reduces memory from ~117MB to ~46MB (saving ~70MB) while trading a bit of lookup speed (~9M/s → ~6M/s). The post covers pprof/runtime profiling, implementation details, and operational motivation (OOM-killed backups).
A step-by-step account of upgrading a personal blog from Hugo v0.40 to v0.135. The author documents breaking changes (template lookup syntax, .Data.Pages -> site.RegularPages, next/prev semantics) and the large migration pain from switching the Markdown renderer from Blackfriday to Goldmark (many Markdown rendering differences and config changes). She describes how she found and fixed regressions (downloading changelogs, generating old/new builds, diffing HTML files), lists specific Goldmark quirks and config fixes, and gives notes on theme maintenance and static-site-generator compatibility.
A practical deep-dive into why terminal colours are tricky: terminals and programs use differing ANSI/256/24-bit colour schemes, emulators map ANSI indices inconsistently, tools can set or assume palettes (causing clashes), TERM/terminfo mismatches cause problems, and vim/Neovim colour modes add complexity. The author explains causes with examples (fd, bat, ngrok, ls, vim), and outlines fixes and workarounds—reconfiguring emulator palettes or using base16-shell, enabling "minimum contrast", using unbuffer or --color flags, tweaking LS_COLORS, and preferring 24-bit colours in modern terminals.
Personal Go web-development notes covering Go 1.22 routing and a trailing-slash gotcha, using middleware patterns, sqlc for generating Go DB code, SQLite tuning tips (SetMaxOpenConns, separate read/write DBs), using GOMEMLIMIT to limit GC memory, and reasons the author likes Go for small websites (single binary, stdlib net/http), plus features they haven’t implemented yet (templates, login, CSRF).
A first‑person post by Julia Evans listing why she prefers the fish shell: it “just works” with minimal config, offers smart autosuggestions and path-aware completions, safer multiline paste, pleasant tab completion and prompt (including git status), robust history behavior, terminal-repair features, syntax highlighting, and easier loop/multiline editing — plus a few downsides (POSIX differences, fish_add_path quirks, default-shell caveats).
The author migrated the Mess With DNS playground from a custom DNS implementation to PowerDNS to fix correctness issues. Key challenges and solutions included intercepting every DNS query (custom Go proxy vs dnsdist), moving DNS logic from the frontend into a new Go HTTP API (to enable tests and simpler UI), generating synthetic record IDs to map PowerDNS recordsets, translating PowerDNS errors into user-friendly messages, and switching from Postgres to SQLite with specific concurrency/tuning decisions. The post also covers frontend work (Vue 2→3, forms, global state store) and project sequencing; the new site is deployed and PowerDNS resolved many prior issues.
Julia Evans describes learning that Go structs are copied on assignment (and how that caused a bug when taking a pointer to a range loop variable), and goes over other common Go pitfalls she discovered (slice backing-array side effects, value vs pointer method receivers). She also points readers to the "100 Go Mistakes" resource, Go documentation/examples, and useful linters/testing tips.
An explainer on why editing and entering text in terminal programs can be confusing: different tools implement input in different ways (no editing, readline, libedit, or custom systems), keybindings and history/search behaviors vary, and there are tradeoffs like licensing and dependencies. The post gives practical tips (Ctrl+A/E, Ctrl+W/U, Ctrl+R, and using rlwrap to add readline to tools), explains origins of common keybindings, and offers a simple flowchart for diagnosing what input system a program uses.
Design sketches for a Python graph layout engine: simple graph API, an intermediate map of vertex coordinates, a sketch of an SVG backend for drawing, plans to use a force-directed (spring) layout with possible Barnes-Hut optimization, and use of CSS to style the SVG output.
