Realm of Racket: Learn to Program, One Game at a Time!

A lot has been written about LISP and it's magical powers and how it has done all the things modern languages do 50 years ago and so on and so on. Wise men praise LISP for decades but the mainstream resists to follow. To finally understand the whole debate a little better I decided to read a book about it (well, I tried the little elefants book before and that shure taught me recursion but it's not the same). Not planning to make it my main language Racket appeared to be the ideal dialect (a dialect of scheme which is a dialect of LISP but what the heck, I want to get the ideas behind all that detail...). It is great for test-driving as it is easy to install, comes with batteries included and leaves enough room for further development towards other interesting topics (planning to learn some logic programming in the future?) You just don't have to worry where to get the GUI libraries, database connection, what IDE to use... - it's all just there and it has very good documentation at your fingertips and it has passed the test of time (back when it was callt PLTScheme...).The backside of Racket: If you like learning from books, you have little choice. How to design Programs (HtDP) is an old book, the new version being online to read for years and Realm of Racket. I like dead tree that I can read in a hotel with fragile internet connection and on the beach with no internet connection. So this is, what you get (go learn Java if you need a lot of choices in books...).The title with "Games" and the pictures leave the impression of a programming book for newbies. Well, it is not. The fast pace in which concepts like a REPL, recursion or functions being passed to functions or the lot of (for) functions is handled is good for people with a little experience in functional programming. The games are not trivial but their construction is not described in the book. It's a "read the code to see more, we'll only explain the new concepts herein" approach. Again, that's not for a newbie programmer and experienced programmers may like this or not. I passed the "read the code to the whole program" part and was busy enough reading the book. Games are used as examples in order not to shy those away who are bored of computing fibonacci numbers with each new language again. Even for someone with no interest in writing games this is not a bad approach. For someone with sincere interest in game development: Games are a means of teaching in this book. It is not really a book about game development.I'm having real problems trying to figure, whom this book is for. It is easy enough for light reading but heavy in content. Some important aspects are covered very shortly. There is a kind of appendix called "Close Paren" where object orientation in Racket ist explained in 4 pages and macros are described in another 4 pages. Not enough for me to grasp, why macros apparently are what helped Paul Graham beating the averages. So in a way, the book did not do what I read it for (see above).Why still 4 stars? It is not a 5 star book, but the book made me start programming in Racket. I finished the first usefull programm within three or four days. It used lots of things that are not covered in the book (drawing on canvas, building input forms, making menus,...) but I was able to read the built-in help and draw the necessary information out of it for everything I planned to do. I now plan to write something new in Racket, that was originally planned to be programmed in another language. So in a way it helped me a lot towards Racket and that's worth 4 stars.If you are patient enough you can learn a lot about the main authors intentions on this book on youtube here: [...] and you can preview some of the games that are not truely programmed within the book here: [...]

