Programs written in an Object Oriented model of computation are comprised entirely of objects, and computations are expressed solely as messages sent from one object to another. Given a reflective environment, and an object, any user may ask the system what kind of computations they can perform with that object. Smalltalk environments are entirely based on this, and they try very hard to make the experience feel like working directly with live objects, rather than descriptions of programs. You manipulate actual entities, you ask those entities to do work, directly. Writing code at all in Smalltalk is a very accidental thing, and a very different experience from writing code in any other environment too — you can see the changes right away, there's no such a thing as "writing a program" and "running a program", they're one and the same.
Discoverability is a very important issue, because in order to make a system do any work at all, a programmer must first know what they can do with the system. Reflective OOP
environments, such as those used in Smalltalk, try to solve this problem at the very core of their programming experience, from the programming language and model itself, to the environment in which you interact with them.
OOP is powerful enough to express what needs to be expressed in practice and simple enough so that many programmers can do this in a consistent way. It is also simple enough for compilers to do their job well and produce fast binaries (at least after 30 years of robust compiler R&D). Some OOP languages come with extensive domain-specific libraries (Java, PERL, Python) which allow programmers to think in domain-specific terms. C++11 supports typed numerical quantities, e.g., you can multiply meters/second^2 by seconds and get meters/second --- very handy to avoid mistakes in kinematics applications.