Question

i have a bit of code that i wrote a few weeks ago (the code’s purpose isn’t so much important as its structure):

if (_image.Empty)
{
   //Use the true image size if they haven't specified a custom size
   if (_glyphSize.Width > 0)
      imageSize.Width = _glyphSize.Width //override
   else
      imageSize.Width = _image.GetWidth;

   if (_glyphSize.Height > 0) then
      imageSize.Height = _glyphSize.Height
   else
      imageSize.Height = _image.GetHeight
}
else
{
   //No image, but they can still override it with a custom size
   if (_glyphSize.Width > 0) then
      imageSize.Width = _glyphSize.Width
   else
      imageSize.Width = 0;

   if (_glyphSize.Height > 0)
      imageSize.Height = _glyphSize.Height
   else
      imageSize.Height := 0;
}

i was going over it tonight, and as i was cleaning it up, i realized that the cleaned version is must more concise:

//Figure out the final image width
if (_glyphSize.Width > 0)
   imageSize.Width = _glyphSize.Width
else if (not _glyph.Empty)
   imageSize.Width = _glyph.GetWidth
else
   imageSize.Width = 0;

//Figure out the final image height
if (_glyphSize.Height > 0)
   imageSize.Height = _glyphSize.Height
else if (not _glyph.Empty)
   imageSize.Height = _glyph.GetHeight
else
   imageSize.Height = 0;

Note: i’ve trimmed down the code to bare logical flow, and obfsucated the source language.

In the end i took the nested if‘s, and inverted them. Doing that allowed this shortening. My question is: how can i recognize this in the future?

What are the tell-tale signs that i’ve just written some code that can be refactored into something shorter?

---

Another example i had from a few weeks ago was something akin to a permission check: the user can perform an action:

• if they have the permission they can do it
• if they don’t have the permission, but the override is in effect

Which i initially coded as:

if ((HasPermission || (!HasPermission and OverrideEnabled))
{
   ...do stuff
}

The logical conditions on that if clause seemed kind of wordy. i tried to reach back to my boolean algebra course to figure out how to simplify it. In the end i could do it, so i ended up drawing a truth table:

Permission  Override   Result
    0           0        0
    0           1        1
    1           0        1
    1           1        1

Which when i look at it is an OR operation. So my if statement became:

if (HasPermission  or OverrideEnabled)
{
   ...
}

Which is obvious and simple. And so now i’m wondering how i couldn’t see that to begin with.

---

Which brings me back to my SO question: What tell-tale signs could/should i be looking for in order to recognize that some block of code needs some TLC?

Answer 1

Here are some guidelines from Code Complete, off the top of my head. That is a good book to get for this sort of thing.

1. Nested if-else and repeated statements in blocks
2. Long for-loops
3. Repeated lines/statements or frequently used operations can be placed in a function
4. If for some reasons you are copying and pasting a line of code over and over again

I found discrete maths to have an influence in how I wrote if statements now. Usually, I see I am writing two same IF statements in 2 blocks, then I would do some mental ‘factoring’.