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
Cracking the Coding Interview

Cracking the Coding Interview

189 Programming Questions and Solutions
189 coding problems teach you to reason aloud, optimize under pressure, and negotiate the offer.
by Gayle Laakmann McDowell 2020 712 pages
4.33
476 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Prepare for unfamiliar problems, not familiar answers

The failure was procedural. The book opens with a promising candidate: a former student with a 3.73 GPA, strong open-source experience, and deep academic knowledge. He still struggled to develop an efficient interview solution, translate it into reliable code, and catch mistakes. The lesson is not that his background lacked value, but that coursework alone did not prepare him for this particular performance task.

Patterns beat memorization. The book gathers 189 questions selected from thousands, but its aim is not to teach 189 answers. Interviewers want to see how candidates reason through unfamiliar problems, communicate choices, and improve an initial solution. Performance is judged in context, against others answering the same question, so a difficult prompt is not automatically a disadvantage.

Analysis

What's revealing is the gap between knowing computer science and demonstrating it under pressure. The interview becomes a performance environment with limited time, incomplete information, and an audience that cannot see the candidate's past work. That makes practice with unfamiliar problems more valuable than collecting memorized solutions. The method also has a real limitation: a timed puzzle is an imperfect proxy for engineering judgment, collaboration, and sustained execution. Candidates can prepare for the proxy without mistaking it for the whole profession.

Make your reasoning visible before you start writing code

Build a solution in stages. First clarify the prompt and preserve details such as sorted input or repeated execution. Draw a specific, non-special-case example, then state a brute-force approach and its time and space costs. Optimize only after the basic logic is clear. Before coding, walk through the algorithm; afterward, inspect and test the code with small and unusual cases.

Search for wasted effort. The book's BUD technique is a diagnostic for bottlenecks, avoidable work, and repeated calculations. For example, repeatedly searching an unsorted array may be the real cost, suggesting a hash table rather than a faster version of some later step. The interview is also a conversation: speak your reasoning aloud, listen to hints, and make tradeoffs legible.

Analysis

This process turns private thought into something the interviewer can evaluate and respond to. The example is not decorative: it externalizes assumptions and gives the candidate a shared object to inspect, much like a sketch helps a design team reason about a system. The staged approach also reduces cognitive load by separating understanding, algorithm design, coding, and testing. It should remain a guide, not a ritual. Some problems yield to a quick insight, while others benefit from silent thought before explanation.

Use Big O to compare growth, not to predict clock time

Measure how work scales. Big O describes how an algorithm's resource use grows as input grows. A scan of an array is O(N); comparing every pair is O(N²); repeatedly halving a search space is O(log N). When two inputs vary independently, name both: sorting strings in an array depends on both the number of strings and their lengths.

Keep the model honest. Drop constant factors and lower-order terms when describing growth, but remember that this does not guarantee a faster program for every real input. Add sequential work, multiply nested work, and count memory used by recursive calls. Amortized time describes the average cost across a sequence of operations: a resizable array occasionally copies everything, yet insertion remains O(1) amortized because capacity grows geometrically.

Analysis

Big O is valuable because it replaces vague claims such as this feels efficient with a comparison that survives changes in input size. The book also correctly separates asymptotic growth from practical speed: constant factors, memory pressure, and implementation details still matter in production. The interview version of the notation is a simplified convention, not a complete mathematical treatment of upper and lower bounds. That simplification is useful as long as candidates can explain what variable the notation refers to and what assumptions it hides.

Pick structures by the operations your problem repeats

Start from required operations. Arrays offer fast indexed access; linked lists make local insertion and deletion easier but require traversal to reach an index. Hash tables usually support lookup in O(1), though collisions can degrade performance. A resizable array offers O(1) access and O(1) amortized insertion. A stack is last-in, first-out; a queue is first-in, first-out.

Match structure to search. A queue supports breadth-first search, which explores nearby graph nodes first and is useful for shortest paths. Depth-first search follows a branch deeply and is often simpler for traversing every node. A trie is a character-based tree that supports prefix lookup in time proportional to the query length. Balanced search trees add ordering, while heaps efficiently expose a minimum or maximum.

