practical process control

control systems

What makes Elixir great for startups?

elixir

whose github actions am I running?

devops security

Scaling Prometheus: From Single Node to Enterprise-Grade Observability

devops sre

[2310.15505] The Quantum Tortoise and the Classical Hare: A simple framework for understanding which problems quantum computing will accelerate (and which it will not)

cs physics quantum

Testing concurrent code with testing/synctest - The Go Programming Language

golang

Resilience: some key ingredients

resilience sre

Versioning versus Coordination - Marc’s Blog

distributed systems

Beej’s Guide to Git

devops

Let’s Implement Consistent Hashing From Scratch

distributed systems golang

Gravy Pitcher by Myrtle Pedals

Track featuring the mystery pedal that uses my artwork.

art guitar

How AI generated code compounds technical debt - LeadDev

ai

Systems Correctness Practices at AWS

cs

Normalize chart data using Ecto and PostgreSQL

databases elixir

Meta’s Hyperscale Infrastructure Overview and Insights

distributed systems sre sysadmin

How doctors handoff patients (how it applies to incidents) : sre

I-PASS stands for:

• Illness Severity
• Patient Summary
• Action List
• Situation Awareness & Contingency Planning
• Synthesis by Receiver

sre

Representing graphs in Postgresql

databases

Summary of How I write HTTP services in Go after 13 years:

• The NewServer constructor - big constructor that takes all dependencies as parameters. returns http.Handler. configures its own muxer and calls out to routes.go. includes setting up middleware, CORS, logging. ** Long argument lists - type safety in arguments.
• Map the entire API surface in routes.go
• func main() only calls run() - run() returns an error and accepts OS fundamentals as parameters for easier testing. background context is created in main but all other context handling is done in run. ** Gracefully shutting down - pass context through and check it at each level. ** Controlling the environment - use flags.NewFlagSet inside run. make a replacement os.Getenv for tests and pass that to run (or the real thing for main).
• Maker funcs return the handler - creates a readable closure for each.
• Handle decoding/encoding in one place - for JSON/XML encode/decode.
• Validating data - single method interface with Valid(ctx context.Context) (problems map[string]string)
• The adapter pattern for middleware - take an http.Handler and return one.
• Sometimes I return the middleware ** An opportunity to hide the request/response types away - keeps global space clear.
• Use inline request/response types for additional storytelling in tests
• sync.Once to defer setup - anything expensive during handler setup, defer to the first time it’s called to improve overall app startup time.
• Designing for testability ** What is the unit when unit testing? - multiple levels of options from run() down to calling individual handler functions. ** Testing with the run function ** Waiting for readiness - loop on hitting a /healthz endpoint until the server has started.

golang

Probabilistic Increment: A Randomized Algorithm to Mitigate Hot Rows

algorithms distributed systems sre

Improved evaluation times with pre-resolved Nix store paths

nixos

Persistent packages on Steam Deck using Nix

nixos

Black-Scholes

finance math

Build a Modern Godot 4 MMO with Golang | Tristan Batchler

golang

rewrite.md

Really good writeup of Roc’s decision to rewrite their compiler in Zig (original version written in Rust).

roc rust zig

scalable oltp in the cloud: what’s the big deal?

databases distributed systems

Data evolution with set-theoretic types - Dashbit Blog

elixir

Go All the Way: Why Golang is Your Swiss Army Knife for Modern Development

golang

Out-of-the-box Elixir telemetry with Phoenix - Honeybadger Developer Blog

elixir

Phoenix LiveView: Presenting DateTime in User’s Time Zone - Mike Zornek

elixir

Market Structure Primer

finance

The Modifications I Make to Every New Phoenix Project - John Elm Labs

elixir

Packer: How to Build NixOS 24 Snapshot on Hetzner Cloud - Developer Friendly Blog

devops nixos

Functional programming self-affirmations - NorikiTech

cs functional

How Distributed Systems Avoid Race Conditions using Pessimistic Locking?

distributed systems

TLA+ from first principles

cs math

Designing a distributed circuit breaker for disabling webhook endpoints in Golang

distributed systems golang

An Alternative Construction of Shannon Entropy

math

You built an Erlang

erlang

From ALB to Caddy - Our Wandering Path to Supporting Thousands of Domain Names

distributed systems sysadmin

ouaouaron - Wiktionary, the free dictionary - the Canadian French word for “bullfrog”, ouaouaron, likely derives from an Iroquois word pronounced like “wawaron” (which is probably onamotapoeic). French doesn’t really use “w” for that sound, so they used “ou” instead.

linguistics

Netflix’s distributed counter abstraction

distributed systems

Putting a full power search engine in Ecto

databases elixir

Advanced inserts with Ecto | Bego.dev

databases elixir

NixOS is a good server OS, except when it isn’t | Bernardo Vecchia Stein / Daniel Sidhion

linux nixos

A good day to trie-hard: saving compute 1% at a time

datastructures rust

Avoiding downtime: modern alternatives to outdated certificate pinning practices

cryptography security

How to respond to global broadcasts in Phoenix Liveview

elixir

Good Retry, Bad Retry: An Incident Story | by Denis Isaev | Yandex | Aug, 2024 | Medium

distributed systems sre

making a video out of an audio file and a single image:

$ ffmpeg -loop 1 -i cover.jpg -i audio_file.mp3 -c:v libx264 -tune stillimage -c:a aac -shortest -pix_fmt yuv420p output.mp4

Note: the image must have a height that’s divisible by 2.

linux

Garnix Blog: Hands-on NixOS servers

nixos