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

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

Accessing the UI Thread with Tasks in F#

I have a Windows Forms program written in F# that can deploy a code base to n number of sites at once (you select the sites you would like to deploy to and it goes off and completes a number of tasks (backing up current sites, various unpacking and moving of files etc... ). Once you start it, it begins it's merry journey and begins to update the UI with what has happened. At the moment this method of updating the UI is not pretty because the threads I am doing the work on can't update the UI so I perform some fiendery to make that happen (don't ask). I knew there was a better way using some newer .NET features but I just hadn't got round to having a fiddle yet. I have now found that if you use the built in Task class but break your code up in a nicer way and then chain the tasks together you can then pass the correct context into the task that you want to talk to the UI. Here's a little script to give you a feel for it. You can press the "start" butt

NESTA - Next Gen.

via nesta.org.uk Following on from an article on the BBC about Raspberry Pi, this next gen report has some interesting findings. The scariest stat which I picked out from the BBC website was "out of the 28,767 teachers who were awarded Qualified Teacher Status... in 2010, only three qualified in computing or computing science as their primary qualification" Having worked as a computer science teacher for a year in a school that was a specialist in Computing I can concur that the uptake in Comp Sci was woeful. 2 Students for A2... The other teachers backgrounds in Computer Science was also fairly woeful (most knowing a bit about Office but still a paltry amount even about that). I couldn't speak for my counterpart that I was covering however. I suspect they were fairly up on things. All in all what kills me is that Computer science is not a secondary level subject. Areas are often covered, a little in IT, a little in DT subjects (if kids choose Systems and Contr