Languages From Designers Perspective

Based on the idea that GoodLanguageDesign matters.

I love Smalltalk because its design is clean and sparse. The number of concepts is small and deviations are few. But more than that, it was the first good design using these concepts, and even the first language to make major use of those concepts.

(Note to programmers, GarbageCollection is an implementation feature which actually reduces the number of concepts in the design. A sparse design doesn't imply a sparse implementation.)

I love Self even more because it does away entirely with at least one Smalltalk concept (classes), unifies others (variables and methods), and crystallizes out of the nightmare that is MVC a shining concept of DirectManipulation.

I respect Lisp because it brought many new concepts into the world and deviates rarely from those concepts. I may never use those concepts because I find them unnatural, difficult to apply and completely incompatible with my favourites, but that's irrelevant. What's relevant is that I recognize the concepts for what they are and I respect Lisp for them.

(Multimethods are a good case. They're a good concept but entirely unnatural. English is characterized as SVO, not SVS or OVO. It doesn't matter WhyTheFirstArgIsSpecial?, it just is.)

In contrast, I disdain Perl because it brought no new concepts to language design. Of course I don't know Perl.

I loathe Java because it was conceived as SmalltalkMinusMinus and its few contributions (interfaces and anonymous inner classes) don't justify themselves and are the wrong way to go anyways. Almost all uses of anonymous inner classes are to replace blocks, and what's the point of them in a prototypical language?

I despise C++ with a passion. It represents everything that is anathema to design.

-- RichardKulisz

(Minor quibble: English isn't always SVO - imperative sentences are VO with an implied subject. I always find it ironic that imperative languages like SmallTalk are SVO, while (mostly) declarative languages like Lisp and Haskell are VO. Perhaps that's why I find procedural, VO languages like Basic, Pascal, and procedural Python to be the most readable, even though they're brain-dead in most other respects. -- JonathanTang)

Smalltalk is not subject/verb/object, It's imperative-verb/object/prepositional-clauses/other-objects/adverbs. The subject (self) is implicit. SubjectOriented languages dispatch on both subject, object; some also dispatch on argument types as well, and so the SubjectOrientated? dispatch is the same mechanism as the MultiMethod? dispatch. SlateLanguage is an example.