Customer Reviews


3 Reviews
5 star:
 (2)
4 star:
 (1)
3 star:    (0)
2 star:    (0)
1 star:    (0)
 
 
 
 
 
Average Customer Review
Share your thoughts with other customers
Create your own review
 
 
Most Helpful First | Newest First

5.0 out of 5 stars Essential reading for anyone who considers themselves a software craftsperson..., 28 April 2013
Verified Purchase(What is this?)
This review is from: Java Application Architecture: Modularity Patterns with Examples Using OSGi: A Roadmap for Enterprise Development (Agile Software Development) (Paperback)
In a nutshell: This book is a thought-provoking peek into a topic that I believe will be highly influential in the next stage of evolution within software craftsmanship. The concepts presented within this book sit nicely in between the low-level 'clean code' philosophy (SOLID principles, Design Patterns, TDD etc) and the high level system/platform architecture principles (loose coupling, message orientation, event-driven systems, EIP etc). If you are serious about becoming a well-rounded developer or architect then this book is a must read.

I'm a freelance software architect/developer who primarily works on the JVM stack. I'm a strong supporter of Uncle Bob's 'Clean Code' principles, and I spend a lot of time on InfoQ and various other sites learning about historical and current big-picture systems architectural approaches, but until reading this book I hadn't thought too much about what happens in the middle of all of this. As a seasoned developer I now have several formuli for designing the big-picture architecture, and am happy creating (what I think is) well crafted code. But in the Java world packaging components together for deployment can feel clumsy at times (fat JARs or stuffed WARs anyone?). This book aims to address this discomfort.

The key premise of the book is 'Architecture all the way down', and although this may not make sense to you now, I have a strong suspicion that after reading the book and watching the online videos of the author (at Parleys) you'll be nodding along enthusiastically (or at least thinking that more attention should be focused in this space). Several of the principles within this book are discussed within the context of OSGi, and although I've been aware of OSGi for quite a while now, it always seemed peripheral to what I was working on, and chatting with colleagues used to produce the 'isn't that the huge frameworks used to develop app servers?' type conversations. Although the book doesn't deep-dive into OSGi per se, it did help to clear up a lot of the mystery and intended design goals for me.

Just to address a few comments made by other reviewers:

* I also believe that this book will be suitable for a non Java developer/architect, although the reader may have to work a bit harder to relate the content to analogous frameworks and toolkit within their chosen language/platform.
* In regards to the review stating 'not a general software architecture book' I respectfully think the reviewer has missed the point of this book - 'Java Application Architecture' is clearly aimed at a well-defined and often over-looked niche within the software architecture domain, and should not be considered in isolation. It would be easy to say that a book on software design patterns is 'not a good software development book', but this is because the application of design patterns should be mixed with well-crafted code and other good design principles.

In summary, if you're a fan of reading books like Uncle Bob's inspiring Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin) and the ground-breaking The Pragmatic Programmer you are going to enjoy this a lot. It may not leave you with concrete implementation details, but it will make you think a lot about how you assemble your software components.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4.0 out of 5 stars Not just for Java, 27 July 2012
This review is from: Java Application Architecture: Modularity Patterns with Examples Using OSGi: A Roadmap for Enterprise Development (Agile Software Development) (Paperback)
This book is about physical architecture and design, showing how a modular architecture helps in tackling complexity and in dealing with, for example, the tension between promoting reuse and ease of use.

In his forward to this book, Robert Martin suggests that John Lakos' "groundbreaking" book on modular design went unread because it had "C++" in the title, at a time when many were moving away from that language. Kirk Knoernschild may have made a similar mistake in, through its title, pinning his book to the Java platform; not because Java as a platform is necessarily behind us but because those not using Java may not be inclined to read his book. The text makes frequent reference to the Java environment but the ideas presented here will be of value to architects and designers working on a wide range of platforms.

The book starts with a section that explains the principles of, and makes the case for, modularity. Then comes a set of patterns for modular architecture, dealing with, for example, managing dependencies, reuse and extensibility. The material in this section represents a detailed treatment of some core architecture and design principles and their application and, as such, the pattern format seems rather gratuitous and something of a distraction. It does not, though, detract from the underlying thorough treatment of the application of core design considerations. There's a brief section specifically on OSGi which is an interesting introduction but there are undoubtedly more thorough treatments of the subject elsewhere.

Architects, designers and developers - even those working outside of the Java environment - should find this book interesting.

(In keeping with Amazon's disclosure policy: I originally reviewed this book for the British Computer Society and, in doing so, received a free copy of the book. This has not, in the case of other books, prevented me from writing reviews that have been critical.)
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Very very very useful book. I recommend it!, 6 Nov. 2012
Verified Purchase(What is this?)
This review is from: Java Application Architecture: Modularity Patterns with Examples Using OSGi: A Roadmap for Enterprise Development (Agile Software Development) (Paperback)
Kirk Knoernschild did a really nice work in this book.
It explains very well how to make your system modular. On top of that, this book provides a deep insight of OSGi, as a way of showing the benefits of modularity, and the even more benefits when combining modularity with OSGi.

As down sides, you can seldom find small grammatical errors and maybe 1-2 explanations of the diagrams are not so perfect.

Overall, if you aim for becoming a Java expert, you must definitely master the patterns teached by Kirk Knoernschild, so you should read the book.

It WORTHS!
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


Most Helpful First | Newest First

This product

Only search this product's reviews