Part 1: The codeslinging adventure begins
June, 2001
This first article sets the stage for the story of the dragonslayers and the Go-ForIt application that rejuvenated their consulting careers.

Part 2: eXtreme programming: deceptively simple innovation
June, 2001
Willy Farrell and Mary-Rose Fisher discuss the four values developers bring to a software project: communication, simplicity, feedback, and courage. eXtreme programming is a set of practices that apply those values to create an environment where you can rapidly and accurately develop business applications. The 12 basic practices of eXtreme programming are also discussed.

Part 3: Session management, servlets, and maintaining state
July, 2001
Jeff Wilson describes how the GoFor-It.com project uses session management. This article discusses the methods, inner workings, and pitfalls of the session object, and shows how to create your own session-aware servlet. It also explains how, by understanding the concept of "maintaining state" within an application, you can contribute to a rich user experience while giving your server a break from the tedious chore of continuous data crunching.

Part 4: "Bean" there, done that
July, 2001
Sandeep Desai describes how the team uses Java client-side beans in the Go-ForIt project. This article discusses the architectural and design issues that prompted the team to choose client-side beans and includes sample code showing the application design.

Part 5: View beans: Keeping Java code out of JSP components
August, 2001
Allison Pearce Wilson describes how the Go-ForIt.com project uses view beans. This article discusses how view beans can solve a common design dilemma -- where to code presentation logic. Allison explains how to use view beans to cleanly separate components in a Web application while still providing a rich user interface. She also walks you through code examples that show how Go-ForIt.com uses view beans.

Part 6: The valuable but vexing art of data validation and verification
September, 2001
Indran Naick describes how the Go-ForIt.com project handled user input validation and verification. This article describes the advantages and disadvantages of client-side and server-side validation. Indran discusses HTML forms, elements, and good design practices for data input. He also explains the project's use of command beans and EJB components.

Part 7: Dare to share: Joint code development with VisualAge for Java team server
September, 2001
Venkata Nagalla and Sandeep Desai describe how they used VisualAge for Java® team server, and WebSphere Studio, so team members could jointly develop and share code. This article also shows how the eXtreme Programming (XP) methodology worked in conjunction with the application development tools.

Part 8: A descent into the maelstrom of multilevel displays
September, 2001
Dan Hattenberger discusses the challenges of retrieving and displaying lists of items, drilling down into details of a single item, and returning to the original list to review additional items. As they descended into detailed pages, the team needed to keep track of where they were and where they came from. The Go-ForIt project continues to challenge the team, and this article explains how they decided to tackle the problems of multilevel displays.

Part 9: Avoiding high inheritance "taxes"
October, 2001
David Carew and Chris Nelson explain how they solved a problematic proliferation of subclass combinations. Inheritance is one of the foundations of object-oriented programming languages, such as Java, and it has many benefits. With inheritance, programmers can reuse code and extend the function of existing code with minimum impact. This article discusses why inheritance didn't meet the design challenge for some of the Go-ForIt project, and the authors explain an alternative solution that was easier to implement and maintain.

Part 10: Using custom finder methods to retrieve different result sets
October, 2001
Container-managed Enterprise JavaBeans (EJB) components are used in the Java world to represent real entities stored in databases. Finder methods allow applications to work with the EJB container to properly retrieve the data from the databases and instantiate the corresponding entity EJB components. This article explains what custom finders do and shows how to use them in several examples.

Part 11: Testing enterprise components without interrupting the production server
November, 2001
Balu Ramachandran discusses how the team used the IBM WebSphere Test Environment to test Enterprise JavaBeans (EJB) components and servlets developed with VisualAge for Java's Integrated Development Environment (IDE). This article explains how you can test the code developed with VisualAge for Java using the WebSphere Test Environment and then deploy the code to the production server.

Part 12: Lay it on the line -- command line tools for WebSphere Application Server
November, 2001
Balu Ramachandran discusses two command line tools that deploy application components on the WebSphere Application Server. The tools, WebSphere Control Program (WSCP) and XML Config, are an alternative to the GUI administration console and allow flexibility when administering application components. With the command line tools you can administer Enterprise JavaBeans (EJB) components, servlets, data sources, JDBC API drivers, application servers, and more. He also shows you how to write scripts to automatically execute tasks.

Part 13: Using command patterns to enhance performance
December, 2001
Sandeep Desai and Venkat Nagalla describe how the team leverages the command framework for big performance benefits. They discuss the architectural and design issues that prompted the team to choose command beans, and include sample code showing the application design.

Part 14: Unit testing with Junit
January, 2002
Willy Farrell describes how the team used the JUnit framework within VisualAge for Java to unit test the Java classes, including Enterprise JavaBeans (EJB) components, for the Go-ForIt project. This article gives a brief overview of the JUnit framework, describes the team's overall unit testing strategy, and discusses testing considerations for EJBs.

Part 15: Payment processing with IBM WebSphere Commerce products
February, 2002
Indran Naick and Reema Gupta describe the IBM WebSphere Payment Manager and how they integrated it with the Go-ForIt application using Simple Object Access Protocol (SOAP). Collecting payments is a critical part of doing business on the Web, and this article includes several code samples showing how it can be done.

Part 16: Clean preparations with SOAP and WebSphere Payment Manager
March, 2002
Indran Naick and Reema Gupta describe how they prepared the application to collect payments from customers. They describe the runtime architecture of Go-ForIt.com and setting up the IBM WebSphere Payment Manager. They also discuss the Simple Object Access Protocol (SOAP) server environment, the SOAP client, and some security implications.

Part 17: Movin' on up: Migrating from WebSphere Application Server Version 3.5.4 to Version 4.0
April, 2002
Sandeep Desai describes how the team migrated the Go-ForIt application from WebSphere Application Server Advance Edition Version 3.5.4 to Version 4.0. He discusses the new deployment option in WebSphere Application Server Version 4.0, and packaging differences between Versions 4.0 and 3.5.4. The article also covers various tools the team used.

Part 18: Improving availability by clustering WebSphere Application Server Version 4.0
May, 2002
Rohit Sahasrabudhe and Balu Ramachandran describe how they deployed Go-ForIt to a clustered environment. The GoForIt project has been up and running for some time now, and clustering becomes significant during the production stage of a project. Adding clustering to Go-ForIt makes the project more scalable and available for customers. This article describes, with many detailed instructions, how to bundle an application and deploy it to a clustered environment built with WebSphere Application Server 4.0.

Part 19: Go-ForIt Chronicles: Struttin' your stuff with WebSphere Studio
September, 2002
Learn how to develop a Struts-based application using the new WebSphere Studio Application Developer IDE. This tutorial, written by IBM e-business architect and dragonslayer David Carew, is based on his experience rewriting the dragonslayers' Go-ForIt application with Struts using Application Developer.

Part 20: Go-ForIt Chronicles: Struttin' your stuff with WebSphere Studio Application Developer
November, 2002
In this tutorial, a follow-on to Part 19, David Carew focuses on the use of the Tiles templating framework in conjunction with Struts using the WebSphere Studio Application Developer as the development environment.

Hungry for more dragons? The second series in our chronicle takes the Go-ForIt project beyond the WebSphere domain and into the realm of Web services, data management, Lotus, Tivoli, and Linux.