Effective Enterprise Java (Effective Software Development Series)

Paperback (Print)
Used and New from Other Sellers
Used and New from Other Sellers
from $1.99
Usually ships in 1-2 business days
(Save 96%)
Other sellers (Paperback)
  • All (19) from $1.99   
  • New (6) from $18.32   
  • Used (13) from $1.99   
Close
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any BN.com coupons and promotions
$18.32
Seller since 2014

Feedback rating:

(512)

Condition:

New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

New
2004 Paperback New

Ships from: san francisco, CA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$23.36
Seller since 2008

Feedback rating:

(176)

Condition: New
0321130006 BRAND NEW NEVER USED IN STOCK 125,000+ HAPPY CUSTOMERS SHIP EVERY DAY WITH FREE TRACKING NUMBER

Ships from: fallbrook, CA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
$43.09
Seller since 2008

Feedback rating:

(18539)

Condition: New
Brand New, Perfect Condition, Please allow 4-14 business days for delivery. 100% Money Back Guarantee, Over 1,000,000 customers served.

Ships from: Montgomery, IL

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
$43.10
Seller since 2007

Feedback rating:

(23951)

Condition: New
BRAND NEW

Ships from: Avenel, NJ

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
$58.77
Seller since 2008

Feedback rating:

(214)

Condition: New

Ships from: Chicago, IL

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
$72.16
Seller since 2015

Feedback rating:

(6)

Condition: New
New

Ships from: Idyllwild, CA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Page 1 of 1
Showing All
Close
Sort by

Overview

"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.

Read More Show Less

Product Details

  • ISBN-13: 9780321130006
  • Publisher: Addison-Wesley
  • Publication date: 9/9/2004
  • Series: Effective Software Development Series
  • Edition description: New Edition
  • Pages: 470
  • Product dimensions: 7.00 (w) x 9.00 (h) x 1.20 (d)

Meet the Author

Ted Neward is a software architect, consultant, author, and presenter who has consulted for such companies as Intuit and Pacific Bell, and UC Davis. He is the author of Server-Based Java Programming (Manning, 2000), and coauthor of C# in a Nutshell (O'Reilly, 2002) and SSCLI Essentials (O'Reilly, 2003). Ted was a member of the JSR 175 Expert Group. He now frequently speaks on the conference circuit and to user groups all over the world. He continues to develop and teach courses on Java and .NET.

Read More Show Less

Read an Excerpt

Those who cannot remember the past are doomed to repeat it.
—George Santayana

These are heady days for Java programmers. Commercially available for less than a decade, Java has nevertheless emerged as the language of choice for enterprise systems on nearly all major computing platforms. Companies and individuals with challenging programming problems increasingly embrace the language and platform, and the question faced by those who do not use Java is often when they will start, not if. The breadth and scope of the specifications and libraries defined by and under the Java 2 Enterprise Edition Specification—which both dwarfs and subsumes that of the Java language itself—makes it possible to write rich, complex systems without sacrificing performance or implementing common algorithms or data structures from scratch. The Java language and virtual machines grow ever more powerful. Tools and environments for Java development grow ever more abundant and robust. Commercial libraries all but obviate the need to write code in many application areas.

Scott Meyers wrote much the same in his opening to More Effective C++ Meyers97 almost a decade ago. It seems a fitting tribute to use that paragraph, suitably modified, as the opening in this book. As a matter of fact, the two paragraphs are deliberately side-by-side similar. In many ways, we now find ourselves in a part of the Golden Age of Java, looking out over a landscape that stretches from horizon to horizon, with ample space and established borders that seem to have no limit. Just as C++ ruled the landscape in 1996, Java rules the landscape in 2004.

The chief aim in drawing these parallels is to recognize the scenario—not more than two years after Scott wrote that paragraph, C++ was toppled from its throne by this upstart named Java. Just as C++ developers had finally begun to "figure everything out," this new language and environment leapt forward into the fray, and almost overnight, it seemed, took over. In turn, Java now faces fierce competition from Microsoft's .NET platform. The natural concern, then, is to see that history doesn't repeat itself. To do that, Java developers must make sure that the systems they develop meet or exceed expectations set for them. To do that, Java developers need to know how to make the most of the language and platform they use.

It has been said, in many places by many people, that it takes about five years to "figure out" a technology and how best to use it. Certainly this was true for C++: in 1990, we looked at C++ as simply another object-oriented language, and therefore using it should mirror the best-usage practices discovered with Smalltalk. By 1995, we were well out of that world and starting to explore the uniqueness that C++ provides (such as templates and the STL). Certainly this was also true of HTTP: in 1995, when the browser debuted, we looked at HTTP as the means by which HTML was delivered. Now, we look at HTTP as a universal transport by which to transmit all sorts of data.

