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

Java Performance

The Definitive Guide: Getting the Most Out of Your Code
Find the real source of Java slowdowns, then tune the part that actually limits your application.
by Scott Oaks 2014 423 pages
4.39
319 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Measure the deployed system before tuning its Java component

Find the real constraint. Java is only one part of an application’s performance. A faster business-logic module cannot raise overall throughput if the database still handles only 100 requests per second. The same applies to network delays, disk activity, test harnesses, and other applications sharing the machine. Diagnose the whole system before deciding that the JVM is responsible.

Test what users run. A tiny benchmark may omit database calls, network transfers, sessions, or the code paths that shape real compiler behavior. A full application test is the most faithful option; a mesobenchmark, a substantial test of one component, is a useful compromise. Microbenchmarks can mislead through compiler optimizations, unrealistic inputs, and measurement overhead.

Analysis

What's striking is how often a local improvement can make the larger system no faster, or even slower by increasing pressure on an already overloaded component. This is a systems problem, not a Java trick. The practical discipline is to connect each proposed change to an end-to-end measure, then check whether the bottleneck moved. Component tests still have value for diagnosis, but they cannot establish the benefit to users on their own.

Treat benchmark results as noisy evidence, not verdicts

Choose the right measurement. Batch tests report time to finish fixed work; throughput tests report completed operations per second; response-time tests examine how quickly a fixed load is served. For user-facing services, averages can conceal pauses, so pair them with a percentile such as the 90th or 99th. Warm-up matters when JIT compilation, caches, or operating-system file buffers change performance over time.

Separate signal from noise. In the book’s example, three runs suggested a 25% improvement, but the t-test yielded a p-value of 0.43, so the evidence was inconclusive. More runs made the difference clearer. Statistical significance is not practical importance: a reliable 1% slowdown may matter less than a noisy 10% slowdown. Automate repeated runs and collect enough system data to explain changes.

Analysis

The useful habit is to treat a benchmark as an experiment with a hypothesis, not as a stopwatch contest. Variability, warm-up, and instrumentation are part of the result, not administrative details. A further caution is that a p-value does not tell whether a change is valuable, nor is it the probability that a performance difference is real. Effect size, operational cost, and user impact still require judgment.

Use profiles to locate causes, not merely the hottest method

Make hidden work visible. Operating-system tools reveal CPU, disk, memory, and network conditions; JVM tools show threads, classes, compilation, and garbage collection. A profile is a guide to where to investigate, not an automatic list of edits. If class definition dominates startup, the fix may be loading fewer classes or loading them concurrently, not rewriting a native method that the application cannot change.

Know each tool’s blind spots. Sampling profilers have low overhead but may miss short or infrequent work. Instrumented profilers count calls more precisely but alter bytecode and can change compiler decisions. Thread timelines and stack dumps help distinguish active work from waiting. Java Flight Recorder records JVM events, including lock waits, allocation, I/O, and GC, with low overhead in its default recording mode.

Analysis

The distinction between a symptom and a cause is central here. A method can appear expensive because it sits at the end of a larger costly process, or because the profiler sees only part of the work. Comparing independent views, such as CPU profiles, thread states, and operating-system counters, acts like triangulation. The trade-off is that every diagnostic tool changes the scene to some degree, so results need interpretation rather than blind trust.

Let the JIT optimize hot code, then verify its cache

Compilation improves with evidence. HotSpot initially interprets bytecode, then compiles frequently used methods after observing how the application behaves. The server compiler waits longer than the client compiler, but can make stronger optimizations; tiered compilation starts with quicker compilation and recompiles hot code more aggressively. In the book’s tests, tiered compilation was a strong general choice for long-running work, while the client compiler helped short startup-sensitive jobs.

Tune only what evidence supports. A finite code cache can fill, especially with tiered compilation or large applications. If it does, some code may remain interpreted, so monitor the cache and enlarge it when needed. Compilation logs can reveal whether critical methods are compiled. Avoid random flag changes: simpler code often gives the compiler more room to optimize, and many tuning flags solve narrow problems.

