2026

August 58

• Subprocess without the shell42026-08-25
• Salary conversation without guessingarchived82026-08-25
• How much coverage is enough82026-08-25
• Bike gears that skip under load82026-08-25
• Sample size before running the test42026-08-24
• Questions to ask the interviewer62026-08-24
• Full text search in SQLite without a server42026-08-24
• Documentation for a project only you know62026-08-24
• Open Graph tags that change nothing in ranking42026-08-23
• Is turning on strict worth the errors it produces62026-08-23
• Choosing a train test split for tiny data42026-08-23
• Choosing a compression format42026-08-23
• My regex for nested brackets keeps failing42026-08-22
• Is a sitemap worth it for twenty pages42026-08-22
• How do I plan dinners that still happen on the bad days82026-08-22
• Any approach to jet lag that actually works42026-08-22
• Which mini PC is quiet enough to sit in a bedroom62026-08-21
• Small subscriptions add up and I lose track62026-08-21
• MTU problems that look like random hangs42026-08-21
• Choosing an SSD for constant writes42026-08-21
• What ratio and time for cold brew that does not taste harsh62026-08-20
• My loop breaks on filenames containing spaces132026-08-20
• Feature flags versus branches42026-08-20
• Connection pool sizing for a small service62026-08-20
• Why estimates are always optimistic62026-08-19
• What do I write down before going on holiday82026-08-19
• Systemd service that restarts too eagerly62026-08-19
• Counting rows without the full scan62026-08-19
• Why estimates are always optimistic42026-08-18
• Soft deletes that do not haunt you42026-08-18
• Keeping secrets out of a repository62026-08-18
• Comparing two offers with different equity82026-08-18
• Rebase versus merge for a small team82026-08-17
• Jet lag that does not ruin the first days42026-08-17
• Edge cases worth writing down42026-08-17
• Catching exceptions without hiding bugs152026-08-17
• Timestamptz or timestamp for event times42026-08-16
• The rear derailleur skips on the third gear when I push hard42026-08-16
• My raised bed dries within a day42026-08-16
• Choosing a chart for a five point scale132026-08-16
• Strict mode on an existing project82026-08-15
• Kubernetes secrets are just base64. Is that a problem62026-08-14
• Interviewing when you hate whiteboards62026-08-13
• Slow PostgreSQL query on a 40M row tablearchived182026-08-12
• Making a static site discoverable42026-08-12
• Vocabulary that sticks192026-08-11
• Embeddings for search on a small corpus42026-08-11
• Alphabetical sort puts accented names at the end172026-08-11
• Where should a local app keep an API key132026-08-10
• Estimating how well text will compress62026-08-09
• Cutting a text in half without losing content42026-08-09
• Large pull requests nobody reviews62026-08-08
• First week for a new developer172026-08-08
• Meal plan that survives a busy week62026-08-07
• Everything I asked while rewriting the ingest service482026-08-05
• Should requests equal limits62026-08-04
• Rolling update that drops requests82026-08-03
• Gradient descent, but explain the math182026-08-01

July 30

• How many database connections should a service with 4 workers42026-07-31
• REST or gRPC for internal services42026-07-30
• Pagination that survives inserts62026-07-30
• Reviewing code without nitpicking62026-07-29
• Diagnosing slow DNS172026-07-29
• Exposing a home service safely42026-07-27
• Any way to opt out of whiteboard interviews without seeming62026-07-26
• When to use JSONB instead of columns42026-07-25
• Finished Designing Data-Intensive Applications. What next62026-07-25
• Why my index is not being used62026-07-23
• Making a script importable and runnable62026-07-23
• Web font swaps cause a visible reflow. Fix62026-07-22
• Does resting a steak actually matterarchived22026-07-21
• Resting meat, real or mytharchived42026-07-20
• Reading a ChatGPT export without losing your mind182026-07-20
• Two visually identical strings fail an equality check62026-07-19
• Greedy versus lazy quantifiers152026-07-18
• Strength work with no equipment42026-07-17
• Queue versus cron for background work22026-07-15
• Birthday collisions in identifiers82026-07-14
• My edits look wrong on the phone62026-07-13
• Counting characters that users recognise62026-07-12
• Deploys cause a handful of 502s every time42026-07-11
• Why my list comprehension is slower than a loop62026-07-09
• Why is my container image 1.2 GB162026-07-09
• Setting up the home archive, start to finish462026-07-09
• Latency numbers worth memorising42026-07-08
• Testing code that talks to the network62026-07-03
• Reading papers without a maths degree62026-07-03
• I pushed a bad commit to a shared branch. Reset or revert42026-07-01

