I have learned the very basics of Lisp. It is in my opinion a weird
language. It uses strange named operators (car...) and lots of (() ).
I am left witha very superficial look at what appears to be a retro
language, a throwback to a time when computers were the size of
buildings. It is hard to think in Lisp or what I can use it for.

I can not imagine why I should keep trying to program in this language when I have
better, easier modern languages with a cleaner syntax and operators with
names that make sense to me. SO far everything I understand I can do in
Lisp I can just as well do in another language I know. I know not the
ways of Lisp or what it is about that has enabled it survive this long.

So far the only thing I have learned to do with Lisp is make a stack
using a very strange syntax. I could easily code this same problem in
Python or C or Java much faster and easier to read (to me).

What oh what makes Lisp or Scheme useful? Are they just hacker languages
that a hacker must know to be accepted by the hacker community? Or is
there really something about Lisp (or Scheme) that makes them stand apart
from the easier (IMO) to understand languages like Python, Java or C/C++?

How has Lisp survived through the years? I have come across many many
computer languages in my studies, and the majority of them died before
they were even conceived. Yet Lisp, Fortran, and C survived. I know C and
Fortran. They are not too hard to understand. But Lisp is IMO very hard to
understand (first, everything is literally backwards in it...).

I would like to learn how to program in Lisp, so I can appreciate
something of the history of Computer Science. I am also interested
in understanding Lisp, because I have read that it teaches you to think
about problems recursively. But I am still struggling to figure out how
to write an interesting program in the language.

If you can explain to a neophyte Computer Scientist why learning to code
in Lisp will enlighten me and will be worth the pain of getting
acquainted with it, I'd like to know!

Also are there any free e-books on programming in Lisp or Scheme?
Are there any places I can get Lisp (or Scheme) code so I can look at to
learn how to think in these languages?

I am still interested in the way of Lisp and Scheme so I am not closed to
learning about it. But my only experience with it is a funny taste. It is
completely opposite of how I think and I can not think at all in this
language. I just stare at the clisp prompt wondering what I should do
next. I can write simple programs that process a list, but it is a toy.
There must be more to it than just making toys.

hehe.

Most people here won't agree with you that other (more "modern")
languages are better than Lisp. Maybe they seem easier to learn, yes,
but it's also easier to drive a Toyota than to drive a Ferrari.

You might want to read a text that another Lisp newbie has written
some days ago. It also includes some useful links for further reading
at the end:

  <http://www.cs.uni-bonn.de/~costanza/lisp/guide.html>

Now this is the kind of statement that makes me interested in Lisp! Why
is it considered a Ferrari? It looks like a VW beetle when I play with
it.

Where do I find the archives and other ****modern**** resources on
Lisp that will help me in my understanding of why Lisp is cool!

Take a look at Document -> "Common Lisp, Typing and Mathematics".

--
Regards,
Alexey Dejneka

personally I still feel that room for improvement exists (though I can not
argue that mine is any better...). mine at present, like scheme, still
holds the ideal of keeping the core language small and consistent.
my idea is to try to develop an effective module system and try to promote
this as a major means of extending the language. unlike modules in many
other languages, the ones in mine are also conceptually capable of
extending/altering the syntax as well (though this has yet to be
specified...).

from experience it seems though that very few people are actually willing
to contribute ideas though. a problem is that language design leaves
problems in that there may be plenty of issues for which I am not aware,
and language design pushes my language knowlege limits at present...

see http://www.paulgraham.com/onlisp.html

Also see http://www.norvig.com

When I started to learn Lisp, I started very simply, simple interactions with the Lisp
Listener, stuff like (+ 3 4), (list 1 2 3 4).  I worked through my text's chapters
systematically, doing all the examples, until I understood the the simple syntax of what I
was doing.  Doing it this way with no preconceived notions of what is "right" allows the
brain to catch on to what is going on.  Its like learning a foreign language, it just
looks like nonsense at the beginning, but then suddenly you begin to see letters, then
words and then sentences.  But you have to give yourself time to understand, it does not
happen instantly (especially when one is used to C-like-syntax languages).

And get the Hyperspec
http://www.lispworks.com/reference/HyperSpec/index.html

  Do /not/ feed the trolls.

--
Erik Naggum, Oslo, Norway

