Software Engineering
144 articles · all categories
Software Engineering articles
22 articles from 2023 · show all
December 2023
Keeping a high engineering culture, tips from the field
I asked engineers how they keep a high quality culture. These are the takeaways
November 2023
The efficacy of TypeScript
TypeScript may streamline code navigation and catch semantic errors, but it doesn't guarantee fewer bugs or faster fixes.
Don't neglect your upgrades
Regular software updates may seem tedious, but they save you from the nightmare of a massive overhaul down the line.
October 2023
Solve the problem, not a different more difficult problem
Solve the problem at hand, not the one you imagine might come next. A simple fix now often beats a complex one later.
August 2023
Avoid spooky action at a distance
Shared state in programming isn't the enemy, it's unclear dependencies that tangle your code. Keep it clean with explicit state dependencies and strict access guidelines
Finding modules in a Big Ball of Mud with ChatGPT
Detangling a Big Ball of Mud is hard. You have to find domain boundaries where none exist. Looks like AI can help 🤩
Followup answers to Forget complicated code, focus on the system
Why are utility files bad? How do you recognize architectural complexity? What the hell is a transitive dependency?
Forget complicated code, focus on the system
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.
July 2023
What I learned from Team Topologies
You can't escape Conway's Law. Might as well use it for good.
Different worlds
Different lenses, different worlds. Your perspective is shaped by your experiences. Even in debates, all sides can be right in their own context.
You can't stop the business, or why rewrites fail
Rewriting code isn't a magic fix-all. Consider the opportunity cost, complexity of the old system, and estimation challenges. Instead of stopping all to rewrite or building new while maintaining the old, try incremental improvements and new code adoption.
June 2023
When to throw away your code
Delete code when it stops providing value 💡 All code is a liability; context matters. Keep what solves problems, toss the rest.
What does "solve problems" even mean
Focus on solving problems, not just doing work or writing code. Think creatively, question existing processes, and prioritize effective outcomes
Why taming architectural complexity is paramount
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.
May 2023
Two types of complexity and their impact
Complicated code slows down junior devs, while complex systems impact senior devs more. Focus on managing system complexity & dependencies, not just simplifying code.
You can't fix the wrong abstraction
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.
April 2023
A backend service nobody can grok
a little case study from an upcoming book I'm writing with Manning about software rewrites
Own the outcome, not the work
Efficient problem-solving in engineering with a shift in perspective – focusing on user outcomes can lead to innovative solutions and change your approach to system design.
DRY vs SoC, a difficult choice
What is the essential difference between DRY and SoC principles in software engineering and how do you balance the two
March 2023
Clever technical hackery can't solve the wrong design
A simple change in perspective can help you overcome complex technical challenges and save time on future projects.
January 2023
Squash merge? Really!?
Learn why squash merging is your friend - from hating it to loving it! Squash merging helps you keep moving and focus on the work instead of recording the work.
Why trunk-based development is best
Merging finished work straight to main and deploying to production right away, scales to teams of thousands. This approach is counterintuitive to many engineers who may be used to working on their own