I don't know about you, but I'm tired of hearing about KISS (keep it simple, stupid).


Even Einstein said, "Things should be as simple as possible and no simpler."

Simplicity is a goal, a Zen concept. It is not possible to live in the real world while achieving absolute simplistic perfection. Humans and their creations have inherent limitations.

When I read articles that contain the word KISS, I think to myself, if only it was as easy as worshipping a four-letter acronym.

People who don't write code under duress can refactor all they want. The rest of us must publish or perish.

User interfaces and APIs are not made in ivory towers or in Word documents. I have never successfully designed either without prototyping them first. As I go through the implemention process I am more than willing to change the design. Nature has a word for this: evolution. Software evolves. It isn't decreed by some genius demi-god, Founder, Knighted Fellow, or VP of Engineering.

Frankly, complexity keeps the paychecks coming. If everything were as simple as others would like it to be, my job would have been shipped overseas a long time ago. This is one reason why I actively seek out complexity when looking for employment. C++ work usually guarantees a sufficient amount of complexity.

Yes, strive for simplicity. But please keep your arrogant world view to yourself. We morons are busy getting our complex dungpile to QA.

-- update ---

C APIs are usually a nightmare to use. C++ APIs can be much more elegant if designed for simplicity up front.

C APIs are complex because of resource management. A function returns a pointer which can not be simply deleted but instead must be freed via another function.

It's easy enough to make C++ wrappers or "smart pointers" to deal with this complexity. These days, I wonder why anyone would build a C interface. gcc supports C++ on every platform that matters today. I suppose it's for legacy projects that are still using some ancient C code base for which for one reason or another (usually laziness) hasn't been modernized for gcc.

Some purists discourage operator overloading in C++, but sometimes it makes code simpler, more elegant, and easier to read and write. One good example is Boost Spirit. I'm sure there are bad examples. Language features must be used only when the pros outweigh the cons.

One excellent example of simplicity in APIs can be found in the realm of XML parsers. Xerces C++ is huge and complex while XMLWrapp is small, simple, and usable. It's difficult to parse an XML document into a DOM with Xerces C++ and evaluating an XPATH expression against it can only be accomplished by masters of the craft. On the other hand, programmers can do both with XMLWrapp in about three lines of code. XMLWrapp's XPATH support uses clever and usable operator overloading for evaluating XPATH expressions.

XMLWrapp is easier to use than even the best Java-based parser because it started with the programmer and the code in mind. In contrast, the Xerces API is cluttered with all sorts of options and features that programmers might need but usually don't.

The goal of simplicity is simple: hide complexity. Make it obvious how to do the things that normal users need to do most of the time. Hide less-used features. Make sure there is a real need for "power features" before they are added.

Again, simplicity is a goal whose ultimate manifestation requires several iterations over a period of months or even years. Simplicity requires determination, discipline, and tireless commitment.

---

Permalink: tiki-view_blog_post.php?blogId=1&postId=157