Runtime Arguments

Jim McQuillan & Wolf

Conversations about technology between two friends who disagree on plenty, and agree on plenty more.

Play

Open in

20 episodes
fortnightly
Avg 1 hr 19 min
English

Episodes 20

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

#37
Saturday · 1 hr 3 min
37: Unix Year 2038 problem and the art of underestimating
Jim walks through the classic 2038 problem — Unix's 32-bit signed timestamp (seconds since Jan 1, 1970) overflows on January 19, 2038, flipping negative and breaking anything that depends on file/time comparisons (e.g., Make). He compares it to Y2K, tracing the two-digit-year decision back to real storage constraints of the era — punch cards (80 characters each), early hard disks with fixed-size sectors — and argues those were reasonable trade-offs for their time, not simply negligence. That leads into a side discussion (Wolf) about engineering decisions made from measurement versus decisions made from feeling — and why the former holds up better over decades. Also covered: the "DJ10K" problem (fear that 4-digit stock-ticker fields would break when the Dow crossed 10,000 in 1999), and how the 2038 fix has rolled out — 64-bit systems are fine, Linux kernel 5.6+ (2020) handles it, filesystem support varies (ext4 and btrfs/xfs are fine with proper config, older ext3 is not). They compare how databases store timestamps: Postgres' 64-bit timestamptz (good until year 294,276), MySQL's 5-byte datetime, SQLite's lack of a native date type (stored as ISO 8601 strings), and DuckDB's 64-bit microsecond timestamps. The episode then runs through a rapid-fire list of real-world overflow/rollover bugs: GPS's 10-bit week counter, which has already rolled over in 1999 and 2019, and will again in 2038 and 2058 (moving to 13 bits) NTP's 32-bit unsigned rollover coming February 7, 2036 Postgres transaction ID (XID) wraparound, and how autovacuum (added in Postgres 8, 2005) prevents it The Boeing 787's 51-day generator bug (all four generator control units can fail simultaneously if not power-cycled) NASA's Deep Impact probe, lost after a 32-bit tenths-of-a-second counter overflowed 16-bit limits on PIDs and TCP port numbers Discord's issues with Twitter-style 64-bit Snowflake IDs, since JavaScript numbers only safely hold 53 bits IPv4 address exhaustion and the slow IPv6 transition AACS DRM's 32-bit hard-coded expiration field, which can make Blu-ray discs/players stop working on a schedule nobody chose Then a set of leap-year date bugs: Excel/Lotus's belief that 1900 was a leap year (it wasn't — a refresher on the "divisible by 4, except by 100, except by 400" rule), the Sony PlayStation 3 bricking on Feb 29, 2010 (which wasn't a leap year), and the Microsoft Zune's clock freeze on Dec 31, 2008. Closing thought: Wolf ties it back to values — writing software that's fixable and maintainable by anyone, not code where you're the only one who can "pull the lever" (job security through obscurity), which Jim agrees is admirable but ultimately counterproductive. Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Check out our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#36
September 5 · 1 hr 14 min
36: Now, let's talk about leaning the ladder (finally)
It sounds like a productivity episode. It isn't. Everything changes, all the time; what you know is perishable, and so is what you've built. The scarce resource isn't time — everyone gets the same clock — it's attention, and where it lands. So how do you aim it? Wolf makes the case that the answer is values, and that every "should I adopt this?" decision you've ever made was a values call in disguise. Jim makes the case for saying no — and it turns out both hosts are inside the span of success, just at different spots. Also: Wolf confesses to talking too much and not answering questions fast enough. Jim has a fix. Listeners, feel free to hold him to it. Key concepts Bit rot — not the decay of an implementation, but the growing gap between code frozen in time and a world that keeps moving Attention, not time — the clock is the same for everyone; what differs is attention and how hard it hits where you point it. Saying no isn't just declining one thing; it's reclaiming attention you can spend anywhere. Two jobs — keep moving yourself toward the person you want to be, and keep moving your work toward the thing you want it to be. Neither is ever finished. Job one comes first because it compounds: investing in yourself raises the impact of every unit of attention you spend afterward. Values vs. goals — a value is forever; a goal is a place you can get to. If it can be finished, it's a goal. If it can't, it's a value. Leaning the ladder — knowing what's important is what lets you put your attention on the right goals in the right order. Get the order wrong and effort doesn't save you; you just climb the wrong wall faster. Definition of done — every goal needs one. A test is a definition of done that checks itself. (Jim: Seth Godin's version is "does it meet the specification?") Everything is an evaluation (ROI) — what will I pay, what will I gain, what if I wait, what if I don't solve it at all? And who picked the axes? You did. That's what a value is. Success is a span, not a point — Inside the span is success; outside it in any direction isn't. Too far ahead of the evidence is risky, corner-cutting, hard to maintain. Short of the definition of done is bit rot from day one. Different spots inside the span aren't better or worse — the picture is multi-dimensional, like a radar chart. Ship of Theseus — the constant replacement of the pieces is the growth that keeps you level with a moving world. You, your code, your opinions. Don't fall in love with your answer — the moment your defense is emotional instead of a benchmark, you're on the path to bit rot. Love your family and your pet. Not your car, your algorithm, your language, or your database. Friction is a thief — it steals the only thing you have. Note it every time you hit it, and never make the same mistake twice. Make yourself irreplaceable by making yourself replaceable — from Wolf's colleague Dr. Dave: the person who leaves every campsite better and whose work anyone can pick up is the one a company can't afford to lose. The whole episode in one sentence — You have a fixed budget of attention and a target that never stops moving; values are how you aim, goals are where you land, and measuring is how you know you got there. How was your week? Jim read Jonathan Livingston Seagull on Wolf's recommendation and is going back for a second read. Wolf calls it his philosophy in book form. Runtime Arguments book club is apparently now a thing. Jim got HTTP/3 running on HAProxy — and discovered Chrome and Firefox refuse to speak H3 to a certificate signed by your own CA, while Safari doesn't care. Hours of back-and-forth with Claude to get there. Wolf spent a weekend in Ohio at an in-person NROI Range Officer class and is now a certified USPSA RO. Wolf shipped a complete solution to a problem previously thought too hard to keep up with its input (billions of points a day) — roughly an 8,000x speedup over initial attempts. Also 132 hours in a fortnight, which he concedes is a balance problem. The Kinesis Advantage 360 Pro is off Wolf's desk. Absolutely beautiful keyboard; not enough desk time to justify the footprint. Links: Is your ladder leaning against the right wall? — usually credited to Stephen Covey (The 7 Habits of Highly Effective People), sometimes to Thomas Merton. Neither originated it; the earliest known version is from 1915, credited to Allen Raine. https://quoteinvestigator.com/2017/08/17/ladder/ Ship of Theseus — https://en.wikipedia.org/wiki/Ship_of_Theseus Software rot (bit rot) — https://en.wikipedia.org/wiki/Software_rot Return on investment — https://en.wikipedia.org/wiki/Return_on_investment Episode 34 — writing your first test, and why a test is a definition of done Episode 35 — HTTP, the unsung hero of the internet (where the HTTP/3 thread started) Jonathan Livingston Seagull — by Richard Bach (1970). His other notable books: Illusions: The Adventures of a Reluctant Messiah (1977) — "Reluctant Messiah" is the subtitle, which answers Wolf's on-air question — and One (1988). https://en.wikipedia.org/wiki/Jonathan_Livingston_Seagull Radar Chart — The chart Jim couldn't name: a radar chart, also called a spider chart. https://en.wikipedia.org/wiki/Radar_chart HTTP/3 — https://en.wikipedia.org/wiki/HTTP/3 Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Check out our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#35
August 22 · 1 hr 41 min
35: HTTP - The Unsung Hero of the Internet
Jim leads a deep dive into HTTP — how it works, why it's still the backbone of the internet, and what's changed since Tim Berners-Lee built it at CERN in 1991. Wolf and Jim cover the protocol from request methods to modern performance upgrades, with detours into cookies, CORS, WebSockets, and the tools they reach for when debugging. Topics covered What HTTP is: Hypertext Transfer Protocol, created by Tim Berners-Lee at CERN in 1991; a text-based request/response protocol that underlies the modern web and REST APIs. Request methods: GET, HEAD, POST, and friends — including the newer QUERY method (published mid-2026) — plus what idempotency means and why it matters. Headers: Host, User-Agent, Content-Type, Content-Length, cookies, and the Accept header's role in content negotiation. Status codes: the 2xx/3xx/4xx/5xx mental model, the difference between 301 and 302 redirects, and a couple of joke codes (418 I'm a Teapot, 451 Unavailable for Legal Reasons). HTTP versions: from 0.9 (1991, no headers) through 1.0, 1.1 (reusable connections), HTTP/2 (2015, header compression, ~71% adoption), and HTTP/3 (2022, QUIC over UDP instead of TCP — now on roughly 40% of sites). Cookies: how they enable state in a stateless protocol, session-based login, and the tracking side of things. CORS: what Cross-Origin Resource Sharing is, why it's painful, and Jim's approach of funneling everything through a single HAProxy front end to sidestep it. WebSockets: how Jim's team uses them for real-time resource locking and push notifications in their scheduling system. Tools: curl (including the handy `-L` and `-O` flags), Postman, VS Code's OpenAPI plugin, HTTPie, and TCPdump/Wireshark for packet-level debugging (including decrypting HTTPS traffic with browser-exported keys). Also in this episode Catching up on Jim's early-morning bike rides at Kensington Metro Park, and a reminder to wave at fellow trail users. Listener feedback from Marlon (writing testable code) and DaveMQ (mocking in tests, and a callout for Wolf's missing Mastodon announcements). A recommendation of Jonathan Livingston Seagull as a favorite philosophy read. A shoutout to Julia Evans (Wizard Zines) for her HTTP zine. Links: Julia Evans Wizard Zine: https://wizardzines.com/comics/status-codes/ 418 - I'm a Teapot: https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/418 Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#34
August 8 · 1 hr 24 min
34: The Hardest Test You'll Ever Write Is Test #1
Wolf is at the "relies on tests" end of the spectrum. Jim is closer to the other end, somewhere around "how do I start?". He doesn’t need convincing. He just needs to get from zero (non-trivial) tests to one. Today’s episode is a candid discussion where Wolf addresses Jim’s obstacles and tries to "start Jim’s testing engine". With other stuff along the way (as always). Links: Pandoc celebrates 20 years https://pandoc.org/twenty-years-of-pandoc.html C-Kermit releases version 11.0, first release in 15 years https://changelog.complete.org/archives/44456-celebrating-45-years-of-kermit-with-the-first-new-c-kermit-release-in-15-years-and-working-with-a-decades-old-c-codebase Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#33
July 25 · 1 hr 9 min
33: Perl Refuses To Die
Wolf and Jim open with two AI stories from the week. First, the report that an OpenAI model "escaped its sandbox" and went after Hugging Face — a story Wolf finds infuriating precisely because the words don't go together. Reading the actual joint statement, it turns out the incident happened during an internal evaluation explicitly designed to push models toward advanced exploitation; the model found a zero-day in the package registry cache proxy, escalated privileges, and moved laterally until it reached a node with internet access. In other words: they built a gun, and it fired a bullet. Then Jim covers Linus Torvalds' LKML post declaring that the Linux kernel is not an anti-AI project and that AI is a useful tool for developers — following similar comments from Andrew Tridgell of Samba and rsync fame, and drawing similar backlash. That leads into a candid discussion of AI's loudest critics, why Jim (a skeptic himself as recently as February) thinks most of them are working from an outdated picture, and where "adapt or die" lands when it's your own brother's freelance copywriting career that dried up. The main topic is Perl — not how to write it, but why a language that once owned the world became one you'd never pick today. Jim traces his own path from a million-plus lines of COBOL to Perl in 2000, including the genuinely clever trick of linking the Perl runtime into the AccuCOBOL C bridge so COBOL programs could talk to Postgres — which let him replace the system one piece at a time over about nine years without ever stopping the world for a rewrite. That sets up Wolf's rule (if your plan is to rewrite everything, you've already lost, see also: Netscape) and the argument that Perl 6 broke exactly that rule, fracturing the community for years before finally becoming Raku. The hosts dig into the numbers: of ~17,500 GitHub projects created in 2026 with 100+ stars, exactly three had Perl as their primary language — 49th out of 116. Along the way: CPAN as possibly the first package repository, why Python is like coming to work to play with a puppy and Perl is like petting your porcupine, the languages that actually protect you (Rust, Swift, TypeScript) versus the ones that just let you do anything, the companies still running on Perl (Booking.com, Craigslist, cPanel, DuckDuckGo, IMDb, Ticketmaster, Shutterstock, Slashdot, Bugzilla), and Wolf's verdict — Perl is dead in the way COBOL is dead — followed by a genuinely warm case for why that leaves Jim in an enviable position. Links: OpenAI / Huggingface incident: https://openai.com/index/hugging-face-model-evaluation-security-incident/ Linus Torvalds LKML post about AI being a useful tool: https://lore.kernel.org/linux-media/CAHk-=wi4zC+Ze8e+p3tMv8TtG_80KzsZ1syL9anBtmEh5Z40vg@mail.gmail.com/ The Tiobe Index showing Perl's ranking: https://www.tiobe.com/tiobe-index/ Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#32
July 11 · 1 hr 45 min
32: Why Rust?
High-points on Rust: how it’s different, how it might help you even if you never actually use it on a project, why people care. … And some things Jim and Wolf have (separately) been working on. Links: SQL 'SELECT * (EXCEPT ...)' new functionality https://peter.eisentraut.org/blog/2026/06/30/waiting-for-sql-202y-stockholm-meeting-report Marlon recommended a book: “the book” (https://doc.rust-lang.org/book/) Rustlings website: https://rustlings.rust-lang.org/ links from Robbie about the LLM episode: https://www.youtube.com/watch?v=05e4AgvXT18 (Never use ChatGPT again) pewdiepie-archdaemon/odysseus: Self-hosted AI workspace. Mentioned by Wolf: https://github.com/wolf/engineering-philosophy Direnv: Home: https://direnv.net Repo: https://github.com/direnv/direnv My PR: https://github.com/direnv/direnv/pull/1594 Atuin: Home: https://atuin.sh Repo: https://github.com/atuinsh/atuin My PR: https://github.com/atuinsh/atuin/pull/2851 Helix: Home: https://helix-editor.com Repo: https://github.com/helix-editor/helix Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#31
June 27 · 59 min
31: Local LLMs: Good Enough Might Be Enough
Jim shares his adventure into running LLMs on his own hardware. For him it's less about saving money and more about privacy — working in healthcare, he can't send patient data to the cloud. App vs. model: Claude Code and Codex are applications, not models. Features like plan mode come from the app. (Wolf's "Opus Plan" is a Claude Code mode that uses Sonnet 4.6 for most work and Opus 4.8 for planning.) Ollama makes local models easy — ~15-min install, runs on macOS/Linux/Windows, and exposes a REST API. Not to be confused with Meta's Llama models. Example: `ollama run llama3`. Parameters & training: Think of an 8B model as "8 billion knobs." Training randomly initializes them, then refines predictions over billions of iterations. Wolf ties this to Markov models (parameters ≈ weighted edges) and the Bayes episode (random init = priors). Fitting big models in memory: Quantization shrinks 32-bit parameters down to ~4 bits. Mixture of Experts (MoE) keeps only part of a model active (e.g., Llama 4 is ~108B params but ~17B active). Jim's tests (M1 Mac Studio, 64 GB), asking why H₂O is liquid: Llama 4 Scout took ~10–15 min and maxed out RAM/swap; Llama 3 (8B) answered in ~31s; Qwen (36B) gave the best answer in just 34s. The open question: Is local "good enough"? Wolf's real test isn't trivia — can a local model write and iterate on an 8-page implementation plan? (Homework for Wolf's 128 GB MacBook Pro.) Build your own: Fine-tune an existing model or train from scratch. Jim's dream: a local model fine-tuned on his DB schema + 2,000 SQL queries so users could ask in plain English and get runnable Postgres — no cloud required. Browse Hugging Face for specialized models Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#30
June 13 · 56 min
30: Available compute: way more than you need, right up until you need it!
You almost never have exactly the right amount of compute for the job. Either cores are sitting idle while your code runs on one, or you've got more problem than machine. This episode is about the two fundamental tools for closing that gap — and why picking the wrong one makes things slower, not faster. Topics covered: Concurrency vs. parallelism — the core distinction: concurrency is a scheduling problem (you're waiting a lot); parallelism is a compute problem (you need more processing). They are not interchangeable. IO-bound vs. CPU-bound — how to identify which problem you actually have before writing a line of concurrent code. (And a third case: memory-bound, where the fix is data layout, not more cores.) Threads aren't always what you think — system-level vs. user-level threads; why JavaScript's `async`/`await` is single-threaded concurrency and not parallelism; why Go routines can be either. Colored functions / async infection — why `async` spreads through a codebase the way `const` does in C++, and why Go sidesteps it entirely with `go func()`. Go channels and Rust ownership — why these two language designs are the cleanest modern answers to shared-state problems. Python's GIL — what it was, why it hurt, and why 3.14+ removes it (with caveats for single-threaded performance). Amdahl's Law — the mathematical ceiling on how much any parallelization effort can help, and why it's specific to your problem. Hidden parallelism — CPU pipelines and branch prediction run in parallel below your abstraction layer, and you can't see them without special tools. Communication is the real enemy — GPU bus bandwidth, cluster fabric, Apple Silicon shared memory vs. NVIDIA CUDA: the cost of moving data often swallows the benefit of more cores. Fork and copy-on-write — how Unix `fork` got fast, and why Python's reference counting undermines it. The actor model — how Erlang (and now Swift) solve the ownership problem by letting the object own the data, not the caller. Heisenbugs — the bugs that live in parallel code and only appear when you least want them. Examples: Pixar render farms — 130,000 frames × 24 hours each, solved by embarrassingly parallel independent frames `make -j` — the classic CPU-bound parallelism win; why it only helps when you have real cores, not threads Trolltech's distributed C++ build system — compile-farm tied to a specific commit, object files cached and shared JavaScript worker threads and Web Workers — breaking out of the four-query Node.js limit Link to Wolf's dap-mux presentation at mug.org: https://www.youtube.com/live/iyAk8-oE6cM?t=1725 Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#29
May 30 · 1 hr 6 min
29: The Alphabet Soup of Wi-Fi
Jim talks about his struggles to get decent Wi-Fi in all corners of his house. The big issue is all of the numbers and codes and things they use to describe the different Wi-Fi technologies. Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#28
May 16 · 1 hr 31 min
28: Don't let the language be the problem — let the problem be the problem
Don't let the language be the problem — let the problem be the problem. You're not picking a language; you're picking an ecosystem. Boring is a feature. Resume-driven development is real, it's expensive, and everyone has done it at least once. Python is slow. But is your service slow? And is it slow because of Python? If your team is debating the language, you may not be debating the right thing. The language is not the product. The language is the tool. A model change costs 2–3× what a syntax change costs. Budget accordingly. COBOL processes $3 trillion a day. Nobody's talking about COBOL. Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#27
May 2 · 1 hr 26 min
27: SSH and how we got here
From rsh to certificates: The story of how we learned to log in safely. SSH has been around for a long time, over 30 years in fact. In this episode we talk about what came before and why SSH is such a huge improvement. We talk about choices you can make in using SSH, such as choosing the right key algorithm and how to securely store those private keys and how to distribute the public keys. Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#26
April 18 · 1 hr 16 min
26: Why You'll Never Switch Editors (And What You're Missing)
You already have an editor. You already love it. Nothing we say is going to change that — and we know it. But your editor shapes how you think about editing, which means there are problems it could solve for you that you've never even thought to have. We walk through the real differences between editors, IDEs, and the technologies underneath them — TreeSitter, LSPs, the Debug Adapter Protocol — and talk honestly about what actually matters: syntax awareness that doesn't break, language intelligence that works across editors, and where AI fits into all of it. No editor wars, no winner declared. Just two guys who've been doing this for decades explaining why the landscape looks the way it does. What we cover: The spectrum from Notepad to full IDE — and where VS Code actually falls Modal editing (Vim, NeoVim, Helix) vs. chord-based editing (Emacs) vs. point-and-click (the entire rest of the world) TreeSitter: why regex-based syntax highlighting is broken and what replaced it LSPs: the protocol that turned simple editors into language-aware tools Editors as complete environments — Emacs, Smalltalk, and the "world" concept AI integration: editor-first (Cursor, VS Code) vs. AI-first (Claude Code) Muscle memory, sunk costs, and why switching editors is like moving to Australia Can JetBrains (or any company that lives on editor/IDE sales) survive when free tools keep getting better? Links: TreeSitter (https://tree-sitter.github.io/tree-sitter/) — incremental parsing library, originally built at GitHub for Atom Language Server Protocol (https://microsoft.github.io/language-server-protocol/) — the protocol that decoupled language intelligence from editors Helix (https://helix-editor.com/) — modal editor with TreeSitter and LSP built in Alabaster theme (https://github.com/tonsky/sublime-scheme-alabaster) — Tonsky's minimalist syntax theme that highlights what matters XKCD #927: Standards (https://xkcd.com/927/) — the comic about inventing yet another standard (re: IPv8) Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#25
April 4 · 1 hr 8 min
25: The X Window System and Wayland
If you've been using Linux on the desktop you almost certainly have been using the X Window System. In this episode we dive into what that is, where it came from and what kinds of choices you have. We get into the toolkits like GTK and Qt and talk about desktop environments like Gnome and KDE. Then we get into the future, namely Wayland. If you want to run an X client application on a remote server, you need to have an Xserver running local. If your desktop is MacOS, you can install Xquartz. If it's Windows, you can install Xming. If your desktop is Linux, you already have an Xserver running (or maybe you have Wayland, in which case you can run Xwayland). The following command will log you into a remote system where you can run an X client application and have it display on your local desktop: ssh -X user@example.com If you echo your $DISPLAY environment variable, you should see something like: localhost:10.0 That's telling the X client app to send it's data using the X protocol to the your local desktop and proxy it over SSH. The next step is run on an X app. It's easy, just run it: xterm A terminal window should pop up on your local desktop. Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#24
March 21 · 1 hr 8 min
24: Bayes' Rule - The Formula For Learning Everything
If you've ever debugged a program, looked for lost socks or tried to figure out why red spots are developing on your skin, then Bayes' rule was almost certainly used to help you on your journey. Even if you don't know anything about it. Humans have evolved to solve problems but along the way, we as a species sometimes fall for traps or fail to consider all the evidence when figuring things out. In this episode, Wolf explains what Bayes' rule is, how we use it and how we could use it better to solve our mysteries. One sentence Bayes' Rule is the formula that tells you how to update what you believe when you get new evidence — it combines what was already true with what you just learned. The math The probability of A given B equals the probability of B given A, times the probability of A, divided by the probability of B P(A | B) = P(B | A) * P(A) / P(B) Key concepts Bayes' Rule — the formula for updating what you believe when you get new evidence Representativeness heuristic — substituting "how well does this match?" for "how likely is this?" (ignoring base rates) Base rate neglect — the tendency to ignore population-level frequencies when evaluating specific cases Prior / likelihood / posterior — what you believed before, how likely the evidence is, what you should believe now System 1 / System 2 — Kahneman's framework for fast intuitive thinking vs. slow deliberate reasoning The Tom W problem From Kahneman's Thinking, Fast and Slow, Chapter 14. A personality description that tricks you into ignoring base rates. The Sin of Representativeness — Unearned Wisdom The cab problem Also from Kahneman. A witness, a hit-and-run, and the surprising math of why 80% reliability doesn't mean 80% probability. Kahneman's Bayesian inference example Books: Daniel Kahneman, Thinking, Fast and Slow (2011) — the Tom W problem, the cab problem, System 1/System 2, representativeness Sharon Bertsch McGrayne, The Theory That Wouldn't Die (2011) — the history of Bayes' theorem from its discovery through the frequentist wars to its modern resurgence Douglas Hofstadter, Gödel, Escher, Bach: An Eternal Golden Braid (1979) — a Pulitzer-winning exploration of how self-reference and formal systems connect mathematics, art, and music Ernest Nagel and James R. Newman, Gödel's Proof (1958) — a concise, accessible walkthrough of Gödel's Incompleteness Theorems for non-mathematicians Historical: Thomas Bayes (1701–1761) — Presbyterian minister who first derived the theorem; never published it. Richard Price submitted it posthumously. Pierre-Simon Laplace — independently derived and generalized Bayes' work; arguably did the heavier mathematical lifting Tools (if you want to go deeper): PyMC — Python library for Bayesian statistical modeling Bayes' theorem — Wikipedia Thinking, Fast and Slow — Wikipedia Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
- Chapters
#23
March 7 · 1 hr 41 min
23: Containers - What's in the box????
Containers have become the standard way for deploying applications on servers and the web and sometimes even on the desktop. In this episode we dive into what containers are, how they work, how to build them and what you can do with them. Whether you are using containers in your development environment, deploying on servers in your data center or as a cloud service, containers save time, handle dependencies, increase security and just make things easier and better in so many ways. We discuss several commands to build and run containers and we've included examples here: Dockerfile example: ------------------------------------------------------------------------------------------------------- FROM ubuntu RUN apt update && apt install -y apache2 ENTRYPOINT [ "/usr/sbin/apachectl", "-D", "FOREGROUND", "-k", "start" ] ------------------------------------------------------------------------------------------------------- Build the image using the above Dockerfile: docker buildx build --tag my_container ./ Run the container: docker run -p 8080:80 -d my_container Now, point your web browser at http://localhost:8080 (assuming you did this on your desktop) Display a list of running containers: docker compose ls Attach to a running container and get a shell: docker exec -it [container name] /bin/bash Stop a container: docker container stop [container name] Start it running again: docker container start [container name] Remove a container (after stopping it) docker container rm [container name] Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#22
February 21 · 1 hr 22 min
22: With Claude, I'm doing the right things better and quicker
In episode 8, Wolf talks about using AI to write code; and a bit of the landscape around that. In this episode, he describes what he’s learned on his journey from just coding to using AI as a major tool in his toolbox for addressing friction in every area of (mostly) work and (a bit of) life. Less about the landscape and more about the applications, the reasoning, the big-picture, and having the right expectations. Links: Claude best practices guide - https://code.claude.com/docs/en/best-practices Claude Opus 4.6: The Biggest AI Jump I've Covered – It's Not Close - https://www.youtube.com/watch?v=JKk77rzOL34 The OpenClaw Saga: Zuckerberg Begged This developer to Join Meta. He Said No - https://youtu.be/5IzPLjqkFaE?si=P-2Ba1WHXmkU_zOj Seth Godin - https://seths.blog/2026/02/how-to-write-a-coaching-learning-prompt/ Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
- Chapters
#21
February 7 · 1 hr 36 min
21: Everything Is A Database Problem
Jim brings his vast knowledge of Databases and dives into the history, some theory, some best practices and some choices you can make. Links: Claude best practices guide - https://code.claude.com/docs/en/best-practices Passkeys Server and Client - https://github.com/Runtime-Arguments/passkeys-demo Webassembly History - https://bytecodealliance.org/articles/ten-years-of-webassembly-a-retrospective E.F.Codd - Relational Model of Data for Large Data Banks- https://www.seas.upenn.edu/~zives/03f/cis550/codd.pdf - E.F.Codd Lessons about rewriting: https://en.wikipedia.org/wiki/Ship_of_Theseus Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
#20
January 24 · 1 hr 43 min
20: Git protects you
Git is an amazing tool for managing your source code. Lots of people use it every day but most people barely scratch the surface of what git can do. In this episode, we dive in and explain lots of features from the simple to the complex. Links: Julia Evans Wizard Zines https://wizardzines.com - The main page https://wizardzines.com/comics/inside-git/ - The git specific 'Zine Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
- Chapters
#19
January 10 · 1 hr 14 min
19: Data centers - Don't we have enough already?
Data centers are sprouting up every where. Do we really need more of them? In this episode, Jim and Wolf talk about what data centers are, how prevalent they are and what it takes to build them. We talk about the sizes and energy uses and all sorts of other things related to data centers. It was a fun episode to research and very eye-opening. Links: https://statista.com https://cloudscene.com/region/datacenters-in-north-america https://venturebeat.com/infrastructure/inference-is-splitting-in-two-nvidias-usd20b-groq-bet-explains-its-next-act https://energyattheedge.substack.com/p/how-utilities-make-money-capital Wolf’s dotfiles: https://github.com/wolf/dotfiles Direct link to Wolf's Alabaster theme for Helix (now both light and dark): https://raw.githubusercontent.com/wolf/alabaster-for-helix/main/helix/dot-config/helix/themes/wolf-alabaster-light.toml The repo for the dotx tool: https://github.com/wolf/dotx Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
- Chapters
#18
Dec 27, 2025 · 1 hr 2 min
18: The one where Jim asks Wolf questions
This episode is a little different from our normal format. When you listen to podcasts, watch Youtube videos or even sit in a conference room listening to a speaker, they almost always will mention things and assume you know what they are talking about. And lets face it, we don't always know what they are talking about. In this episode, Jim asks Wolf questions. Questions about things you hear in other podcasts (maybe even ours) or other places and you don't really understand what they said so, if you are like us, you have to go look up whatever it was they mentioned, just so you can follow along. It's a fun one and we're sure you'll get something out of it. And, if you have questions you'd like answered, please send them to us. We'll probably do this again sometime. Links: HackerNews: https://news.ycombinator.com/ Advent of Code: https://adventofcode.com/ Hosts: Jim McQuillan can be reached at jam@RuntimeArguments.fm Wolf can be reached at wolf@RuntimeArguments.fm Follow us on Mastodon: @RuntimeArguments@hachyderm.io If you have feedback for us, please send it to feedback@RuntimeArguments.fm Checkout our webpage at http://RuntimeArguments.fm Theme music: Dawn by nuer self, from the album Digital Sky
- Transcript
- Chapters

Showing 1–20 of 20 episodes