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
Effective Java

Effective Java

Build Java code that stays correct, understandable, and adaptable long after its first release.
by Joshua Bloch 2001 412 pages
4.51
8k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Write for Java's usage conventions, not merely its syntax

Usage is the craft. Effective Java is a guide to the choices that make code understandable, correct, reusable, and easier to change, rather than a tour of Java's grammar. Its 57 rules draw on the author's work designing and maintaining Java platform libraries, where an awkward interface can outlive the implementation that created it.

Favor clear contracts. Bloch's recurring tests are whether a module surprises its users, exposes more than necessary, duplicates existing work, or delays discovery of mistakes. A rule is guidance, not an absolute: learn the practice, then depart from it only for a reason you can explain. The aim is not clever code. It is code another programmer can safely understand and modify.

Analysis

The book's strongest premise is that programming fluency includes social convention, not just language mechanics. Shared idioms reduce the mental translation required to read unfamiliar code, much as standard notation helps scientists compare results. Its API-centered focus is especially useful because a method signature shapes how other people reason about a system. The limitation is that rules of thumb can harden into ritual. Their value comes from the failure modes they prevent, so the underlying contract matters more than copying a favored style.

Give object creation names when constructors cannot explain intent

Factories clarify creation. A static factory is a class method that returns an instance. Unlike a constructor, it can have a descriptive name, reuse an existing object, or return a suitable subtype without exposing its implementation class. A method describing a probably-prime integer, for example, communicates more than a constructor with ambiguous numeric parameters. Factories can also support provider frameworks, where a client requests an implementation without depending on its concrete class.

Choose the trade-off. Private constructors can enforce a singleton, a class with exactly one instance, or prevent instantiation of a utility class. But hiding constructors also blocks ordinary subclassing, and factories may be less obvious to API users. Use them when those benefits justify the loss of convention and discoverability.

Analysis

A named creation method acts like a small piece of executable documentation: it makes the caller state what kind of object is wanted. Returning an interface rather than a concrete implementation also preserves room to change internals without rewriting clients. This resembles dependency inversion, where high-level code relies on a stable abstraction instead of a particular implementation. The caution is real: too many factory names can make an API feel like a guessing game. The name should distinguish a meaningful choice, not decorate an ordinary constructor.

Make value objects immutable, then share them without fear

One state is simpler. An immutable object cannot change after construction. Bloch recommends omitting mutators, preventing overrides, and making fields private and final. If the object contains mutable components, clients must not be allowed to alter them through references. The complex-number example follows a functional style: adding two values returns a new object instead of changing either input.

Sharing becomes safe. Immutable values are easier to reason about, can be used concurrently without synchronization, and make dependable map keys. Factories can reuse common instances, reducing needless allocation. The cost appears when a large value is repeatedly transformed: a million-bit number changed one bit at a time may require repeated large copies. For such workloads, a mutable companion can provide efficient intermediate operations.

Analysis

Immutability reduces the number of states a program must consider, a benefit that reaches beyond local correctness into testing and concurrency design. It also turns sharing from a risk into a simplification, because readers need not ask which thread changed a value. The trade-off is not simply memory versus safety: repeated copying can make large transformations expensive. The useful design question is whether mutation belongs in the public model or only inside a carefully controlled implementation.

Copy mutable inputs and outputs before they cross your boundary

References transfer power. A constructor that stores a caller's mutable object directly gives the caller a way to change the new object's state. Returning that internal object through an accessor creates the same vulnerability in reverse. Bloch's `Period` example stores start and end dates: because `Date` is mutable, changing either original date after construction can break the period's invariant.

Defend both directions. Copy mutable arguments before storing them, and return copies rather than internal references. Validate the copies, not the originals, so another thread cannot alter an argument between validation and copying. Avoid trusting `clone` on a class that clients can subclass. Arrays also need protection because a nonempty array can always be changed by its recipient.

Analysis

This is an early, practical form of ownership discipline: a component should know who can mutate each piece of state. Languages with ownership or borrowing systems can enforce parts of this rule, but Java APIs often have to establish the boundary by convention and copying. Defensive copies are not free, so indiscriminate copying can waste time and space. The important test is whether outside mutation could invalidate an invariant, corrupt a key, or create a security problem.

Use composition unless your subclass truly is a subtype

Inheritance exposes assumptions. A subclass can depend on undocumented details of its parent. Bloch illustrates this with an instrumented `HashSet`: overriding both insertion methods counts additions twice because the parent's bulk method internally calls the single-item method. Fixing the count may still rely on an implementation detail that could change.

