Recent changes to feature-requests

provide generic implementation for the NullObject pattern

Giovanni Azua — Wed, 17 Nov 2010 09:55:06 -0000

Provide a generic implementation for the NullObject pattern. The implementation will allow to easily instantiate an empty variant of any interface type. Allow some flexibility to let the generic instance be initialized to some values.

Improve Observer to handle complex dependencies

Giovanni Azua — Thu, 25 Mar 2010 22:38:48 -0000

Improve the Observer Pattern implementation to support complex dependencies in UI applications e.g.Swing-based. Suppose there is a UI with many widgets that have complex inter-dependencies e.g.

widget "b" computed value depends on widget "a" value
widget "c" computed value depends on widget "a" value
widget "c" computed value depends on widget "b" value

Suppose this inter-dependencies are implemented in the design using the Observer pattern in this case widget "c" will be notified whenever widget "a" changes or widget "b" changes but this is not efficient ... the worst is that the notification to widget "c" can happen before "b" gets updated so that the state of "c" is temporarily "dirty"

A solution to this problem is to improve the Observer implementation with Topological Sorting based on these complex inter-dependencies so that "c" widget is notified only once and when all the widgets it depends upon have been updated.

Showcase Swing UI application

Giovanni Azua — Thu, 25 Mar 2010 22:29:56 -0000

Build a showcase Swing-based UI application that demonstrate the use of many of the patterns already implemented. Requires the generic MVC implementation first. The Swing UI could do something useful in itself e.g. demonstrate SVM Kernel-PCA for classification.

include Model View Controller Pattern

Giovanni Azua — Thu, 25 Mar 2010 22:22:35 -0000

Provide implementation for a componentized Model View Controller framework aiming to provide a consistent high level architecture for thin client UI applications e.g. Swing-based. Many Swing-based UI applications are created with adhoc architectures that do not scale well over time with respect to adding more use-cases. The idea is to provide a high level MVC that will be context free and built on top of the following Design Patterns: Observer, Command, State and Chain Of Responsibility patterns. The implementation of the MVC pattern will emphasize on IoC friendliness. Optionally provide a new Maven artifact for generating new Swing UI bare bones based on this architecture.

The top abstractions of this generic MVC are: IModel, IController, IView. They generically expose interfaces that will be wired together automatically i.e. use-case based. The interfaces exposed by each of these top level abstractions are explained below.

IModel interface:
- exposes ISubject (Observer) interfaces: Notifies about changes in the model will be automatically wired to the IView's IObserver
- exposes fine grained Model State to be accessed and changed by Controller implementations

IController interface:
- exposes IObserver (Observer) interfaces: Receives notification about user gestures from the IView and triggers execution of Commands
- exposes ICommand (Command) interfaces: Trigger the execution of Commands

IView interface:
- exposes IObserver (Observer) interfaces: Handles notifications about changes in the model.
- exposes ISubject (Observer) interfaces: Notifies user gestures.
- exposes IInvoker (Command) interfaces: Directly triggers the execution of a Command

There will be an initial entity that will scan the concrete implementation of these top level interfaces and do the wiring e.g.
IView's IInvokers with IController's ICommands
IModel's ISubjects with IView's IObservers
IView's ISubject with IController's IObservers

Showcase Struts2-based Web Application

Giovanni Azua — Thu, 25 Mar 2010 21:56:45 -0000

Create a new subproject that demonstrates the use of many of the Patterns already implemented to support high quality low maintenance Struts2-based Web Application. The application will be a showcase of several of the existing design Patterns e.g.

- DAO-based CRUD facilities.
- Value List handler (Page-by-Page iterator)

These two above can be elegantly implemented as a Strus2 perfectjpattern plugin

Optionally the showcase could be made as bare bones to start new Web Applications i.e. a new Maven artifact. The concept would be similar to that of AppFuse but with a slightly different approach of componentized DAO rather than generated code.

SpringGenericDao not to inherit from HibernateGenericDao

Anonymous — Sun, 19 Jul 2009 19:34:39 -0000

Instead make it configurable to take any IGenericDao implementation either HibernateGenericDao or EclipseLinkGenericDao meaning the SpringGenericDao will decorate any implementation and add the dynamic mapping of interface methods to named queries

provide DAO implementation for EclipseLink

Anonymous — Mon, 27 Apr 2009 16:57:37 -0000

Provide a parallel implementation of the DAO API using TopLink with the corresponding proprietary findByExample implementation (i.e. perfectjpattern-toplink subproject), ability to switch between Essential and the full blown commercial version, maybe simply by using the Maven exclude option but test it in both.

include Value List Handler Pattern

Anonymous — Mon, 20 Apr 2009 19:09:20 -0000

Since one of the most critical components for having a robust Value List Handler implementation is a componentized Dao, create a componentized implementation of the Value List Handler Pattern including Stateful Session EJB examples

Composite to be built using Builder Pattern

Anonymous — Tue, 17 Mar 2009 10:35:24 -0000

Introduce CompositeBuilder that simplifies the creation of Composite using the Builder Pattern

add Builder Pattern template

Anonymous — Tue, 17 Mar 2009 10:33:46 -0000

Provide a base template implementation of the Builder pattern