This is going to be pretty abstract, so bear with me
At the architecture level, complexity is defined as the interconnectedness of things. Things can be functions, modules, classes, whatever. A connection between them is a dependency of some kind -- call, communication protocol, common file format, etc.
The goal of a good design is to reduce the interconnectedness of things as much as possible. I think a lot of people lose sight of this and try instead to create something that looks simple on the outside but is nightmarishly complex on the inside. This is called "simplexity".
Although I can't directly relate it to OS design, I've seen this before in typical OO designs. People who understand the "letter" but not the "spirit" of OOD will look at the requirements, create a class for every noun, and proceed to absorb huge amounts of responsibility into each class. This ultimately leads to all kinds of crazy dependencies between classes. Sure, on the face of it, a system with only 20 classes seems simpler than one with 200, but verifying the correctness of any of those 20 will be more than 10 times harder than doing the same for one of the 200.
I'm not sure I believe in the dichotomy of "simple internally, complex externally" and vice-versa. I think a well-design system's interface reflects its internals while leaving out crucial details. In other words, you can simplify through abstraction, but not to the point where you are re-defining the problem you have to solve. That's when you get leaky abstractions. A good system will usually be quite complex when you look at the most fine grain of detail, but it will not be needlessly complex (like COM, Corba, or EJBs... yuck!)
Perhaps not surprisingly, all these attitudes make me a fan of microkernels, while simultaneously making me uncomfortable with how paging I/O is typically implemented in microkernels.
It's always felt like an abstraction inversion to me...
Quote:
no, my friends, I think there are plenty of simplicity options not yet implemented, like stop redefining standars every couple of years.
I'm sorry to say you're dreaming. Technical sensibility is rarely involved in the development of standards. A lot of them are pushed by vendors with an agenda (*cough* M$ *cough*) and don't necessarily work very well. Unless you plan to overthrow capitalism, I suspect these sorts of shenanigans will keep happening. I think this is why I've become less interested in studying commercially available technologies and more interested in OS and programming language research in recent years.