Search
Close this search box.
Search
Close this search box.
Search
Close this search box.

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:

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