Answers.Body: <p>Frame challenge, don't <em>start</em> with a book. Start with Problem 1 on <a href="https://projecteuler.net/archives" rel="nofollow noreferrer">Project Euler</a> (spoiler, Problem 1 is just Fizz Buzz) and Google/Stack Overflow/language documentation and just write some code. Your first code will be terrible Lisp since your brain will still want to work procedurally and that's OK, imo actually experiencing this is the best way to really <em>know</em> how Lisp is different from procedural code.</p>
  <p>I think Project Euler is particularly good for this because a) a lot of the questions have very elegant recursive solutions so the reward for writing idiomatic Lisp is high, and b) there are usually several Lisp solutions posted in the forums for easy problems so you can see how other people solved the same problem. (Plus you get a bonus of seeing how people solved it in other languages.)</p>
  <p>Then you can go read a book and build an academic understanding on top of your intuitive understanding.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-08-07T12:18:31.977Z
Answers.Text: The Dreyfus model of learning indicates that novices learn best through starting out by being told exactly what to do, moving on to minor variants of that, and only slowly generalising to rules, guidelines, and so on. I've found this to be true in my experience as well. That's why I recommend _The Little Schemer_ first; it will directly teach you the idioms rather than leaving you stumbling around trying to figure out what they are. The Project Euler problems would be a great exercise _after_ learning the basic patterns of problem solving in Lisp.
Answers.UserDisplayName: cjs
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-08-01T14:23:30.143Z
Answers.LastActivityDate: 2022-08-01T14:23:30.143Z
Answers.UserDisplayName: user3067860
Answers.Body: <p><em>How to Design Programs</em> is a truly fantastic text. Should you choose to read it, I suspect you will be able to learn many useful things from it. However, I hesitate to recommend it as an answer to your question as-stated for two reasons:</p>
  <ol>
  <li><p>HtDP is ultimately a textbook, and it is not written to be read front to back. Rather, it is primarily intended to be used alongside a course taught by an instructor who knows how to use it most appropriately.</p>
  </li>
  <li><p>More bluntly, HtDP is simply not a book about Lisp.</p>
  </li>
  </ol>
  <p>Yes, HtDP uses a programming language (or, more accurately, a family of programming languages) that happens to be a Lisp. But this is somewhat incidental, and the book can be adapted to other languages (and sometimes is in practice). Moreover, the language used by HtDP is <strong>not</strong> Racket, nor is it even Scheme—instead, HtDP uses a family of languages specifically designed for teaching, which intentionally lack many of the features that are traditionally considered the qualities that make Lisps interesting.</p>
  <p>So what <em>is</em> HtDP about? True to its name, it is a book about how to design programs. It is not about how to design <em>Lisp</em> programs, and although it certainly does have a somewhat functional bent, its ideas are applicable to all programming languages. This is why it is often used as an introductory text. The Lisp is not the point, so if you want to learn about Lisp, HtDP is not going to leave you terribly satisfied.</p>
  <hr />
  <p>Given the above, it may sound like I am strongly recommending that you read <em>Structure and Interpretation of Computer Programs</em>, instead, and that is not entirely untrue. Unlike HtDP, SICP is <em>not</em> an introductory text (as much as people sometimes seem to pretend otherwise), but it’s also not really about Lisp, either. Rather, SICP covers some of the foundational ideas in the field of programming languages, and it explores these via simple interpreters written in Scheme. Many of the ideas in SICP are definitely “Lispy” in some sense, and you say you’re interested in perhaps pursuing the field of programming languages, in which case I suspect you will find SICP quite edifying. On the other hand, I personally think many of its ideas are presented better elsewhere (though many would disagree, so YMMV).</p>
  <p>Ultimately, the question comes down to what you <em>really</em> want to learn about. Here are a few possibilities:</p>
  <ul>
  <li><p>If you want to learn about writing programs in Lisp or about functional programming more generally, I recommend reading <a href="https://docs.racket-lang.org/guide/index.html" rel="noreferrer">The Racket Guide</a>. The Racket Guide does not exactly present itself as a book, but it is structured like one, and it provides a very thorough introduction to programming in a full-featured Lisp that covers everything from the bare basics to compile-time metaprogramming to higher-order contracts. The Racket Guide is a wonderful resource that will give you everything you need to start writing real Lisp programs (and then some).</p>
  </li>
  <li><p>If you want to explore the foundations of programming languages using a Lisp as a vehicle, then I recommend <a href="http://cs.brown.edu/courses/cs173/2012/book/" rel="noreferrer"><em>Programming Languages: Application and Interpretation</em></a> by Shriram Krishnamurthi. PLAI covers much of the same content as SICP, but it does so in a more precise and less handwavy way, and it also covers more topics, such as garbage collection.</p>
  </li>
  <li><p>If you want to learn specifically how to <em>implement</em> a simple Lisp, then I actually think it’s quite possibly more illustrative to do that in a language that <em>isn’t</em> a Lisp. <a href="https://wespiser.com/writings/wyas/00_overview.html" rel="noreferrer">Write You A Scheme</a> uses Haskell as its implementation language of choice, which I think provides a particularly lucid grounding for the ideas it introduces.</p>
  </li>
  </ul>
  <p>Ultimately, all of the things I’ve mentioned here—including both HtDP and SICP—are good reading, so I wouldn’t worry too much about which one you pick. It would certainly be counterproductive to feel overwhelmed by choice and not end up reading <em>any</em> of them, so don’t get stuck in analysis paralysis. But personally, based on the contents of your question, I think The Racket Guide and PLAI would both be great choices to help you get started on your journey into Lisp and programming languages.</p>
  <p>(Disclaimer: I am a regular contributor to Racket and am currently employed working on GHC, the Haskell compiler. I like to think my suggestions are relatively unbiased in spite of my personal interests, but then, we all do. :))</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-07-31T17:42:13.463Z
