In this third and final article in Ramnivas Laddad's aspect-oriented programming (AOP) series, Ramnivas demonstrates how to use AOP and AspectJ to solve real-world problems by modularizing crosscutting concerns. His examples will help you better understand aspect-oriented concepts so you can apply AOP to your projects. (2,500 words)

The Phased Process pattern is used extensively in game programming, installer construction, and especially user interface development. You can easily exploit it in any situation where a set of successive operations exists. Though probably overkill for simple progressive processes (e.g., communications handshaking), this pattern is ideal for user interface elements like installation wizards. The design lets you quickly discern how control flows from one operation to another, promoting rapid comprehension and enhancing your code's maintainability... (2,400 words)

Instead of giving you tips to use in your programming (at least directly), I want to look at some common mistakes made in enterprise programming. And instead of focusing on what to do, I want to look at what you should not do.

• It doesn't matter what data store type you use.
• Vendor-specific programming speeds up programming tasks.
• need an editor or tool to write my Enterprise JavaBeans
• I've got to include JMS, XML, JAXP, and more in every application.
• Stateful beans make programming more object-oriented.
• don't need anyone telling me what to do in my programming.

This article proposes an alternative to the standard Value Object/Data Transfer Object approach patterns, by illustrating using EJB 2.0 in conjunction with bean introspection and JAXP to create dynamic XML based data structures.
In the article, a framework is developed that can dynamically traverse the container managed persistent and related fields of a given local EJB and create an XML document that can be transferred between the various tiers in the application.

You've certainly seen the Document/View architecture (sometimes called the Model/View architecture), even if you haven't been aware of it. Most e-mail client programs, for example, display both a screen showing a list of message headers and a separate window containing the text of the selected message. The document is the collection of e-mail messages; one view shows just the headers and another displays the full text of one message. Another example is a spreadsheet program in which the data can be displayed in the familiar grid or table arrangement, and can also be displayed as a graph....

Most J2EE (Java 2 Platform, Enterprise Edition) applications strive to abstract the database tier by employing the Data Access Object (DAO) design pattern. However, these implementations typically deal with project-specific object types. This article shows you a DAO pattern framework that you can reuse on all your projects, regardless of object type.

A design pattern for user interface validations that treats the validation rules as data making it easily configurable and maintainable.

This article lies somewhere between an opinion piece and a product review. It briefly describes how Allen Holub designs an object-oriented (OO) system, discusses the tools that don't work for this purpose and why they fail, and presents a piece of software that solved the UML- (Unified Modeling Language) diagramming problem for him once and for all.

In this article, Jason Cai explores the benefits and advantages of using the Session Facade pattern. He discusses when to use the pattern with value objects, and when to use it with XML. He also provides a detailed implementation of the Session Facade pattern integrated with XML.

Software can never be tested sufficiently, and testing usually starts too late, particularly for J2EE applications. Since components often behave differently when they are alone than when they have been assembled, testing each component individually before two or more components are joined together ensures each piece of code in a J2EE application will work as it was designed to do. Then, if an error occurs in the application, the developer knows the application's assembly may be the cause. This article presents unit testing techniques and how to apply unit testing to Enterprise JavaBeans (EJBs). (2,800 words)

The Decorator design pattern lets you attach responsibilities to objects at runtime. This pattern proves more flexible than inheritance, which is static. In this latest installment of Java Design Patterns, David Geary explores Decorator with an implementation example. (2,800 words)