Book Review – Designing Data-Intensive Applications


Exactly one year ago, I bought Designing Data-Intensive Applications by Martin Kleppmann. However, since I was busy writing High-Performance Java Persistence, it took me over a year to find the time to read Martin Kleppmann’s book.

This post is a review of what this book is all about and why you should be interested in reading it.


If you are a backend developer, a team leader or a software architect, this book must be on your reading list. While a junior developer might find the book interesting too, you got to have some background knowledge so that everything falls into place.


The book is a very detailed summary of how database systems work. From relational databases to data warehouses, key-value stores, column-oriented databases, Martin Kleppman describes a great deal of aspects like:

  • storage engines and indexing
  • data encoding
  • data partitioning
  • replication techniques
  • transactions and concurrency control
  • distributed systems and consensus algorithms
  • batch processing
  • streaming

Why you should buy it?

Although some concepts are not very easy to understand, Martin Kleppman does a very good job explaining all these concepts using down-to-earth examples.

The book is a summary of hundreds of research papers, books, and other scientific articles that would require you a great deal of effort to go through all of them, albeit to understand them. Hopefully, you don’t have to since the book is exactly what you need to get a better understanding of how data management systems.


I strongly recommend you buying this book. Although I read it, I’m sure that I’ll come back to it in future to validate that I haven’t forgotten anything I learned from this book.

If you liked this article, you might want to subscribe to my newsletter too.

High-Performance Java Persistence – Chapter 16 – Caching

Part 2, Chapter 16

Every new chapter of my book is released right after it’s being completed, so the reader doesn’t have to wait for the whole part to be finished to get access to new material.

Table of content

This chapter explains how enterprise caching works, from database internal buffers, to application-level caching, and the second-level cache offered by Hibernate.

16. Caching
16.1 Caching flavors
16.2 Cache synchronization strategies
16.2.1 Cache-aside
16.2.2 Read-through
16.2.3 Write-invalidate
16.2.4 Write-through
16.2.5 Write-behind
16.3 Database caching
16.4 Application-level caching
16.4.1 Entity aggregates
16.4.2 Distributed key/value stores
16.4.3 Cache synchronization patterns
16.4.4 Synchronous updates
16.4.5 Asynchronous updates Change data capture
16.5 Second-level caching
16.5.1 Enabling the second-level cache
16.5.2 Entity cache loading flow
16.5.3 Entity cache entry Entity reference cache store
16.5.4 Collection cache entry
16.5.5 Query cache entry
16.5.6 Cache concurrency strategies READ_ONLY Inserting READ_ONLY cache entries Updating READ_ONLY cache entries Deleting READ_ONLY cache entries NONSTRICT_READ_WRITE Inserting NONSTRICT_READ_WRITE cache entries Updating NONSTRICT_READ_WRITE cache entries Risk of inconsistencies Deleting NONSTRICT_READ_WRITE cache entries READ_WRITE Inserting READ_WRITE cache entries Updating READ_WRITE cache entries Deleting READ_WRITE cache entries Soft locking concurrency control TRANSACTIONAL XA_Strict mode XA mode Inserting TRANSACTIONAL cache entries Updating TRANSACTIONAL cache entries Deleting TRANSACTIONAL cache entries
16.5.7 Query cache strategy Table space query invalidation Native SQL statement query invalidation

Continue reading “High-Performance Java Persistence – Chapter 16 – Caching”

High-Performance Java Persistence – Chapter 15 – Fetching

Part 2, Chapter 15

Every new chapter of my book is released right after it’s being completed, so the reader doesn’t have to wait for the whole part to be finished to get access to new material.

Table of content

This chapter explains how fetching works in Hibernate.

15. Fetching              
15.1 DTO projection          
15.1.1 DTO projection pagination         
15.1.2 Native query DTO projection       
15.2 Query fetch size           
15.3 Fetching entities          
15.3.1 Direct fetching  Fetching a Proxy reference Natural identifier fetching        
15.3.2 Query fetching           
15.3.3 Fetching associations  FetchType.EAGER   FetchType.LAZY The N+1 query problem How to catch N+1 query problems during testing LazyInitializationException The Open Session in View Anti-Pattern Temporary Session Lazy Loading Anti-Pattern Associations and pagination        
15.4 Query plan cache           

Continue reading “High-Performance Java Persistence – Chapter 15 – Fetching”