Analysis

The JIT’s advantage is adaptive specialization: it uses observed behavior rather than guessing every program’s hot paths in advance. That makes a warmed benchmark different from a cold start, and makes a microbenchmark’s profile potentially unlike production. The key operational question is not whether compilation is sophisticated, but whether the application has enough time and code-cache capacity to benefit. Startup-sensitive tools and continuously running services have different objectives.

Choose garbage collection by latency, throughput, and available CPU

Every collector trades something. The throughput collector pauses application threads for collections, using parallel workers to maximize completed work while they run. CMS and G1 do much of old-generation work concurrently, reducing long pauses but consuming CPU in the background. G1 divides the heap into regions and can reclaim selected regions, which makes it better suited than CMS to many large-heap cases in the book’s Java 7 and 8 context.

Let the workload decide. In one four-CPU test, CMS improved a batch job’s time slightly; on one CPU it was slower than the throughput collector because both competed for the same processor. For response-time workloads, concurrent collection can improve the slowest percentiles while worsening averages or CPU use. Start with defaults, inspect detailed GC logs, and investigate full collections or concurrent failures before tuning.

Analysis

Garbage collection is best understood as resource scheduling, not as a contest for the shortest pause number. Concurrent work spends CPU to protect responsiveness; a stop-the-world collector can be more efficient when CPU is scarce. That framing also explains why a collector that wins an isolated test may lose when several JVMs share a host. The specific collector rankings and defaults here belong to the book’s HotSpot versions, not every Java release or deployment.

Reduce long-lived heap data before reaching for clever GC flags

Live memory is costly. Short-lived objects are often cheap because young-generation collection can discard them quickly. Long-lived objects take more work to trace and retain space that could serve new allocations. In the book’s GC example, a full collection that reclaimed nearly all old-generation data took about 70 milliseconds; collections where most data remained live took roughly 540 to 730 milliseconds.

Make memory changes selectively. Use histograms to find abundant object types, then heap dumps to trace who retains them. Smaller fields, lazy initialization of rarely used objects, and canonical copies of repeated immutable values can reduce footprint. Reuse is justified for a small number of expensive resources, such as database connections, but large pools burden GC. Soft references can keep cached data too long, weak references disappear quickly, and finalizers delay reclamation.

Analysis

The important shift is from counting allocations to asking what stays reachable. A busy application can allocate rapidly yet perform well if most objects die young; a seemingly quiet cache can be costly if it anchors a large object graph. Memory profiling therefore needs both object counts and retention paths. Reuse is not inherently efficient: its benefit depends on initialization cost, object count, and how long those objects remain live.

Size thread pools for the true bottleneck, not the visible queue

More threads are not automatically more work. On a four-CPU machine, the stock-calculation batch test improved markedly up to four threads, then slowed as more threads competed for resources. When an external system is saturated, adding threads can overwhelm it and lower total throughput. A pool also needs sensible bounds and a queue size: a huge backlog can turn overload into long user waits instead of solving it.

Match task shape to scheduling. Fixed partitions work well when tasks take similar time. ForkJoinPool supports recursively divided tasks and work stealing, which can help when task durations vary, but millions of tiny tasks add allocation and scheduling overhead. For synchronization, reduce shared mutable state and keep critical sections short. Thread-local objects can avoid needless contention; false sharing can still slow independent variables that occupy the same CPU cache line.

Analysis

A thread pool is both a parallelism tool and a throttle. Its size should reflect CPU capacity and the behavior of dependencies, not merely the number of waiting tasks. This resembles queueing systems where admitting more work can increase congestion rather than completed work. Fine-grained tasks help balance uneven workloads, but their management has a price. The best design is therefore workload-specific, and must be measured under the bottleneck conditions it is meant to handle.

Batch database work, but keep transaction locks no longer than needed

