Rating: 
Summary: A useful guide to successful development
Review: "Better, Faster, Lighter Java" does a great job of walking the reader down a path to successful J2EE projects. In the vein of "Bitter Java" and "Bitter EJB", it exposes some of the myths -- both procedural and technical -- in today's J2EE world. Additionally, it goes a step further than the "Bitter" series by providing holistic solutions to managing and implementing successful projects, rather than localized solutions to specific anti-patterns.The first few chapters provide excellent coverage of practical agile development, as is often seen in the real world. Bruce and Justin explain the motivations behind concepts like test-driven development, continuous integration, scope definition and creep, and the trade-offs of coupling. They then show examples of how to implement these concepts in an enterprise Java project. These concepts are absolutely critical to any non-trivial project, as they make or break the ongoing maintainability of a project. Anyone who has not used agile processes in the real world (i.e., anyone who thinks that tests belong in the QA department only) should read this book just for those chapters. The book then continues to discuss common framework components and how they interact, including the pros and cons of different persistence and container strategies. In an interesting twist, the authors analyze the framework components discussed against the criteria for successful projects established earlier. One of the points that the authors make is that a project should do one thing, and do it well. This book focuses on one thing -- a high-level analysis of how to execute on a successful development project. This is not a definitive reference guide on any of the technologies or processes discussed. Rather, it distills out the essence from the various types of components that you will encounter in your project, and puts them together in an easy-to-follow format. One gripe that I had was that the Hibernate and Spring chapters delved a little too deep into their respective topics. I would have preferred to see more coverage of other aspects of the development cycle (preparation of content for hand-over to the UI design team, the role of Swing / SWT front-ends in enterprise development, etc.) rather than more depth on particular framework components.
Rating:
Summary: Common sense advice for practical Java
Review: As the title implies this book is a scattershot of topics for improving your Java architecture and implementation patterns. Bruce is always practical and pragmatic in his approach and it's no different here. He covers test first development very well. There is also an excellent section on transparency. But much like a theme album this short book is supposed to be ingested whole. Definitely a must have for professional Java developers.
Rating:
Summary: Great for architects and technical decision makers
Review: Better, Faster, Lighter starts by explaining the basic problem in J2EE, complexity and API bloat, and then builds around five principles that should guide Java application development. Each of these principles are enclosed in an individual chapter, and in the second half of the book, these principles are explained using open source frameworks and example code. The most useful chapter for me was the chapter called "You Are What You Eat" as it explains alternatives to the standard J2EE architecture. It discusses all the major technologies that J2EE architects and developers care about - XML, Web Services, Session and Entity EJBs, Distribution etc, and gives scenarios under which it is suitable or unsuitable to choose each. This is the sort of information that is useful for persons who make architectural or design choices. The book also proposes two alternate deployments to the traditional 3-tiered architecture and gives reasons why these would lead to improved performance and lower complexity. This chapter explains how to make the technical decisions that will impact application development down the road. This book gives an introduction to two of the most popular open source frameworks today - Spring and Hibernate, and argues that they have become successful as they focus on simplifying Java development. The chapters on Hibernate and Spring are relatively short at 22 and 25 pages respectively, and so should not be relied upon for a detailed exposition into these frameworks. Persons wanting to get up to speed with these technologies should buy Rod Johnson's Expert One on One J2EE Development without EJB, or Matt Raible's Spring Live, as well as the Hibernate in Action when these books are released. But the chapters fit nicely into the overall argument in favor of simple tools that help simplify development. The Spring chapter explores the JPetstore sample application that uses IBatis as the persistence layer. Later on Bruce Tate discussed moving to Hibernate, and also supports the use of JDO. Better, Faster, Lighter Java is a little different from the traditional Java/J2EE books, and is written in a conversational, rather than a technical style. Thus it's more useful for persons seeking the big picture surrounding Java development, rather for pure techies. Relatively few books focus on the why of application development, and I recommend this book as one of these. If you enjoy reading authors such as Rod Johnson, Martin Fowler, and Scott Ambler, then this book won't disappoint.
Rating:
Summary: Its about time someone wrote something like this
Review: Bravo for a very timely book. One of the advantages of Enterprise JavaBeans and similar approaches to programming is it allows for faster development of code. However, there is a price to be paid for this programming convenience. The price is generally large bloated code. With each line of code the speed of the application slows down, the size of the program increases, and more opportunities for errors are introduced. Better, Faster, Lighter Java sounds the clarion call for better code writing, project management, and maintenance. The authors also include chapters on other open-source products, such as Hibernate and Spring, which can help keep the code clean and build projects using a container model like EJB without all the unnecessary overhead. Better, Faster, Lighter Java is a highly recommended book for Java programmers.
Rating:
Summary: Thought-provoking overview
Review: I am an experienced programmer, having used Java and many other languages on a variety of projects. In the last 2-3 years Java, and especially server-side Java has become increasingly important to me at work and I now spend a great deal of my time trying to understand the roles and relationships of the various J2EE technologies and their alternatives. For the most part I find these kinds of discussions worthwhile and very interesting.
'Better, Faster, Lighter Java' is very useful to me because: a) Its main contention that programmers need to be aware of and avoid Java "bloatware" agrees with my experience; b) Its authors provide some criteria to use to decide whether a Java technology is well designed; and c) It provides some alternative Java technologies to use as comparisons with ones that are too "heavy" and not as flexible or extensible. All this was done in a relatively brief book (itself rather "light").
Hence I appreciate this book for the synthesis of ideas it provides, the questions it raises and for its introducing me to alternative Java technologies that I'll now seek more in-depth treatments of.
Rating:
Summary: Makes you think
Review: I've had this book for a few months now and I've read and re-read several sections. I also went back and forth as to whether or not I agreed with some of the information so many times I gave up counting. So, I guess if nothing else this book made me think - which is always the hallmark of a good book, in my opinion. The book is organized well and the authors present their case for "Better, Faster, Lighter Java" in a careful and concise manner.
This is not really a "here's how to implement technology X" book (i.e. if you want to learn about Hibernate, pick another book). It does more to promote concepts and ideas to avoid "bad programming". It provides a lot of opinion and argument for and against various frameworks, design patterns, programming methodologies, etc. It is quite obvious the authors are convinced and passionate about their view of software development. If you've ever asked yourself, "why do we have to use such complicated stuff to do even the simplest of things?", then this book will give you plenty of ammunition to backup your argument.
It's a rare software development book that I actually read (let alone re-read) almost cover to cover. While you may not agree with everything in the book, it will make you re-evaluate your development techniques.
Rating:
Summary: Simple, and elegant
Review: If I were looking for a Spring or Hibernate book, this one would let me down. But that's not what Gehtland and Tate are trying to do. They are showing why Spring and Hibernate are important, and how they have passed up enterprise java beans. They have shown basic rules for lightweight development, and they have done it effectively. The book is simple, well-written, and in conflict with established J2EE development. I get into the emphasis on JUnit. I also like how Gehtland and Tate show me more than programming. They let me see how companies sell. They show me how a better process can work. I like extreme programming, but my manager doesn't. They give me some good ideas about how to use the best parts without doing all of XP. I also like the idea of showing the principles, and then seeing how those principles apply to open source software, and then showing me how to put them into use. I don't think that the book would have been useful if they would have simply tried to invent some application that fit their model. Instead, they picked a couple of open source projects that seem to do what they are advocating. Lighter Faster java is a home run. If you're looking for a Spring book, just go buy Expert J2EE One on One. If you want to understand why Spring, and other technologies like it, are important, get Lighter Faster Java. I can understand how to program Spring and Hibernate with tutorials on line. This book gives me something far more valuable. Insight. I think I'm also going to pick up one for my boss.
Rating: 
Summary: Better Title: A REVIEW to Better, Faster, Lighter Java
Review: It is a very nice book. It is something that you would like to give to people who are into EJB most of their lives telling them its time to change. It's time to go to the gym and lose gallons of fat.
But if you are someone who really wants to know how things are done and how things work, I would not recommend this book. If you are into Hibernate, Spring, or other simpler frameworks or just want to learn these stuff, you don't need this book. Simply because you don't need a book that will only tell you what you already know; and that is, in java simple things are definitely not mediocre.
In my humble opinion this book gives you an insight to the future of java development. This book prepares you on what is coming. But unfortunately it is not enough, far not enough, to gear you up for it.
But in fairness this is not really an "in-depth" kind of book so may I rate it the way it is.
Rating:
Summary: An important book
Review: One may love 'Better, Faster, Lighter Java' or may hate it -- but it's a book that is difficult to ignore. Because, the authors had the courage to state their viewpoint against the growing trend of spiraling complexity of J2EE development. Because their book steps back from being a conventional tome on cranks-shafts-gears of a big J2EE engine and asks the important question of how to maintain the core design principle of KISS (Keep It Simple, Stupid) in the face of ever-growing complexity of frameworks. They rightly identify that bloat -- the growth of complexity of any successful infrastructure -- is inevitable. Any intermediate to advanced Java developer who had been confronted by emergence of mega-frameworks that promise to solve the problem but become a problem by their own volition will find this book useful to fight the bloat.
The authors presented their strategy to fight the bloat with suggestions, practical advises and associated tools such as JUnit, Ant, Hibernate, Kodo or Spring. This book is not a reference to these agile technologies but provides enough information on their design principles to justify how they can become the foundations to build reliable, extensible enterprise systems.
The suggestions such as 'Do one thing, and Do it Well', 'Strive for Transparency', 'Allow for Extension' are direct, full of experienced insight and supported by definite examples and best practices.
The beginning sentence of the book simply states: Java development is in crisis. Now that is a strong assertion. The J2EE evangelists and architects and big application server vendors will surely disagree. But the book is full of such opinions. One may agree or disagree with these assertions but their directness will make one think. That, in my opinion, is an important purpose of any book. In that sense, it is an important book for those who like to think what they are doing.
Rating: 
Summary: Not worth buying. Simple manifesto.
Review: This book delivers a great message in the worst possible way.
It is useful if you are trying to persuade a PHB (management) that going with a full-blown EJB solution doesn't make sense.
If you need to convince an architect about this, give them Rod Johnson's book "Expert one-on-one J2EE Design and Development without EJB".
If you want to actually learn anything about the approach and philosophy, don't use this book. For one thing, the authors are working on a broken definition of "coupling" and fail to address "cohesion" by its proper name. In short, there is a lack of depth and rigor in what they are presenting that, at times, leads them to recommend approaches that aren't necessarily valid. For example: Using a message passing API without a strict message format definition (such as a WSDL definition in the WS world) actually leads to tighter coupling because the author of a service client must inspect the code of the service in order to understand the rules of exchange (the API). By definition that is tight coupling. The omission is minor, but significant in understanding the pitfalls of message-oriented service integration.
In short, AOP and related ideas are all about cohesion. Not just on the function or method level, but on the interface and class level. "Separation of concerns" sounds a lot like "functional cohesion". Not addressing this well understood issue by its formal name denies the reader the opportunity to find the broader body of knowledge on the subject. Why reinvent the wheel?
I guess if I had to sum up why this book isn't worth your money is because it is dogmatic and not prescriptive. The great thing about Rod Johnson's book is that it tells you not only when it is appropriate to take this approach, but the different ways to do so. The examples presented here are straw-men and "hello world" (as described above). What would be nice is a full example that brings all the pieces together. An implementation of the Java Pet Store using this approach, fully described point-by-point would be a nice approach.
|
