Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Think Like a Programmer

Think Like a Programmer

An Introduction to Creative Problem Solving
Turn unfamiliar programming problems into testable steps, then build solutions you can explain.
by V. Anton Spraul 2012 233 pages
3.87
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat programming as problem solving, not as syntax recall

Knowing code is not creating code. Spraul’s students often understood examples and language rules but froze when asked to produce an original program. The missing ability was problem solving: turning a task into a program that meets its constraints. Reading code resembles learning ingredients and kitchen tools; programming means combining them to make something the recipe never specified. Syntax matters, but it does not supply a method for deciding what to build.

Practice the creative step. The book focuses on systematic ways to explore a problem, test possible approaches, and build a solution from familiar techniques. Its exercises are not optional decoration: reading about a method cannot replace using it on a fresh task.

Analysis

The distinction is useful well beyond programming. Recognition feels like mastery because familiar examples are easy to follow, but recall and construction demand different work. A learner who can explain a finished solution may still lack a process for producing one. The book’s strongest educational move is to make that gap explicit rather than treating it as a talent test. Its C++ examples are a vehicle, not the lesson. Still, systematic methods do not make every task easy; they make uncertainty easier to inspect and less likely to be mistaken for inability.

A result is not enough. Spraul defines programming problem solving as creating a program that performs the requested task while obeying every stated constraint. A program that works only for a small input, or ignores a required platform, is not a valid solution. He calls such a false victory a Kobayashi Maru, borrowing the name of a fictional test whose rules seem impossible to satisfy. Evading a constraint can look clever while leaving the actual problem unsolved.

Make the problem explicit. In the river puzzle, a farmer must ferry a fox, a goose, and corn without leaving dangerous pairs together. The overlooked legal move is bringing the goose back. Listing constraints and general operations reveals that possibility. An elaborate alien-lock puzzle reduces to the same relationships, once its distracting story is stripped away.

Analysis

This is a practical form of specification discipline. Writing down allowed actions and forbidden states turns vague intuition into something that can be checked, discussed, and implemented. Constraints can narrow a search rather than merely obstruct it. The caution is that specifications themselves may be incomplete or contradictory, so formalizing them should include asking what remains ambiguous. The farmer puzzle makes that point neatly: a solver may overlook an allowed action simply because the description never highlights it.

Break the task until each next step is testable

Progress can be local. A large task is easier when divided into smaller parts, or temporarily reduced to a simpler version. To produce a triangle of symbols, Spraul first solves a line, then a square, then adjusts the row length. Each result becomes a tested building block. For a sliding-tile puzzle, he places a complete row or column and treats the remaining board as a smaller puzzle, instead of trying to plan every move at once.

Plan the search, too. A plan need not predict every obstacle. It can specify what to test first, what partial result counts as progress, and what to revise if an approach fails. Starting with a piece already understood builds momentum and can reveal how the unfamiliar piece should work.

Analysis

Decomposition reduces both technical complexity and the emotional cost of a task. A small test gives fast feedback, so a mistaken assumption is cheaper to correct. This resembles experimental design: isolate one uncertain factor instead of changing several things at once. There is a limit, however. Dividing work carelessly can create pieces that fit individually but not together. Useful decomposition preserves a clear account of how each part contributes to the final behavior.

Start with the part that has the fewest possible answers

Constraints can guide your first move. In Sudoku, a square with only one legal digit is a better starting point than a square with many possibilities. Spraul connects this to the most constrained variable rule: when assigning values under constraints, tackle the variable with the fewest available choices. A nearly complete three-by-three region may force a digit, which then narrows the options in its row and column.

Use solved problems as maps. The alien lock becomes manageable when its actual interactions are compared with the fox, goose, and corn puzzle. Similarity may concern only one part of a task, but that can still save work. Small experiments also help reveal structure: Spraul develops a sliding-puzzle method by playing with a reduced board, then applies the insight to larger boards.

Analysis

