

Choosing Languages  - bootload
http://steve.yegge.googlepages.com/choosing-languages

======
etal
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.

~~~
benreesman
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.

~~~
tokipin
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

~~~
benreesman
Upmodded for the thoughtful and informative reply. I really need to take a
look at Lua, there seems to be a lot of momentum building around it.

------
tel
I feel sorry for pg. It wasn't intended poorly, but being called a "thought
leader" just seems to ring so sketchily anymore.

