Well no, not really. In fact, the difference is striking. It doesn't
take a genius to be dumbstruck by the gaping difference.
Here's the story, I kept a few points on my impressions of lisp (along
with another textfile of notes on what I was learning), and one of the
things that struck me was how much different the lisp interpreter felt
from all other interpreters I had dealt with in my previous attempt to
learn a programming language, and how much different the interaction is
for the user with such an interpreter from others like perl.
In my impression points I made note of how vivid the gasping feeling
that the lisp interpreter felt 'intelligent', for lack of a better
word, yet 'intelligent' is so apt. 'Talking' to the lisp interpreter
felt like that, like 'talking' - in part because lisp has a clear
verbose simple syntax, and in part because what was being said to it
felt a little 'chatty'. It didn't feel like entering commands in perl,
tcl or python. In lisp it felt almost like meeting someone and they'd
say "what is it that you want?", and you start yapping, not knowing
where to start. And guess what, they'd listen, and keep it all in mind.
Well guess what, this may seem like old news to you, but for me as a
newbie I'm a little startled that the difference was so obvious to me.
In fact, one of my impressions is a sense of disbelief at how someone
so old, from the early days of computing, could seem so
next-generation. But here's what may seem like old news to you, but to
me, it was new
http://www.cs.ait.ac.th/~kitt/caml/OCaml1.pdf
It seems programming languages are imperative or functional - and all
those C-like languages I had encounter with were imperative, where the
interpreter is a dumb machine, requiring instructions for dummies. Lisp
is my first encounter with a functional programming language, and I'm
dumbstruck. In fact, I doubt I would want to endure the stupidity of an
imperative one anymore.
"In addition to its success in AI, Lisp pioneered the process of
Functional Programming. Many programming language researchers believe
that functional programming is a much better approach to software
development, than the use of Imperative Languages (Pascal, C++, etc)."
"The oldest example of a functional language is Lisp, though neither
the original LISP nor modern Lisps such as Common Lisp are
pure-functional."
But maybe I'm wrong, maybe that's not it, though reading about OCaml's
description struck a vivid note with me about how 'intelligent' the
lisp interpreter felt.
Is this it? Is it an issue of imperative vs functional as to why the
lisp interpreter felt different, almost half-human, man in the machine,
from others I had dealt with in the past?
············@gmail.com wrote:
> In fact, one of my impressions is a sense of disbelief at how someone
> so old, from the early days of computing, could seem so
> next-generation.
Typo, I meant how something so old, not someone so old, though the typo
seems telling - the lisp interpreter really felt to me far more human,
unmachine-like, than others.
············@gmail.com wrote:
> ············@gmail.com wrote:
>
>>In fact, one of my impressions is a sense of disbelief at how someone
>>so old, from the early days of computing, could seem so
>>next-generation.
>
>
> Typo, I meant how something so old,...
Yes, that is one of the strongest indicators that McCarthy got something
Deeply Right and Lisp inevitably will rule the world. Someone recently
noted that Lisp was proving an exception to the rule that languages do
not come back from the dead. Same thing. Lisp is so fundamentally
correct that accidents of history, which normally kill things like Beta
no matter what their advantages, are impotent against the deeper
superiority of Lisp's core concepts; not even death can kill Lisp.
But in the OP you were wondering which core concepts were decisive,
leaning towards the functional thing. That rocks, fer sher, but I think
the code-as-data quality might be the number one virtue. Reflection is
huge, too. All objects all the time, strong runtime data typing and no
static variable typing. Maybe the real point is not to look for one
great honking difference... or send McCarthy an email and ask him if he
can trace all these qualities back to one root "win" in the Lisp design.
if anyone will know, it would be him.
Anyone remember what he said at the last two ILCs? Ah, I remember him
slamdunking Norvig's elevation of Python to Lispness by asking him about
code as data. Not sure that identifying that as "most differentiating"
also makes it "most enabling".
--
Kenny
Why Lisp? http://wiki.alu.org/RtL_Highlight_Film
"I've wrestled with reality for 35 years, Doctor, and I'm happy to state
I finally won out over it."
Elwood P. Dowd, "Harvey", 1950
From: David Steuber
Subject: Re: ...McCarthy was [ was Re: I'm such a genius - either that, or...]
Date:
Message-ID: <874q6l0zxc.fsf@david-steuber.com>
Kenny Tilton <·······@nyc.rr.com> writes:
> Anyone remember what he said at the last two ILCs? Ah, I remember him
> slamdunking Norvig's elevation of Python to Lispness by asking him
> about code as data. Not sure that identifying that as "most
> differentiating" also makes it "most enabling".
Code as data is definitely a big win for Lisp if not the big win for
Lisp. Functional programming has its place, no doubt, but so far
most of my Lisp is imperative. I still consider myself a newbie
though (even if I have been at it for a while now).
If I might indulge in an analogy, I feel like writing code in Lisp is
closer to writing prose while other languages are more like iambic
pentameter or some other such straight jacket of conformity to help
the machine.
More than any one feature of Lisp, I would say it is the gestalt that
truly makes it great. Well that and the syntax ;)
--
http://www.david-steuber.com/
The UnBlog: An island of conformity in a sea of quirks.
http://www.david-steuber.com/snippets/Boycott_Sony/
From: Andras Simon
Subject: Re: ...McCarthy was [ was Re: I'm such a genius - either that, or...]
Date:
Message-ID: <vcdfyq4lj7f.fsf@csusza.math.bme.hu>
David Steuber <·····@david-steuber.com> writes:
> If I might indulge in an analogy, I feel like writing code in Lisp is
> closer to writing prose while other languages are more like iambic
> pentameter or some other such straight jacket of conformity to help
> the machine.
Perfect!
Andras
From: Robert Uhl
Subject: Re: I'm such a genius - either that, or...
Date:
Message-ID: <m3wtjjvgyi.fsf@4dv.net>
············@gmail.com writes:
>
> It seems programming languages are imperative or functional - and all
> those C-like languages I had encounter with were imperative, where the
> interpreter is a dumb machine, requiring instructions for
> dummies. Lisp is my first encounter with a functional programming
> language, and I'm dumbstruck. In fact, I doubt I would want to endure
> the stupidity of an imperative one anymore.
You might not like Lisp, then, since it's an imperative language. And a
functional language. And an object-oriented language...
--
Robert Uhl <http://public.xdi.org/=ruhl>
For entertaining gas contamination I always liked concentrated sulphuric
acid and elemental iodine. The result of mixing these is a mixture of
gaseous iodine, hydrogen sulphide and sulphur dioxide, so it stinks,
stains everything, is poisonous and corrosive.
Robert Uhl wrote:
> ············@gmail.com writes:
> >
> > It seems programming languages are imperative or functional - and all
> > those C-like languages I had encounter with were imperative, where the
> > interpreter is a dumb machine, requiring instructions for
> > dummies. Lisp is my first encounter with a functional programming
> > language, and I'm dumbstruck. In fact, I doubt I would want to endure
> > the stupidity of an imperative one anymore.
>
> You might not like Lisp, then, since it's an imperative language. And a
> functional language. And an object-oriented language...
>
Well I like lisp, that's for sure, I was just wondering if what I liked
was 'that functional thing'.
> --
> Robert Uhl <http://public.xdi.org/=ruhl>
> For entertaining gas contamination I always liked concentrated sulphuric
> acid and elemental iodine. The result of mixing these is a mixture of
> gaseous iodine, hydrogen sulphide and sulphur dioxide, so it stinks,
> stains everything, is poisonous and corrosive.
············@gmail.com wrote:
> > You might not like Lisp, then, since it's an imperative language. And a
> > functional language. And an object-oriented language...
> >
>
> Well I like lisp, that's for sure, I was just wondering if what I liked
> was 'that functional thing'.
It looks like what you like is that there is a single image, with
everything integrated in it, including an interactive listener. You
type right to the language parser. But its behavior is robust and
forgiving; when you make an error, it doesn't crash, but transfer
control to an error handler where you can fix things, examine the stack
of evaluation frames, or give up and escape to the top level. You can
define a function, then later change your mind and redefine it. You can
explore things without going through an edit-compile-run cycle.
············@gmail.com wrote:
> Robert Uhl wrote:
>
>>············@gmail.com writes:
>>
>>>It seems programming languages are imperative or functional - and all
>>>those C-like languages I had encounter with were imperative, where the
>>>interpreter is a dumb machine, requiring instructions for
>>>dummies. Lisp is my first encounter with a functional programming
>>>language, and I'm dumbstruck. In fact, I doubt I would want to endure
>>>the stupidity of an imperative one anymore.
>>
>>You might not like Lisp, then, since it's an imperative language. And a
>>functional language. And an object-oriented language...
>
> Well I like lisp, that's for sure, I was just wondering if what I liked
> was 'that functional thing'.
You are probably currently focusing on the elements that you haven't
known before. This always happens when people encounter something new.
However, (at least some of) the elements that you already know are still
valid, and the good thing is that you don't have to throw them overboard.
Pascal
--
My website: http://p-cos.net
Closer to MOP & ContextL:
http://common-lisp.net/project/closer/