Newsletter #106
Enjoy Newsletter #106.
How The Heck Does GPS Work? (An Interactive Exploration)
Shri Khalpada’s interactive explainer shows that GPS is fundamentally a machine for turning time into distance. Satellites broadcast radio signals at the speed of light, your phone measures how long the signal took to arrive, and each nanosecond corresponds to roughly 0.3 meters. One satellite tells you that you lie somewhere on a sphere (or circle in 2D), a second narrows it to two intersection points, and a third pins down a single point — a method called trilateration. The catch is the clock: satellites carry atomic clocks, while your phone only has a cheap quartz oscillator, and a drift of just a few microseconds throws your position off by hundreds of meters. That is why a fourth satellite is required: there is only one clock-offset correction that makes all four spheres intersect at a single point, allowing the receiver to solve for both exact position and exact time simultaneously.
Then comes the “relativity tax”: because satellites move so fast, their clocks tick about 7 microseconds slower per day (special relativity), but higher up in weaker gravity they tick about 45 microseconds faster (general relativity). Left uncorrected, positions would drift by roughly 10 km per day, so satellite clocks are engineered to tick slightly slower before launch on the ground. In practice, modern receivers lock onto 8–12 satellites at once across GPS (US), GLONASS (Russia), Galileo (EU), and BeiDou (China) to reduce error; in dense cities, signals bouncing off buildings (multipath error) remain the hardest problem.
If AI Writes Your Code, Why Use Python?
Noah Mitchem argues that the decade-long “bargain” — picking Python or TypeScript for their huge ecosystems, easier hiring, and fast prototyping while accepting 10x to 100x worse performance than Rust, Go, or C++ — has expired, because AI has gotten good at the hard languages. By April 2026, Claude Opus 4.7, GPT-5.5, Gemini 3.1, and DeepSeek V4 all topped 80% on SWE-bench Verified. The strict type systems and tight compiler feedback loops of Rust and Go let agents iteratively self-correct. The proof is already here: Microsoft ported the TypeScript compiler to Go (roughly 10x faster); Nicholas Carlini at Anthropic orchestrated 16 Claude agents to write a 100,000-line C compiler in Rust across nearly 2,000 Claude Code sessions for under $20,000; and Andreas Kling ported Ladybird’s JavaScript engine from C++ to Rust in two weeks — roughly 25,000 lines with zero regressions.
Even the Python ecosystem is increasingly a “Rust ecosystem wearing a Python hat”: pydantic, polars, tokenizers, and orjson are all written in Rust; OpenAI acquired Astral (uv, ruff), and Anthropic acquired Bun. The unit of open-source contribution is also shifting from patches to full ports: Armin Ronacher used an agent to port MiniJinja from Rust to Go in 10 hours with only 45 minutes of actual human effort. Exceptions remain: Prisma moved back to a TypeScript/WASM core for serverless, PyTorch still commands roughly 85% of deep learning research, and Zig, Haskell, and Gleam lack training data. As the developer’s role shifts toward design and review, Python’s ease-of-writing advantage fades while the performance advantage of harder languages compounds every day.
On Rendering the Sky, Sunsets, and Planets
Maxime Heckel walks through rendering atmospheric scattering in WebGL shaders from first principles up to near-photorealistic results. The foundation is raymarching: sampling atmospheric density along the view ray, computing transmittance via Beer’s Law, and using phase functions to describe scattering direction. Three physical mechanisms are combined: Rayleigh scattering (shorter wavelengths scatter more strongly, which is why the sky is blue), Mie scattering (larger particles like dust and aerosols that create the bright halo around the sun), and ozone absorption (filtering out specific wavelengths and deepening sunset colors).
After building a flat sky, the author wraps the atmosphere around a spherical planet: reconstructing world-space coordinates from the depth buffer, using ray-sphere intersection to find atmospheric bounds, and handling depth so the atmosphere blends seamlessly with rendered geometry. With the exact same simulation framework, tweaking parameters produces a solar eclipse or a Martian sky. Finally, to hit real-time frame rates, the article implements Sébastien Hillaire’s lookup-table (LUT) method: precomputing transmittance, sky-view, and aerial perspective into textures and sampling them instead of running nested raymarching loops every frame. Packed with interactive widgets to tweak sun angle, altitude, Mie scattering, and ozone density, it is well worth reading directly.
Starting Systems Programming, Pt 1: Programmers Write Programs
This is the opening installment of Efron Amber Licht’s series on systems programming, built around a simple premise: to get good, you have to do the thing, and programmers write programs. In the author’s view, a problem counts as “systems” programming when it interacts with the OS or hardware, operates under tight performance constraints, or manipulates bytes and registers directly. A systems programmer views the computer as a physical machine that can be understood completely rather than an opaque abstraction, and isn’t afraid to take things apart to see how they work.
The article opens the “black box” of a program by compiling a Go “hello world” binary and inspecting the executable directly. Readers build small tools from scratch along the way: findoffset to locate a string inside a file, echo and cat to write and print files, binpatch to patch binary contents directly without recompiling, and hexdump utilities to inspect machine code. Through these exercises, readers see that an executable is just an organized sequence of bytes: the string "hello, world!" sits at a fixed offset, while the ELF header holds the magic number, target architecture, and the entry point where the CPU begins execution, with values stored in little-endian order on x86-64. The ethos the author wants to pass on: build your own tools, look at the raw data with your own eyes, and understand the system rather than hiding behind abstractions — because at the end of the day, it’s all just bytes.
Learning Software Architecture
Replying to a physicist asking how to learn software architecture, Matklad argues that the skill is best learned by doing. University design courses felt to him like “kindergarteners playing firefighters”; what actually taught him architecture was unexpectedly becoming the lead of the IntelliJ Rust project. His second observation is Conway’s Law: software mirrors the social structure of the organization that builds it. He quotes neugierig: code ultimately matters less than architecture, and architecture matters less than social problems. Poor “scientific code,” therefore, stems mainly from incentive structures — like pressure to publish a paper in three months — rather than a lack of programming knowledge.
There are two ways forward: very rarely, you get a chance to redesign a project’s incentive structure; most of the time, you have to accept the constraints and adapt the architecture around them. rust-analyzer is a prime example: its deep, compiler-like core is kept trivial to build with a test suite that runs in seconds so it can attract strong contributors, while its wide surface of IDE features is isolated so that each feature is wrapped in catch_unwind and operates on an immutable snapshot of data — allowing weekend contributors to submit imperfect code without crashes cascading or corrupting state. While he has no single “bible” book to recommend, he points readers to Gary Bernhardt’s talk “Boundaries,” Pieter Hintjens’s writings, Ted Kaminski’s blog, and Jamii’s post “Reflections on a decade of coding.”
I’m an introvert. This is how I get myself to speak up.
Wes Kao shares her experience as an introvert in the workplace, where meetings naturally favor people who speak first and think out loud. Introverts prefer time to process before responding, putting them at a systematic disadvantage. Rather than waiting until you feel confident — a moment that usually never arrives — she recommends preparing ahead of time and using concrete tactics she relies on herself.
Before a meeting, decide in advance that you are going to speak so you don’t waste energy debating yourself in the moment, and chime in early before prolonged self-doubt lets the opportunity slip away. Keeping a few go-to opening phrases ready, such as “That’s a great point. My POV on this is…”, makes jumping into a fast-moving discussion much easier. Written channels like docs and meeting notes serve as a parallel track for contributing and leave behind durable artifacts. Remote meetings also offer unique advantages for introverts (controlled lighting, framing, and small video tiles reduce pressure), and you can enlist a trusted colleague to give you a gentle prompt to hold yourself accountable.
How I use LLMs as a staff engineer in 2026
Sean Goedecke reflects on how his LLM usage as a staff engineer has evolved over the past year, and the biggest shift is that agents have gotten genuinely good. In 2025 he only used AI for autocomplete, small edits in unfamiliar codebases, or Q&A; today, every code change starts by handing it to an agent (primarily via the GitHub Copilot app, running dozens of sessions a day). He skims the result for about 30 seconds, throws away most attempts because they aren’t what he had in mind, and carefully reviews and polishes the ones that survive. For bug reports, he feeds every single one to an agent first because it diagnoses the issue correctly about 80% of the time. Human expertise still matters, though: one bug took until the 14th agent session to crack, after he supplied context from logs and Slack, reproduced the issue himself, and narrowed the search space.
He offloads a lot of testing and environment setup to agents: having them test their own changes and inspect the logs, write integration tests, and troubleshoot local machine configs. Test code is treated as “cheap,” whereas he avoids delegating UI work because agents still lack visual sensibility. Conversely, he still writes all his own PR descriptions, ADRs, Slack messages, and blog posts, because LLMs are overly verbose, struggle to surface the core point, and writing things yourself signals to coworkers that a real human is thinking on the other end. In his view, the most important AI skill today is delegating as much as possible to agents without pushing it too far.
Interrogatory LLM
Martin Fowler introduces the “Interrogatory LLM” pattern: instead of a human writing pages of context up front for a complex task, you ask the LLM to interview you, ask every question it needs answered, and synthesize the conversation into a context report that a subsequent session (potentially running a different model) uses to execute the task. He first spotted this technique on Harper Reed’s blog, noting the key trick of forcing the LLM to ask only one question at a time — a constraint Fowler found he had to remind the model of repeatedly when trying it himself.
The pattern also works in reverse: hand an LLM an existing document, such as a software specification, and have it interview a domain expert to verify whether the spec is still accurate, replacing the tedious document review process that many experts struggle with. You can even combine both directions: one LLM drafts the document through an interview, and other LLMs take it to different experts for cross-examination. More broadly, while Fowler himself treats writing as an integral part of thinking, many people find writing painful; a structured conversation with an LLM can help them turn their tacit knowledge into written documentation.
I don’t think AI will make your processes go faster
After rereading the classics The Toyota Way and The Goal, Frederick Van Brabant argues that AI won’t speed up organizational processes the way many expect, because we keep misidentifying the bottleneck. Looking at a project timeline, software development takes the longest chunk of time, so the knee-jerk reaction is to add headcount or assume AI will speed it up. But taking a long time doesn’t mean the problem originates there: nobody makes a project faster by typing faster. Most of that time is actually spent deciphering vague, title-only tickets like “send an email to the user when the order is completed” — what goes in the email, what happens on failure, and what counts as completed?
AI generates code fast, but that doesn’t mean it generates the right code. Comparisons between humans and AI routinely ignore the hand-holding required: to get AI to build the right thing, product and domain experts have to specify every feature and edge case down to the tiniest detail, ballooning the specification phase. Yet that level of clarity is what developers have wanted all along; if human engineers received specs that detailed, their productivity would skyrocket too. If you want faster processes, make sure the people doing the work have what they need to succeed — echoing The Goal’s lesson that a bottleneck must be fed high-quality, predictable inputs.
Using an Engineering Notebook
Nicole Tietz shares what she considers perhaps her single most important productivity habit: handwriting in an engineering notebook, a practice borrowed from laboratory notebooks. The notebook records in rich detail what she is doing and why, thoroughly enough that someone else could reproduce the work; every entry is dated, written contemporaneously as the work happens, append-only without erasures or edits, and serves as the primary record rather than a neat copy transcribed from elsewhere. That level of detail matters because your future self is also “someone else” and will forget most of the context. She started the habit in 2016 while consulting for multiple clients at once, and now uses an e-ink tablet instead of paper notebooks because she is left-handed and doesn’t want to carry multiple physical notebooks around.
The notebook delivers two main benefits. First, it acts as a memory aid: both as a log she can read back to recover context after an interruption, and because the physical act of handwriting improves retention. Second, it is a thinking tool: she routinely writes out a description of a planned code change in her notebook before touching the keyboard, forcing herself to think carefully and spot gaps in her understanding before writing a single line of code. She rarely rereads old notebooks and never shows them to anyone, because “the writing is the work.” Her advice: if you haven’t tried keeping one, give it a shot and adapt the format, medium, and level of detail to fit your own style.
Bonus
Documents: AI eats the world
This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.
Comments