If you have ever had the chance to witness the live performance of the authors, you know what a dynamic duo they are, taking a no-nonsense, pragmatic and very down to earth attitude towards the perils and treasures of modern day Java development. It is easy to see that almost every page of ‘The Well-Grounded Java Developer: Vital techniques of Java 7 and polyglot programming‘ is full of that energy.
The world of Java development is wide and this book is very well-balanced in its selection of topics. In other words, almost any serious Java development team would welcome a new developer well versed in the topics of this book, or to put it differently, unless you don’t know much about most of those topics, do not consider yourself fit for a sharp and focused Java development team.
Having said that, the breadth and the depth of the Java and JVM world makes this book look like a relatively large tip of an iceberg. Most of the chapters provide a solid starting point, but for example, when it comes to performance analysis and evaluation, you will be better off with an in-depth study such as ‘Java Performance‘. Or when it comes to explaining IoC (Inversion of Control) and DI (Dependency Injection), you might feel like the exposition is made a little overcomplicated: you might be better off reading a proper tutorial on Guice or the relevant chapter from ‘GWT in Action‘. I could make a similar set of comments regarding the concurrency chapter, but the added value of the book on that topic lies not in the summary introduction of Java concurrency, or modern features such as Fork/Join but rather the introduction of state-of-the-art paradigms such as actor based message passing systems, e.g. Akka. The same goes for book’s exposition of modern languages that run on JVM, such as Groovy, Scala, and Clojure. It is certainly very difficult to do justice to these wildly different languages in a few short chapters, but the authors succeed in capturing and presenting very clearly the essential characteristics of those languages (albeit they do not focus one of the tenets of functional programming: easy composability thanks to pure functions). They provide the reader with the pragmatic reasons to try out these languages, and they don’t refrain to evaluate each of those languages from many angles, such as the tooling support.
Apart from that, the chapter discussing the internals of class files and bytecode, even though not being very technically in-depth, nevertheless provides nice, self-contained overview of the topic just enough to be ocassionally useful for the daily needs of a not-too-specialized developer (and if you are a very specialized one, then you already know where to look for more technical details).
The chapter on TDD (Test Driven Development) is neither too detailed, nor too superficial, it gives solid grounding and rationale, that is if you are still skeptic about the advantages of unit testing, doing it properly, easily, most important of all, doing it right from the start. The examples using open source Mockito testing framework are not bad, but they would be brilliant if the authors did not refrain to demonstrate how Dependency Injection (e.g. Guice in particular) could be useful for unit tests, using a self-contained example (and I wonder if all of these could be even better presented using something like Jukito framework).
The rest of the book, particularly chapters related to Continuous Integration and building using Jenkins and Maven present just enough material to digest and coupled with code metrics, they hint at what a modern and healty development team should aim for. On the other hand, web development part will probably polarize the audience due to the selection of particular languages and frameworks, but I don’t think any author can escape from this, given the volatility of the subject matter.
I can easily recommend this solid book to junior and senior developers to learn more or to strengthen their understanding of modern Java & JVM development practices. Not only will you be very well-grounded, enforcing a pragmatic approach with healthy look at the current and future developments, but also smile, or even chuckle at the use of witty & geeky humour, highlighting some important historical aspects of the Java world.