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
Code Complete

Code Complete

A Practical Handbook of Software Construction
Build software people can understand and safely change, without letting process overwhelm the work.
by Steve McConnell 1993 914 pages
4.30
9k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat construction as engineering, not clerical coding

The unavoidable center. Construction is not simply typing a finished design into a language. It includes detailed design, coding, debugging, integration, and developer testing. Depending on project size, it consumes roughly 30 to 80 percent of development time and accounts for a substantial share of defects. Other activities can be skipped or rushed; if software is built at all, construction happens.

Code carries the truth. Requirements and design documents can become outdated, while source code remains the current description of what the system does. That makes construction quality consequential for both the initial product and its future maintenance. The book is a practical handbook because sound construction habits improve software across languages, not a defense of coding in isolation from planning, architecture, or testing.

Analysis

The useful distinction is between construction as a central activity and coding as the whole job. The former deserves serious engineering attention; the latter is an incomplete picture of how software succeeds. Treating code as the system's most current record also explains why readability is operational, not decorative. One qualification matters: high construction effort does not make upstream work optional. The central activity still inherits the consequences of earlier decisions.

Spend effort upstream in proportion to the cost of being wrong

Prepare to reduce risk. Before construction, establish the problem to solve, the requirements, and the architecture. A problem statement should describe the user's difficulty, not presume a software solution. Otherwise, a team can efficiently build the wrong thing. In one example, an annual profit report seemed to require programming, until someone noticed that adding four quarterly figures by hand solved the actual problem.

Scale preparation to risk. Studies cited in the book found that fixing a requirements defect after release can cost 10 to 100 times more than fixing it during requirements work. Yet requirements change during development, with an average change rate near 25 percent in the studies cited. Stable, low-risk work can support more upfront definition; uncertain work needs short cycles, feedback, and controlled change.

Analysis

This is not an argument for a heavyweight phase before every line of code. It is an argument for buying down the risks that would be expensive to discover late. The distinction between problem and proposed solution is especially valuable because it prevents technical momentum from disguising a failure to understand the user. Iteration does not remove preparation; it changes its timing and scale. The practical test is whether preparation is reducing uncertainty or merely producing paperwork.

Treat design as a search, not a blueprint-writing ceremony

Expect discovery. Some design problems cannot be fully understood until a partial solution exists. The original Tacoma Narrows Bridge was designed around structural strength, but wind-driven movement led to its collapse in 1940. The failure exposed an important design condition that had not been adequately understood. Software has its own wicked problems: building and testing part of a system can reveal requirements or constraints that were previously invisible.

Explore cheaply. Try more than one design, move between broad structure and concrete details, and prototype a specific uncertainty. A prototype should answer a focused question, such as whether a database design can meet a stated transaction rate. It is throwaway investigative code, not a shortcut to production. Top-down decomposition and bottom-up composition are complementary ways to explore, not rival creeds.

Analysis

The bridge story makes a difficult point concrete: a clean design can still be wrong because the problem was incompletely understood. That supports iteration without making planning pointless. A prototype is most useful when its question is narrow enough that the result can change a decision. Without that discipline, experimentation can quietly become production development. The strongest design process is therefore neither endless exploration nor premature certainty, but deliberate learning at low cost.

Hide complexity and change behind small, stable boundaries

Protect the reader's attention. Information hiding means keeping design and implementation decisions inside the module responsible for them, exposing only what other modules need. A routine that generates identifiers can hide whether those identifiers are sequential, reused, or stored as integers. If that decision changes, one implementation changes rather than dozens of callers.

Limit the ripple. Divide large systems into subsystems, classes, and routines with clear responsibilities and few connections. Abstraction lets a programmer use a component without understanding its internals; encapsulation prevents accidental dependence on those internals. The goal is not to eliminate complexity from the problem, which may be impossible, but to keep each person from having to reason about all of it at once. Loose coupling and cohesive responsibilities help changes stay local.

Analysis

