Mike Gold wrote:
> The parentheses are there for power: code is data, data is code.  When 
> evaluated as a language only, putting aside external issues such as 
> mindshare, it is an objective statement to say that lisp is more 
> powerful than any language which does not have the code-data 
> equivalence.

How is it more powerful than any other language which allows reflection? 
Including Ruby, with ParseTree?

> Without end we could discuss popularity, "naturalness," "well I like 
> ...", blah blah blah.  But it remains an empirical fact some things can 
> be done in lisp which cannot be done in ruby, unless ruby greenspuns its 
> own code processor.  In lisp you can manipulate code _in code_.

Right. Like ParseTree.

I have found Ruby's reflection to be more immediately useful, but I 
didn't use Lisp long enough to really be sure. I'm talking about the 
more specialized stuff, like define_method and instance_eval.

> If I understand Pascal's point, if he has one, it is that the vast 
> majority of programmers do not realize that the non-lisp language they 
> use is preventing them from thinking certain thoughts.  If after reading 
> the previous sentence you shouted "bullshit!", then you might not be 
> fully aware of this special code-data equivalence and why it makes lisp 
> and lisp-like languages different.
>   

Actually, I shouted "bullshit!" because a language cannot _prevent_ 
thoughts.

For example: Ruby has blocks, where JavaScript does not. But JavaScript 
does have anonymous functions.

So while Javascript doesn't support this:

foo.each do |obj|
  # do something with 'obj'...
end

It does support this (using jQuery):

$.each(foo, function() {
  // do something with 'this'...
});

// or, on a jQuery wrapped object:
foo.each(function() {
  // do something with 'this'...
});

The question then becomes whether a language actually makes certain 
things impossible, or impractical, or just annoying. And Ruby does have 
ParseTree.

> I am not soliciting opinions on what is more practical, what you prefer, 
> what is better, or what your favorite color is.  I am just giving an 
> overview of the core language itself, with all those issues aside.
>   

However, Pascal's point was that Lisp was unarguably the _best_ 
language, and implied that we were all "unwashed masses" for using Ruby 
(and that we probably didn't know about Lisp). I think if we're really 
going to have a discussion about "best", practicality has to play a part 
of that.

In fact, even if we're only talking about the most powerful language, 
power is also subjective. Ruby, for example, allows me to define a DSL 
as a subset of Ruby, and have the DSL be very readable -- the 
parentheses alone would make that harder in Lisp. All the flexibility 
that I like about Ruby's practice of duck typing would bother someone 
who wanted strict compiler checks and mathematical provability -- that 
is, the power to ignore type would bother someone who wanted the power 
to enforce it.

"Power" is subjective.