All posts
When a REST API Is Slow — the Order for Finding the Bottleneck
Finding API bottlenecks by procedure instead of instinct: instrumenting to split the request into segments, the four usual suspects (database, serialization, external calls, N+1), the priority order of fixes like caching and pagination, and why p99 matters more than p50.
GitHub Foundations #10 Bonus — Full-Scale Practice Exam (50 Questions with Explanations)
The final post of the GitHub Foundations series. Work through 50 questions distributed across the seven exam domains, with the answer and explanation available on every question. If you score 38 or more (76%), consider yourself ready to book the exam.
RI vs Savings Plans: Choosing an AWS Commitment Discount
A working standard for choosing between Reserved Instances and Savings Plans: the structural difference between matching instance attributes and committing to an hourly spend, the flexibility split behind the identical 72% maximum discount, the services Savings Plans cannot cover (RDS and friends), capacity reservation as a separate problem, and how to size a commitment against the stable floor of your bill.
Wails in Practice #10 Finishing Touches — Settings, Dark Mode, Data Backup
The final post of the series. Features are all there, but we fill in the touches that make the app worth reopening. Covers a structure for saving and loading settings, dark mode that follows the system, remembering window state, backup/export/import that keeps user data safe, and a recap of the principles running through all ten posts.
What Load Average Actually Is — and How It Differs from CPU Usage
Reading the most misread metric in Linux correctly: the definition (running + runnable + disk-wait D-state tasks), judging against core count, the four classic ways it diverges from CPU usage, and reading the 1/5/15-minute triple as a trend.
Does fork Really Copy Memory? — Copy-on-Write in Practice
Why fork duplicates an entire process yet finishes in milliseconds: copy-on-write at the page-table level. The copy-only-when-written mechanism, why fork+exec is nearly free, real cases like Redis snapshots and pre-fork servers, and why memory accounting and overcommit get confusing.
EFS vs EBS vs S3: Choosing AWS Storage
A working standard for choosing among the three AWS storage services: the access-model difference between block, file, and object storage, unit prices that spread from $0.023 to $0.30 per GB and the provisioned-versus-usage billing split behind them, hidden costs like EFS throughput charges, the common overengineering of using EFS without a sharing requirement, and a selection order driven by access patterns.
GitHub Foundations #9 Domain 7: The GitHub Community + Exam Tips
Open source versus source-available, InnerSource, and community features like Sponsors and Marketplace, followed by question-type strategies, commonly missed patterns, and a test-environment checklist to finish your preparation.
Wails in Practice #9 Implementing Auto-Update — Delivering a New Version Safely
Actually implement the auto-update that #6 only discussed as strategy. Covers stamping a version into the app and querying the latest from GitHub Releases, a safe notify-style implementation, why fully automatic replacement is risky and what it must uphold, and a version flow that does not clash with signing and CI.
GitHub Foundations #8 Domain 6: Privacy, Security, and Administration — Permissions, 2FA, and Dependabot
The five repository roles, the Organization permission model, 2FA and PAT authentication, branch protection, and the boundaries between Dependabot, secret scanning, and code scanning. This post covers Domain 6 of GitHub Foundations.
Processes vs. Threads — Everything Follows from Shared Memory
The process/thread difference unpacked from one criterion: whether memory is shared. The isolation-versus-sharing tradeoff, context switch costs, crash blast radius, and what nginx, browsers, Java, and Python (GIL) each chose — in practical terms.
SQS vs SNS vs EventBridge: Choosing a Messaging Service
A working standard for choosing among the three AWS messaging services: the model difference between a queue, pub/sub, and an event bus, where retention and retries exist and where they do not, pricing that spreads from $0.40 to $1.00 per million with 64KB-chunk billing, combination patterns like SNS-to-SQS fan-out, and the traps of EventBridge latency and FIFO throughput limits.