June 35

• Monthly spending review142026-06-30
• Cutting a text in half without losing content62026-06-30
• Twelve recurring meetings and nobody remembers why half exist82026-06-29
• Errors clients can act on62026-06-29
• Writing a changelog worth keeping22026-06-27
• How much salt is right for pasta water82026-06-27
• Do I need ECC memory at home62026-06-26
• How do people fit a week into carry-on22026-06-25
• Choosing an SSD for constant writes82026-06-25
• Watering that survives a heatwave62026-06-24
• Rewriting to async made throughput worse172026-06-23
• Reading logs without drowning22026-06-23
• Positive expected value means I should take the bet every time82026-06-22
• Is there a real reason to use dataclasses over dicts for42026-06-21
• Pan sauce that separates22026-06-20
• Making a table readable on a phone42026-06-19
• Is port forwarding to a home server a bad idea62026-06-19
• Index bloat after a bulk delete82026-06-18
• Deciding what not to keeparchived152026-06-18
• RAW or JPEG for casual shooting42026-06-13
• Image that never made it into the export32026-06-13
• Pan sauce that separates82026-06-12
• Matching nested structures42026-06-10
• Measuring before optimising192026-06-09
• I cannot mutate a vector while iterating over it132026-06-08
• Reading logs without drowning62026-06-07
• How long should a take-home exercise bearchived42026-06-07
• Regex for parsing nginx access logs42026-06-06
• Strings that look identical but compare unequal42026-06-05
• I need one commit from a long branch, not the rest152026-06-05
• Exposing a home service safely42026-06-05
• Should the venv see system site-packages82026-06-04
• Four threads and the CPU-bound job takes the same time42026-06-03
• Big O that matters and Big O that does not22026-06-03
• How do you shorten a document that feels bloated42026-06-02

May 21

• Rebase versus merge for a small team62026-05-27
• Finding when a bug appeared42026-05-27
• Dataclasses versus plain dicts172026-05-27
• I read and forget. What note system survives22026-05-26
• Fixing a wobbly standing desk62026-05-23
• Docker compose setup for local development142026-05-23
• Alerts nobody ignores132026-05-22
• Every handled exception ends up in the logs and drowns the real62026-05-19
• Dependency updates without breaking everything22026-05-19
• Migrations that lock the table22026-05-17
• Reviewing a change you do not understand82026-05-11
• How do people practise in a flat22026-05-11
• Dark mode without a flash of white82026-05-11
• Can a status meeting be replaced by writing62026-05-11
• CAP theorem in plain words42026-05-11
• A folder of photos compresses to 98% of its size42026-05-10
• Read replicas and stale reads42026-05-09
• Choosing between managed and self-hosted database42026-05-09
• How do I retry a network command a few times in basharchived42026-05-08
• How do I estimate a data migration with unknown data quality82026-05-08
• Is a deleted_at column a good idea82026-05-07

April 20