This principle turns modularity into a cognitive strategy: a boundary is valuable when it lets someone reason safely about one part without carrying the rest of the system in mind. It also explains why convenient access to internal data can be costly. Yet hiding is not automatically beneficial. A boundary that conceals an unstable or incoherent interface can make debugging harder. The test is whether the abstraction reduces the knowledge a caller must possess while preserving the behavior that caller genuinely needs.

Give every class and routine one coherent job

Design around responsibility. An Abstract Data Type, or ADT, groups data with the operations that belong to it. A font abstraction, for example, should offer font-level actions rather than require every caller to manipulate pixel counts and attribute bits. A study cited in the book found that students working with an ADT-based program scored more than 30 percent higher on comprehension questions than students using a functionally organized version.

Keep interfaces consistent. A class should present one clear abstraction, not mix employee operations with unrelated report or database details. Prefer containment for a has-a relationship, and use inheritance when a subtype genuinely preserves the parent type's contract. At routine level, aim for functional cohesion: one operation done well. Seven parameters is a useful warning threshold, not an absolute law, and routine length should follow complexity rather than an arbitrary line limit.

Analysis

A coherent interface is a promise to future callers: they can use the service without reverse-engineering its construction. This is why naming and responsibility matter together. A class called Employee that exposes database queries and generic phone validation is not merely untidy; it offers competing mental models. The seven-parameter guideline is similarly best used as a diagnostic prompt. Sometimes a structured object is the right abstraction, but bundling unrelated values only hides coupling rather than solving it.

Keep each value local, initialized, and single-purpose

Shrink the danger window. Initialize variables near their first use, keep their scope as narrow as possible, and group related operations together. The book illustrates this with a routine whose variables had an average live time of 54 statements. Moving initialization nearer to use reduced the average to about seven, making each value easier to track and less vulnerable to accidental changes.

Avoid ambiguous state. A variable should serve one purpose and have a name that says what it represents. Reusing a temporary value first for a mathematical result and then to swap array elements makes unrelated operations look connected. Global variables create still wider risks: hidden side effects, aliasing, uncertain initialization, and difficulty reusing code. If pointers are necessary, isolate their operations and make allocation, validation, and release disciplined and visible.

Analysis

The principle is less about minimizing the number of variables than minimizing the amount of hidden state a reader must track. A few well-named local values can make a routine clearer than one terse expression. The live-time example gives a practical way to see that clarity: shorter distance between initialization and use narrows the opportunity for confusion. This discipline does not eliminate bugs, but it makes state changes easier to inspect and suspicious behavior easier to localize.

Make code legible before comments try to rescue it

Write for human readers. Specific names, consistent formatting, and short logical sections help people understand what code does. A loop using names such as employeeIndex and divisionIndex communicates more than one using i, j, and k. White space should reveal the structure of the logic, not merely make the page look polished. Project conventions reduce arbitrary differences so attention can go to meaningful differences.

Comment the intent. A comment that repeats an assignment adds little; a comment that explains why a search is finding a command terminator may reveal information the code cannot. Comments should stay close to the code, remain maintainable, and explain assumptions or surprises. The Pseudocode Programming Process offers one way to make useful comments economical: refine an English description of the routine until it can guide the implementation, then retain the parts that explain intent.

Analysis

Readable code is a form of communication that reduces the effort required for review, debugging, and future change. The book's emphasis on names and layout is strongest when understood as a way to expose logic, not impose aesthetic uniformity. Comments help when they add information unavailable from the statements themselves. They become a liability when they duplicate code or decay after edits. A convention is most useful when it makes the code easier to read without turning style compliance into the work itself.

Handle bad input deliberately, and reserve assertions for broken assumptions

Distinguish two failures. External data and routine inputs can be invalid, so production code should validate them and respond according to the consequences. An assertion checks a condition that should never be false if the program is behaving correctly. Assertions are useful as executable documentation during development, but they do not replace error handling for anticipated failures.

Choose the right response. A consumer application may continue with a harmless substitute after a minor display error. A system controlling radiation dosage should favor correctness and stop rather than risk an inaccurate result. The architecture should set a consistent error strategy. Barricades can mark boundaries where data is checked and sanitized, allowing trusted internal code to rely on clearer assumptions. Exceptions are useful for truly exceptional conditions, but can obscure control flow when used as routine decision-making.

