Posts Tagged ‘Ward Cunningham’
Quote of the Day
I don’t claim to be a methodologist, but I act like one…to protect myself from crazy methodologists.
—Ward Cunningham, in a talk quoted at Geek Noise
Making it simple, keeping it complex
Simplicity is the shortest path to a solution.
The ideas need not be complex. Most ideas that are successful are ludicrously simple. Successful ideas generally have the appearance of simplicity because they seem inevitable.
When I begin, I usually improvise a melody and sing words—and often those words are just clichés. If it is an old songwriting cliché, most of the time I throw it away, but sometimes I keep it, because they’re nice to have. They’re familiar. They’re like a breather for the listener. You can stop wondering or thinking for a little while and just float along with the music.
The solution for me, surely, is neither in total renunciation of the world, nor in total acceptance of it. I must find a balance somewhere, or an alternating rhythm between these two extremes; a swinging of the pendulum between solitude and communion, between retreat and return.
It is important to emphasize the value of simplicity and elegance, for complexity has a way of compounding difficulties and as we have seen, creating mistakes. My definition of elegance is the achievement of a given functionality with a minimum of mechanism and a maximum of clarity.
Fools ignore complexity. Pragmatists suffer it. Some can avoid it. Geniuses remove it.
The nail doesn’t have to look like a house; it is not a house. It is a nail. If the house is going to stand, the nail must do the work of a nail. To do the work of a nail, it has to look like a nail.
Complexity must be grown from simple systems that already work.
While it might seem that richness suggests excess and maximal inclusion, we actually need to be selective about the elements we include, or the novel will not be rich so much as an incomprehensible blur, a smear of language. Think about the very real limitations of Pynchon as a novelist: many complain about his flat characters and slapstick humor, but without those elements to manage the text and simplify it, his already dangerously complex fiction would become unreadable.
Simplicity isn’t just a visual style. It’s not just minimalism or the absence of clutter. It involves digging through the depth of the complexity. To be truly simple, you have to go really deep. For example, to have no screws on something, you can end up having a product that is so convoluted and complex. The better way is to go deeper with simplicity, to understand everything about it and how it’s manufactured. You have to deeply understand the essence of a product in order to be able to get rid of the parts that are not essential.
A great impression of simplicity can only be achieved by great agony of body and spirit.
I would not give a fig for the simplicity this side of complexity. But I would give my life for the simplicity on the other side of complexity.
—Attributed to Oliver Wendell Holmes, Jr.
Where does the architecture come from?
Often, the program ends up amazing. You’ll say, “This is beautifully architected.” Well, where did that architecture come from?
In this case, architecture means the systematic way we deal with diverse requirements. Architecture allows us, when we go to do work we need to do on the program, to find where things go. It is a system that was worked into the program by all the little decisions we made—little decisions that were right, and little decisions that were wrong and corrected. In a sense we get the architecture without really trying. All the decisions in the context of the other decisions simply gel into an architecture.
“What’s the simplest thing that could possibly work?”
“Given what we’re trying to do now, what is the simplest thing that could possibly work?” In other words, let’s focus on the goal. The goal right now is to make this routine do this thing. Let’s not worry about what somebody reading the code tomorrow is going to think. Let’s not worry about whether it’s efficient. Let’s not even worry about whether it will work. Let’s just write the simplest thing that could possibly work.
Once we had written it, we could look at it. And we’d say, “Oh yeah, now we know what’s going on,” because the mere act of writing it organized our thoughts. Maybe it worked. Maybe it didn’t. Maybe we had to code some more. But we had been blocked from making progress, and now we weren’t. We had been thinking about too much at once, trying to achieve too complicated a goal, trying to code it too well. Maybe we had been trying to impress our friends with our knowledge of computer science, whatever. But we decided to try whatever is most simple…We would just write it and see it work. We knew that once it worked, we’d be in a better position to think of what we really wanted.
—Ward Cunningham, creator of the first wiki, to Artima Developer
Alec Nevala-Lee 