When an English speaker is drowning in details that make the big picture hard to see, she might complain, “I can’t see the forest for the trees.”
image credit: Miguel Virkkunen Carvalho (Flickr)
It’s an odd expression, partly ironic and partly humorous. When I hear it, I sometimes think of my sister, who, after moving from Indiana to Utah, complained that the mountains were getting in the way of her view. (Her tongue was firmly in her cheek… :-)
The expression also describes an important problem of software engineering–one that a lot of engineers don’t understand well enough. It’s a problem with generalization.
How do you make things simple?
I’ve written that simplicity is powerful, and that it undergirds many deep architectural breakthroughs. In posts about pragmatism and balance, I’ve quoted Oliver Wendell Holmes about the simplicity on the other side of complexity.
But I’ve never talked about how to achieve it.
photo credit: hurley gurley (Flickr)
This is not an easy question; if we knew how to make things simple, we’d do it more often and more quickly. It takes some serious effort (and genius) to go from centuries of experiments and volumes of equations to
e = mc2. I’ve been pondering simplicity in software architecture for a decade, and I’m certain I’ve only scratched the surface.
Still, simplicity is a learnable skill, and some strategies are consistently helpful… Continue reading
Most stories about zen masters, gurus, or other paragons of wisdom follow a similar pattern. The pupil discovers a problem. He or she struggles with it. The problem gets more and more overwhelming. Solutions are elusive. Finally the pupil goes to the master and pours out his heart, whereupon the master offers a pearl of insight that radically reinterprets the problem.
Seek the simple… Photo credit: departing(YYZ) (Flickr)
There’s a reason why this narrative exists in every culture: human beings need the insight that comes from synthesis, pared down to its essence. We crave the simple but profound:
- Less is more.
- Do unto others as you’d have others do unto you.
- A watched pot never boils.
- Freedom isn’t free.
The software industry desperately needs this sort of insight, but far too often I see us operate in the stage of the narrative where the pupil misunderstands the problem, struggles, and makes things worse. Continue reading
Last week I heard a Stanford researcher describe how failure can be a good thing, if we are prepared to learn from it.
I agree, although this mindset is easier to describe than to achieve. So here I’m kicking off a new series of posts about mistakes I’ve made over the years, and what I’ve learned from them. Look in the “Mistakes” category for more like this.
If you’ve followed my blog at all, you’ll know that I regularly return to the theme of what constitutes good code. Ever wonder why I don’t get more ambitious and talk about “great code” instead?
A big reason is that in software, great can be the enemy of good.
If you’re a fan of aphorisms, you’ve probably heard the opposite statement a few times: “good is the enemy of great.” People who say this are emphasizing the value of setting lofty goals, and then aligning our day-to-day lives to deeply held priorities. They remind us that settling for mediocrity is almost guaranteed not to create deep meaning or purpose. And they are quite right.
However, I submit that the greatness you should be pursuing in software is less about producing great code, and more about becoming a great producer of code. And great producers of code know that most of their creations will not optimize business value if they aim for a magnum opus. Not every commission can be the Sistine Chapel.
Detail from the Sistine Chapel, by Michaelangelo. Image credit: Wikimedia Commons.
Don’t get me wrong. I care about the quality and artistry of code, and there is definitely great code out there. It’s just that I’ve got these battle scars…
Daniel builds a tower
In 2001, I helped design and code Continue reading
In my first post about what constitutes “good code,” I claimed we were dealing with a complex question. This is why I distrust short answers.
So many competing concerns must be balanced to achieve goodness:
- Short-term revenue pressures
- Long-term strategic value
- Performance (many aspects)
- Scalability (up, down, across)
- Ease of use
- Conceptual integrity
- Alignment with the skills, temperament, interests, and tools of the team that owns it
- Cost vs. benefit (for some problems, quick and dirty is definitely “right”)
- Simplicity (separation of concerns)
More items undoubtedly belong on the list. Quite a balancing act!
Someone’s got this “balance” thing down! Photo credit: joãokẽdal (Flickr).
Pick a module, application, or subsystem that you know well, and grade its code according to how much its coders emphasize a few different dimensions (e.g., performance, testability, scalability, ease of use). Do you like the balance? Are any attributes being neglected?