Analysis

The distinction between defensive handling and assertions prevents two opposite mistakes: treating user mistakes as programmer bugs, or silently accepting a broken internal invariant. The choice between continued operation and stopping is also contextual, not universal. A graceful fallback is valuable only if the fallback is safer than failure. The same error policy cannot fit every subsystem, but inconsistent handling makes a system unpredictable, so local choices still need architectural coordination.

Build a defect net from methods with different blind spots

Testing is necessary, not sufficient. Developer testing checks units and their interactions, but the book reports typical defect-detection rates of about 30 percent for unit testing and 35 percent for integration testing. Formal design and code inspections were reported at roughly 55 and 60 percent. These methods find different kinds of problems, so a quality plan should combine them rather than expect one technique to certify correctness.

Choose tests systematically. Test requirements and design decisions, exercise each line and branch, examine how data moves from assignment to use, and check boundaries and invalid inputs. Writing tests before code can expose unclear requirements earlier. Keep and automate tests so they can be rerun after changes. In one study of a program with 15 known defects, experienced programmers found an average of only about five through a single testing or review method.

Analysis

The strongest implication is methodological diversity, not the claim that any one percentage applies everywhere. A test suite can execute code without challenging its assumptions, while a reviewer may notice unclear interfaces that a test cannot expose. Conversely, human review cannot reliably substitute for executing boundary cases. Because different methods reveal different failures, the value lies in overlap with distinct perspectives. Detection rates should guide process design, not serve as guarantees for an individual project.

Integrate a little at a time, keeping the system runnable

Avoid the big bang. Phased integration combines many separately developed components at once, so when the system breaks, the source may be anywhere. Incremental Integration adds a tested class or feature to a working system, then checks the combined result before adding more. A football stadium at the University of Washington collapsed during construction because its partially built structure could not yet support itself. Software, too, must work at each construction step, not only in the imagined finished state.

Make progress visible. A daily build and smoke test compile the project and run a short end-to-end check. If yesterday's build worked and today's does not, the search area is much smaller. Integration order can follow risk, features, or slices through the system. On large teams, whose communication paths grow rapidly with team size, frequent integration also exposes coordination problems early.

Analysis

Integration is not just the final joining of components; it is a way to control uncertainty while the system is being built. A runnable product provides evidence that design assumptions and interfaces are holding together. Daily builds make that evidence frequent, though the smoke test must be meaningful and maintained as the product grows. The practice has coordination costs, especially for large changes, but postponing integration does not remove those costs. It concentrates them at the moment when diagnosis is hardest.

Refactor for clarity whenever change exposes a design weakness

Improve the structure without changing behavior. Refactoring is a change to internal code organization that preserves observable behavior while making the system easier to understand or modify. Duplicate logic, oversized routines, mixed class responsibilities, long parameter lists, public data, and repeated parallel edits are warning signs. When a defect reveals that a routine is poorly organized, fixing the immediate symptom is not enough; the code should be made less likely to produce similar defects.

Make changes safely. Save a working version, make small changes one at a time, compile and retest, and review riskier changes. Refactoring is not a euphemism for experimenting on broken code, nor should it become an excuse to polish a system that needs a clean rewrite. A useful strategy for legacy systems is to improve the code being touched, gradually expanding the well-structured portion without destabilizing everything at once.

Analysis

Refactoring treats maintenance as a chance to improve the system's future economics, not simply restore its previous behavior. The preservation of observable behavior is crucial because it separates structural improvement from feature change. The safest scale is usually local and testable, but a small edit is not automatically a safe edit. Repeated one-line changes can be riskier than a larger, deliberate rewrite. The decision should depend on whether the old structure can be improved incrementally without carrying its central defects forward.

Optimize only the measured bottlenecks, after the design works

Find the hot spots first. Code tuning changes correct code to improve speed or size, often at a cost to clarity. The book cites the familiar concentration pattern: roughly 20 percent of routines may consume 80 percent of execution time, and Knuth found that less than 4 percent of a program could account for more than half its run time. Measure before choosing where to work.

