The bar for Web-based applications is being raised….
I am excited about Sun Microsystems’ JavaServer Faces (JSF). Multiple, psychological studies prove that “group think” results in diffusion of responsibility and poor output. JSF has potential as an effective product development framework and supports both the building of AJAX-based Web applications and helps teams collaborate. What developers need is a way to promote collaboration and get the front-end team talking to the back-end team. The introduction of AJAX, Web 2.0, and rich Internet applications is driving demand for a new wave of Web development. This demand is for more complex Web applications and will be a big challenge for all development teams. Overcoming this challenge will require a new level of team collaboration. Front-end development is no longer an afterthought; the front-end is the ‘Application.’ Collaboration between front-end and back-end developers is becoming more important. Teams who fail to collaborate will suffer.
Enter JavaServer Faces
JSF is Sun Microsystems’ response—a component framework offering excellent support for AJAX-based Web development. JSF is one of the exciting new directions Sun Microsystems is taking Java. This promising new direction also addresses the need for teams to collaborate effectively. JSF is part of J2EE and is built on top of Servelets and JavaServer Pages. Teams using JSF can better manage common product life-cycle bottlenecks.
Developers, product managers, and other stakeholders are familiar with the risks introduced by lock-step interaction between the front-end and back-end development teams. Collaboration is the key to successful product development. Too often, collaboration is missing. Front-end developers are left waiting for back-end development tasks to be completed. In this case, the potential benefits of collaboration are unrealized. Any collaboration that takes place is after the fact; for the most part, the opportunity to act on the front-end development team’s input has passed. This is expensive. Product development is often slowed while UI front-end developers are faced with one of the two following choices:
- Wait for back-end development to be completed before starting real work.
- Spend significant time and energy creating throw-away mock objects in an attempt to start development before back-end developers finish implementation.
A loss is suffered with either choice. The development and product management communities need to do better and avoid the inherent diffusion of responsibility that results with two independent teams pointing the finger at each other. The first choice results in isolation with front-end teams joining projects too late for real input because back-end developers have already made design decisions and are moving on. The second choice often results in an unpredictable integration stage that sends the schedule beyond original estimates. The common result is that teams are isolated, quality suffers, and iterative approaches become superficial. Developers are people and people want out!
JSF can help. Really. Superficially, it may appear that the project is suffering from a skills risk. The front-end team never understands the back-end, or—a political risk—the team is not jelling. Closer inspection may reveal that the real culprit is a technological risk; you are not using a framework technology that supports collaboration.
If you are not developing with Java, take a look at other frameworks that support collaboration, Flash, or XAML.
The use of off-the-shelf UI components is the best solution to the above-mentioned problems. UI components act as building blocks that can be assembled by UI architects. This assembly takes place with a minimal amount of stubbing or mock object creation. UI prototyping and front-end development can near completion before, during, or after the back end is developed.
Okay, I know you are one of the smart ones out there and you have realized JSF is no silver bullet; integration risks still exist. Some things are unavoidable. Any collaborative project will have an integration phase and the integration of software is never easy. Integration surprises will always exist.
Now, the Real Solution: Managing Collaboration Risks
Let me come down to earth and suggest that JSF is an effective tool to manage collaboration and integration risks. The JSF component framework manages integration risks in the following ways:
- Craftwork + structure -> Engineering + reuse -> architecture
- The JSF framework creates structure for collaboration.
- The JSF components within the structure are reusable.
- Avoiding the big bang
- The collaboration structure of JSF is fine grained, allowing integration to take place continuously
- The JSF framework encourages the inversion of control, thus leading to loose coupling and interfaced-based development.
- Test driven development; well, almost
- JSF works within the larger J2EE architecture.
- TDD is achieved by the effective use of Hibernate and other mock object tools within the JSF backing beans.
The JSF framework helps development teams collaborate and work effectively. AJAX is here. All successful new Web projects need to support an AJAX-based interaction. However, creating an AJAX-based Web application is not easy. Teams building AJAX-based Web applications must collaborate effectively. Teams building AJAX-based Web applications need a structured architecture.
I am excited about JSF’s potential as an effective product development framework that will better support team collaboration. I am excited about JSF as part of a larger J2EE set of architectural solutions. Share my excitement.
About the Author
Godfrey Hobbs has been involved in Internet software development for over six years. He is Lead Java Developer of eBusiness Applications (http://www.ebusinessapps.com). His primary areas of expertise include usability, software engineering, project management, and component-based software development methodologies. Past experience includes Technical Leadership and Senior Software Developer positions at www.amazon.com and www.etrade.com.