• Retrying a flaky commandarchived62026-04-29
• Gzip, zstd or xz for archives I keep for years62026-04-29
• With 800 labelled examples, is an 80/20 split reasonable62026-04-27
• Making sense of an old research folder42026-04-27
• Pod that restarts without an obvious error42026-04-23
• Salting pasta water properly152026-04-20
• A test is 99% accurate and I tested positive. Am I 99% likely62026-04-17
• Three days in Lisbon, walking distances42026-04-15
• Resting meat, real or mytharchived62026-04-14
• Learning an instrument as an adult62026-04-14
• Is clicking delete enough42026-04-11
• Our retries turned a blip into a full outage42026-04-10
• How do you decide what is worth archiving at allarchived22026-04-10
• Managed database or run it myself82026-04-09
• What actually matters for a small static site in search42026-04-08
• How do I answer the expected salary questionarchived62026-04-08
• Sourdough starter refuses to rise142026-04-04
• Greedy versus lazy quantifiers42026-04-03
• Cutting a team from twelve meetings a week42026-04-03
• What do I collect before deleting an account62026-04-01

March 17

• Finding what fills the diskarchived42026-03-31
• Sitemaps for a small site22026-03-28
• My service restarts in a loop and floods the journal42026-03-28
• Cache hit rate stuck at 40 percent162026-03-23
• Does rebasing actually help with two people62026-03-22
• First week with a new spoken language82026-03-19
• TLS handshake failures on an old client62026-03-17
• Two users need to write to the same folder without stepping on192026-03-14
• Backing up 2 TB of photos properly162026-03-14
• Returning to running after a break22026-03-12
• Are embeddings worth it for searching 5000 documents42026-03-12
• I keep hearing p-values are misused. What do they mean172026-03-08
• What is a sane rate limit design for a public API192026-03-05
• Colour that looks different on every screen82026-03-03
• Why my search index got 19 MB and how to keep it fast162026-03-02
• Watering that survives a heatwave62026-03-01
• Soil that dries out too fast62026-03-01

February 14

• A pattern hangs on certain inputs22026-02-28
• How do I explain recursion without factorials62026-02-23
• Buffer that does not get eaten82026-02-21
• When a static site stops being enough42026-02-20
• What is actually worth asking at the end152026-02-19
• Should scheduled jobs go through a queue62026-02-18
• Tests that fail only in CI62026-02-11
• SQLite has no date type. What do people store22026-02-10
• Is it realistic to start piano at 3562026-02-10
• Is 80% coverage a reasonable target22026-02-10
• What is the fastest way to check whether two directories match42026-02-07
• Practising without annoying neighbours62026-02-05
• Bar chart or stacked bar for survey responses62026-02-05
• Hashing passwords in 202662026-02-03

January 12

• Fonts that do not shift the layout62026-01-30
• Versioning an API without pain later42026-01-21
• Where do you start adding type hints to an existing project82026-01-19
• Booking flights without the games42026-01-16
• Is bit rot a real concern for a home library42026-01-15
• Deadlines that cannot move62026-01-13
• Big PRs sit for days. How do we fix that22026-01-11
• What a data export actually containsarchived62026-01-10
• WAL mode and concurrent readers62026-01-10
• Images that do not push content around62026-01-10
• How do I review without turning it into style comments22026-01-09
• Error handling without unwrap everywhere42026-01-05

2025

December 20

• Checksums for a photo library22025-12-30
• Backups for a self-hosted setup42025-12-30
• How much notice is reasonable when the handover is complex62025-12-29
• Culling thousands of photos quickly82025-12-25
• Emergency fund sizing42025-12-21
• Why my threads do not speed anything up62025-12-20
• Reverse proxy with automatic certificates192025-12-17
• Large responses hang while small ones work62025-12-17
• Logs, metrics or traces first22025-12-16
• Deadlock that only happens under load42025-12-13
• Async that is somehow slower82025-12-13
• What should an API error body contain22025-12-12
• Expected value of a repeated bet42025-12-10
• Does commit signing matter for a solo public project62025-12-09
• Can SQLite do decent full text search on a few hundred thousand152025-12-09
• Soft deletes that do not haunt you62025-12-07
• Leaving a job without burning it down82025-12-03
• Long-lived connections die after 60 seconds62025-12-02
• Commit messages that help later62025-12-02
• At what point does a static site need a backend62025-12-02

November 9

