
So you've read SICP, now what? - youdontknowtho
Perennial Lisp newb question...
SICP used a scheme dialect. How big of a difference is there really between Common LISP and scheme? Which would be the better place to start if building apps for other people to use?
======
davelnewton
How "big" a difference? I'm not sure how to quantify those differences. I'd
probably just search the web for the differences then decide for yourself if
you think they're "big" differences. The _mindset_ is the same (for me).

For building apps it's hard to say. Depends on who/what you want to target,
really, what platform support you need, and so on.

------
brudgers
[Differences]

In so far as the differences are tiny the fights between their proponents
vicious.

To _me_ , the difference between MIT Scheme (the dialect in SICP) and ANSI
Common Lisp (what 'Common Lisp means these days) is, in some ways a Turing
Tarpit. Common Lisp is a _big_ language and has explicitly defined procedures
to perform many ordinary type tasks and domain specific languages for loops
and formatting text all built in. It was built by consensus on top of existing
commercial implementations and rolled many vendor specific features into the
spec -- some for compatibility, some because they were good ideas, some
because the group defining the language had to pick something.

Scheme is a 'small' language and it's smallness is at least in part motivated
by the pedagogical purpose of which SICP is an artifact. Unlike Common Lisp,
procedures for many ordinary tasks are external in the standard libraries
(plural) and to me, the standard libraries reflect the same philosophy that
led to their creation...just as they exist to keep some useful constructs out
of the language, the resist inclusion of other useful constructs. For example,
standard Scheme does not include `(while...)` nor do its libraries. Everyone
gets to write their own macro.

The different origin stories explain a lot of the difference. Common Lisp was
created by and for working programmers and done while those programmers were
working. Industry was involved...Steele's _Common Lisp: The Language_ was
published by Digital Equipment Corporation (DEC) press. Scheme grew out of
academic AI research at MIT.

Recently, I've been thinking that the big difference between Common Lisp and
Scheme and pretty much every other programming language comes from its
concurrent development with Lisp Machines. The hardware abstraction of the
programming language means that there is no programmer/user dichotomy. Common
Lisp just has users and they are users in the same sense as Windows users or
OSX users.

In terms of language design, this created a context where telling the user to
type

    
    
      (rename-file #P"foo" #P"bar")
    

For the same reasons a user might be instructed to click on the start menu or
the trashcan icon or File->New. The high bit of typing s-expressions in Common
Lisp's design is not writing programs, it's using a computer. The parallel is
the high bit of s-expressions in Emacs Lisp is editing text.

[Now what]

1\. Probably the simplest step from SICP toward writing applications is the
Racket ecosystem. It is robust and well documented and well maintained and
_beginner friendly._

2\. The second set of alternatives are Clojure or ClojureScript. They are less
beginner friendly and are harder to learn without a background in the
underlying platforms (JVM and the browser).

3\. Common Lisp would be my third choice as a recommendation for developing
applications. It's the least newbie friendly of the three and the ecosystem of
widgets and add-ons is harder to navigate: partly because age means that there
is obsolescent advice and abandoned tooling, partly because it is a mix of
commercial and open source projects (and therefore the default is very often,
if you want it open your wallet), and partly because it is from the age when
Read the Manual was the answer to everything except an actual bug [but see
item 4].

4\. Common Lisp would be my first recommendation for what to _learn_ next.
Partly because the RTM age produced really good manuals. _Common Lisp: The
Language_ is very readable while still being a specification. Partly because
the best book on programming I've read is Norvig's _Paradigms of Artificial
Intelligence: Case Studies in Common Lisp_...someone said it was, I picked up
a copy and they were write.

Another reason to learn Common Lisp is as a stepping stone to Clojure.
Although nobody says it because it would be horrible for marketing,
understanding Common Lisp is necessary for really understanding why Clojure is
the way it is: Leiningen is just another system definition facility, the high
bit of the REPL is using a computer not programming one, and probably a number
of things I have thought of yet.

Good luck.

