In his keynote speech on Oopsla 1997 (see link below) Alan Kay talked about the primary need for software development to deal with scalability.
We develop tools for making models (and software) that are very suitable to build dog houses. The misconception is that building larger structures (scaling up) entails nothing more than scaling up the dog house 100 times. Et voilá: we have created a cathedral!
Engineers know that scaling up a physical structure 100 times, means a mass that is 300,000,000 times greater, while its internal structure and integrity only scales up 30,000 times. This means that the new construction will be 300 times weaker than the original dog house. The result is not what we envisioned, a cathedral, but more probably something like a pyramid: the structure will collapse under its own weight.
Here 
Software structures have, contrary to physical building structures, to deal with many more forces which makes the differences in scale even greater!
The reason object-orientation works has to do with the same “trick” Buckminster Fuller used: create the most extreme possible internal division of forces (cohesion).
An object-oriented structure is in fact one that is made out of numerous elements, each of which as small and simple as possible, and with as few dependencies as possible with other elements (coupling). As can be evidently derived from this principle using an object-oriented programming language or modelling language gives no guarantee whatsoever that you are using these scalability principles. It is still possible to specify complex elements, and/or elements with many dependencies (coupling). When that is the case, you cannot take advantage of the power of object-orientation, especially regarding scalability.
A good OO model is perhaps very simply: any model that consists of a large number of very small elements with minimal dependencies.
Alan Kay’s keynote on Oopsla 1997. I was there to take home much inspiration (and was even able to grab the opportunity to talk with him 🙂 ):
