(Part 2) Best products from r/lisp

Some context, I've been living in this house for about 3 years now, my girlfriend and i moved in to take care of the owner of the house. Turns out that he was a big lisp / scheme hacker back in the 80s-90s and had developed a lot of cutting edge tech in his hay day. Anyway, these books have been hiding in his library downstairs...

It was like finding a bunch of hidden magical scrolls of lost knowledge :)

edit: I will compile a list of the books later. I'm out doing 4th of July things.

update: List of books

• Lisp: Style and Design by Molly M. Miller and Eric Benson
  ISBN: 1-55558-044-0
  
  
• Common Lisp The Language Second Edition by Guy L. Steele
  ISBN: 1-55558-042-4
  
  
• The Little LISPer Trade Edition by Daniel P. Friedman and Matthias Felleisen
  ISBN: 0-262-56038-0
  
  
• Common LISPcraft by Robert Wilensky
  ISBN: 0-393-95544-3
  
  
• Object-Oriented Programming in Common Lisp by Sonya E. Keene
  ISBN: 0-201-17589-4
  
  
• Structure and Interpretation of Computer Programs by Harold Abelson, Gerald Jay Sussman w/Julie Sussman
  ISBN: 0-07-000-422-6
  
  
• ANSI Common Lisp by Paul Graham
  ISBN: 0-13-370875-6
  
  
• Programming Paradigms in LISP by Rajeev Sangal
  ISBN: 0-07-054666-5
  
  
• The Art of the Metaobject Protocol by Gregor Kiczales, Jim des Rivieres, and Daniel G. Bobrow
  ISBN: 0-262-11158-6
  
  
• Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp by Peter Norvig
  ISBN: 1-55860-191-0
  
  
• Practical Common Lisp by Peter Seibel
  ISBN: 1-59059-239-5
  
  
• Common Lisp The Language by Guy L. Steele
  ISBN: 0-932376-41-X
  
  
• Anatomy of Lisp by John Allen
  ISBN: 0-07-001115-X
  
  
• Lisp Objects, and Symbolic Programming by Robert R. Kessler
  ISBN: 0-673-39773-4
  
  
• Performance and Evaluation of Lisp Systems by Richard P. Gabriel
  ISBN: 0-262-07093-6
  
  
• A Programmer's Guide to Common Lisp by Deborah G. Tatar
  ISBN: 0-932376-87-8
  
  
• Understanding CLOS The Common Lisp Object System by Jo A. Lawless and Molly M. Miller
  ISBN: 0-13-717232-X
  
  
• The Common Lisp Companion by Tim D. Koschmann
  ISBN: 0-417-50308-8
  
  
• Symbolic Computing with Lisp and Prolog by Robert A. Mueller and Rex L. Page
  ISBN: 0-471-60771-1
  
  
• Scheme and the Art of Programming by George Springer and Daniel P. Friedman
  ISBN: 0-262-19288-8
  
  
• Programming In Scheme by Michael Eisenberg
  ISBN: 0-262-55017-2
  
  
• The Schematics of Computation by Vincent S. Manis and James J. Little
  ISBN: 0-13-834284-9
  
  
• The Joy of Clojure by Michael Fogus and Chris Houser
  ISBN: 1-935182-64-1
  
  
• Clojure For The Brave and True by Daniel Higginbotham
  ISBN: 978-1-59327-591-4
  
  
  
  

That sounds like a reasonable plan. The choice of Lua or Cg depends on the type of programming you plan to do - it sounds like you might be interested in gaming. Personally, I would recommend Haskell ahead of Lisp as a vehicle for learning to be a better programmer. I think Python is close enough to Lisp that learning Lisp-proper won't buy you much.

I actually wrote a huge edit to the above post. Unfortunately, Reddit seems to have hiccuped, and it got lost. Since I took the time to write it, I'll post it below...

-----------------------------

Wow, after reading the responses in this forum, I really worry that you're being lead astray.

Please realize that I like Lisp. It's a wonderfully fun language, and I highly recommend that you learn it eventually. That said, there are several problems with learning it as your first language. In no particular order:

