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.