We found 57 Reddit comments about The Little Schemer - 4th Edition. Here are the top ones, ranked by their Reddit score.
Thank you all for your responses! I have compiled a list of books mentioned by at least three different people below. Since some books have abbreviations (SICP) or colloquial names (Dragon Book), not to mention the occasional omission of a starting "a" or "the" this was done by hand and as a result it may contain errors.
edit: This list is now books mentioned by at least three people (was two) and contains posts up to icepack's.
edit: Updated with links to Amazon.com. These are not affiliate - Amazon was picked because they provide the most uniform way to compare books.
edit: Updated up to redline6561
If you have the time, learn scheme. The scheme books I've seen are extremely well written and go way beyond simply talking about the language.
You could start at SICP, but it doesn't assume previous programming knowledge. It's a beginner's book, but don't take this as "the book is easy". Try it out and see what you think about it.
Another one is The Little Schemer. This one is a book on recursion. It uses scheme too. It's probably the best programming book I've read. I never stopped to think about a ranking, but thinking on the spot, this would be the 1st.
SICP is freely available: http://mitpress.mit.edu/sicp/ with video lectures from a course (based on the book; or the book is based on the course) given at MIT http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/
This one is also pretty good. http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme.html
There are other scheme books out there. There is, for example, a "How to Design Programs" http://htdp.org/, which also has a course based on it: https://www.coursera.org/course/programdesign -- but I've never read this book or taken this course.
The Little Schemer will teach you to truly think recursively. It teaches via a continuous series of question and answer.
Haskell does throw a little too much at you at once, I agree. Another option though would be to go straight with ML, using The Little MLer. It's like The Little Schemer but, shockingly, in (S)ML. It'll get you enough of types and recursion and consing and so on that Haskell will "only" be adding laziness, type classes and monads. At the same time, I think it's a very accessible book, and it mentions food a lot.
Or perhaps even learn Scheme, then ML, then Haskell. Make your life easier at each stage, and learn more languages to boot.
I found some of the more abstract ways to introduce functional programming to be good fun. Like the Clojure Koans or The Little Schemer
Your post has too little context/content for anyone to give you particularly relevant or specific advice. You should list what you know already and what you’re trying to learn. I find it’s easiest to research a new subject when I have a concrete problem I’m trying to solve.
But anyway, I’m going to assume you studied up through single variable calculus and are reasonably motivated to put some effort in with your reading. Here are some books which you might enjoy, depending on your interests. All should be reasonably accessible (to, say, a sharp and motivated undergraduate), but they’ll all take some work:
(in no particular order)
Gödel, Escher, Bach: An Eternal Golden Braid (wikipedia)
To Mock a Mockingbird (wikipedia)
Structure in Nature is a Strategy for Design
Geometry and the Imagination
Visual Group Theory (website)
The Little Schemer (website)
Visual Complex Analysis (website)
Nonlinear Dynamics and Chaos (website)
Music, a Mathematical Offering (website)
Mathematics and its History
The Nature and Growth of Modern Mathematics
Proofs from THE BOOK (wikipedia)
Concrete Mathematics (website, wikipedia)
The Symmetries of Things
Quantum Computing Since Democritus (website)
On Numbers and Games (wikipedia)
Street-Fighting Mathematics (website)
But also, you’ll probably get more useful response somewhere else, e.g. /r/learnmath. (On /r/math you’re likely to attract downvotes with a question like this.)
You might enjoy:
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 - Has to be one of my favorites
Friedman & Felleisen Little Schemer seems noteworthy. Unorthodox, but nicely done.
And while I think that Meyer's technical writing isn't exactly the best, Object-Oriented Software Construction has a nice visual layout and is one of the few computer books that uses color effectively.
I reccomend the SICP book and SICP Video Lectures taught by Gerry Sussman, who is one of the creators of Scheme.
Higher-order procedures (Lecture 2A), Metacircular Evaluator (Lecture 7A) are simply badass if you've never been exposed to them.
Also, pick up a copy of The Little Schemer
I think the book does a good job of covering the mind-blowing [for me] concepts of continuations and the applicative order Y-combinator
You can find some in-the-browser Scheme interpreters too like this one:
Others have recommended great languages already, but you also need a good book to teach you not only the syntax and the libraries, but how to think in a different paradigm. So, here are some of my favorites:
The Little Schemer takes you from zero? to meta circular interpreter in 10 chapters of questions and answers.
If i had to suggest one book to you I'll suggest buy "The little schemer". Take a pen and a notebook with you. Keep the laptop aside and solve it on paper. Don't do anything else. Read it, solve it on paper then rest and think about what you just learnt. This book will change the way you think about computation if you have never seen any functional language before.
Oh and the book is in Socrates style, so you'll not feel you are just reading a book you'll feel you are talking to a master and having a dialogue with him. Some people can't get that style. It worked wonders for me.
Give it a shot. And pleasure is mine :)
We need a book like The Little Schemer, but for haskell.
Try the book "The little schemer"
The Little Schemer - 4th Edition https://www.amazon.com/dp/0262560992/ref=cm_sw_r_cp_apa_i_OST2Db7M254TR
I couldn't wrap my head around anything past very basic recursion. Once I had completed this book, I felt like I had a fairly solid understanding of the topic. Well worth the money, in my opinion.
Edit: As a side effect, you learn a little scheme which happens to be a very fun language.
The little schemer and the seasoned schemer. They start feeling like a really easy, gentle intro to programming. The dialog presentation style is amusing, and some serious Socratic style teaching going on about programming with an algebraic bent, and the second book builds up to a surprise ending, a rather interesting program -- I won't spoil the surprise for you.
While I have not read it, I hear great things about The Little Schemer
The Little Scheme on amazon
I used SICP which can be found here. It is really great!
There is now a 4th edition, which has a different name.
I second Practical Common Lisp, and may I recommend ANSI Common Lisp and The Little Schemer (I know its scheme, but when I did the exercises I did them in LISP).
I made some Python code quizzes that teach by example. The quizzes follow The Little Schemer teaching style.
I learned using Dr Racket and this little book: http://www.amazon.com/exec/obidos/ASIN/0262560992/ref=pd_sim_books/103-5471398-9229403
The little schemer is great.
Functional programming is notoriously difficult to teach due to people learning it and getting stuck in jargon. Then it becomes almost impenetrable when you combine that with a language with a totally new syntax (like haskell). There's an old joke that's somewhat tired but expresses this well: "what's so hard about monads? It's just a monoid in the category of endofunctors".
I'm glad someone suggested scheme. Then get her The Little Schemer. It's a nice introduction to the language in the form of step by step questions.
Warning: Food related examples may cause hunger.
Groovy is a scripting language so it solves a fundamentally different problem than Java does. It's fast enough for most things but it doesn't approach the speed of Java as it does a lot more work (hence burns more CPU time) to give you advanced features. When you want to build something big and powerful, you will choose Java over Groovy.
It's worthwhile learning both Java and Groovy as both run on the JVM and can interface directly with each other's objects. It's common to write a Java application with pieces of the codebase written in Groovy or the reverse: a Groovy application with pieces written in Java where better performance is required.
Especially while you're in school, learn as many languages as you can. Each new language you learn will teach you something new about programming and will improve your overall effectiveness as a programmer. Additionally it'll make it easier for you to keep up with technology. I've been a professional programmer for 4.5 years and have used more than 10 languages in my day to day work. It's expected that you can pick up a new language fairly quickly when necessary.
Specifically try to learn different classes of languages. Java is a Statically Typed, Compiled, Object Oriented Language. Scheme, on the other hand, has none of those attributes. It's a Dynamically Typed, Interpreted, Functional Language. Check out The Little Schemer if you're interested.
The most amazing demo I've seen at a meetup was done with Overtone. Whether or not to pursue Clojure or Python is a matter of taste/inclination. I think it would be really hard a priori to determine it since it requires a fair amount of exposure to decide whether or not you are interested in computing as an intellectual exercise.
If you think you'll end up writing code a fair amount, then this is like any trade: invest in good tools to get professional results. In my opinion, Clojure is the superior tool (compared with Python).
Both Python and Clojure claim Lisp as an antecedent but Clojure has these "killer features":
Your math background really shouldn't be an issue. If you're curious, though, check out this primer on lambda calculus.
Also highly recommended is The Little Schemer, which should fit your bill perfectly as a beginner to functional programming.
There are different variants of Lisp. One is Common Lisp. A really good book on it is online for free: Practical Common Lisp.
I have heard The Little Schemer recommended for learning Scheme, but I've never done so myself or read it.
The Little Schemer was a good read when I wanted to learn about recursion. It cleared everything right up =) Only the first few chapters are necessary:
The Little Schemer
This book is a great tutorial for "programming" in lisp just by reading the book. You can learn "lisp as a concept" more than lisp for work.
The Little Schemer
( google books preview )
Read The Little Schemer
The little schemer and later, The seasoned schemer have my highest recommendation.
Many others have answered this sufficiently but as it's your gf taking the course I thought I would chime in to suggest picking up The Little Schemer which is a cute book for informally learning the language and you will pick up cute-points.
Intro: The Little Schemer
Intro: Simply Scheme
Intermediate: Structure and Interpretation of Computer Programs
Program anything. The choice of IDE (JCreator) isn't very important. Try debugging a program if you've never done that. If you're on *nix, check out GDB and valgrind.
Your profs have probably set up the course structure for 4 years to work a certain way. Some where down that road (2nd semester for me after AP comp sci) I had to take Programming Languages and we used Scheme. Functional programming feels entirely different from imperative. I would suggest buying a copy of The Little Schemer. It is one of the few programming books I'll probably keep forever, and it doesn't break the bank. It will also open your mind in CS.
The Little Schemer. After you read that book, in addition to having had a car load of fun, you'll be pretty good with recursion, which is all that book basically teaches. It's pretty slim, around 100 pages IIRC. You could knock it out in under two weeks if you worked at it. Man, I love that book.
FWIW, the "applicative order Y-combinator" is the punchline of The Little Schemer, which I highly recommend.
Most explanations of it describe it as "how you do recursion without names," which is a good enough operational description, I guess. What it really is, historically, is the proof of Curry's paradox, a simplification of a proof that was originally arrived at by Alonzo Church's grad students, Stephen Kleene and John Rosser, as a demonstration that the untyped lambda calculus is logically inconsistent.
In other words, its significance isn't as a tool for implementing general recursion. Its significance is as a proof that the untyped lambda calculus isn't useful for what it was originally intended (i.e. use as a formal logic), and motivates the introduction of type theory in logic and computer science.
Heres something from an older reddit thread asked in /r/ruby and it suggest the book The Little Schemer to help you think recursive, if you got that down I guess writing your own recursive code is less of a struggle, I cannot however tell you how good that book is, so you should do some research on that yourself.
I think SICP is one of the greatest books I've ever read and that anyone who is serious about programming should read it (or be aware of the ideas discussed there).
However, it is a daunting book especially for newcomers (doubly so if the newcomer wants to get the most out of the book and wants to do every exercise).
I would recommend a book such as Simply Scheme to build up some background knowledge before tackling SICP.
I also highly recommend the Schemer series: Little Schemer, Seasoned Schemer.
Try Little Schemer.
If you're on OS X, you should also check out Clozure, not that SBCL isn't a fine choice. But Clozure has a functional Objective-C bridge that let's you write native applications on OS X. Both have a vastly superior debugging environment running under SLIME in emacs. Chicken debugging is unfortunately not much fun in comparison. That aside, Chicken's egg repository is a treasure trove and it's trivial to install and use them. The same cannot be said for ASDF[-INSTALL]. Depending on what Lisp libraries you're trying to install, you can easily end up in a mire of abandoned software. And while Cliki makes it appear like there's a lot of choice, I find that choice somewhat misleading: there's often 13 different libraries to wade through but only one or two that are still being maintained, if you're lucky. It takes a lot of time to vet the dependencies. On the other hand, I've found the quality of Chicken eggs to be much higher on average. This is not meant in any way to disparage any of the Lisp libraries, it's just that so many of them are no longer being actively developed and since so much of what we write these days depends on evolving Internet standards, having stale libraries is a real impediment. Chicken is a labor of love and it shows. It's also embeddable in C which is just insanely useful if you ever were to need it.
There are significantly worse things in life than working your way through The Little Schemer or SICP. Stick with Scheme though if you're going to be doing either. While the exercises can be expressed in Lisp, they're no fun to write in Lisp for reasons that are beyond the scope of a reddit comment. Once you know either you can switch back and forth fairly easily, though porting code between them, not so much.
Anyone else notice the thinly veiled Little Schemer reference?
read "The Little Schemer":
It'll turn your brain inside-out, and you'll learn more about recursion in this short book than I think you will in most other places
This is really interesting. I just finished The Little Schemer recently, and I'm also new to Arduino, would be great if I fuck around with both.
Newbie question. Does this compile the Lisp program into machine code? I don't think I understand the way compiling works in Arduino.
Hello, this book will make you smarter, I promise
Source: I program professionally for almost a decade now
I would recommend "The Little Schemer".
This is the example that helped me understand recursion.
if xs == :
return xs + sumlist(xs[1:])
This is a recursive summation function. There are better ways to do it, but this is the most readable. Basically, it will return 0 if the list is empty; otherwise, it adds the current headof the list xs to the value returned by the application of the function to the tail of the list xs[1:].
x = sumlist([1, 2, 3]) # 0 - Initial call.
xs == ? nope # 1 - Check terminal condition.
1 + sumlist([2, 3]) # 1 - Add current head (1) to value of next call.
xs == ? nope # 2 - Check terminal condition.
2 + sumlist() # 2 - Add current head (2) to value of next call.
xs == ? nope # 3 - Check terminal condition.
3 + sumlist() # 3 - Add current head (3) to value of next call.
xs == ? yes # 4 - Check terminal condition.
0 # 4 - Return 0.
3 + 0 # 3 - Higher frame: add 3 to 0.
3 # 3 - Return 3.
2 + 3 # 2 - Higher frame: add 2 to 3.
5 # 2 - Return 5.
1 + 5 # 1 - Higher frame: add 1 to 5.
6 # 1 - Return 6.
x = 6 # 0 - Assign the result of the recursion to x.
If you're interested in this, the book The Little Schemer is pretty good.
I agree with the recommendations for SICP - it's great.
In addition to the MIT videos, there are videos from Brian Harvey's SICP class at UC Berkeley. They're available both on YouTube and in iTunes.
However, I'll admit that I found SICP a bit overwhelming at first. For context, I'd been programming (primarily Python) for a couple years, but it was my first exposure to Lisp. I ended up taking a brief break from it to work my way through The Little Schemer and The Seasoned Schemer. It only took a week or two and at the end I was much more comfortable diving into SICP.
Not everyone likes the Schemer books - they're quite distinctive - but I loved them. I found them particularly helpful in really groking recursion and continuations.
Some great books for learning Scheme are The Little Schemer and The Seasoned Schemer by Daniel P. Friedman.
right on, for lisp or scheme I recommend the little lisper or the little schemer
Yes, it is, and is listed here: https://www.ai-class.com/resources. Besides, Sebastian's style is similar to The Little Schemer(http://www.amazon.com/Little-Schemer-Daniel-P-Friedman/dp/0262560992): The author presented you with numerous examples, and you'll see the key concepts emerge.
If you are new to programming I can't recommend python enough. I was able to pick up the language in a couple of weeks in high school and now I use it every day at work.
If you are feeling a little more adventurous get the book The Little Schemer. The book kickstarted my love of computer science.
I'm going to go against the grain here with my recommendation. I'm a guy who was in a similar position years ago. I've since transitioned from web development to game programming and have working knowledge of 7+ languages.
I would recommend not switching platforms from the web. One of the most important skills guys like us can have is seeing where technology is heading and betting on the right horse. It's very clear that webapps are going to be even more important in the future. You can already make desktop apps with web technology naively in pretty much all major OSs now.
After that, learn a good server side language like Java, Python, or C#. (C# is in very high demand, and has many applications) Or learn all three and you'll be very well positioned career wise. Well, make sure to get some experience with SQL too for good measure.
Also if you want to have a good challenge instead of being bored on those easy things, like drawing shapes, why don't you try Udacity's fine WebGL course? Jumping in the deep end isn't bad as long as you don't expect it to be easy.
MIT used to, not sure if they still do.
Scheme is a surprisingly good choice for CS101 precisely because it doesn't distract with lots of syntax or details of internal workings of the computer.
You could try learning scheme. Try out the little schemer .
Then graduate to SICP