Reduce round trips. JDBC prepared statements can reuse database work when pooled per connection. Batching can make a dramatic difference: inserting 200,448 rows took about 2,221 seconds with autocommit and no batching, but about 12 seconds with one batch and one commit in the reported test. The gain comes from fewer database calls, not a magical JVM setting.

Respect database limits. Longer transactions reduce commit overhead but hold locks longer, which can restrict concurrency. Connection pools should usually match application concurrency, unless that load overwhelms the database, in which case the pool should limit access. JPA adds its own cache behavior: its second-level cache can serve entities found by key, but query results generally bypass it. A join query may be faster initially and slower on repeated runs unless query caching is available.

Analysis

This is a clear example of optimization crossing organizational boundaries: application code controls call patterns, while the database determines what concurrency and storage can sustain. Batching reduces communication overhead, but the optimal transaction boundary depends on correctness and lock duration. Likewise, a cache changes which work is repeated, so measuring only the first query can select the wrong design. The performance unit is the whole interaction, not the Java method that initiates it.

Send less, reuse expensive resources, and respect serialization costs

Network time changes the answer. A 100 KB response that took 20 milliseconds on the book’s LAN took about a second over public WiFi. Removing whitespace or compressing the response greatly reduced the remote delay, though compression could hurt performance on a fast LAN by spending extra CPU. Test on representative networks, and balance fewer, larger calls against the cost of transferring unused data.

Choose richer formats deliberately. XML, JSON, document models, and Java objects trade processing speed, memory, and ease of use. Reusing parser factories and schemas avoids repeated setup. In Java EE, pooling EJBs or connections can pay off when creation is expensive, but oversized pools retain memory. Custom serialization can reduce bytes and sometimes improve transfer speed, yet incorrectly rebuilding shared objects can break program behavior.

Analysis

The key insight is that latency is not located only in code execution. Encoding, network distance, payload size, and setup costs all contribute, and the dominant cost can change with deployment. Compression is a good illustration: less data helps a slow link but may waste CPU where bandwidth is abundant. Good performance design therefore preserves functional needs while trimming the costs that matter in the target environment.

Prefer simple Java choices that avoid hidden costs at scale

Small choices accumulate. Buffer file and socket I/O so code does not make a system call for each byte. Pre-size collections when the expected size is known, use a data structure suited to the lookup, and avoid piecemeal string concatenation that creates temporary objects. Keep disabled logging cheap by checking whether a message is enabled before calculating its arguments.

Do not optimize by folklore. JNI crossings can cost more than equivalent Java code; if native code is necessary, make calls coarse-grained and keep pinned arrays or strings pinned briefly. Exceptions are appropriate for unexpected events, not routine branching. Lambdas and anonymous classes performed similarly in the book’s tests, while lazy streams could stop early and avoid building intermediate collections. These choices are small, but repeated millions of times, their costs become visible.

Analysis

The book’s strongest practical position is neither tune nothing nor optimize everything. It distinguishes low-complexity choices that avoid known waste from speculative changes that complicate code before measurement. That is a valuable middle ground: use sound defaults, choose data structures according to the operation, and reserve invasive optimization for measured bottlenecks. One limitation is that even sensible implementation advice ages as the JDK evolves, so the principle lasts longer than any particular API behavior.

Analysis

The book’s most durable contribution is not its catalog of HotSpot flags. It is a method for treating performance as an observable property of a deployed system. The narrative repeatedly moves from a tempting local explanation to a broader causal chain: an apparent Java slowdown may be database saturation, a client that cannot drive the server, excessive retained heap, or a benchmark that measures its own harness. This is a useful corrective to optimization culture, which often mistakes visible code for the whole system.