Wrap, then forward. Composition places an existing object inside a new one and forwards selected operations to it. A wrapper around the `Set` interface can add instrumentation without inheriting `HashSet` internals, and it can wrap different set implementations. Interfaces make that flexibility possible. For interfaces with many operations, a skeletal implementation can supply reusable defaults without forcing every implementation into a single inheritance hierarchy. Inherit only when the subtype relationship is genuine and the parent is designed for extension.

Analysis

Composition is valuable because it limits the blast radius of change: a wrapper depends on a public contract, not on the hidden choreography of a superclass. This is a form of substitutability with tighter control over what is exposed. It is not a universal ban on inheritance. Carefully designed frameworks need extension points, and forwarding can become tedious or miss callback behavior. The key distinction is whether inheritance represents a true type relationship or is merely being used as a shortcut for code reuse.

Keep equality, hashing, and ordering faithful to one value model

Contracts travel across collections. If a class defines logical equality, `equals` must be reflexive, symmetric, transitive, and consistent. Equal objects must also have equal hash codes, or a hash map may fail to find an entry using an equal key. Bloch's phone-number example demonstrates this: without a matching `hashCode`, an inserted number and a separately created equal number can land in different buckets.

Ordering must agree. `compareTo` should define a consistent ordering, ideally one that treats the same objects as equal as `equals` does. Otherwise sorted collections may behave differently from hash-based ones. Adding state in a subclass can make equality laws impossible to preserve; composition avoids that trap. A useful `toString` also makes objects and collections easier to inspect when diagnosing failures.

Analysis

These methods are not cosmetic overrides. They are protocols that let independently written components cooperate, so a local inconsistency can become a collection-wide failure. The deeper design lesson is to define one stable notion of value and use it consistently for equality, hashing, and ordering. That can be difficult when mutable fields or inheritance blur identity. Human-readable string output serves a different purpose: it improves observability, but should not become a substitute for typed accessors.

Make methods predictable: validate inputs, simplify signatures, document contracts

Catch errors near their source. Check public inputs at the start of a method and document the restrictions. A bad index or a null value should fail before it leaves an object half-modified or causes a distant, confusing failure. Keep parameter lists short; long runs of similar types invite callers to swap arguments without producing a compile-time error. Prefer an interface parameter, such as `Map`, when the method does not need a particular implementation.

Remove needless branches. An array-returning method should return an empty array when it has no results, not `null`, so every caller need not add a special case. Document exposed API elements with their preconditions, results, side effects, and exceptions. Overloads deserve particular restraint because Java selects them using compile-time types, which can surprise callers expecting runtime dispatch.

Analysis

Predictable methods reduce the number of hidden decisions imposed on callers. This connects API design to human-factors engineering: fewer special cases and clearer labels make misuse less likely, especially when code is read under pressure. Documentation also functions as a boundary between a component's stable promises and its changeable internals. There is a balance to strike. Excessive validation, overloads, or documentation can add noise, so each should clarify a real constraint rather than state the obvious.

Use exceptions for failure, not as hidden control flow

Make failure legible. Exceptions are for exceptional conditions, not ordinary looping or branching. Use checked exceptions when callers can reasonably recover, and runtime exceptions for programming mistakes such as violating a precondition. Reuse standard exception types when their documented meaning fits. An exception should describe the abstraction that failed, rather than leak an unrelated low-level detail; translate lower-level exceptions when needed.

Preserve a usable object. Failure atomicity means a failed operation leaves the object as it was before the call. Validate first or arrange potentially failing work before changing state. Include useful values in exception details, and do not silently discard an exception. An empty catch block hides information and can let corruption surface much later, far from its cause.

Analysis

Exceptions are part of an API's control-flow design, not just a reporting mechanism. The distinction between recoverable conditions and programming errors helps callers decide whether to retry, repair input, or stop. Failure atomicity extends that clarity to object state: a caller should not have to guess what a failed operation changed. One nuance is that preserving state can be costly or impossible under concurrency, so APIs should state the guarantee they actually provide rather than promise universal rollback.

Synchronize shared mutable state for visibility, not just exclusion

Atomic is not visible. A single variable read or write may be indivisible, yet one thread is not guaranteed to see another thread's update without synchronization or an appropriate visibility mechanism. The book's serial-number example shows that incrementing a field combines a read and a write, allowing duplicate results when threads interleave. A stop flag can also fail if its update is not reliably observed.

Keep locks disciplined. Synchronization protects both state consistency and communication between threads. Avoid calling client-overridable methods while holding a lock, since callbacks can cause deadlocks or expose inconsistent state. Wait for a condition inside a loop, because waking does not guarantee the condition still holds. Do not rely on scheduler timing to make a program correct, and document the class's thread-safety guarantees.

