- Paperback: 312 pages
- Publisher: No Starch Press; 1 edition (June 25, 2013)
- Language: English
- ISBN-10: 1593274912
- ISBN-13: 978-1593274917
- Product Dimensions: 7 x 0.9 x 9.2 inches
- Shipping Weight: 1.5 pounds (View shipping rates and policies)
- Average Customer Review: 16 customer reviews
- Amazon Best Sellers Rank: #212,151 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Realm of Racket: Learn to Program, One Game at a Time! 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
All Books, All the Time
Read author interviews, book reviews, editors picks, and more at the Amazon Book Review. Read it now
Frequently bought together
Customers who bought this item also bought
An Excerpt From the Preface: "Why Should I Learn About Racket?"
About the Author
Professor Matthias Felleisen is one of the original authors of the Racket language and a co-author of The Little Schemer and How to Design Programs. In 1995, Felleisen launched the TeachScheme! Project, reaching out to high schools with a radically novel computing curriculum. Felleisen is the 2012 recipient of the ACM Special Interest Group on Programming Languages (SIGPLAN) Lifetime Achievement Award as well as ACM's 2009 Karl V. Karlstrom Outstanding Educator Award. He is currently a Trustee Professor in the College of Computer and Information Science at Northeastern University in Boston, Massachusetts.
Conrad Barski has an M.D. from the University of Miami and nearly 20 years of programming experience. The author of Land of Lisp, Barski is also an avid cartoonist, having created the popular alien Lisp mascot and many graphical tutorials.
David Van Horn is a research professor who has programmed in Racket and Scheme for over a decade.
Eight students of Northeastern University contributed to Realm of Racket: Forrest Bice, Rose DeMaio, Spencer Florence, Feng-Yun Mimi Lin, Scott Lindeman, Nicole Nussbaum, Eric Peterson, and Ryan Plessner.
Top customer reviews
It is a very good introduction to the language. If you have to take Northeastern's CS5010 and work threw this book before starting the course, you will be 2 steps ahead of most other students. The book was not designed for this course but is still a good reference for the course. It uses some things not allowed in the course and the course covers more than what is in the book. Even if you did not use the book before starting the course it is still worth reading at times.
coding style and functional programming. I'm sure it didn't dive into many of the advanced ideas on the topic, but it was fun and enough to get me started doing some functional programming. Very fun. Very well written.
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.
The biggest issue to learn programming is, at least for me, the huge difference between real world codes and the example toy codes in the tutorial books. Syntax/Semantics of that languages are already complex for beginners, and you should master most of them to progress next level. So, the example codes focus on to show the syntax and semantics. At this stage, you can hardly make an interesting program, because what you have learnt is just the language. At the next stage such as frameworks, you would get far more complex theories and knowledges all at once. It's because the languages and the libraries/frameworks are designed for professional use, not for education.(There are also many languages regarded as "easy", but that means "easy to use" for professional programmers, and not "easy to learn." for non-programmer.) Tutorials at this stage focus on to explain the complex structure of the framework and many detailed APIs. So, you cannot learn how to program at this stage either. After the long and tedious learning process, you can finally start to learn how to program. This learning method is simply wrong and makes programming looks unnecessarily harder than it actually is. Far better when they start with a simple but real world-related interesting task with enough simplified language and libraries, and gradually motivate to more interesting but challenging tasks with an appropriately extended language. If the reader is motivated with the program, they experiment themselves. This is what the learning process should be. But unfortunately, it would be a really hard work with ordinary programming languages, because the languages and libraries they offer are already fixed for professional programmers. Each API covers a very small specific task and is very detailed. It's like that you should learn axiomatic set theory first as a prerequisite, and then you can solve simple arithmetic equations with it.
But Racket is different and the reason is manifold. First, the author of this book is also the founder of the language Racket. He made a module for that educational purpose and it is included in the official Racket distribution. Second, the language Racket, as a descendent of Scheme, has a very small and simple set of rules. The size of the basic syntax/semantics of scheme is like that of C without pointer, and while C without pointer is a useless one, the basic level of scheme is powerful. So, the tutor and the reader can concentrate on program logic and the various programming concepts without language-specific hassle. Also, Racket offers a decent IDE, which is portable and includes nearly complete library collections, so that novice programmers don't need to struggle to search, download and install libraries to do something other than command-line I/O. It is the best educational environment hands down. With all that supports from language and IDE, the author could easily control the difficulty and pace, without sacrificing contents. Actually, this book, which is for absolute programming novices, has introduced basic GUI, network and AI programming through example game programs under 300 pages. It is really remarkable. It can be achieved only with the mutual cooperation of the tutorial, the programming environment and the language. I personally prefer the style of the original "land of lisp" to "realm of racket"(while realm of racket shows more interesting graphical game codes, the explanation is drier and the example code snippets are highly unordered.), but what the programming environment Dr. Racket offers is really a huge advantage.
In fact, though all the program in the book is written in Racket, what you learn from this book is not Racket. Racket/Scheme actually is a deep language, which could be hardly covered by an introductory programming book.(If you are an experienced programmer and want to learn just Racket, visit their website.), What you can learn from this book is the espresso version of the general programming experience. My first programming language was Java from my university, and I had to put far more time and effort to get the similar experience with less motivations. If I had such an experience before starting to learn Java, I would be far more motivated and could know what's important, where to focus, and ultimately, could learn more effectively. Many experienced programmers learn other programming languages easily in short period of time, because on the one hand, much of their experience is not language-specific and can be applied to other languages, and on the other hand, they know exactly what's important and what is not from their experience. Therefore, it makes far easier the learning process if you have some basic experience before starting to learn a professional language, imho.
If you are an absolute beginner, I recommended to read this book first, even if you don't have any interest on scheme or racket.
Most recent customer reviews
And the details on the DrRacket programming interface you can find elsewhere.