• Learning "Lisp" really means understanding the concept of Lisp. IMO, this is something that is hard to appreciate until you've got some experience under your belt. I suggest that you pick it up after your compilers class.
  
  
• Supporting the above point - look at the Amazon.com reviews of SICP - probably my favorite programming book of all time. It's highly skewed to 1's and 5's. Typically, beginners who pick it up hate it because it fails to answer the question "How do I use this language to accomplish X" for any real-world value of X.
  
  
• Also note that in this forum alone I see 3 Lisps just casually mentioned - Common Lisp, Scheme, and Clojure - these are all quite different from each other. Just choosing a particular implementation and getting a development environment setup is not trivial.
  
  
• Paul Graham once put Lisp at the top of the "language power" spectrum. However, IMO, Lisp is merely the "logical conclusion" of one particular family of languages (dynamically typed, introspective). There are myriad other paradigms out there - and personally I find Haskell to be more interesting and powerful than Lisp.
  
  
• Also, Python is in the same family of languages as Lisp, is almost as powerful, is much cleaner and more consistent than Common Lisp, and is much easier to accomplish just about any real-world task owing to it's incredibly large set of libraries.
  
  Anyway, just wanted to give a different perspective. I don't wish to discourage you from learning Lisp, but I really do not think that it is a good first language.

> Essentially, yes.

I didn't see that in the CLHS. News to me.


> I would consider elegance to be the ratio of constructs that
> something can implement easily to the size of its syntax.

That had what to do with number of pages?


> Just look at the godawful LOOP macro.

What's wrong with it? It looks to me like a DSL for looping. Some people claim that the ITERATE package feels better for complex loops, but I have never justified installing the extra dependency. Granted, it is nice that people can easily extend Lisp to have constructs that they prefer.


> I want to solve large OR problems with metaheuristics. I notice that all
> the Lisp libraries that would suitable for my purposes are incomplete
> abandonware. I use Python instead.

How does cl-smogames help you with that? Are you pulling my leg? Have you tried asking around about available packages? It isn't my interest, so I cannot help you, personally.


> So a bunch of stuff that's mostly in the Python standard library? Really?

Ha! We must not be looking at the same list. ;) And it is a completely separate debate as to what should be part of a core language and up to the community to provide.

This response and others in these threads give me the impression that you have a python axe to grind. That really is not useful here. Besides, I want nothing to do with a language whose creator turns an intentional blind eye towards tail recursion and whose only takeaway from SICP was that it was a book that advertised Lisp. ;)

Lisp is like magic - it's the programmable programming language - if you learn it, everything else kind of pales in comparison :P

One fascinating aspect of lisp is that it's based on lambda calculus, which is basically a cleaner alternative to Turing machines (Turing machines are basically a mathematical way to describe computable problems). After learning about lambda calculus, Turing machines looked like a hack to me. A decent non-mathematical guide I found introducing them was this: http://palmstroem.blogspot.com/2012/05/lambda-calculus-for-absolute-dummies.html

Even though lisp allows for a lot of functional programming, it's not purely functional, and can be used to write object oriented code, or anything else really.

The books I'd recommend to learning it are:

• The Little Schemer - a lovely, beginner friendly book that introduces Lisp and computation in a rather unique way.
  
• Structure and Interpretation of Computer Programs - this is the book that was used to teach a bunch of programming classes at MIT, and is a classic text for computer science. Despite its advanced topics, it's still rather approachable, especially if you have a decent amount of programming background.
  

>Two years is a short time to make a judgment, isn't it? Just kidding, "brah".

No, six.

>I see what you are seeing. I have seen the same thing in the perl community with CPAN. If you try out the libraries and read further, you will find that they are actually pretty feature complete.

Really? Go on common-lisp.net and try proving your hypothesis.

http://common-lisp.net/project/cl-machine-learning/

>cl-machine-learning is a project with assorted supervised, unsupervised, and reinforcement learning algorithms written in Common Lisp.

>As of summer 2009, the project is barebones. We have a support vector machines library (cl-svm).

Great, that's really useful to me.

http://common-lisp.net/project/cl-smogames/

>cl-smogames contains collection of small games. Playable but not very mature.

http://common-lisp.net/project/cltl3

>This is an automatically generated placeholder page: this project has not yet created a website.

(There are a lot of these, and so it goes...)

>I question the idea that "expressive power" should be measured "quantitative"ly, as opposed to "qualitatively". Here is what keeps me clinging to Lisp: macros and reader macros.

Macros are a shitty form of encapsulation.

>Common Lisp includes a full-fledged MetaObject Protocol and gives you a sample implementation on top of it called CLOS.

I'm aware of that, because I have this:

