(Part 2) Top products from r/lisp

LispTutor jr is a very good option to start learning Common Lisp. I'll repeat/consolidate here some of the things I've recently said about it in other posts.

If using LispTutor jr, then the "Mastery" option may lead to more lessons than the "Traditional" option after logging in.

If sample code is listed in the lessons, then typing it in one's own Lisp editor/environment (ex: Portacle, Corman Common Lisp) and running/playing with it can help improve understanding.

This is especially true for the first chapter on Iteration (Chapter 3), because this version of the LispTutor doesn't have exercises for that chapter (there are checked exercises for the Recursion and the advanced Iteration (Loop Facility) chapters that follow). But, it is still a critical chapter to read and the lesson's code should be typed / run / tested / played-with for different made-up scenarios until there's a solid understanding of how to plan / design an Iteration using the provided rules on properly initializing the interdependent loop variables based on the type of loop one is creating.

The exercises are best approached as a puzzle / game because there may be more than one correct answer to a given exercise, but only one of them is being asked for by the exercise. So, experimentation is sometimes in order if the lessons were not carefully studied or well understood before moving to the exercise.

If stuck on any of the exercises, then typing / running / testing code outside of the exercise screen using one's own Lisp edit/environment (ex: Portacle) might help brainstorming better. All of the exercises provide an example of what a valid output should look like when the correct source code has been entered in the exercise.

Look around the exercise screen for hints. All of the possible Lisp primitives that could be used in the expected answer are listed at the top and to the left side of the screen. Brute force in attempting some or all of those primitives is a valid problem solving method / heuristic to obtain the specific answer being asked for if nothing else comes to mind after reasoning / testing things out first :-)

A good approach in using LispTutor Jr is to combine it with another learning resource. After carefully reading the lessons (don't skip any AND do take notes!) and completing all of the strictly guided / checked exercises, then one can complete all of the lessons / exercises / projects in the "Land of Lisp" book.

The primary advantages are that both are used at university (perhaps, increasing confidence in the approach) and that LispTutor has been proven to work.

>The original LispTutor was developed at Carnegie Mellon University by Reiser, Anderson, Corbett, Farrell and others. Lisptutor Jr is a simplified version of the system, but it is still used by many people interested in learning the classic language for Artificial Intelligence: LISP.
>
>- About LispTutor Jr

As quoted above, the original LispTutor interactive training system was created at Carnegie Mellon (home of CMUCL from which SBCL is derived). It has been used there, and at other schools, to teach Common Lisp. Its contents are derived from the insightful "Essential LISP" book that was the result of AI research in determining what it takes to teach students who've never been exposed to Lisp how to program in it competently.

The special focus of the "Essential Lisp" book and LispTutor is Iteration and Recursion, since those are often the most difficult topics for students to understand and internalize well. In fact, they cover things that no other Lisp book I've seen does, such as providing principles to help determine what the primary variables in a particular Iterative structure should be initialized to. That alone helps reduce student error by avoiding over iterating or under iterating.

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.
  

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.

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

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

Check your sources, all of the listed techniques have been around in computer architectures for decades. cfr. Computer Architectures

\> than the common definition of lisp, which _clearly_ includes Clojure

What would that definition be? That it has parens? That would exclude Dylan. That it has conses? That would exclude Clojure. I've added the emphasis because it seems to indicate that you are starting from the assumption that Clojure must be a Lisp and looking for supporting premises.

Keep in mind I'm saying this as someone who normally refers to Clojure as a Lisp and will continue to do so. But /u/lispm's arguments have shown me that there isn't a precise definition of Lisp that matches the commonly used 'extensional definition' of Lisp. This in turn means the term is in danger of becoming a meaningless label.

I ask you, can you produce such definition? When you hear someone saying Clojure is not a Lisp, do you think their intention is to put down Clojure? Your post elow shows people _referring_ to Clojure as a Lisp, not any definition of Lisp. The only definition I saw below is linked in Wikipedia, a single citation to the book Milestones in Computer Science and Information Technology which can be summed up with parens + prefix (excluding Dylan) and seems to be from a randomly selected book.

>Ah, this is another troll tactic, the misleading statistic. Many DO disagree. Many MORE, at least twice as many, agree.

I personally tend to weight negative reviews a bit higher.

See the other book I named:

http://www.amazon.com/G%C3%B6del-Escher-Bach-Eternal-Golden/dp/0465026567

>Maybe you did not try asking non-inflammatory questions in the places where people are willing to answer, such as here and #lisp.

My memory of the chanop in #lisp (though this was years ago) was that he was exceedingly surly for no real reason. In fact, pretty much everyone there had a bug up their ass. There again, IRC in general has that same problem.

My top suggestion: documentation of existing libraries.

I think the #1 biggest problem with the libraries out there is that no one has any earthly idea what the hell they are. Zach on Quicklisp has acknowledged this as a big-time failure.

The same situation existed for LaTeX for a long time: there were oodles of libraries available on CTAN, and no one had any idea what to was available, what to use, how they interacted, what was good, what was old, or even how everything worked together. So these libraries languished in obscurity.

Then The LaTeX Companion came out and revolutionized the LaTeX scene. And all this book was was a compendium description of existing libraries.

Lisp badly, desperately, needs a Lisp Companion.