Answers.Text: Is there a way to escape DrRacket IDE hell?  Personally, I don't like IDEs and I would appreciate if you could tell there is command line racket interpreter available for Unix based systems?
Answers.UserDisplayName: Taimoor Zaeem
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-07-31T17:44:05.387Z
Answers.Text: @TaimoorZaeem You are certainly under no obligation to use DrRacket. The `racket` command-like executable drops you into a REPL if given no arguments, and there’s also a racket-mode for emacs.
Answers.UserDisplayName: Alexis King
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-08-01T20:31:23.833Z
Answers.Text: WYAS is perhaps not the best choice, since Haskell is very different from both Scheme and the languages OP claims to know. OP would have to first learn Haskell to derive the greatest benefit from WYAS.
Answers.UserDisplayName: OpenAI was the last straw
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-10-22T21:50:11.293Z
Answers.Text: @TaimoorZaeem there is also good Vim support available. See the racket docs on editors
Answers.UserDisplayName: D. Ben Knoble
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-07-31T15:49:12.897Z
Answers.LastActivityDate: 2022-07-31T15:54:32.807Z
Answers.LastEditDate: 2022-07-31T15:54:32.807Z
Answers.UserDisplayName: Alexis King
Answers.Body: <p>The problem with learning any of the Lisp family of languages after learning several others is that Lisp and its progeny use a different paradigm. Changing paradigms implies changing the <em>way you think</em>. It isn't about syntax, but about a mental model of the nature of computation.</p>
  <p>There is nothing naive about SICP, but you need to get beyond the first few pages. Once you have internalized the thought process, you can move to other functional languages, just as you can move from Java to Python, say.</p>
  <p>The big difference between pure functional languages and those you already know is the replacement of &quot;state&quot; represented by variables with &quot;expressions&quot;.</p>
  <p>Racket and Scheme share many things, including an abstract syntax. But the most important thing they share is the computing model; the paradigm and that will be the biggest hurddle.</p>
  <p>But, either of those books should be fine for a first look at FP. The authors are among the finest around and all have a very deep knowledge of their respective topics.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-07-31T03:24:11.540Z