http://www.amazon.com/Common-LISP-Language-Second-Steele/dp/1555580416

>Paperback: 1029 pages

What a bloated elegant language.

I'm not much interested in perceptions, more in realities. I've never bothered too much about what people think unless there is really something behind it.

http://www.amazon.co.uk/What-Care-Other-People-Think/dp/0141030887

Anyway my post from Y-combinator

"The license was introduced before Shen was issued in September 2011 (the license came out in June) and for a year or so the only specification was Shendoc (now Shendoc 16). The understanding was that Shen was specified in that document and what was not covered by Shendoc was covered by 'Functional Programming in Qi'. Later a hurriedly introduced text 'The Book of Shen (first edition)' (TBoS) was produced to fill a gap (2012) and this year (January 2014) a more thorough 2nd edition of TBoS (> 400 pages) was published which fixes the language standard very thoroughly. This is currently the canonical standard.
You can find a link to that book on the Shen home page.

http://www.fast-print.net/bookshop/1506/the-book-of-shen-sec...

Shen is now very stable and has been for nearly two years. At my suggestion, I posited that it might be better to move the standard to a computable series of tests and this was floated to the 2011 committee that is responsible jointly for all the ports.

http://shenlanguage.org/2011committee.html

Such a change requires the unanimous consent of all the people involved and it seems we have this and a reworded simplified license.

The only obstacle is the work needed to put this test suite together. I've suggested that this suite might be assembled in Github, though for legal reasons the final version must be put in a publicly accessible but tamper-proof place.

Since the type-integrity given out by the system is not better than the strength of the kernel, we take kernel work very seriously. There is already a suite of 126 tests that I run every Shen port through and 2011 members echo these tests. But this informal test suite needs to be amped up to several hundred tests to approach what I consider to be an adequate test suite. It is very boring but important work. So far I have begun assembling all the programs in TBoS into this suite.

These license issues really only affect people who are deeply involved in kernel work and as far as application programmers are concerned, I doubt that it affects them much at all. As far as graphics, concurrency, FFI etc. and add-ons are concerned there are no restrictions. Likewise none on closed source work.

I'll also add that I'll be asking for volunteer contributions on the Shen news group to help assemble this test suite. So people who want to expedite us here can do so."

SICP? Sort of... Otherwise it's mostly papers at readscheme.org (R.I.P.)

EDIT: an interesting non-Lisp book that could yield ideas portable to certain Lisps is Concepts, Techniques, and Models of Computer Programming.

Yes, for math there is Edmund Landau's Foundations of Analysis. Read the reviews.

Sure it was LISP? Possible it was Scheme?

Looks a lot like this … animal: https://www.amazon.de/Land-Lisp-Learn-Program-Game/dp/1593272812?ie=UTF8&SubscriptionId=AKIAILSHYYTFIVPWUY6Q&camp=2025&creative=165953&creativeASIN=1593272812&linkCode=xm2&tag=duckduckgo-ffab-de-21

My memory is that this book implements a dynamically scoped lisp. See Lisp in Small Pieces for more modern implementations that include lexical scoping.

(Note: I have been out of the Lisp games for years so this info might only be partially correct.)

Doesn't meet the time frame but:

​

https://www.amazon.co.uk/Art-Lisp-Programming-Robin-Jones/dp/3540195688?SubscriptionId=AKIAILSHYYTFIVPWUY6Q&tag=duckduckgo-ffab-uk-21&linkCode=xm2&camp=2025&creative=165953&creativeASIN=3540195688

​

Or perhaps:

​

https://www.flickr.com/photos/nathanchantrell/5540390072

They can always use Corman, Lispworks, or Allegro, I presume, if they're not going "all in". For class or experimentation, that might be what they're looking for.

[Going off on a tangent, there seems to be a new Emacs book on the market.]

Common Lisp Recipes by Edi Weitz https://www.amazon.com/Common-Lisp-Recipes-Problem-Solution-Approach/dp/1484211774/ref=mp_s_a_1_1?keywords=common+lisp+recipes&qid=1562954309&s=gateway&sr=8-1

My copy of this just arrived today:

https://www.amazon.com/LISP-Lore-Guide-Programming-Machine/dp/0898382289

See this 432 page book about barefoot walking...

There is a book called "Looking at Lisp" with a similar idea on the cover:

http://www.amazon.com/gp/product/0201120801/