Book review: High Performance in-memory computing with Apache Ignite

Today, I would like write a few words about a book on Apache ignite. This book is called High Performance in-memory computing with Apache Ignite. This book is co-authored by Shamim Ahmed Bhuiyan, Michael Zheludkov, and Timur Isachenko. The review is my personal thoughts and experiences while reading/learning from the book.

In memory computing is pretty exciting space today. A lot innovations and disruptions are happening in this area. When it comes to higher service performance, this is one of the spaces we look at/explore while solution designing.

You know, as we were researching various options for scaling our service performances, we stumbled upon Apache Ignite product along with various other products. However, one thing that really hooked me onto this product was it’s elevation/claim to be in memory data fabric. This is a notch above in memory data grid in terms of features and services it provides. What an elevation indeed! I don’t know of any other product in its space. I loved the concept itself. Among many other, I loved the SQL support in this product. We were hooked and started on exploring it.

As we dug deeper, few questions kept coming in my mind; what on earth is this data fabric and what are these grids in this fabric? How are these cohesively existing together and supporting various business/technical use cases? I was intrigued. I went through ignite documentation. I must commend that it’s an extremely well written documentation on everything you would like to know NOW and In Future as you implement/architect your solutions; and this is regardless of whether you are developer or an architect. Well, that’s what my experience has been.

But, I wanted something more. You know, as a reader, I always loved books; be it a novel or books of technologies. But there are problems with books as well, at times it gets boring and works as a medicine to one’s insomniac nature. 🙂 . I observed this in some of my previous reading experiences. At times, books are too much of theory and at times, too much of code blocks. Many a times, a lot of high-octane gibberish (or at least seemed so to me) words difficult to comprehend.

However, on the other hand, a well written book on any product or technology becomes a fantastic read. You learn so much from it structurally and sequentially; build knowledge in proper sequence. Instead of searching blogs and learning haphazardly. A book on technology specially takes you across the breadth of the product right from building the concept around it to a really advanced concepts about the product. I was looking for something similar for this product as well. Because Apache ignite indeed is a very promising product and feature lists are really cool.

Anyways, while searching I came across the mentioned book (also available in leanpub) and to be honest, I loved it right from the beginning. The authors wrote this book keeping a developer in mind and built it up for the Solution and Enterprise Architects for solutions. While doing so, it does not bore the developer either. In my experience, this is a gigantic task as the aspects of a developer and an architect are different in many ways. Glad to mention that the authors have nicely achieved this monumental job.

The book starts with a simple how to of starting a single/multi node ignite cluster to a very complex concepts of complex event processing, streaming etc and how Apache Ignite addresses those; with a lot of explanatory figures, code blocks, screenshots etc. For  example, one splendid thing that I learnt was how to connect to your cache from a SQL client (like DBeaver etc) of your choice and run SQL query on your cache as if you are interacting with regular database. I loved it to the core! The book also covers ignite visor tool as well. It explained how to use it and what the result means with screenshots and explanations.

One salient feature of the book is how the authors explained every concept of Apache ignite through simplistic examples. All these working examples are available in github as well. Cool! isn’t it? You get your hands dirty as you read. At times, too much read makes you feel sleepy. Some activities along the reading is best way of learning. This books follows the same principle.

I loved the Architecture overview chapter. In very simple words, various features and solutioning aspects have been touched upon and explained. It explained CAP theorem and Ignite’s fitment. The chapter also explained various caching strategy/topology, clustering, multi-data center replication concepts, how sql works on ignite etc. One realizes whether to go for partition or replication strategy in your implementation use case.

Now, before I explain further, take a careful look in the below picture. Looks complex? Yes, Apache Ignite has a highly complex underlying architecture.

apache-ignite

And yes, this is the data fabric I was referring to. When I did some reading in internet and blogs, I got some of the questions cleared up about various grids. But, there were still some open questions and how to implement etc. This books covered these grid concepts explicitly with examples and helped me clear those doubts. That’s pretty awesome read.

The explanation of the persistence and caching are really fine learning experience. In the chapter of Streaming and complex event processing, the booked touched upon data streamer concepts with examples on camel streamer, flume streamer, storm streamer. I tell you, this is really helpful. The fun part is it’s just not theory, there are coding examples as well. That makes it more fun and interesting read. This book also touched upon distributed computing with Apache ignite with detail. Again with examples clearing concepts.

All in all, my experience has been fantastic with this book. I am still reading through it and it’s a good recommended one. Last but not the least, I noted the English is a little broken here and there in the book. At times, it feels like it’s overlooked while touching on the technology concepts or may be some printing mistakes as well. However, even though it’s a trivial issue, importance must be given on this. This makes the reading even more beautiful.

Apache Ignite is growing and we see new stable builds are coming in short intervals. This is a very good sign of a hit open source product. I am hopeful, authors will include the new features in their further editions as well.

Well, that’s all for today. I’ll be back with some more learning experiences in Apache Ignite and beyond.

Happy igniting folks! 🙂