The other thing is that you can do `cadr', `caar' and so on.  Some
people hate this but I think it's kind of neat.

If you are unhappy with prefix --- that is, the way lisp does (+ 2 3)
as opposed to 2 + 3 --- then I can only say that you'll get used to
it, and you'll be happy when you find yourself doing (+ 2 3 4 5) or
(= x y z) or things like that.

Lisp uses a `regular' syntax, with parentheses as its primary
structure-creating mechanism.  For this reason, it's easy to read
Lisp.  You always know what's going on.  Almost all the semantics is
pushed into named operators.

For example, instead of

   a[4]

you say

   (aref a 4)

Instead of

   for(i = 0; i < 5; i++) {
     ...do something....
   }

you say

   (dotimes (i 5)
     (...do something))

Note in the examples from C you see braces, brackets, semicolons and
parentheses to indicate structure of one kind or another.  In Lisp you
see parentheses.  (Lisp programs are `line noise free zones'!)

(defvar *my-stack* nil)

(push 3 *my-stack*)
(push 4 *my-stack*)
(push 12 *my-stack*)
(push 7 *my-stack*)

(pop *my-stack*)
(pop *my-stack*)

(etc.)

Of course, this isn't an `information-hiding' version of a stack, but
it's easy enough to do that in Lisp too using closures.

(let ((my-stack nil))
  (defun my-push (e)
    (push e my-stack))

  (defun my-pop ()
    (if my-stack
        (pop my-stack)
        (error "Stack empty!"))))

An example of language-induced complexity that someone posted in this
newsgroup some time ago can be found in the following paper:

   http://www.oonumerics.org/tmpw00/eisenecker.html

I am not sure I understand this paper, but it seems to me that in Lisp
the problem doesn't arise at all.

For example, here's my Lisp code that does what I think they were
trying to do in the paper:

;;;;

(defclass customer ()
 ((first-name :initarg :first-name)
  (last-name :initarg :last-name)))

(defmethod print-it ((cust customer))
  (with-slots (first-name last-name) cust
      (format t "~&First name: ~A~%Last name: ~A~%" first-name last-name)))

(defclass phone-contact (customer)
  ((phone-number :initarg :phone-number)))

(defmethod print-it ((phone phone-contact))
  (with-slots (phone-number) phone
    (call-next-method)
    (format t "~&Phone number: ~A~%" phone-number)))

(defclass email-contact (customer)
  ((email-address :initarg :email-address)))

(defmethod print-it ((email email-contact))
  (with-slots (email-address) email
    (call-next-method)
    (format t "~&Email address: ~A~%" email-address)))

(defclass postal-address (customer)
  ((postal-address :initarg :postal-address)))

(defmethod print-it ((address postal-address))
  (with-slots (postal-address) address
    (call-next-method)
    (format t "~&Postal address: ~A~%" postal-address)))

(defclass customer-info (phone-contact email-contact postal-address)
   ())

(setf *my-info*
  (make-instance 'customer-info
                 :first-name "Foo" :last-name "Bar"
                 :phone-number "555-1212"
                 :email-address "f...@bar.com"
                 :postal-address "1234 Main. St. Anytown, CA"))

(print-it *my-info*)

;;;

It all works as it is.  (I think I'd write it a little differently,
though.)

The working code at the end of the paper contains a lot of extra
mechanism and complexity, and I claim that this is all
language-induced, that is, necessary to work around shortcomings in
the language.

To put it somewhat hyperbolically, Lisp lets you solve problems, while
other languages let you solve problems AFTER you've solved the
problems presented by using that language in the first place.

One thing to realize.  If Lisp is really snake-oil, it will seem weird
and quirky because it is just a collection of poorly thought-out hacks
and frauds.  But if Lisp really is a serious alternative, it will also
seem weird and quirky because it doesn't follow various fundamental
assumptions about how things must be done.  That's the very thing that
makes it a serious alternative.

The only way to find out which is true (snake oil or serious
alternative) is to take Lisp on its own terms, and NOT impose those
fundamental assumptions on it.  Don't expect anything in Lisp to work
the way it does in any other language and you'll get it faster.

You should go back to one of those programming languages that you cited; these
will give you enough impedance so that you can push against them and dissipate
your energy to create the feeling that you are accomplishing something.

