Reddit Reddit reviews The Little Schemer - 4th Edition

We found 57 Reddit comments about The Little Schemer - 4th Edition. Here are the top ones, ranked by their Reddit score.

Computers & Technology
Computer Software
The Little Schemer - 4th Edition
Check price on Amazon

57 Reddit comments about The Little Schemer - 4th Edition:

u/cronin1024 · 25 pointsr/programming

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 These are not affiliate - Amazon was picked because they provide the most uniform way to compare books.

edit: Updated up to redline6561

u/phao · 21 pointsr/learnprogramming

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: with video lectures from a course (based on the book; or the book is based on the course) given at MIT

This one is also pretty good.

There are other scheme books out there. There is, for example, a "How to Design Programs", which also has a course based on it: -- but I've never read this book or taken this course.

u/gingenhagen · 15 pointsr/ruby

The Little Schemer will teach you to truly think recursively. It teaches via a continuous series of question and answer.

u/kalmar · 14 pointsr/programming

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.

u/gremy0 · 14 pointsr/ProgrammerHumor

I found some of the more abstract ways to introduce functional programming to be good fun. Like the Clojure Koans or The Little Schemer

u/jacobolus · 11 pointsr/math

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)
Solid Shape
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:

u/charles__l · 11 pointsr/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:

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.
u/tooz · 9 pointsr/programming

The Little Schemer - Has to be one of my favorites

u/mhd · 8 pointsr/programming

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.

u/dropafew · 8 pointsr/scheme

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:

u/[deleted] · 8 pointsr/programming

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:


  • Dennis Merritt: Adventure in Prolog (free!) - the gentlest introduction to a new programming language I've ever seen.
  • E. Shapiro - L. Sterling: The Art of Prolog (Amazon)

    Common Lisp:

  • Paul Graham: On Lisp (free!)
  • Peter Siebel: Practical Common Lisp (free!)
  • Peter Norvig: Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp (Amazon)


  • H. Abelson - G. J. Sussman: Structure and Interpretation of Computer Programs (free!) - the classic text; if you read only one book from this list, let it be this one.
  • D. Friedman - M. Felleisen: The Little Schemer (Amazon)
  • D. Friedman - M. Felleisen: The Seasoned Schemer (Amazon)


  • B. O'Sullivan - D. Stewart -J. Goerzen: Real World Haskell (free!)
  • Simon Thompson: Haskell: The Craft of Functional Programming (Amazon)
  • Paul Hudak: Haskell School of Expression (Amazon)

u/mxyzptlk · 8 pointsr/programming

The Little Schemer takes you from zero? to meta circular interpreter in 10 chapters of questions and answers.

u/firesofmay · 8 pointsr/compsci

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 :)


u/vagif · 8 pointsr/programming

We need a book like The Little Schemer, but for haskell.

u/Andrew_Hager · 7 pointsr/learnprogramming

Try the book "The little schemer"

The Little Schemer - 4th Edition

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.

u/cparen · 7 pointsr/compsci

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.

u/Grel · 6 pointsr/learnprogramming

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!

u/khafra · 4 pointsr/programming

Since you're fuzzy on the whole "Turing Complete" concept, I wouldn't start at the toy app level. The best place for you is probably The Little Schemer with javascript transformations from applied (Unless you want to get yourself an actual Scheme implementation, which would be fantastic). Also, if you work through both that, and "Structure and Interpretation of Computer Programs," you'll have super-high nerd cred.

u/jbos1190 · 4 pointsr/learnprogramming

There is now a 4th edition, which has a different name.

u/DrStrngeluv · 4 pointsr/lisp

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).

u/MrPowersAAHHH · 4 pointsr/learnprogramming

I made some Python code quizzes that teach by example. The quizzes follow The Little Schemer teaching style.

u/Julian-Delphiki · 3 pointsr/scheme

I learned using Dr Racket and this little book:

The little schemer is great.

u/wreckedadvent · 3 pointsr/learnjavascript

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".

That all being said, I think that means the best way to seriously get into it is to avoid resources that focus on jargon. Unfortunately javascript is not a great language for FP, so most of the great resources I can think of focus on other languages:

  • F# for fun and profit is basically everything I just said, but for F# (this specifically talk really helped me but check out the whole website):

  • I've been consuming content from Mark Seemann for a while. I liked his book on dependency injection a lot, but he also gives good talks on some functional stuff:

  • LYAH (learn you a haskell) is somewhat obligatory. I don't really like it too much since it almost immediately delves into typeclasses (which I think are very intimidating to a newbie) but I would feel bad not giving it a mention:

  • The little schemer is a good way to pick up LISP (and you will eventually pick up LISP if you stay in functional circles long enough, the language is just too perfect). LISP is especially good for getting you out of thinking of things in imperative steps and more like streams of data (which is the big take-away).

  • On the javascript side of things, react and react-likes can actually be a decent way to start thinking functionally, if you avoid the class-based stateful components. Redux takes a lot of lessons learned from FP. I picked up react many, many moons ago so I don't remember any good resources there, sorry.

  • The elixir home page is very dry, but focuses on learning a functional language pragmatically and without a lot of the higher-level jargon.

  • Rust! The rust book is one of the better programming books I've read, and rust will probably be the most approachable thing on the list if your background is javascript, especially if you're already comfortable with how promises work. Rust is heavily influenced by functional languages, to the point it doesn't even have exceptions.
