Effective Enterprise Java

Rating:
Summary: Best practices for developing enterprise Java systems
Review: An excellent compendium of best practices for developing enterprise Java-based systems. Even if you already know some of this stuff (as experienced Java folks will) you will still learn probably something new. Also Ted has a very entertaining conversational tone that makes the material much more enjoyable than your typical Java book.

[...]

Rating:
Summary: We all need a mentor
Review: As anyone who has programmed using Servlets, JSPs, and EJBs knows, the complexities of integrating multiple layers of code can drive you to distraction. If you aren't careful, you can create an application that performs poorly under load, is difficult to maintain, and is impossible to port from one platform to another. The tricks that a programmer needs to avoid these problems often come painfully with experience. The author has taken his experience and given us a book that is well-written, easy to understand, and provides plenty of excellent advice that will help you produce superior applications. The best part is that the advice you get is practical advice from someone who has actually experienced the pain and suffering of J2EE development. This book deals in the reality of development and not pie-in-the-sky theory.

The book contains seventy-five items of discussion broken up into seven main areas. The items cover a wide range of topics from the broad, "Keep it simple" to the specific, "Never cede control outside your component while holding locks." The items cover everything from architecture, "Define your performance and scalability goals," to coding, "Use HttpSession sparingly." Even if a particular item is not of interest to you, there will be plenty of other items that will be of interest.

This book is not a tutorial or beginner's book. It is expected that the reader already has some experience with Enterprise Java. If that describes you, make sure you get this book to avoid more pain and suffering. You will end up a better J2EE developer and your applications will be cleaner and easier to maintain.


Rating:
Summary: A skillfully written guide to the nuances of Java 2 Platform
Review: Expert software architect and consultant Ted Neward presents The Complete Idiot's Guide To Making Effective Enterprise Java, a sourcebook filled cover to cover with tips, tricks, and techniques for building Java enterprise applications that work more efficiently. A skillfully written guide to the nuances of Java 2 Platform, Enterprise Edition (J2EE), Effective Enterprise Java includes architecture advice such as the importance of differentiating layers from tiers and keeping data and processors close together, and why one must never optimize without profiling first; processing tips such as the importance of keeping savepoints to retain partial work in the face of rollback and favoring immutables which need no locks; security requirements such as always validating user input, how to make the best use of role-based authorization, and much, much more. An excellent, advanced supplementary resource for seasoned professionals.


Rating:
Summary: Great book, but supplement with IoC and ORM...
Review: I bought the book after attending one of Ted's "No Fluff, Just Stuff" seminars and was pleased to see just how much ground is covered. I'd recommend it to any enterprise developer, even if they're not working with EJBs (although they'll get extra benefit from it). Ted's excellent conversational style (and supporting experience) really shines through in the book, and I'd almost call it a "technical novel" based on how the information is presented. The only ding I'd give Effective Enterprise Java is that it doesn't include good coverage of modern object-realtional mapping (ORM) tools such as Hibernate and OJB, and to inversion of control (IoC) frameworks such as Spring, Pico and Nano, all of which are having significant impacts on how enterprise applications are being approached today. All in all though it's an excellent book and will make any reader better at designing enterprise applications.

Rating:
Summary: Well written but of little actual value
Review: I feel kind of lonely here; everyone else seemed to love this book. Looking at the table of contents, I was very excited when I started reading the book. However, while reading it cover to cover I slowly became more and more dis-illusioned with it.

The book is divided up into a number of recommendations, called items, in a manor similar to Effective C++ and Practical Java. The problem is that most of the items appear to fall into one of a few general catagories:

1) Intro level generalities of good design for the web.
e.g.
- pass data in bulk - multiple asynchronous calls out of process are more expensive than one big call
- make deployment as simple as possible - exactly what it says!
- use HttpSession sparingly - this is web application design 101
- always validate user input - my personal favorite; who today is not validating user input received from the web?

2) Using a pair of items to represent a classic design best practice.
e.g.
- Lazy-load infrequently used data & Eager-load frequently used data
- Consider using optimistic concurrency for better scalability & Consider using pessimistic concurrency for explicit concurrency control

3) Re-statements of some of the principals of secure coding
e.g.
- Security is a process, not a product
- Remember that security is not just prevention, aka "fail securely"
- Assume insecurity, aka "grant minimal trust necessary"
- Establish a threat model