The inverted review bell curve on Abelson's seminal book on Lisp and functional programming (Structure and Interpretation of Computer Programs, Second Edition) shows either love or hate, and little in between! Those who love it say it is a life changing experience for mathematicians, engineers and physicists as well as programmers, and indeed Abelson does border on the mystical when describing nested recursive functions with "hundreds" of parentheticals preceding quantum-level differential equations, all running on numerics, beneath which are (self defining recursive quantum states) and....The problem, especially with those who hate it, is that lambda calculus, recursion, and multiple paradigm (imperative, functional, logical, etc.) models mean that each sentence is an adventure in study, not reading. IOW, I stopped highlighting when I realized I was highlighting the whole page!This awesome new Racket gem makes Abelson an unprecedented one-two punch if you REALLY want to understand some of the hottest new concepts in programming-- at a 30,000 foot level, yet with a TON of fun, down to earth exercises. Lisp has evolved as the second oldest (months after FORTRAN) language that is not only still in use, but still producing new dialects, as this book demonstrates! I mean, a data structure not of hashes and trees but of LISTS??? You'll learn to your amazement how lists can even handle multiprocessor and concurrent computing nightmares with recursion that would defy the most agile trees. Talk about ancient and up to date at the same time!The coolest thing about Racket, and even Scheme and Common Lisp, is that you can create your own "complete" programming environment, in this case to play with art and games, including compilers and interpreters! C# started with some multi paradigm elements and is now even adding functional programming, but being part of the .net family, there are limits. Yes, you can design a GUI AND a game in C#, but Racket allows you to create an entire programming universe from o/s to environment, SDK, compiler, GUI, language, libraries... all virtually!If you look at a typical coding interview, you'll have the "solve this phony, contrived problem" on the whiteboard. Yet four of the hottest career areas in IT AREN'T in specific language coding (so much of it is being outsourced to India, China and Russia)-- they are in management of: 1. Data Science 2. Embedded Systems 3. Networking 4. Sploits.There even is a new "CTO" type job-- CDSO, for "Chief Data Science Officer." These management, team leadership and high level positions don't require you to create a list prioritization algorithm on the whiteboard in C# in half an hour, but they DO require you to understand how systems from the machine and network levels relate to solutions in choice of languages, software and --especially-- paradigms.In talking with programmers and engineers all day who submit new software for patents, I'm astonished at how many got all the way through even grad school (including Stanford and MIT) without taking a single paradigm class! They can generally tell you which apps work better with trees vs. arrays, but at a high level, why to choose functional vs. imperative is often really foggy.Solution: PLAY WITH RACKET, then read Abelson! Even if you're an autodidact, this awesome and up to date Lisp text is perfect for self study when carving out your own dream job or starting your own practice. The authors are teachers par excellance, and the pedagogy is beyond painless-- you're half way through recursion vs. iteration before even knowing you've learned it! And while you're at it, you are playing with components and paradigms in ways you've never tried before even if you're a Lisp jock-- because this text takes the time to INCLUDE imperative and logical options. This is possible because Racket moves a little toward OOP just as C# (3.0 and up) has moved a little toward functional, including many steps beyond Scheme.For those who feel Lisp is out of date or a "has been" (never mind that Lisp invented garbage collection and even presaged early oop (data/object/call/argument units) and that binaries and other newer data structures are coming back around to lists in some of the hottest research, even IN imperative), I guarantee that this book will dispel your doubts! And, if you tried Abelson, loved it, but was missing half the points (I sure was), try Racket first--Abelson won't become easy, but it will, as Abelson said himself as his primary objective, make it a LOT more fun.Be SURE to get the second edition of Abelson, however, as he completely reoriented it around a new central theme crucial today to multiprocessing-- the time/memory challenge. You can get Ableson 2ed (see link in first paragraph) used at a great price now. I give it as a gift to programmer friends, and this new Racket text would make a great gift too! This author also wrote the awesome Little Schemer book (The Little Schemer - 4th Edition) which is another excellent adjunct to Abelson.EMAIL ANSWER: A new lisper asked if this book will help with things like closure. Absolutely! In fact, lexical (or functional) closure, when combined with environments, binding and defun/define macros ARE oop at a very basic level, except that they REQUIRE garbage collection. Let Over Lambda (LoL) is "the" closure book, but Racket gives many more practical tips and uses than that "heavy" text (no comparison really, this book is pure enjoyment, LoL requires two double shot starbuck ventis per sentence-- NOT for beginners). Q. How can other languages implement closure? A. Technically C can't due to no garbage collection (hence no fast and unlimited stack vs. heap options, especially since it and C++ are stack based), but C# and many others can.Although anonymous methods ARE NOT closure, they offer "closure analogs" like callbacks and blocks (in C and C++ for you circuit folks), Local classes in Java, Delegates, and after 3.0, even lambda expressions in C# (do NOT use closure if a lamda will work more simply), overloading operators, etc. Scheme/Racket/Lisp/Clojure... jocks will argue that the differences between oop and functional are semantic, because 1 macro can take care of inheritance, and object orientation is another word for a LISP list function combining procedure and state, and with closure, can easily duplicate the entire oop benefit. Macros are essentially functions that return lists as this book will teach us, but since those lists can just as easily contain code as data, as well as environments and bindings, the "oop" concept was either anticipated, subsumed, or invented by Lisp decades ago, depending on your point of view!The whole point of learning Racket, at a deep level of understanding paradigm fits in addition to the fun apps in this book, is about time and memory and really "getting" high level (but deep and detailed) program and systems engineering, in many more aspects than most programmers encounter. Stack vs. heap based eventually becomes a sticky wicket for all programmers and engineers, especially with today's concurrency challenges. Look at Erlang-- it dances so easily between functional and imperative because it uses BOTH stack and heap! Besides, lists are way more intuitive and fun ds's (in my biased and elderly opinion) than trees, hash tables, binaries, etc.-- even ON the whiteboard!Library Picks reviews only for the benefit of Amazon shoppers and has nothing to do with Amazon, the authors, manufacturers or publishers of the items we review. We always buy the items we review for the sake of objectivity, and although we search for gems, are not shy about trashing an item if it's a waste of time or money for Amazon shoppers. If the reviewer identifies herself, her job or her field, it is only as a point of reference to help you gauge the background and any biases.

I love this book! It's perfect example that the best way to learn is learning by doing and having fun! Recommended!

I was looking for a compact documentation of the Racket language and IDE to understand some code snippets in the dissertation of Neil Toronto about "Trustworthy, Useful Languages for Probabilistic Modeling and Inference". Racket is an extension of Scheme which is an extension of Lisp - the language of symbolic AI -. RoR is the only reference to Racket in book form. Unfortunately it is not addressed to academics but to newbees in programming. Similar in style to Conrad Barski's "Land of Lisp" it is devoted to "Learn to Program, One Game at a Time!" (this is the subtitle). Concepts range from simple functional programming to higher functions with nested lambdas, lazy evaluation, memoization, to imperative programming with states and guis. I would be glad if I had such an introduction nearly forty years ago. At that time I had to learn imperative Algol for solving dull numerical problems.Learning Racket makes it necessary to switch to a different language when doing some serious programming afterwards. Clojure is a natural follow up language. Scala is not bad too. Martin Odersky feels himself in the tradition of Abelson & Sussmans seminal book "Structure and Interpretation of Computer Programs". So beware, when learning Racket you later have to move on to a second production language. What's the rating? 5 stars for the didactic concept, minus 2 stars for the verbose sophomore-orientated style and the missing references.

I found these products very informative. the product lived up to its advertised purpose and the cost was very affordable.