I've been poking around in a lot of gems lately and I found this beauty (I added the 1 to the name for obvious reasons below):
def load_tags1()
x = Array.new() # Group and Element ID
y = Array.new() # Value representation
z = Array.new() # Name
# E.1 Registry of DICOM command elements
# Group 0000
x+=["0000,0000"] and y+=[["UL"]] and z+=["Command Group Length"]
x+=["0000,0001"] and y+=[["UL"]] and z+=["Length to End"] # RET
x+=["0000,0002"] and y+=[["UI"]] and z+=["Affected SOP Class UID"]
x+=["0000,0003"] and y+=[["UI"]] and z+=["Requested SOP Class UID"]
x+=["0000,0010"] and y+=[["CS"]] and z+=["Recognition Code"] # RET
# ... 2500 more lines like the above
# Return the array information:
return [x,y,z]
end
This one method flogs at an astounding 15538! As a comparison, my entire perforce repository flogs at 37391. The next highest method I've found flogged at 3685.
What's wrong with this code? Well, for starters, it flogs to 15k for a reason. That's a LOT of code and almost all of it need not exist to begin with. A very quick analysis shows that NONE of the and logic needs to exist. Those could be semicolons. Further, this is really all static data and the method returns the 3 columns... So why not treat them as columns and be done with the 3 variables? Here was my quick 1 minute rewrite (no, really):
def load_tags2()
# E.1 Registry of DICOM command elements
# Group 0000
[["0000,0000", ["UL"], "Command Group Length"],
["0000,0001", ["UL"], "Length to End"],
["0000,0002", ["UI"], "Affected SOP Class UID"],
["0000,0003", ["UI"], "Requested SOP Class UID"],
["0000,0010", ["CS"], "Recognition Code"],
# ... 2500 more lines like the above
].transpose
end
This returns exactly the same data. What does that flog to? 1. That's right, one. Why? Because there is a total of 1 method calls throughout the whole thing. The rest is all static data.
And my final rewrite:
def load_tags3()
TAGS
end
Just realizes that the whole thing is static/constant so you should treat it as such. This probably flogs at less than one. I didn't bother figuring out because once you go from 15k to 1 the rest is cake.
The real important part is this: Flog scores mean something real. In this case, flog complexity not only translates to "hard to test", it also means "hard to run":
% ./quick.rb 1000
# of iterations = 1000
user system total real
null_time 0.000000 0.000000 0.000000 ( 0.000152)
load_tags1 61.910000 0.340000 62.250000 ( 62.716426)
load_tags2 3.540000 0.020000 3.560000 ( 3.575550)
load_tags3 0.000000 0.000000 0.000000 ( 0.000504)
load_tags1 is 17.5x slower that load_tags2, which is in turn 3580x slower than load_tags3.
It pays to flog.
