Would learning Lambda Calculus be useful to understanding Lisp? If
so, what are the prerequisites and what are some good tutorial
references on the subject?
--
Those who do not remember the history of Lisp are doomed to repeat it,
badly.
David Steuber wrote:
> Would learning Lambda Calculus be useful to understanding Lisp? If
> so, what are the prerequisites and what are some good tutorial
> references on the subject?
>
It probably won't help very much, and it probably won't hurt (except
that you'll spend time understanding two things instead of one).
Lambda calculus is interesting in its own right, but it isn't essential
for understanding Lisp. John McCarthy says he invented Lisp by
misunderstanding lambda calculus, so it might be interesting to see what
it is that he misunderstood, but I don't think it'll help you understand
Lisp better or more quickly.
There are other languages that are more like implementations of lambda
calculus (notably Haskell, Clean, and unlambda).
mikel evins <·····@evins.net> wrote in message news:<··········@news.athenanews.com>...
> David Steuber wrote:
> > Would learning Lambda Calculus be useful to understanding Lisp? If
> > so, what are the prerequisites and what are some good tutorial
> > references on the subject?
> >
>
> It probably won't help very much, and it probably won't hurt (except
> that you'll spend time understanding two things instead of one).
>
> Lambda calculus is interesting in its own right, but it isn't essential
> for understanding Lisp. John McCarthy says he invented Lisp by
> misunderstanding lambda calculus, so it might be interesting to see what
> it is that he misunderstood, but I don't think it'll help you understand
> Lisp better or more quickly.
He probably means that Lisp originally had (only) dynamic scope,
whereas lambda calculus is lexically scoped.
David Steuber <·············@verizon.net> wrote in message news:<··············@david-steuber.com>...
> Would learning Lambda Calculus be useful to understanding Lisp? If
> so, what are the prerequisites and what are some good tutorial
> references on the subject?
Mainly it helped me understand things like dynamic variables really
easily. And give me a sense of safety while learning Scheme. (I
learned SICP Scheme before lisp.)
Now when I say that, I mean I read a couple articles. ;)
http://www.mactech.com/articles/mactech/Vol.07/07.05/LambdaCalculus/
If you happen to like the author's style, more of his MacTech articles
at:
http://www.google.com/search?hl=en&ie=UTF-8&oe=UTF-8&q=Meulebrouck+site%3Awww.mactech.com&btnG=Google+Search
Of course I don't know if it's more important than anything else I've
learned, so it's certainly not worth forcing yourself if you can't
muster up the interest. But I personally need to know foundations,
because authors often treat what they're teaching as a foundational
thing, which it absolutely isn't. It's much easier to predict what
the author will say once the foundations are known, and you're not in
this twisted funhouse where you don't know what the next encounter
will be and can't link discrete pieces of knowledge together.
David Steuber <·············@verizon.net> writes:
> Would learning Lambda Calculus be useful to understanding Lisp? If
> so, what are the prerequisites and what are some good tutorial
> references on the subject?
Learning Lambda Calculus is useful for understanding all sorts of
computer science, not just lisp. High-school algebra should be
sufficient for getting a start (it is extraordinarily simple). I
don't know what the good tutorials are, I just picked up Church.
--
~jrm
David Steuber <·············@verizon.net> wrote in message news:<··············@david-steuber.com>...
> Would learning Lambda Calculus be useful to understanding Lisp?
The connection between lambda calculus and Lisp is the feature of
anonymous functions. Lambda calculus is no more useful for
understanding anonymous functions in a programming language than
regular algebra with named functions is useful for understanding named
functions in a programming language. Lisp has much more stuff in it in
addition to anonymous functions. It's a big language with an ANSI
standard that is about the size of the C++ one. It has a generic
sequence library, an object-oriented programming system, I/O streams,
conditions, a full numeric tower with rationals, complex numbers and
bignum integers, multi-dimensional arrays, strings, an entire
sublanguage called LOOP for concisely expressing iterative algorithms,
symbols as a data type, macros, packages, a sophisticated condition
system, etc. There is no one single entry point into it.
I would say that working with Lisp closures will probably help you
understand lambda calculus, rather than the other way around. A Lisp
system can be used to interactively explore some topics in lambda
calculus: and not just because of the support for anonymous functions,
but because of good numeric support! If you transliterate some math
expression into most programming languages, typically they will choke
due to representational limitations or poor flexibility in the
operational semantics.
David Steuber <·············@verizon.net> writes:
> So is the answer a weak maybe?
It's an `it depends'. Certainly you can have a career in programming
without being familiar with lambda calculus, but if you are interested
in computer language theory and tools like compilers and interpreters,
and why languages other than Lisp suck, then spending a little time
with lambda calculus will be of great utility.