Software architects are a strange breed.
They obsess over code quality. They can’t explain anything without a whiteboard. They adore design patterns that most of us have never even heard of.
When the project is in trouble, they swoop in and save the day.
And they constantly reject my patches.
But I’m thankful for that â€” all of it. I’ve been fortunate enough to work with some really, really great architects in my (admittedly short) career, and through it all I’ve managed to distill the one skill possessed by every great architect I’ve ever met:
The ability to identify potential pitfalls.
Expecting something more dramatic? Well, tough luck. I know it’s not sexy, but if you want to be a great software architect someday, you need this skill.
Pitfalls are easy to spot when building a room.
The wife and I are currently finishing our basement. I’m learning a lot during this process, like how to make sure a wall is straight, and the joys of using a ramset.
And of course while I’m swinging that same old hammer into about the fiftieth 3″ nail, my mind starts to correlate what I’m learning about building a room to what I know about building software.
The biggest realization so far?
In simple construction, spotting potential problems is very easy.
If you line up a 2×4, you’re going to notice if it’s not the right size. Measure again, cut again. Problem solved.
If you have to extend some piping, it’s easy to grok the current pipe system and figure out where to make a cut. Plumbing refactored, job well done.
If you’re about to fire a nail through a plank of wood to affix it to the floor, it’s easy to visualize that you’ll have trouble cutting out a doorway there later. Nobody wants to hack through molten metal, so put those nails around where the door is going to be. Crisis averted.
In fact, it’s so trivial to see problems in advance that we’ve yet to make any major mistakes. This is amazing to me! Can you imagine saying anything like that about a software project? (Even a small one?)
Of course you can’t. And you already know why:
Pitfalls are nearly impossible to spot when building software.
How many times have you had to refactor some code you wrote last month, because it wasn’t up-to-snuff? Or had to completely re-write a feature that you implemented earlier in the project?
Seeing potential pitfalls in software is hard.
You would never build a cutting-edge webapp, then turn around and brag about how you got everything right on the first try. Your fellow developers would think you’re crazy, and your QA wouldn’t be able to stop laughing.
Every software developer makes mistakes all the time. Functions that aren’t quite single-purpose, dependencies that aren’t strictly necessary, routines that are a little too verbose. And we always end up paying for it later. Who will save us from this madness?
Architects, that’s who.
Great software architects mitigate rework and lost time by identifying pitfalls in advance.
They can look at a framework and tell you if it’s too abstract or not abstract enough. They can examine an existing codebase, and have a pretty good idea of where to start refactoring. They can tell when a new patch is going to break a valuable design pattern, or introduce inconsistencies into the codebase, or need to be re-written before the end of the next sprint.
This skill, this ability to look at some seemingly-harmless change and intrinsically know what problems it will cause later â€” it’s amazing. I don’t understand how they do it, and I don’t know if I’ll ever acquire that talent.
But I know it’s something I admire. And if you ever want to become a great software architect, this is the one thing you need to get right.
Now if you’ll excuse me, I have to go fix up my latest patch…