Agile Java: Crafting Code with Test-Driven Development

This book is a fantastic primer to not only the java language, but to agile methods and junit as well. The author does a great job of introducing many concepts in a way that is easy to digest without being slow. However, seasoned java programmers may get frustrated with the early chapters that speak to basic java while introducing the bread and butter of junit. This is only for the first 150 pages or so. The information and lessons on refactoring, best practices, and junit are well worth it though. The best part of the book is the author's style. He does not speak down to the reader with overly high vocabulary, or with an "I am all knowing" attitude, but rather he uses a conversational tone with an emphasis on making the topic clear concise and to the point.

This is a wonderful book and should be your first choice if you are learning Java. Or if you already know Java and want to learn more about it and see lots of great example of "agile source code." What I like about this book is that it addresses a fundamental problem in otherwise very good books such as Deitel's "Java: How To Program" and Eckel's classic "Thinking In Java." This book combines solid instruction in Java programming with a truly agile view of how to develop the source code. Significant (yet still small) examples are built in a test-driven manner, which serves to reinforce and instill the idea that this is the right way to write code. In talking with friends I've been saying for a few years that test-driven development is great but that it will really start to have an impact when it is part of how programmers first learn to program rather than a new technique they learn as it is now. To achieve this, new programmers need a book from which they can learn how to write code and that writing a test first is the best way to do this. Langr has written that book. Highly recommended.

It's getting more and more difficult to do Java books that offer anything that's unique. But Jeff Langr has succeeded in finding a niche with Agile Java (Prentice Hall). It's a book I could definitely recommend... Chapter List: Introduction; An Agile Overview; Setting Up; Getting Started; Java Basics; Strings and Packages; Class Methods and Fields; Interfaces and Polymorphism; Inheritance; Legacy Elements; Exceptions and Logging; Maps and Equality; Mathematics; I/O; Reflection and Other Advanced Topics; Multithreading; Generics; Assertions and Annotations; Swing, Part 1; Swing, Part 2; Java Miscellany; An Agile Java Glossary; Java Operator Precedence Rules; Getting Started with IDEA; Agile Java References; Index The basics of the book are pretty good. You have fifteen "lessons" that cover the material in the book, as well as three bonus lessons on Swing and other miscellaneous subjects. I really like the way he takes a single example (a student information system) and uses that throughout the entire lesson material. It gives good continuity and you don't have to readjust your focus for each lesson. The exercises at the end of each lesson follow a different example all the way through (a chess program), so you have a couple of different ways to learn, but it remains consistent throughout. He also doesn't try and cover absolutely everything in the Java universe. He picks the important stuff you need to know and realizes that you'll have to get the rest of the stuff on your own. This means that the book is approachable and doesn't become another 1500 page doorstop. The uniqueness in the book comes in with the "Agile" part of the title. Agile methodologies, like extreme programming (XP), are lightweight in nature and don't require that every last detail be spec'd out before starting the coding. There's a large emphasis placed on testing with tools like JUnit in order to prove that changes in the code don't break anything. With the test framework in place, you can also focus on refactoring your code without fear of introducing unknown errors. Langr shows early on how JUnit tests need to be integrated into your code, and that follows through the entire book. As a result of that and of using a single example, there are plenty of opportunities to refactor your code and then to use the JUnit test to make sure everything still works. This slant on Java coding is something you rarely see integrated into the process of learning Java, and it's probably long overdue. Even without the focus on unit testing and refactoring, it'd be a decent tutorial book. With that focus, this book becomes a recommended tool to use to learn Java. Good job...

Pity those of us who try to teach people how to program. Thirty years ago, everyone was a beginner. Ten years ago, everyone wanted to program because it was the hottest way to make money (remember? Learn Java, move to Silicon Valley and make millions). Each year, the background and experience of the set of people who want to learn more about programming gets wider and more diverse. There are people who've tinkered with computers since they were kids, people who learned by the seat of their pants in industry; and people who've learned in school. Jeff Langr's book, Agile Java, is significantly different and significantly better than most programming/language tutorials that have been written. One major difference is its sheer ambition. When you read this book, you'll learn the elements of Java (not just basic syntax but deep guru advice on why and why not to do things in particular ways), you'll learn the Java 1.5 extensions, and you'll also learn Test Driven Development (it is woven into the style of the book and explained throughout). A book this ambitious could've easily failed on any of these fronts, but Langr pulls it off because of his in-depth knowledge in all three areas and clear, lucid writing style. I recommend this book for anyone who has a bit of programming experience who wants to get a leg up by learning Java and TDD simultaneously. The book is also a very informative read for much more experienced programmers. Agile Java contains a lot of good programming and testing advice, and experienced programmers will find that Langr's take on the fundamentals of programming may help them see things in more productive ways. It is a very good snapshot of the state of best programming practices today. Agile Java is a great way to learn and relearn Java programming. And, given the rate of change in the industry, we all need to relearn programming periodically to be as effective as we can be.

Don't just learn Java, learn how to write solid Java code. I teach Java in a continuing education program that is part of the University of Massachusetts. I will be using this book in my future classes. Here's why: It is pretty easy to learn the basics of Java. Sun provides a free tutorial that's good. (http://java.sun.com/docs/books/tutorial/), and there are a literally tons of Java books out there too. While one of the strengths of Java is that is pretty easy to get started with, it is much harder to do right. What makes this book stand out is that that it tries (and succeeds) at doing more than just teach Java. It teaches an important methodology too - how to test your code as you are writing it. This is an important aspect of writing good Java code, and one that I can't over emphasize when teaching it. It is just as important as learning the language itself. The particular methodology used in this book is called Test Driven Development, but I don't think that's so important to someone just starting out. What's important is to learn the value of unit testing from the start, and this book does that well. The book uses the JUnit framework and ANT from the start. Both of these tools belong in any Java programmer's tool kit. They go hand and in hand with the Java language. It is great that they are presented in a context targeted for novice programmers who want to learn Java. These are real world skills that are often over looked in more academic approaches to teaching Java. Yet, they not only make you more productive with Java, but they can make using it more fun too. See (Unit Test Infected: Programmers Love Writing Tests http://junit.sourceforge.net/doc/testinfected/testing.htm) Other things that make this book strong include the author's writing style. It is clear, concise and refreshingly informal. No stuffed shirts here and you won't end up needing an extra cup of coffee to get through it. The books organization is also well tailored to learning Java (as well as teaching it). Each chapter builds on the others but each is also a self contained lesion with useful exercises. I understand that there's a teacher's version of the book available as well. It is also useful that the book covers the recently released Java 5, so it will stay concurrent for a while. In short, I think this will end up being a wonderful teaching aide. Anyone who has to teach an introduction to Java course should strongly consider this book. However, the book really stands alone and does not need to be part a course setting to be accessible. In fact, using this book, I wonder what will be left to lecture about. (I am sure I'll think of something...) I'd recommend this book to anyone wanting to learn Java or to anyone who wants to learn how to write good Java code. I think this book, along with Joshua Bloch's Effective Java Programming Language Guide [...] should be required reading for any attempting to learn Java.