Modernizing Legacy Systems: Software Technologies, Engineering Processes, and Business Practices 1st Edition

If you have ever had the task of migrating legacy code and data to a new system you know how complex that task can be. "Modernizing Legacy Systems" covers all the bases of migrating a legacy system in wonderful detail without being overly wordy or obscure. System and software engineers will recognize and appreciate the fact that this book bases its advice on real world experience - the kind you get only from working on complex projects.
A well-defined plan of migration is presented early on for a complex retail supply system migration. Each phase of the plan is presented and explained in detail - covering both management and development perspectives equally well. For those of us who spend our days in a developer's world, the additional information on managing the migration effort contributes the right mix of information for what we are tasked to accomplish. I appreciated the technical specifics that were included throughout (i.e., utilizing Enterprise Java Beans) so that I didn't need to use my imagination as to how this plan would fit into my current project. Everything you need to know about legacy migration and then some is covered in this book. I knew that when I started to agree with what I was reading (aka Been There Done That) and could relate what was in the book to my own experience that I had found a winner.
This book is a good read and a great reference guide to help you get through a large, complex legacy migration. When you finally finish the book, take another look to capture all the detail you missed on your first read-through.

This book describes the process and technologies involved in updating a legacy system. Chapters 1 through 4 do a very good job of describing the problems inherent in working with legacy systems, which the authors define simply as having "code that was written yesterday." I couldn't agree more with their perspective. Once code is written, it needs to be maintained, updated, and managed, whether it is COBOL, Fortran, PowerBuilder or Java; all code becomes legacy code once it is written.
Early in the book, the authors present a Unified Modeling Language (UML) activity diagram to describe their proposed process for updating legacy systems. They then open each chapter by depicting where they are in the process -- from Portfolio analysis completed (modernization candidates selected) to Modernization plan defined. The book defines ten main steps and two checkpoints for completing this process, including decision points to determine whether modernization is the correct choice.
To describe the process in detail, the authors follow a legacy system modernization project over the course of the book. As process experts from the Software Engineering Institute (SEI), they consulted on this project, which was to update and Web-enable a primarily COBOL retail supply system. The case study helps readers understand the flow of the process the authors recommend and brings reality to their suggestions, although at times they abandon the "story" and go into overly minute detail, discussing every process option they could have chosen. I would have liked them to focus more deeply on the option they did choose, and to discuss at greater length how to be successful with that option (or any other). A good example of this is the discussion in Chapter 4 around requirements. The authors do a good job of describing where to get requirements from, but never discuss good processes and techniques for gathering those requirements. In most situations I have been involved in around requirements, knowing where to go wasn't much of a challenge, but knowing how to elicit them was.
The book does a good job of describing the different technologies the project used as well as others available for modernization efforts -- Java/J2EE, Web Services, wrapper code, and different packaged systems -- providing an overview of each technology as well as customized ways to write integrations from the legacy systems to modern ones. They discuss screen scrape technologies as well as screen rewrites, but focus mainly on modernizing the software. This was a little disappointing: Based on the title, I expected to see discussions of all the hardware, software, development processes and additional technologies involved in modernizing systems.
Overall, however, I learned a lot from the book, and it confirmed many of my beliefs about the importance of modernizing legacy systems and the best approaches to use. The authors provided good strategies for understanding systems that are already in place starting with the workflow they follow throughout the book. They then go into examples which include modeling, requirements management and the process they followed. What was a bit lacking is the actual process for implementation. The book focuses primarily on understanding what you have, designing for change, and planning how to get where you want to go, but it doesn't go far enough into what you actually have to do to get there. I would recommend this book for people who need a better understanding of the processes and technology decisions you must make made when building software systems. For most of us in the industry, no matter what we are working on, there's probably a legacy system involved in some way.

Addressing a timely and vital topic, 'Modernizing Legacy Systems' is an excellent book from the standpoints of both content and presentation. The advocated approach, which is termed the Risk-Managed Modernization (RMM) Approach, is synopsized on page 28 in UML activity diagram form. The exposition in the subsequent chapters is keyed to corresponding activities in this diagram. This key makes it quite easy to situate and interrelate the coverage of the respective chapters in the context of the RMM Approach. I found this recurring orientation feature to be very helpful in understanding and integrating the book's content.
The book describes, rationalizes, and selectively illustrates the RMM Approach, where the continued availability of the legacy system capabilities is necessary over the sequence of modernization increments. While the approach is illustrated through an incremental transformation of a legacy COBOL-based system to a Java-based derivative, the RMM Approach is nevertheless applicable to other modernization problems or technologies. Moreover, the book does an exceptionally good job of interweaving explanations with examples. These examples are modest but salient and revealing, thereby avoiding unwarranted detail or distractions.
The advocated approach is at once both architecture-centric and component-centric. Architecture centricity captures and sustains a rather specific vision of the as-desired system, and the associated target architecture provides a stable reference over the various modernization activities. Component centricity enables the identification, analysis, grouping, and ultimate realization of system elements that are allocated to the respective modernization increments. Overall then, the target architecture establishes the initial and termination points of a modernization project, and the componentization installments determine the actual redevelopment trajectory connecting the project end points.
For me, the most intriguing, innovative, and vital parts of the approach appear under the RMM activities labeled Define Modernization Strategy and Reconcile Strategy with Stakeholder Needs (Chapters 13-15 and Chapter 16, respectively). Basically, the modernization strategy provides a systematic approach to delineating, analyzing, and grouping modernization elements through an examination of the legacy system implementation, subject to project constraints and certain prior higher-level technical decisions. Then, the finalization of element groupings into sequential increments is determined using programmatic preferences of the various stakeholders. This two-stage definition of modernization increments is driven prominently by cost and risk considerations, as well as by programmatic and technical factors. Ultimately, the designated increments establish waypoints on the aforementioned redevelopment trajectory, thereby identifying interim architectural configurations that facilitate closure on the target architecture, while simultaneously maintaining user capabilities during the modernization effort.
In all, 'Modernizing Legacy Systems' is a readable, coherent, illuminating, and surprisingly broad treatment of a vital topic. Hopefully, the RMM Approach or variants thereof will see widespread use in industry, thereby exploiting "a systematic and fact-based method that avoids arbitrary, intuitive decision making..."