I like creating software solutions to solve problems. I am also a speaker, podcaster, and author on technology. I love htmx, server-side web dev, data, Web APIs, baseball and bourbon. .NET/Web Dev MVP
All of my posts are created using recycled electrons
| Website/Blog | https://woodruff.dev |
| GitHub | https://github.com/cwoodruff |
| https://www.linkedin.com/in/chriswoodruff/ |
Every abstraction in a codebase is a capital expenditure. Construction is paid once. Maintenance is paid every year the codebase exists.
For most abstractions, the break-even is three to ten uses. Most reach one or two. The investment never pays off.
Stranded assets. Paid for once. Maintained forever.
https://simplicityfirstphilosophy.substack.com/p/the-abstraction-budget
Was talking with folks from the EF Core team about common anti-patterns. I walked through offset pagination, Skip().Take(), and forgot to mention keyset pagination.
I should have. So I wrote the post I should have brought.
Skip().Take() isn't wrong, it's misapplied. On large or write-heavy tables, it's slow (OFFSET reads and discards every skipped row) AND silently skips or duplicates records under concurrent writes.
Keyset fixes both.
If you've built an ASP.NET Core API or list view backed by Entity Framework Core, you've almost certainly written something like this: var page = await _db.Orders .OrderBy(o => o.Id) .Skip((pageNumber - 1) * pageSize) .Take(pageSize) .ToListAsync(); It works. It matches the page-number UI most users expect. Every EF Core tutorial uses it. It's also
Every system has two layers that look like one. The technology layer (language, runtime, platform) is visible. The architecture layer (data model, ownership, failure modes) is invisible.
Most rewrites change the technology and preserve the architecture. The new codebase is faster for six months because it has no features. Then the same problems return in a new language.
Netscape proved this. So did most rewrites since.
#softwarearchitecture #softwaredesign
https://simplicityfirstphilosophy.substack.com/p/the-rewrite-trap-why-rebuilding-the
New live episode of Rust in Production and it's a special one! 🥁
Recorded on stage at Rust Week in Utrecht with two people shaping the future of the Linux kernel:
🐧 Greg Kroah-Hartman (@gregkh ), Linux Foundation Fellow
⚙️ Alice Ryhl, core maintainer of Tokio, Rust for Linux at Google
▶️ https://corrode.dev/podcast/s06e04-rust4linux/
Huge thanks to the Rust Week crew for hosting this one. You're awesome! 🦀
I will be on the .NET Data Community Standup in about 30 minutes. You can watch here https://www.youtube.com/watch?v=jlR6KFuFODI
I will be discussing 8 Real-World EF Core Query Anti‑Patterns (and How to Fix Them). I might even drop in a bonus EF Core nugget if there is enough time.
Every dependency on your stack carries a Total Cost of Ownership with five components: acquisition, integration, maintenance, lock-in, exit. The accounting system tracks the first one. It partially tracks the second. It completely ignores the last three.
Acquisition is the smallest cost. Maintenance is the largest. Lock-in compounds yearly. Exit cost arrives as an emergency the moment the vendor changes terms.
The cloud bill is 20% of what your system actually costs.
https://simplicityfirstphilosophy.substack.com/p/the-dependency-audit
I was a guest on a new episode of The Modern .NET Show.
Topic: Why complexity is not sophistication — and what it's costing your team.
We covered the Architecture Tax, the 2 AM Test, the Half-Rule, and why most over-engineered systems are a product of broken incentives, not bad engineers.
Give it a listen:
https://dotnetcore.show/season-8/simplicity-first-why-complexity-is-not-sophistication-with-chris-woodruff/
Chris Woodruff joins Jamie to argue that simplicity, not complexity, is the true mark of sophisticated software architecture, sharing his three filters: the half rule, the 2 a.m. test, and primary path first — drawn from 30+ years building .NET systems.
Microsoft ousts Israel country manager over mass surveillance system targeting Palestinians
Knuth's most-cited sentence: "Premature optimization is the root of all evil." His full passage tells engineers to measure first. The popular version cuts that part out.
Fifty years later, teams build Redis clusters for problems a database index would solve. Nobody measured the system before approving the proposal.
The forcing question: what specific, measurable condition would justify this?
#SoftwareArchitecture #SystemDesign #Engineering #Performance
Matthias Endler
Robert Reich
vejeta ☑️
