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:

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