Thus, the timing is fortuitous for Java. It officially debuted in 1995; for all intents and purposes, however, Java truly entered the mindscape of the average developer in 1997 or so, having by that point built enough of a "critical mass" to win its way past the critics and skeptics. Almost a decade later, we have been writing Java applications for most of that time, and we're starting to see the practices and patterns that have emerged to assist (but not necessarily guarantee) successful deployments. As a community, we're just starting to hit our stride.

Some things aren't different from the C++ days. We have the same questions, modified for the Java world, as those we asked (and Scott answered) a decade ago about C++. As the language and platform have matured and our experience with Java has increased, our needs for information have changed. In 1996, people wanted to know what Java was. "It has something to do with the Internet, whatever that is" was a common explanation. Initially, developers focused on using applets, making rich browser clients, and harnessing Java's cross-platform portability. By 1998, they wanted to know how to make it work: "How do I access a relational database? How do I internationalize? How do I reach across physical machine boundaries?" Now, Java programmers ask higher-level questions: "How can I design my enterprise systems so they will adapt to future demands?

How can I improve the efficiency of my code without compromising its correctness or making it harder to use? How can I implement sophisticated functionality not directly supported by the language or platform?"

As if this weren't enough, a new dimension has arisen in the whole enterprise system arena, neatly captured in two words: Web Services. Even as Java developers are asking the hard higher-level questions about Java, they face the start of the cycle with Web Services—what is a Web Service, how does it work, and, perhaps most importantly, how does it relate to Java?

In this book, I answer these questions and many like them.

About the items

One thing I feel compelled to point out, before we get too deeply into it all, is that readers may notice a significant difference between the items in this book and those from books like Effective Java Bloch and Effective C++ Meyers95. In particular, the scope of the items in this book is much larger than that in other similar books—in here, there's less focus on language and/or APIs and more on design-level constructs and/or usage patterns.

This is not an accident; in fact, I believe that this is in keeping with the larger scope of an enterprise application as a whole. Certainly, without question, all of Effective Java also applies to building enterprise applications, but to simply remain at that level misses the larger point, that enterprise systems have much more to worry about, things outside of the scope of the language or APIs.

For example, an unsuccessful EJB application usually begins not with misuse of a particular method call or interface but with the design of entity beans that are called directly from a client. This isn't so much an implementation problem as a design problem, and solving it requires a more "high-level" view of what the entity bean is trying to provide in general. (See Item 40 for more details about entity beans and their consequences.)

As a result, the items presented in this book strive to help developers recognize efficiency not at a language level but at a systemic and architectural level. Many of these items will be familiar ground to some; many will be simple codification of something some readers "always knew." That's OK—what's "intuitive" to one reader will be new to another, and vice versa.

In addition, I have carefully tried to avoid walking on familiar territory. A number of books have been released that discuss best practices and effective use of the virtual machine and/or the language; see the Bibliography for a complete list. As a result, discussions of material covered there won't be repeated here unless it has some particular relevance or application within the enterprise space.

Toward that end, I will refer frequently to patterns already established wit in the enterprise Java literature space; in particular, I will tend to lean heavily on Fowler's Patterns of Enterprise Application Architecture (Addison-Wesley, 2002), Hohpe and Woolf 's Enterprise Application Integration (Addison-Wesley, 2004), and Alur, Crupi, and Malks's Core J2EE Patterns, 2nd ed. (Addison-Wesley, 2003), among others. (Again, see the Bibliography for a complete list.)

Where a pattern is cited by name, I use the standard Gang-of-Four pattern citation format, citing the pattern name with its page number in parentheses behind it; however, because these patterns come from different sources, I also put the author's names (or "GOF" for the Gang-of- Four book, Design Patterns) as part of the page citation. So a reference to the Data Transfer Object pattern from Fowler's Patterns of Enterprise Application Architecture book will be cited as "Data Transfer Object (Fowler, 401)".

Reporting bugs, making suggestions, and getting book updates

I have tried to make this book as accurate, readable, and useful as possible, but I know there is room for improvement. (There is always room for improvement.) If you find an error of any kind—technical, grammatical, typographical, spiritual, whatever—please tell me about it. I will try to ensure the mistake is corrected in a future printing of the book, and if you are the first person to report it, I will happily add your name to the book's acknowledgments. Likewise, if you have suggestions or ideas on how to improve the book for subsequent revisions or editions, I'm all eyes and ears.