u/stuhacking · 3 pointsr/programming

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.

u/CapoFerro · 3 pointsr/leagueoflegends

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.

u/afmoreno · 3 pointsr/Clojure

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":

  • macros: the ability to add new features to the language. One way to program in Lisp is to design a Domain Specific Language so you can interact with your problem using its language, not some arbitrary computer language.
  • literal syntax: think of this as a way to describe sets and other data structures that are core to programming. Here Python is great but Clojure is better!
  • very thoughtful design of its data structures so that you can move up and down a ladder of abstraction to pick, say, the right type of collection for your problem (e.g. a list vs. a vector)
  • functional programming is encouraged and supported with immutable data types. Not having immutable data types makes life really hard because one has to deal with values that change over time. If your domain is music, where time is of the essence (pardon the pun), I would think that immutability would be important to you.
  • Clojure runs on the browser (ClojureScript). This means that you can write all your code in one language (if you end up doing a lot of it, then this matters).

    Python is really nice but after having worked with it for years, I felt that I could do better. Things that pushed me away:

  • Writing DSLs is not the default. Sure, one can use parsers and create a grammar, but this is more like building a programming language instead of a DSL. (Sure, there is method overloading which one can take pretty far...)
  • Immutability: for my domain (processing data with a time dimension) it was very painful to keep track of values since the only efficient data structures were mutable. The core issue that I had debugging was that I had a hard time tracking when the data changed. Having immutable values provides a dead-simple solution to the problem of history.

    I wholeheartedly recommend reading SICP to anyone who ends up writing code in Lisp because it is a great way to expand one's mental model of what's possible in terms of capturing abstraction in code. And I think Scheme is a really nice language to learn. If you are interested, you might want to look at The Little Schemer. I have found Chez Scheme (now free) to be excellent.

    Good luck--feel free to write if you have any questions.

    Cheers! afm
u/nsxt · 3 pointsr/functionalprogramming

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.

u/bo1024 · 3 pointsr/learnprogramming

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.

u/twolfson · 2 pointsr/Frontend

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:

u/ccc123ccc · 2 pointsr/programming

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.

u/burke · 2 pointsr/IWantToLearn
u/solid7 · 2 pointsr/learnprogramming

The little schemer and later, The seasoned schemer have my highest recommendation.

u/fnord123 · 2 pointsr/programming

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.

u/justsomebuddypal · 2 pointsr/learnprogramming

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.

u/ryanklee · 2 pointsr/learnprogramming

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.

u/paultypes · 2 pointsr/programming

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.

u/siedler084 · 2 pointsr/learnprogramming

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.

u/kanak · 1 pointr/programming

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.

u/nmtake · 1 pointr/learnprogramming
u/ddp · 1 pointr/lisp

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.

u/asciilifeform · 1 pointr/

Anyone else notice the thinly veiled Little Schemer reference?

u/schoof · 1 pointr/compsci

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

u/CSMastermind · 1 pointr/learnprogramming

