In article <·····················@news.columbia.edu> ····@cunixf.cc.columbia.edu (Reha Elci) writes:
>In article <·················@CUNYVM.BITNET> <·····@CUNYVM.BITNET> writes:
>>I just purchased a book for Lisp programming, but have never used this before.
>>Is this easy to learn by myself by reading the manual and practicing on the
>>computer?
>
>LISP is ***the*** easiest language to learn by a 10:1 ratio to even the
>nearest contender. So just get an interpreter and start typing. you do
>not have to write a program like 'C' to learn it.
A minority opinion from someone who has learned/is learning Lisp on
his own:
Lisp isn't that hard to learn, and it's great. The basics are
fairly basic, even though some of the subtleties of Common Lisp take
some work (for me, anyway).
But (now comes the sacreligeous comment) I don't find Lisp to be the
easiest language to learn. Basic was easier for me, and dBASE was
easier still. It goes without saying that Lisp is more powerful, more
elegant, cooler, and just generally more fun (well--I suppose that
this last comment doesn't "go without saying"--it's what I believe,
though).
You may think I've been poisoned by my early experiences--perhaps
that's so. Doesn't seem that way to me, though.
I suppose that Lisp is the easiest language for some, and not for
others.
Marshall Abrams
····@midway.uchicago.edu
In article <······················@midway.uchicago.edu> ····@midway.uchicago.edu writes:
>>LISP is ***the*** easiest language to learn by a 10:1 ratio to even the
>>nearest contender. So just get an interpreter and start typing. you do
>>not have to write a program like 'C' to learn it.
>But (now comes the sacreligeous comment) I don't find Lisp to be the
>easiest language to learn. Basic was easier for me, and dBASE was
>easier still. It goes without saying that Lisp is more powerful, more
>elegant, cooler, and just generally more fun (well--I suppose that
>this last comment doesn't "go without saying"--it's what I believe,
>though).
Another data point -- I learned Fortran ages ago, back when it didn't
have numbers (pre Fortran-II) and that was the easiest language. All
one had to do was read a couple of programs and you were off and running.
The hard part was learning how to use a key punch and a card reader!
Really, if you are going to talk about "easy to learn" you have to
divide the notion. E.g.
How much intellectual work does it take to learn how to execute code
in the language?
How much intellectual work does it take to learn the syntax of the
language?
How much intellectual work does it take to understand the approach
of the language if you are a novice? If you are used to a very
different approach?
How great is the distance between the raw syntax of the language and
the idioms and intellectual constructs that one needs for writing
real programs?
--
Richard Harter: SMDS Inc. Net address: ··@smds.com Phone: 508-369-7398
US Mail: SMDS Inc., PO Box 555, Concord MA 01742. Fax: 508-369-8272
In the fields of Hell where the grass grows high
Are the graves of dreams allowed to die.
In article <······················@smds.com> ··@smds.com (Richard Harter) writes:
Really, if you are going to talk about "easy to learn" you have to
divide the notion. E.g.
How much intellectual work does it take to learn how to execute code
in the language?
How much intellectual work does it take to learn the syntax of the
language?
[etc.]
This is very true. I currently teach an introductory programming class
(where we use Scheme). If the sole purpose of the class would be to
teach enough programming to be able to write simple programs, say to
sum integers from one to n, I would definitely use basic. Fortunately
things are not that bad, and we are allowed to teach programming
instead of making computers do tricks.
There are some fundamental things that one must learn in order to use
any of the modern languages (Pascal, C and Lisp included) that are not
needed with basic, namely the hierarcical structure of programs, the
concept of subprograms, and what it means to "return a value". The
execution model of a block structured language is also conceptually
much more difficult than that of a line oriented language.
What it boils down is that "Lisp is the easiest language to learn" is
maybe market hype, but "It is easy to learn to write good programs
in Lisp" is, at least IMHO, true.
--
Pertti Kellom\"aki (TeX format) # These opinions are mine,
Tampere Univ. of TeXnology # ALL MINE !
Software Systems Lab # (but go ahead and use them, if you like)
In article <················@talitiainen.cs.tut.fi> ··@cs.tut.fi (Kellom{ki Pertti) writes:
>There are some fundamental things that one must learn in order to use
>any of the modern languages (Pascal, C and Lisp included) that are not
>needed with basic, namely the hierarcical structure of programs, the
>concept of subprograms, and what it means to "return a value".
Not to argue with your general point, but when criticizing Basic, I
think it's important to be aware that many modern Basic's have better
control structures available than just GOSUBs and The Dreaded GOTO.
:-) Some people aren't aware of ways in which Basic has evolved in the
last 10 years. For example, both Borland Turbo Basic and DEC's Vax
Basic both allow multiple-line recursive functions and multiple-line
IF's, and don't require line numbers. (Amazingly, the built-in Basic
on my Z-80 based notebook (Cambridge Z88), also allows multiple-line
recursive functions, despite requiring line numbers and not having a
multiple-line IF or any useful case construct.)
Obviously you can do more, more elegantly, etc. in Lisp. I'm not
claiming that Basic is the best language for an introductory computer
science course. But I don't believe that Basic has to cause "brain
damage" anymore. Of course, Basic *could* still be taught solely in
terms of GOTOs. But then, Common Lisp could be taught using GO as the
only control construct.
Marshall Abrams
From: Jeff Dalton
Subject: Re: Is lisp easy to learn?
Date:
Message-ID: <7849@skye.ed.ac.uk>
In article <················@talitiainen.cs.tut.fi> ··@cs.tut.fi (Kellom{ki Pertti) writes:
>In article <······················@smds.com> ··@smds.com (Richard Harter) writes:
> Really, if you are going to talk about "easy to learn" you have to
> divide the notion. E.g.
>
> How much intellectual work does it take to learn how to execute code
> in the language?
>
> How much intellectual work does it take to learn the syntax of the
> language?
>[etc.]
>
>This is very true. I currently teach an introductory programming class
>(where we use Scheme). If the sole purpose of the class would be to
>teach enough programming to be able to write simple programs, say to
>sum integers from one to n, I would definitely use basic. Fortunately
>things are not that bad, and we are allowed to teach programming
>instead of making computers do tricks.
What "early programs" do you find to work well for teaching Lisp?
Arithmetic doesn't show Lisp at it's best, and some students are
turned off by "boring math", so I suspect that some simple symbolic
things might be better. Random numbers (hence games, etc) might
be helpful.
In article <····@skye.ed.ac.uk> ····@aiai.ed.ac.uk (Jeff Dalton) writes:
>What "early programs" do you find to work well for teaching Lisp?
>
>Arithmetic doesn't show Lisp at it's best, and some students are
>turned off by "boring math", so I suspect that some simple symbolic
>things might be better. Random numbers (hence games, etc) might
>be helpful.
When I was at MIT, the Student Information Processing Board (about the
closest thing to a computer club at the Institute) taught an introductory
Lisp course during the January Independent Activities Period. The example
programs we used were an algebraic simplifier (recognizing simple
identities), a symbolic differentiator, the Animals game, and Eliza. These
demonstrate symbolic processing and recursive algorithms very well.
Consider how far in a C or Pascal course you would have to get before you
knew enough of the language to be able to write any of these. In order to
implement symbolic and recursive data in most conventional languages you
need to know about structures and pointers; in Lisp we can teach lists and
use them for anything (the teacher can decide whether to teach DEFSTRUCT
early or late). In the case of Eliza, you'd probably want to use yacc
rather than straight C or Pascal.
--
Barry Margolin
System Manager, Thinking Machines Corp.
······@think.com {uunet,harvard}!think!barmar
In article <····@skye.ed.ac.uk> ····@aiai.ed.ac.uk (Jeff Dalton) writes:
What "early programs" do you find to work well for teaching Lisp?
Arithmetic doesn't show Lisp at it's best, and some students are
turned off by "boring math", so I suspect that some simple symbolic
things might be better. Random numbers (hence games, etc) might
be helpful.
The course is not intended as a Lisp (or Scheme) course, but rather as
an introduction to programming in general. Therefore, we try not to
emphasize features special to Lisp. We do use lists and symbols, but
we try to make the course accessible also to students who have
difficulties even in grasping what a procedure is.
Looking at the material, we have simple arithmetic procedures like
square etc. when introducing the use of procedures. We introducing
lists, we write a program to solve the equation ax^2+bx+c = 0, and use
lists as a means of representing complex numbers. A more involved
example we use is a simulation of a solar system, where each body is
represented by a list containing its mass, x-y coordinates etc.
Simulation seems to be a fairly good topic, especially if you can get
some graphics out of it.
It seems that most of our material is somehow math oriented rather
than symbolic, but that's mostly because of the goals of the course.
--
Pertti Kellom\"aki (TeX format) # These opinions are mine,
Tampere Univ. of TeXnology # ALL MINE !
Software Systems Lab # (but go ahead and use them, if you like)
In article <······················@midway.uchicago.edu> ····@quads.uchicago.edu (Marshall Abrams) writes:
But (now comes the sacreligeous comment) I don't find Lisp to be the
easiest language to learn. Basic was easier for me, and dBASE was
easier still.
if you only learned as much of lisp as would be required to do what
you can do in basic, then lisp would have been easier.
You may think I've been poisoned by my early experiences--perhaps
that's so. Doesn't seem that way to me, though.
some have claimed that learning basic first causes brain damage.
In article <·················@lole.nmsu.edu>, ···@nmsu.edu (Classic Ted) writes:
> In article <······················@midway.uchicago.edu> ····@quads.uchicago.edu
(Marshall Abrams) writes:
>
> But (now comes the sacreligeous comment) I don't find Lisp to be the
> easiest language to learn. Basic was easier for me, and dBASE was
> easier still.
>
> if you only learned as much of lisp as would be required to do what
> you can do in basic, then lisp would have been easier.
You've tried this, so you know.
I've tried learning both, and I found BASIC to be very simple to _master_.
It's also an easy language to build on, learning more of the language
(say QuickBasic) or leaping to C, Pascal, or FORTRAN is a natural progression.
I have not found Lisp to make sense beyond the trivial examples mentioned
previously. Understanding the necessity for and use of macros is definitely
non-trivial. Optimizing Lisp source is a task for only the most experienced
Lisp hackers (which I infer, having seen only Peter Norvig seriously attempt
to document the practice). And Lisp is a language that few ever _master_,
because Common Lisp is almost certainly the largest programming language ever
devised, and because few programmers ever use it unless they are wealthy or
have steady access to a large organization which can afford the $500+ in
software and multiple thousands in hardware necessary for one person to get
serious in Lisp.
One day I will develop proficiency in Lisp, but not soon and it won't be
_anywhere_ as easy to accomplish as becoming expert in BASIC was.
>
> You may think I've been poisoned by my early experiences--perhaps
> that's so. Doesn't seem that way to me, though.
>
> some have claimed that learning basic first causes brain damage.
But you've forgotten who. It was Edsgar Dijkstra.
--
| Randy Crawford ········@mitre.org The MITRE Corporation
| 7525 Colshire Dr., MS Z421
| N=1 -> P=NP 703 883-7940 McLean, VA 22102
Date: Thu, 22 Oct 1992 16:06 EDT
From: Randy Crawford <········@boole.mitre.org>
In article <·················@lole.nmsu.edu>, ···@nmsu.edu (Classic Ted) writes:
> In article <······················@midway.uchicago.edu> ····@quads.uchicago.edu
(Marshall Abrams) writes:
>
> But (now comes the sacreligeous comment) I don't find Lisp to be the
> easiest language to learn. Basic was easier for me, and dBASE was
> easier still.
>
> if you only learned as much of lisp as would be required to do what
> you can do in basic, then lisp would have been easier.
You've tried this, so you know.
I've tried learning both, and I found BASIC to be very simple to _master_.
It's also an easy language to build on, learning more of the language
(say QuickBasic) or leaping to C, Pascal, or FORTRAN is a natural progression.
I have not found Lisp to make sense beyond the trivial examples mentioned
previously.
If anything, Lisp makes *more* sense for non-trivial examples than most
other languages with which I am familiar.
Understanding the necessity for and use of macros is definitely
non-trivial.
I don't understand why you think macros are non-trivial. They are
simply another tool for doing abstraction, except that macros are often
used to do control abstraction rather than data abstraction.
Optimizing Lisp source is a task for only the most experienced
Lisp hackers (which I infer, having seen only Peter Norvig seriously attempt
to document the practice).
I agree that optimizing Lisp code can be difficult. The reason is that
in Lisp, the cost of many operations is not explicit. This means that
the programmer must know the language well enough to know what the cost
of most operations is. The learning curve for this is quite long.
And Lisp is a language that few ever _master_,
because Common Lisp is almost certainly the largest programming language ever
devised,
It is large only if you lump all of the Lisp's "library" routines in
with the basic language, which the dpANS spec does. If you included all
of the C/C++ libraries in the basic definitions for C/C++, those
languages would look very large, too.
and because few programmers ever use it unless they are wealthy or
have steady access to a large organization which can afford the $500+ in
software and multiple thousands in hardware necessary for one person to get
serious in Lisp.
MCL costs $500, and Macintoshes that run it are quite inexpensive. It's
a very good implementation of Lisp, too. CMU's Lisp compiler is free,
excellent, and runs on some workstations that are very inexpensive.
The `essence of Lisp', admittedly imperfect, is far more regular and consistent
than Basic. It's more complex than basic, but not _that_ much more. It IS
very very muchly more powerful. You have to put more effort into learning it.
Well worth it.
IMarrogantO, Common Lisp is an _abomination_ of this `essence of Lisp'! Try
Scheme, a rather trim, clean Lisp. The defining document, "Revised^4 Report on
the Algorithmic Language Scheme" (that's pronouced "arforaress", heh) is 54
pages total. The informal description of the language is a scant 29 pages.
This portion is easy enough on the eyes for a casual reader. It is not a
textbook on the language or programming, though, and it is not intended to be.
But the document is a must-have. Archie will tell you where to get R4RS.
Regards, [Ag]
From: Stefan Monnier
Subject: Re: Is lisp easy to learn?
Date:
Message-ID: <BwLnpJ.ArK.2@cs.cmu.edu>
In article <··························@brushfire.rutgers.edu>, ······@brushfire.rutgers.edu (Silver) writes:
> The `essence of Lisp', admittedly imperfect, is far more regular and consistent
> than Basic. It's more complex than basic, but not _that_ much more. It IS
> very very muchly more powerful. You have to put more effort into learning it.
> Well worth it.
>
> IMarrogantO, Common Lisp is an _abomination_ of this `essence of Lisp'! Try
> Scheme, a rather trim, clean Lisp. The defining document, "Revised^4 Report on
> the Algorithmic Language Scheme" (that's pronouced "arforaress", heh) is 54
> pages total. The informal description of the language is a scant 29 pages.
> This portion is easy enough on the eyes for a casual reader. It is not a
> textbook on the language or programming, though, and it is not intended to be.
> But the document is a must-have. Archie will tell you where to get R4RS.
>
> Regards, [Ag]
Yes, TOO TRUE, Common Lisp is a shame.
Let's have something a bit cleaner:
SSSS CCCC H H EEEEE M M EEEEE !!
S C H H E MM MM E !!
SSS C HHHHH EEE M M M EEE !!
S C H H E M M E !!
SSSS CCCC H H EEEEE M M EEEEE !!
Stefan
In article <······················@linus.mitre.org> ········@boole.mitre.org (Randy Crawford) writes:
In article <·················@lole.nmsu.edu>, ···@nmsu.edu (Classic Ted) writes:
> if you only learned as much of lisp as would be required to do what
> you can do in basic, then lisp would have been easier.
You've tried this, so you know.
well, i have tried teaching both of them.
I've tried learning both, and I found BASIC to be very simple to _master_.
low ceilings.
I have not found Lisp to make sense beyond the trivial examples mentioned
previously.
if all you want to do is what you can do in basic, then all you really
need is the first two chapters of SICP plus a few string operations.
this takes very little time to explain.
Understanding the necessity for and use of macros is definitely
non-trivial.
this doesn't matter since teaching a subset of lisp which provides
essentially all of basic obviously doesn't involve talking about
macros.
Optimizing Lisp source is a task for only the most experienced
Lisp hackers (which I infer, having seen only Peter Norvig seriously attempt
to document the practice).
sicp had some very good comments on optimizing. the basic point to be
made is that optimizing algorithms pays more than optimizing code.
And Lisp is a language that few ever _master_,
because Common Lisp is almost certainly the largest programming language ever
devised,
have you read the ada standard lately?
One day I will develop proficiency in Lisp, but not soon and it won't be
_anywhere_ as easy to accomplish as becoming expert in BASIC was.
again, this is a matter of very low ceilings. i have yet to see a
book on basic which documents the answers to the following questions:
1) how do i pass closures as arguments?
2) how do i define a new type?
3) is there a data type in which a standard abstract syntax for basic
can be stored?
4) what is the equivalent of map? reduce? lambda?
5) what is the standardized object system?
6) what operations work on very large integers? on rationals? on
complex numbers?
7) what is the log of -1?
8) how can my program access the on-line documentation system?
9) how can my program be included into the on-line documentation?
> You may think I've been poisoned by my early experiences--perhaps
> that's so. Doesn't seem that way to me, though.
>
> some have claimed that learning basic first causes brain damage.
But you've forgotten who. It was Edsgar Dijkstra.
no... edsgar dijkstra was just the FIRST person to say it in print.
many others have said it since.
(including me).
From: Patrick May
Subject: Lisp or Scheme? (Was: Is lisp easy to learn?)
Date:
Message-ID: <73791@apple.Apple.COM>
Since Lisp is such an easy language to learn, I think I'll set aside
Thursday to do so.... Seriously, I've been interested in learning Lisp
for quite some time in order to add to my potential "best tools for the
job". I've read through the FAQ, and I'd like input on whether I'd be
better off learning Common Lisp or Scheme (pick your favorite criteria
for "better off").
The above sounds like a request for a religious war -- I hope the
Lisp/Scheme camps are better behaved than the Smalltalk/C++ people.
Also, which of the public domain implementations listed in the FAQ
would you recommend?
Thanks,
Patrick May
···@apple.com
------------------------------------------------------------------------
"A contract programmer is always intense."
From: Stefan Monnier
Subject: Re: Lisp or Scheme? (Was: Is lisp easy to learn?)
Date:
Message-ID: <Bwt20H.AB0.2@cs.cmu.edu>
In article <·····@apple.Apple.COM>, ···@Apple.COM (Patrick May) writes:
>
> Since Lisp is such an easy language to learn, I think I'll set aside
> Thursday to do so.... Seriously, I've been interested in learning Lisp
> for quite some time in order to add to my potential "best tools for the
> job". I've read through the FAQ, and I'd like input on whether I'd be
> better off learning Common Lisp or Scheme (pick your favorite criteria
> for "better off").
Which one ?
SCHEME
It's so much more consistent: functions are truly considered values
(not special values as in CL but plain normal values, stored the same
way as a number), it's much smaller and it's better (that's the main
argument). CL has a lot of functions (useful for big programs) but CL
code tends to be much more C like (lisp is fundamentally a functional
language, but CL is much closer to imperative actually).
> The above sounds like a request for a religious war -- I hope the
> Lisp/Scheme camps are better behaved than the Smalltalk/C++ people.
This seems logical: Scheme is objectively so much better that noone
can honestly pretends lisp to be the best.
> Also, which of the public domain implementations listed in the FAQ
> would you recommend?
SCM from Aubrey Jaffer is a good choice in general (there is an X interface
available). But some other may be better: it depends on your hardware
> Thanks,
You're welcome
> Patrick May
Stefan
This seems logical: Scheme is objectively so much better that noone
can honestly pretends lisp to be the best.
OK, but how about CLOS? I consider it one of the high-points of
Western Civilization, right up there with the use of corks in wine
bottles. I'd rather use Scheme than CLTL1 Common Lisp, but if I'm
offered all of CLTL2, I start to waver...
- Jim
From: Jeff Dalton
Subject: Re: Lisp or Scheme? (Was: Is lisp easy to learn?)
Date:
Message-ID: <7851@skye.ed.ac.uk>
In article <·····················@paintbrush.mcc.com> ·······@paintbrush.mcc.com (Jim Barnett) writes:
>
> This seems logical: Scheme is objectively so much better that noone
> can honestly pretends lisp to be the best.
>
>OK, but how about CLOS? I consider it one of the high-points of
>Western Civilization, right up there with the use of corks in wine
>bottles. I'd rather use Scheme than CLTL1 Common Lisp, but if I'm
>offered all of CLTL2, I start to waver...
There are some CLOS-like object systems available for Scheme.
Typically, old-style macros are required.
If the Comp.lang.lisp FAQ doesn't discuss this, it should.
But wait! I can just look. Yes! Lisp wins again by having such an
excellent FAQ list:
The MEROON package is a mini-CLOS-like object package for generic
R4RS Scheme (but with non-standard macros). It runs with PC-Scheme,
Scheme->C and Chez Scheme. It is available in the Scheme Repository
as nexus.yorku.ca:pub/scheme/new/meroon.*.tar.Z. A paper on it
appears in nexus.yorku.ca:pub/txt/meroon.ps.Z.
-- jd
In article <············@cs.cmu.edu> ········@CS.CMU.EDU (Stefan Monnier) writes:
In article <·····@apple.Apple.COM>, ···@Apple.COM (Patrick May) writes:
> I've been interested in learning Lisp
> for quite some time in order to add to my potential "best tools for the
> job". I've read through the FAQ, and I'd like input on whether I'd be
> better off learning Common Lisp or Scheme (pick your favorite criteria
> for "better off").
Which one? SCHEME
Assuming your goal is to learn enough of some dialect to get a good feel
for "what lisp is like" so you (1) know when lisp is the right tool
and (2) can do some small-to-moderate programming tasks in it, I agree
that Scheme is the right choice. It is a small, elegant, powerful
dialect. But if your goal is to be able to work on large programs
I would go with common lisp.
CL has a lot of functions (useful for big programs)
CL also has things like the package facility (for information-hiding
and modularity) and a standardized macro facility, which are also
important for big programs, and a standard object-oriented programming
facility (CLOS). Also, I suspect the best programming environments
available for common lisp are much better than for scheme. (Anyone
know of a window-oriented debugger or specialized emacs interface for
scheme?)
but CL code tends to be much more C like (lisp is fundamentally a
functional language, but CL is much closer to imperative actually).
You can write as functional a program you like in cl, but it does
also have a few more constructs for imperative-style programming than
scheme.
[In Scheme] functions are truly considered values
(not special values as in CL but plain normal values, stored the same
way as a number)
You are confused here - functions are plain normal values in cl just
as in scheme and can be stored in a variable. What scheme has has
that cl lacks in this regard is "call-with-current-continuation", but
if you are just trying to learn lisp quickly, you *really* don't want
to get into continuations. They are powerful and elegant (and available
in cl, too, but less nicely), but they are real mind-benders on first
exposure. Almost as bad as first learning about recurison.
Or are you referring to the fact that the meaning of a symbol used as
a function in the car of a form is the same as when it is used as a
variable? This is only a minor part of Scheme's elegance, and
certainly not a major issue as far as learnability goes. Even in
scheme the car of a form is treated specially - it's value is a
function to be applied to the other arguments - so the fact that in cl
you get that value differently from the way you get the values of the
args is not that big an inelegance or learning problem.
--
Lou Steinberg
uucp: {pretty much any major site}!rutgers!aramis.rutgers.edu!lou
internet: ···@cs.rutgers.edu
From: Zdzislaw Meglicki
Subject: Re: Lisp or Scheme? (Was: Is lisp easy to learn?)
Date:
Message-ID: <1d7cb3INNdk7@manuel.anu.edu.au>
Although I agree that Scheme is conceptually more elegant than
Common Lisp, when it comes to all that really matters, that is
the quality of the compilers, the quality of the programming
environment, availability of useful facilities, there's little
out there that could even compete with Common Lisp.
But learning Common Lisp is a hard undertaking. Don't try to read
Steele's "Common Lisp, the Language". That book is not for the
beginners. The best Common Lisp text I know about is
Patrick Henry Winston and Berthold Klaus Horn:
"Lisp" - third edition; perhaps even fourth is already
available
--
Zdzislaw Gustav Meglicki, ······@arp.anu.edu.au,
Automated Reasoning Program - CISR, and Plasma Theory Group - RSPhysS,
The Australian National University, G.P.O. Box 4, Canberra, A.C.T., 2601,
Australia, fax: (Australia)-6-249-0747, tel: (Australia)-6-249-0158
From: Viktor Haag
Subject: Re: Lisp or Scheme? (Was: Is lisp easy to learn?)
Date:
Message-ID: <1992Nov4.155517.22897@mks.com>
In article <············@manuel.anu.edu.au> ······@arp.anu.edu.au (Zdzislaw Meglicki) writes:
>
>But learning Common Lisp is a hard undertaking. Don't try to read
>Steele's "Common Lisp, the Language". That book is not for the
>beginners. The best Common Lisp text I know about is
>
> Patrick Henry Winston and Berthold Klaus Horn:
> "Lisp" - third edition; perhaps even fourth is already
> available
I just purchased the 3rd edition a few weeks ago, so I don't think it has
yet gone to the 4th.
Publishers are Addison-Wesley, 1989 corrections reprint, ISBN 0-201-08319-1.
--
Viktor Haag ······@mks.com
Mortice Kern Systems (519) 884-8469
35 King North, Waterloo, Ontario ext. 41
"we are not thugs. we are vitamin supplements to justice ..." | a selector
From: Jeff Dalton
Subject: Re: Is lisp easy to learn?
Date:
Message-ID: <7850@skye.ed.ac.uk>
Lisp vs Basic.
There are some good ideas in Basic. One is that it should be
possible to do simple things simply. You may not think Basic
actually accomplishes this, but it was an explicit goal, and
there's at least some evidence for it in the language (no
semicolons after or between statements, the PRINT statement,
FOR ... NEXT vs what you had to do in FORTRAN or Algol 60,
default array bounds so you don't have to know how to DIM,
matrix operations (so the "weather in OZ" markov chain problem
would be easy).
Lisp does pretty well by this criterion, because of default
arguments, automatic storage management, and a defined I/O
form for most data. Common Lisp FORMAT makes output harder
than some of the older methods, though. (Think of the msg
macro in Franz.) On the other hand, the read-eval-print
loop means that you don't have to know anything about the
I/O functions in order to start programming. (Compare this
to the standard 1st C program "Hello, world".)
Moreover, it's very easy to start using CLOS. Strictly speaking,
all you have to learn beyond normal CL is DEFMETHOD.
-- jd
From: Jeff Dalton
Subject: Re: Is lisp easy to learn?
Date:
Message-ID: <7848@skye.ed.ac.uk>
In article <······················@linus.mitre.org> ········@boole.mitre.org (Randy Crawford) writes:
>I have not found Lisp to make sense beyond the trivial examples mentioned
>previously. Understanding the necessity for and use of macros is definitely
>non-trivial. Optimizing Lisp source is a task for only the most experienced
>Lisp hackers (which I infer, having seen only Peter Norvig seriously attempt
>to document the practice). And Lisp is a language that few ever _master_,
>because Common Lisp is almost certainly the largest programming language ever
>devised, and because few programmers ever use it unless they are wealthy or
>have steady access to a large organization which can afford the $500+ in
>software and multiple thousands in hardware necessary for one person to get
>serious in Lisp.
1. It's not too hard to afford a 386/486 PC that will run 386BSD
and hence a wide range of Lisp systems, many small, all free.
The OS is free too.
2. Common Lisp isn't the only Lisp. If you're worried about the
size of the language, there are others to choose from. However,
you can be an effective Common Lisp programmer while using a
fairly small subset of the language.
3. It's not too hard to do some things efficiently. But it's usually
far less clear what's efficient in Lisp than in a language such as
C.
4. Macros shouldn't be that hard. There's certainly a wide range
of macros that are easy to write and understand, because they
correspond so directly to something you can do without macros.
I think many discussions of macros confuse people by explaining
why macros are necessary.
One thing that people learning Lisp often don't know is how to
write readable Lisp. Indentation is very important. The aim is
to make it unnecessary to pay attention to individual parens when
reading. The meaning should be clear from indentation and arity
alone, with paren groups reinforcing a meaning that's already
fairly clear. (By "arity" I mean that EQUAL takes 2 args, etc,
so that something like EQUAL CAR A CAR B is fairly clear w/o
any indentation or parens.)
Try writing some Lisp and taking off the parens. For example:
(defun equal (x y)
(or (eq x y)
(and (consp x)
(consp y)
(equal (car x) (car y))
(equal (cdr x) (cdr y)))))
defun equal x y
or eql x y
and consp x
consp y
equal car x car y
equal cdr x cdr y
The prefix notation wins over infix in many cases. For instance,
and OR tells you that the following expressions will be evaluated
as part of a condition. If the OR were infix, you wouldn't know
this until after the first expression, and it might be difficult
to see the scope of the OR.
Jeff Dalton,
AI Applications Institute, ········@ed.ac.uk
Edinburgh University.
jeff's original prefix version:
defun equal x y
or eql x y
and consp x
consp y
equal car x car y
equal cdr x cdr y
worse than this even:
eql x y or
consp x and
consp y and
car x equal car y and
cdr x equal cdr y
this is gibberish without the parentheses...
-- clint
--
Clint Hyde "Give me a LispM or give me death!" -- anonymous
Advanced Decision Systems/BAH Internet: ·····@chesapeake.ads.com
1953 Gallows Rd, Suite 600
Vienna, VA 22182-3934 (703) 902-7130
From: Jeff Dalton
Subject: Re: Is lisp easy to learn?
Date:
Message-ID: <7876@skye.ed.ac.uk>
In article <··················@pecos.ads.com> ·····@pecos.ads.com (Clinton Hyde) writes:
>
>jeff's original prefix version:
>
> defun equal x y
> or eql x y
> and consp x
> consp y
> equal car x car y
> equal cdr x cdr y
>
>worse than this even:
>
> eql x y or
> consp x and
> consp y and
> car x equal car y and
> cdr x equal cdr y
>
>this is gibberish without the parentheses...
Are you agreeing with me or disagreeing? If the letter, I don't think
you will find Lisp readable no matter what.
Anyway, I can read both versions. I happen to find the first easier.
-- jd
In article <······················@midway.uchicago.edu> I write:
>But (now comes the sacreligeous comment) I don't find Lisp to be the
>easiest language to learn. Basic was easier for me, and dBASE was
>easier still.
> ...
>You may think I've been poisoned by my early experiences--perhaps
>that's so. Doesn't seem that way to me, though.
Since I wrote the above, I started thinking about Friedman and
Felleisen's The Little Lisper, which I read in the last year (and
thoroughly enjoyed). I wonder whether, had my first experience with
programming been through a Lisp book as simple as TLL, if Lisp would
have been as easy for me as dBASE was. It's hard to say--TLL seems
easy, but I already knew Lisp when I read it. Apart from Douglas
Hofstadter's articles on Lisp in his book Metamathemagical Themas, my
introduction to Lisp was Winston and Horn's LISP. I thought
that the early chapters of Winston and Horn were really clear, but they
don't seem to have as basic and thorough of an approach as TLL. And I
remember thinking at the time "Boy, Lisp sure is different from
Basic." That everything was a function, and the way that functions
were used to organize program flow, was so different. Just they way
that code was layed out on the page seemed odd.
All of this is to say that perhaps I was, to a small degree, "poisoned"
by Basic-style languages. I don't know whether Lisp or Basic or
whatever is objectively easier, but at this point I'm thinking that
it's not that important of a question.
Note that Lisp, Basic, and dBASE all usually have interpreters, and
that each has a number of commands that can do interesting things
without any prior code (e.g. in Lisp and Basic you can set a variable
without having first declared it). Also, each language has a fair
amount of built in loose polymorphism, which means that you don't have
to pay very close attention to data types at first. (I'm thinking of
Basic's and dBASE's printing functions, and the fact that a
user-defined Lisp function might accept or return things of arbitrary
type). These seem to me be features that make learning a language
easy at first.
···@nmsu.edu (Classic Ted) writes:
> if you only learned as much of lisp as would be required to do what
> you can do in basic, then lisp would have been easier.
Hmm, maybe. Though I still don't know how to use Lisp to do some of the
file and screen i/o that I know how to do in Basic. Of course, that's
at least partly because I haven't spent much time on that stuff in
Lisp.
Marshall Abrams