The Well-Grounded Java Developer: Vital techniques of Java 7 and polyglot programming [Paperback]

Benjamin J Evans (Author), Martijn Verburg (Author)

Book Description

Publication Date: July 18, 2012

Summary

The Well-Grounded Java Developer offers a fresh and practical look at new Java 7 features, new JVM languages, and the array of supporting technologies you need for the next generation of Java-based software.

About the Book

The Well-Grounded Java Developer starts with thorough coverage of Java 7 features like try-with-resources and NIO.2. You'll then explore a cross-section of emerging JVM-based languages, including Groovy, Scala, and Clojure. You will find clear examples that are practical and that help you dig into dozens of valuable development techniques showcasing modern approaches to the dev process, concurrency, performance, and much more.

Written for readers familiar with Java. No experience with Java 7 or new JVM languages required.

Purchase of the print book comes with an offer of a free PDF, ePub, and Kindle eBook from Manning. Also available is all code from the book.

What's Inside

• New Java 7 features
• Tutorials on Groovy, Scala, and Clojure
• Discovering multicore processing and concurrency
• Functional programming with new JVM languages
• Modern approaches to testing, build, and CI

Table of Contents

PART 1 DEVELOPING WITH JAVA 7

1. Introducing Java 7
2. New I/O

PART 2 VITAL TECHNIQUES

3. Dependency Injection
4. Modern concurrency
5. Class files and bytecode
6. Understanding performance tuning

PART 3 POLYGLOT PROGRAMMING ON THE JVM

7. Alternative JVM languages
8. Groovy: Java's dynamic friend
9. Scala: powerful and concise
10. Clojure: safer programming

PART 4 CRAFTING THE POLYGLOT PROJECT

11. Test-driven development
12. Build and continuous integration
13. Rapid web development
14. Staying well-grounded

Editorial Reviews

About the Author

Ben Evans is the CEO of a Java performance firm and a member of the Java Community Process Executive Committee.

Martijn Verburg is the CTO of a Java performance firm, co-leader of the London JUG, and a popular conference speaker.

Product Details

• Paperback: 496 pages
• Publisher: Manning Publications (July 18, 2012)
• Language: English
• ISBN-10: 1617290068
• ISBN-13: 978-1617290060
• Product Dimensions: 7.4 x 1 x 9.2 inches
• Shipping Weight: 1.9 pounds (View shipping rates and policies)
• Average Customer Review: 4.6 out of 5 stars  See all reviews (13 customer reviews)
• Amazon Best Sellers Rank: #30,579 in Books (See Top 100 in Books)
  • #40 in Books > Computers & Technology > Programming > Languages & Tools > Java

More About the Author

Discover books, learn about writers, read author blogs, and more.

Most Helpful Customer Reviews

20 of 22 people found the following review helpful

5.0 out of 5 stars Java 7, TDD, Concurrency, Polyglotism and Beyond July 24, 2012

By Summer Hasani

Format:Paperback

The authors of Well Grounded Java Developer promise the reader a book that will help modernize their knowledge base, brush up on vital techniques, and learn a new language or two. Promise delivered!

The book is split into four parts. First part covers Java 7 with its new features, such as NIO, Project Coin that comes with the diamond operator, string in switch statements and try-with-resources features. With lots of clear examples, written in both Java 6 and 7, the book showcases the new features and what problems they attempt to solve.

While part one covered new language features, part two focuses on universal practices and methodologies vital to any developer regardless of experience. Among the covered topics: TDD, CI, DI and the Java implementation of javax.inject, performance tuning, and modern concurrency.

Part three of the book is for those of us who believe in and/or want know about polyglotism. It provides an easy starting point to a number of languages without neither overwhelming novices, nor boring the experienced. The book has chapters on Scala, Groovy and Clojure. I bought this book a little over a week ago and now halfway through part three but did briefly skim thought the fourth part of the book. In this final part, the focus is on applying everything from previous three parts into creating a new project; it dedicates a whole chapter on TDD highlighting its paramount importance in modern software development. I will update the review with more details after finishing this part.

The best thing about this book is that it will inspire you to take part in the evolution of JVM ecosystem currently underway. After all, a well grounded java developer would :)

8 of 11 people found the following review helpful