Analysis

The practical lesson is to ask what the algorithm does repeatedly, then choose a structure that makes that operation cheap. That habit is more transferable than memorizing data-structure definitions. There is an important nuance: textbook operation costs assume particular implementations and favorable conditions. Hash lookup is not magically constant regardless of collisions or key size, and a balanced tree's guarantees depend on maintaining balance. Interviewers should value a candidate's explanation of these conditions, not just the familiar complexity label.

Cache repeated subproblems before recursion buries you

Look for duplicate calls. The naive recursive Fibonacci algorithm branches repeatedly, recomputing the same values and taking exponential time. Memoization, meaning storing results for subproblems already solved, reduces the work to O(N): each Fibonacci value is computed once, then reused. The same pattern appears when recursively finding paths in a grid or counting ways to make change.

Choose a direction. A top-down solution starts with the full problem and recurses into smaller cases. A bottom-up solution solves simple cases first and builds toward the answer. For Fibonacci, retaining only the previous two values avoids storing the entire table. Recursion can make the logic clearer, but its call stack costs space; an iterative version may use less memory at the price of more bookkeeping.

Analysis

Dynamic programming is presented as a recognition skill rather than a mysterious specialty: repeated subproblems are evidence that prior work should be reused. This connects algorithm design to caching more broadly, where computation is traded for storage. The choice between recursive and iterative forms is not merely stylistic, since deep recursion can consume substantial stack space. A useful question is whether the memo table stores the smallest state that fully determines the answer. Poorly chosen keys can preserve redundant work or, worse, reuse results that are not actually equivalent.

Design systems by naming assumptions before scaling them

Scope before architecture. For a system-design question, clarify the features, users, freshness requirements, and expected load. State reasonable assumptions, draw the main components, identify bottlenecks, then revise the design. A URL shortener, for example, changes substantially depending on whether users need click analytics, custom links, or immediate availability.

Tradeoffs are the design. Caches speed up repeated reads; sharding divides data across machines; asynchronous queues keep slow work from blocking users. Each creates costs, such as stale data, routing complexity, or delayed completion. The book's Best Conceivable Runtime is a lower bound implied by the task itself, such as reading every input item. Reaching it can signal that further effort should target memory or reliability instead of speed.

Analysis

The chapter's most useful correction is that system design is not a search for one perfect diagram. It is a sequence of explicit assumptions and revisions, with the interviewer acting as a collaborator who can expose missing requirements. This resembles real architecture work, where data freshness, failure behavior, and user expectations can change the optimal design. The method also guards against a common failure of technical interviews: treating scale as a collection of fashionable components. A cache or shard only helps when it addresses a stated bottleneck.

Clarify users and relationships before drawing classes

Design follows use. Object-oriented design questions are often vague on purpose. Before naming classes, ask who will use the system and what they need to do. A coffee maker for a small home and a machine serving a busy restaurant are different design problems. Then identify core objects, their relationships, and the actions they perform.

Keep responsibilities understandable. In a restaurant model, parties, guests, tables, employees, and reservations may relate in different ways. A party might need several tables, and a table might serve more than one party over time. Those details affect the design. Named patterns such as Singleton or Factory Method can help in specific situations, but the book warns against forcing a pattern where a simpler design works.

Analysis

The method resists a familiar engineering temptation: beginning with classes because classes are easy to name. Requirements determine whether objects, relationships, and boundaries make sense. Asking who uses a system also surfaces accessibility, scale, and workflow needs that a purely technical sketch can miss. Design patterns are best treated as shared vocabulary for recurring structures, not as badges of sophistication. A design can be elegant without using a named pattern, and a pattern can make a small system needlessly rigid.

Test failure modes, not just the happy path

Test the real use. For a physical object or a software feature, first establish who uses it and why. Then examine use cases, operating limits, and failure conditions. Testing a pen for children, for instance, is not just checking whether it writes. The intended surface, washable ink, safety, and predictable misuse all matter.

