Dylan is an advanced, object-oriented, dynamic language which supports the Rapid Development of programs. When needed, the programmer can later optimize [his or her] programs for more efficient execution by supplying type information to the compiler. Nearly all entities in Dylan (including functions, classes, and basic data types such as integers) are first class objects. Additionally Dylan supports Multiple Inheritance, Poly Morphism, Multiple Dispatch, Keyword Parameter Passing, object introspection, and many other advanced features which make programming a more productive and enjoyable experience.
Think Common Lisp with more mainstream syntax (closer to C, Pascal, Python, etc.), and a few warts removed, and you'll be close.
Two implementations of Dylan are currently being maintained (2001/09):
Functional Developer (former Harlequin Dylan) is a commercial implementation of Dylan for Windows NT, 98, 95 (alpha version for x86 Linux also available):
Gwydion Dylan is an open-source implementation of Dylan for Unix-compatible systems:
Apple's implementation of Dylan for the Mac OS was abandoned in 1995 soon after its first public release.
Other Dylan links:
news:comp.lang.dylan
Advanced Dylan Tutorial:
www.gwydiondylan.org 
The Dylan Reference manual:
at www.opendylan.org
Dylan Exchange:
dylanpro.com
The following are Broken Links.
Dylan / Java Source Code Comparison:
www.harlequin.com
The Dylan Evangelists:
dylan.prinz.org
Dylan World:
www-dylan.uchicago.edu
The Dylan FAQ-O-Matic:
www.randomhacks.com
Q: I have a question about Dylan's lack of Message Passing. How do you deal with situations where you want to pass a message, such as distributed objects or any situation where objects are in a different computer, memory space, or thread? Message Passing seems really good for this, so what do you do in Dylan?
A: Since Message Passing is equivalent to Single Dispatch, and thus a subset of Multiple Dispatch, there's nothing you can't do in Dylan that you can with a message-passing paradigm. And access to objects is using getters and setters exclusively. Calls to these functions can happen transparently over whatever lower-layer implementation. There exist implementations of CORBA, Xml Rpc and DOM.
Someone else's comments seems to have disappeared--do you mean Message Passing as in Message Based Concurrency (a means of communication between two different processes), or Message Passing as in what Smalltalkers call method calls?). Single Dispatch is equivalent to the latter; it certainly is not equivalent to the former.
I recently took a close look at Dylan, and was very impressed. Only two things keep me from trying to adopt it for ongoing work:
Thin and declining support -- only two compilers out there that I could see, and the free one is apparently not actively supported on Windows platforms, and hard to use there.
The macro system is very nice, but in some ways not as expressive as C++. It seems like it would be difficult or impossible to build new static types in a macro expansion that's part of an expression. (This is of interest to me because of some of the work that I've been doing lately. See Notes Ona Cee Plus Plus Rdbms Api.)
Other than that, I think the language designers made exactly the right choices: Multi Methods, a packaging scheme that is not based on classes, powerful integrated template/macro system, flexibility between early and late typing to facilitate tradeoffs between quick programming versus efficient compiled code.
Some very weak concerns: The lexical syntax could be a little simpler by omitting funky characters from identifiers, the use of angle brackets in predefined types is kind of annoying, and the unnecessarily long keywords make the language a bit more verbose than necessary. -- Dan Muller
Even if I didn't want identifiers to contain funky characters, I'd allow that just to make everybody put spaces around their operators. I also like type names to look different (it's easier to talk about Gizmo or than gizmo), and I think beats Foo Bar on a few points, like case sensitivity and extensibility (type names are capitalized, macro names in uppercase -- what about instance variables?).
See original on c2.com