Many others have already said wonderful things about this book, and I wholeheartedly agree with them. As a Ph.D. in Applied Mathematics and Statistics, I find myself in an unusual position: despite the growing necessity of coding in modern research and experimentation, I simply don’t enjoy it. While I believe I have the capacity to code, it has never been something I truly liked. That’s why Al’s books have been a revelation for me. Al is a great educator. He has a talent of teaching programming in a way that resonates. It truly got me intrigued. I’ve purchased several of his books to show my gratitude.

The Recursive Book of Recursion teaches recursion in a clear, methodical way that actually helps you understand how it works, rather than just showing patterns to memorize. The explanations build gradually, making complex ideas feel approachable instead of abstract or intimidating.

The Python and JavaScript examples are well designed and reinforce the underlying concepts, helping you develop the right mental model for recursive thinking. The exercises are meaningful and encourage real understanding, not trial-and-error coding.

Overall, this is a well-structured, thoughtful book for anyone who wants to genuinely learn recursion and feel confident applying it in real code. Highly recommended for developers who want a deeper, clearer grasp of this topic.

I encourage folks learning programming to first buy Al Sweigart’s book, “Automate the Boring Stuff with Python”. That book teaches you Python from the beginning and assumes no previous knowledge. The book used in conjunction with his video course on Udemy, similarly named “Automate the Boring Stuff with Python”, are a great way to start learning Python.

His latest book, "The Recursive Book of Recursion", takes the reader into the more advanced subject of recursion. Topics include the concepts of the stack, pushing in and popping out of the stack, and stack overflow. Recursion is compared to iteration, and examples are shown where both approaches are shown and critiqued. Cases where recursion is advantageous are presented with illustrations to enhance one’s comprehension. While not a beginner’s book, it is a good read to fill in a sufficiently complex subject. Copious Python and JavaScript recursion code are provided. Some fun and cool demonstrations of recursion make use of turtle graphics. Going forward, this will be my ‘go-to’ reference for recursion. Thank you, Al Sweigart!

Here’s a breakdown of what’s included (from the book):

Introduction - Covers how to set up Python and JavaScript on your computer to follow along with the code examples in the rest of the book.

Part 1: Understanding Recursion

Chapter 1: What is Recursion? - Explains recursion and how it is the natural result of the way programming languages implement functions and function calls. This chapter also argues that recursion isn’t nearly the elegant, mystical concept many claim it is.

Chapter 2: Recursion vs. Iteration – Dives into the differences (and many similarities) between recursive and iterative techniques.

Chapter 3: Classic Recursion Algorithms – Covers famous recursive programs such as the Tower of Hanoi, the flood fill algorithm, and others.

Chapter 4: Backtracking and Tree Traversal Algorithms – Discusses a problem for which recursion is particularly suited: traversing tree data structures, such as when solving mazes and navigating a directory.

Chapter 5: Divide-and-Conquer Algorithms – Discusses how recursion is useful for splitting large problems into smaller subproblems and covers several common divide-and-conquer algorithms.

Chapter 6: Permutations and Combinations – Covers recursive algorithms involving ordering and matching, as well as the common programming problems to which these techniques are applied.

Chapter 7: Memoization and Dynamic Programming – Explains some simple tricks to improve code efficiency when applying recursion in the real world.

Chapter 8: Tail Call Optimization – Covers tail call optimization, a common technique used to improve the performance of recursive algorithms, and how it works.

Chapter 9: Drawing Fractals – Tours the intriguing art that can be programmatically produced by recursive algorithms. This chapter makes use of turtle graphics for generating its images.

Part 2: Projects

Chapter 10: File Finder – Covers a project that searches through the files on your computer according to custom search parameters you provide.

Chapter 11: Maze Generator – Covers a project that automatically generates mazes of any size using the recursive backtracker algorithm.

Chapter 12: Sliding-Tile Solver – Covers a project that solves sliding-tile puzzles, also called 15-puzzles.