My copy of this book has long been in the trash. Save your money. Here are a couple of free online articles to get you started:
Secure coding: http://www.securityfocus.com/infocus/1596
Article on stopping SQL injection: http://www.securityfocus.com/infocus/1768


Rating:
Summary: Excellent insight of some of the critical architectural issu
Review: I have just finished reading some of the items from this book. The feeling is awesome. After spends quite a bit of time in developing and understanding enterprise application, it is not unusual to get a feeling that all big terms associated with the enterprise application have some common linkage. But, it is equally difficult to find some one who can actually understand this linkage and can explain to everybody. I guess Ted has succeeded in this front. This book will definitely helps reader to understand this underlying linkage of some of the 'over-used' terms in an enterprise application.

Rating:
Summary: Pragmatic advice for J2EE developers
Review: I like this book a lot. It's contains the type of practical and pragmatic advice that gets applications off the ground, and effectively defuses the rocket that propels architecture astronauts. Like Effective C++ before it this book has a collection of practical common sense fragments of advice around the entire application development cycle. I particularly liked the material around SQL and state management, but there is a lot there to like for everyone.

On the downside the book is a little text heavy and it could have used more diagrams and illustrations to make it's points. But that is a minor complaint. This is a valuable book for those interested in shipping applications. If you liked Bitter Java and Bitter EJB you will love this book.

Rating:
Summary: Effective, Efficient and Convenient
Review: If you have had a chance to see Ted speak, you have a sense of what to expect from this book: insight, amusement and a touch of controversy. Seasoned professionals will find themselves nodding at most of the items in this book. Folks from the trenches knowing this material is good news however; you wouldn't want to be faced with a deluge of maverick advice in something donning the title "Effective". What those types of engineers will find so useful is the convenient collection and organization of advice with which they can efficiently reassess their designs, communicate with peers, etc. Far from being a simple collection of didactic nuggets, however, there is exposition and justification behind the suggestions Ted makes. More junior engineers will find a series of rungs and footholds with which to scale the wall of enterprise Java. Beyond reading techniques that make sense and learning new approaches to solving common Enterprise problems, chances are your conventional wisdom will be challenged by at least one of the recommendations (like #11 did to me).

Rating:
Summary: Great for J2EE design
Review: Neward writes at an engagingly sophisticated level about many problems that arise when using J2EE. He offers 75 "items". (O'Reilly publisher would probably call these "hacks".) Unusually for a computer book these days, there does not appear to be a single diagram. Just pages of text, interspersed with an occasional code snippet. But not dry. He leavens it with a low key wit.

A lot of items relate to having EJBs in your system, and the scalability and redundancy issues that arise when you want to improve one or both. Another topic given careful study is security. He shows the danger of blithely accepting client side input from an HTML form, without filtering it on the server side. This has to be done, even if you have written the equivalent filters for your client code. Because on the physical client machine, you must assume that all your client side tests can be circumvented. A simple example is given of how a cracker can try to break into your server's SQL database, by injecting SQL code into input text fields. In general, and not just for input from HTML forms, he suggests making a Java class, "TaintedString", that has filters which can validate a suspect input string. You might give this idea some consideration.

In general, the book is at a level of complexity that may hit the right chords, if you are struggling with J2EE design issues.

Rating:
Summary: Great book and worthy successor in a wonderful series
Review: This is an amazing book that does not disappoint in any way. It is full of wonderful well-written content. The book is organized as a series of 75 essays, each running from 1 to 10 pages. Each essay gives advice on what to do or not do in an enterprise Java application.

Since I'm not a fan of Enterprise JavaBeans, before I received the book I was worried that the "enterprise" in the title might mean the book was focused on concerns of EJB developers. That isn't the case at all and the vast majority of the book is absolutely applicable if you avoid EJB in favor of lighter-weight frameworks such as Sping.

Recently I was working with a team whose application was running out of memory and causing their application server to crash, sometimes in as little as an hour. With the help of this book's sections on the garbage collector they were able to identify and resolve the problems within a day, which was much shorter than everyone had expected.

This book is a wonderful successor to Scott Meyers' "Effective C++" and I recommend it highly.