Perhaps the overall complexity of the flexible solution is bigger, but it is quite usuall that it means shifting the complexity to some other place and make the code simple. Once more a good example of this is templating where you don't hardcode the interface design in your program but rather leave it to some other mechanism. For complex sites your program stays much simpler that when you hardcode page generation in it.

Sometimes I wonder how software ever even makes it past a client without being evaluated to see if it works. I've seen plenty of time and money spent on programs that don't work.

I say, if you don't have something simple that works, then you definitely won't have something flexible/complicated that works. I've seen plenty of flexible programs that haven't worked all because somebody worried about the chrome before the engine.

Just an opinion from a guy who's had his share of deadlines.

smiles

PS If flexibility is so darned important, then I think no one would write one-liners.

In fact it seems that very flexible code is often also very simple. This is particularly common when flexibility has been achieved by a modular plug-in architecture, and new features have been added through plug-ins rather than through complicating the core design. (There are, of course, significant overheads in resource usage with this approach.)

Well, I think that proves my point. Surely code that doesn't have a plug-in architecture is less complex than code that doesn't have the additional code to deal with plug-ins. But it's also less flexible.

Abigail

A core with hooks for plug-ins, and then a few plug-ins that come standard often is less complex than monolithic code which provides natively the flexibility in those plug-ins. This goes double if the monolithic code attempts to add functionality to compensate partway for what in the other architecture can be safely left to optional plug-ins available elsewhere if you care.

The overall complexity might be bigger. But I would argue that the overall complexity is not the most important factor in understading the system. The important factor is something that I would call the 'complexity of the viewing window' - that is how much complexity there is in each whole 'view' of the system. This is quite vague thought - but I'll try to explain it.

With good plugin architecture you can partage the whole code into isolated parts with low complexity, you can view each part with a low 'complexity of the viewing window'. What is more you can view the whole system with a low 'complexity of the viewing window' too - since you don't need to know all the details of how those plugins are coded - you just need to know how they are assembled.