Its technical model is unusually concrete for a reference book. Compiler behavior, object lifetimes, GC pauses, thread scheduling, network transfer, and database transactions are connected through measurable trade-offs. That creates a practical hierarchy: establish the user-facing metric, find the constrained component, inspect what the runtime is doing, change the smallest relevant mechanism, then repeat the experiment. The distinction between a statistical signal and an operationally important regression is especially valuable, although the book’s gloss on p-values is not statistically precise. A p-value is calculated assuming the null hypothesis, not the probability that the null is true. The operational lesson still holds: noisy measurements do not justify certainty, and magnitude matters alongside confidence.

The book’s age is material. Its specific compiler defaults, garbage collectors, flags, and Java EE guidance describe HotSpot Java 7 and 8 in 2014. They should not be copied into a modern deployment without checking current runtime documentation and testing. The more lasting advice is to distrust inherited tuning recipes, record the actual runtime configuration, and treat performance claims as conditional on workload and hardware. In that sense, the title’s promise of a definitive guide is best read as a guide to disciplined reasoning, not a timeless table of optimal settings. Its central tension is productive: the JVM automates more than ever, but automation cannot infer application value, external bottlenecks, or acceptable tail latency without engineers defining and measuring them.

Summary in 30 Seconds
Application speed depends on the whole system, so measure realistic workloads before changing Java code. Benchmarks need warm-up, repeated runs, and percentiles because averages and noisy samples can hide slow responses. Profiles and runtime logs help locate causes, while garbage collection, thread counts, database batching, and network payloads each trade speed against memory, CPU, or latency. In one test, batching 200,448 database inserts cut processing time from about 2,221 seconds to 12.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.39 out of 5
Average of 319 ratings from Goodreads and Amazon.

Java Performance is highly praised as an essential, comprehensive guide for Java developers. Readers commend its in-depth coverage of JVM internals, garbage collection, and performance optimization techniques. While some find it challenging due to its technical density, many consider it a must-read for experienced developers. The book is noted for its practical examples, benchmarks, and up-to-date information on Java 7 and 8. Reviewers consistently rate it highly, comparing it favorably to other respected Java texts and recommending it for those seeking to enhance their understanding of Java performance.

Your rating:
4.64
156 ratings
Want to read the full book?

Glossary

Microbenchmark

Tiny operation timing

A test intended to measure a very small operation, such as a method call or an arithmetic alternative. Microbenchmarks are unusually vulnerable to compiler optimizations, measurement overhead, unrealistic inputs, and artificial thread contention. They can offer rough comparisons, but the book cautions against treating them as reliable evidence of application performance.

Mesobenchmark

Partial application test

A benchmark that performs real work and exercises substantial code, but represents only part of a complete application. A simple web request test with a JSP and server infrastructure is one example. Mesobenchmarks are generally more realistic than microbenchmarks and easier to manage than full-system tests, but can omit features that change performance.

Tiered compilation

Fast compile, then optimize

A HotSpot compilation strategy that first compiles code with the client compiler, then recompiles sufficiently hot code with the more optimizing server compiler. It aims to combine quicker startup with strong long-running performance. The book discusses its behavior and defaults specifically for Java 7 and Java 8.

Stop-the-world pause

Application threads temporarily stop

A period during garbage collection when application threads are paused so the collector can safely inspect or move objects. These pauses can affect response time, especially when a full collection takes a long time. Collectors differ in how much work requires such pauses and how much can run concurrently.

Escape analysis

Detects unshared objects

A JIT compiler optimization that determines whether an object is used only within a limited scope or escapes to other code. When the object does not escape, the compiler may eliminate its allocation, avoid synchronization, or keep its fields in registers. The book notes that this optimization is enabled by default in the server compiler it describes.

TLAB

Thread-local allocation area

A thread-local allocation buffer is a small region of the young generation reserved for one thread’s object allocations. It allows many allocations to proceed without synchronizing with other threads. Objects too large to fit, or allocations made when the buffer is full, may be allocated directly from the heap instead.

False sharing

Unrelated data shares a cache line

