1. 23
  1.  

  2. 12

    This isn’t a ‘have you tried x answer’ but I’d like to talk a little bit about the little schemer. I know some folks who seriously dislike the book’s style (it sort of reads like a socratic dialogue between you and the writer).

    Reading through this book was an incredibly enlightening experience. I had no computer, just a notebook, to work the examples. This book has repetition and the entire thing is a worked exercise. It kind of works like a directed conversation with the repl.

    The important part is, that by the end of this book, I was basically a lisp reader. Having to write and validate all of the individual forms while working through it solved a lot of the basic problems of code literacy but also taught a lot about recursion and abstraction. I read a whole bunch of other books on my way to learning lisp but other than writing it exclusively at work I can say that this book really cracked a lot of the base principles for me.

    The book might feel a little elementary if you’re an experienced programmer, but I’ve never suffered as a result of starting from first principles, even if it seems boring initially.

    On Lisp is full of a lot of really nice stuff too, especially in terms of some explanation of a lot of the virtues of lisp that we are often told exist but would have difficulty actually rationalizing and demonstrating.

    1. 3

      Thanks for the suggestion! I never tried it, and I think it was fairly deep into the curve that I heard of it. I’ve been meaning to go back and check it out, along with finishing Land of Lisp.

      1. 1

        Some have asked us if http://haskellbook.com/ is inspired by the ‘Little’ series. I’d lean towards “no”, particularly if it’s a question about style. Roughly a cycle of, describe -> query -> hypothesis -> validate along with exercises that ask you to construct and synthesize things based on what you know so far. The exercises are much of the point of the book even if they seem boring. Haskell Programming is being tested with people that have never programmed before, which is an emphasis it might share with the “Little” series.

        Don’t think it works as well a computer though, you’re supposed to iterate on examples and test answers via the REPL. This is partly to get people into a flow that mates well to doing ordinary work in Haskell.

        1. 2

          Looking forward to the book.

          1. 1

            Sorry, “works as well without a computer”

            To add something more - early on we were worried about people getting bored or giving up, but that hasn’t come up. Rather, most feedback has been led to adding elaboration, a better example, better wording, or more exercises. Some of this was expected, but we thought we would get push-back on the amount of “work” in the material. None so far.

          2. 1

            Even for experienced programmers as you say, I would argue that the section around the Y combinator takes its toll on your brain. By the way, Friedman et al are releasing their new book next month.

          3. 2

            I’m not sure I agree with this.

            Complaining Lisp is hard because LoL and SICP are a lot of work isn’t exactly fair.

            It’s completely possible to use Lisp without being a macro guru. TBH, I’d be a little worried about a beginner working through LoL - it takes a lot of experience to know when and where to use macros, and that experience isn’t going to come from reading a few books.

            And SICP is more just a basic CS book than it is a Lisp guide - it just happens to use Scheme. You could just as easily work through SICP using Python or Ruby, and claim those languages are hard.

            1. 2

              i wonder if learning an ML first would help in general. for instance, here’s the part in HTDP where lists are introduced:

              ; A List-of-names is one of:
              ; – empty
              ; – (cons String List-of-names)
              ; interpretation a List-of-names represents a list of invitees by last name

              while learning lisp, you have to mentally map that definition to the concrete representation of a list while you work with it, whereas in ML you’d actually say NameList = Empty | Name * NameList and have explicit type tags in your destructuring code.

              i’m pretty excited about the potential of pyret as a first language; it seems to combine the best parts of lisp and ML.