Runtime Arguments

Jim McQuillan & Wolf

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

  1. 20h ago

    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, 2036Postgres transaction ID (XID) wraparound, and how autovacuum (added in Postgres 8, 2005) prevents itThe 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 overflowed16-bit limits on PIDs and TCP port numbersDiscord's issues with Twitter-style 64-bit Snowflake IDs, since JavaScript numbers only safely hold 53 bitsIPv4 address exhaustion and the slow IPv6 transitionAACS DRM's 32-bit hard-coded expiration field, which can make Blu-ray discs/players stop working on a schedule nobody choseThen 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

  2. Sep 5

    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 movingAttention, 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_TheseusSoftware rot (bit rot) — https://en.wikipedia.org/wiki/Software_rotReturn on investment — https://en.wikipedia.org/wiki/Return_on_investmentEpisode 34 — writing your first test, and why a test is a definition of doneEpisode 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_SeagullRadar Chart — The chart Jim couldn't name: a radar chart, also called a spider chart. https://en.wikipedia.org/wiki/Radar_chartHTTP/3 — https://en.wikipedia.org/wiki/HTTP/3Hosts: 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

  3. Aug 22

    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/418Hosts: 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

  4. Jul 25

    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

  5. Jun 27

    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 modelsHosts: 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

  6. Jun 13

    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 threadsTrolltech's distributed C++ build system — compile-farm tied to a specific commit, object files cached and sharedJavaScript 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

Ratings & Reviews

5
out of 5
4 Ratings

About

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

You Might Also Like