A processor-cache effect in which threads modify different variables that happen to occupy the same cache line. The hardware may repeatedly invalidate and reload that shared line, slowing the threads even though they do not logically share the variables. The book suggests reducing writes or, in suitable cases, separating data through padding.

Java Flight Recorder

Low-overhead JVM event history

A JVM recording facility that captures selected events, such as garbage collection, allocation, lock blocking, compilation, and I/O. Its event history can be examined live or saved for later diagnosis. The book describes it as a particularly rich source of JVM visibility, with overhead dependent on the events and thresholds enabled.

L2 cache

Shared JPA entity cache

The JPA second-level cache is shared among entity managers in an application. It can serve entities retrieved by primary key or through relationships, avoiding database calls. In the book’s account, entities retrieved through queries do not automatically enter this cache, so query and join choices can behave differently on repeated executions.

FAQ

1. What is "Java Performance: The Definitive Guide" by Scott Oaks about?

  • Comprehensive Java performance focus: The book explores the art and science of Java performance, delving into JVM internals, garbage collection, JIT compilation, and Java SE/EE API optimizations.
  • Bridging theory and practice: Scott Oaks balances theoretical concepts with actionable advice, helping readers understand both how Java works under the hood and how to apply best practices in real-world scenarios.
  • Holistic performance coverage: Topics include memory management, threading, synchronization, object lifecycle, web container tuning, database access, and more, providing a complete view of Java performance engineering.

2. Why should I read "Java Performance: The Definitive Guide" by Scott Oaks?

  • Expert, actionable guidance: Scott Oaks is a recognized authority on Java performance, offering proven strategies to optimize applications and avoid common pitfalls.
  • Covers both Java SE and EE: The book addresses performance considerations for a wide range of Java applications, from core language features to enterprise technologies like EJBs and JPA.
  • Emphasizes measurement and tuning: Readers learn the importance of testing in real environments, using the right tools, and making data-driven optimization decisions.

3. What are the key takeaways from "Java Performance: The Definitive Guide" by Scott Oaks?

  • Performance is both art and science: Deep JVM knowledge, experience, and intuition are all necessary for effective tuning.
  • Test and measure in context: Realistic, repeated, and statistically analyzed performance testing is essential for meaningful results.
  • Holistic optimization: Effective performance work spans JVM tuning, code best practices, memory management, threading, and external system considerations.

4. What are the best quotes from "Java Performance: The Definitive Guide" by Scott Oaks and what do they mean?

  • "Performance tuning is part art and part science." This highlights the need for both technical knowledge and practical intuition in optimizing Java applications.
  • "Test real applications, not just microbenchmarks." Emphasizes that only real-world testing reveals true performance characteristics and bottlenecks.
  • "The law of diminishing returns applies to heap sizing." Reminds readers that simply increasing heap size won’t always yield better performance and can sometimes make things worse.

5. How does Scott Oaks in "Java Performance: The Definitive Guide" recommend approaching Java performance testing?

  • Test real-world scenarios: Performance testing should be conducted on the actual application as it will be used, not just on isolated modules or microbenchmarks.
  • Account for variability: Run tests multiple times and use statistical analysis (like Student’s t-test) to distinguish real regressions from random noise.
  • Integrate testing early: Automated, frequent performance testing in the development cycle helps catch regressions and collect comprehensive data for analysis.

6. What are the main Java Virtual Machine (JVM) internals and tuning strategies discussed in "Java Performance: The Definitive Guide"?

  • JIT compilation: The JVM interprets bytecode initially, then compiles hot methods to native code for better performance; tuning involves selecting compiler modes and managing code cache.
  • Garbage collection algorithms: The book covers serial, throughput (parallel), CMS, and G1 collectors, each with different trade-offs for pause times, throughput, and heap sizes.
  • Heap and generation sizing: Properly sizing the heap and its generations, and tuning related flags, is crucial to balancing GC frequency, pause times, and memory usage.

