Some rando called “Joe Armstrong” has said the same thing:

Joe Armstrong: Erlang has got all these things. It’s got isolation, it’s got polymorphism and it’s got pure messaging. From that point of view, we might say it’s the only object oriented language

Ralph Johnson: The thing about Erlang is that it’s in some sense 2 languages, at least you program it 2 levels because one is the functional language that you use to write a single process and then there is what you think about all these processes and how do they interact, one process is sending messages to the other. At a higher level, that Erlang is object oriented, at the lowest level it’s a pure functional language and that’s how it got advertised for a long time.

Ralph Johnson, Joe Armstrong on the State of OOP - InfoQ ~7m30s

(Elixir was not out at this time.)

I don’t really know how comment on this. Just some points (hopefully not too confusing):

• Concurrency and fault tolernace were fundamental properties of the systems in which we were interested. Without these any solution was not interesting, however cool it might be.

• For us concurrency and parallelism are different things, related but not the same. Concurrency is all about the problem and how you structure your system to solve it, while parallelism is a property of the hardware on which you are running.

• Our goal was to create language, and ways to use it, which supported us in building these types of systems.

• This is why we called them processes as that was how we were thinking.

• The functional nature actually came later. It started out as Prolog and then migrated to a functional language as it better fitted what we felt we needed.

• We were never OO at least clasical OO! At all! There is an OO chapter in the original book but that was more written as a joke. Shh that is a secret.

• We got the feeling that OO languages, at least in those days, were very sequential and not concurrent. While they might talk of “sending messages” it was really just doing a function call. Which was what we didn’t want.

• Doing the right error handling worked much better with processes.

I could go on here but think operating systems!

EDIT: We also felt that OO was very mutable, shared and global concerning data. Everything we didn’t want!

Also, I clean forgot that Alan Kay answered this question on Quora:

I love Joe Armstrong — we lost a great man when he recently left us.

And, he might be right. Erlang is much closer to the original ideas I had about “objects” and how to use them.

However, another way to look at this is to consider “What Is Actually Needed” (WIAN) and realize that much more is needed beyond what we are programming in today.

Joe would most definitely be more in favor of this idea than worrying about what either one of us did decades ago.