Entrepreneur Reading List

  1. Disrupted: My Misadventure in the Start-Up Bubble
  2. The Phoenix Project: A Novel about IT, DevOps, and Helping Your Business Win
  3. The E-Myth Revisited: Why Most Small Businesses Don't Work and What to Do About It
  4. The Art of the Start: The Time-Tested, Battle-Hardened Guide for Anyone Starting Anything
  5. The Four Steps to the Epiphany: Successful Strategies for Products that Win
  6. Permission Marketing: Turning Strangers into Friends and Friends into Customers
  7. Ikigai
  8. Reality Check: The Irreverent Guide to Outsmarting, Outmanaging, and Outmarketing Your Competition
  9. Bootstrap: Lessons Learned Building a Successful Company from Scratch
  10. The Marketing Gurus: Lessons from the Best Marketing Books of All Time
  11. Content Rich: Writing Your Way to Wealth on the Web
  12. The Web Startup Success Guide
  13. The Best of Guerrilla Marketing: Guerrilla Marketing Remix
  14. From Program to Product: Turning Your Code into a Saleable Product
  15. This Little Program Went to Market: Create, Deploy, Distribute, Market, and Sell Software and More on the Internet at Little or No Cost to You
  16. The Secrets of Consulting: A Guide to Giving and Getting Advice Successfully
  17. The Innovator's Solution: Creating and Sustaining Successful Growth
  18. Startups Open Sourced: Stories to Inspire and Educate
  19. In Search of Stupidity: Over Twenty Years of High Tech Marketing Disasters
  20. Do More Faster: TechStars Lessons to Accelerate Your Startup
  21. Content Rules: How to Create Killer Blogs, Podcasts, Videos, Ebooks, Webinars (and More) That Engage Customers and Ignite Your Business
  22. Maximum Achievement: Strategies and Skills That Will Unlock Your Hidden Powers to Succeed
  23. Founders at Work: Stories of Startups' Early Days
  24. Blue Ocean Strategy: How to Create Uncontested Market Space and Make Competition Irrelevant
  25. Eric Sink on the Business of Software
  26. Words that Sell: More than 6000 Entries to Help You Promote Your Products, Services, and Ideas
  27. Anything You Want
  28. Crossing the Chasm: Marketing and Selling High-Tech Products to Mainstream Customers
  29. The Innovator's Dilemma: The Revolutionary Book that Will Change the Way You Do Business
  30. Tao Te Ching
  31. Philip & Alex's Guide to Web Publishing
  32. The Tao of Programming
  33. Zen and the Art of Motorcycle Maintenance: An Inquiry into Values
  34. The Inmates Are Running the Asylum: Why High Tech Products Drive Us Crazy and How to Restore the Sanity

    Computer Science Grad School Reading List

  35. All the Mathematics You Missed: But Need to Know for Graduate School
  36. Introductory Linear Algebra: An Applied First Course
  37. Introduction to Probability
  38. The Structure of Scientific Revolutions
  39. Science in Action: How to Follow Scientists and Engineers Through Society
  40. Proofs and Refutations: The Logic of Mathematical Discovery
  41. What Is This Thing Called Science?
  42. The Art of Computer Programming
  43. The Little Schemer
  44. The Seasoned Schemer
  45. Data Structures Using C and C++
  46. Algorithms + Data Structures = Programs
  47. Structure and Interpretation of Computer Programs
  48. Concepts, Techniques, and Models of Computer Programming
  49. How to Design Programs: An Introduction to Programming and Computing
  50. A Science of Operations: Machines, Logic and the Invention of Programming
  51. Algorithms on Strings, Trees, and Sequences: Computer Science and Computational Biology
  52. The Computational Beauty of Nature: Computer Explorations of Fractals, Chaos, Complex Systems, and Adaptation
  53. The Annotated Turing: A Guided Tour Through Alan Turing's Historic Paper on Computability and the Turing Machine
  54. Computability: An Introduction to Recursive Function Theory
  55. How To Solve It: A New Aspect of Mathematical Method
  56. Types and Programming Languages
  57. Computer Algebra and Symbolic Computation: Elementary Algorithms
  58. Computer Algebra and Symbolic Computation: Mathematical Methods
  59. Commonsense Reasoning
  60. Using Language
  61. Computer Vision
  62. Alice's Adventures in Wonderland
  63. Gödel, Escher, Bach: An Eternal Golden Braid

    Video Game Development Reading List

  64. Game Programming Gems - 1 2 3 4 5 6 7
  65. AI Game Programming Wisdom - 1 2 3 4
  66. Making Games with Python and Pygame
  67. Invent Your Own Computer Games With Python
  68. Bit by Bit
u/smurfyfrostsmurf · 1 pointr/arduino

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.

u/quantumproductions_ · 1 pointr/learnprogramming

Hello, this book will make you smarter, I promise

Source: I program professionally for almost a decade now

u/mac · 1 pointr/lisp

I would recommend "The Little Schemer".

u/asthasr · 1 pointr/learnprogramming

This is the example that helped me understand recursion.

def sumlist(xs=[]):
if xs == []:
return 0
return xs[0] + 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[0] 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([3]) # 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.

u/johnmastro · 1 pointr/emacs

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.

u/organic · 1 pointr/IWantToLearn

Some great books for learning Scheme are The Little Schemer and The Seasoned Schemer by Daniel P. Friedman.

u/muddo · 1 pointr/learnprogramming

right on, for lisp or scheme I recommend the little lisper or the little schemer

u/g9yuayon · 1 pointr/aiclass

Yes, it is, and is listed here: Besides, Sebastian's style is similar to The Little Schemer( The author presented you with numerous examples, and you'll see the key concepts emerge.

u/ewhouse · 1 pointr/MyLittleSupportGroup

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.

u/g1i1ch · 1 pointr/explainlikeimfive

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.

Dude, don't sweat these feelings you're having. You're just at a wall. We all reach different kinds of walls in this career and they're really the best thing ever. It means you're about to jump ahead in skill by at least 10x. You just got to find the trigger for it. Be patient and try different things. Go check out Udacity and do some courses on there. Also this is the time to start reading books. Not just any cheap book you find. Good books that will give you the perspective of an industry professional. Books like JavaScript: The Good Parts, Code Complete, The Pragmatic Programmer, or The Little Schemer. Also it doesn't matter what language the books are in to enjoy it. 98% of all programming languages are the same anyways, which you'll soon learn. For the most part, they just have moderately different ways and syntax to do the same thing.

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.

I say learn JavaScript front and back. Read JavaScript: The Good Parts and JavaScript: The Definitive Guide cover to cover. Once you learn JavaScript it'll be very easy to transition to any C-based language, which is most of them. In fact I credit JavasScript for giving me the basics to jump to just about any language comfortably and pick it up in a few weeks.

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.

u/metamatic · 1 pointr/javascript

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.

u/zitterbewegung · -1 pointsr/programming

You could try learning scheme. Try out the little schemer .
Then graduate to SICP