Runtime Arguments

28: Don't let the language be the problem — let the problem be the problem

Sat, 16 May 2026 15:00:00 -0400

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

27: SSH and how we got here

Sat, 02 May 2026 15:00:00 -0400

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

26: Why You'll Never Switch Editors (And What You're Missing)

Sat, 18 Apr 2026 16:00:00 -0400

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

25: The X Window System and Wayland

Sat, 04 Apr 2026 15:00:00 -0400

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

24: Bayes' Rule - The Formula For Learning Everything

Sat, 21 Mar 2026 15:00:00 -0400

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

23: Containers - What's in the box????

Sat, 07 Mar 2026 15:00:00 -0500

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

22: With Claude, I'm doing the right things better and quicker

Sat, 21 Feb 2026 15:00:00 -0500

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

21: Everything Is A Database Problem

Sat, 07 Feb 2026 15:00:00 -0500

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

20: Git protects you

Sat, 24 Jan 2026 15:00:00 -0500

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

19: Data centers - Don't we have enough already?

Sat, 10 Jan 2026 15:00:00 -0500

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

18: The one where Jim asks Wolf questions

Sat, 27 Dec 2025 15:00:00 -0500

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/

17: Does my key fob have more computing power than the Lunar lander?

Sat, 13 Dec 2025 15:00:00 -0500

When people talk about the power of their computers, we've heard all kinds of claims:

I have more power on my desktop computer than the Apollo had to put a man on the moon
The phone in my pocket has more power than the Apollo space program had
I have more power on my wrist watch than the lunar lander
And the latest one: I have more power in my key fob than the Apollo capsule had

Are any of these true? In this episode, we break it down and enjoy a bit of computing history along the way.

Links:

https://en.wikipedia.org/wiki/ENIAC

https://en.wikipedia.org/wiki/Apollo_Guidance_Computer

https://www.ibm.com/history/space-shuttle

https://www.nordicsemi.com/Products/nRF52840

16: Do you have all the right tools in your toolbox?

Sat, 29 Nov 2025 15:00:00 -0500

Wolf has lots of great information about the tools you should consider using when developing software projects. Jim chimes in with his own ideas.

Takeaways

Just a few take-aways this episode and I hope by this point you have already internalized them and this is just a summary.

I’ve presented categories: the tools you will absolutely need to get your job done. You will need an editor. You will need language. You will need a source-code control strategy. The first take-away from this episode is these categories! Do you have everything you need? Are you using it when you actually need it? Have you been using print when what you really needed was a debugger?
I’m going to separate this next take-away into angles. These angles have the same implication: to get the right tools, you might need to do a little research.
- Do you know what all a tool in a given category can do for you?
  If you’re a Notepad user and didn’t know that PyCharm or Helix or VS Code could rename a method and fix it across your entire project in a single command (skipping over things that were spelled the same but weren’t actual uses of that method) … then why would switching even cross your mind?
- Do the “math”: is an alternative enough better to make you switch?
  Will you get out of it more than you put into the switch? Git was enough better, for Jim, than Subversion. But in editors, Helix is not enough better for Jim, to make him leave Vim. There’s nothing wrong with that! In every case, it’s never about which is better; it’s about which is enough better. Is the juice worth the squeeze?
Maybe one tool is not enough! I personally do the bulk of my editing in Helix; but sometimes, PyCharm does the specific thing I need. Both are at my fingertips. You don’t have to settle for just one tool.
And finally, as always for me, the underlying theme is: are you spending whatever it is you’re spending (time, money, effort) on the things with the biggest payback? Using a great editor, an editor that you are great at using, lets you work faster and more effectively. The right tool doing the right job at the right time helps you spend less on your way to the end goal.

Links

Here's a link to the github repo with the project for reading Meater temperature probes: https://github.com/Runtime-Arguments/meater

15: POSIXLY_CORRECT - What it means to be POSIX Compliant

Sat, 15 Nov 2025 15:00:00 -0500

