One idea i think about on occasion is whether something is lost when one componentizes or modularizes software. We are taught abstraction as religion, mostly for the benefit of the human mind--as a compromise with our finite brain power (globbing and the whole 6-8 things at once thing). Because people make fewer mistakes when the cognitive load of a task is decreased, abstraction leads to better software.

But i think it also leads to more limited software (from the developer's perspective). Limited not with respect to computation, but with respect to malleability and ease of adaptation. Basically, this is the same lesson that the end-to-end argument and worse is better convey.

The larger and more granular an interface is and the larger the policy which it enforces, the more brittle it will become.

But large policies encode complex semantics and with them power, at least, iff that policy is the exact one for the case at hand.

Certainly, we cannot abandon abstraction as long as people write software (and it is likely to continue to be written by people for awhile, especially when creativity is required). I have a number of ideas as i'm sure quite a few people do.

(recently, i was writing a medium sized software framework which had so far been quite nice and modular and did everything i needed it to do. but suddenly i wanted one small piece of information in a place where it was not available due to the particular set of abstractions that were chosen. so in order to fix this, i'm going to have to cruelly hack up things to get that bit of information from the internal place it is, to the other part. the brittleness invited cruft.

this is certainly fixable, the problem is more that it's a giant pain in the ass. it is also preventable, had i known that i'd need to prevent it. unfortunately to always prevent these situations, you need infinite look ahead. since this isn't likely, there needs to be a better mechanism. the world is dynamic and software requirements change. what is perfect for today may be dead wrong tomorrow.

(maybe adaptive intefaces would be good). (we need to get to the point where we can say the Word and the universe will work out the implementation details and test the implementation.) )