Prefer higher-leverage fixes. Requirements, architecture, algorithms, data structures, compiler choices, or hardware may offer larger gains than rewriting statements. In one graphing application, a few changes reduced a 45-minute drawing operation to under 30 seconds; subsequent work brought it to a little over one second. Each optimization still had to be measured, because changes that help one language or compiler can hurt another. Keep a working version and revert changes that fail.

Analysis

The chapter's strongest performance advice is epistemic: intuition is not measurement. A programmer can make a loop look more efficient while a compiler has already removed the apparent cost, or can optimize code that barely runs. Profiling protects effort from these attractive mistakes. There is a tradeoff, since performance work can be necessary in embedded or time-critical systems. In those cases, clear budgets and measured hot spots keep optimization purposeful rather than turning cleverness into a substitute for a requirement.

Analysis

Code Complete makes a case for software construction as disciplined craft: not because coding is the entire lifecycle, but because every real system must pass through it, and because construction practices determine whether complexity stays manageable. Its organizing idea is cognitive economy. Good interfaces, narrow scope, meaningful names, readable layout, modularity, and incremental integration all reduce the amount of information a developer must hold in mind at once. That is a practical theory of quality, not a style guide for its own sake.

The book's most productive tension is between preparation and adaptation. It rejects both extremes: coding before understanding the problem, and specifying every detail as if users and developers could know the final system in advance. Its answer is risk-weighted preparation followed by iterative learning. That stance remains relevant in modern continuous delivery, where frequent releases shorten feedback loops but do not remove the need to understand architectural constraints, security, or the cost of changing shared interfaces.

Its quality argument is economic as well as technical. Reviews, tests, and early defect removal consume time, yet prevent the larger drain of rework. The evidence cited is compelling as direction, but many figures come from particular organizations, languages, and project eras. They are best treated as signals to measure local performance, not universal constants. The book itself repeatedly supports that caution in its discussion of optimization.

The strongest contemporary reading is that Code Complete is less a catalogue of timeless rules than a method for making decisions visible. A coding convention should reduce ambiguity, not become ceremony. A test should challenge an assumption, not merely confirm a happy path. An abstraction should localize change, not hide a confusing design. Modern code generation and automated tooling can accelerate construction, but they also increase the importance of reviewable interfaces, traceable assumptions, and reliable tests. The durable lesson is not to write more process into every project. It is to match rigor to risk, keep feedback close to the work, and make the system understandable enough that people can safely change it.

Summary in 30 Seconds
Construction includes design, coding, debugging, integration, and testing, often consuming 30 to 80 percent of development time. Match preparation to risk: late requirements fixes can cost 10 to 100 times more, while requirements still change substantially during development. Clear boundaries, focused routines, and readable code limit complexity. Combine testing with reviews because each catches different defects. Measure performance before tuning, since a small fraction of routines often accounts for most execution time.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.30 out of 5
Average of 9k+ ratings from Goodreads and Amazon.

Code Complete receives mostly positive reviews, praised for its comprehensive coverage of software development best practices. Many consider it essential reading, especially for junior developers. Readers appreciate the focus on managing complexity, writing readable code, and following good design principles. Some criticize its length, verbosity, and outdated examples. Experienced developers find less value, as much content feels obvious. The book's age is noted, with some parts no longer relevant to modern development practices. Overall, it's seen as a valuable resource for learning fundamental software engineering concepts.

Your rating:
4.59
309 ratings
Want to read the full book?

Glossary

Software Construction

Building and verifying software

The hands-on work of creating software, centered on coding and debugging but also including detailed design, unit testing, integration, and integration testing. It is distinct from requirements development, architecture, management, and independent system testing, though it interacts with all of them. The book treats it as a substantial engineering activity rather than a mechanical translation of a finished design.

Information Hiding

Localize design decisions

A design principle in which a module keeps selected implementation or design decisions private and exposes only a controlled interface. The hidden decision may be a data representation, algorithm, file format, or area likely to change. By containing such information, a system limits the effects of modifications and reduces how much surrounding code must understand.

