Changing Software and Legacy Code

The old adage, "If it ain't broke, don't fix it," doesn't necessarily apply in the case of technology. Projects continually require alterations, updates, and enhancements. This chapter outlines the nature of code change, and suggests some of the challenges to be faced when making these changes.

This chapter is from the book

This chapter is from the book

Changing code is great. It's what we do for a living. But there are ways of changing code that make life difficult, and there
are ways that make it much easier. In the industry, we haven't spoken about that much. The closest we've gotten is the literature
on refactoring. I think we can broaden the discussion a bit and talk about how to deal with code in the thorniest of situations.
To do that, we have to dig deeper into the mechanics of change.

Four Reasons to Change Software

For simplicity's sake, let's look at four primary reasons to change software.

Adding a feature

Fixing a bug

Improving the design

Optimizing resource usage

Adding Features and Fixing Bugs

Adding a feature seems like the most straightforward type of change to make. The software behaves one way, and users say that
the system needs to do something else also.

Suppose that we are working on a web-based application, and a manager tells us that she wants the company logo moved from
the left side of a page to the right side. We talk to her about it and discover it isn't quite so simple. She wants to move
the logo, but she wants other changes, too. She'd like to make it animated for the next release. Is this fixing a bug or adding
a new feature? It depends on your point of view. From the point of view of the customer, she is definitely asking us to fix
a problem. Maybe she saw the site and attended a meeting with people in her department, and they decided to change the logo
placement and ask for a bit more functionality. From a developer's point of view, the change could be seen as a completely
new feature. "If they just stopped changing their minds, we'd be done by now." But in some organizations the logo move is
seen as just a bug fix, regardless of the fact that the team is going to have to do a lot of fresh work.

It is tempting to say that all of this is just subjective. You see it as a bug fix, and I see it as a feature, and that's
the end of it. Sadly, though, in many organizations, bug fixes and features have to be tracked and accounted for separately
because of contracts or quality initiatives. At the people level, we can go back and forth endlessly about whether we are
adding features or fixing bugs, but it is all just changing code and other artifacts. Unfortunately, this talk about bug-fixing
and feature addition masks something that is much more important to us technically: behavioral change. There is a big difference
between adding new behavior and changing old behavior.

Behavior is the most important thing about software. It is what users depend on. Users like it when we add behavior (provided
it is what they really wanted), but if we change or remove behavior they depend on (introduce bugs), they stop trusting us.

In the company logo example, are we adding behavior? Yes. After the change, the system will display a logo on the right side
of the page. Are we getting rid of any behavior? Yes, there won't be a logo on the left side.

Let's look at a harder case. Suppose that a customer wants to add a logo to the right side of a page, but there wasn't one
on the left side to start with. Yes, we are adding behavior, but are we removing any? Was anything rendered in the place where
the logo is about to be rendered?

Are we changing behavior, adding it, or both?

It turns out that, for us, we can draw a distinction that is more useful to us as programmers. If we have to modify code (and
HTML kind of counts as code), we could be changing behavior. If we are only adding code and calling it, we are often adding
behavior. Let's look at another example. Here is a method on a Java class:

When we added that method, did we add new behavior to our application or change it? The answer is: neither. Adding a method
doesn't change behavior unless the method is called somehow.

Let's make another code change. Let's put a new button on the user interface for the CD player. The button lets users replace
track listings. With that move, we're adding the behavior we specified in replaceTrackListing method, but we're also subtly changing behavior. The UI will render differently with that new button. Chances are, the UI
will take about a microsecond longer to display. It seems nearly impossible to add behavior without changing it to some degree.

Improving Design

Design improvement is a different kind of software change. When we want to alter software's structure to make it more maintainable,
generally we want to keep its behavior intact also. When we drop behavior in that process, we often call that a bug. One of
the main reasons why many programmers don't attempt to improve design often is because it is relatively easy to lose behavior
or create bad behavior in the process of doing it.

The act of improving design without changing its behavior is called refactoring. The idea behind refactoring is that we can make software more maintainable without changing behavior if we write tests to
make sure that existing behavior doesn't change and take small steps to verify that all along the process. People have been
cleaning up code in systems for years, but only in the last few years has refactoring taken off. Refactoring differs from
general cleanup in that we aren't just doing low-risk things such as reformatting source code, or invasive and risky things
such as rewriting chunks of it. Instead, we are making a series of small structural modifications, supported by tests to make
the code easier to change. The key thing about refactoring from a change point of view is that there aren't supposed to be
any functional changes when you refactor (although behavior can change somewhat because the structural changes that you make
can alter performance, for better or worse).

Optimization

Optimization is like refactoring, but when we do it, we have a different goal. With both refactoring and optimization, we
say, "We're going to keep functionality exactly the same when we make changes, but we are going to change something else."
In refactoring, the "something else" is program structure; we want to make it easier to maintain. In optimization, the "something
else" is some resource used by the program, usually time or memory.

Putting It All Together

It might seem strange that refactoring and optimization are kind of similar. They seem much closer to each other than adding
features or fixing bugs. But is this really true? The thing that is common between refactoring and optimization is that we
hold functionality invariant while we let something else change.

In general, three different things can change when we do work in a system: structure, functionality, and resource usage.

Let's look at what usually changes and what stays more or less the same when we make four different kinds of changes (yes,
often all three change, but let's look at what is typical):

Adding a Feature

Fixing a Bug

Refactoring

Optimizing

Structure

Changes

Changes

Changes



Functionality

Changes

Changes





Resource Usage







Changes

Superficially, refactoring and optimization do look very similar. They hold functionality invariant. But what happens when
we account for new functionality separately? When we add a feature often we are adding new functionality, but without changing
existing functionality.

Adding a Feature

Fixing a Bug

Refactoring

Optimizing

Structure

Changes

Changes

Changes



New Functionality

Changes







Functionality



Changes





Resource Usage







Changes

Adding features, refactoring, and optimizing all hold existing functionality invariant. In fact, if we scrutinize bug fixing,
yes, it does change functionality, but the changes are often very small compared to the amount of existing functionality that
is not altered.

Feature addition and bug fixing are very much like refactoring and optimization. In all four cases, we want to change some
functionality, some behavior, but we want to preserve much more (see Figure 1.1).

That's a nice view of what is supposed to happen when we make changes, but what does it mean for us practically? On the positive
side, it seems to tell us what we have to concentrate on. We have to make sure that the small number of things that we change
are changed correctly. On the negative side, well, that isn't the only thing we have to concentrate on. We have to figure
out how to preserve the rest of the behavior. Unfortunately, preserving it involves more than just leaving the code alone.
We have to know that the behavior isn't changing, and that can be tough. The amount of behavior that we have to preserve is
usually very large, but that isn't the big deal. The big deal is that we often don't know how much of that behavior is at
risk when we make our changes. If we knew, we could concentrate on that behavior and not care about the rest. Understanding
is the key thing that we need to make changes safely.

Preserving existing behavior is one of the largest challenges in software development. Even when we are changing primary features,
we often have very large areas of behavior that we have to preserve.