7. What are the key garbage collection (GC) algorithms and their trade-offs in "Java Performance: The Definitive Guide" by Scott Oaks?

  • Serial collector: Simple and single-threaded, best for small heaps and single-CPU systems, but causes long pause times.
  • Throughput (Parallel) collector: Multi-threaded, maximizes throughput but can have long pauses during full GC cycles.
  • Concurrent Mark Sweep (CMS): Reduces pause times by doing most work concurrently, but uses more CPU and can suffer from fragmentation and promotion failures.
  • G1 collector: Designed for large heaps, divides memory into regions, balances pause times and throughput, and reduces fragmentation risk.

8. How does "Java Performance: The Definitive Guide" by Scott Oaks advise choosing and tuning a garbage collector for your application?

  • Match GC to workload: Use serial GC for small heaps or single CPUs, throughput GC for maximizing throughput on multi-CPU systems, and CMS or G1 for low-pause requirements and large heaps.
  • Consider application type: Batch jobs with available CPU may benefit from concurrent collectors, while CPU-limited jobs may perform better with throughput GC.
  • Tune for response time goals: Throughput GC often yields better average response times, while concurrent collectors like CMS and G1 improve 90th/99th percentile response times by reducing long pauses.

9. What are the best practices for heap memory management and avoiding out-of-memory errors in "Java Performance: The Definitive Guide"?

  • Minimize object creation: Create objects sparingly and discard them quickly to reduce GC pressure, but balance this with the cost of recreating expensive objects.
  • Use object reuse techniques: Employ thread-local variables, object pools, and indefinite references (soft, weak, phantom) judiciously to manage memory efficiently.
  • Analyze and monitor heap: Use tools like jcmd, jmap, and heap analyzers to identify memory leaks and optimize object retention; trigger heap dumps on out-of-memory errors for diagnosis.

10. What threading and synchronization performance advice does Scott Oaks provide in "Java Performance: The Definitive Guide"?

  • Thread pool sizing: Set minimum and maximum thread pool sizes thoughtfully, often matching the number of worker threads to available CPUs.
  • Avoid thread oversubscription: Too many threads can degrade performance, especially for CPU-bound tasks or when external bottlenecks exist.
  • Minimize synchronization costs: Reduce the use of synchronized blocks to avoid contention; prefer lock-free utilities and thread-local variables for better scalability.

11. How does "Java Performance: The Definitive Guide" by Scott Oaks address Java EE performance, including HTTP session state, EJBs, and database access?

  • Manage HTTP session memory: Minimize session data and use server features to serialize or cache session state, reducing heap impact and GC pauses.
  • Tune EJB pools and caches: Pool EJBs to reduce initialization costs, set steady pool sizes carefully, and avoid passivation for stateful beans to maintain performance.
  • Optimize database access: Use prepared statements, statement pooling, batch operations, and properly sized connection pools; manage transactions and locking to improve scalability.

12. What are the performance implications of Java 8 features like lambdas and streams in "Java Performance: The Definitive Guide"?

  • Lambdas vs. anonymous classes: Lambdas offer similar runtime performance but reduce classloading overhead, as they are implemented as static methods.
  • Streams enable lazy evaluation: Streams process data lazily, allowing for early termination and potential performance gains over eager processing.
  • Parallel processing and filters: Streams facilitate parallel processing on multi-core systems, and while multiple filters add some overhead, they can outperform traditional iterators in many cases.

About the Author

Scott Oaks is a highly regarded author in the field of Java programming and performance optimization. With extensive experience in software development, Oaks has established himself as an authority on Java internals and performance tuning. His writing style is praised for its clarity and depth, making complex topics accessible to readers. Oaks' work is recognized for its practical approach, combining theoretical knowledge with real-world examples and benchmarks. His expertise in JVM internals, garbage collection, and performance profiling is evident throughout his books, which are widely recommended by both novice and experienced Java developers.

Download PDF

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

Download EPUB

To read this Java Performance 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.37 MB     Pages: 26
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...