Pankaj Kumar's Weblog

On face of it, the statement that felxibility results in complexity is almost an expression of commonsense -- similar to the assertion that more secure systems are less usable. Afterall, any activity undertaken to make a system more flexible, such as, adding more options, supporting additional configurations, introducing hooks for extensibility etc., will inevitably introduce complexity.

But, is it really true that more secure systems less usable? An obvious justification would be that if it was not so, then why would companies (like MS)sacrifice security in favour of ease of use. Or, is the real truth, like most things in life, less clear? Constantin Rozinov's paper Are Usability and Security two opposing directions in computer systems [PDF] examines this question with a number of real life examples and comes to the conclusion that it is possible to grow security and usability of a system at the same time. It requires more forethought and a different approach to design and construction (than adding security to an existing insecure system), but is doable.

So, when this issue of designing more flexible systems without introducing additional complexity came up during one of our team meetings, I started thinking about examples and counter-examples.

Here are some of the supporting ones I came up with:

1. A general purpose computer (say, a PC) versus a specialized device (say, a TV set): A PC, capable of doing many different kinds of tasks, is undoubtedly more flexible and complex than a TV, which can be used for a fairly limited set of activities.


2. Perl versus JavaScript: I don't have to argue that Perl is flexible. With Perl, you can do almost anything that you can do in C (though you may not like to!). However, the price of the power is signficant complexity. It is not unheard of, even for expert Perl programmers, that understanding even your own code could be hard. In compariosn, JavaScript, another scripting language, is much simpler. Of course, it does limit you in what you can do with it!
3. Unix versus DOS: This comparison may not make sense in year 2004 but go back into the past by 10 years and then compare these two dominant Operating Systems. Unix was (is) very flexible (and complex) compared to DOS.


4. Emacs versus vi: I have never used Emacs myself but based on whatever I have heard and read, it is a safe bet to say that the former is much more flexible than the later. It also is much more complex, at least to someone who doesn't know either of these editing environments.

Do these examples conclusively determine that flexible systems are always more comlex? Well, examples can never be proofs, but they do throw some light on potential linkage.

I also tried to come up with some counter-examples and was pleasantly surprized to come up with an equal number of those:

1. Command shell versus GUI: A command shell may be more difficult to learn and use (than a GUI), but as far as the internal complexity is concerned, there cannot be any doubt that the former is much simpler. At the same time, it lets you do things that simply may not be possible with a GUI.
2. XML versus ASN.1: With so many XML related specifications coming out almost every day, it may be hard to say that XML is simple. But then, most of these are languages making use of XML and are proof of the fact that XML is flexible. ASN.1, in contrast, never found applicability outside a limited domain consisting of SNMP, PKCS, RPC, CORBA and so on. Those who have worked with both these technolgoies to specify information schema and formatting, would agree that ASN.1 is much more complex to learn, use, implement and debug.


3. HTTP versus FTP: Now, some people may argue that it is not fair to compare HTTP with FTP, but if you look at their guts, these two protocols are not all that different in their intent -- both allow exchange of data, both run on top of TCP/IP, both require two ends to be active at the same time, both have very similar primitives and so on. Still, HTTP is much simpler and flexible than FTP.


4. Internet versus POTS (Plain Old Telephone Systems): My last example is the most telling one: Intenet, the global network of millions of computers connected together using open protocols, does things (like moving information from one point to another) which are very simlar to what POTS, a complex switching and communication systems built on many proprietary technologies, does. Still, the Internet is infinitely more flexible than POTS.

An interesting aspect of these counter-examples, with the exception of Command Shell and GUI, is that the simpler and more flexible system grew to solve newer problems and at times, out of frustration with the existing and inflexible system. This didn't happen as a result of minor tinkering or addition of newer capabilities into the existing system. The simpler and more flexible systems were designed from ground up, using entirely different principles. And may be, herein, lies the lesson: if your goal is to increase flexibility without introducing additional complexity, then look at a different way to solve the same problem!