`With this book, Ted Neward helps you make the leap from being a good Java enterprise developer to a great developer!`?John Crupi, Sun Distinguished Engineer coauthor, Core J2EE Patterns
If you want to build better Java enterprise applications and work more efficiently, look no further. Inside, you will find an accessible guide to the nuances of Java 2 Platform, Enterprise Edition (J2EE) development. Learn how to:
Use in-process or local storage to avoid the network,
see item 44 Set lower isolation levels for better transactional throughput,
see item 35 Use Web services for open integration,
see item 22 Consider your lookup carefully,
see item 16 Pre-generate content to minimize processing,
see item 55 Utilize role-based authorization,
see item 63 Be robust in the face of failure,
see item 7 Employ independent JREs for side-by-side versioning,
see item 69 Ted Neward provides you with 75 easily digestible tips that will help you master J2EE development on a systemic and architectural level. His panoramic look at the good, the bad, and the ugly aspects of J2EE development will address your most pressing concerns. Learn how to design your enterprise systems so they adapt to future demands. Improve the efficiency of your code without compromising its correctness. Discover how to implement sophisticated functionality that is not directly supported by the language or platform. After reading Effective Enterprise Java, you will know how to design and implement better, more scalable enterprise-scope Java software systems.
User review
Book could be zipped into a tenth of the size.
The book has too much of unwanted commentary, to be called as a technical book. He showed his unwanted English language narrative skills. Actual content is very minimal, which we deal with every day. Why would a dumb guy want to know about framework and architecture? He repeats most of the content atleast 10 times.
He talks about efficiency, but his book is not efficient. He could have saved a lot of paper and environment, not the least our time by trying to be to the point.
Eg quote from book: `Oh, don't get me wrong, I'm not suggesting that we don't need to process the credit card payment, I'm just suggesting it doesn't need to be done while user is waiting .` The problem with that statement is redundancy. `Oh, don't get me wrong` is completely redundant. All such comments across the book gave the book an unitelligent look. (Infact, whenever he faces an analysis like what I did, he keeps on writing for 2 pages atleast)
Man, there are lots and lots of such silly jokes. He himself keeps saying `please bear with me`. I'm disappointed that he initially embarked on a good book, but he got dragged away by some bad advice to bloat the book. He gave some good points though. But doesn't deserve the size of the book.
User review
sage distributed computing wisdom
I've developed software for over 20 years and most of that has been middle-ware and distributed software systems. I've done the gamut from C++/DCOM to ASP.NET to Java custom implemented to J2EE and JMS, and then that coupled with Spring for true test driven development.
I knew Ted Neward but had not read his material or been to any of his conference sessions. Yet when I picked up this book and began reading it, I nearly fell over.
All the lessons I've learned through years of experience can be found crystalized in this book. It is very well presented - easy to read and coupled with examples that well explain things in such a way that gets to the heart of the matter.
The reason I nearly fell over in my reaction to this book is that a lot of material that is published for architects and designers of distributed software is not particularly effective in actual practice. Indeed a lot of what passes for convention and so-called common wisdom in these circles actually leads to bad systems.
Here are a few of the core principles found in the book that pretty much go against the grain (the reason being is that the very biggest vendors in our industry have a lot at stake in wanting to shove certain technology initiatives down our collective throats - even though they're based on failed concepts):
* prefer data-centric distributed communication to behavior-based, i.e., passing a data message works out much better than calling methods on remote interfaces (refer to the book to find out the reasons why).
* prefer passing those data messages in an asynchronous manner to synchronous request/response fashion
* stick with that which can be evolved over time without much headache (XML format of documents is much more pragmatic in that sense than distributed object remote interfaces)
The systems I've designed and built over the last several years, the best and most successful in my career, follow a number of the principles that will be found in Ted Neward's book. When I have a developer that I want to bring up to speed on how to develop distributed software and succeed, I'll direct said developer to this book.
User review
Great guide about enterprise architectures for ANY PLATFORM
This is an excellent book that should be read by anyone working with enterprise applications -distributed ones in particular- no matter if they are using Java, J2EE, .NET or any other technology. Ted does a great job explaining the whys and hows for every tip he writes about. I think this is one of the more important books in the last years, and I'm only concerned with the Java in the title restricting its audience a bit.
User review
excellent tip collection
`Effective Enterprise Java` is similar in format and quality to `Effective Java.` It is written at a higher level as it applies to J2EE systems, rather than the Java language. The 75 items include architecture/design (batch SQL to avoid server round trips) and coding level (serialverUID) tips. They do lean toward the architecture/design level tips as the author refers to `Enterprise Java` for more lower level ones.
The tradeoffs of various techniques are highlighted rather than just relying on best practices. For example, `use object-first persistence`, `use relational-first persistence` and `use procedural-first persistence` are all included as tips. Obviously, you wouldn't want to do all of these at once. However, the discussion of when to use each is extremely valuable.
All the trips are grouped by topic. Where appropriate, code snippets are used quite effectively (no pun intended.) Examples and anecdotes prevent the material from getting dry. This book is destined to become a classic. I highly recommend it for any J2EE developer, designer or architect.
User review
Great but,,.
Yes, you can learn to be a better Java architect or programmer. But you only learn a lot if you haven't before. I read this book and it is impressively well written, but I feel many of the topics have already been covered in beginners to intermediate level Java books.