Analysis

The crucial shift is from thinking of locks only as gates to understanding them as communication rules. A program can appear correct on one machine and fail on another when visibility is assumed rather than guaranteed. The advice to keep synchronized regions small also reflects a broader principle: do not hold shared resources while invoking code whose behavior is outside your control. Thread-safety labels are useful only when they describe the actual guarantee, including any sequences that still require client coordination.

Treat serialization as a public format and hostile input

Persistence creates a contract. Implementing `Serializable` can make a class's private representation part of its long-term compatibility obligations. A custom serialized form should describe the object's logical data, not accidental structures such as the links in a private linked list. Declare an explicit serial version identifier and make serialization a deliberate design decision, not a reflex.

Deserialization needs defenses. Treat `readObject` like a constructor receiving untrusted input: validate invariants and defensively copy mutable components. A crafted stream can otherwise create an invalid object or expose references to its internals. A ` readResolve ` method can restore a canonical instance for a singleton or other instance-controlled class. Such protections must fit the class's inheritance design, since deserialization interacts with subclass state.

Analysis

Serialization turns an implementation detail into a durable data format, much like a database schema or network protocol. That creates both compatibility pressure and a security boundary: input may be old, malformed, or deliberately constructed to violate assumptions. The advice therefore generalizes beyond Java's serialization mechanism to any object reconstruction from external data. A custom format costs design effort, but accepting a default representation without review merely postpones that cost until change becomes difficult.

Use libraries and measurements before inventing clever optimizations

Borrow tested solutions. Standard libraries embody more design, testing, and use than a quick replacement is likely to receive. The book's homemade random-number method is biased and can return an invalid negative result, while the library already provides a bounded method. Likewise, binary floating-point cannot represent many decimal amounts exactly: a simple money calculation can produce a visibly incorrect remainder. Use decimal arithmetic or scaled integers when exact amounts matter.

Measure before tuning. Repeated string concatenation copies growing strings and can scale quadratically; a mutable buffer is better for building large results. More generally, profile a clear implementation before optimizing it. Performance depends on the runtime and workload, and a clever micro-optimization may add complexity without improving speed. Architecture and API choices still deserve early attention because they can be difficult to change.

Analysis

The book separates two decisions that are often confused: choosing sound abstractions early and tuning implementation details only when evidence points to a bottleneck. Its examples expose different kinds of hidden cost, from numeric representation error to repeated copying and uneven random distributions. Modern profiling tools make measurement more accessible, but measurements still need representative workloads. A benchmark can optimize the wrong behavior if it does not resemble how the software is actually used.

Analysis

Effective Java is best understood as a manual for preserving options. Its individual rules cover factories, object contracts, method design, exceptions, concurrency, and serialization, but the common concern is what a module promises to the code around it. Public fields, subclass hooks, mutable values, and default serialized forms all expose decisions that become expensive to reverse. Encapsulation is therefore not secrecy for its own sake. It is a way to retain the ability to improve an implementation without forcing every client to change.

The book also treats correctness as compositional. Collections rely on equality and hashing contracts; callers rely on documented exceptions and parameter rules; threads rely on synchronization to observe coherent transitions. A class cannot be judged only by whether its own methods work in isolation. It must honor the assumptions that other components are entitled to make. This is why examples such as the miscounting `HashSet` subclass are so effective: the bug comes not from an exotic algorithm, but from an undocumented dependency between methods.

The first edition's Java context matters. Some recommendations address language gaps of that era, including the typesafe enum pattern, which modern Java's built-in enum feature generally supersedes. Runtime performance claims are also tied to particular machines and JVM versions. Those details should not be transplanted blindly. The durable contribution is the reasoning beneath them: use types that express intent, isolate mutation, respect behavioral contracts, and verify performance empirically.

The book is a collection of rules rather than a single theory, and not every rule carries equal weight. Its greatest value comes from learning to recognize the cost of a design decision before it becomes an API obligation. Read the examples as diagnostic patterns, not commandments. A strong engineer follows a convention because its trade-offs fit the problem, and can explain the exception when they do not.

Summary in 30 Seconds
Good Java design preserves future options: hide representation, minimize public commitments, and express intent through types and method contracts. Prefer immutable values, defensive copies, composition, and coherent equality rules. Validate early, use exceptions for genuine failure, and synchronize shared state for visibility as well as mutual exclusion. Treat serialized data as an external format, rely on standard libraries, and measure before optimizing.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.51 out of 5
Average of 8k+ ratings from Goodreads and Amazon.

