Obviously ReuseRequiresUnderstanding. But it doesn't necessarily require understanding very much. There are a hundred thousand people who have build software that uses Amazon as a web service, and I bet most of them have only a superficial understanding of what is going on inside Amazon.
Amazon works very hard to have a simple interface. One of the keys to making software reusable is to keep its interface simple. The software doesn't have to be simple as long as it has a simple interface.
UnderstandingULS said that it is easier to reuse small pieces of software. But it is more valuable to reuse large pieces of software. Software is more likely to be reused when it is valuable. The trick is to hide your powerful software behind a simple interface that is exactly what your customers need.
In general, I think that trying to make units of reuse smaller is the wrong way to go. There are two opposing forces; make the interface to software simpler and make it do more. Sometimes by making it do more, you can make it simpler, because you can remove the need to specify options. Even if you can't make it simpler, if you can make it do twice as much without making it any more complex, it might be a win. Of course, your clients might not need the extra functionality, in which case it isn't really bettr for them. But just trying to make software smaller is not likely to lead to making it more reusable.
To make a company profitable, you need to increase income and reduce expenses. People who focus on reducing expenses can miss big opportunities. Companies need new ideas and new markets if they are going to raise profits. Obviously you can't let expenses get out of control, but an overemphasis on reducing expenses can stifle creativity.
In the same way, to make software reusable, you need to increase power and decrease complexitiy. An overemphasis on reducing complexity can prevent new features and potential simplifications by bundling a lot of pieces together into one unified system.
I entirely agree. I also think that trying to make units of reuse smaller is the wrong way to go, and I don't advocate that.
The more valuable a unit of software and the simpler to reuse, the better. Scale, understandability, value and simplicity usually conflicts, and balancing them can be challenging.
ULS increase this challenge, that's my point.