Legacy Code: Extract-FirstUT-Cover-Refactor-TDD

Facebook
Twitter
LinkedIn
Pinterest
WhatsApp

Recently, I had the opportunity to work on legacy code with several teams from various organizations. I would like to share my experience.

We usually start by choosing a piece of code that is “painful”: changing frequently and “scary” to touch because of its complexity. We explain that our purpose is to make the code simpler, readable, and easy to change. Establishing the motivation for what we do is important!

In essence, the steps we take are:

  1.       Use extract method/rename to make the code more readable (specifically applicable for very long methods).
  2.       Write and execute the first unit test (that’s usually the toughest part) as described by Michael Feathers.
  3.       Add more unit tests until the area you want to refactor is satisfactorily covered.
  4.       Refactor to make the code more maintainable (working in very small steps, as described by Joshua Kerievsky).
  5.       Make the required change using TDD.

The purpose of (1) is to see the forest, not the trees. Long methods tend to be unreadable. Using the “extract method” helps you see clearly what’s going on. Once you gain vision, you can start to rename. Arlo Belshee talks about this.

As an example, look at these two statements:

At the first, if statement, we have extracted the condition to a method. Remember that what you do most of the time with code is read it. You need to make it readable.

Item (2), as mentioned above, is the difficult part. You need both to master the technique and have the resolution to do it. I usually do it with the entire team and so, together, we have the required courage.

For instance, take a look at this behemoth method.

Pure fun, eh? This is something I call an amusement park method. We usually start by trying to call it null. Sometimes it actually works and we have a first-unit test. Then we start to slowly fill in the parameters. Maybe instead of a null send an empty dictionary. Maybe instead of an empty dictionary send a dictionary with two entries. And if there’s no choice sometimes we run the actual application and serialize the parameters, to be deserialized in the unit test later.

Sometimes we change a method from private to public, sometimes we add a method to better control a member, and there are more vicious things we do. Sometimes it can take a whole morning to do this. However, once you understand this, it becomes very simple.

Then you start looking at coverage.

Once you have the first test, things start to move faster (3). You start adding more and more tests. You start looking at coverage reports to see which lines of code are covered and which aren’t. If something is not covered, you can add another unit test to cover it.

Now (4) we can start to make bigger changes. Once you have the unit tests in place you feel free. You make a small change, you run the test. Another small step and the tests run again. Some IDEs have plug-ins that run the tests every time something is changed.

This is the time to get better familiar with the automatic refactoring tools of your IDE. Make sure you are familiar with introducing parameters, fields, and variables. Extract class is a very nice one and so is the ability to convert a method to static and move a method. The trick here is to make as fewer manual changes as possible and move the code around fluently.

Many times by this point, there is a small disappointment. The code you feared in the morning now looks quite simple. The real challenge is making the code simple and solving the puzzle.

Now we reached the point when we can quite easily add some code to fulfill a new requirement (5). We can add a new test, see it fail, make the required change, see it pass, and maybe do a little refactoring. Nothing like the joy of seeing unit tests turn from red to green.

(the above are unit tests from a very nice exercise called Gilded Rose)

And that’s it.

Subscribe for Email Updates:

Categories:

Tags:

Professional Scrum with Kanban
Professional Scrum Master
Tips
Principles of Lean-Agile Leadership
chatgpt
Product Ownership
Lean Agile Basics
Kanban
Reading List
Release Train Engineer
Agile Israel
An Appreciative Retrospective
Agile Testing Practices
Keith Sawyer
Webinar
Change Management
Video
Agile Product Development
Agile Basics
Covid19
Nexus and SAFe
Team Flow
Introduction to Test Driven Development
Kanban Game
Implementing SAFe
Lean and Agile Principles and Practices
LAB
GanttBan
Legacy Enterprise
SAFe
Agile and DevOps Journey
Sprint Iteration
Business Agility
Software Development
Applying Agile Methodology
Rovo
Scrum Guide
Lean Budgeting
Agile Assembly Architecture
Managing Risk on Agile Projects
RTE Role
Scrum Primer
Certified SAFe
NIT
Spotify
Continuous Deployment
Nexus Integration Team
System Archetypes
ARTs
Lean Risk Management
Entrepreneurial Operating System®
Scaled Agile Framework
Lean Software Development
speed @ scale
Scrum Master
Agile Risk Management
Agile Exercises
Agile for Embedded Systems
Agile Project
Lean and Agile Techniques
Continuous Improvement
SA
Agile Contracts Best Practices
Accelerate Value Delivery At Scale
Risk Management on Agile Projects
Agile Israel Events
Kaizen Workshop
Continuous Delivery
Manage Budget Creation
Daily Scrum
Systems Thinking
Games and Exercises
Process Improvement
Jira admin
Lean Startup
Agile India
ScrumMaster Tales
Professional Scrum Product Owner
Development Value Streams
Presentation
Pomodoro Technique
speed at scale
agileisrael
Code
QA
lean agile change management
LPM
Scrum
LeSS
Advanced Roadmaps
Agile in the Enterprise
Continuous Integration
Slides
System Team
ALM Tools
Sprint Planning
Agile Release Planning
Agile Techniques
Tools
AgileSparks
Planning
RSA
The Agile Coach
Lean Agile
Agile Product Ownership
Lean Agile Management
Implementation of Lean and Agile
Agile Delivery
Sprint Retrospectives
Agile Project Management
Frameworks
Coaching Agile Teams
Jira
Story Slicing
Acceptance Test-Driven Development
Nexus vs SAFe
Test Driven Development
EOS®
Agile Development
Risk-aware Product Development
WIP
Operational Value Stream
Lean Agile Leadership
Introduction to ATDD
Built-In Quality
Confluence
SAFe Release Planning
Achieve Business Agility
Hybrid Work
Amdocs
ROI
Agile Marketing
transformation
Kanban 101
Limiting Work in Progress
Agile
Agile Community
Effective Agile Retrospectives
Agile Program
Certification
Risk Management in Kanban
PI Objectives
Scrum Master Role
Kanban Kickstart Example
Lean-Agile Budgeting
Rapid RTC
What Is Kanban
Enterprise DevOps
AI Artificial Intelligence
Atlaassian
Product Management
Legacy Code
Kanban Basics
Artificial Intelligence
Perfection Game
Jira Cloud
AI
ART Success
Scrum and XP
Quality Assurance
Nexus and Kanban
Continuous Planning
BDD
Large Scale Scrum
POPM
TDD
Atlassian
Lean-Agile Software Development
Agile Release Management
Software Development Estimation
Portfolio for Jira
Scrum With Kanban
SAFe DevOps
A Kanban System for Software Engineering
Elastic Leadership
Nexus
DevOps
Program Increment
Iterative Incremental Development
Scrum.org
Managing Projects
Agile Games
Releases Using Lean
SPC
Self-organization
PI Planning
Scrum Values
Lean Agile Organization
ATDD vs. BDD
Retrospectives
Agile Mindset
Engineering Practices
RTE
Kaizen
ATDD
Value Streams
System Integration Environments
predictability
User stories
Agile Games and Exercises
Agile Outsourcing
IT Operations
Agility
The Kanban Method
AgileSparks
Logo
Enable registration in settings - general

Contact Us

Request for additional information and prices

AgileSparks Newsletter

Subscribe to our newsletter, and stay updated on the latest Agile news and events

This website uses Cookies to provide a better experience
Shopping cart