Chapter 13: Fractal Art Maker – Explore a project that can produce custom fractal art of your own design.

Chapter 14: Droste Maker – Explores a project that produces recursive, picture-in-picture images using the Pillow image-manipulation module

Finally, I would also recommend another one of his earlier books, “Cracking Codes with Python”. This is an excellent book on using Python to encrypt, decrypt, and cracking various encryption algorithms.

It may seem odd that a book devoted entirely to recursion would contain such statements as “You never need to use recursion. No programming problem requires recursion … In fact, a recursive function might be an overcomplicated solution…” Nevertheless, Al Sweigert goes on to explain the ins and outs of a programming technique you should rarely, if ever, need to use. And he does so masterfully.

Recursion and recursive functions seem to many (including me) to be esoteric mysteries, understandable only to those elite few who are wired to think in a pretty unconventional way. We are taught from a young age that you can’t define a word by using that word, itself. To that idea, recursion says “watch me!”.

In explaining recursion, Sweigert is careful to begin by laying important groundwork. With adequately (but not overly) detailed and approachable explanations and examples, he discusses functions, their operation and features. He spends significant time explaining the call stack, what it does, how it is structured, and how it operates, leading to a discussion of ‘stack overflow’, one of the risks of using recursion. With that out of the way, he then devotes an entire chapter to comparing recursion and iteration, demonstrating that in the vast majority of cases, recursive functions simply aren’t necessary and in some cases perform worse than their iterative counterparts.

The ensuing chapters look at recursion in action, exploring several popular recursive algorithms and techniques. It is in these chapters where we begin to see where recursion is actually a good idea, where it is a good fit (and also where it is not). So, while recursion may be mostly unnecessary, it is absolutely tailor-made for certain functions. Among other things, Sweigert explores traversing tree structures and demonstrates how memoization (yes, I spelled that correctly) can improve the efficiency of some recursive functions. He provides a plethora of examples demonstrating each concept he explores. It is worth noting here that Sweigert provides code examples in both Python and JavaScript (where possible), making it a valuable resource for students of both. The book ends with several projects that build on the lessons that come before, including one that implements the very cool Droste Effect.

For the beginning and intermediate programmer, which is the only demographic to which I can relate, the real value of this book lies not only in its teaching about recursion. Its value also stems from its ability to stretch you just a little bit further, to make think just a little bit differently, to give you confidence that maybe lofty concepts that seem way above your head are within reach. Any book that can achieve that while simultaneously telling you that what you’re learning is mostly unnecessary is well worth the read.

--Reviewer was provided a review copy by the author

I've enjoyed Al's books in the past, and I'm so glad I checked this one out too. I appreciate the structure, the tone, and the examples in this book the most.

So far, the book is compassionate in its approach to a subject that many learners find intimidating, and is quick to acknowledge when and, more importantly, WHY things might be confusing (e.g. it references "The fact that the call stack doesn't exist in source code is the main reason recursion is so confusing to beginners: recursion relies on something the programmer can't even see!") This type of explanation and acknowledgment help new learners feel at ease.

This book also has great examples in the form of both code (JavaScript and Python) and diagrams/figures. First, the text describes what is happening in an example, then you get to see the code, and then often a diagram or table that visually demonstrates exactly what is happening in the example.

I also appreciate the simplicity of some the examples in the first few Chapters. The book uses common examples (Fibonacci, factorial, exponents, palindromes...) that students likely have already seen (non-recursively) in previous exposures to educational programming content. As someone who doesn't actively think about recursion day-to-day, I appreciate these examples that I can easily wrap my head around.

I also appreciate the "Further Reading" sections, which point readers to deeper or alternative sources covering the relevant material!

All in all, this is another book from Al that I think people should check out if they want to dig deeper into recursion!