I continue to collect guidelines for effective enterprise programming in Java. If you have ideas for new guidelines, I'd be delighted if you'd share them with me. You can either find me on one of several public Java programming mailing lists, the predominant one being the ADVANCED-JAVA list at DISCUSS.DEVELOP.COM, or you can reach me at:

Ted Neward c/o Addison-Wesley Professional/Prentice Hall PTR Pearson Technology Group
75 Arlington St., Suite 300
Boston, MA 02116

Alternatively, you can drop me an email at ted@neward.net.

I maintain a list of changes to this book since its first printing (including bug fixes, clarifications, commentary, and technical updates) on the book's blog, http://www.neward.net/ted/EEJ/index.jsp. Please feel free to post comments and/or errata there if you wish to share them with your fellow readers.

Enough preliminaries. On with the show!

Read More Show Less

Table of Contents

Foreword.

Preface.

L ist of Abbreviations.

Chapter 1. Introduction.

The goals of J2EE.
Middleware and J2EE.
J2EE implementation.
The ten fallacies of enterprise computing.

Chapter 2. Architecture.

Item 1: Prefer components as the key element of development, deployment, and reuse.
Item 2: Prefer loose coupling across component boundaries.
Item 3: Differentiate layers from tiers.
Item 4: Keep data and processors close together.
Item 5: Remember that identity breeds contention.
Item 6: Use hook points to inject optimizations, customizations, or new functionality.
Item 7: Be robust in the face of failure.
Item 8: Define your performance and scalability goals.
Item 9: Restrict EJB to transactional processing.
Item 10: Never optimize without profiling first.
Item 11: Recognize the cost of vendor neutrality.
Item 12: Build in monitoring support.
Item 13: Build in administration support.
Item 14: Make deployment as simple as possible.

Chapter 3. Communication.

Item 15: Understand all your communications options.
Item 16: Consider your lookup carefully.
Item 17: Recognize the cost of network access.
Item 18: Prefer context-complete communication styles.
Item 19: Prefer data-driven communication over behavior-driven communication.
Item 20: Avoid waiting for remote service requests to respond.
Item 21: Consider partitioning components to avoid excessive load on any one machine.
Item 22: Consider using Web Services for open integration.
Item 23: Pass data in bulk.
Item 24: Consider rolling your own communication proxies.

Chapter 4. Processing.

Item 25: Keep it simple.
Item 26: Prefer rules engines for complex state evaluation and execution.
Item 27: Prefer transactional processing for implicitly nonatomic failure scenarios.
Item 28: Differentiate user transactions from system transactions.
Item 29: Minimize lock windows.
Item 30: Never cede control outside your component while holding locks.
Item 31: Understand EJB transactional affinity.
Item 32: Prefer local transactions to distributed ones.
Item 33: Consider using optimistic concurrency for better scalability.
Item 34: Consider using pessimistic concurrency for explicit concurrency control.
Item 35: Consider lower isolation levels for better transactional throughput.
Item 36: Use savepoints to keep partial work in the face of rollback.
Item 37: Replicate resources when possible to avoid lock regions.
Item 38: Favor the immutable, for it needs no locks.

Chapter 5. State Management.

Item 39: Use HttpSession sparingly.
Item 40: Use objects-first persistence to preserve your domain model.
Item 41: Use relational-first persistence to expose the power of the relational model.
Item 42: Use procedural-first persistence to create an encapsulation layer.
Item 43: Recognize the object-hierarchical impedance mismatch.
Item 44: Use in-process or local storage to avoid the network.
Item 45: Never assume you own the data or the database.
Item 46: Lazy-load infrequently used data.
Item 47: Eager-load frequently used data.
Item 48: Batch SQL work to avoid round-trips.
Item 49: Know your JDBC provider.
Item 50: Tune your SQL.

Chapter 6. Presentation.

Item 51: Consider rich-client UI technologies.
Dynamic HTML.
Macromedia Flash.
Applets.
The UrlClassLoader class.
JNLP and Java Web Start. Item 52: Keep HTML minimal.
Item 53: Separate presentation from processing.
Item 54: Keep style separate from content.
Item 55: Pregenerate content to minimize processing.
Item 56: Validate early, validate everything.

Chapter 7. Security.

