This looks a few years old. Interesting how since writing this article, Stevey's flipped on two points:
1) Javascript went from a "language you're stuck with" to the "next big language".
2) Here he has a hunch that, basically, Java is the best language for building large systems, and a dynamically typed, interpreted language probably would fail. Now at Google, he's certainly seen large systems done in Python, he uses Ruby everywhere he's allowed, and he's rewritten Rails and Wyvern in Javascript.
And he never explains why Lisp might be a special case.
Upmodded for pointing out that Yegge is always a little too sure of himself. He's an engaging writer though and ultimately he does a good thing by being an effective cheerleader for good (or at least better) languages.
A lot of people had the wrong idea about Javascript, the runtime environment (coupled with the unfortunate scoping) really obscured the genius of the language. Now with Rhino 1.7 you got almost all of the cool modern features of other structurally-typed 'scripting' languages (comprehensions, generators, Scheme-style lexical scoping, etc.) as well as access to what is arguably the largest body of useful library code on the planet. The only real problem is the lack of a first-class package mechanism, but it turns out you can add that too if you're a little tricky ;)
The JS 'object' is IMHO the 21st-century cons cell, in the sense that is an extremely simple atom from which you can build just about anything your heart desires. Javascript scopes are basically just objects, and methods are just (first-class) functions that have been stuck into objects. Add to this the fact that you've got a well-considered API into the interpreter itself and you've got basically the most kickass thing to happen to the JVM since...ever.
Lua's tables go further in a few respects. one is that anything can be a key, including other objects, which makes certain things much easier
another is Lua's metatable system, which lets you specify the behavior of the table under various operations. one of the interesting ones is the operation of accessing an index that doesn't have an entry in the table, which leads to straightforward ways of implementing inheritence and memoization, among countless other things
Lua's tables also entirely subsume arrays and other key-value pair thingies at minimal performance loss. tables are also used across the language in various places. for example, you can set a function's variable environment with a table, which is how modules are officially implemented
not to make an offhand comparison, but because Lua and Javascript are quite close
A little too sure of himself? Really? I'd say the opposite: he qualifies almost everything he says, and, besides, his essays tend to be, for lack of a better way to put it, a snapshot of Stevey's mind at a given point in time.
I agree with some things he says and disagree with others, but I like the fact that he doesn't claim to know everything.
1) Javascript went from a "language you're stuck with" to the "next big language".
2) Here he has a hunch that, basically, Java is the best language for building large systems, and a dynamically typed, interpreted language probably would fail. Now at Google, he's certainly seen large systems done in Python, he uses Ruby everywhere he's allowed, and he's rewritten Rails and Wyvern in Javascript.
And he never explains why Lisp might be a special case.