Lambda the Ultimate

The encapsulation in Erlang is achieved via threads. The polymorphism is achieved via messaging. As was discussed in a thread on message vs method OOP, the OOP languages that use messages are much more dynamic in nature. So, I'd agree that messaging in Erlang is probably truer to the original OO designs within Smalltalk, than say the method based languages like Java or C++.

That said, I don't think that mimicking OO practices in Erlang is the best use of the facilities of the language. Threading and Messaging in the language is quite strong and that's the direction that it should be used.

But Erlang's sequential programming model is it's most cumbersome, and does not really support OO in the sense of Smalltalk or Python.

I'd like to see a combination that worked better.

This is indeed the common wisdom. Personally, I am allergic to this list. Encapsulation exists in so-called object-based languages (e.g., Ada83, Modula-2); Polymorphism is a very generic term (pun intended): In OOP we are interested in subclass polymorphism and not parameteric pm.

When I want to highlight the properites most important, I usually concentrate on the following: deffered definitions (i.e, abstract methods etc.); subclass polymorphism, esp. as regards heterogenous datastructures; dynamic binding(late)/dispatching; factoring out common behaviours ("classwide programming" is what we all it in the Ada world).

Subtyping in dynamic messaging languages like Smalltalk (or even Erlang) is not restricted solely to the subclassing mechanism. Specifically, the typing is a function of the ability to respond to a message of the desired type. For example, if we had a type of Drawable and the meaning of that type is that the object is capable of drawing itself on a screen, then any class that implements the draw method is considered of type Drawable - even it doesn't explicitly subclass the Drawable class.

Static OO languages do require an explicit definition of subtype via either the subclass or interface mechanism. In Smalltalk you don't really need multiple inheritance, but it's a requirement for languages like Eiffel. Was one of the shortcomings of Simula that it was limited to single inheritance - a problem that I don't know has ever been resolved satisfactorally.

Do you mean static OO languages in general or just the current mainstream static OO languages?

Perhaps we are talking about different things, but as far as I can see, it is possible to design OO languages that do not require explicit annotation of subtype relations. See chapter 32[.2] of Types and Programming Languages. The subtype relations in the described object system follow directly from the various subtyping rules and do not need to be explicitly specified. Specifically, the definition of a ResetCounter does not explicitly say that it is a subtype of Counter. I think that a careful reader of that chapter can get a very good understanding of the difference between inheritance and subtyping (which is, IMO, often not clearly documented in OOA/D/P literature).