Listen in as Jim describes what POSIX is, what it means to be "POSIX Compliant" and why you should (or shouldn't) care.

14: You are NOT Google

Sat, 01 Nov 2025 15:00:00 -0400

Wolf surfaces five fundamentals to becoming a better developer (that you probably didn’t even know you didn’t know)! This is a fiery one! Jim asks questions, and also questions Wolf's choices.

Takeaways

The problem comes first—ask more questions
Start with the simplest thing that could reasonably work
Measure before you optimize (but don’t be stupid)
Understand what’s actually an error
Test so you can evolve, and so that you don’t waste time, money, and effort

Links

Solution from Marlon for Jim's problem of maximizing a terminal window vertically

https://github.com/Runtime-Arguments/MaximizeVertically

13: Terminals: Talking to the machine

Sat, 18 Oct 2025 15:00:00 -0400

Jim takes us on a walk down memory lane!

Terminals have been around for a long time, probably much longer than you'd ever guess. Join us as we talk about the history of computer terminals and get a bit into how they work and how they've evolved into the amazing applications that we have today.

Links

Julia Evans Wizard Zines links:

12: GPUs - Can I, Should I, and How?

Sat, 04 Oct 2025 15:00:00 -0400

It's Wolf's turn this episode, and this one required research!

GPUs obviously do tons of work. You see it every time you play a graphics intensive game. You know how crypto-miners are using them. You’ve heard AI companies using them for model building. You’ve got this hardware in your machine! Can you use it? Should you use it? Where even to start?

GPUs can help if your problems, data, systems, languages, and architecture align. GPU-based solutions won’t help everyone … but when they do help, oh boy do they really help.

Takeaways
Platform recommendations:

NVIDIA: Richest ecosystem, start here if you have choice
AMD: Improving rapidly, good for PyTorch workflows
Apple Silicon: Excellent for unified memory workloads

Language recommendations:

Python for quickest wins
Rust/C++ for maximum control
JavaScript for web applications

Links

Dave Farley explains what's wrong with Vibe coding https://youtu.be/1A6uPztchXk?si=mzEg4mpbTIjaihnP

How do graphics cards work https://youtu.be/h9Z4oGN89MU?si=JRrumRPfYU6a0A02

11: IPv6 - Size really does matter

Sat, 20 Sep 2025 15:00:00 -0400

Jim demonstrates more of his networking knowledge, though this episode still required a lot research. Wolf, of course, has questions.

The internet has been around for more than 40 years in some form. It's outgrown its ability to handle all of the hosts but fortunately, there's a solution. IPv6 is mature and wide-spread and not only does it increase the address space to 128-bits (up from 32-bits) it is also more efficient for routing and transferring data across the net and it's better for VOIP and Gaming. In the US, 55% of all internet traffic is over IPv6 and in some other countries it's much higher. You almost certainly are using it in your home network and your cell phone is likely using it as well. In this episode we get into the history of the internet. We'll talk about IPv4 shortcomings and how IPv6 deals with those issues. Hopefully by listening to this episode, you'll come away ready to embrace this technology.

Takeaways

IPv6 is more prevalent than you might have thought
IPv6 shouldn't be feared and it doesn't have to be annoying and really isn't terribly complex
Make sure you have a firewall enabled on your router
Even if your ISP doesn't provide IPv6 support you can still use it locally

In Episode 3, we talked about Web Assembly. Here's a link to the announcement about WASM-3.0 which was released this week

https://webassembly.org/news/2025-09-17-wasm-3.0/

10: Command-Line Superpowers: Connecting Simple Tools for Complex Solutions

Sat, 06 Sep 2025 15:00:00 -0400

Wolf hands you the keys to the old-world kingdom, which turn out to still be valuable, just much less used!

Most programmers are comfortable in their IDE but still click through file managers and manually handle repetitive tasks outside of it. You might know basic command line navigation, maybe even write the occasional script, but you're missing the real superpower: composition - the art of connecting existing tools to solve complex problems without writing any code. This episode reveals how thinking like a conductor rather than a programmer transforms your relationship with the command line. We'll show you how to orchestrate simple, specialized tools into powerful workflows that handle the tedious work you're doing manually right now. Whether you're a Python developer who reaches for scripts too quickly or someone who's been intimidated by the terminal, you'll walk away understanding how to compose solutions from tools that already exist on your computer. By the end, you'll have a clear path from GUI-dependent to composition master, with five practical takeaways you can implement this week to start building your personal superpower toolkit.

Takeaways

You now have the conceptual framework: command line as composition and orchestration, not memorizing cryptic commands
The specialist tools already exist on your computer right now - you're learning to conduct the orchestra
Every composition you create becomes part of your growing personal capability
Start this week: pick one repetitive task that annoys you and find its composition solution
Your journey from GUI-dependent to composition master begins with connecting just two simple tools

Here's a link for the article about a VPN service that is doing screen captures of what you think are private pages:

https://www.csoonline.com/article/4044514/featured-chrome-extension-freevpn-one-caught-capturing-and-transmitting-user-data.html

9: Looking at Data Types From Both Sides

Sat, 23 Aug 2025 15:00:00 -0400

We talk about data types and their importance in software development. Modern dynamic languages hide type information from you but it's still there, under the hood. Statically-typed languages, on the other hand, bring types right out in front of you. What are the fundamental types and why are they important? What about user defined types and aggregate types?

Join us as we dive right in and try to explain it all. In most episodes, one of us (we alternate) has knowledge or does research and presents the most helpful information they can, while the other asks questions. This episode is mostly Jim, but more a combined effort than usual.

Takeaways

The CPU knows about (let’s call them “atomic”) types and has instructions that apply to them
Languages know about types BEYOND what the CPU knows and provide operations beyond what the CPU can do
In Strictly typed languages, the compiler can catch a whole suite of bugs that you may not catch in a dynamic language until runtime. (because you made a promise, and then you broke it)
You can build your own types that are vastly more complicated than the CPU or Language provide

8: I’ve Been Using AI to Code for a Year. Here’s What I Learned

Sat, 09 Aug 2025 15:00:00 -0400

Wolf has a lot to say about AI and coding!

If you’re expecting AI to write entire programs for you while you sit back and watch, we're going to disappoint you right up front—that’s not what these tools do well, and chasing that fantasy will waste your time. But what if we told you there’s a tool that could help you interpret cryptic error messages, navigate tricky syntax in unfamiliar languages, write the documentation you always skip, and spot those needle-in-the-haystack bugs that eat hours of your day—but only if you understand what you’re asking it to do? Today we’re diving into the reality of AI tools for programmers: not the magic bullet some promise, but the practical truth about what actually works and how to avoid the pitfalls that can corrupt your work.

Wolf has been using AI tools in his daily programming work, and he wants to share what he's learned—both the genuine benefits that have made him faster and more effective, and the critical mistakes that can trip you up if you’re not careful. We’ll explore why AI isn’t magic, why being a domain expert matters more than ever, and how these tools are more like really sophisticated auto-complete than the thinking machines some claim them to be. Whether you’re skeptical, curious, or already experimenting, you’ll walk away with concrete strategies for making AI work for you instead of against you.

Take-aways from the episode:

You must be a domain expert. You must understand the problem, and you must have the knowledge and skill to evaluate the result. This might be the most important thing I’ve said in this whole episode.
You must read and understand everything the AI gives you. This is fundamental. It’s part of your job. It always has been.
Working with AI is an iterative collaboration, not just pushing a button on the magic “answer machine”. You will be doing a lot of work if the problem is hard. And it’s the same work you’ve been doing, maybe all your life: explaining to the computer exactly what you want.
You must carefully, fully, and deeply explain to the AI what you want (Prompt Engineering), and even then, you (plural) will iterate over and over and over again before reaching a satisfying answer.
Current AIs don’t think, they produce the most popular results they can that satisfy your prompt. They don’t give you the best answer. They give you the most popular answer.
AI is great at analyzing and helping you to improve your existing code. It’s less great when you start with nothing.

7: VPNs - Connecting Safely

Sat, 26 Jul 2025 15:00:00 -0400

If you need to connect to remote networks, or if you are outside of your network and would like to connect into it, then almost certainly you need a VPN. Jim has lots of real-world experience connecting networks together. In this episode we talk about various ways to connect and list some of the issues that you might run into.

Take-aways from the episode:

There's a difference between a "VPN" and a "VPN Service"
If you are looking for something simple allowing you to talk to a home machine while you are outside the home, Tailscale works REALLY well. It doesn't require you to "poke a hole" in your firewall.
If you want a bit more control and host everything yourself, Wireguard is GREAT for that. I used to recommend OpenVPN but now I think Wireguard is the best choice because it's so much easier to set up.

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

6: Code Performance - Where does the money go?

Sat, 12 Jul 2025 15:00:00 -0400

Wolf talks about making your programs better. There are lots of ways to make them better. It all starts with figuring out what matters and measuring it. Measuring it all the time. Measuring it more. This episode is about following that path.

Show notes:

Take-aways from the episode:

Understand what you are optimizing for: (speed,memory,storage,developer, etc…)
Measurement is job one, because that’s the only way to know where the money is actually going. You should be measuring. A lot. More than that. It should be part of CI/CD. You should run it before pushing. Everyone should be doing it. Measurement might be even more important than testing (and don’t get me wrong, testing is very important). When I worked on Mozilla, our build servers did timing. If your commit slowed something down, that was considered “bustage”, and required immediate fixing.
Use the profiler for two things:
- To see if the whole thing is faster or slower so you know when it’s time to look deeper
- To dive into the actual execution and locate the bad parts you need to improve.
It’s all about the money.
Write clear, simple, and correct (you’ll know by testing) code. Only then should you optimize. Do I need to repeat the old adage about premature optimization? “Premature optimization is the root of all evil.” It’s easier to speed up working code, than it is to fix fast but broken code.
Understand the (real) data you will be operating on.
You don’t know just by looking at the source what actually costs you the most money. Yes, you can see where stupid things happen, but even for those, knowing which actually matter requires measurement.

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: Filesystems - So many choices

Sat, 28 Jun 2025 15:00:00 -0400

When setting up a new system there's many things to think about including choosing the filesystem. In this episode, Jim dives into all of the choices and describes the benefits of each. Wolf is here to ask the questions, and to fail at keeping Jim entirely on track.

Show notes

Things to think about:

For Linux, ext4 is the default for many distros and it's pretty good but btrfs has some really great benefits and you should consider using it.
For MacOS, the default is case-insensitive for filenames. This can cause some problems when cloning some git repos because within the repo there may be two files with the same name, only different by case. In a case-insensitive filesystem, you'll have a collision. BUT, turning off case-insensitive can cause other problems for some applications. Maybe the best thing to do is create a separate case-sensitive filesystem on a volume and use that for your git trees.
Beware of the 'Year 2038' problem on linux filesystems before ext4.

Links:

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: Functional Programming - You're probably already doing it

Sat, 14 Jun 2025 15:00:00 -0400

People throw around the term Functional Programming but it's not always clear what they mean. In this episode, Wolf explains what goes into FP, and together we build a clearer picture that reveals you might already be doing it.

Show notes and things to think about:

Functional programing isn't academic. It isn't overwhelming. It isn't impossible to use. It isn't inapplicable to ordinary problems like the ones you're solving right now.
You can use functional techniques in almost any modern programming language. In fact, you probably already are.
Main pillars of FP:
1. Pure functions (no side-effects)
2. Functions are first-class objects (you can pass them as arguments, you can return them as results, you can store them in lists or any other data-structure)
3. Data is immutable by default
4. FP languages often provide powerful pattern matching syntax (didn't mention this much in the episode other than briefly noting Python's new match statement)
5. A couple of things not mentioned: in FP, your code is more about what you want, not about how to get it. That stack of functions for the sales data example looks declarative, not imperative.
6. A couple of other things not mentioned: recursion and lazy evaluation. Not exclusive to FP, but very often available in functional languages.
Papers and explanations about monads might be unreadable, but you're already using them and you already know how they work.
Using FP techniques appropriately can make your code easier to test, harder to break, and possibly even prettier to look at.
There are places in your code right now that you can make better right now with FP. Do it!

Links:

We mentioned a ton of languages. Most of them have easy to find home pages so I'm not going to list out all the links; but there are a couple of obscure ones
- There's nothing for the original Lisp, the closest these days is probably https://common-lisp.net.
- ML can be found at https://sml-family.org but the more modern and popular variant, OCaml, can be found at http://ocaml.org. Microsoft's take on this is F#, open-sourced at https://fsharp.org.

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

Theme music:

Dawn by nuer self, from the album Digital Sky

3: Web Assembly

Sat, 31 May 2025 15:00:00 -0400

Web browsers and web sites have been around for quite a while. Javascript has been the language driving those pages but there's a way to write in a lower-level language and speed up the slow parts without losing cross-platform compatibility. That way is called Web Assembly (WASM). In this episode Jim explains exactly what that is, and Wolf asks questions.

Show notes:

Take-aways from the episode:

If you have a compute intensive part of your web application, it may make sense to implement that bit of code in a compiled language like C, C++ or Rust and then compile them to WASM so they can be executed in the browser.
Security and Portability. WASM code is secure as it utilizes the browsers' sandbox and portable as all browsers are supporting the W3C Standard WASM.
You are almost certainly using WASM based applications. It's in use in Google Maps & Docs, Netflix, Spotify, Amazon and many more.

Links:

https://emscripten.org/index.html
https://emscripten.org/docs/getting_started/Tutorial.html - Nice tutorial
https://github.com/WebAssembly/wabt - Web Assembly Binary Toolkit
https://collabnix.com/top-20-companies-that-uses-wasm/ - Companies using WASM
https://developer.mozilla.org/en-US/docs/WebAssembly/Reference - WASM Instruction set
https://developer.fermyon.com/wasm-languages/webassembly-language-support - Languages supported
https://github.com/snaplet/postgres-wasm - Postgres implemented in WASM

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

Theme music:

Dawn by nuer self, from the album Digital Sky

2: Bitcoin, Cryptocurrency, and the Blockchain

Sat, 17 May 2025 15:00:00 -0400

Lots of people talk about Cryptocurrency. It's in the news all the time but who really knows what it is? In this episode, Wolf reports his research and together we dig into it and explain what it's all about.

Show notes:

Take-aways from the episode:

Crypto is not really anonymous
Crypto is both regulated and taxed (at least here in the US)
Legal uses of crypto outweigh illegal uses. This stuff is legitimate. There are dangers, but crypto is something you might legitimately possess
There are scammers everywhere. Protecting the private key in your wallet is vital to keeping your money: don’t lose it, don’t let it be stolen, don’t give it away. Stealing your private key is much easier than stealing US dollars out of your bank account.

Feedback from episodes:

Champ at Key 9 Identity sent us a couple of links for blog posts on passkeys.

https://blog.k9.io/p/passwords-must-die

https://blog.k9.io/p/key9-the-2025-security-key-shootout

Hosts:

Jim McQuillan can be reached at jam@RuntimeArguments.fm
Wolf can be reached at wolf@RuntimeArguments.fm

If you have feedback for us, please send it to feedback@RuntimeArguments.fm

Theme music:

Dawn by nuer self, from the album Digital Sky

1: Out of the Datacenter and into the Cloud

Sat, 03 May 2025 15:00:00 -0400

Have you thought about moving your computing into the Cloud?

This episode takes a look at a real-world adventure that Jim went through when moving his computing infrastructure from purchased servers in a rented rack in a datacenter to a VM Running in a cloud service provider using Docker, Linux, managed PostgreSQL. He covers the steps he took to get there, how it's going, the good stuff and the challenges in making it work.

Show notes:

Cloud service providers:

Technologies used:

Hosts:

Jim McQuillan can be reached at jam@RuntimeArguments.fm
Wolf can be reached at wolf@RuntimeArguments.fm

Dawn by nuer self, from the album Digital Sky

0: Passkeys

Sat, 12 Apr 2025 17:00:00 -0400

There are many scams, some to get your password(s), some just for money. Join us as Wolf tells everything he knows and together we discuss a new way to protect your online accounts.

Show notes:

Lists of login methods:

Who implements Passkeys?

The three things that come together to make passkeys:

Using key pairs, like SSH: https://www.ssh.com/academy/ssh/public-key-authentication
Biometric authentication, you're already used to it from your phone
New User Interface "ceremonies"

Which password managers support passkeys?

1Password (our personal favorite)
Bitwarden
Dashlane
Google Password Manager
Keeper
NordPass
RoboForm

A little about password managers:

Almost any password manager is better than no password manager at all so do your research. Find the best one for you. Make sure it answers these questions:

Does it run on all the platforms you care about?
Does it have a pricing model you like?
Does it use a cloud service, or not, or of your choice, in a way that you like?
Does the password service itself have access to your keys?
What kind of secrets can it keep?
Passkey descriptions and implementation documents
- The FIDO alliance: https://fidoalliance.org/passkeys/
- Google (for developers): https://developers.google.com/identity/passkeys/developer-guides
- Apple (for developers): https://developer.apple.com/passkeys/

Wolf's top three personal digital security recommendations

Use a password manager (it should support passkeys). See above.
- Once you create a passkey for a specific service; change your previous password. The new one should be generated by your password manager and you should never use it unless you absolutely must.
Make sure your device is secure
- Use biometric authentication
- Have a strong password. Your password manager can generate one made from words. Easy to remember; hard to guess.
- Make sure you know how to force your device to require a password. You can be tricked or forced to authenticate biometrically. Law enforcement can't force you to reveal a password; and if you're careful, you can't be tricked out of it.
Be aware of your surroundings. Bad actors can "shoulder surf" and get your password, or cameras. It's just like the old days at the ATM. You don't want a person right behind you to see your PIN.

Hosts:

Jim McQuillan can be reached at jam@RuntimeArguments.fm
Wolf can be reached at wolf@RuntimeArguments.fm

Dawn by nuer self, from the album Digital Sky