Hello.
Firstly, I'll explain my (short) computing background, and intent:
� have only used Windows(XP), and like it
� have been coding JScript for a couple of years, to a point where
learning a programming language seems worthwhile (Lisp looks great)
� this will always be 'just for fun', though I have an aspiration for
complete knowledge, and enjoy collaborating
Secondly, I've researched the following questions (perpetually), so a
FAQ referral may not help.
1. Which Win-compatible implementations are (the most)
standard-compliant?
2. Is a syntax-aware IDE absolutely essential? (I'd rather use
Notepad, at least in the beginning.)
3. Is source code interpretted/executed--when its containing file is
run (and if not how exactly does that work)?
I hope those seem somewhat reasonable (yeah, the 'standards thing'
might sound silly, but I suppose that would allow for distinguishing
my mistakes from non-implemented stuff).
If possible, I'd like to consult the HyperSpec, write some code, save
it, run it, see the result, and build upon that experience.
Well, that's what I'm currently accustomed to, and it would be nice to
keep it as such--in order to introduce myself to the language, alone.
There's no hurry; its just a matter of simplicity, for starters (and
I'd rather not install every applicable demo/WIP to find out).
·········@yahoo.com (neofibril) writes:
> � have only used Windows(XP), and like it
How sad. :) But then I'm a Mac fan, what else can I say?
> � have been coding JScript for a couple of years, to a point where
> learning a programming language seems worthwhile (Lisp looks great)
That would be an interesting development direction. On the one hand,
JScript (and JavaScript) are both interpreted and don't require strong
typing, so there are some similarities with Lisp environments.
Lisp is a really nice language to get started on, although it is quite
different in numerous ways from the syntax and also semantics of other
more popular languages. It does give you a lot of freedom and the
ability to try a number of different ideas out.
> � this will always be 'just for fun', though I have an aspiration for
> complete knowledge, and enjoy collaborating
As a 'just for fun' and learning experience, you might also want to
consider looking at Scheme in conjunction with Abelson & Sussman's
_Structure and Interpretation of Programming Languages_ It's a fabulous
look at a lot of very interesting issues in programming and computation.
(Disclaimer: I know both Abelson & Sussman, and they did a great job on
this book)
Scheme, as you probably know, is in the general Lisp family of languages
but was designed primarily with simplicity, consistency and ease of
teaching in mind, rather than tools and support for industrial
programming.
> Secondly, I've researched the following questions (perpetually), so a
> FAQ referral may not help.
>
> 1. Which Win-compatible implementations are (the most)
> standard-compliant?
Can't really help here. For learning, though, you might be able to use
something like LispWork's Personal Edition or Franz' free trial edition.
> 2. Is a syntax-aware IDE absolutely essential? (I'd rather use
> Notepad, at least in the beginning.)
Yes. It will help you past one of the greatest initial barriers to
language acceptance, which is proper management of parentheses. Also, a
good IDE will automatically indent your code for you, which helps
highlight the structure. Getting your code to indent properly helps you
with mastering the Lisp syntax, and it also makes it easier to
communicate with other Lisp programmers, such as those who frequent this
list. Having programs that "look like" Lisp code makes it a lot easier
for people to read, and also aids your own understanding of what is
going on.
My personal recommendation would be to bite the bullet and learn to use
Emacs. It has very good support for Lisp editting, and can also connect
to lisp systems for compiling and running code. Working with Lisp via
an Emacs buffer also makes it a lot easier to repeat things and go back
to retry (with modifications) earlier work.
> 3. Is source code interpretted/executed--when its containing file is
> run (and if not how exactly does that work)?
This is one of the really tricky issues to answer briefly.
Lisp systems typically come with something called a "Listener" or
"Read-Eval-Print" loop. Generally when you start up a Lisp system, you
are greeted with a prompt. At that point you can just type lisp
expressions which will be executed, usually via an interpreter.
That is really great for experimenting and learning the language,
because you can try things out in small pieces without having to go
through the hassle of building an entire program. You can type
expressions or call functions interactively, which greatly speeds up
learning (and later code development).
If you have code residing in a file, then you can load the file. That
will cause any definitions in the file to become present in your lisp
environment. Any function calls will be executed. (You can also
compile the file first if you wish.) Generally, though, you will find
that you do most of your work from the top-level listener.
> I hope those seem somewhat reasonable (yeah, the 'standards thing'
> might sound silly, but I suppose that would allow for distinguishing
> my mistakes from non-implemented stuff).
>
> If possible, I'd like to consult the HyperSpec, write some code, save
> it, run it, see the result, and build upon that experience.
Well, I wouldn't start with the HyperSpec. It is a language
specification document and is not designed at all as a tutorial. If you
want a reference-type of document, I find Guy Steele's _Common Lisp: The
Language_ a more accessible document. It isn't strictly the standard,
but I find it more useful.
But that wouldn't be my first recommendation. Instead, I would look for
something more along the lines of a tutorial work. I've heard good
things about Paul Graham's _On Lisp_ and there are likely other
candidates in the FAQ.
A really good book to get, though, would be Peter Norvig's _Paradigms of
Artificial Intelligence Programming: Case Studies in Common Lisp_. It
contains a short introduction to the Common Lisp language. I always try
to use this when I have to introduce students here to Lisp, since it is
a nice, condensed introduction. Unfortunately, it is sometimes a bit
too terse, and not everyone has done well starting with it. Sometimes a
little bit more of a tutorial approach is needed. If you are up to
learning a language by reading it's ANSI spec, then perhaps this would
be a good starting point. The other benefit of this book, is that it
soon goes beyond basic Common Lisp to introduce you to a number of
rather neat programming techniques used in AI.
--
Thomas A. Russ, USC/Information Sciences Institute
Thomas A. Russ <···@sevak.isi.edu> wrote:
> But that wouldn't be my first recommendation. Instead, I would look for
> something more along the lines of a tutorial work. I've heard good
> things about Paul Graham's _On Lisp_ and there are likely other
> candidates in the FAQ.
Well, yeah. On Lisp is nice, but _not_ as a first book. It gives you a
totally skewed picture of Lisp if you don't have some experience under
your belt when you read it. As second, third, or even fourth book it's
good.
> A really good book to get, though, would be Peter Norvig's _Paradigms of
> Artificial Intelligence Programming: Case Studies in Common Lisp_. It
Seconded. PAIP is very good. It's not strictly a tutorial either, but
Norvig's style is very nice, and the book is eminently readable.
Paul Graham's ANSI Common Lisp is decent, but make sure it's not the only
book you read: his style isn't typical and he skips some important (and
common) topics out of personal preference. Nonetheless a good start.
Yet another one is in works by Peter Seibel, called "Practical Common
Lisp". Google for preview: higly recommended. (If wish this had been my
first CL book.)
Cheers,
-- Nikodemus "Not as clumsy or random as a C++ or Java.
An elegant weapon for a more civilized time."
·········@random-state.net writes:
> Thomas A. Russ <···@sevak.isi.edu> wrote:
[snip]
> Yet another one is in works by Peter Seibel, called "Practical Common
> Lisp". Google for preview: higly recommended. (If wish this had been my
> first CL book.)
Wow, thanks! For the OP, the work in progress is available on the web
at:
<http://www.gigamonkeys.com/book/>
I'm soliciting any and all feedback at this point on the chapters
marked "Ready for review".
-Peter
--
Peter Seibel ·····@javamonkey.com
Lisp is the red pill. -- John Fraser, comp.lang.lisp
neofibril wrote:
> Hello.
>
> Firstly, I'll explain my (short) computing background, and intent:
>
> � have only used Windows(XP), and like it
>
> � have been coding JScript for a couple of years, to a point where
> learning a programming language seems worthwhile (Lisp looks great)
>
> � this will always be 'just for fun', though I have an aspiration for
> complete knowledge, and enjoy collaborating
>
>
> Secondly, I've researched the following questions (perpetually), so a
> FAQ referral may not help.
>
> 1. Which Win-compatible implementations are (the most)
> standard-compliant?
AllegroCL and Lispworks. Free trials available for both. I like
AllegroCL, others swear by Lispworks (and CLisp and CormanCL).
>
> 2. Is a syntax-aware IDE absolutely essential? (I'd rather use
> Notepad, at least in the beginning.)
Notepad will drive you mad within minutes. Both AllegroCL, Lispworks,
and Corman include integrated editors.
>
> 3. Is source code interpretted/executed--when its containing file is
> run (and if not how exactly does that work)?
It varies between implementations. Some only compile then run that, even
when you just enter (+ 2 2) interactively. (Done transparently so it
feels like an interpreter.) Most offer several ways to run code,
including compile then load then kick off some function or other
interactively. AllegroCL includes a project manager to which you
identify your test function and any files needed, and can automatically
save, re-compile/load, and then kick off the "main" function given one
key combo. That's sweet once you have several files open and you are
hacking them randomly.
>
>
> I hope those seem somewhat reasonable (yeah, the 'standards thing'
> might sound silly, but I suppose that would allow for distinguishing
> my mistakes from non-implemented stuff).
>
> If possible, I'd like to consult the HyperSpec
F1 on any Lisp term will take you to the CLHS in AllegroCL. I cannot
speak for other tools.
kenny
--
Cells? Cello? Celtik?: http://www.common-lisp.net/project/cells/
Why Lisp? http://alu.cliki.net/RtL%20Highlight%20Film
·········@yahoo.com (neofibril) writes:
> 1. Which Win-compatible implementations are (the most)
> standard-compliant?
I'd advise you tu use clisp on MS-Windows. http://clisp.cons.org
(just remember to always use the -ansi option).
> 2. Is a syntax-aware IDE absolutely essential? (I'd rather use
> Notepad, at least in the beginning.)
No, but you can also go to work with a bullet attached to your left
leg. It works too.
When you'll be fed up with counting parens, switch to emacs:
http://www.gnu.org/software/emacs/windows/
> 3. Is source code interpretted/executed--when its containing file is
> run (and if not how exactly does that work)?
Depending on the implementation and/or options, either.
In the case of clisp, you can pass the -C option when loading a file
to have it compiled before executed. Or you can explicitely compile a
file before loading:
(load (compile "test.lisp"))
instead of:
(load "test.lisp")
But compilation is only a very late stage optimization. You only do
that when you're ready to ship an application to speed-hungry
customers.
As a programmer, you're target should be a correct (bug-free)
program. In this, details such as interpretation or compilation play
no role.
> I hope those seem somewhat reasonable (yeah, the 'standards thing'
> might sound silly, but I suppose that would allow for distinguishing
> my mistakes from non-implemented stuff).
>
> If possible, I'd like to consult the HyperSpec, write some code, save
> it, run it, see the result, and build upon that experience.
With lisp it's even better than that:
Write some code, press RETURN, see the result, build upon that.
WHEN it WORKS, copy and paste the CORRECT code to a file and save it.
(of course, it's even easier to do from emacs).
> Well, that's what I'm currently accustomed to, and it would be nice to
> keep it as such--in order to introduce myself to the language, alone.
>
> There's no hurry; its just a matter of simplicity, for starters (and
> I'd rather not install every applicable demo/WIP to find out).
--
__Pascal Bourguignon__ http://www.informatimago.com/
There is no worse tyranny than to force a man to pay for what he does not
want merely because you think it would be good for him. -- Robert Heinlein
·········@yahoo.com (neofibril) wrote in message news:<···························@posting.google.com>...
> Hello.
>
> Firstly, I'll explain my (short) computing background, and intent:
>
> ? have only used Windows(XP), and like it
Just a suggestion, but try Linux out sometime. Don't restrict yourself
to one OS.
>
> ? have been coding JScript for a couple of years, to a point where
> learning a programming language seems worthwhile (Lisp looks great)
>
> ? this will always be 'just for fun', though I have an aspiration for
> complete knowledge, and enjoy collaborating
>
>
> Secondly, I've researched the following questions (perpetually), so a
> FAQ referral may not help.
>
> 1. Which Win-compatible implementations are (the most)
> standard-compliant?
As Kenny said Allegro CL and LispWorks are both great. I prefer
Allegro for Windows (what little I use it) my self. Get a good
textbook to learn from as well, I found that this helps me. (I'm still
a newbie to Lisp)
> 2. Is a syntax-aware IDE absolutely essential? (I'd rather use
> Notepad, at least in the beginning.)
Uh, no you wouldn't trust me on this one. You are going to want a
syntax aware editor. Emacs is probably the best option, although I do
like Allegro's built-in editor as well.
>
> 3. Is source code interpretted/executed--when its containing file is
> run (and if not how exactly does that work)?
Not exactly. Lisp is interactive, so you can type something into
top-level and see the results in real-time. That's real nice, cause
you can test stuff out before putting it in your program. Lisp also
has an interactive debugger, which is quite nice as well. For instance
I can do:
(defun foo (args)
(do_stuff_with_args))
and top-level, as soon as I close all parans will reply:
FOO
You can then test the function out some more.
>
>
> I hope those seem somewhat reasonable (yeah, the 'standards thing'
> might sound silly, but I suppose that would allow for distinguishing
> my mistakes from non-implemented stuff).
Hmm not 100% sure what you mean here. CL is a standerd in itself hence
the "Common".
I strongly recommend you purchase the book, "ANSCI Common Lisp" by
Paul Graham. It's the definitive guide I guess you could say. As well
as the HyperSpec, if you have IRC, you might want to check out #lisp
on freenode.net
Well good luck, these were a few things that I found helped me out in
the first few months of learning Lisp. One last thing: don't expect to
know all there is to know about Lisp in a few months or weeks, it
doesn't happen. As far as I can tell, Lisp may well take a few years
to master well.
>
> If possible, I'd like to consult the HyperSpec, write some code, save
> it, run it, see the result, and build upon that experience.
That's a good start. The HyperSpec can be hard to understand from time
to time, that's why I recommend a textbook.
> Well, that's what I'm currently accustomed to, and it would be nice to
> keep it as such--in order to introduce myself to the language, alone.
>
> There's no hurry; its just a matter of simplicity, for starters (and
> I'd rather not install every applicable demo/WIP to find out).
Hope this helps. Good luck, and have fun.
--
May the Source be with you.
neo88 (Philip Haddad)