Techno-Babble

Simplicity vs Complexity: A False Dichotomy

Let me just say that while I believe in the pursuit of simplicity, the aversion to complexity is immature and self-destructive.  I’m tired of MDA and no-code solutions.  Does anyone believe in that degree of simplicity anymore?  I don’t think they do.

There is definitely a growing trend towards simplicity that is, at its core, a very good thing.  I’d call the good form “making  simplicity a major design goal”.  However, when people live in stubborn denial of complexity, they are hurting themselves.  This goes for technical design and implementation as well as for perhaps every other aspect of life.

The interesting thing about having simplicity as a design goal is that it carries within it an implicit commitment to grapple with complexity.  To say that simplicity is your goal is to say “I am so committed to creating something that is ultimately simple, that I am willing to deal with the fullness of the complexity of the problem in order to reduce it to a simple solution”.  Thus you have people designing things like Ruby on Rails, DI containers, the Piccolo toolkit, etc, which are far from simple in their design and implementation, in order to make their consumption simple.

I feel that there is an increasing stratification among developers and that the issue of complexity is one of the major dividers.  I believe this aversion to complexity is the reason that WPF, which is incredibly sophisticated, innovative, and even in many ways simple, just different, is not being adopted, nor is it being cloned by other platforms (but I believe it’s day will come.  More on WPF later).

But then again, community sentiment about “great” or “inescapable” concepts can override this in some cases.  Closures, for example, are not that simple, but they look simple, and they’re really neato.  So you have a bunch of people getting into closures and inadvertently getting sucked into more complexity than they expected, but they deal with it just fine.  Relational Databases aren’t simple, but they’re just a fact of life.  Parallel programming is another complex “fact” that people will ultimately just need to deal with.

I say all this because I’m tired of people using mild complexity as an excuse not to investigate or adopt a particular technology.  Tying this back to my WebForms rants, it is a shame when good developers who can definitely handle complexity abandon WebForms citing its complexity as one of their justifications.  Similarly, the hypocrisy of people who refuse to look at NHibernate but get excited about the Entity Framework is kind of ridiculous.  The list goes on - Castle / Spring, WPF, object databases, parallel programming.  When will we realize that with any innovation, a bit of complexity must usually come before simplicity?

Tags: Philosophy