Learning Lisp

So /prog/ serious question - I'm honestly just hoping for a good answer. I'm getting more and more interested in Lisp - some people may think the Syntax and the functional concepts suck, but I don't; It's the opposite actually. I think it's really interesting.

Now there are more than one Lisp dialects:
    * ANSI Common Lisp
    * Scheme
    * Arc
Just to name a few I read about while informing myself about Lisp. (Arc seems pretty cool btw.) Would you suggest learning Lisp? I already know Python but am interested in learning more - specifically other programming languages and thought Lisp would be pretty interesting.

I'm just a bit worried about which dialect I should actually learn. I think I'm going to start with ANSI Common Lisp for now (since it's the standard) and maybe take a look at Scheme and Arc afterwards. What would you guys suggest me?

Also is Lisp, or any dialect of it suitable for general-purpose scripting? Basically the things I do with Python:
    * Webscraping
    * Text editing
    * Renaming files
Just to name a few.

I'm starting with Scheme since I am following along with SICP.

When I'm finished with SICP I was thinking about using Common Lisp too, but I'd also like to hear what /prog/ suggest as a good implementation.

SICP is pretty awesome, because you learn shit about compilers and interpreters, which is important for every aspiring computer scientist (if not every programmer). Of course, Scheme isn't terribly useful outside of SICP, and even if all you're doing with Lisp is customizing your .emacs file, you're better off learning Common Lisp so you have a better sense of what mainstream Lisps are like. So, decide between interesting theory and semi-practical experience, and read SICP or Practical Common Lisp, respectively.

>>3
What if I continue reading SICP until I finish, and then I decide to move on to Practical Common Lisp?

>>4
A  that is fine too.

I think lisp-1s are more straightforward to learn before lisp-2s.
Of course, Scheme isn't terribly useful outside of SICP
wut

>>6
YHBT

>>6
It's true. You might even be better off with Haskell, and that's really saying something.

Scheme, Common Lisp, or Clojure. Arc is a joke. There's also NewLisp, an even poorer joke than Arc, and Emacs Lisp, which is a little moldy and best confined to writing programs for Emacs.

>>9
All right, what's the best material for learning Clojure?

>>10
Beats me. Not sure I'd recommend it as a first exposure to Lisp anyway, but it's not a bad language.

How is clisp as a Lisp implementation?

>>12
It's just fine.

>>8
IHBTA ;_;

Also is Lisp, or any dialect of it suitable for general-purpose scripting? Basically the things I do with Python:
* Webscraping
* Text editing
* Renaming files
Just to name a few.

While /prog/ fags with a stick up their ass may bitch about it, newLISP is probably the most useful for those needs.

>>12
It's fine, but not the fastest implementation around, try SBCL if you need more speed.

>>15
newLISP is pretty brain-dead when it comes to macros, and other design choice.

   * Webscraping
There's xml/sgml parsers, web-servers, even http clients with renderers written in Common Lisp, freely available.
   * Text editing
CL's native file processing functions are pretty good, but there's also nice portable libraries for this.
   * Renaming files
CL's native path functions.

I strugly suggest you avoid newLISP until you get to know the 2 main lisps out there: Common Lisp and Scheme.
newLISP may be good for the most trivial scripting, but it's filled with bad design choices which were removed from the early lisps in the '70's (and if you want to implement these ideas that badly, you could easily do it in CL or Scheme in a few lines of code).

clojure is excellent as an introduction to lisp. >>10 is a nigger.

                       //`'''```,
             o        // LISP   `.,
       ,....OOo.   .c;.',,,.'``.,,.`
    .'      ____.,'.//
   / _____  \___/.'
  | / ||  \\---\|
  ||  ||   \\  ||
  co  co    co co

I recommend Croma. Croma's partly an attempt to correct everything I see wrong with CL/Scheme (1 namespace and continuations like Scheme, but all sorts of everday useful stuff snarfed from CL like proper lambda-list keywords and so on). It also sticks in various experimental things: 1st class macros (bad idea, I've since decided). I spent a while re-thinking assignment, and Croma uses a strange new idea of “overloading” the values of data objects: you can add in an additional function value (sort of like CL) that'll be used instead of its value in the _function_ position if it exists, to make possible assignment that's generalised and extendable but also idiomatic.

All of this is geared towards an integrated continuation-based web development system. Using a fairly elaborate standard library, you can do stuff like (link "Click here" (fn (hdrs) (str 'you 'clicked "me")) in the middle of HTML pages. And, of course, it gets rid of HTTP transactional/statelessness cruft, as has been documented by Graham and Queinnec.

Croma's not quite in a world-useable state, but it's getting there. I'll GPL it as soon as I think others might find it useful, anyway.

>>19
I'm aware that this is copy-pasta, but I don't see how his description implies a single namespace (Lisp-1), it sounds like a generalized Lisp-n to me. At the same time, CL being a Lisp-2, can behave like a Lisp-n because of proplists.

All of this is geared towards an integrated continuation-based web development system.
I'm amazed by how many such projects have appeared in the past few years.

I wonder if CROMA will ever be released, but the choice of a GPL license is strange in the Lisp world, public domain, BSD or LLGPL(weak LGPL which allows static linking) are much better choices for Lisp as simply stating GPL, means that all code that uses your implementation (links to it in a core image) needs to be GPLed too. This makes it incompatible with many other free licenses, not to mention commercial ones.

newLISP may be good for the most trivial scripting

You say that like any Lisp has ever been used for something more.

>>21
Maybe you only use it for that or think people are using for that.
IHBT

Scheme is also standard, take a look at RNRS (replace N with standard version). There's a ratifying process going on that plans to radically reform and dichotome scheme. Arc is not standard and I don't recommend it to learn lisp - arc is still experimental, and should be used for experimenting purposes only. The dialect doesn't really matter, but you'll probably end up learning scheme or common lisp. /prog/ people talk a lot about SICP, but there's a list of excellent books using lisp that simply can't be ignored. You might also notice the scheme and the CL school of programming, which are both a product of the fundamentals differentiating the languages describing them -- and these are arbitrary (or at least more than two) -- some named, some unnamed (see zetalisp, Le-Lisp et&).

Also is Lisp, or any dialect of it suitable for general-purpose scripting? Basically the things I do with Python:
Not all dialects are shaped with general-purpose scripting in mind. It might be possible, but crudy. Elisp isn't general purpose for instance, its purpose is provide tools for text editing, which brings me to the second item in your task list. In common lisp and scheme you can rename files; I'm not sure what webscraping is.

Also is Lisp, or any dialect of it suitable for general-purpose scripting?

While /prog/ fags with a stick up their ass may^₁ bitch^₂ about^₃ it, newLISP is probably the most useful for those needs.

______________________
1.
newLISP is pretty brain-dead when it comes to macros, and other design choice
2.
I strugly suggest you avoid newLISP
3.
newLISP may be good for the most trivial scripting