I think the kind of message-centric OO that Alan Kay was talking about was very different from what we see in practice today.
Likewise, if you read "The Art of Meta-object Protocol" there are some deep insights about the configurability and power you get whan you have pre and post hooks into everything in the system. MOP systems are very powerful.
It is also nice to have the implicit "this," "self" or "message recipient" that you don't have to pass around all the time into the same family of functions (methods.)
The kind of typical "enterprise java" code that you see in the wild is what I call "class-oriented programming" - using classes as containers for procedural code. This is at the extreme end of crappiness for the imperative world.
If you go back to the initial spirit of OO, and combine that together with techniques like constructor injection with good citizenship, lots of immutable value objects, and polymorphic strategies, you get a style of OO that is more friendly with FP. It still isn't that delightful in verbose languages like java, but is a lot better than the norm.
The problem is that not a lot of people deeply grok OO in this way and you don't run into projects using this style often.
But let's not bash OO, let's learn from the cool stuff and throw out the garbage.
Any references for this style of development? Have you written about your development/architecture practices anywhere?
sigh
Like, if you know you're going to have to sanitize a ton of data, couldn't you use anything you wanted?
That's why what you ask for doesn't exist.