Other Sellers on Amazon
+ FREE Delivery
+ S$11.71 delivery
+ S$7.74 delivery
Building Event-Driven Microservices: Leveraging Organizational Data at Scale Paperback – 17 July 2020
|New from||Used from|
Enhance your purchase
Frequently bought together
About the Author
From the Preface
I wrote this book to be the book that I wish I’d had when I started out on my journey into the world of event-driven microservices. This book is a culmination of my own personal experiences, discussions with others, and the countless blogs, books, posts, talks, conferences, and documentation related to one part or another of the event-driven microservice world. I found that many of the works I read mentioned event-driven architectures either only in passing or with insufficient depth. Some covered only a specific aspect of the architecture and, while helpful, provided only a small piece of the puzzle. Other works proved to be reductive and dismissive, asserting that event-driven systems are really only useful for one system to send an asynchronous message directly to another as a replacement for synchronous request-response systems. As this book details, there is far more to event-driven architectures than this.
The tools that we use shape and influence our inventions significantly. Event-driven microservice architectures are made possible by a whole host of technologies that have only recently become readily accessible. Distributed, fault-tolerant, high-capacity, and high-speed event brokers underpin the architectures and design patterns in this book. These technological solutions are based on the convergence of big data with the need for near-real-time event processing. Microservices are facilitated by the ease of containerization and the requisitioning of compute resources, allowing for simplified hosting, scaling, and management of hundreds of thousands of microservices.
The technologies that support event-driven microservices have a significant impact on how we think about and solve problems, as well as on how our businesses and organizations are structured. Event-driven microservices change how a business works, how problems can be solved, and how teams, people, and business units communicate. These tools give you a truly new way of doing things that has not been possible until only recently.
No customer reviews
|5 star (0%)||0%|
|4 star (0%)||0%|
|3 star (0%)||0%|
|2 star (0%)||0%|
|1 star (0%)||0%|
Review this product
Most helpful customer reviews on Amazon.com
Unless you're familiar with DDD, you may miss the motivation behind some of the presented ideas and ideally you'd want to read both DDD by Eric Evans and Implementing DDD by Vernon Vaughn, although the latter would be more important since the idea of domain events is introduced there and Event-Driven Microservices builds on from there. In doing so, the author also takes a bit of a Kafka-centric approach, and some of the best-practice advice regarding the way you organise events and streams doesn't make a lot of sense if you're creating your event-driven services using a different technology, e.g. Akka.
Now, with that off my chest here's what made this one so worth reading for me. First, I recognized some of the issues with the traditional approach to microservices, which at my current company we managed to solve with event sourcing. Which, as things go in software, gave us a completely different set of issues, and this book deals with them. While I can't say the book had much practical value at this point, it did help me articulate better why some approaches work and why others don't. Second, I particularly liked the mix of high-level abstraction of the patterns and the low-level technical detail that can be found in every chapter - the author managed to perfectly time the jumps/switches between the abstract and the technical and also strikes a fine balance between the two, keeping most of the patterns abstract, but delving into the nitty-gritty details when they are important to the way you implement the pattern or, sometimes, if those technical details are the cause or the enabling factor behind the pattern. Finally, while I know I've mentioned this under the 'bad' column, it's a actually a good thing in my case - the book is a perfect sequel to blue and red DDD books and promotes those ideas even further.
However, his writing style is quite dry and wordy. Some simple concepts are unnecessarily described and taxonomized to great detail, only to make the reader untangle the words. On the other hand, the author tried to keep the discussion independent from technology choices at length, but also made the discussion less grounded in implementation.
Author have pretty good experience, but pretty broad understanding of what is from which area and where, actually, event-driven design's concepts begins and ends.
So, each term, concept, idea, fundamental statement or explanation will be tainted with author's broad experience, guesses or unrelated things from completely unrelated areas, which will be described as the part of event-driven design.
Rather than explain fundamentals and concepts strictly related to the subject itself, author describes everything he met in his experience, while worked on even-driven services. Author clearly have some difficulties to separate what is directly related to the topic, what is just frequently used together or what he personally just used in connection to the main topic.
Attempts to explain event-driven services connections to the business or provide a real-world examples makes situation even more hopeless. It is impossible to draw the line between all the areas touched.
It is like you want to learn something new about mushrooms and asked forester to bring you some. But forester just dag cubic yard of soil from a middle of a forest and brought it to you. With all the grass, trees, flowers and even extremely confused mole. Mushrooms, of course, are here.
BOTTOMLINE: If you are experienced in event-driven design and want to compare your path to somebody's path to maybe learn something or rethink what you did and learned - this is the great book.
If you want to learn something about event-driven design - choose something else.