I either have time for reading or writing, but not both. Now that the first edition of High-Performance Java Persistence is done, I can catch up on the many books I planned on reading but didn’t have time to do so.
In this post, I’m going to review High Performance MySQL by Baron Schwartz, Peter Zaitsev, and Vadim Tkachenkoa, which is a must-read book for anyone working with MySQL.
Continue reading “Book Review – High Performance MySQL (3rd edition)”
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
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 buy 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.
One year after I published the first part of the High-Performance Java Persistence, I managed to publish the print version of the book.
The book is printed on demand using Amazon CreateSpace, and it looks like as follows.
Continue reading “The print version of High-Performance Java Persistence”
Another milestone has been reached
The second part of High-Performance Java Persistence book is out. It’s been almost a year since I started writing this book, and seven months since I published the first part.
Continue reading “High-Performance Java Persistence – Part Two”
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.1 Caching flavors
16.2 Cache synchronization strategies
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
220.127.116.11 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
18.104.22.168 Entity reference cache store
16.5.4 Collection cache entry
16.5.5 Query cache entry
16.5.6 Cache concurrency strategies
22.214.171.124.1 Inserting READ_ONLY cache entries
126.96.36.199.2 Updating READ_ONLY cache entries
188.8.131.52.3 Deleting READ_ONLY cache entries
184.108.40.206.1 Inserting NONSTRICT_READ_WRITE cache entries
220.127.116.11.2 Updating NONSTRICT_READ_WRITE cache entries
18.104.22.168.3 Risk of inconsistencies
22.214.171.124.4 Deleting NONSTRICT_READ_WRITE cache entries
126.96.36.199.1 Inserting READ_WRITE cache entries
188.8.131.52.2 Updating READ_WRITE cache entries
184.108.40.206.3 Deleting READ_WRITE cache entries
220.127.116.11.4 Soft locking concurrency control
18.104.22.168.1 XA_Strict mode
22.214.171.124.2 XA mode
126.96.36.199.3 Inserting TRANSACTIONAL cache entries
188.8.131.52.4 Updating TRANSACTIONAL cache entries
184.108.40.206.5 Deleting TRANSACTIONAL cache entries
16.5.7 Query cache strategy
220.127.116.11 Table space query invalidation
18.104.22.168 Native SQL statement query invalidation
Continue reading “High-Performance Java Persistence – Chapter 16 – Caching”