Abstract Data Type (ADT)

Data with related operations

A collection of data and the operations that describe or modify that data. An ADT lets the rest of a program work with a meaningful entity, such as a font or file, rather than its low-level representation. Classes commonly implement ADTs, but the concept can also guide design in languages without object-oriented features.

Pseudocode Programming Process

Design before coding

A routine-construction method that begins by defining the routine's purpose, inputs, outputs, assumptions, and tests. The programmer then writes precise, English-like pseudocode, reviews and refines it, and turns it into code. The pseudocode can become comments that explain intent, while successive refinement exposes design problems before they are embedded in implementation.

Defensive Programming

Limit damage from errors

A way of writing software that anticipates invalid inputs, unexpected conditions, and mistakes at component boundaries. It includes validating external data, checking assumptions with assertions, choosing explicit error responses, and containing damage. Assertions are for conditions that should never occur; production error handling is for problems the program expects may occur.

Structured Basis Testing

Exercise independent code paths

A white-box testing method that estimates the minimum number of test cases needed to execute each path through a routine. It starts with one case for the straight path and adds cases for decision points, including conditional terms and switch cases. It provides a systematic foundation, but must be supplemented with data-flow, boundary, and invalid-input tests.

Incremental Integration

Add tested pieces gradually

An integration strategy that combines a working system with one tested class, component, or feature at a time. After each addition, the combined software is tested and debugged before more pieces are introduced. This narrows the likely source of new failures, makes progress visible earlier, and avoids the diagnostic difficulty of joining many untested components at once.

Refactoring

Improve structure, preserve behavior

A change to a program's internal structure that makes it easier to understand or modify without changing its observable behavior. Examples include extracting a routine, replacing duplicated code, clarifying a class interface, or reducing unnecessary coupling. Safe refactoring uses small steps, saved versions, compilation, testing, and review appropriate to the change's risk.

Daily Build and Smoke Test

Build and check each day

A practice in which the project is compiled and linked frequently, ideally every day, then run through a brief end-to-end test for major failures. A broken build becomes an immediate priority because it interrupts the team's shared ability to test and integrate. The smoke test must grow with the system and be automated when practical.

Technology Wave

Maturity of tools and platforms

A metaphor for how mature a programming environment is. Early-wave environments often have unstable tools, limited documentation, and weak debugging support, while mature environments offer more reliable compilers, libraries, and integrated tooling. The programmer should adjust expectations and practices to the environment, while using conventions to compensate for language or tool limitations.

FAQ

What's Code Complete about?

  • Comprehensive Guide: Code Complete by Steve McConnell is a detailed handbook focused on software construction, emphasizing best practices and methodologies for building high-quality software.
  • Focus on Practical Techniques: It provides practical advice and techniques that can be applied directly to software projects, making it a valuable resource for both novice and experienced developers.
  • Structured Approach: The book organizes content into clear sections, covering design principles, coding standards, and debugging strategies, helping readers understand the complexities of software development.

Why should I read Code Complete?

  • Enhances Software Quality: Reading Code Complete equips developers with the knowledge to improve the quality of their code, which is crucial in today’s software-driven world.
  • Practical Insights and Techniques: The book is filled with practical insights that can be immediately applied to real-world projects, ensuring a holistic understanding of software construction.
  • Widely Respected Resource: Code Complete is considered a classic in software engineering, often recommended by industry professionals and educators.

What are the key takeaways of Code Complete?

  • Importance of Design: Good design is the foundation of good code, leading to more maintainable and efficient software.
  • Coding Standards Matter: Adhering to coding standards enhances readability and maintainability, which are crucial for successful software development.
  • Debugging and Testing: These are integral parts of the development process, ensuring that software meets its requirements and is free of defects.

What are the best quotes from Code Complete and what do they mean?

  • "You can’t build a reputation on what you are going to do.": Emphasizes the importance of action over intention in software development.
  • "The best way to improve productivity is to improve quality.": Highlights the direct relationship between quality and productivity, suggesting that investing in quality leads to fewer defects and less rework.
  • "Good software is built by people who care.": Reflects the idea that passion and dedication are essential for creating high-quality software.