C is great for this; you can start with no idea at all, and starting writing
thousands of lines of supporting code in hopes that the idea will materialize
in the meanwhile.

It is really painful to read "cadaverous" code; not unlike fiddling
with assembler, or FORTH code that's full of ROT, -ROT, SWAP, and
ROLL.

If you're using Lisp _well_, you'll have a nice set of defuns,
defmethods, perhaps some macros, and such, that make it largely
unnecessary to fill your code with rubbish looking like
   (cons (cdddadar a) (cddar (car b)))

When I finish working on some Lisp code, I usually do a read through
it to see where there are references to CAR and CDR, with a view to
seeing if they couldn't be replaced with something a little more
elegant.

(do ((i 0 (incf i)))
    ((= i 5))
  (format t "Value: ~A~%" i))

It's pretty likely that the introductory texts on Lisp mention DO, and
say little, if anything, about the other alternatives.  The only place
I _ever_ use DO is if I'm building an iteration macro, and even _that_
is rare.  DO is almost perfectly analagous to the C "for(;;) {}" loop,
with the difference that the order of the three statements changes a
bit.

(do ((variable initial-value update-form))
    (termination-test)
    (body-of-loop))

The only piece of that which is expressly identified as what it is is
the DO at the start.  And I downright _hate_ looking at DO loops,
pretty much as a result of that.

One thing that I kind of like about the syntax of ML is that it puts
fairly sensible names to the pieces.

The similarly-not-overly-obvious LET statement
(let ((a b) (c d)) (foo a) (bar c))
in ML would look something like:

let
   a = b and
   c = d
 in
   foo(a);
   bar(c);

if I write a compiler will this topic be more acceptable?...

if you are artistic, write programs that are artistic (and produce art,
bonus!).

if you rage against the machine, write simulation programs, and build a
better society.

if you are lazy, write screensavers.

if you are curious, write virii.

if you are a slave, convince your fellows that lisp is no good and talk
amongst yourselves.

if you are kind, learn what you can learn and teach what you can teach.

if you are whiny, write programs that filter spam (please).

if you want to cash in on the programming "profession", hire lisp
programmers and give them some slack.

--
Thomas.

no one in comp.lang.misc seemed to care either when I had posted there.

  Why does it matter to you whether people on Usenet care?  Usenet is a good
  place to people who already care about the same things; they congregate in
  newsgroups according to what they care about.  When people in a newsgroup do
  not care about what you care about, they are extremely unlikely to /start/ if
  you somehow imply that they /ought/ to.

  If you feel that people /should/ care about what you care about, you have only
  set out to become a nuisance to others in their eyes.  They will want you to
  go away more than anything else.  If even this conducive to your personal
  needs, you should really talk to someone who already cares about /you/.

--
Erik Naggum, Oslo, Norway

I am just experiencing a problem in learning a new language. You could
imagine that I am fluent in a certain type of language. Lisp and Scheme
are a very different type of language.

I can not see in my mind how to translate my ideas from my native tongue
to my new language. All I can do in my new language is make toys. While
that is an interesting career, I want to build rocket ships.

I can build rocket ships in my native tongue (C). Translating my rocket
ship into Lisp results in a broken machine. I am missing doors, windows,
glass, steering controls, landing gear, wings, and fuel. I have a
complete toolbox in C. In Lisp, I just have a screwdriver.

That is my frustration with Lisp so far. I can build rockets. But in Lisp
I am starting all over again. It is sort of intimidating. I am actually
kind of interested in the challenge. But I need a guide to teach me.
I just can't find a guide. It would be nice if there was a Lisp for C
programmers book around.

That's why I am griping. It's not that I think Lisp sucks. It is that I
can not communicate in it at all. I am a stranger in a strange land in
Lisp.

in life I have no freinds, and I am alone. I guess I wanted people to talk
to about something so that I am not in more isolation...

before I could talk to my ex about stuff, then she left me. since then I
have made little progress on anything, everything now seems to be in the
past. I still do not really understand why she left, just at the end she
said she did not care about me anymore. that was 2 months ago...

all my life has been like that, people get bored with me then they leave.
everyone else avoids me altogether...
being online has been an attempt to escape that, hoping somewhere somehow
what I said would mean something. due to my lack of productivity this is
too large of a goal, thus I continue to be worthless...