Choosing the most restricted element is a search strategy, not just a Sudoku trick. It exposes contradictions early, before effort accumulates around choices that later prove impossible. Analogy offers a complementary shortcut: it transfers structure, not necessarily a complete answer. The danger is forcing a resemblance where the important rules differ. A good comparison asks which relationships are preserved and which are not, rather than trusting surface likeness or familiar vocabulary.

Build complex code from isolated experiments, not hopeful guesses

Turn uncertainty into a small test. The Luhn check-digit problem requires reading a number of unknown length one character at a time, doubling alternating digits, and checking whether the total is divisible by ten. Rather than solve all of it at once, Spraul isolates the subtasks: convert a character digit to an integer, handle doubled values, and detect the end of input. Since doubling a digit from zero to nine yields at most eighteen, the digit-summing rule is easy to test separately.

Keep both possibilities alive. The program cannot know the number’s length until input ends, yet length determines which digits to double. It therefore maintains two running checksum totals, one for each parity, and selects the valid one at the end. A deliberate experiment tests a hypothesis; random code changes merely hope.

Analysis

The two-checksum solution is a compact example of postponing a decision until the necessary evidence arrives. In other domains, the same pattern appears whenever an early choice depends on information available only later: preserve alternatives, update them as data arrives, then select. Small test programs also act as instruments for learning an unfamiliar interface. Their value is not only a working snippet, but a record of what the programmer has actually verified.

Choose data structures by required operations, not by habit

Start with what the work demands. Arrays provide indexed, random access, but their size is fixed. Vectors can grow, while linked lists allow efficient insertion at the front but require sequential traversal. The right choice depends on the operations and size limits the task requires, not on which structure is most familiar.

Let the data shape the method. To find the most common survey answer when responses range from one to ten, sorting and counting runs works, but a histogram is more direct. It stores one counter per possible answer, then a single scan identifies the largest count. If responses arrive one at a time and need not be revisited, the program can update the histogram immediately instead of storing every response. That saves unnecessary space and work.

Analysis

This is algorithmic thinking in a useful everyday form: describe the workload before selecting the tool. A structure is not efficient in the abstract; efficiency depends on what it must do, how often, and at what scale. The histogram works especially well because the value range is small and known. If the range were huge or open-ended, the same representation could waste space. The book’s examples encourage matching representation to constraints rather than treating one structure as universally superior.

Draw heap ownership before changing pointers

Make invisible memory visible. A dynamically allocated string may need a larger replacement array when a character is appended. The program must find its length, copy the old characters, add the new one and a terminator, then release the old allocation. A diagram tracks which pointer refers to which block and which blocks must be freed. Without that map, an apparently small edit can cause a memory leak or a dangling reference.

Check the edge cases. Linked lists grow one node at a time. Adding at the head avoids scanning the whole list, while removing a node requires reconnecting its predecessor, with separate handling when the first node is removed. A list’s empty state matters too. Pointer-based code becomes easier to reason about when each allocation, link, and lifetime is accounted for explicitly.

Analysis

Diagrams externalize a mental burden that working memory handles poorly: several pointers can change while the data they refer to remains out of sight. This is not merely a beginner’s crutch; visualizing ownership and state can also clarify complex systems. The discipline is especially valuable around deletion, where a pointer can remain syntactically valid while referring to memory that no longer belongs to the program. Modern abstractions can reduce this burden, but they do not remove the need to understand lifetime and ownership.

Use classes to hide coherent implementation, not disguise globals

Package what belongs together. A class can group related data and operations, provide a clear interface, and keep implementation details away from client code. A student record, for example, can protect its grade field and validate updates through methods. A collection class can hide its linked-list pointers so users add, find, or remove records without manipulating nodes themselves.

Dynamic memory raises the stakes. A class that owns a linked list must release its nodes when destroyed and make real copies when duplicated. A shallow copy duplicates only the head pointer, causing two objects to share one list; changing or deleting nodes through one can damage the other. Classes help contain this complexity, but a class that merely gathers unrelated functions or global-like state is a fake abstraction, not good design.

Analysis

