ACCU Home page ACCU Conference Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Google+ ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation

Search in Book Reviews

The ACCU passes on review copies of computer books to its members for them to review. The result is a large, high quality collection of book reviews by programmers, for programmers. Currently there are 1918 reviews in the database and more every month.
Search is a simple string search in either book title or book author. The full text search is a search of the text of the review.
    View all alphabetically
Title:
The Well-Grounded Java Developer
Author:
Benjamin J. Evans and Martijn Verburg
ISBN:
978-1617290060
Publisher:
Manning (2012)
Pages:
496pp
Price:
£
Reviewer:
Neil Youngman
Subject:
Java
Appeared in:
25-1

Reviewed: March 2013

The Well-Grounded Java Developer is not simply a book about Java. It’s aim is to improve your Java development by not only introducing you to the latest features of Java, but also a range of development techniques and other languages that use the Java VirtualMachine.

Part 1 of The Well-Grounded Java Developer the libraries are considered to be part of the (Chapters 1 and 2) introduces the new features language or the platform. This chapter is written in Java 7. in a clear and easy to follow style.

Chapter One introduces the set of small changes that originated in project Coin. Although these are small changes, they include some features that will bring significant benefits in simplifying code, such as allowing Strings in switch statements and ‘try with resources’. Chapter One also defines the distinction between the Java language and Java platform and summarises the issues that have to be considered when the language or platform change. One notable omission is that it does not state whether the libraries are considered to be part of the language or the platform. This chapter is written in a clear and easy to follow style.

Chapter 2 covers the new file and Network I/O facilities introduced in Java 7. This chapter tries to cram a lot of material into a small chapter, which results in a lot of examples with sketchy explanations. This chapter is best read with a Java 7 reference available to fill in the gaps. While I would have appreciated more detail, this is an introduction, not a reference and there is enough information to give a clear picture of the new APIs.

Part 2 covers vital techniques that a ‘well­grounded’ developer needs to understand, from dependency injection to performance tuning, via concurrent programming and class loading.

Chapter 3 covers dependency injection. While the basic concept is clearly explained, I found the detail lacked sufficient context to understand how it all fits together. Sub-sections on qualifiers used by the injector and those used by the target do not state where each qualifier is used and some listings contained parts from both sides. While it is possible to work this out, it makes for a harder read than necessary and made me feel uncertain. Ultimately I had to go and read the web introduction to Guice before I really felt I understood the bulk of the material in this chapter.

Chapter 4 covers concurrency in Java. This starts with a brief primer on concurrent programming, then takes you through the older concurrency classes and introduces the newer structures that provide simplified support.

Chapter 5 covers topics related to the JVM, such as class loading, byte code and some new features of the Java language and the JVM. Although I have been using Java for some time, this is an area that has been a bit of a black box for me and this chapter was very useful in improving my understanding of the JVM.

Chapter 6 is about performance tuning. This is always a difficult topic and this chapter provides a useful mix of pragmatic advice and technical detail. I have not had a need to tune my Java apps, but when I do, I am sure this chapter will provide a good starting point.

Part 3 is about polyglot programming. As well as Java there a large number of other languages implemented on the JVM. Chapter 7 talks about the limitations of Java and its relative suitability for various kinds of project. Chapters 8, 9 and 10 introduce three of the major alternatives: Groovy, Scala and Clojure. Groovy is the most similar to Java, Scala provides a more functional programming style than Java and Clojure is a lisp variant on the JVM. All these languages are also interoperable with Java. They can call Java code and be called from Java where needed.

Polyglot programming is mixing and matching the various languages available on the Java Virtual Machine to improve productivity by applying their different strengths appropriately.

Part 4 is mainly about applying development best practice to polyglot programming projects. This covers test driven development (ch 11), build and integration (ch 12) and web frameworks (ch13). As you would expect, it covers tools in more than one language and discusses their integration with Java.

Finally, chapter 14 looks to the future with an exploration of the changes expected in Java 8, many of which will assist in supporting languages other than Java, both by adding support for new features in the JVM and by technical improvements in memory allocation and concurrency support.

Overall this book covers a wide sweep of technologies and techniques in the Java ecosystem. Given the breadth of its scope it can not be an in-depth guide to any of them, but it is very informative and well written. This book will open many people’s eyes to a range of new and valuable ideas. I recommend it to any Java developers who wish to widen their horizons.