Skip to main content

5 Tips For Refactoring In Brownfield Land

1. Don't try and refactor on the branch / clone you are working on

Whilst doing some of the everyday work, I couldn't help breaking into a refactor mission the problem is that refactor missions always take you down deeper than expected. You still need to get the other jobs done and other bugs may come up too. This has caught me out so many times when I just think I will do a little fix here or there. Be patient, you don't need to do the re-factor straight away.

2. Plan the refactor with clear objectives

Ugh, another of my favourites. When starting my current refactoring mission, I was like an ape in the produce section of Asda. My code was highlighted in blue Resharper squiggles and I could see duplication everywhere. Now I have calmed down and grown a little wiser. I have begun making a list of objectives and sections that I plan to refactor. Make a list of what each section of code does, if you have an appropriate tool that you can tag it with then do that. You can then approach sections together like "Front end refactoring" you could also make estimates on how long it could take. For example the list could be like:

  • Making a note of functionality so it can be rearranged and grouped together.
  • Removing in-line CSS from elements.
  • Refactoring JavaScript on pages.
  • Extracting interfaces on service or task classes then implementing an IoC Container.

 

3. Write tests around the functionality. Make sure you aren't breaking things.

This can be hard unless you do some of the refactoring first. Once you have extracted some of the external classes to interfaces and you can squirt test cases in, you can start testing the real behaviour of the class and how it should react. Document this correctly and give the test behavioural names like;

Namespace: GivenAnApartmentsRentIsDue

Class: WhenTheReminderIsSent

Method: ThenTheCorrectReminderDateIsSet

Method: TheCorrectAddressIsSet

When you have a lot of behaviour tests, providing you have grouped your tests together well, you really get a feel for the functionality of the system.

4. Don't moan about the code that's there. It will annoy the people you are working with.

Yes the code is crap, yes you are busy because every job takes 10 times longer than it should and only Ming the Merciless himself would devise such a cruel way retrieve users from the database. But you have been that person before; normally things get muddy because of a mixture of uncertainty, lack of details, and lack of time, no training and money. There are all sorts of reasons, but if you moan all the time about them you will just annoy / alienate people and it creates a crappy negative feeling in the team.

5. Create a baseline of functionality and performance before you refactor.

Users get really angry if you make things worse. It only takes one or two users to notice poor performance and the word will spread. It can really shake confidence in your software. If needs be and the changes are big enough (especially if there are front end usability changes), create an acceptance site for users to try out and ensure that the interactions on it are logged (anonymously perhaps) so that you can get an idea if people really have tried it out.

Summary

Hope that helps / confirms what you already know :-)

Comments

Popular posts from this blog

Creating star ratings in HTML and Javascript

I'd searched around a little for some shortcuts to help in doing this but I couldn't find anything satisfactory that included the ability to pull the rating off again for saving. I'd ended up coming up with this rather cheeky solution. Hopefully it helps you too! This is my first post in a while (I stopped blogging properly about 8 years ago!) It's strange coming back to it. Blogger feels very crusty and old by todays standards too.

Make your objects immutable by default

More about the Good Dojo In my post last week , I discussed creating objects that are instantiated safely. Please go back and read if you are interested. At the end of the post, I mentioned that I'd also written the class so it was immutable when instantiated. This is important!!! I feel like a broken record in repeating this but I am sure at the time of writing your code, you aren't modifying your object all over the place and so are safe in the belief that protecting against mutability is overkill. Please remember though, your code could be around for a hell of a long time. You aren't writing your code for now... you are writing for the next fool that comes along (including you) . Nothing is more upsetting that coming back to fix a bug on some wonderfully crafted code to say "Who has butchered my code?!", but often you were involved at the start of the process. You made the code easy to modify, allowing objects to be used / reused / modified without thi

An instantiated object should be "ok"

I've been QA'ing quite a bit of work recently and one common theme I've noticed across both Java and C# projects I have been looking at is that we occasionally open ourselves up unessacarily to Exceptions by the way objects are being created. My general rule of thumb (which I have seen mentioned in a Pluralsight video recently but also always re-iterate in various Robust Software talks I have done) is that you shouldn't be able to create an object and then call a method or access a property that then throws an exception. At worst, it should return null (I'm not going to moan about that now). I've created an example below. We have two Dojos, one is good and one is bad. The bad dojo looks very familiar though. It's a little class written in the style that seems often encouraged. In fact, many classes start life as something like this. Then as years go on, you and other colleagues add more features to the class and it's instantiation becomes a second