SPA Conference session: Learning to See the Value of Legacy Software Using Value Stream Mapping | |||
| One-line description: | The application of the Lean tool Value Stream Mapping to legacy software , based on the principles of Micheal A Jackson. | ||
| Session format: | Tutorial [read about the different session types] | ||
| Abstract: | In this session we will be looking at how the Lean tool Value-Stream Mapping can be applied for transforming legacy software. Software is eating the world, but what about the ghosts of software past? Are those companies haunted by legacy cursed to fail? Powerless against the hungry onslaught of digital-first starts-ups? Normally legacy is seen as a good thing. Why is it that in software Legacy is always seen as bad? Does the past really have nothing of value? Lean emerged from the challenges of post-industrial manufacturing. It is based on fixing broken processes from a previous era. It has proven its ability to transform factories from the worst to best performing. How can we adapt Lean tools to do the same for our legacy systems. Drawing heavily on the work of M A Jackson, we will look at seven principles that will help us to adapt value-stream mapping into a tool that we can use to see the flow of value between the software in the machine and the real world. 1. Software IS A factory 2. Software and environment together satisfy requirements ( S E ⊢ R ) 3. Legacy software is software that delivers Value 4. Software is only sustainable if it delivers value to all stake holders 5. Software delivers Value by solving problems 6. Software is composed from sequential processes 7. Value stream mapping for software is Jackson System Development in reverse | ||
| Audience background: | The tutorial will require basic programming abilities. Knowledge of Java is useful, but not essential. An awareness of Lean principles and knowledge of lean approaches such as Kanban will be useful, but not essential. | ||
| Benefits of participating: | Participants will learn a structured approach to reading code. These skills will prove to be invaluable for anybody that needs to quickly get to grips with a new code base. The use of value stream mapping also helps to understand not only how code works but, more importantly, how it delivers value. Seeing the flow of value through the code helps with prioritising tasks and identifying the critical constraints that must be addressed. They will also be introduced to the principles of some abstract theory within a practical setting, including Hoare's communicating sequential processes and Jackson's Problem Frames. Reading code effectively brings many benefits. Studies show that code inspection leads to a significant improvement in Software Quality [1] The following quotes highlight the importance of code reading as a skill: "I firmly believe that the reading of code should be both properly taught and used as a method for improving one's programming abilities." Diomidis D. Spinellis, Author of Code Reading: The Open Source Perspective "While architects study thousands of buildings in their training and during their careers, most software developers only ever get to know a handful of large programs well. And more often than not, those are programs they wrote themselves." Greg Wilson and Amy Brown in the Introduction to The Architecture of Open Source Applications [1] http://www.mfagan.com/pdfs/aisi1986.pdf [2] [3] http://www.spinellis.gr/codereading/preface.html [4] http://aosabook.org/en/intro1.html | ||
| Materials provided: | Participants will be provided with and early draft of a spiral bound work book inspired by the Lean Institutes "Learning to See" work book by Mike Rother and John Shook. [1] The workbook will present the principles described It will also describe a full Value Stream Map for the FIT framework. This will include the proposed solution to the take home exercise which is based on the JSP principle of Program Inversion. [1] http://www.lean.org/Bookstore/ProductDetails.cfm?SelectedProductId=9 | ||
| Process: | The session is divided into three acts: The Software Factory, The value of Legacy Software and Identifying Sequential Processes. Each act introduces two or three high level principles based on theory and practical examples. Each acts concludes with practical exercises to make use of the new principles introduced. Each of these exercises follows the format of breaking out into groups and then reconvening to discuss the results. Ward Cunningham's FIT testing framework is used an example of legacy code. This code is chosen because it is small enough to study while delivering clear value to multiple stakeholders. It is also a very well written piece of software that is a pleasure to read. [1] The session concludes by identifying a defect in the FIT framework and asking the participants to consider how it might be resolved using the principles introduced. This is left for them to complete in their own time. The proposed solution to the problem is included in the workbook that will be provided to all participants. [1] https://books.google.co.uk/books?id=gJrmszNHQV4C&printsec=frontcover#v=onepage&q&f=false | ||
| Detailed timetable: | Greetings and introduction. [5 minutes] Act One - The Software Factory [25 minutes] - 00:05 - 00:15 First and Second Principles - 00:15 - 00:30 Exercise Act Two - The Value of Legacy Software [40 minutes] - 00:30 - 00:45 Third, Fourth and Fifth Principles - 00:45 - 01:10 Exercise Break [5 minutes] Act Three - Identifying Sequential Processes [40 minutes] - 01:15 - 01:25 Sixth and Final Principles - 01:25 - 01:45 Exercise Take Home Exercise [5 minutes] - 01:45 - 01:50 FIT's Stack Overflow | ||
| Outputs: | Participants will be introduced to a new way of viewing legacy code. A workbook is provided that includes the concepts introduced in the tutorial and continues to introduce further concepts presented through a full Value Stream Map of the fit code base. | ||
| History: | This is the first presentation of this session. The ideas presented in the presentation have been used successfully for project rescues. | ||
| Presenters | |||
| 1. Ged Byrne Endava |
2. | 3. | |