Item 57: Security is a process, not a product.
Item 58: Remember that security is not just prevention.
Item 59: Establish a threat model.
Item 60: Assume insecurity.
Item 61: Always validate user input.
Item 62: Turn on platform security.
Item 63: Use role-based authorization.
Item 64: Use SignedObject to provide integrity of Serialized objects.
Item 65: Use SealedObject to provide confidentiality of Serializable objects.
Item 66: Use GuardedObject to provide access control on objects.

Chapter 8. System.

Item 67: Aggressively release resources.
Item 68: Tune the JVM.
Item 69: Use independent JREs for side-by-side versioning.
Item 70: Recognize ClassLoader boundaries.
Isolation.
Versioning. Item 71: Understand Java Object Serialization.
The serialVerUID field.
Customization (writeObject and readObject).
Replacement (writeReplace and readResolve).
Further Details 415Item 72: Don't fight the garbage collector.
Item 73: Prefer container-managed resource management.
Item 74: Use reference objects to augment garbage collection behavior.
SoftReference objects.
WeakReference objects.
PhantomReference objects. Item 75: Don't be afraid of JNI code on the server.

Bibliography.

Index.

Read More Show Less

Preface

Those who cannot remember the past are doomed to repeat it.
—George Santayana

These are heady days for Java programmers. Commercially available for less than a decade, Java has nevertheless emerged as the language of choice for enterprise systems on nearly all major computing platforms. Companies and individuals with challenging programming problems increasingly embrace the language and platform, and the question faced by those who do not use Java is often when they will start, not if. The breadth and scope of the specifications and libraries defined by and under the Java 2 Enterprise Edition Specification—which both dwarfs and subsumes that of the Java language itself—makes it possible to write rich, complex systems without sacrificing performance or implementing common algorithms or data structures from scratch. The Java language and virtual machines grow ever more powerful. Tools and environments for Java development grow ever more abundant and robust. Commercial libraries all but obviate the need to write code in many application areas.

Scott Meyers wrote much the same in his opening to More Effective C++ Meyers97 almost a decade ago. It seems a fitting tribute to use that paragraph, suitably modified, as the opening in this book. As a matter of fact, the two paragraphs are deliberately side-by-side similar. In many ways, we now find ourselves in a part of the Golden Age of Java, looking out over a landscape that stretches from horizon to horizon, with ample space and established borders that seem to have no limit. Just as C++ ruled the landscape in 1996, Java rules the landscape in 2004.

The chief aim in drawing these parallels is to recognize the scenario—not more than two years after Scott wrote that paragraph, C++ was toppled from its throne by this upstart named Java. Just as C++ developers had finally begun to "figure everything out," this new language and environment leapt forward into the fray, and almost overnight, it seemed, took over. In turn, Java now faces fierce competition from Microsoft's .NET platform. The natural concern, then, is to see that history doesn't repeat itself. To do that, Java developers must make sure that the systems they develop meet or exceed expectations set for them. To do that, Java developers need to know how to make the most of the language and platform they use.

It has been said, in many places by many people, that it takes about five years to "figure out" a technology and how best to use it. Certainly this was true for C++: in 1990, we looked at C++ as simply another object-oriented language, and therefore using it should mirror the best-usage practices discovered with Smalltalk. By 1995, we were well out of that world and starting to explore the uniqueness that C++ provides (such as templates and the STL). Certainly this was also true of HTTP: in 1995, when the browser debuted, we looked at HTTP as the means by which HTML was delivered. Now, we look at HTTP as a universal transport by which to transmit all sorts of data.

Thus, the timing is fortuitous for Java. It officially debuted in 1995; for all intents and purposes, however, Java truly entered the mindscape of the average developer in 1997 or so, having by that point built enough of a "critical mass" to win its way past the critics and skeptics. Almost a decade later, we have been writing Java applications for most of that time, and we're starting to see the practices and patterns that have emerged to assist (but not necessarily guarantee) successful deployments. As a community, we're just starting to hit our stride.

Some things aren't different from the C++ days. We have the same questions, modified for the Java world, as those we asked (and Scott answered) a decade ago about C++. As the language and platform have matured and our experience with Java has increased, our needs for information have changed. In 1996, people wanted to know what Java was. "It has something to do with the Internet, whatever that is" was a common explanation. Initially, developers focused on using applets, making rich browser clients, and harnessing Java's cross-platform portability. By 1998, they wanted to know how to make it work: "How do I access a relational database? How do I internationalize? How do I reach across physical machine boundaries?" Now, Java programmers ask higher-level questions: "How can I design my enterprise systems so they will adapt to future demands?