5.0 out of 5 stars A good model for modern Java August 12, 2012

By Rick Goff

Format:Paperback

The Well Grounded Java Developer is a welcome addition to the library of this work-a-day Java developer. I think I acquired this title for its promise to introduce features new to Java 7, which it does, but I find much more value than just this. As new concepts and techniques are introduced, the code samples demonstrate not only the new idea, but also the implementation of the various enhancements Java 7 provides. In other words, the code samples in this book look like Java 7 code from top to bottom, rather than Java 6 code with a sore thumb. Throughout the second section, you see code that uses the Path abstraction, multi-catch, underscores in number literals, and the other features that were introduced in Part 1.

Section 2 contains a lot of information that is new to me. As a Java developer incubated in a corporate setting, I have been nurtured to produce code, more than to understand it.

Chapter 3 discusses IoC and DI usefully. I am, just as the authors anticipated, one who probably heard the term Spring before I heard the term Inversion of Control. This chapter makes DI make sense as a design solution with many possible implementations, including Guice 3, the RI for JSR-330.

Chapter 4 discusses concurrency. The authors stress the inevitability of the rising importance of concurrency programming as multicore CPU's become standard. They discuss the advantages of immutability in the context of concurrency, foreshadowing the rise of functional programming styles and languages for the JVM. See for example the Callable interface, which they describe as "the closest that Java 7 gets to having functions as first-class objects." They laud java.util.concurrent, and elucidate Atomic and Locks. They also introduce ConcurrentHashMap, and suggest we always favor it over HashMap. And they present fork/join with "a simple example" that I had to read a half-dozen times to grok. Probably just me.

Chapter 5 discusses Class files and bytecode. It steps through the class loading process. MethodHandles are introduced as an answer to certain shortcomings of the Callable interface. The constant pool was a brand new concept for me, as was javap, the tool to use for examining these constants. There is a section on Bytecode, which is "an intermediate representation of a program - halfway between human readable source code and machine code." This representation takes the form of a list of operation codes ("opcodes") that may take arguments. Each opcode is represented by a single byte, "hence the name bytecode." Opcodes are organized into logical groups by function, such as "Load and Store" and "Arethmetic." Java 7 introduces a new opcode - a first! The new opcode is invokedynamic, which allows deferral of method selection to runtime. This is a JVM thing for dynamic languages; Java-the-language doesn't emit invokedynamic. This is another reminder that the future of the JVM is polyglot, with increasing support for dynamic languages.

Chapter 6 discusses performance tuning. The topic of this sermon is, "You have to measure. You can't tune properly without measuring." It discusses some metrics, such as latency and utilization. It also mentions transforming bytecode as it is loaded in order to attach tuning instrumentation. This chapter doesn't provide a lot of code samples, and I don't know how I individually will apply much of it. It's an interesting read, though. The imperative to utilize caches closest to the CPU is demonstrated visually. There's a section on Garbage Collection, in which Areas of memory (Eden, Survivor, Tenured and PermGen) are defined, as well as the jmap and VisualVM tools for viewing memory contents. Escape analysis is a neat idea, where a method is assessed as a candidate to create its dependencies on the stack, rather than on the heap, if its local reference variables are used only inside the method. The G1 collector is a radical departure from previous collector models. It learns how much collection it can expect to accomplish in a given amount of time (the pause), and plans its workload according to your pause goals of duration and frequency. Finally, Just-in-Time compilation is discussed, with an introduction to compilation strategies. Inlining methods is described as "eliminating the call to the inlined method, and instead placing the code of the called method inside the caller." The compiler uses runtime statistics to determine where to apply this strategy.

I have perused Part 3, and I look forward to reading it and Part 4 thoroughly.

This book is an excellent resource for Java developers who are capable of enthusiasm about programming. The book is of no value to the reader who is new to Java. I would highly recommend the book to a curious colleague who is fundamentally sound and insists on enjoying the next few years creating code for the JVM.

5.0 out of 5 stars Good reading for developer April 20, 2013

By artsiom yemelyanenka

Format:Paperback|Amazon Verified Purchase

All books I read about java now are boring. They're simple for me. On the other hand, there are a lot of thing happening with the platform. You may harvest information in blogs and JSR or just may buy this book and get you brains updated )