

Ask HN:  What makes Lisp hard to learn? - francoisdevlin

I'm interested in producing educational material on how to use a LISP.  What are the major pain points on the learning curve for everyone?  Specifically, what's tough to get coming from a Java or C# background?<p>Share your stories!
======
pchristensen
The hardest thing is the lack of a "batteries included" standard package.
There are competing implementations (which all have strengths and weaknesses)
and lots of libraries (many of which are good, few of which are widely
accepted as "standard").

The short answer is to setup SBCL and Slime/Emacs (here's a guide I wrote:
[http://www.pchristensen.com/blog/articles/installing-sbcl-
em...](http://www.pchristensen.com/blog/articles/installing-sbcl-emacs-and-
slime-on-windows-xp/) )

A previous discussion on learning Lisp:
<http://news.ycombinator.com/item?id=125766>

Plus another article I wrote: <http://www.pchristensen.com/blog/articles/how-
to-learn-lisp/>

Additional resources:

SLIME/Emacs cheat sheet: [http://www.pchristensen.com/blog/articles/public-
beta-open-f...](http://www.pchristensen.com/blog/articles/public-beta-open-
for-ultimate-n00b-slimeemacs-cheat-sheet/)

Watch the SLIME movie (<http://www.guba.com/watch/3000054867> ) and read my
notes on it ([http://www.pchristensen.com/blog/articles/reference-for-
the-...](http://www.pchristensen.com/blog/articles/reference-for-the-
slimelispemacs-screencast/) )

EDIT: To avoid the setup hassle entirely, try Thnake
(<http://jasonfruit.com/thnake/> ) - a Linux liveCD with SBCL/SLIME/emacs
preconfigured, complete with webserver and gui packages.

~~~
dpritchett
I note that the poster described _a_ Lisp and not specifically Common Lisp.
Clojure at least has plenty of batteries available via its Java
interoperability. The biggest thing holding Clojure back at the moment appear
to be installation, building other people's projects, and IDE setup.

I don't know if Clojure is a helpful suggestion to the OP but it is certainly
a more appealing way for me to get into Lisp than Common Lisp was.

 _Edit:_ I have just recently completed the install/build/IDE trifecta myself
thanks to ELPA and leiningen but it certainly wasn't a one-day process. One of
my biggest problems was reading out of date tutorials rather than the latest
and greatest. It can be hard for a newcomer to see a HOWTO blog post from mid
2009 and decide whether or not to try it out.

~~~
pchristensen
I can do an SBCL/emacs/SLIME setup in 15 minutes or so, but I've done it a
bunch of times. Someone following my guides can do it in ~1 hour.

I'd love to try out clojure, but I want to type something like 'sudo apt-get
install clojure-sandbox'.

~~~
regularfry
Leiningen actually isn't that far from being exactly that. It's not a one-
liner, but setting up a scratch project that'll give you a repl is very
straightforward. Setting up swank is only _slightly_ less simple because
you've got to edit a config file. It can be difficult to figure out the right
incantation for that because the docs are pretty nonexistent, but google is
helpful enough there.

------
conanite
For me, coming from java, macros and closures were the two concepts that were
completely alien and made a huge difference. Java provides a lot of structure
(packages, classes, interfaces) that result in a lot of reassuring boilerplate
code. If you're using lisp for conciseness, there is no boilerplate to comfort
you, to signal where you are and what you should be doing at this point in the
code.

------
hga
Hmmm, I started learning it in 1979 (sic) when my major experience was
FORTRAN, BASIC, and an obscure language called PPL who's major features I
hadn't taken advantage of (it was for a summer class). I'd toyed with/looked
at COBOL, PL/1 and C.

The biggest thing, I think, is that it's based on expressions rather than
statements, which is rather a different model than the Algol family (more or
less) languages mentioned above. And for me, learning the importance of
indentation for code comprehension, but that had already started with my
learning C.

And then there's recursion; you can't do idiomatic LISP without it ( _The
Little Lisper_ or nowadays _Schemer_ is good for that).

Ideally you'll also learn functional programming; optional in Common Lisp,
hard to avoid in Scheme, and there's little point in using Clojure without it.

Frankly, I find it delightfully simple. The conceptual base is small, the
syntax of parens, atoms, immediates (e.g. numbers) and special forms (e.g. if)
makes is a very regular language, no "cancer of the semi-colon.

It's really quite nifty, and of course back then there was pretty much nothing
faster with which to develop software. You mostly just have to unlearn some
stuff and be willing to put in some effort, which will be well rewarded.

------
hernan7
I come from a C/Unix shell/Perl background mostly (with a sprinkling of Java).
The main stumbling blocks that I found were:

1) oddly-named functions -- rplaca, cadaddaddr and the like

2) weird "macho" indentation -- more so than the much-maligned parens. I found
that at some points of The Little Lisper, I needed a ruler to make sense of
the indentation level. I have hopes that the default 4-column indentation in
Clojure will make it much easier for me to learn.

3) strange control flow constructs. Trying to make sense where the condition,
if and else clauses begin and end in an "if" can be a pain. More so for "cond"
or "do". Combine that with 2), and things become unreadable quite fast.

By the way, none of these would be a showstopper if I had to learn Lisp for
work or college. Just that, they made it not worth my time to try to learn it
for fun.

Edit: I forgot, tail-call recursion. A single misstep and your CPU and memory
footprint go from constant to exponential and/or Ackermaniac.