Answers.Text: While I have no disagreement with the general outline of this answer, I wonder about phrasing it using terms like "problem" and "hurdle". Learning a new programming paradigm is a wonderful *opportunity* and can be very *enjoyable*; it *widens the mind* of a CS student and prepares it for further widening. At least that is how I perceived working with LISP (specifically, Common LISP) when I learned it in the 1980s. My university mandated that CS students learn either LISP or Prolog to make sure they had a grasp on programming languages beyond procedural ones.
Answers.UserDisplayName: njuffa
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-07-31T13:47:33.610Z
Answers.Text: "The problem with learning any of the Lisp family of languages after learning several others is that Lisp and its progeny use a different paradigm." – Although the OP says they have a strong background in JavaScript, which is essentially Scheme with a thin veneer of NewtonScript, Act-1, and Self. At least, that was my epiphany. I tried learning JavaScript multiple times, but it only clicked for me when I realized that I should ignore everything I ever learned about JavaScript and simply think of it as Scheme with dictionaries instead of lists as the ubiquitous data structure.
Answers.UserDisplayName: Jörg W Mittag
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-07-31T18:54:56.017Z
Answers.Text: @JörgWMittag To expand on what you say, the "paradigm" of the Lisp family is that everything is a reference to first-class objects. This exists in the popular scripting languages: JavaScript, Python, PHP (except that arrays are copy-on-write). That hurdle is often the biggest when going from traditional languages to Lisp, and he's achieved it if he understands JS.
Answers.UserDisplayName: Barmar
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-08-06T14:32:52.703Z
Answers.Text: Best class in which I ever enrolled was called, "Comparative Programming Languages." The list of languages included Lisp, Pascal, [SNOBOL4](https://en.wikipedia.org/wiki/SNOBOL), Smalltalk, [Prolog](https://en.wikipedia.org/wiki/Prolog), and one or two others. (It was forty years ago, my memory is dim.) The primary focus was on how different languages support different ways of thinking about a problem. Secondary attention was paid to the tradeoff between benefits of certain language features (e.g., Lisp's lexical closures) vs. the cost of implementing and/or using those features.
Answers.UserDisplayName: Solomon Slow
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-08-06T14:35:16.840Z
Answers.Text: @SolomonSlow, such a course is best if it focuses on "principles of programming languages" rather than "examples of programming languages". Your course may have been more in the first category.
Answers.UserDisplayName: Buffy
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-07-30T19:29:57.100Z
Answers.LastActivityDate: 2022-07-30T19:29:57.100Z
Answers.UserDisplayName: Buffy
Answers.Body: <p>As someone points out in the comments, Racket is a Scheme implementation. But I wouldn't worry about which Lisp variant you learn at first, not even whether it's a Lisp-2 (Lisp) or Lisp-1 (Scheme); the things you need to learn initially will be taught pretty much as well in any variant.</p>
  <p>The book I recommend you start with is <a href="https://felleisen.org/matthias/BTLS-index.html" rel="noreferrer"><em>The Little Schemer</em></a> by Daniel Friedman.</p>
  <p>The first few chapters are essentially simple exercises that will introduce you to the basic idioms used by many functional programming languages that imperative programmers are generally not used to, including manipulation and use of singly-linked lists, iteration via recursion (rather than loops), functions as first-class objects, lambdas (anonymous functions), and so on. The book's question-and-answer format helps you <em>practice</em> with these idioms; this is key because easy and fluent use of them is absolutely essential in most functional programming languages, even ones as different from Lisp as Haskell or ML.</p>
  <p>The later chapters of the book go deeper into what you might call the very heart of functional programming, covering both things less discussed, such as currying, and some fairly complex things, such as the applicative-order <em>Y</em> combinator. The book ends with the following; if you have difficulty wrapping your mind around it, well, that's why you need to do the exercises in the book:</p>
  <pre><code>(define Y
    (lambda (le)
      ((lambda (f) (f f))
       (lambda (f)
         (le (lambda (x) ((f f) x)))))))
  </code></pre>
  <p>From the start you may find that short (less than 200 page) book looks overly simple; don't be fooled. Depending on your previous experience, some parts may indeed actually be simple for you, but if so, you'll get through them quickly and waste little time. But if there are any questions that you don't <em>fully</em> understand, don't skip them; go back and contemplate them and do your own exercises based on them until you are confident you have mastered them.</p>
  <p>The book can easily be worked through with pen and paper, and that's the way I recommend you do it. However, if you feel you want to use an interpreter, almost any Lisp or Scheme interpreter will do, though you may have to look up a few details for your particular version of Lisp or Scheme that differ from the book. The book does have some footnotes giving Lisp equivalents of the Scheme functions/macros they use, where the Lisp functions/macros differ.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-07-31T15:12:06.617Z
Answers.LastActivityDate: 2022-07-31T15:12:06.617Z
Answers.UserDisplayName: cjs
Answers.Body: <p>The best book to get into Lisp is Peter Norvig's <a href="https://rads.stackoverflow.com/amzn/click/com/1558601910" rel="nofollow noreferrer" rel="nofollow noreferrer">PAIP</a> - it showcases the core Lisp multi-paradigm approach and also some unique Lisp features that make it suitable for solving problems dealing with knowledge manipulation.</p>
  <p>The other great book for those who, like you, have significant conventional programming experience is Peter Seibel's <a href="http://www.gigamonkeys.com/book/" rel="nofollow noreferrer">Practical Common Lisp</a> which introduces Lisp in the familiar context of those language's approaches.</p>
  <p>Finally, for those who have very little programming experience or for kids, Conrad Barski's <a href="http://landoflisp.com/" rel="nofollow noreferrer">Land of Lisp</a> may be a good accessible and light-hearted introductory book.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2022-08-01T05:23:58.620Z
Answers.LastActivityDate: 2022-08-01T05:23:58.620Z
Answers.UserDisplayName: Vsevolod Dyomkin
Body: <p>I am an undergraduate computer science student. I have completed two out four years of my degree. I have not had an interaction with any Lisp family of languages. I have strong background in C, Java, x86 assembly and Javascript (at least that's what I think).</p>
  <p>I have read that Lisp can teach me some of the core computer science concepts. I am currently stuck in the choice between How to Design Programs (HTDP) and Structure and Interpretation of Computer Programs (SICP). I have read about 50-70 pages of HTDP and it feels quite beginner. So, I did some research on SICP and found SICP teaches Scheme. I have also read that Scheme is old and learning Racket would be a better choice. Which book should I choose?</p>
  <p>Note: I wish to pursue further education in Computer Science possibly in researching about Programming Languages.</p>
  
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2022-07-30T20:49:29.103Z
Comments.Text: Just a note, you can't learn "Scheme", it is a family of languages.  You must pick a flavor.  Racket is an excellent Scheme variant, and comes with a lot of support for learners.
Comments.UserDisplayName: Ben I.
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2022-07-31T07:17:10.580Z
Comments.Text: Seibel's ["Practical Common Lisp"](https://gigamonkeys.com/book/) is quite nice.
Comments.UserDisplayName: Faheem Mitha
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2022-07-31T20:17:21.490Z
Comments.Text: @BenI. Why do you think Scheme is a family of langauges? It's no more a family of languages than C++, with a series of not completely compatible standards.
Comments.UserDisplayName: prosfilaes
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2022-08-01T00:05:08.377Z
Comments.Text: @prosfilaes From Wikipedia: "This has resulted in scores of implementations,[33] most of which differ from each other so much that porting programs from one implementation to another is quite difficult, and the small size of the standard language means that writing a useful program of any great complexity in standard, portable Scheme is almost impossible.[13]".  If you want to quibble with my use of the word "family" I'm happy for a better word, but there's no eponymous "scheme" that you can just install. You have to choose among pretty wildly different implementations to even get started.
Comments.UserDisplayName: Ben I.
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2022-08-01T00:09:33.130Z
Comments.Text: @prosfilaes Perhaps the word "varietal" is better than "variant" here.
Comments.UserDisplayName: Ben I.
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2022-08-01T22:17:29.190Z
Comments.Text: I've always heard that the best introductory book on lisp is [Alices Adventures in Wonderland](http://community.schemewiki.org/?alices-adventures-in-wonderland).
Comments.UserDisplayName: larsks
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2022-08-02T14:35:03.163Z
Comments.Text: As HTDP is mentioned i point out [dcic](https://dcic-world.org/) the latest work from one of the authors. Quite interesting.
Comments.UserDisplayName: Mohan Radhakrishnan
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2022-08-02T18:20:18.917Z
Comments.Text: @BenI. Standard versions of BASIC, Forth, ECMAScript, C and Pascal all provide similarly limited bases; it's just the one implementation world of Python, Java, and C# that provide maximal compatibility. (One dominant implementation, maybe?) JavaScript beyond the browser lacks that compatibility, for a modern example. Even for Java, writing said useful program so it runs on Windows and Android is impossible. Little of this need concern the student, who's not writing complex useful programs, nor is concerned about idiosyncratic GUIs.
Comments.UserDisplayName: prosfilaes
Tags: <functional-programming><scheme>
Title: Which book should I choose to get into the Lisp World?
ThreadText: # Which book should I choose to get into the Lisp World?
  
  (Asked by: username_0 on 2022-07-30)
  
  I am an undergraduate computer science student. I have completed two out four years of my degree. I have not had an interaction with any Lisp family of languages. I have strong background in C, Java, x86 assembly and Javascript (at least that's what I think).
  
  I have read that Lisp can teach me some of the core computer science concepts. I am currently stuck in the choice between How to Design Programs (HTDP) and Structure and Interpretation of Computer Programs (SICP). I have read about 50-70 pages of HTDP and it feels quite beginner. So, I did some research on SICP and found SICP teaches Scheme. I have also read that Scheme is old and learning Racket would be a better choice. Which book should I choose?
  
  Note: I wish to pursue further education in Computer Science possibly in researching about Programming Languages.
  
  **Tags:** functional-programming, scheme
  
  > **Comments:**
  > **username_1**: Just a note, you can't learn "Scheme", it is a family of languages.  You must pick a flavor.  Racket is an excellent Scheme variant, and comes with a lot of support for learners.  
  > **username_2**: Seibel's ["Practical Common Lisp"](https://gigamonkeys.com/book/) is quite nice.  
  > **username_3**: @BenI. Why do you think Scheme is a family of langauges? It's no more a family of languages than C++, with a series of not completely compatible standards.  
  > **username_1**: @username_3 From Wikipedia: "This has resulted in scores of implementations,[33] most of which differ from each other so much that porting programs from one implementation to another is quite difficult, and the small size of the standard language means that writing a useful program of any great complexity in standard, portable Scheme is almost impossible.[13]".  If you want to quibble with my use of the word "family" I'm happy for a better word, but there's no eponymous "scheme" that you can just install. You have to choose among pretty wildly different implementations to even get started.  
  > **username_1**: @username_3 Perhaps the word "varietal" is better than "variant" here.  
  > **username_4**: I've always heard that the best introductory book on lisp is [Alices Adventures in Wonderland](http://community.schemewiki.org/?alices-adventures-in-wonderland).  
  > **username_5**: As HTDP is mentioned i point out [dcic](https://dcic-world.org/) the latest work from one of the authors. Quite interesting.  
  > **username_3**: @BenI. Standard versions of BASIC, Forth, ECMAScript, C and Pascal all provide similarly limited bases; it's just the one implementation world of Python, Java, and C# that provide maximal compatibility. (One dominant implementation, maybe?) JavaScript beyond the browser lacks that compatibility, for a modern example. Even for Java, writing said useful program so it runs on Windows and Android is impossible. Little of this need concern the student, who's not writing complex useful programs, nor is concerned about idiosyncratic GUIs.  
  
  ---
  
  ## 5 answers
  
  ### Answer by username_8 on 2022-07-31. Score: 28 | Accepted answer
  
  *How to Design Programs* is a truly fantastic text. Should you choose to read it, I suspect you will be able to learn many useful things from it. However, I hesitate to recommend it as an answer to your question as-stated for two reasons:
  
  1. HtDP is ultimately a textbook, and it is not written to be read front to back. Rather, it is primarily intended to be used alongside a course taught by an instructor who knows how to use it most appropriately.
  2. More bluntly, HtDP is simply not a book about Lisp.
  
  Yes, HtDP uses a programming language (or, more accurately, a family of programming languages) that happens to be a Lisp. But this is somewhat incidental, and the book can be adapted to other languages (and sometimes is in practice). Moreover, the language used by HtDP is **not** Racket, nor is it even Scheme—instead, HtDP uses a family of languages specifically designed for teaching, which intentionally lack many of the features that are traditionally considered the qualities that make Lisps interesting.
  
  So what *is* HtDP about? True to its name, it is a book about how to design programs. It is not about how to design *Lisp* programs, and although it certainly does have a somewhat functional bent, its ideas are applicable to all programming languages. This is why it is often used as an introductory text. The Lisp is not the point, so if you want to learn about Lisp, HtDP is not going to leave you terribly satisfied.
  
  ---
  
  Given the above, it may sound like I am strongly recommending that you read *Structure and Interpretation of Computer Programs*, instead, and that is not entirely untrue. Unlike HtDP, SICP is *not* an introductory text (as much as people sometimes seem to pretend otherwise), but it’s also not really about Lisp, either. Rather, SICP covers some of the foundational ideas in the field of programming languages, and it explores these via simple interpreters written in Scheme. Many of the ideas in SICP are definitely “Lispy” in some sense, and you say you’re interested in perhaps pursuing the field of programming languages, in which case I suspect you will find SICP quite edifying. On the other hand, I personally think many of its ideas are presented better elsewhere (though many would disagree, so YMMV).
  
  Ultimately, the question comes down to what you *really* want to learn about. Here are a few possibilities:
  
  * If you want to learn about writing programs in Lisp or about functional programming more generally, I recommend reading [The Racket Guide](https://docs.racket-lang.org/guide/index.html). The Racket Guide does not exactly present itself as a book, but it is structured like one, and it provides a very thorough introduction to programming in a full-featured Lisp that covers everything from the bare basics to compile-time metaprogramming to higher-order contracts. The Racket Guide is a wonderful resource that will give you everything you need to start writing real Lisp programs (and then some).
  * If you want to explore the foundations of programming languages using a Lisp as a vehicle, then I recommend [*Programming Languages: Application and Interpretation*](http://cs.brown.edu/courses/cs173/2012/book/) by Shriram Krishnamurthi. PLAI covers much of the same content as SICP, but it does so in a more precise and less handwavy way, and it also covers more topics, such as garbage collection.
  * If you want to learn specifically how to *implement* a simple Lisp, then I actually think it’s quite possibly more illustrative to do that in a language that *isn’t* a Lisp. [Write You A Scheme](https://wespiser.com/writings/wyas/00_overview.html) uses Haskell as its implementation language of choice, which I think provides a particularly lucid grounding for the ideas it introduces.
  
  Ultimately, all of the things I’ve mentioned here—including both HtDP and SICP—are good reading, so I wouldn’t worry too much about which one you pick. It would certainly be counterproductive to feel overwhelmed by choice and not end up reading *any* of them, so don’t get stuck in analysis paralysis. But personally, based on the contents of your question, I think The Racket Guide and PLAI would both be great choices to help you get started on your journey into Lisp and programming languages.
  
  (Disclaimer: I am a regular contributor to Racket and am currently employed working on GHC, the Haskell compiler. I like to think my suggestions are relatively unbiased in spite of my personal interests, but then, we all do. :))
  
  > **Comments:**
  > **username_0**: Is there a way to escape DrRacket IDE hell?  Personally, I don't like IDEs and I would appreciate if you could tell there is command line racket interpreter available for Unix based systems?  
  > **username_8**: @username_0 You are certainly under no obligation to use DrRacket. The `racket` command-like executable drops you into a REPL if given no arguments, and there’s also a racket-mode for emacs.  
  > **username_9**: WYAS is perhaps not the best choice, since Haskell is very different from both Scheme and the languages OP claims to know. OP would have to first learn Haskell to derive the greatest benefit from WYAS.  
  > **username_10**: @username_0 there is also good Vim support available. See the racket docs on editors  
  
  ---
  
  ### Answer by username_7 on 2022-07-31. Score: 7
  
  As someone points out in the comments, Racket is a Scheme implementation. But I wouldn't worry about which Lisp variant you learn at first, not even whether it's a Lisp-2 (Lisp) or Lisp-1 (Scheme); the things you need to learn initially will be taught pretty much as well in any variant.
  
  The book I recommend you start with is [*The Little Schemer*](https://felleisen.org/matthias/BTLS-index.html) by Daniel Friedman.
  
  The first few chapters are essentially simple exercises that will introduce you to the basic idioms used by many functional programming languages that imperative programmers are generally not used to, including manipulation and use of singly-linked lists, iteration via recursion (rather than loops), functions as first-class objects, lambdas (anonymous functions), and so on. The book's question-and-answer format helps you *practice* with these idioms; this is key because easy and fluent use of them is absolutely essential in most functional programming languages, even ones as different from Lisp as Haskell or ML.
  
  The later chapters of the book go deeper into what you might call the very heart of functional programming, covering both things less discussed, such as currying, and some fairly complex things, such as the applicative-order *Y* combinator. The book ends with the following; if you have difficulty wrapping your mind around it, well, that's why you need to do the exercises in the book:
  
  ```
  (define Y
    (lambda (le)
      ((lambda (f) (f f))
       (lambda (f)
         (le (lambda (x) ((f f) x)))))))
  
  ```
  
  From the start you may find that short (less than 200 page) book looks overly simple; don't be fooled. Depending on your previous experience, some parts may indeed actually be simple for you, but if so, you'll get through them quickly and waste little time. But if there are any questions that you don't *fully* understand, don't skip them; go back and contemplate them and do your own exercises based on them until you are confident you have mastered them.
  
  The book can easily be worked through with pen and paper, and that's the way I recommend you do it. However, if you feel you want to use an interpreter, almost any Lisp or Scheme interpreter will do, though you may have to look up a few details for your particular version of Lisp or Scheme that differ from the book. The book does have some footnotes giving Lisp equivalents of the Scheme functions/macros they use, where the Lisp functions/macros differ.
  
  
  ---
  
  ### Answer by username_11 on 2022-07-30. Score: 6
  
  The problem with learning any of the Lisp family of languages after learning several others is that Lisp and its progeny use a different paradigm. Changing paradigms implies changing the *way you think*. It isn't about syntax, but about a mental model of the nature of computation.
  
  There is nothing naive about SICP, but you need to get beyond the first few pages. Once you have internalized the thought process, you can move to other functional languages, just as you can move from Java to Python, say.
  
  The big difference between pure functional languages and those you already know is the replacement of "state" represented by variables with "expressions".
  
  Racket and Scheme share many things, including an abstract syntax. But the most important thing they share is the computing model; the paradigm and that will be the biggest hurddle.
  
  But, either of those books should be fine for a first look at FP. The authors are among the finest around and all have a very deep knowledge of their respective topics.
  
  > **Comments:**
  > **username_12**: While I have no disagreement with the general outline of this answer, I wonder about phrasing it using terms like "problem" and "hurdle". Learning a new programming paradigm is a wonderful *opportunity* and can be very *enjoyable*; it *widens the mind* of a CS student and prepares it for further widening. At least that is how I perceived working with LISP (specifically, Common LISP) when I learned it in the 1980s. My university mandated that CS students learn either LISP or Prolog to make sure they had a grasp on programming languages beyond procedural ones.  
  > **username_13**: "The problem with learning any of the Lisp family of languages after learning several others is that Lisp and its progeny use a different paradigm." – Although the OP says they have a strong background in JavaScript, which is essentially Scheme with a thin veneer of NewtonScript, Act-1, and Self. At least, that was my epiphany. I tried learning JavaScript multiple times, but it only clicked for me when I realized that I should ignore everything I ever learned about JavaScript and simply think of it as Scheme with dictionaries instead of lists as the ubiquitous data structure.  
  > **username_14**: @username_13 To expand on what you say, the "paradigm" of the Lisp family is that everything is a reference to first-class objects. This exists in the popular scripting languages: JavaScript, Python, PHP (except that arrays are copy-on-write). That hurdle is often the biggest when going from traditional languages to Lisp, and he's achieved it if he understands JS.  
  > **username_15**: Best class in which I ever enrolled was called, "Comparative Programming Languages." The list of languages included Lisp, Pascal, [SNOBOL4](https://en.wikipedia.org/wiki/SNOBOL), Smalltalk, [Prolog](https://en.wikipedia.org/wiki/Prolog), and one or two others. (It was forty years ago, my memory is dim.) The primary focus was on how different languages support different ways of thinking about a problem. Secondary attention was paid to the tradeoff between benefits of certain language features (e.g., Lisp's lexical closures) vs. the cost of implementing and/or using those features.  
  > **username_11**: @username_15, such a course is best if it focuses on "principles of programming languages" rather than "examples of programming languages". Your course may have been more in the first category.  
  
  ---
  
  ### Answer by username_16 on 2022-08-01. Score: 4
  
  The best book to get into Lisp is Peter Norvig's [PAIP](https://rads.stackoverflow.com/amzn/click/com/1558601910) - it showcases the core Lisp multi-paradigm approach and also some unique Lisp features that make it suitable for solving problems dealing with knowledge manipulation.
  
  The other great book for those who, like you, have significant conventional programming experience is Peter Seibel's [Practical Common Lisp](http://www.gigamonkeys.com/book/) which introduces Lisp in the familiar context of those language's approaches.
  
  Finally, for those who have very little programming experience or for kids, Conrad Barski's [Land of Lisp](http://landoflisp.com/) may be a good accessible and light-hearted introductory book.
  
  
  ---
  
  ### Answer by username_6 on 2022-08-01. Score: 1
  
  Frame challenge, don't *start* with a book. Start with Problem 1 on [Project Euler](https://projecteuler.net/archives) (spoiler, Problem 1 is just Fizz Buzz) and Google/Stack Overflow/language documentation and just write some code. Your first code will be terrible Lisp since your brain will still want to work procedurally and that's OK, imo actually experiencing this is the best way to really *know* how Lisp is different from procedural code.
  
  I think Project Euler is particularly good for this because a) a lot of the questions have very elegant recursive solutions so the reward for writing idiomatic Lisp is high, and b) there are usually several Lisp solutions posted in the forums for easy problems so you can see how other people solved the same problem. (Plus you get a bonus of seeing how people solved it in other languages.)
  
  Then you can go read a book and build an academic understanding on top of your intuitive understanding.
  
  > **Comments:**
  > **username_7**: The Dreyfus model of learning indicates that novices learn best through starting out by being told exactly what to do, moving on to minor variants of that, and only slowly generalising to rules, guidelines, and so on. I've found this to be true in my experience as well. That's why I recommend _The Little Schemer_ first; it will directly teach you the idioms rather than leaving you stumbling around trying to figure out what they are. The Project Euler problems would be a great exercise _after_ learning the basic patterns of problem solving in Lisp.  
  
  ---
  
  