Abstract :
Summary form only given. Complexity is the enemy of dependability. The author notes that if one wants to build systems that are safe and reliable, we know that we should make them as simple as possible. Unfortunately, not all complexity is the result of poor design. Sometimes complexity is necessary. In such circumstances simplicity may not be achievable. How, then, do we make our systems dependable? It is argued that one way forward is through the use of diversity. The best-known applications of diversity in computing date back a couple of decades and involve design diversity, e.g. n-version programming. This kind of diversity, in the pursuit of fault tolerance, has had a checkered history. On the one hand, several famous experiments have shown that the benefits fall far short of what might be expected if the different versions were to fail independently. On the other hand, several serious industrial applications seem to have worked well. The major thesis of this talk, though, is that diversity is ubiquitous. In particular, the author will argue that diversity appears to be ´a good thing´ not only for fault-tolerant system design but in other areas of software engineering. An example is the use of diverse methods to seek faults in software. Another is in diverse arguments ?? e.g. He then will try to show that the formalism developed for design diversity will work in these wider contexts. Some of the results are intuitively plausible, some of them are rather surprising and non-intuitive. Altogether, it seems that this is another area of computer science where mathematical formality can bring better understanding and, ultimately, better control over the attributes of the systems we build.
