Book Review – Designing Data-Intensive Applications

Introduction

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.

Audience

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.

Content

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.

Conclusion

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
16.4.5.1 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
16.5.3.1 Entity reference cache store
16.5.4 Collection cache entry
16.5.5 Query cache entry
16.5.6 Cache concurrency strategies
16.5.6.1 READ_ONLY
16.5.6.1.1 Inserting READ_ONLY cache entries
16.5.6.1.2 Updating READ_ONLY cache entries
16.5.6.1.3 Deleting READ_ONLY cache entries
16.5.6.2 NONSTRICT_READ_WRITE
16.5.6.2.1 Inserting NONSTRICT_READ_WRITE cache entries
16.5.6.2.2 Updating NONSTRICT_READ_WRITE cache entries
16.5.6.2.3 Risk of inconsistencies
16.5.6.2.4 Deleting NONSTRICT_READ_WRITE cache entries
16.5.6.3 READ_WRITE
16.5.6.3.1 Inserting READ_WRITE cache entries
16.5.6.3.2 Updating READ_WRITE cache entries
16.5.6.3.3 Deleting READ_WRITE cache entries
16.5.6.3.4 Soft locking concurrency control
16.5.6.4 TRANSACTIONAL
16.5.6.4.1 XA_Strict mode
16.5.6.4.2 XA mode
16.5.6.4.3 Inserting TRANSACTIONAL cache entries
16.5.6.4.4 Updating TRANSACTIONAL cache entries
16.5.6.4.5 Deleting TRANSACTIONAL cache entries
16.5.7 Query cache strategy
16.5.7.1 Table space query invalidation
16.5.7.2 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          
15.3.1.1 Fetching a Proxy reference      
15.3.1.2 Natural identifier fetching        
15.3.2 Query fetching           
15.3.3 Fetching associations          
15.3.3.1 FetchType.EAGER           
15.3.3.2 FetchType.LAZY         
15.3.3.2.1 The N+1 query problem         
15.3.3.2.2 How to catch N+1 query problems during testing  
15.3.3.2.3 LazyInitializationException      
15.3.3.2.4 The Open Session in View Anti-Pattern     
15.3.3.2.5 Temporary Session Lazy Loading Anti-Pattern  
15.3.3.3 Associations and pagination        
15.4 Query plan cache           

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