Software

A C programmer compares resource cleanup, bounds checks, errors, and tooling in Zig, alongside the costs of an evolving language.

A Home Assistant project traces an air purifier's cloud setup and replaces it with local provisioning and control.

Mehmet Ince traces a PostgreSQL type-confusion vulnerability from a prepared value and a schema change to a backend exploit.

A developer traces unexpected traffic to Defender sample submissions and shows how to check the logs without mistaking network connections for proof of a file upload.

The limits of program verification, and why targeted checks and empirical study still matter.

A faster tile copier for an 8-bit game borrowed the system stack, then had to survive audio interrupts without corrupting its source data.

A Rust UI benchmark asks which components rerun after one value changes, and what coarse invalidation costs as an app grows.

A toy allocator shows why malloc keeps freed memory, when pages become resident, and what glibc trades for speed.

James Hague's reading list favors real problems, creative practitioners, and simple code: five older books whose ideas travel beyond their languages.

Five years into running his firm on Free software, Neil Brown keeps the tools that earn their upkeep and retires the services nobody uses.

GitHub separates immutable objects from mutable references, shrinking consensus work and moving compaction off the machines serving requests.

Kevin Boone's UEFI programming advice: test ordinary logic on Linux, make platform assumptions explicit, and budget for the operating-system services you lose.

An offline probe, plaintext logs and independent cryptographic checks turn a gym app's rotating QR code into a small browser tool.

An audit engine keeps its Scala core while Java takes over APIs and workflows. Migration safety starts with the boundary between them.

A CAD architecture write-up connects scripted nodes, functional geometry, and draggable handles through one dependency graph.

Paul Masurel on extension points, shared benchmarks with Lucene, and the review work that keeps a search library maintainable.

A free software license signals one set of commitments; project governance and community practices reveal who gets a say.

Jake Voytko recalls crashes, lost documents, and fragile installs. Reliability improves when systems absorb the recovery work users once had to do themselves.

Bloffy's creator replaced Next.js with Hono for public blog pages, removing browser JavaScript while keeping Next.js for the management app.

Alfie John's route from swapping games to writing demos shows what a good tutorial can do: make something admired feel within reach.

A moreutils tour covers quieter successful jobs, visible failures, safe input buffering, and timestamps for shell debugging.

A Roc compression library approaches libdeflate's speed through careful ownership, bounds-check elimination, and compile-time work.

rqlite's creator maps three different needs behind distributed SQLite: consensus, disaster recovery, and merging independent writes.

Peter and George Phillips on preserving old software with emulation, binary translation, and an honest budget for compatibility.

PHP's allocator could abandon half-built structures that shutdown later traversed. Alexandre Daubois traces the failure and explains why two CVEs need different mitigations.

Dijkstra argues that precise notation reduces mistakes and communication costs. Making an interface more familiar can create extra work on both sides.

Evgen Bodunov takes a map triangulator from 2.93 seconds to 489 milliseconds by simplifying the job, measuring each change, and preserving fallbacks.

Rust compiler contributor Matyáš Racek traces faster builds and new capabilities to years of architectural cleanup, performance triage, and sustained maintenance.

Sean Goedecke treats a deadline as a constraint for choosing a design, then gives managers several approaches with explicit risks. His focus is unfamiliar work in large codebases.

Netflix connects telemetry, deployments and incident discussions through a validated knowledge graph. Its agents propose evidence-backed hypotheses; engineers still decide what happened.

A buggy Breakout clone and some difficult weekend experiments make Chris Kiehl's case for programming without an economic justification.

Karri Saarinen on earned intuition, shared product judgment, and why individually sound features can make the whole product worse.

Build a text parser from small functions, then read the HN discussion for the failure cases a friendly introduction leaves aside.

A 1982 research agenda for better tools, trustworthy reusable components, and prototypes that expose misunderstood requirements before implementation.

Rain presses for specific credit to Mononoke's design, then accepts Anthropic's added attribution. The discussion separates that correction from disagreement over the engineering achievement.

Sharp texels, palette-based lighting, and a useful reminder that a faster rendering backend can change the work it renders.

Reusing an open-source design is welcome. Crediting its authors should not disappear when an LLM helps build the successor.

A case for programming without a business case: follow curiosity, build disposable experiments, and keep production obligations out of the playground.

A Google DevSite RCE writeup shows how readable session state, credential reuse, and pickle deserialization collapsed a trust boundary.

A stalled Linux audio project becomes tractable when guessing at algorithms gives way to controlled probes, explicit assumptions, and held-out validation.

Around €150 of real-user testing exposed the assumptions a developer couldn't see in his own installation guide.

A delayed cleanup deleted a new alarm's wake entry. Celld's simulator found the race, replayed it, and turned it into a regression test.

A large memory-bandwidth gain translated into a small compiler speedup: a useful reminder to distinguish microbenchmarks from end-to-end performance.

Treat telemetry export as a product capability: OTLP destinations, preserved context, and an explicit trade-off between tenant isolation and operational overhead.

Zotero's origin story shows why understanding a workflow together takes longer than writing a prototype — and why that time can make software last.

Invest in accessibility, native CSS, and communication rather than mistaking a fashionable stack for a durable web-development career.

Software posts lose readers through slow openings, assumed knowledge, links that do the explaining, and broken mobile layouts.

A hands-on tour of the kernel boundaries that make a container: namespaces, capabilities, seccomp, and resource limits.

A CHICKEN Scheme maintainer on debugging a heap corruption, learning a language runtime, and knowing when a REPL's state cannot be trusted.

Lukas Vogel runs Doom's game logic and renderer inside CedarDB, revealing which parts fit set-based processing and which fight it.