Book Review: High-Performance In-Memory Computing With Apache Ignite
Book Review: High-Performance In-Memory Computing With Apache Ignite
In-memory computing is a pretty exciting space today, and Apache Ignite is becoming even more relevant. Check out this review of a book that covers this growing area.
Join the DZone community and get the full member experience.Join For Free
Hortonworks Sandbox for HDP and HDF is your chance to get started on learning, developing, testing and trying out new features. Each download comes preconfigured with interactive tutorials, sample data and developments from the Apache community.
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. This review is my personal thoughts and experiences while reading/learning from the book.
In-memory computing is a pretty exciting space today. A lot of innovations and disruptions are happening in this area. When it comes to higher service performance, this is one of the spaces we look at and explore while designing solutions.
You know, as we were researching various options for scaling our service performances, we stumbled upon Apache Ignite products along with various other products. However, one thing that really hooked me onto this product was its elevation/claim to be an in-memory data fabric. This is a notch above an 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 others, I loved the SQL support for this product. We were hooked and started on exploring it.
As we dug deeper, a few questions kept coming to mind: What on earth is this data fabric? 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 the Ignite documentation. I must comment that it’s extremely well-written documentation with everything you might want to know both now and in the future, as you implement/architect your solutions; and this is regardless of whether you are a 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 novels 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 theory and at times, they're too much code blocks. Many 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, building your knowledge in proper sequence. Instead of blogs and haphazard learning, a book on technology especially takes you across the breadth of the product, right from building the concept around it to 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 on Leanpub). And to be honest, I loved it right from the beginning. The authors wrote this book with developers in mind and built it up for the solution and enterprise architects. While doing so, the book 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. I'm happy to to say 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 concept 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 learned was how to connect to your cache from a SQL client (like DBeaver, for example) of your choice and run SQL queries on your cache as if you were interacting with a regular database. I loved it to the core! The book also covers the Ignite Visor tool. It explains how to use it and what different results mean 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 on GitHub, as well. Cool, isn’t it?! You get your hands dirty as you read. At times, too much read makes you feel sleepy. Doing some activities while reading is the best way of learning. This book follows the same principle.
I loved the Architecture Overview chapter. In very simple words, various features and solutions were touched upon and explained. It explained CAP theorem and Ignite’s fitment. The chapter also explained various caching strategies/topologies, clustering, multi-datacenter replication concepts, how SQL works on Ignite, etc. One realizes whether to go for a partition strategy or replication strategy their unique implementation use case.
Now, before I explain further, take a careful look at the below picture. Look complex? Yes, Apache Ignite has a highly complex underlying architecture.
And yes, this is the data fabric I was referring to. When I did some reading on the internet, some of my questions about various grids were cleared up. But there were still some open questions about how to implement things. This book covered these grid concepts explicitly with examples and helped me clear those doubts. That’s a pretty awesome read.
The explanation of persistence and caching is a really fine learning experience. In the chapter Streaming and Complex Event Processing, the book touched upon data streaming concepts with examples of Camel streamers, Flume streamers, and Storm streamers. I tell you, this is really helpful. The fun part is it’s just not theory — there are coding examples, as well, which makes it more fun and interesting to read. This book also touched upon distributed computing with Apache Ignite with detail, again, with examples clearing concepts.
Last but not 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, and there may be some printing mistake,s as well. Even though it’s a trivial issue, attention must be given to this.
Apache Ignite is growing and we see new stable builds coming in short intervals. This is a very good sign of a hit open-source product. I am hopeful that authors will include the new features in 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!
Published at DZone with permission of Sadruddin Mohammed . See the original article here.
Opinions expressed by DZone contributors are their own.