WHY LISP SHOULD BE FIRST PROGRAMMING LANGUAGE

Lisp is a fully programmable programming language, because Lisp programs are written in the same syntax that Lisp primitives work best with: S-expressions. This means that you can relatively easily create your own variants of Lisp tailored to your problem domain. For example, Andy Gavin created custom Lisp dialects for the Naughty Dog games that mixed high-level programming abstractions with assembly constructs and even direct manipulation of the GPU via parallel threads of execution.

Lisp derives this kind of programmability primarily from its syntax, which is simple enough for a Lisp program -- either at compile time or run time -- to examine, modify, and then run. Lisp advocates often point to the powerful Macro facilities which let programs modify themselves at compile time.

From a pedagogical standpoint, Lisp is excellent because it's feasible in one or two semesters to have students create a complete Lisp interpreter in Lisp, thereby learning the basics of how programming languages "work".

In contrast, if you try to do the same thing with, say, Python, you have to first take an extended detour into tokenizing, parsing, and abstract syntax trees. These are great topics for a more advanced class (e.g., a compiler construction course) but not so much for an introductory class.

Finally, programs are themselves just data, meaning one can reason about them formally. Getting this point across to students is incredibly important, because this observation underlies all of modern Computational complexity theory -- see, for example, the Turing machine.

Don't read this. Look at this picture of my cat looking inspired instead.

All true, but not conducive to the "hire a bunch of H1-Bs to throw Java/.Net at it" approach to software development.

/thread

fucking 10/10

Sussman himself said that using lisp now is wrong since programming has change majorly in the past decade.
They decided to go with python

Wrong for college freshmen, specifically.

The dementia has long kicked in for that old fucker

He was losing his hair back when they filmed the original lecture series

Why python is an amazing introductory language, isn't it used now more than java?

yeah learn lisp first so you don't understand other languages after that, good goy

I use python for things where the libraries completely solve the problem, or when i need to collaborate with others. But I'm well aware that cpython is decades behind SBCL.

Sure, if this is 30 years ago. Now even Gerry Sussman admit if lisp is no longer relevant.

www.posteriorscience.net/?p=206

Paraphrasing: Because they're no longer solving complex problems, but pasting together libraries.

C++ should be everyone's programming cherry-popper

Lisp is fun.
I wrote an RPN calculator in 12 lines or so.
But then I did the same in Python.
Lisp is old now.
It's time to let go.

Nothing wrong with that. Most programming task are no longer complex, that's what we call "progress".

no, progress is when women and niggers learn to kode™

Where all my Haskell niggas at?

me in the back

I started losing my hair when I was a teenager

They're busy writing unreadable various iterations of unreadable messes to find one their compiler won't shit all over.

Is this a good place to start?
Or would SICP be better?
How about elisp and emacs?

They're busy writing various iterations of an unreadable mess to find one their compiler won't shit all over.

Lisp sounds awesome! Too bad it has been discontinued and superseded by Haskell.

>discontinued
wrong.

>Haskell
*Java, JavaScript, Python, Ruby, Perl

Yes a good place
SICP would be good too.
Long answer: Gentle Introduction goes slow and steady, basically it assumes you don't know any programming (and when it comes to lisp, you might as well treat it as if your first PL), and describes the lisp semantics in what I consider an interesting way. SICP is more theoretical, speaking about types of processes, big O notation, and the excercises require you to do some of the old thinking. You should go slow with this one.
Regarding Emacs/Elisp. You could read Chasell's Eintr, which comes with emacs (C-h i emacs li ) and it also assumes no prior knowledge in programming.
But I honestly don't know if Elisp is a good beginner language, some people have learned it as their first language (emacs users of course), but it is editor-oriented. I haven't learned any elisp because I don't have much need to make enhancements to emacs. I'd reather get into some more dank programming.
Also Elisp is old, either Scheme or CL have more modern features than Elisp

I've heard good things about Land of Lisp.

It's fun and has interesting problems but I can't say this enough times: the code is horrid.
Let me give you an example
(defun tweak-text (lst caps lit)
(when lst
(let ((item (car lst))
(rest (cdr lst)))
(cond ((eql item #\space) (cons item (tweak-text rest caps lit)))
((member item '(#\! #\? #\.)) (cons item (tweak-text rest t lit)))
((eql item #\") (tweak-text rest caps (not lit)))
(lit (cons item (tweak-text rest nil lit)))
(caps (cons (char-upcase item) (tweak-text rest nil lit)))
(t (cons (char-downcase item) (tweak-text rest nil nil)))))))

That unreadable wall of C-like functionality could very well be replaced by

(format nil "~@(~a~)" list)

And even that is unnecesary. The author actually decided to save as lists something whose only purpose is to be printed as a string. Having strings in the language, he decided to make a huge workaround because "using lists is the lisp way". Which is not true, no lisper in his right mind would do something as stupid as make a huge workaround for something that's there, in the language, as a primitive. Imagine if we decided "numbers are too un-lispy, we should implement them as peano lists instead!"