Effective Java is highly regarded as an essential read for Java developers, praised for its clear explanations and practical advice. Readers appreciate Bloch's expertise and the book's focus on writing high-quality, maintainable code. Many consider it a must-read for both beginners and experienced programmers. The book covers various Java features, best practices, and common pitfalls. While some find certain sections outdated or too advanced, most agree that it significantly improves coding skills and understanding of Java's intricacies.

Your rating:
4.69
468 ratings
Want to read the full book?

Glossary

static factory method

Named object creator

A static method that returns an instance of its class or a subtype. Unlike a constructor, it can have a descriptive name, reuse existing instances, and choose among implementation classes without exposing them. Bloch presents it as an alternative to, or companion for, public constructors, with trade-offs including reduced subclassability and less obvious discoverability.

typesafe enum pattern

Typed fixed set of values

A prebuilt Java pattern for representing a fixed set of named values as instances of a class with a private constructor and public static final constants. Because clients cannot create additional instances, values are type-safe and can carry methods or implement interfaces. This pattern addressed Java's lack of a built-in enum construct when the first edition was written.

defensive copying

Isolate mutable references

Creating a copy of mutable data received from a caller before storing it, and returning a copy rather than exposing mutable internal data. This prevents outside code from changing an object's state or breaking its invariants through a shared reference. The technique is especially important for immutable classes that contain mutable components, and for arrays.

failure atomicity

Failure preserves prior state

A property of an operation that leaves its object in the same valid state it had before the operation if the operation fails. It can be achieved by using immutable objects, validating inputs before mutation, doing failure-prone work first, or operating on a temporary copy. Not every operation can provide it cheaply or at all.

exception translation

Map errors to abstraction

Catching an exception from a lower-level component and throwing a different exception that makes sense in the higher-level API. This prevents implementation details from leaking through an abstraction boundary. When the lower-level cause may help diagnose the failure, exception chaining retains that cause for inspection.

open call

Call external code unlocked

An invocation of a method outside a synchronized region. Moving calls to client-provided or overridable methods outside a lock reduces the risk of deadlock and avoids holding shared access while unknown code runs. The term is used for the safer structure demonstrated by the book's work-queue example.

skeletal implementation

Reusable interface implementation

An abstract class that accompanies an interface and implements much of its behavior, leaving a small set of primitive operations for subclasses to provide. It reduces the work of implementing the interface without requiring every implementation to inherit from that class. The pattern combines interface flexibility with shared implementation assistance.

readResolve method

Replace deserialized instance

A serialization hook invoked after an object has been reconstructed. It can return a canonical instance instead of the newly deserialized object, preserving singleton or other instance-control guarantees. It can also rebuild an object through a validating constructor, though its suitability depends on the class's inheritance and serialization design.

serialized form

Object's stored representation

The byte-stream representation used to serialize an object and reconstruct it later. Once a class is widely serialized, this form becomes a compatibility commitment. A good form describes the object's logical state rather than incidental implementation details, so the internal representation can evolve without needlessly breaking persisted data.

initialize-on-demand holder class idiom

Lazy static initialization

A technique for lazily initializing a static field by placing it in a nested holder class. The holder is initialized only when first accessed, using the language's class-initialization guarantees. The accessor needs neither explicit synchronization nor repeated initialization checks. The idiom applies to static fields, not instance fields.

FAQ

What's Effective Java about?

  • Java best practices: Effective Java by Joshua Bloch is a comprehensive guide focused on best practices for Java programming. It aims to help developers write clear, correct, robust, and reusable code.
  • Practical advice: The book is tailored for developers familiar with Java who wish to enhance their coding skills. It covers a wide range of topics, including object creation, methods, classes, and interfaces.
  • Structured format: The content is organized into distinct items, each addressing a specific aspect of Java programming. This structure allows readers to easily navigate and apply the advice.

Why should I read Effective Java?

  • Improve coding skills: Reading Effective Java can significantly enhance your Java programming abilities by providing insights not commonly found in other resources.
  • Expert insights: Joshua Bloch, a key contributor to the Java platform, shares his extensive experience through practical examples and rules of thumb.
  • Code quality focus: The book emphasizes writing code that is not only functional but also maintainable and efficient, leading to fewer bugs and easier code management.

What are the key takeaways of Effective Java?

  • Clarity and simplicity: The book stresses the importance of writing clear and simple code, ensuring understandability and maintainability over time.
  • Composition over inheritance: Bloch advises using composition instead of inheritance to create more flexible and robust code structures, reducing dependencies and potential fragility.
  • Static factory methods: The book recommends using static factory methods for object creation, offering better readability and flexibility.

