Core J2EE Patterns: Best Practices and Design Strategies

• Authors: Deepak Alur;Dan Malks;John Crupi
• Venue: Core J2EE Patterns: Best Practices and Design Strategies
• Year: 2001

From the Book:In the world of software, a pattern is a tangible manifestation of anorganization's tribal memory. A pattern provides a common solutionto a common problem and so, within the culture of one specific organizationor within one domain, naming and then specifying a patternrepresents the codification of a common solution, drawn fromproven, prior experience. Having a good language of patterns at yourdisposal is like having an extended team of experts sitting at yourside during development: by applying one of their patterns, you ineffect take the benefit of their hard-won knowledge. As such, the bestpatterns are not so much invented as they are discovered and thenharvested from existing, successful systems. Thus, at its mostmature state, a pattern is full of things that work, absent of thingsthat don't work, and revealing of the wisdom and rationale of itsdesigners.Deep, really useful, patterns are typically ancient: you see one andwill often remark, "Hey, I've done that before." However, the verynaming of the pattern gives you a vocabulary that you didn't havepreviously and so helps you apply that pattern in ways you otherwisemight have not have realized. Ultimately, the effect of such apattern will be to make your system simpler.Patterns not only help you build simpler systems that work, butthey also help you build beautiful programs. In a culture of timestarvation, writing beautiful software is often impossible. That's sad,for as professionals, we strive to build things of quality. By applyinga good set of patterns, it is possible to bring a degree of elegance in toyour systems that might otherwise have been lacking.The authors of Core J2EE Patterns have harvested a really usefulset of patterns. Don't get me wrong: J2EE is certainly an importantplatform, enabling teams to build some very powerful systems. However,reality is, there is still a wide semantic gap between theabstractions and services that J2EE provides and the final applicationthat a team must build. Patterns such as specified in this bookrepresent solutions that appear again and again in filling that gap.By applying these patterns, you thus carry out the primary means ofreducing software risk: you write less software. Rather than discoveringthese solutions on your own, apply these patterns, which havealready proven their utility in existing systems.More than just naming a set of patterns, the authors make themapproachable by specifying their semantics using the UML. Additionally,they show you how to apply these patterns and how to refactoryour system to take advantage of them. Again, it's just likehaving a team of experts sitting at your side.Grady BoochChief ScientistRational Software Corporation