Organize coverage. For software, distinguish black-box testing, where internals are unavailable, from white-box testing, where code can be inspected. Use manual testing where judgment is needed and automation for repeatable checks. For a function, cover ordinary inputs, extremes, invalid values, and unusual cases. For a crash report, reproduce the scenario and divide the user journey into smaller steps rather than offering a generic reinstall.

Analysis

The chapter treats testing as an exercise in modeling users and consequences, not merely generating a long list of inputs. That perspective connects software quality to safety engineering: the cost of a failure matters, so payment errors deserve different priority from cosmetic defects. It also explains why testing needs both structured automation and human observation. Neither is sufficient alone. A limitation is that exhaustive coverage is usually impossible, so the tester must make priorities explicit and revisit them as real usage reveals new failure patterns.

Make your individual contribution visible in every interview story

Tell a structured story. The book recommends beginning with a concise summary, then explaining the situation, actions, and result. In the S.A.R. approach, the action deserves the most attention: what did the candidate personally do, and why? A team success described only as we shipped the project leaves the interviewer unable to judge individual impact.

Prepare evidence in advance. The Interview Preparation Grid maps projects and roles against challenges, mistakes, leadership, conflict, and what the candidate would change. Strong resume bullets likewise connect the accomplishment, the method, and the result, ideally with a measurable effect. Prepare a few projects deeply enough to discuss technical choices, tradeoffs, and failures without reciting a long chronology.

Analysis

The emphasis on personal action is not an invitation to erase teamwork. It is a way to make responsibility legible within a short interview, where broad team language can hide both contribution and learning. Specific evidence also limits empty self-promotion: the interviewer can evaluate what happened rather than accept a personality claim. The structure should not make every story sound rehearsed. A strong answer is organized enough to follow, but still responsive to the question and honest about uncertainty, shared credit, and mistakes.

Negotiate the package, then keep managing your career

Compare the whole offer. Salary is only one part of compensation. Include bonuses, equity, relocation, taxes, and cost of living; signing and stock awards can be compared over the period you expect to stay. Also consider learning, promotion paths, team growth, manager quality, stability, and location. A prestigious product is not a substitute for a healthy working relationship or a role that develops relevant skills.

Make a specific ask. The book recommends negotiating with a viable alternative, naming what would change the decision, and considering non-salary terms. An offer deadline may be extendable, and rejection is not always permanent; candidates can ask when to reapply. After joining, review progress yearly, seek projects aligned with career goals, maintain relationships, and interview periodically to understand available opportunities.

Analysis

This ending usefully expands interview preparation into career agency. An offer is not simply a prize to accept; it is a bundle of financial, developmental, and human conditions that shape future choices. The advice to keep interviewing can preserve market awareness, though it should not turn employment into permanent negotiation theater. Career growth also depends on circumstances a candidate cannot fully control, including visa constraints, caregiving, and local job markets. The strongest use of the framework is deliberate evaluation, not maximizing every variable.

Analysis

Cracking the Coding Interview is best understood as a practical curriculum for a peculiar assessment environment, not as a complete account of software engineering. Its central move is to shift preparation away from collecting facts and toward practicing observable problem solving. The opening candidate story makes that claim concrete: strong grades, open-source work, and advanced textbook knowledge did not translate into an interview performance that demonstrated optimization, careful coding, and self-correction.

The book's strongest teaching device is decomposition. A candidate learns to clarify a prompt, build an example, establish a baseline, find wasted work, implement, and test. These steps externalize reasoning and make mistakes easier to locate. The data-structure chapters reinforce the same habit: identify the operation that dominates the task, then choose a structure that supports it. Dynamic programming adds a further question: are recursive branches solving the same subproblem repeatedly?

The book also understands interviews as social systems. Communication, behavioral evidence, interviewer guidance, company-specific expectations, and relative evaluation all affect outcomes. Its guidance for interviewers is especially valuable because it recognizes that nervousness and lack of interview practice can obscure engineering ability. That perspective complicates the premise that coding interviews are neutral measures of skill. They are useful signals for certain kinds of reasoning, but imperfect proxies for collaboration, maintenance, product judgment, and sustained work.