• Why does my page jump while images load42025-11-29
• Packing for a week in one bag22025-11-25
• The script runs fine in my shell and does nothing from cron62025-11-20
• Exporting everything from a service before leaving22025-11-20
• Monorepo or many repositories152025-11-14
• Why my compressed archive barely shrinks42025-11-04
• Is unknown really better than any22025-11-04
• Which edge cases deserve a test in a small project42025-11-01
• Images that do not push content around62025-11-01

October 13

• Discriminated unions for state42025-10-29
• How do you plan when the date is fixed42025-10-28
• Estimating work you have never done42025-10-28
• Reading a huge JSON file without loading it42025-10-25
• Adding a NOT NULL column locked our table for two minutes. How82025-10-25
• Do social tags affect search position82025-10-22
• Subscriptions that quietly accumulate42025-10-21
• Everything passes locally and CI fails at random62025-10-18
• How do I model loading and error states without booleans62025-10-16
• How do you estimate a task with unknown parts82025-10-14
• Making documentation people actually read62025-10-10
• Cardinality that kills the metrics bill62025-10-08
• Is cloning to satisfy the compiler bad practice22025-10-07

September 5

• One class is 3% of the data and oversampling barely helps152025-09-28
• Permissions for a shared directory42025-09-27
• Should the primary key be the email or a generated id82025-09-18
• Keeping a personal archive readable in ten years42025-09-16
• Regex that is slow on long input42025-09-04

August 12

• Which protocol for service to service calls22025-08-29
• Returning to running after a break62025-08-29
• Retrying a flaky commandarchived42025-08-27
• Timezones in timestamp columns22025-08-25
• How do I start running again after two years off42025-08-24
• Flashcards work for a while then stop. Why42025-08-23
• Signed commits, worth it or theatre62025-08-20
• Take-home tasks that respect timearchived62025-08-11
• Do I need ECC memory at home22025-08-06
• Same code, same data, different results on another machine42025-08-05
• Handover that survives the handover22025-08-05
• Waking at the same time every night22025-08-02

July 16

• Deleting an account properly42025-07-30
• Prefetching without wasting data62025-07-29
• Safe defaults for a shell script22025-07-27
• Class imbalance that resists resampling22025-07-27
• Our README is thorough and nobody reads it. Why62025-07-25
• Read replicas and stale reads62025-07-20
• Why validation loss goes up while training loss falls82025-07-17
• Copying millions of small files42025-07-15
• Is a monorepo worth it for four services42025-07-14
• Sampling traces without losing the bad ones42025-07-11
• Vacuuming a database that only grows62025-07-09
• Reproducibility across machines62025-07-05
• Keeping notes on technical books62025-07-03
• Why my threads do not speed anything up82025-07-02
• Counting rows without the full scan62025-07-02
• A comprehension building 2M items is slower than the equivalent22025-07-01

June 11

• Padding gets consumed immediately. Better approach82025-06-23
• Is shell=True ever acceptable62025-06-21
• Storing enum-like values42025-06-19
• Head sampling drops exactly the requests I want to see42025-06-19
• Zero percent financing or pay upfront42025-06-17
• Cardinality that kills the metrics bill42025-06-17
• Secrets that are not really secret62025-06-16
• Users see their own edits disappear after saving. Replica lag22025-06-13
• Errors clients can act on42025-06-10
• Our alerts fire constantly and everyone mutes them22025-06-07
• Dropping a CSS framework from a small site62025-06-06

May 9

• Matching nested structures172025-05-29
• How many months of expenses should be liquid82025-05-25
• How long should a random id be to avoid collisions42025-05-22
• Is ECC worth it for a home NAS42025-05-19
• CSRF when the API is token based42025-05-18
• What makes an error message good42025-05-15
• The index exists but EXPLAIN shows a sequential scan42025-05-11
• What a p-value actually tells you42025-05-08
• Len() disagrees with what users see as one character62025-05-02

April 2

• Full text search in SQLite without a server42025-04-17
• Explaining recursion to a beginner62025-04-03

March 11