Information hiding is valuable because it gives a program a stable boundary: clients depend on what an object promises, not on how it stores its data. That boundary also lets implementation change without forcing changes everywhere. Yet hiding should not become concealment of consequential trade-offs. A linked-list collection and an array-backed collection have different access and growth properties, and clients may care. Good abstraction hides incidental detail while making essential behavior and limitations legible.

Trust a recursive call with the smaller problem

Define the smallest case first. Recursion means a function calls itself on a reduced problem until it reaches a case it can answer directly. For an array sum, an empty array sums to zero; otherwise, add the last value to the sum of all earlier values. Spraul’s Big Recursive Idea is to treat that recursive call as a reliable helper, without tracing every call while designing the current one.

Match recursion to structure. A linked list naturally divides into its first node and the remainder. A binary tree divides into a root and left and right subtrees. Recursion can make branching traversals clear, especially when an iterative version would need a separate stack to remember where to return. For simple forward scans, a loop is usually simpler. A wrapper function can pass private tree data to a recursive helper.

Analysis

The crucial shift is from imagining a call unfolding to specifying its contract: what smaller question it answers, and how that answer helps solve the current one. This is a form of compositional reasoning, where a system is understood through reliable parts. Recursion is not inherently elegant or efficient, though. Deep call chains can consume stack space, and simple linear tasks often need no recursive machinery. Choosing it well depends on whether the problem’s structure repays the added call overhead.

Reuse blueprints you understand, not code you cannot explain

Borrow concepts, then make them yours. Spraul distinguishes good reuse, which extends skill and produces code the programmer understands, from copying that bypasses learning and can fail during modification. An algorithm describes a method, a design pattern offers a reusable structure, an abstract data type specifies operations, and a library provides implemented components. Each saves a different amount of work and offers a different degree of flexibility.

Investigate before depending. To let clients traverse a private student list efficiently, the book borrows the iterator idea from standard libraries and builds a small iterator with operations to start, advance, check for the end, and retrieve the current record. Once its behavior is understood, using a library iterator is informed reuse rather than blind copying. The same principle applies when adapting an existing program or learning a new library.

Analysis

Understanding reuse as a spectrum avoids two bad extremes: reinventing every tool, or treating borrowed code as magic. A well-chosen library can improve reliability and save time, while a conceptual pattern can fit an unusual requirement more precisely. The right level depends on deadlines, flexibility, and the programmer’s need to learn. Reconstructing a small component can be worthwhile for comprehension, but reproducing mature infrastructure for its own sake may waste effort.

Build a personal workflow around your recurring coding habits

Make the process fit the programmer. The book’s final method is a personal master plan built around recurring strengths and weaknesses. Someone who skips testing can schedule it as a required step; someone who overdesigns can limit design time; a fast learner can reserve time to investigate unfamiliar tools. The point is not to adopt one universal workflow, but to notice patterns in one’s own mistakes and compensate deliberately.

Prototype the unknown. In the closing hangman project, the program cheats by keeping every candidate word and choosing each answer to preserve the largest remaining group. Spraul first tests a rough version, then considers better structure and interface. The example brings together restatement, experimentation, decomposition, and reuse. To build skill, practice those methods on exercises and small projects before relying on them under pressure.

Analysis

A personal workflow turns self-knowledge into engineering practice. Instead of hoping to become more careful, a programmer can design checkpoints that make care more likely; instead of fighting every weakness through willpower, the process can route around it. The cheating hangman prototype also shows why a working first version matters: it gives later redesign a concrete baseline. A prototype is not proof of quality, however. It must still be tested against the full requirements and refined without quietly dropping constraints.

Analysis

Think Like a Programmer is less a catalog of C++ tricks than an apprenticeship in handling uncertainty. Its recurring move is to transform an opaque task into something observable: list constraints, name operations, isolate unknowns, construct a small case, and test. The puzzles make the method memorable, while the programming examples show that the same reasoning survives a change of subject, from output loops to memory ownership, class design, and recursive traversal.

The book’s deepest educational claim is that competence is built by producing solutions, not merely recognizing them. This is why its examples repeatedly pause before code, and why exercises matter more than passive familiarity. The reader is encouraged to keep intermediate programs, treat failed approaches as evidence, and use analogies as bridges between known and unknown problems. Confidence emerges from accumulated successful attempts, not from a mystical gift for coding.

