# Farid Zakaria's Blog

I'm a software engineer, father and wishful amateur surfer. If you've come seeking my political views, you've found the wrong Fareed.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Build systems à la trace

DevFeed: [Build systems à la trace](<https://devfeed.tech/articles/build-systems-a-la-trace-143192.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/11/18/build-systems-a-la-trace>)

Author: Farid Zakaria

Published: 2026-11-18T18:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [bazel](<https://devfeed.tech/topics/bazel.md>), [Build tool](<https://devfeed.tech/topics/build-tool.md>), [reproducible builds](<https://devfeed.tech/topics/reproducible-builds.md>), [make](<https://devfeed.tech/topics/make.md>)

Tags: [bazel](<https://devfeed.tech/tags/bazel.md>), [build-system](<https://devfeed.tech/tags/build-system.md>), [build-systems](<https://devfeed.tech/tags/build-systems.md>), [trace](<https://devfeed.tech/tags/trace.md>)

### AI overview

genrulify turns a recorded Nix build into Bazel and Buck rules by using Rewind's deterministic VM trace to capture commands, dependencies, environment, file descriptors, and filesystem states. It models each command as a unit of work, tracks successive versions of files to handle in-place changes, and uses MLIR passes to simplify the graph. The initial output is one `genrule` per command, with inputs and outputs made explicit; recorded commands run in a sandbox that recreates their original context. Pattern matching can raise commands into abstractions such as `cc_object`, but these remain macros over genrules and do not change execution semantics. The article reports that Bazel and buck2 produced GNU hello with the same NAR hash served by cache.nixos.org, and argues that the explicit graph enables parallel scheduling even when the original build used `make -j1`. This conversion describes a build after it has run; the excerpt does not establish that future dynamic dependencies are known in advance.

### Source excerpt

As a build systems enthusiast, Build Systems à la Carte is one of my favourite papers. It defines a way to think about build systems that is both precise and surprisingly practical.

## Worshipping at the altar of Brendan Gregg

DevFeed: [Worshipping at the altar of Brendan Gregg](<https://devfeed.tech/articles/worshipping-at-the-altar-of-brendan-gregg-132442.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/11/12/worshipping-at-the-altar-of-brendan-gregg>)

Published: 2026-11-12T18:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [scheduling](<https://devfeed.tech/topics/scheduling.md>), [Process](<https://devfeed.tech/topics/process.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [all](<https://devfeed.tech/tags/all.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [analyze](<https://devfeed.tech/tags/analyze.md>), [build](<https://devfeed.tech/tags/build.md>), [builds](<https://devfeed.tech/tags/builds.md>), [command](<https://devfeed.tech/tags/command.md>), [context-switch](<https://devfeed.tech/tags/context-switch.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [critical](<https://devfeed.tech/tags/critical.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [ebpf](<https://devfeed.tech/tags/ebpf.md>), [economics](<https://devfeed.tech/tags/economics.md>), [epoll](<https://devfeed.tech/tags/epoll.md>), [flame](<https://devfeed.tech/tags/flame.md>), [flame-graph](<https://devfeed.tech/tags/flame-graph.md>)

### AI overview

Rewind's new `rewind time` command uses data already captured for deterministic replay--context switches and wakeups--to show a run's critical path, where its time went, and which work could shorten it. In the libuv example, a 78-second run has a 47.4-second critical path; `make check` accounts for 41.9 seconds, largely from sequential tests waiting on timers, which a CPU profile would miss. The command breaks results down by phase and process, estimates "drag" (how much sooner the run would finish if a step took no time), and can drill into a process or replay to a recorded step to inspect source and debug with gdb. It also exports folded stacks for flamegraph.pl or speedscope and traces for Perfetto. The article contrasts this with live off-CPU tracing, which must be started before a run, has a cost, and captures only selected runs; Rewind recordings can be analyzed afterward. The example's repeated sleeps are intentional test behavior, not an optimization opportunity.

### Source excerpt

Okay, I am the first to admit that I'm a bit manic with AI. When you are working on a problem that has endless possibilities, it is difficult to constrain yourself to a limited set of features.

## What if every Nix build were bit-reproducible?

DevFeed: [What if every Nix build were bit-reproducible?](<https://devfeed.tech/articles/what-if-every-nix-build-were-bit-reproducible-126397.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/11/09/what-if-every-nix-build-were-bit-reproducible>)

Published: 2026-11-09T18:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Nix](<https://devfeed.tech/topics/nix.md>), [reproducible builds](<https://devfeed.tech/topics/reproducible-builds.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [builds](<https://devfeed.tech/tags/builds.md>), [built-from-source](<https://devfeed.tech/tags/built-from-source.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cascade](<https://devfeed.tech/tags/cascade.md>), [change](<https://devfeed.tech/tags/change.md>), [content](<https://devfeed.tech/tags/content.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [hash](<https://devfeed.tech/tags/hash.md>), [input](<https://devfeed.tech/tags/input.md>), [linux](<https://devfeed.tech/tags/linux.md>), [linux-distribution](<https://devfeed.tech/tags/linux-distribution.md>), [making](<https://devfeed.tech/tags/making.md>), [model](<https://devfeed.tech/tags/model.md>), [multiple](<https://devfeed.tech/tags/multiple.md>), [nix](<https://devfeed.tech/tags/nix.md>), [rebuilds](<https://devfeed.tech/tags/rebuilds.md>), [reproducibility](<https://devfeed.tech/tags/reproducibility.md>), [reproducible-builds](<https://devfeed.tech/tags/reproducible-builds.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

Rewind, a deterministic virtual machine, can make Nix builds bit-reproducible by capturing implicit inputs such as time, randomness, and scheduling in a controlled environment. The article's example shows a build with a random UUID and timestamp failing Nix's determinism check on the host but producing the same bytes and content-addressed store path across Rewind builds and stores. Reproducibility can therefore enable cache hits across machines and avoid input-addressed rebuild cascades and multiple output variants. Rewind requires KVM and an advertised rewind-amd or rewind-intel host feature; fixed-output derivations are refused because the VM has no network. Reproducibility is limited to the same Rewind version and CPU vendor: changing Rewind forces rebuilds, and Intel and AMD produce different, though individually reproducible, outputs.

### Source excerpt

The holy grail of build systems and package managers is bit-reproducible1 builds. This is such a desired trait that nearly every Linux distribution has a reproducible builds project to track the progress and validity of their builds. Why is bit-reproducibility so important? Trust. You can trust that the software you are running has not been tampered with and is the same as what the developers intended if you can verify that when built from source, the output is identical. Making software bit-reproducible though is hard. There are a lot of ways that can introduce non-determinism into a build: timestamps, random seeds, thread scheduling, and more. Most distributions that have achieved "reproducible builds" have done so for only a subset of their packages, usually those that comprise the core of the ISO or distribution. Nix's default model, the extensional model (input-addressed), famously works around the need for bit-reproducibility by hashing the inputs to a build and using that hash as the store path. This lets the build be repeatable even if the output is not bit-for-bit identical. It is an incredibly pragmatic solution to making builds repeatable, but it does not solve the problem of trust. We are still trusting the outputs uploaded to cache.nixos.org have not been tampered with. Nix also has an experimental content-addressed model (intensional model) where the /nix/store paths are based on the content of the output, but crucially, it does not guarantee that the builds are bit-reproducible. This leaves us with an undesirable situation regardless of the model. For the extensional model, the smallest change in the inputs changes the store path which causes a cascade of rebuilds. For the intensional model, a single derivation can produce multiple different outputs. Extensional model input-addressed one byte changes glibc zlib openssl curl x7mq2v... 9kd0zl... p3vn8a... c1rw5y... ba4ks1... h0wq7f... 6jtm9d... rz2pl8... rebuilt rebuilt rebuilt rebuilt One input changes, every path dow

## Making profile-guided optimization reproducible

DevFeed: [Making profile-guided optimization reproducible](<https://devfeed.tech/articles/making-profile-guided-optimization-reproducible-122552.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/11/07/making-profile-guided-optimization-reproducible>)

Published: 2026-11-07T18:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Nix](<https://devfeed.tech/topics/nix.md>), [inlining](<https://devfeed.tech/topics/inlining.md>), [performance-optimization](<https://devfeed.tech/topics/performance-optimization.md>)

Tags: [amd](<https://devfeed.tech/tags/amd.md>), [binaries](<https://devfeed.tech/tags/binaries.md>), [block](<https://devfeed.tech/tags/block.md>), [blocks](<https://devfeed.tech/tags/blocks.md>), [boot](<https://devfeed.tech/tags/boot.md>), [branch](<https://devfeed.tech/tags/branch.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [build](<https://devfeed.tech/tags/build.md>), [builder](<https://devfeed.tech/tags/builder.md>), [builds](<https://devfeed.tech/tags/builds.md>), [cache](<https://devfeed.tech/tags/cache.md>), [clang](<https://devfeed.tech/tags/clang.md>), [clock](<https://devfeed.tech/tags/clock.md>), [closure](<https://devfeed.tech/tags/closure.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [performance](<https://devfeed.tech/tags/performance.md>), [pgo](<https://devfeed.tech/tags/pgo.md>), [profile](<https://devfeed.tech/tags/profile.md>)

### AI overview

Profile-guided optimization can improve performance, but its training run normally depends on machine conditions and thread scheduling, producing profiles and binaries that may differ across builds. The article makes PGO reproducible by running only the training step inside Rewind, a deterministic VM, while keeping the instrumented and final compiles as ordinary derivations. The profile is fixed by Rewind inputs such as epoch, seed, schedule, CPU model, and clock. Because Intel and AMD remain distinguishable inside the VM, training must be pinned to a CPU vendor and the derivation requires a matching builder feature. Reproducibility does not ensure a useful profile: the training workload and schedule should resemble expected production behavior. In the example, three of four schedules omit `compress` from training, while one yields an approximately even workload split.

### Source excerpt

Profile-guided optimization (PGO) is an easy way to speed up a program, especially if the workload is somewhat stable. In leaving performance on the table I built a profile-guided sqlite3 variant for a 1.32x speedup for our select workloads.

## The intensional model in disguise

DevFeed: [The intensional model in disguise](<https://devfeed.tech/articles/the-intensional-model-in-disguise-122148.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/11/06/the-intensional-model-in-disguise>)

Published: 2026-11-06T18:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [actions](<https://devfeed.tech/tags/actions.md>), [bazel](<https://devfeed.tech/tags/bazel.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [binaries](<https://devfeed.tech/tags/binaries.md>), [build](<https://devfeed.tech/tags/build.md>), [building](<https://devfeed.tech/tags/building.md>), [builds](<https://devfeed.tech/tags/builds.md>), [c](<https://devfeed.tech/tags/c.md>), [ca](<https://devfeed.tech/tags/ca.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cat](<https://devfeed.tech/tags/cat.md>), [cc](<https://devfeed.tech/tags/cc.md>), [change](<https://devfeed.tech/tags/change.md>), [changes](<https://devfeed.tech/tags/changes.md>), [clang](<https://devfeed.tech/tags/clang.md>), [command](<https://devfeed.tech/tags/command.md>), [model](<https://devfeed.tech/tags/model.md>), [nix](<https://devfeed.tech/tags/nix.md>), [prototype](<https://devfeed.tech/tags/prototype.md>), [store](<https://devfeed.tech/tags/store.md>)

### AI overview

The article argues that Nix content-addressed derivations and Bazel/buck2 action caching implement the same intensional build model: outputs are identified by content, and actions key off command lines and input content digests. In its C example, changing a comment makes the compile action run, but leaves the object file unchanged, so Bazel and buck2 reuse the link action's cached result. Nix defaults to an extensional model, where recipe and upstream input changes propagate through store paths and trigger downstream rebuilds; enabling content-addressed derivations lets it avoid rebuilding the unchanged link output. Bazel and buck2 use the intensional model by default and offer no input-addressed mode, while Nix supports both. The excerpt identifies early cutoff as the resulting optimization and says its granularity helps explain why people use Bazel and buck2 for large builds until Nix dynamic derivations stabilize.

### Source excerpt

Despite how different they look on the surface, Nix, Bazel and buck2 are remarkably similar under the hood. Don't believe me? I built a prototype in one store, two frontends to prove it. Turns out though that the similarities are even deeper than I realized.

## Rewinding by fast-forwarding

DevFeed: [Rewinding by fast-forwarding](<https://devfeed.tech/articles/rewinding-by-fast-forwarding-121375.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/11/05/rewinding-by-fast-forwarding>)

Published: 2026-11-05T17:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [gdb](<https://devfeed.tech/topics/gdb.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>)

Tags: [account](<https://devfeed.tech/tags/account.md>), [balance](<https://devfeed.tech/tags/balance.md>), [bank](<https://devfeed.tech/tags/bank.md>), [breakpoint](<https://devfeed.tech/tags/breakpoint.md>), [bug](<https://devfeed.tech/tags/bug.md>), [debuggers](<https://devfeed.tech/tags/debuggers.md>), [example](<https://devfeed.tech/tags/example.md>), [execution](<https://devfeed.tech/tags/execution.md>), [failed](<https://devfeed.tech/tags/failed.md>), [failure](<https://devfeed.tech/tags/failure.md>), [gdb](<https://devfeed.tech/tags/gdb.md>), [history](<https://devfeed.tech/tags/history.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [interactive](<https://devfeed.tech/tags/interactive.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [process](<https://devfeed.tech/tags/process.md>), [records](<https://devfeed.tech/tags/records.md>), [rewind](<https://devfeed.tech/tags/rewind.md>), [run](<https://devfeed.tech/tags/run.md>), [tools](<https://devfeed.tech/tags/tools.md>)

### AI overview

Rewind records a program's execution in a deterministic virtual machine, then replays it to inspect earlier state. Its `rewind blame --reads` traces memory reads and writes; in the two-teller example, it reveals that one teller read 110, then overwrote nine later deposits with stale value 120. `rewind gdb` also supports watchpoints and reverse commands such as `reverse-continue`, `reverse-step`, and `reverse-next`. Rewind does not literally execute the VM backward: it restores a checkpoint, runs forward while recording accesses, and repeats from earlier checkpoints to find the last access before the target step. This can take time when a step spans millions of instructions.

### Source excerpt

Debuggers are an incredibly powerful and useful tool, but they mostly show you only the present and let you move forward.1 Inspecting the present can help you understand the past, but is that a limitation we must accept? Tools like rr and Undo record a process and let you run its replay backwards. Rewind records the whole machine, the kernel included, so the same inputs make the same run every time. ↩

## Why does shuffling the schedule find so many bugs?

DevFeed: [Why does shuffling the schedule find so many bugs?](<https://devfeed.tech/articles/why-does-shuffling-the-schedule-find-so-many-bugs-117127.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/11/03/why-does-shuffling-the-schedule-find-so-many-bugs>)

Published: 2026-11-03T17:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [bugfixes](<https://devfeed.tech/topics/bugfixes.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Process](<https://devfeed.tech/topics/process.md>)

Tags: [aws](<https://devfeed.tech/tags/aws.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [code](<https://devfeed.tech/tags/code.md>), [counter](<https://devfeed.tech/tags/counter.md>), [database](<https://devfeed.tech/tags/database.md>), [distributed-system](<https://devfeed.tech/tags/distributed-system.md>), [events](<https://devfeed.tech/tags/events.md>), [example](<https://devfeed.tech/tags/example.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [idempotency](<https://devfeed.tech/tags/idempotency.md>), [jepsen](<https://devfeed.tech/tags/jepsen.md>), [schedule](<https://devfeed.tech/tags/schedule.md>)

### AI overview

The excerpt argues that schedule-dependent bugs can be common even when the event order that triggers them is rare. In a two-thread `counter++` example, 18 of 20 possible instruction orderings lose an update, yet an idle laptop produced only five orderings across 20,000 runs and lost an update four times. Rewind VM runs the guest on one virtual CPU and can change schedules at system calls or `rewind_point()` calls. In the reported runs it reached 15 of 20 orderings without a barrier and all 20 with one, exposing more lost updates than the host. The article also treats long pauses as schedules; `--stall-max` and `--stall-min` adjust stall durations to explore less common cases.

### Source excerpt

Here is something to think about: bugs are not rare, but rather the orderings of events that trigger them are. What do I mean by this?

## A clock made of branches

DevFeed: [A clock made of branches](<https://devfeed.tech/articles/a-clock-made-of-branches-112306.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/11/01/a-clock-made-of-branches>)

Published: 2026-11-01T17:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [Emulator](<https://devfeed.tech/topics/emulator.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [branch](<https://devfeed.tech/tags/branch.md>), [clock](<https://devfeed.tech/tags/clock.md>), [conditional](<https://devfeed.tech/tags/conditional.md>), [counter](<https://devfeed.tech/tags/counter.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [time](<https://devfeed.tech/tags/time.md>), [vm](<https://devfeed.tech/tags/vm.md>)

### AI overview

Rewind uses two guest-clock modes for deterministic replay. Exit time advances 5 microseconds whenever the guest exits, treating all work between exits as instantaneous; this can make timeouts impossible to reproduce and skew races. Counter time advances 1 nanosecond per retired conditional branch to account for guest work. In a billion-iteration loop, the conditional-branch count stayed at one billion across runs, while total instruction counts varied with interrupts and page faults because the counter also sees kernel activity. The author presents branch count as a repeatable, reasonably realistic proxy for time, while noting that AMD Zen can slightly overcount branches by default due to SpecLockMap; Rewind and rr address this by setting a PMU MSR bit.

### Source excerpt

What is time inside a machine you want to replay? 🧘 When building Rewind, a deterministic VM, you come face-to-face with the idea of how to represent time very quickly. You need a way to measure time inside the guest so that on subsequent replays, the guest sees the same time and makes the same decisions. Time is the ultimate variable.

## Reading the code is the hard part

DevFeed: [Reading the code is the hard part](<https://devfeed.tech/articles/reading-the-code-is-the-hard-part-106410.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/10/28/reading-the-code-is-the-hard-part>)

Published: 2026-10-28T17:00:00Z

Content type: tutorial

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [bugfixes](<https://devfeed.tech/topics/bugfixes.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [reproducibility](<https://devfeed.tech/topics/reproducibility.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-assistance](<https://devfeed.tech/tags/ai-assistance.md>), [bug](<https://devfeed.tech/tags/bug.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [build](<https://devfeed.tech/tags/build.md>), [can-bus](<https://devfeed.tech/tags/can-bus.md>), [code](<https://devfeed.tech/tags/code.md>), [commit](<https://devfeed.tech/tags/commit.md>), [commits](<https://devfeed.tech/tags/commits.md>), [concurrently](<https://devfeed.tech/tags/concurrently.md>), [data](<https://devfeed.tech/tags/data.md>), [debug](<https://devfeed.tech/tags/debug.md>), [reading](<https://devfeed.tech/tags/reading.md>), [rewind](<https://devfeed.tech/tags/rewind.md>), [testing](<https://devfeed.tech/tags/testing.md>), [user-experience](<https://devfeed.tech/tags/user-experience.md>), [vm](<https://devfeed.tech/tags/vm.md>)

### AI overview

Rewind VM can replay a test, script, or binary under many thread schedules, find failing runs, and narrow a failure to a single step. In a `git notes` example, 15 of 32 Rewind schedules lost one of two concurrently added notes even though both commands exited successfully; the author also reports the issue in normal Linux runs. `rewind diff --outputs` showed differing notes refs, `rewind blame` traced the difference to one process reading an older ref before another updated it, and `rewind where` mapped the write to Git source code. These traces make the failure reproducible and give an AI agent focused evidence to inspect the code and suggest a fix. The author says agents have found and fixed bugs this way, while Rewind itself identifies what happened but cannot explain the code's failure.

### Source excerpt

I have been stress testing Rewind VM, a deterministic VM, to work through the kinks, bugs and dog-fooding the user-experience. Even having developed it myself, I continue to be wild-eye amazed at the magic of what it can do.

## Dafuq is a deterministic VM?

DevFeed: [Dafuq is a deterministic VM?](<https://devfeed.tech/articles/dafuq-is-a-deterministic-vm-99007.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/10/24/dafuq-is-a-deterministic-vm>)

Published: 2026-10-24T17:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [boot](<https://devfeed.tech/tags/boot.md>), [c](<https://devfeed.tech/tags/c.md>), [clock](<https://devfeed.tech/tags/clock.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cpus](<https://devfeed.tech/tags/cpus.md>), [device](<https://devfeed.tech/tags/device.md>), [exit](<https://devfeed.tech/tags/exit.md>), [exits](<https://devfeed.tech/tags/exits.md>), [external](<https://devfeed.tech/tags/external.md>), [features](<https://devfeed.tech/tags/features.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [image](<https://devfeed.tech/tags/image.md>), [influence](<https://devfeed.tech/tags/influence.md>), [init](<https://devfeed.tech/tags/init.md>), [rewind](<https://devfeed.tech/tags/rewind.md>), [system](<https://devfeed.tech/tags/system.md>), [virtual](<https://devfeed.tech/tags/virtual.md>), [virtual-machine](<https://devfeed.tech/tags/virtual-machine.md>), [vm](<https://devfeed.tech/tags/vm.md>)

### AI overview

Rewind VM aims to make runs repeatable by controlling the guest's contact with the outside world. It runs a patched Linux guest under KVM and uses cooperative VM exits as numbered steps: the guest asks the monitor for time, timers, idle handling, or event reporting, and the monitor controls when interrupts arrive. Rewind hides hardware counters and random-number instructions, uses a seeded guest random generator, and schedules threads on one virtual CPU. Its input image is mapped into guest memory to avoid variable disk-read timing. The article's C example prints identical time, random value, and stack address across runs with the same seed; changing the seed changes the output. Because the monitor advances virtual time directly to a sleep deadline, a one-second sleep need not take one second of wall time. These guarantees rely on the guest being deterministic between steps and the described kernel and monitor controls.

### Source excerpt

The life of a system call inside Rewind VM. Since I started writing about Rewind VM, the question I get most from friends is not "does it work?" but "how does it actually work?" 🤔 D'uh! It is a virtual machine that only gets interrupted when it asks to be.

## Who wrote this byte?

DevFeed: [Who wrote this byte?](<https://devfeed.tech/articles/who-wrote-this-byte-98446.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/10/23/who-wrote-this-byte>)

Published: 2026-10-23T17:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [reproducible builds](<https://devfeed.tech/topics/reproducible-builds.md>), [reproducibility](<https://devfeed.tech/topics/reproducibility.md>), [Nix](<https://devfeed.tech/topics/nix.md>), [builds](<https://devfeed.tech/topics/builds.md>), [Data integrity in software engineering](<https://devfeed.tech/topics/data-integrity-in-software-engineering.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [GPU instancing](<https://devfeed.tech/topics/gpu-instancing.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [builds](<https://devfeed.tech/tags/builds.md>), [git](<https://devfeed.tech/tags/git.md>), [hash](<https://devfeed.tech/tags/hash.md>), [input](<https://devfeed.tech/tags/input.md>), [nix](<https://devfeed.tech/tags/nix.md>), [package](<https://devfeed.tech/tags/package.md>), [reproducibility](<https://devfeed.tech/tags/reproducibility.md>), [reproducible-builds](<https://devfeed.tech/tags/reproducible-builds.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

Rewind VM's `rewind blame` traces the first program that wrote a differing byte between two build runs. In the `tiles` example, varying Python's random hash seed changes the order of dependencies written to a pkg-config file; blame traces the difference through `install` to `python3`, and sorting the dependencies fixes it. Rewind records file writes and opens in the guest kernel, then reads those traces to identify byte provenance without replaying both runs. Its checks can vary random seeds, thread schedules, and directory-entry order, each of which can expose different sources of non-reproducibility. The excerpt also describes a visual comparison in the Rewind app and says recording overhead was measured as small enough to keep enabled in every run.

### Source excerpt

git blame for your build's bytes. 🔍 A build is bit reproducible when the same inputs give the same bytes. Why does reproducibility matter? They provide certainty that software is genuine and has not been tampered with. See reproducible-builds.org. Nix is infamously not bit reproducible, but rather input-addressed: the hash of a package is calculated from the inputs rather than the output.

## No quarter for gaps

DevFeed: [No quarter for gaps](<https://devfeed.tech/articles/no-quarter-for-gaps-91423.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/10/20/no-quarter-for-gaps>)

Published: 2026-10-20T16:00:00Z

Content type: opinion

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Ruby](<https://devfeed.tech/topics/ruby.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [code](<https://devfeed.tech/tags/code.md>), [cost](<https://devfeed.tech/tags/cost.md>), [economics](<https://devfeed.tech/tags/economics.md>), [ecosystem](<https://devfeed.tech/tags/ecosystem.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [nix](<https://devfeed.tech/tags/nix.md>), [nixpkgs](<https://devfeed.tech/tags/nixpkgs.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [slop](<https://devfeed.tech/tags/slop.md>), [software](<https://devfeed.tech/tags/software.md>), [verify](<https://devfeed.tech/tags/verify.md>), [workaround](<https://devfeed.tech/tags/workaround.md>)

### AI overview

The author argues that LLMs make it economical to close long-standing software-stack gaps. In the Nix/Ruby case, a nixpkgs manual workaround reportedly failed in practice, while a Bundler lockfile solution, gemlock.nix, was written in under an hour to address the author's problem. The article says AI-assisted development can still produce slop, but describes reproducible Nix tests as a way for agents to verify generated code. It presents this as a personal example of a broader shift in the cost of fixing neglected ecosystem issues.

### Source excerpt

The advent of large language models has changed the economics of closing gaps in software stacks.

## One store, two frontends

DevFeed: [One store, two frontends](<https://devfeed.tech/articles/one-store-two-frontends-89568.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/10/17/one-store-two-frontends>)

Published: 2026-10-17T16:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [NixOS](<https://devfeed.tech/topics/nixos.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>)

Tags: [bazel](<https://devfeed.tech/tags/bazel.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [content-addressed-store](<https://devfeed.tech/tags/content-addressed-store.md>), [ebpf](<https://devfeed.tech/tags/ebpf.md>), [glibc](<https://devfeed.tech/tags/glibc.md>), [linux](<https://devfeed.tech/tags/linux.md>), [nix](<https://devfeed.tech/tags/nix.md>)

### AI overview

The article proposes using relocatable Nix store closures so Nix and build systems such as Buck2 and Bazel can share artifacts and support remote execution. It explains how relative runtime paths, Linux 7.3 interpreter support, and content-addressed outputs could connect the systems, and describes a proof of concept plus the work needed to complete the approach.

### Source excerpt

One of the big ideas I think the Nix community should pursue is relocatable binaries. I put my money where my mouth is and collaborated with the VFS Linux maintainer Christian Brauner to get $ORIGIN support in PT_INTERP and the shebang via EBPF 🐝. That work is in Linux 7.3 which is about to be released.

## Using Rewind VM properties to find and verify concurrency bugs

DevFeed: [Using Rewind VM properties to find and verify concurrency bugs](<https://devfeed.tech/articles/always-sometimes-never-86860.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/10/14/always-sometimes-never>)

Published: 2026-10-14T18:00:00Z

Content type: tutorial

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [intermittent failures](<https://devfeed.tech/topics/intermittent-failures.md>), [table driven tests](<https://devfeed.tech/topics/table-driven-tests.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [flaky-tests](<https://devfeed.tech/tags/flaky-tests.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

The article explains how Rewind VM explores different thread schedules to find flaky tests and concurrency bugs. It shows how property-based checks, including assertions about outcomes and invariants, can identify a race condition in a Java bank example and verify that a lock fixes it.

### Source excerpt

Exit 0 means your program exited 0. That's it. That's all it means. 🍞 I have been working on a deterministic VM called Rewind VM, where "a run" (i.e. test, command etc.) is a function of its inputs including the thread schedule. The determinism comes from the tool recording every step which lets you replay it exactly. This alone is a pretty good way to find flaky tests: run the test under Rewind, then rewind check runs it under many different thread schedules, with some slight latency added, and failures often crop up. 🐛

## Jinx compiles Nixpkgs to TypeScript for evaluation across the TypeScript ecosystem

DevFeed: [Jinx compiles Nixpkgs to TypeScript for evaluation across the TypeScript ecosystem](<https://devfeed.tech/articles/nixpkgs-for-the-frontend-impaired-85701.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/10/12/nixpkgs-for-the-frontend-impaired>)

Published: 2026-10-12T21:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Nix](<https://devfeed.tech/topics/nix.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [frontend](<https://devfeed.tech/tags/frontend.md>), [nixpkgs](<https://devfeed.tech/tags/nixpkgs.md>), [reproducibility](<https://devfeed.tech/tags/reproducibility.md>), [typescript](<https://devfeed.tech/tags/typescript.md>)

### AI overview

Jinx compiles Nix expressions into TypeScript while preserving their evaluation behavior and derivation paths. The article reports that it compiled all 231,777 Nixpkgs attributes and found no differences in derivation paths across three tested platforms. This makes Nixpkgs accessible to TypeScript tools for editor completion, debugging, profiling, scripting, unit testing, and browser evaluation, though evaluation is slower than native Nix.

### Source excerpt

tl;dr jinx is a tool that compiles Nix to TypeScript. All of nixpkgs, each 231,777 attribute, produces the exact drvPath Nix does. Open the playground or evaluate hello in your browser tab with no Nix installed anywhere. 😈 Despite my admiration and joy for Nix, the language and tool, it is not what is magical. The store model is the great idea. Any similar tool built on the same model will have the same magical properties of reproducibility, and hermeticity.

## How Nix enables deterministic debugging of race conditions

DevFeed: [How Nix enables deterministic debugging of race conditions](<https://devfeed.tech/articles/nix-wrote-half-of-my-debugger-76908.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/10/07/nix-wrote-half-of-my-debugger>)

Published: 2026-10-07T19:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Nix](<https://devfeed.tech/topics/nix.md>), [gdb](<https://devfeed.tech/topics/gdb.md>), [race-condition](<https://devfeed.tech/topics/race-condition.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>)

Tags: [debugger](<https://devfeed.tech/tags/debugger.md>), [nix](<https://devfeed.tech/tags/nix.md>), [race-condition](<https://devfeed.tech/tags/race-condition.md>)

### AI overview

The author describes Rewind, a debugger built around Nix derivations and a deterministic virtual machine. Rewind can replay builds, vary thread schedules to find race conditions, compare runs, and inspect program state with gdb. Nix supplies reproducible inputs, sources, and debug symbols for the debugging workflow.

### Source excerpt

A few days ago I wrote about Rewind VM, a deterministic VM where every run of a Nix build is a pure function of its inputs, thread schedule included! I have been using it to find, reproduce and solve numerous race conditions in Nix builds, but it's been making me feel a little crazy. What is this superpower, and why is nobody else using it? The tool has quickly grown a source panel, stack frames, bookmarks, a "Compare" tab, a lot more gdb support, thread lanes, which show who held the CPU at every step, and "Check from here", which helps find the exact step where a race condition happens. I went into each new feature thinking it would be a big code-lift but I kept running into the same thing: the hard part of each feature was already done, and Nix had done it. A debugger for instance, needs the exact inputs of the program, its debug symbols, its sources, the sources of every library under it, and a way for someone else to get all of that on their machine. That's exactly what a derivation is, and Nix makes that easy.

## Rewind VM: a flaky build you only catch once

DevFeed: [Rewind VM: a flaky build you only catch once](<https://devfeed.tech/articles/rewind-vm-a-flaky-build-you-only-catch-once-64486.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/10/03/rewind-vm-a-flaky-build-you-only-catch-once>)

Published: 2026-10-04T02:52:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Chaos Engineering](<https://devfeed.tech/topics/chaos-engineering.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [make](<https://devfeed.tech/topics/make.md>), [NixOS](<https://devfeed.tech/topics/nixos.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [ci](<https://devfeed.tech/tags/ci.md>), [flaky](<https://devfeed.tech/tags/flaky.md>), [laptop](<https://devfeed.tech/tags/laptop.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

Rewind VM makes Linux builds and test runs reproducible by controlling external events and allowing developers to replay or explore perturbed thread schedules. The article demonstrates how it exposes and helps fix a dining philosophers deadlock, while noting limits such as one virtual CPU, no network access beyond loopback, and replay on the same CPU vendor.

### Source excerpt

If a test fails on CI and nobody can reproduce it, did it really fail? 🧘 Nix gives me a build that is a function of its inputs via the extensional model. The same derivation, produces the same store path, and if I am lucky, the same bytes. What Nix does not give me is the same run.1 A test suite with a race in it may pass on my laptop, fail once on CI, and when I rebuild it to look, it passes again. A run is the sequence of events that happen in a process to produce a result. A build is a run of a derivation. ↩

## Using a Python CI check to keep AI-written prose consistent with a preferred style

DevFeed: [Using a Python CI check to keep AI-written prose consistent with a preferred style](<https://devfeed.tech/articles/hiding-my-ai-slop-from-my-nix-friends-61476.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/09/28/hiding-my-ai-slop-from-my-nix-friends>)

Published: 2026-09-28T20:21:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Nix](<https://devfeed.tech/topics/nix.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Python](<https://devfeed.tech/topics/python.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [build](<https://devfeed.tech/tags/build.md>), [ci](<https://devfeed.tech/tags/ci.md>), [code](<https://devfeed.tech/tags/code.md>), [code-comments](<https://devfeed.tech/tags/code-comments.md>), [codex](<https://devfeed.tech/tags/codex.md>), [nix](<https://devfeed.tech/tags/nix.md>), [prompting](<https://devfeed.tech/tags/prompting.md>), [python](<https://devfeed.tech/tags/python.md>), [source](<https://devfeed.tech/tags/source.md>)

### AI overview

The author describes using AI for software work while trying to keep its prose from sounding generic. After repeated prompts failed to enforce the preferred style, an agent created a Python script that scans the repository for banned words and phrases. The script was added to CI, making the style check deterministic and reproducible.

### Source excerpt

Warning If you are pissed off reading this, you can start here and work your way back. I am using AI a lot. I am public about my use of it and when required make the necessary disclosures: "Assited-By" trailers or having to say "I used an AI to help write this software" on every Discourse post.1 Seems like whether or not you use AI, I feel more compelled just to disclose I did to avoid the "you didn't disclose it" argument. Such is life. ↩

## Every package is already installed

DevFeed: [Every package is already installed](<https://devfeed.tech/articles/every-package-is-already-installed-59656.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/09/24/every-package-is-already-installed>)

Published: 2026-09-25T02:14:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Nix](<https://devfeed.tech/topics/nix.md>), [Package Management](<https://devfeed.tech/topics/package-management.md>), [file](<https://devfeed.tech/topics/file.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agent-harness](<https://devfeed.tech/tags/agent-harness.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [filesystem](<https://devfeed.tech/tags/filesystem.md>), [go](<https://devfeed.tech/tags/go.md>), [nix](<https://devfeed.tech/tags/nix.md>), [nixpkgs](<https://devfeed.tech/tags/nixpkgs.md>), [package-management](<https://devfeed.tech/tags/package-management.md>), [packages](<https://devfeed.tech/tags/packages.md>), [shell](<https://devfeed.tech/tags/shell.md>)

### AI overview

The article introduces omnibin, a FUSE filesystem that exposes binaries from Nixpkgs on demand without installing packages or building them locally. It uses JSON metadata from Hydra and lazily fetches and unpacks archives from the Nix cache when files are accessed.

### Source excerpt

tl;dr; omnibin is a FUSE filesystem that puts every binary nixpkgs ever shipped on your $PATH. Nothing is installed. Nothing needs building. 0 bytes on disk until something actually reads a file. 😈 It's 2026, why am I still installing packages individually?1 Why must I go through the ritual of adding a package to my configuration.nix, running nix-shell or succumb to the hellscape of nix-env -iA. Yes, I am a little inspired after watching DHH's keynote at RailsConf 2026. I feel the same way about package management. ↩

## How Nix Dynamic Derivations Change Build Graphs

DevFeed: [How Nix Dynamic Derivations Change Build Graphs](<https://devfeed.tech/articles/a-build-graph-that-rolls-dice-55651.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/09/20/a-build-graph-that-rolls-dice>)

Published: 2026-09-21T01:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Nix](<https://devfeed.tech/topics/nix.md>), [builds](<https://devfeed.tech/topics/builds.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [build-system](<https://devfeed.tech/tags/build-system.md>), [nix](<https://devfeed.tech/tags/nix.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

The article examines how Nix dynamic derivations change build graphs from being fully known in advance to being defined as a build progresses. It explains this distinction using applicative and monadic computation models.

### Source excerpt

We are right around the corner from NixCon 2026. Another year where I sadly won't be present.

## Visualizing Nix closures

DevFeed: [Visualizing Nix closures](<https://devfeed.tech/articles/visualizing-nix-closures-54774.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/09/15/visualizing-nix-closures>)

Published: 2026-09-16T03:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Nix](<https://devfeed.tech/topics/nix.md>), [Closure](<https://devfeed.tech/topics/closure.md>), [NixOS](<https://devfeed.tech/topics/nixos.md>), [Web app](<https://devfeed.tech/topics/webapp.md>), [browser](<https://devfeed.tech/topics/browser.md>)

Tags: [browser](<https://devfeed.tech/tags/browser.md>), [nix](<https://devfeed.tech/tags/nix.md>), [nixos](<https://devfeed.tech/tags/nixos.md>), [visualization](<https://devfeed.tech/tags/visualization.md>), [web-app](<https://devfeed.tech/tags/web-app.md>)

### AI overview

The author introduces seenix.dev, an interactive browser-based tool that visualizes every byte in a Nix closure as pixels along a Hilbert curve. It can map closures from individual packages to large NixOS systems without server-side execution or downloading NARs for layout, and helps inspect dependencies and binary contents.

### Source excerpt

tl;dr seenix.dev lays every byte of a Nix closure out on a map, one pixel per byte, and lets you zoom from a whole NixOS system down to the hex of libc.so.6. Try hello, firefox or a GNOME desktop. Nothing runs on a server. With the advent of LLMs I keep tugging at any crazy question I ask myself. I know there is the anti-AI crowd and they will happily proclaim anything pursued in this vein as "slop" but I am feeling fortunate to be able to explore these questions.

## How a Personal Dashboard Tracks Writing Engagement Across Hacker News and Other Platforms

DevFeed: [How a Personal Dashboard Tracks Writing Engagement Across Hacker News and Other Platforms](<https://devfeed.tech/articles/orange-site-vanity-54773.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/09/14/orange-site-vanity>)

Published: 2026-09-14T22:04:00Z

Content type: opinion

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [dashboards](<https://devfeed.tech/topics/dashboards.md>), [Google Analytics](<https://devfeed.tech/topics/google-analytics.md>), [GitHub Actions](<https://devfeed.tech/topics/github-actions.md>), [data](<https://devfeed.tech/topics/data.md>), [Nix](<https://devfeed.tech/topics/nix.md>)

Tags: [dashboard](<https://devfeed.tech/tags/dashboard.md>), [github](<https://devfeed.tech/tags/github.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [google-analytics](<https://devfeed.tech/tags/google-analytics.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [nix](<https://devfeed.tech/tags/nix.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [reddit](<https://devfeed.tech/tags/reddit.md>), [tracking](<https://devfeed.tech/tags/tracking.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

The author reflects on writing for personal understanding and examines the vanity of public readership by building a dashboard to track engagement. The project combines Google Analytics and Search Console data with submissions to Hacker News, Reddit, and Lobsters, using offline updates, GitHub Actions, and a Nix derivation.

### Source excerpt

"Curiosity is only vanity. We usually only want to know something so that we can talk about it" - Blaise Pascal, Pensées I enjoy writing. Most of the time I write for myself, or that is what I tell myself. The act of writing is me trying to deeply understand something and then recording my thought process. It has paid dividends already as I have gone back numerous times to reference myself.

## A Nix store is three functions

DevFeed: [A Nix store is three functions](<https://devfeed.tech/articles/a-nix-store-is-three-functions-54772.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/09/11/a-nix-store-is-three-functions>)

Published: 2026-09-12T03:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Nix](<https://devfeed.tech/topics/nix.md>), [Cross-origin resource sharing (CORS)](<https://devfeed.tech/topics/cors.md>), [GitHub Pages](<https://devfeed.tech/topics/github-pages.md>), [HTTP](<https://devfeed.tech/topics/http.md>), [Git](<https://devfeed.tech/topics/git.md>)

Tags: [cors](<https://devfeed.tech/tags/cors.md>), [git](<https://devfeed.tech/tags/git.md>), [github-pages](<https://devfeed.tech/tags/github-pages.md>), [http](<https://devfeed.tech/tags/http.md>), [nix](<https://devfeed.tech/tags/nix.md>)

### AI overview

The article explains that a Nix binary cache can be implemented with three functions and that the underlying storage medium, protocol, and domain can vary. It discusses using GitHub Pages and other static file servers as Nix stores, with signatures and content-addressed archives providing transport independence.

### Source excerpt

While building trynix I needed somewhere to host a store-path that did not exist on cache.nixos.org.1 I wanted to demonstrate that non-Nixpkgs store paths could be booted just as easily. I was also waiting for @domenkozar to enable CORS on cache.nixos.org so I could use it. ↩

## Review a pull request by booting it

DevFeed: [Review a pull request by booting it](<https://devfeed.tech/articles/review-a-pull-request-by-booting-it-54771.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/09/09/review-a-pull-request-by-booting-it>)

Published: 2026-09-09T21:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [GitHub Actions](<https://devfeed.tech/topics/github-actions.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [browser](<https://devfeed.tech/topics/browser.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [Nix](<https://devfeed.tech/topics/nix.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>)

Tags: [browser](<https://devfeed.tech/tags/browser.md>), [ci](<https://devfeed.tech/tags/ci.md>), [code](<https://devfeed.tech/tags/code.md>), [github](<https://devfeed.tech/tags/github.md>), [linux](<https://devfeed.tech/tags/linux.md>), [nix](<https://devfeed.tech/tags/nix.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>)

### AI overview

The article presents trynix-preview, a GitHub Action that lets reviewers boot a pull request's build in a browser for testing and feedback. It describes the workflow's cache requirements and fork-related security considerations, while noting poor performance for large binaries.

### Source excerpt

tl;dr; trynix-preview is a GitHub action that comments a link on a pull request which lets you boot the PR's build in the browser using https://trynix.dev. No servers, just browsers.

[Next page](<https://devfeed.tech/sources/farid-zakaria-s-blog.md?cursor=WyIyMDI2LTA5LTA5VDIxOjAwOjAwKzAwOjAwIiwgIjEwZThhNmM3LTBmYjUtNGYwZi1iM2Y2LTVjNjgzMzExNjg3ZSJd>)