There are some bites of personal wisdom in this book. If you personally know the Author in some real world context, you can decide for yourself if you value His wisdom. Otherwise, based on His book alone, anyone else's wisdom might do just as well.
This expert on Lean has sprinkled His book with "deep and meaningful" quotes, placed prominently at the beginnings of important sections, that neither convey much meaning nor support his chain of reasoning. I call that Waste, not Lean. In fact, when asked about the actual meaning of His cherished quotes, the author explodes and shouts that His book is not even making any argument! Hence, questioning its contents value is "not conducive to learning". Well. Today's authoritarians like to hide behind new-age social responsibility waffle, and this Author is no exception.
Avoid this book. Sounds interesting when you read it casually, but deeper questioning will leave you vacuous. According to the Author Himself, He is not trying to make any particular argument for anything, so this book belongs to the realm of fiction or, rather, Waste. The various "thoughts" presented may be helpful... or maybe not.
But hey, everything definitely sounds good and leaves you with that warm, fuzzy feeling that lifts you above the concerns of mere reason, just like my last Zen retreat!
This first book covering the new DCI paradigm of programming is a must read for anyone interested in separating the more often changing behavioral parts of code related to use cases from the more slowly evolving structural parts of domain data.
A great practical description of how the use case evolves and translates directly into code, of how to reflect the end users mental model in code - making it much more readable for both programmers and domain experts. It goes into detail about how use case roles translates to Object Roles playing out their part of a use case algorithm and how they get injected into the domain objects to use their state. And we are presented with how the Context can set up the mapping of Roles to domain Objects in different flexible ways before firing off the trigger Interaction of the use case.
Apart from example code in C++ and Ruby through out the last chapters of the book, it also have a great appendix with coded DCI examples in Scala, Python, C#, Ruby and Squeak.
For anyone interested I can also recommend visiting the Google "object-composition" group where all the concepts are discussed and explored.