The approach has an important boundary. A clear plan cannot guarantee a solution when requirements conflict, time is inadequate, or a problem is computationally impractical. Nor does the text’s emphasis on individual problem solving fully represent collaborative development, where requirements change and design decisions must be negotiated. Its C++ mechanisms also make some lessons unusually explicit, especially pointer lifetime and copying, while other languages hide those details behind abstractions. The broader method still transfers: understand what must be true, choose representations that support the needed operations, and test assumptions early.

The book’s final hangman example is a fitting demonstration. The program becomes a better cheater not by guessing a secret word, but by reframing the objective as preserving as many candidate words as possible. That shift captures the whole method: a difficult task can become tractable when its real structure is made visible. Thinking like a programmer means learning to find that structure, one tested step at a time.

Summary in 30 Seconds
Programming skill comes from producing solutions, not just recognizing syntax or examples. Make constraints and allowed operations explicit, then divide a task into small parts that can be tested. Start with the most constrained choices, and isolate uncertainties in experiments before combining them. Select data structures for the operations required. Draw memory ownership before changing pointers, use recursion when a problem has smaller versions of itself, and adapt your workflow to recurring mistakes.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.87 out of 5
Average of 500+ ratings from Goodreads and Amazon.

Think Like a Programmer receives mixed reviews, with an average rating of 3.86 out of 5. Readers appreciate its problem-solving approach and exercises, finding it useful for developing programming skills. Some praise the author's explanations and consider it a valuable resource for beginners. However, critics argue that the book's reliance on C++ limits its accessibility, and some find the content too basic or academic. The book's focus on logical thinking and breaking down problems is generally well-received, though opinions vary on its effectiveness for experienced programmers.

Your rating:
4.4
367 ratings
Want to read the full book?

Glossary

Kobayashi Maru

A constraint-breaking false solution

Spraul’s term for a program that appears to solve a task but violates one or more stated constraints. It refers to a fictional Starfleet training scenario made winnable by changing its rules. In programming, the label warns against treating a workaround that evades a requirement as a genuine solution.

The train

A sliding-tile rotation technique

A method Spraul develops for sliding-tile puzzles. A sequence of tile positions that includes the empty space can be rotated along a circuit while preserving the tiles’ relative order. The method helps position groups of tiles and supports solving a board progressively by completing a row or column, then treating what remains as a smaller puzzle.

most constrained variable

Choose the fewest legal options

A rule for constraint-based problems that recommends assigning the variable with the fewest possible values first. In Sudoku, this means examining a square with the smallest number of legal digits before one with many options. Resolving a highly restricted part can force further choices and reveal contradictions early.

King of the Hill

Track the best value found

A repeated array-processing technique for finding an extreme or leading candidate. Keep a variable for the best value seen so far, inspect each new item, and replace the current candidate when the new one is better. The same structure can track a maximum, a minimum, or the position of the strongest candidate.

solving by sample case

Trace one concrete input

A method for designing code by choosing a representative input, recording its relevant state, and tracing how each operation should transform it into the desired output. Spraul especially recommends it for pointer-based code, where diagrams can show allocations, links, and deallocations that ordinary variables do not make visible.

Big Recursive Idea

Trust the smaller recursive answer

Spraul’s method for designing recursive functions: handle the simplest case directly, then assume a recursive call correctly answers the same question for a smaller problem. Use that answer, plus the current item or structure, to solve the original case. This avoids trying to mentally trace every nested call during design.

wrapper function

Adapt an interface to a helper

A function that prepares a call to another function whose parameters do not match the interface desired by the client. In recursive class methods, a public wrapper can pass private data, such as a tree’s root pointer, to a private recursive helper. The client receives a simple method without access to implementation details.

good reuse

Reuse that builds understanding