• Comparing a loan against paying cash62025-03-30
• Bayes rule on a medical test22025-03-30
• Quiet mini PC for a bedroom42025-03-25
• Storing API keys in a desktop app42025-03-23
• One offer has more cash, the other more equity. How do I82025-03-22
• Migrations that lock the table42025-03-22
• Choosing a chart for a five point scale42025-03-22
• Unwrap is fine in examples but what do real programs do42025-03-21
• A six column table is unusable on mobile. Options42025-03-21
• The bug exists now and did not three months ago. Faster way42025-03-08
• Classic overfitting or something else62025-03-06

February 6

• Can I make progress with bodyweight only62025-02-25
• Estimating a migration honestly62025-02-14
• Requests and limits that actually work22025-02-13
• Typing an API response you do not control62025-02-11
• Keeping secrets out of a repository22025-02-08
• When to reach for clone62025-02-06

January 8

• I wake at 3am consistently and cannot fall back asleep82025-01-31
• Do I need WAL mode for a read-heavy SQLite database62025-01-30
• Papers lose me at the equations62025-01-27
• Tests that fail only in CI22025-01-24
• Requests and limits that actually work42025-01-20
• Dropping a CSS framework from a small site62025-01-09
• What is the minimum backup for a home server42025-01-07
• My desk wobbles at full height. Anything short of replacing it62025-01-05

2024

December 5

• Alerts nobody ignores22024-12-30
• Making documentation people actually read22024-12-18
• Rate limiting a public endpoint22024-12-13
• Performance drops after a couple of minutes of compiling82024-12-11
• Reproducibility across machines42024-12-02

November 3

• Path versioning or headers42024-11-25
• How do I transfer ownership of a service properly82024-11-11
• What should a new hire do in week one42024-11-02

October 8

• RAW or JPEG for casual shooting132024-10-30
• Modelling money without rounding errors62024-10-21
• I want to share part of my archive publicly132024-10-21
• Undoing a commit that is already pushed42024-10-20
• Is RAW worth the storage for holiday photos62024-10-20
• Storing timestamps in SQLite22024-10-19
• Float or integer for prices62024-10-04
• A 400 MB file is in the history. Removing it from HEAD did not62024-10-03

September 5

• Cron jobs that work by hand but not on schedule42024-09-29
• Two transactions deadlock occasionally in production42024-09-20
• My pan sauce breaks every time82024-09-12
• Database enum, lookup table or plain text42024-09-09
• Storing timestamps in SQLite172024-09-01

August 7

• Offset pagination skips rows when new ones arrive42024-08-21
• Our estimates are consistently half of reality172024-08-20
• Copying millions of small files62024-08-16
• Does an export include everything a service knows about mearchived42024-08-13
• Practising without annoying neighbours62024-08-11
• How often should I water tomatoes in 35 degree weather62024-08-07
• Dark mode without a flash of white82024-08-05

July 5

• We added a cache and p99 got worse62024-07-29
• Type hints on a codebase that has none42024-07-29
• First week with a new spoken language132024-07-27
• Expected value of a repeated bet42024-07-03
• Culling thousands of photos quickly82024-07-03

June 5

• Journalctl output is overwhelming during an incident62024-06-27
• Cold brew that is not bitter82024-06-17
• Our metrics cost exploded after adding a user id label82024-06-07
• Should I store user settings as JSONB or as real columns152024-06-02
• Requests hang for exactly five seconds sometimes42024-06-02

May 9

• When a static site stops being enough62024-05-25
• Is removing Bootstrap from a five page site worth the effort62024-05-25
• Discriminated unions for state62024-05-24
• Index bloat after a bulk delete62024-05-21
• What format survives a decade of neglect42024-05-18
• Cutting a team from twelve meetings a week42024-05-14
• Prefetching without wasting data42024-05-09
• Is prefetching links worth it on a content site62024-05-09
• Logging exceptions without noise42024-05-07

April 8

