Dylan Vs Self

The DylanLanguage and the SelfLanguage are two of the purest ObjectOrientedProgrammingLanguages. Here's the feature set:

Both

completely ObjectOriented - all types are objects
ModuleSystem
MultipleInheritance

Dylan

DynamicTyping - but the programmer can specify the type of variables
MultiMethods
SchemeMacros - inspired from

Self

DynamicTyping
MessagePassing
SmalltalkBlocksAndClosures - inspired from

I think they show the two most interesting approaches to object oriented languages. Personally I think static typing can never capture the richness of behavior object orientation is designed to create. Message passing is great when you have to communicate between different threads, tasks, or computers. And blocks are great, but it might be even better with true anonymous functions. So Self has the leg up in my book.

And blocks are great, but it might be even better with true anonymous functions.

[Blocks are anonymous functions, so what do you mean by that statement? Can you elaborate?]

Dylan's type system is only optionally static. Just as in CommonLisp, you may choose to put type annotations in your code, or you may choose not to. MessagePassing is a subset of MultipleDispatch; calls that dispatch only on the invoked object can be viewed as message passings. Thus, Dylan has MessagePassing.

It's only MessagePassing in the ProgrammingLanguage sense we're used to from SmalltalkLanguage etc. MessagePassing also refers to a concurrency model based on sending asynchronous messages, which Dylan does not support (it could in theory, but last I read, Gwydion had problems just supporting threads, let alone asynchronous message passing). See ActorsModel and MessagePassingConcurrency, also AlanKayOnMessaging.