Better, Faster, Lighter Java

by Bruce A. Tate, Justin Gehtland

Sometimes the simplest answer is the best. Many Enterprise Java developers, accustomed to dealing with Java's spiraling complexity, have fallen into the habit of choosing overly complicated solutions to problems when simpler options are available. Building server applications with "heavyweight" Java-based architectures, such as WebLogic, JBoss, and WebSphere, can be costly and cumbersome. When you've reached the point where you spend more time writing code to support your chosen framework than to solve your actual problems, it's time to think in terms of simplicity. In Better, Faster, Lighter Java , authors Bruce Tate and Justin Gehtland argue that the old heavyweight architectures are unwieldy, complicated, and contribute to slow and buggy application code. As an alternative means for building better applications, the authors present two "lightweight" open source Hibernate--a persistence framework that does its job with a minimal API and gets out of the way, and Spring--a container that's not invasive, heavy or complicated. Hibernate and Spring are designed to be fairly simple to learn and use, and place reasonable demands on system resources. Better, Faster, Lighter Java shows you how they can help you create enterprise applications that are easier to maintain, write, and debug, and are ultimately much faster. Written for intermediate to advanced Java developers, Better, Faster, Lighter Java , offers fresh ideas--often unorthodox--to help you rethink the way you work, and techniques and principles you'll use to build simpler applications. You'll learn to spend more time on what's important. When you're finished with this book, you'll find that your Java is better, faster, and lighter than ever before.

Genres: Programming, Computer Science, Technical, Software, Computers, Technology

262 pages, Paperback

First published January 1, 2004

Reviews

[Linda · Rating 3 out of 5]

I agree with a lot of what Bruce Tate says about software development and the state of Java development, in particular. He seems to be on a crusade against J2EE in general and EJB in particular. He prefers lighter, less invasive solutions.

If you want to read a book about ideas more than details this is your book. If you're looking for the holy grail, magic formula to get better Java then stop now. This won't help. This is a book about concepts. It's a thin book about deep concepts related to software development so it can't ever go in depth. That's by the author's design.

Because of that it is a fairly easy read. You don't need to expend tremendous amounts of concentration following code examples or getting caught up in details. However, at times, it feels like he's waving his hands and saying, "Pay no attention to the man behind the curtain." The reason I say that is many of the ideas he endorses are much easier to say than to do. The devil is in the details and the book is short on those. Because of that it won't really help the beginning programmer and a seasoned programmer has already figured out most of what he's got to say. It seems geared toward to relatively new to moderately experienced programmer. Others may still get something out of it but it won't be as useful.

So, I'd put this in the category of probably worthwhile for most Java developers but your exact mileage may vary.

[David · Rating 3 out of 5]

Started this book a long while ago but never finished until recently, but I mostly just skimmed the last 3 chapters, which were practical examples as well as a conclusion.

A lot of tools and technologies mentioned in the book have undergone many changes, but I think the concepts remained the same. The concepts espoused by the book still remains relevant - something a lot of Java programmers today still fail to grasp. Things like keeping things simple, don't over-engineer, use the right tools, etc.

The book is a bit misnamed though. Yes, it does sort of explain how you can code better, faster, and lighter in Java, but there isn't really that much depth here, something more for the less experienced crowd. So don't go expecting performance-tuning advice or complexity comparisons. It's more accurately described as how to go about designing and developing a piece of software while avoiding some common pitfalls.