Using another programmer’s work in a way that extends capability while preserving understanding. This can mean implementing an algorithm from its description, applying a pattern, or using code the programmer could explain and modify. Spraul contrasts it with copying code as a shortcut that may work initially but leaves the programmer unable to diagnose or safely extend it.

iterator pattern

Traverse without exposing storage

A design pattern that gives client code sequential access to a collection without revealing its internal representation. An iterator identifies the current item, advances to the next one, signals when traversal is finished, and provides access to the current value. It allows efficient traversal while keeping the collection’s underlying links or storage private.

FAQ

What is Think Like a Programmer by V. Anton Spraul about?

  • Problem-solving focus: The book centers on teaching creative and systematic problem-solving skills for programmers, rather than just coding syntax or language features.
  • C++ as a teaching tool: While C++ is used for examples, the problem-solving strategies and concepts are applicable to any programming language.
  • Comprehensive coverage: It spans fundamental programming constructs (arrays, pointers, classes) to advanced topics like recursion, dynamic memory, and design patterns.
  • Goal of transformation: The ultimate aim is to help readers become confident, independent problem solvers who can write original programs from scratch.

Why should I read Think Like a Programmer by V. Anton Spraul?

  • Develop a problem-solving mindset: The book addresses the often-missing skill of solving new programming problems, not just reading or modifying existing code.
  • Structured learning approach: It provides systematic techniques and strategies to organize thoughts, break down problems, and build confidence.
  • Long-term skill building: Readers learn to design robust programs, avoid common pitfalls, and think critically about code reuse and design decisions.
  • Practical exercises: The book includes hands-on exercises to help internalize concepts and build real-world programming confidence.

What are the key takeaways from Think Like a Programmer by V. Anton Spraul?

  • Always have a plan: Planning before coding is emphasized to avoid frustration and directionless activity.
  • Restate and divide problems: Breaking problems into smaller, manageable parts and restating them can reveal easier solutions.
  • Look for analogies: Recognizing similarities with previously solved problems accelerates finding solutions.
  • Confidence through practice: Systematic practice and tackling exercises help build the confidence needed to solve novel programming challenges.

How does Think Like a Programmer by V. Anton Spraul define and teach creative problem solving in programming?

  • Creative and systematic approach: Programming is presented as a creative activity, and the book offers systematic methods to unlock that creativity.
  • Classic puzzles as teaching tools: Puzzles like the Fox, Goose, and Corn, sliding tiles, and Sudoku are used to illustrate problem-solving strategies.
  • Emphasis on experimentation: Readers are encouraged to experiment, use what they know, and learn from controlled trials.
  • Managing frustration: The book highlights the importance of managing frustration to maintain clear thinking and effective problem solving.

What are the most important problem-solving strategies in Think Like a Programmer by V. Anton Spraul?

  • Always have a plan: Even if the plan changes, having one prevents aimless work and helps set intermediate goals.
  • Restate and divide: Restating clarifies understanding, and dividing problems often reduces complexity exponentially.
  • Start with what you know: Use existing skills and try small experiments to gain insight, especially with unfamiliar APIs or behaviors.
  • Look for analogies: Drawing parallels to previously solved problems can lead to faster and more effective solutions.

How does Think Like a Programmer by V. Anton Spraul use C++ to teach problem solving?

  • Assumes basic C++ knowledge: The book expects readers to know basic C++ syntax and semantics, focusing instead on problem-solving skills.
  • Readable code examples: Code is written for clarity and understanding, often breaking down complex steps.
  • Not a cookbook: The emphasis is on developing adaptable problem-solving skills, not memorizing recipes or algorithms.
  • Active learning: Readers are encouraged to solve exercises themselves to internalize the concepts.

How does Think Like a Programmer by V. Anton Spraul explain arrays and their use in problem solving?

  • Array fundamentals: Covers storing, copying, retrieving, searching, and sorting data using arrays.
  • Problem-solving techniques: Demonstrates strategies like sorting before searching for the mode and using histograms for frequency counting.
  • When to use arrays: Discusses scenarios where arrays are appropriate, such as when size is known or random access is needed.
  • Alternatives to arrays: Introduces vectors and lists for cases where data size is unknown or sequential access is preferred.