What are some specific rules from Effective Java?

  • Static Factory Methods: Consider providing static factory methods instead of constructors for better naming and performance.
  • Singleton Property: Enforce the singleton property with a private constructor to ensure a class has only one instance.
  • Override Equals and HashCode: Always override hashCode when you override equals to ensure correct functioning of hash-based collections.

How does Effective Java address object creation?

  • Static Factory Methods: Suggests using static factory methods for object creation instead of constructors for better naming and performance.
  • Avoiding Duplicate Objects: Advises against creating duplicate objects, especially for immutable types, to improve memory management.
  • Enforcing Noninstantiability: Discusses enforcing noninstantiability with a private constructor for utility classes to prevent unnecessary instances.

What are the benefits of immutability discussed in Effective Java?

  • Thread Safety: Immutable objects are inherently thread-safe, eliminating the need for synchronization and simplifying concurrent programming.
  • Simplicity and Clarity: Immutability leads to simpler code, making reasoning about the code easier and reducing the likelihood of bugs.
  • Reuse and Performance: Immutable objects can be shared freely, allowing for efficient memory usage and reduced overhead of object creation.

How does Effective Java suggest handling exceptions?

  • Use Exceptions for Exceptional Conditions: Advises using exceptions only for exceptional conditions, not for regular control flow, to maintain clarity and avoid performance penalties.
  • Document Exceptions: Emphasizes documenting exceptions that a method can throw to improve code readability and help users handle potential errors.
  • Favor Standard Exceptions: Recommends using standard exceptions provided by the Java platform for consistency and familiarity.

What is the significance of the Effective Java item on interfaces?

  • Define Types with Interfaces: Emphasizes using interfaces to define types, not to export constants, keeping the API clean and focused on behavior.
  • Favor Interfaces Over Abstract Classes: Advises using interfaces for flexibility, allowing multiple implementations without single inheritance constraints.
  • Avoid Constant Interfaces: Warns against using constant interfaces, suggesting utility classes instead to group constants.

How does Effective Java recommend designing for inheritance?

  • Design and Document for Inheritance: If a class is designed for inheritance, it must document the effects of overriding methods to ensure subclass understanding.
  • Prohibit Unnecessary Inheritance: Suggests making classes final or using private constructors to prevent unintended inheritance, reducing fragility.
  • Provide Protected Methods: Expose protected methods judiciously to allow subclass extension while avoiding excessive implementation detail exposure.

How does Effective Java address concurrency?

  • Synchronize Access to Shared Data: Emphasizes synchronizing access to shared mutable data to prevent data corruption and ensure thread safety.
  • Avoid Excessive Synchronization: Advises minimizing work within synchronized blocks to enhance performance and avoid deadlocks.
  • Document Thread Safety: Stresses the importance of documenting the thread safety of classes and methods for safe multithreaded use.

What is the double-checked locking idiom, and why is it problematic?

  • Lazy Initialization Purpose: Used to reduce synchronization overhead when lazily initializing a resource by checking if it's initialized before locking.
  • Inconsistent States Risk: Without proper synchronization, threads may see a partially constructed object, leading to inconsistent states and bugs.
  • Avoidance Recommendation: Advises against using double-checked locking due to its complexity and potential pitfalls, suggesting simpler alternatives.

What are the best quotes from Effective Java and what do they mean?

  • "Programs must be written for people to read, and only incidentally for machines to execute." Emphasizes writing code understandable to humans, not just optimized for machines.
  • "The single most important factor that distinguishes a well-designed module from a poorly designed one is the degree to which the module hides its internal data." Highlights the principle of encapsulation for maintainable and flexible code.
  • "Don't create a new object when you should reuse an existing one." Encourages object reuse, especially for immutable objects, to enhance performance and reduce memory usage.

About the Author

Joshua Bloch is a renowned computer scientist and author specializing in Java programming. He has made significant contributions to the Java language and its libraries, including designing and implementing the Java Collections Framework. Bloch's expertise stems from his extensive experience in software development and his involvement in shaping modern Java features. His writing style is praised for being clear, precise, and thorough, making complex concepts accessible to readers. Bloch's work, particularly "Effective Java," has become a cornerstone reference for Java developers worldwide, offering invaluable insights into best practices and effective programming techniques.

Download PDF

To save this Effective Java summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.26 MB     Pages: 22

Download EPUB

To read this Effective Java 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.35 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...