How can I improve the efficiency of my code without compromising its correctness or making it harder to use? How can I implement sophisticated functionality not directly supported by the language or platform?"

As if this weren't enough, a new dimension has arisen in the whole enterprise system arena, neatly captured in two words: Web Services. Even as Java developers are asking the hard higher-level questions about Java, they face the start of the cycle with Web Services—what is a Web Service, how does it work, and, perhaps most importantly, how does it relate to Java?

In this book, I answer these questions and many like them.

About the items

One thing I feel compelled to point out, before we get too deeply into it all, is that readers may notice a significant difference between the items in this book and those from books like Effective Java Bloch and Effective C++ Meyers95. In particular, the scope of the items in this book is much larger than that in other similar books—in here, there's less focus on language and/or APIs and more on design-level constructs and/or usage patterns.

This is not an accident; in fact, I believe that this is in keeping with the larger scope of an enterprise application as a whole. Certainly, without question, all of Effective Java also applies to building enterprise applications, but to simply remain at that level misses the larger point, that enterprise systems have much more to worry about, things outside of the scope of the language or APIs.

For example, an unsuccessful EJB application usually begins not with misuse of a particular method call or interface but with the design of entity beans that are called directly from a client. This isn't so much an implementation problem as a design problem, and solving it requires a more "high-level" view of what the entity bean is trying to provide in general. (See Item 40 for more details about entity beans and their consequences.)

As a result, the items presented in this book strive to help developers recognize efficiency not at a language level but at a systemic and architectural level. Many of these items will be familiar ground to some; many will be simple codification of something some readers "always knew." That's OK—what's "intuitive" to one reader will be new to another, and vice versa.

In addition, I have carefully tried to avoid walking on familiar territory. A number of books have been released that discuss best practices and effective use of the virtual machine and/or the language; see the Bibliography for a complete list. As a result, discussions of material covered there won't be repeated here unless it has some particular relevance or application within the enterprise space.

Toward that end, I will refer frequently to patterns already established wit in the enterprise Java literature space; in particular, I will tend to lean heavily on Fowler's Patterns of Enterprise Application Architecture (Addison-Wesley, 2002), Hohpe and Woolf 's Enterprise Application Integration (Addison-Wesley, 2004), and Alur, Crupi, and Malks's Core J2EE Patterns, 2nd ed. (Addison-Wesley, 2003), among others. (Again, see the Bibliography for a complete list.)

Where a pattern is cited by name, I use the standard Gang-of-Four pattern citation format, citing the pattern name with its page number in parentheses behind it; however, because these patterns come from different sources, I also put the author's names (or "GOF" for the Gang-of- Four book, Design Patterns) as part of the page citation. So a reference to the Data Transfer Object pattern from Fowler's Patterns of Enterprise Application Architecture book will be cited as "Data Transfer Object (Fowler, 401)".

Reporting bugs, making suggestions, and getting book updates

I have tried to make this book as accurate, readable, and useful as possible, but I know there is room for improvement. (There is always room for improvement.) If you find an error of any kind—technical, grammatical, typographical, spiritual, whatever—please tell me about it. I will try to ensure the mistake is corrected in a future printing of the book, and if you are the first person to report it, I will happily add your name to the book's acknowledgments. Likewise, if you have suggestions or ideas on how to improve the book for subsequent revisions or editions, I'm all eyes and ears.

I continue to collect guidelines for effective enterprise programming in Java. If you have ideas for new guidelines, I'd be delighted if you'd share them with me. You can either find me on one of several public Java programming mailing lists, the predominant one being the ADVANCED-JAVA list at DISCUSS.DEVELOP.COM, or you can reach me at:

Ted Neward c/o Addison-Wesley Professional/Prentice Hall PTR
Pearson Technology Group
75 Arlington St., Suite 300
Boston, MA 02116

Alternatively, you can drop me an email at ted@neward.net.

I maintain a list of changes to this book since its first printing (including bug fixes, clarifications, commentary, and technical updates) on the book's blog, http://www.neward.net/ted/EEJ/index.jsp. Please feel free to post comments and/or errata there if you wish to share them with your fellow readers.

Enough preliminaries. On with the show!

Read More Show Less

Customer Reviews

Average Rating 4.5
( 3 )
Rating Distribution

5 Star

(2)

4 Star

(1)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 3 Customer Reviews
  • Anonymous

    Posted November 27, 2004

    Great book and worthy successor in a wonderful series

    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.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted September 30, 2004

    Great for J2EE design

    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.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted July 8, 2009

    No text was provided for this review.

Sort by: Showing all of 3 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)