What is the significance of "information hiding" in Code Complete?

  • Encapsulation of Complexity: Information hiding allows programmers to encapsulate implementation details within classes, reducing complexity for users of the class.
  • Improved Maintainability: By hiding details, programmers can modify the implementation without impacting the overall system, making the code easier to maintain and extend.
  • Design Decisions: Good design involves making conscious decisions about what information to hide and what to expose, creating a clear and understandable interface for classes.

What is the Pseudocode Programming Process (PPP) in Code Complete?

  • Structured Approach: The PPP is a structured approach to writing code that emphasizes the use of pseudocode to outline the logic before actual coding begins.
  • Iterative Refinement: It encourages iterative refinement, allowing developers to clarify their thoughts and designs before diving into implementation.
  • Documentation Benefits: The pseudocode serves as documentation, making it easier to understand the code's intent and logic, which aids in future maintenance.

How does Code Complete address debugging and testing?

  • Debugging as a Process: McConnell presents debugging as a systematic process that involves identifying, isolating, and fixing defects.
  • Testing Importance: Testing is highlighted as crucial for ensuring software quality, with strategies like automated tests and test-driven development emphasized.
  • Strategies for Effective Testing: McConnell provides various strategies for effective testing, encouraging developers to integrate testing into their daily workflow.

What are some best practices for writing readable code according to Code Complete?

  • Use Meaningful Names: Descriptive variable and function names enhance code readability and help others understand the code's intent.
  • Consistent Formatting: Maintaining a consistent formatting style throughout the codebase improves the visual structure of the code.
  • Comment Wisely: Comments should clarify the intent of the code rather than repeat what the code does, focusing on the "why" rather than the "how."

How does Code Complete suggest handling changes in software projects?

  • Anticipate Changes: Identify areas likely to change during the design phase and isolate those areas within the code to minimize impact.
  • Use of Version Control: Emphasizes the importance of using version control systems to manage changes effectively, allowing teams to track modifications and collaborate efficiently.
  • Iterative Development: Encourages regular reassessment of requirements and design, allowing teams to adapt to changes as they arise.

What is the role of refactoring in Code Complete?

  • Improving Code Quality: Refactoring is crucial for improving the internal structure of code without changing its external behavior, making it easier to understand and modify.
  • Continuous Improvement: Regular refactoring is encouraged as part of the development process, allowing developers to refine their code as they gain new insights.
  • Specific Refactorings: The book provides a catalog of specific refactorings that can be applied to enhance code quality, such as simplifying complex expressions and reducing duplication.

What are the main software construction practices discussed in Code Complete?

  • Design Principles: Emphasizes modularity, abstraction, and encapsulation to manage complexity.
  • Coding Techniques: Covers essential techniques like meaningful variable names, consistent formatting, and the importance of comments.
  • Testing Strategies: Outlines different testing strategies, including unit testing, integration testing, and system testing, to identify defects early.

How can I apply the concepts from Code Complete to my projects?

  • Implement Best Practices: Start by implementing the best practices outlined in the book, such as consistent coding standards and thorough documentation.
  • Focus on Design: Prioritize the design phase by creating clear architectural plans and modular designs.
  • Integrate Testing Early: Incorporate testing into your development process from the beginning, using automated tests and regular code reviews.

About the Author

Steve McConnell is a respected software engineering author and consultant. He is best known for his book "Code Complete," which has become a classic in the field of software development. McConnell has written several other influential books on software project management and development practices. He founded Construx Software, a software development consulting and training company. McConnell's work emphasizes practical, evidence-based approaches to software engineering, drawing from extensive research and industry experience. He has received numerous awards for his contributions to the field, including the Award for Outstanding Contribution to the Software Engineering Literature from the IEEE Computer Society.

Download PDF

To save this Code Complete summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.44 MB     Pages: 23

Download EPUB

To read this Code Complete 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: 29
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
600,000+ 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...