The broad technical coverage is a strength and a constraint. Big O, data structures, testing, object design, databases, concurrency, and system design provide a map of interview preparation, but no candidate needs equal mastery of every topic for every role. The most durable takeaway is therefore methodological: learn the fundamentals, practice applying them aloud, and treat each interview as evidence about both the candidate and the hiring process. The book prepares readers to perform better without proving that interview performance and job performance are identical.

Summary in 30 Seconds
Interview problem solving depends on a visible process: clarify requirements, work through an example, establish a baseline, then optimize and test edge cases. Big O compares how resource needs grow, not real-world speed. Choose data structures around repeated operations, and cache repeated recursive work to avoid exponential recomputation. System designs improve when assumptions and tradeoffs are explicit. Interview stories should distinguish personal actions from team results, while job offers merit comparison beyond salary.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.33 out of 5
Average of 476 ratings from Goodreads and Amazon.

Cracking the Coding Interview receives mostly positive reviews, with readers praising its effectiveness in preparing for technical interviews and landing jobs at top tech companies. Many find it comprehensive and valuable for refreshing CS concepts. Some criticisms include its focus on Java, advanced difficulty, and potential for making interviews formulaic. Readers recommend supplementing with other resources and warn that working through the entire book can be time-consuming. Overall, it's considered a must-read for those serious about tech careers, especially early in their journey.

Your rating:
4.63
261 ratings
Want to read the full book?

Glossary

BUD

optimization diagnostic

A problem-solving check for locating where an algorithm wastes time. It directs attention to the part that limits the whole solution, work that can be removed, and calculations repeated unnecessarily. The purpose is to improve a brute-force baseline systematically rather than guessing at optimizations.

Best Conceivable Runtime

problem-specific lower bound

The fastest runtime one can reasonably imagine for a problem, based on what its input and output require. If an answer must inspect every element, for example, the task cannot be completed faster than linear time in the input size. The bound is a guide for optimization, not necessarily an achievable runtime.

S.A.R.

behavioral-story structure

A way to organize an answer to a behavioral interview question around Situation, Action, and Result. The situation establishes context, the action explains what the candidate personally did, and the result shows what changed. Its main purpose is to make individual contribution clear without burying it in background detail.

Interview Preparation Grid

project-story planning tool

A preparation aid that lists major projects, jobs, or activities alongside themes interviewers may ask about, such as challenges, mistakes, leadership, conflict, and lessons. Filling it out helps candidates identify which experiences can support different questions and notice gaps before the interview.

Memoization

cache recursive results

A technique for storing the results of solved subproblems so repeated recursive calls can return them instead of recomputing them. In the book's Fibonacci example, caching each value reduces an exponential-time recursion to linear time. The cache key must capture enough information to identify the subproblem precisely.

Amortized Time

average cost across operations

A way to describe the average cost per operation across a sequence, including occasional expensive operations. A resizable array may need to allocate a larger array and copy its contents when full, but such growth is infrequent. Across many insertions, the average insertion cost remains constant.

search from both endpoints

A path-finding method that runs breadth-first searches from both a source and a destination. When the explored regions meet, the two partial paths can be joined. In a graph with many neighbors per node, this can explore far fewer nodes than a single breadth-first search across the full path.

Trie

prefix lookup tree

A tree structure that stores characters along paths, with markers showing where complete words end. Shared prefixes use shared paths, allowing fast checks for whether a string is a valid prefix or word. Tries are useful when searching dictionaries or pruning recursive searches that build words character by character.

MapReduce

parallel data-processing model

A model for processing large datasets through a Map step and a Reduce step. Map emits key-value pairs from input data. The system groups values by key, then Reduce combines the values associated with each key into a result. The model enables work to be distributed across machines.

FAQ

1. What is Cracking the Coding Interview by Gayle Laakmann McDowell about?

  • Comprehensive Interview Guide: The book is a detailed resource with 189 real programming questions and solutions, focusing on preparing software engineers for technical interviews at top tech companies.
  • Emphasis on Problem-Solving: It teaches core computer science concepts, problem-solving techniques, and strategies for both technical and behavioral interview questions.
  • Insider Perspective: Authored by a former Google interviewer, it offers behind-the-scenes insights into how companies like Google and Facebook hire developers.
  • Practical and Holistic Approach: The book covers everything from coding and algorithms to system design, behavioral questions, and even advice for interviewers.