Recursion is a complex topic to understand in the first place no matter which language we chose to pick to implement the concepts. In this book, Al starts with the intuition of what is recursion via multiple examples, and gradually moved towards defining many condepts like functions, stacks, call stack and so on. I loved the second chapter on Recursion vs Iteration which build a foundation on taking the decision on when to use recursion and when not to. I would strongly recommend to go over chapter 1 to chapter 3 even if you are well verged with recursion/DP, this 3 chapters has lot to offer for anyone who is new as well as for seasoned developer.

The best chapter for me was on memorization and DP, I loved the vizual images used by Al on explaning few of recursive function calls.

Its a must have book for any software engineer who is looking to build a very strong foundation on recursion and DP. And this book also can help to strengthen many general computer science concepts. I would highly recommend this book and would advice to code as you read the book and dont jump to the next chapter without practicing.

Lastly, I just wish the publisher make a colored version of this book, I guess it would enhance the learning if we have the book in colored version (it really helps to reach the code snip-it and images)

I thoroughly enjoyed working through the code samples accompanied by Al's clear and understandable explanations. There are gems of advice sprinkled throughout the entire book.

The first couple of chapters provides a very clear explanation of recursion and a good comparison of recursion vs. iteration. Understanding is furthered by knowing any recursive algorithm can be performed iteratively using a loop and a stack. Guidance is provided about when and when not to use recursion, and what three features of a programming problem, when pres­ent, make it especially suitable to a recursive approach.

Three key questions are answered for each recursive code sample: What is the base case? What argument is passed to the recursive function call? How does this argument become closer to the base case?

Other parts I thoroughly enjoyed:

- Seeing how a perfect maze can be represented by graph (DAG)

- Quicksort walk-through (Perhaps the best explanation I've ever seen of this classic algorithm.)

- Karatsuba Multiplication algorithm and also the supporting math

- Introductory set theory refresher

- What it means for a function to be "pure"

- Memoization and why only pure functions should be memoized

- How tail call optimization works

Larger projects follow that provide more opportunities to work through code and see how recursion can be used to succinctly and elegantly implement solutions. I had fun playing with the Sliding-Tile Solver.

As a full-stack developer in the LIS (Library and Information Science) field, Al's work has always been an important cornerstone in my coding education. Data and Systems librarians are often self-taught, and I am no exception. "Automate the Boring Stuff with Python" was my Bible as I took my first steps into the field and I always recommend it to anyone who wants to follow in similar footsteps.

This new title has its own place in my journey: demystifying recursion - a concept that is largely glossed over in any coding classes or bootcamps. Al handles this task with ease, thoroughly covering the gamut with his trademark accessible language, clear examples, and concise writing. For real, there's no fat to trim in this title! The result is a surprisingly easy and enjoyable read; I recommend it to anyone who wants to clear up the mystery of recursion for themselves. Don't worry about getting lost in the sauce; if you know the basics of Python or JavaScript, you'll have no problem following along.

Note: I am writing this review based on a review copy provided by the author. That said, I am purchasing a copy for myself because I enjoyed it so much.

Kitap bu konuda çok işime yaradı. Konu ile ilgililere şiddetle tavsiye ederim. Faydalı bir kitap akıcı ve anlaşılır. Pek çok şey öğreniyorsunuz. Tabi konu ile ilgili biriyseniz. Python ve Javascript programlama dillerinde intermediate seviyede birikiminiz olması gerektiğini önemle belirteyim. Intermediate seviyedeyseniz alın işe yarar. Baskısı gayet kaliteli ve rahat okunabilir punto büyüklüğü. Ucuza alacağım diye gidip fotokopi, fake kitaplara para vermeyin tavsiye etmem.

This book does a good job of it...

I bought this book as a companion to Elements of Programming Interviews in Python. Glad I did as it has helped my understanding of recursion a lot.

Sehr gutes Buch, um Rekursion zu lernen wirklich lesenswert. Großartiger Autor.

Erfüllt seinen Zweck