Blog

Understanding the complexities of a legacy application requires a top-down, bottom-up approach. 

This is one of a series of blogs connecting the principles described in the Use Case 2.0 eBook to agile legacy modernization.  The principles are:

1. Keep it simple by telling stories
2. Understand the big picture
3. Focus on value
4. Build the system in slices
5. Deliver the system in increments
6. Adapt to meet the team’s needs

Although written with greenfield development in mind, Use Case 2.0 is easily adapted to the world of legacy modernization. We will walk through each of the principles described for application to legacy modernization.

This discussion is based on the following assumptions:

• you want to modernize your legacy application
• you want to retain essential business functionality, not start from scratch
• you’re interested in vendor-independent practices
• you’ve set the goal of reverse engineering a functional model

Capturing the functional behaviour of an application involves and bottom-up, top-down approach. This corresponds to the first two principles of Use Case 2.0:

1. Keep it simple by telling stories
2. Understand the big picture

Presented with the task of understanding a legacy application, it is easy to get lost in detail or miss the larger context. One of the ways to keep it simple, is to start with the most important legacy functionality, i.e. user stories. Begin by understanding user system roles. Examine user goals when using an application. Achieving a goal is the basis of a user story. Initially it is important to capture the main flow and avoid alternate possible flows, exceptions to achieving the goal. Interview stakeholders about how they use the system.  Start with stories key to the business. Add exceptions and alternate endings only in subsequent iterations to achieve a complete picture. Isolating individual stories is the beginning of an agile modernization practice.

 

Use case models define the scope and provide an overall view. But the initial, high-level view need not be complete, detailed or final. Early in the project it is enough to gain a high-level view that can be refined. After initial functional reviews, the use case model should include user interaction, batch functionality and system interfaces, in other words a complete functional overview.

 

One effective technique for an draft use case model is to assemble key system users for a white board session. Do this without access to the legacy application in order to avoid getting lost in detail. The techniques are similar to those used in greenfield development.  The actors you identify will have goals when using the system.

Identifying stories in parallel with the use case helps us reverse engineer the functional model. Unlike some modernization approaches that overwhelm with detail, the approach here is separation of concerns and multiple views. As we look at the other ‘First Principles’ we will see how to use this model in the context of agile software modernization.

Image courtesy of Anthony Seebaran. Visit http://www.anthonyseebaran.com and http://www.istockphoto.com/awseebaran