2. Why should I read Cracking the Coding Interview by Gayle Laakmann McDowell?

  • Real Interview Questions: The book features 189 questions based on actual interviews at major tech companies, ensuring relevant and targeted preparation.
  • Proven Strategies and Insights: It provides five proven strategies for tackling algorithm questions and covers essential topics like data structures, Big O complexity, and behavioral skills.
  • Holistic Preparation: Beyond coding, it addresses resume writing, negotiation, and the "soft" side of interviews, making it a one-stop guide for job seekers.
  • Author’s Expertise: Gayle Laakmann McDowell brings firsthand experience as both an interviewer and candidate, offering authentic, practical advice.

3. What are the key takeaways from Cracking the Coding Interview by Gayle Laakmann McDowell?

  • Master Core Concepts: Understanding data structures, algorithms, and Big O analysis is essential for technical interviews.
  • Problem-Solving Over Memorization: The book emphasizes learning patterns and developing fresh solutions rather than rote memorization.
  • Holistic Interview Preparation: It covers technical, behavioral, and system design questions, as well as the overall interview process and evaluation criteria.
  • Iterative Learning: Hints, detailed solutions, and multiple approaches encourage readers to learn methodically and improve iteratively.

4. What is the typical interview process described in Cracking the Coding Interview by Gayle Laakmann McDowell?

  • Multi-Round Structure: Most top tech companies conduct 3 to 6 interviews per onsite round, including coding, behavioral, and system design questions.
  • Evaluation Criteria: Interviewers assess analytical skills, coding ability, technical knowledge, experience, and culture fit, often comparing candidates to each other.
  • Communication Focus: Candidates are encouraged to talk through their thought process, accept hints, and demonstrate problem-solving skills rather than aiming for flawless code.
  • Holistic Assessment: The process includes resume screening, phone interviews, and onsite rounds, with feedback from multiple interviewers.

5. How does Cracking the Coding Interview by Gayle Laakmann McDowell recommend preparing for behavioral interview questions?

  • Preparation Grid: The book suggests mapping your projects and experiences to common behavioral questions, such as challenges, leadership, and conflict resolution.
  • Structured Responses: Use specific, structured answers (like the S.A.R. method) and focus on your personal contributions.
  • Show Personality and Passion: Interviewers look for communication skills, culture fit, and enthusiasm, so prepare stories that highlight these traits.
  • Integration with Technical Prep: Behavioral preparation is presented as equally important to technical readiness for overall success.

6. What are the most important data structures and algorithms to master according to Cracking the Coding Interview by Gayle Laakmann McDowell?

  • Core Data Structures: Arrays, linked lists, stacks, queues, trees (binary, binary search, balanced), graphs, hash tables, tries, and heaps are essential.
  • Key Algorithms: Sorting (merge sort, quick sort, radix sort), searching (binary search, graph traversal), recursion, dynamic programming, and bit manipulation are covered in depth.
  • Implementation Skills: The book stresses the importance of implementing these from scratch and understanding their time and space complexity.
  • Advanced Topics: It also introduces AVL trees, red-black trees, topological sort, and Dijkstra’s algorithm for more advanced preparation.

7. How does Cracking the Coding Interview by Gayle Laakmann McDowell explain Big O notation and algorithm complexity?

  • Big O Fundamentals: The book explains Big O as a way to describe the upper bound of an algorithm’s runtime or space complexity, focusing on scalability with input size.
  • Simplification Techniques: It teaches to drop constants and non-dominant terms for clarity, e.g., O(2N) becomes O(N).
  • Common Patterns: Detailed examples of O(1), O(log N), O(N), O(N log N), O(N²), and exponential runtimes help readers analyze and compare algorithm efficiency.
  • Practical Application: Readers learn to optimize code and understand trade-offs, which is crucial for technical interviews.

