The trick, then, is to keep related code close together to reduce context boundaries and to limit the amount of relevant detail so it fits in your working memory.

Turn your unwieldy Flask codebase into manageable, composable fragments with this UI pattern. Very close to HTMX.

Hardcoding logic when you're tight on time doesn't need to make a mess. You can build the abstraction first!

Here's an approach to writing code that I've been using for years and couldn't quite put into words until now. One of those _"This feels wrong but I can't explain why"_. Now I can!

Few of your engineering decisions matter long-term. Software is soft. You can change your mind. But how you structure your components is here to stay.

As long as it works, right?

Pulling modules out of a big ball of mud is like grabbing a slice of cheesy pizza. It's kinda separate but also not really.

Forget Gang of Four, here are the 7 architectural patterns real programmers use:

Swizec reveals the hidden pitfalls of overusing the DRY principle in coding, leading to bad abstractions. Discover how to write adaptable, efficient code that avoids these common traps.

Here's a trap that talented engineers fall into all the time. It creates frustration, burnout, and the genre of tweets that read like "Why don't people care about the amazing work I'm doing".

You can classify software projects into 4 quadrants from trivial to complex

You're doing too much. Sit back, relax, see how people *want* to use the code. THEN build the abstraction.

TypeScript may streamline code navigation and catch semantic errors, but it doesn't guarantee fewer bugs or faster fixes.

Solve the problem at hand, not the one you imagine might come next. A simple fix now often beats a complex one later.

Detangling a Big Ball of Mud is hard. You have to find domain boundaries where none exist. Looks like AI can help 🤩

Why are utility files bad? How do you recognize architectural complexity? What the hell is a transitive dependency?

Clean code matters, but it's the architectural complexity that truly impacts your productivity and bug count. Focus on simplifying the system, not just the code.

Unravel the hidden costs of architectural complexity in software engineering and learn practical strategies to tackle it. Boost productivity, reduce defects, and improve staff retention with insights from an MIT PhD thesis.

Complicated code slows down junior devs, while complex systems impact senior devs more. Focus on managing system complexity & dependencies, not just simplifying code.

Unlock the secrets to combating architectural complexity in software development and learn to identify and fix the wrong abstraction. Boost productivity, reduce bugs, and retain more staff.

Wherein I use a silly example to show why you need more than small reusable single purpose functions to write good software.