What does Think Like a Programmer by V. Anton Spraul teach about pointers and dynamic memory management?

  • Pointer basics: Reviews pointer declaration, dereferencing, dynamic memory allocation (new/delete), and assignment.
  • Benefits of pointers: Explains how pointers enable runtime-sized and resizable data structures, and efficient memory sharing.
  • Memory management pitfalls: Discusses stack vs. heap memory, fragmentation, memory leaks, and dangling pointers.
  • Problem-solving with pointers: Provides examples like dynamic arrays for variable-length strings and linked lists for collections.

How does Think Like a Programmer by V. Anton Spraul introduce classes and object-oriented programming?

  • Class fundamentals: Reviews class declarations, member variables, access specifiers, and constructors.
  • Encapsulation and information hiding: Stresses making data private and exposing only necessary methods for robust design.
  • Design for readability: Encourages clear naming and structuring for code that is easy to understand and maintain.
  • Practical examples: Builds a studentRecord class from a struct, adding validation and constructors to illustrate OOP principles.

What practical advice does Think Like a Programmer by V. Anton Spraul give for designing and using classes?

  • Encapsulation: Keep data private and provide only necessary access methods to protect implementation details.
  • Divide and conquer: Use classes to break complex problems into manageable, reusable units.
  • Readability and expressiveness: Choose method names and class structures that make code intuitive for users and maintainers.
  • Testing and validation: Always consider edge cases and validate inputs within class methods for robustness.

How does Think Like a Programmer by V. Anton Spraul explain recursion and recursive thinking?

  • Big Recursive Idea (BRI): Teaches that recursive calls can be thought of as calls to another function, simplifying the design of recursive solutions.
  • Head vs. tail recursion: Explains the difference and uses real-world analogies to clarify when to use each.
  • Common mistakes: Warns against too many parameters and the use of global variables in recursion.
  • Natural fit for data structures: Shows how recursion is well-suited for dynamic structures like linked lists and binary trees.

What are the most common pitfalls and mistakes highlighted in Think Like a Programmer by V. Anton Spraul?

  • Fake classes: Warns against creating classes that simply encapsulate global variables or force OOP where it doesn’t fit.
  • Redundant data: Stresses that storing data that can be derived from other data leads to inconsistencies and bugs.
  • Shallow copies and memory leaks: Explains the dangers of shallow copying objects with dynamic memory and the importance of deep copy implementations.
  • Overcomplicating recursion: Advises against unnecessary parameters and global variables in recursive functions, which can make code harder to understand and maintain.

What are the best quotes from Think Like a Programmer by V. Anton Spraul and what do they mean?

  • “Are you thinking like a programmer yet?” — Captures the book’s goal of transforming readers into creative, effective problem solvers.
  • “Always have a plan.” — Emphasizes the necessity of planning before coding to avoid frustration and produce robust solutions.
  • “Redundant data is trouble waiting to happen.” — Warns against storing unnecessary data, which can cause inconsistencies and bugs.
  • “If you follow certain conventions in your coding, you can pretend that no recursion is taking place.” — Encourages simplifying recursive thinking by treating recursive calls as if they were calls to other functions.
  • “Fake classes mean that the program has all of the same defects as one that uses global variables.” — Highlights the importance of proper class design to realize the benefits of object-oriented programming.

About the Author

V. Anton Spraul is a computer programmer and author known for his work in teaching programming concepts. He has extensive experience in software development and has focused on helping beginners understand the fundamentals of programming. Spraul's approach emphasizes problem-solving skills and logical thinking over simply learning syntax. He believes in the importance of understanding how to break down complex problems into manageable parts. Spraul has written other programming-related books and articles, aiming to make programming concepts accessible to a wide audience. His writing style is described as engaging and sometimes humorous, though some readers find it occasionally patronizing.

Download PDF

To save this Think Like a Programmer summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.43 MB     Pages: 23

Download EPUB

To read this Think Like a Programmer summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.40 MB     Pages: 28
Want to read the full book?
Follow
Listen10 mins
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...