• How specific should except clauses be82024-04-29
• Is there a fast approximate count for a huge table22024-04-25
• A 300 MB JSON array does not fit comfortably in memory. Options42024-04-23
• Comparing a loan against paying cash62024-04-15
• Comparing two directories quickly42024-04-10
• What belongs in a changelog entry22024-04-09
• My pattern swallows the whole line192024-04-05
• Cron jobs that work by hand but not on schedule42024-04-01

March 12

• Sharing an archive without leaking42024-03-23
• I deleted 12M rows and the index is still the same size. Why62024-03-23
• Committing large files by accident42024-03-17
• What is the practical way to stop credentials landing in commits62024-03-15
• What should be at the top of every bash script132024-03-12
• Naps that help instead of hurtingarchived42024-03-07
• Long branch or a flag behind main42024-03-06
• What to read after a distributed systems book192024-03-05
• Rate limiting a public endpoint62024-03-05
• Are those price prediction tools worth anything62024-03-05
• Estimating work you have never done42024-03-04
• Rough numbers for what is fast and what is not82024-03-01

February 8

• Fonts that do not shift the layout152024-02-28
• Virtual environments and system packages152024-02-27
• Rsync of a directory with 2M small files takes forever62024-02-25
• Is an O(n log n) algorithm always better than O(n squared) here82024-02-20
• Waking at the same time every night132024-02-17
• Systemd service that restarts too eagerly82024-02-16
• Looping over filenames with spaces62024-02-09
• Mock the HTTP client or spin up a fake server152024-02-07

January 5

• Simplest way to get HTTPS in front of a few home services62024-01-14
• Making a status meeting unnecessary22024-01-13
• Signed commits, worth it or theatre42024-01-10
• Laptop that throttles under load42024-01-08
• When caching makes things slower22024-01-03

2023

December 14

• Laptop that throttles under load192023-12-30
• Which drive survives a write-heavy workload82023-12-26
• Where do I start when a script is slow and I have no idea why152023-12-25
• Strict mode on an existing project42023-12-21
• Are naps a good idea if I sleep badly at nightarchived42023-12-21
• A pod restarts every few minutes and the logs end normally62023-12-21
• Bcrypt, scrypt or argon2 for a new project42023-12-20
• Switching to dark theme flashes white on load. How do people192023-12-17
• Making a table readable on a phone42023-12-15
• Borrow checker fighting a simple loop132023-12-12
• How many users do I need for an A/B test42023-12-10
• Do I need CSRF protection if I use bearer tokens82023-12-09
• Small service, limited time. Which one first172023-12-06
• Handover that survives the handover42023-12-01

November 9

• Backups for a self-hosted setup62023-11-18
• Natural keys versus surrogate keys82023-11-14
• Naps that help instead of hurtingarchived42023-11-12
• Deadlock that only happens under load62023-11-11
• Reviewing code without nitpicking62023-11-10
• Rough expectation for compressing JSON logs62023-11-09
• An old device cannot connect since we tightened TLS42023-11-07
• Meal plan that survives a busy week22023-11-05
• I come back from a trip with 2000 photos and never sort them62023-11-03

October 9

• Keeping a connection alive through a proxy82023-10-28
• Cherry-pick without dragging half the branch22023-10-28
• Df says 96% full, du disagrees. What is going onarchived42023-10-26
• What makes a commit message useful six months on82023-10-25
• Pagination that survives inserts42023-10-24
• Vocabulary that sticks172023-10-13
• My SQLite file never shrinks after deletes42023-10-13
• How do I structure a file that is both a module and a CLI62023-10-07
• Leaving a job without burning it down42023-10-05

September 8

• How should I structure week one of learning a language42023-09-26
• How do I type JSON from an external API safely82023-09-25
• How often should a small project bump dependencies42023-09-24
• Error messages people can act on62023-09-19
• Sorting names in several languages62023-09-16
• Choosing between managed and self-hosted database22023-09-10
• any versus unknown42023-09-08
• Retries that make an outage worse42023-09-05

August 1

• The diff is in an area I do not know. What do I do82023-08-28