Runtime Arguments

Jim McQuillan & Wolf
  • 5.0 (4)
  • Technology
  • Updated Biweekly

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

  1. 2d ago

    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

  2. Aug 8

    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.htmlC-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

  3. 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

  4. Jul 11

    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-reportMarlon 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-philosophyDirenv: Home: https://direnv.net Repo: https://github.com/direnv/direnv My PR: https://github.com/direnv/direnv/pull/1594Atuin: Home: https://atuin.sh Repo: https://github.com/atuinsh/atuinMy PR: https://github.com/atuinsh/atuin/pull/2851Helix: Home: https://helix-editor.com Repo: https://github.com/helix-editor/helixHosts: 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

  7. May 30

    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

  8. May 16

    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

See All (36)

Ratings & Reviews

5
out of 5
4 Ratings

About

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

Information

  • Creator
    Jim McQuillan & Wolf
  • Years Active
    2025 - 2026
  • Episodes
    36
  • Rating
    Clean
  • Copyright
    © 2026 Runtime Arguments
  • Show Website
    Runtime Arguments

You Might Also Like