8. What problem-solving strategies and methods does Cracking the Coding Interview by Gayle Laakmann McDowell recommend for technical interviews?

  • Problem-Solving Flowchart: Listen carefully, draw examples, state a brute force solution, optimize, walk through the solution, implement, and test thoroughly.
  • Optimization Techniques: Look for bottlenecks, unnecessary or duplicated work (BUD), and brainstorm data structures to improve solutions.
  • Testing and Communication: Test code on edge cases, explain your thought process clearly, and write clean, modular code.
  • Iterative Improvement: Start with brute force and refine with memoization, better data structures, or algorithmic optimizations.

9. How does Cracking the Coding Interview by Gayle Laakmann McDowell approach system design and scalability questions?

  • Step-by-Step Process: Scope the problem, make reasonable assumptions, draw major components, identify key issues, and redesign as needed.
  • Key Concepts: Covers horizontal vs. vertical scaling, load balancers, database partitioning, caching, asynchronous processing, and networking metrics.
  • Trade-Off Analysis: Emphasizes evaluating design choices, considering bottlenecks, and balancing scalability, reliability, and efficiency.
  • Realistic Expectations: Interviewers want to see your problem-solving process, communication skills, and ability to analyze trade-offs, not perfect solutions.

10. What C, C++, and Java concepts are emphasized in Cracking the Coding Interview by Gayle Laakmann McDowell?

  • C/C++ Topics: Classes, inheritance, virtual functions, memory management, pointers, templates, operator overloading, and smart pointers are covered for language-specific interviews.
  • Java Topics: Overloading vs. overriding, collections (ArrayList, Vector, LinkedList, HashMap), generics, lambda expressions, object reflection, and differences between TreeMap, HashMap, and LinkedHashMap.
  • Interview Questions: The book includes language-specific questions, such as private constructors, finally blocks, and multithreading, to prepare for real-world scenarios.
  • Practical Coding Tasks: Implementation exercises reinforce understanding of language features and best practices.

11. How does Cracking the Coding Interview by Gayle Laakmann McDowell address testing, debugging, and concurrency in interviews?

  • Testing Strategies: The book advises on replicating steps, diagnosing random crashes, and creating realistic, manageable tests for both code and real-world objects.
  • Debugging Techniques: It covers identifying common mistakes, such as infinite loops and pointer errors, and suggests structured approaches to debugging.
  • Concurrency Concepts: Thread creation, synchronization, locks, deadlock prevention, and classic problems like dining philosophers and multithreaded FizzBuzz are explained.
  • Practical Advice: Emphasizes clear communication, iterative diagnosis, and understanding of concurrency challenges in interviews.

12. What are the best quotes from Cracking the Coding Interview by Gayle Laakmann McDowell and what do they mean?

  • "Interviews are hard!" Reminds readers that even top candidates struggle, and success is about outperforming others, not achieving perfection.
  • "Perfection on this problem is not expected. Your performance is evaluated in comparison to other candidates." Encourages a growth mindset and reduces pressure to be flawless.
  • "Focus on modularizing your code from the beginning and 'farming out' tedious or less interesting parts of the code to other functions." Stresses the importance of clean, maintainable code and prioritizing core logic.
  • "All (good) interview problems can be approached in a logical, methodical way!" Highlights the value of structured problem-solving and logical thinking in interviews.

About the Author

Gayle Laakmann McDowell is a prominent figure in the tech industry, known for her expertise in career development and technical interviews. She's the founder and CEO of CareerCup and has authored multiple books on cracking interviews in various tech roles. McDowell's background includes software engineering positions at major tech giants like Microsoft, Apple, and Google. She holds both a bachelor's and master's degree in Computer Science from the University of Pennsylvania, as well as an MBA from the Wharton School. Her diverse experience and educational background have made her a respected authority in tech career guidance and interview preparation.

Download PDF

To save this Cracking the Coding Interview 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: 22

Download EPUB

To read this Cracking the Coding Interview 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.44 MB     Pages: 27
Want to read the full book?
Follow
Listen
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...