This is a review of The Well-Grounded Java Developer, Vital techniques of Java 7 and polyglot programming. Written by Benjamin J. Evans and Martijn Verburg. The book was published in July, 2012 and it contains 496 pages

Right from the start I want to say that this is an excellent book and I highly recommend it. One thing you do need to be aware about is that in order to use this book you need to know Java. If you don’t know Java then this is not the book for you. This book is all about bringing you to the next level as a Java developer by showing you how to do continuous integration, dependency injection, testing, performance tuning, and more.

This book even shows you how to use different languages that run on the JVM. The book is written in a easy and concise style, everything is very clear. I also love the annotations which are sprinkled throughout the book, they give some nice background information. While the chapters on Groovy, Scala and Clojure are not a complete reference for the language, they do provide enough material to form a nice foundation, now you can further explore the language on your own.

The book is split up in four parts, I will list each part with the chapters within that part and will give a brief summary what the part is about

Part 1 Developing with Java 7

Chapter 1 Introducing Java 7

Chapter 2 New I/O

This section shows you what was added in Java 7, for example you can now use strings in switch statements, try-with-resources(similar to a using statement in c#, it frees up the resources after it is done). The Java IO stuff has been rewritten and much easier to use, where you had to write a whole bunch of code before, you can now do the same in much less code. Some things that did not exist in Java in terms of IO but now does exist are explained as well.

Part 2 Vital techniques

Chapter 3 Dependency Injection

Chapter 4 Modern concurrency

Chapter 5 Class files and bytecode

Chapter 6 Understanding performance tuning

This part has a lot of stuff and as a Java developer you should really know how this stuff works if you want to get to the next level. Dependency Injection(DI) and inversion of control (IoC) are covered, Guice 3, the reference implementation for DI in Java is also covered. Concurrency before Java 5 and concurrency now is covered. Concurrency will be a must now that we have multi-CPU and multi-core everywhere, you better get your wits around it. There is a whole chapter on the class files itself and how they are loaded as well as what they compile into. These are fun details and will show you exactly what happens when you compile and execute a class. Evereybody’s favorite subject performance tuning is covered in this part of the book as well.

Part 3 Polyglot programming on the JVM

Chapter 7 Alternative JVM languages

Chapter 8 Groovy: Java’s dynamic friend

Chapter 9 Scala: powerful and concise

Chapter 10 Clojure: safer programming

This is a very interesting part of the book and I would suggest not to skip it. There are 3 type of languages covered in this part:

Groovy, a dynamic language

Scala, a functional language

Clojure, a Lisp for functional programming

Take a look at these languages and you will be amazed how much Java boilerplate code you can eliminate by using these languages instead. Some of the functional is a little bit of a paradigm shift and you might need some time adjusting. You will also see how you can interoperate between these languages and Java.

Part 4 Crafting the polyglot project

Chapter 11 Test-driven development

Chapter 12 Build and continuous integration

Chapter 13 Rapid web development

Chapter 14 Staying well-grounded

The last part is all about automation and making your life easier. If you are a developer who still deploys stuff by using FTP to move JAR, EAR and WAR files, pay attention. Maven is covered as the build automation tool, Jenkins is the continuous integration tool. In the Rapid web development chapter Grails is explored.

  • * *Let me just repeat again that I think this is an awesome book and as a Java developer you have to check it out. The one thing that is missing from the book is ORM, it is covered a little in the testing chapter but if you want to know about ORM, you will need to pick out some other book just for that.

You can download the following chapters to get a feel for the book

Sample chapter 1

Sample chapter 4

Head on over to Amazon for other reviews of The Well-Grounded Java Developer, Vital techniques of Java 7 and polyglot programming

The site for the book can be found here: http://www.manning.com/evans/

  • * *Below is the complete table of contents so that you have a little more details about each chapter.

**Part 1 Developing with Java 7

Chapter 1 Introducing Java 7

** The language and the platform

Small is beautiful—Project Coin

The changes in Project Coin

Summary

Chapter 2 New I/O

Java I/O—a history

Path—a foundation of file-based I/O

Dealing with directories and directory trees

Filesystem I/O with NIO.2

Asynchronous I/O operations

Tidying up Socket-Channel functionality

Summary

**Part 2 Vital techniques

Chapter 3 Dependency Injection**

Inject some knowledge—understanding IoC and DI

Standardized DI in Java

Guice 3—the reference implementation for DI in Java

Summary

Chapter 4 Modern concurrency

Concurrency theory—a primer

Block-structured concurrency (pre-Java 5)

Building blocks for modern concurrent applications

Controlling execution

The fork/join framework

The Java Memory Model (JMM)

Summary

Chapter 5 Class files and bytecode

Classloading and class objects

Using method handles

Examining class files

Bytecode

Invokedynamic

Summary

Chapter 6 Understanding performance tuning

Performance terminology—some basic definitions

A pragmatic approach to performance analysis

What went wrong? Why we have to care

A question of time—from the hardware up

Garbage collection

JIT compilation with HotSpot

Summary

**Part 3 Polyglot programming on the JVM

Chapter 7 Alternative JVM languages

** Java too clumsy? Them’s fighting words!

Language zoology

Polyglot programming on the JVM

How to choose a non-Java language for your project

How the JVM supports alternative languages

Summary

Chapter 8 Groovy: Java’s dynamic friend

Getting started with Groovy

Groovy 101—syntax and semantics

Differences from Java—traps for new players

Groovy features not (yet) in Java

Interoperating between Groovy and Java

Summary

Chapter 9 Scala: powerful and concise

A quick tour of Scala

Is Scala right for my project?

Making code beautiful again with Scala

Scala’s object model—similar but different

Data structures and collections

Introduction to actors

Summary

Chapter 10 Clojure: safer programming

Introducing Clojure

Looking for Clojure—syntax and semantics

Working with functions and loops in Clojure

Introducing Clojure sequences

Interoperating between Clojure and Java

Concurrent Clojure

Summary

**Part 4 Crafting the polyglot project

Chapter 11 Test-driven development

** TDD in a nutshell

Test doubles

Introducing ScalaTest

Summary

Chapter 12 Build and continuous integration

Getting started with Maven 3

Maven 3—a quick-start project

Maven 3—the Java7developer build

Jenkins—serving your CI needs

Code metrics with Maven and Jenkins

Leiningen

Summary

Chapter 13 Rapid web development

The problem with Java-based web frameworks

Criteria in selecting a web framework

Getting started with Grails

Grails quick-start project

Further Grails exploration

Getting started with Compojure

A sample Compojure project—“Am I an Otter or Not?”

Summary

Chapter 14 Staying well-grounded

What to expect in Java 8

Polyglot programming

Future concurrency trends

New directions in the JVM