The Road to Performance Is Littered with Dirty Code Bombs

From WikiContent

(Difference between revisions)
Jump to: navigation, search
Line 1: Line 1:
-
Performance problems are a direct results of how you coded your application to use the available hardware. While one can sometimes solve the problem by adding more hardware, quite often the best or only solution is to alter code. By starting down that path you've just agreed to take on all the risk that comes when you start to change code. Furthermore, the quality of the code will have an inverse affect on your ability to estimate how long it will take to finish the recoding.
+
Performance problems are a direct result of how you coded your application to use the available hardware. While one can sometimes solve the problem by adding more hardware, quite often the best or only solution is to alter code. By starting down that path you've just agreed to take on all the risk that comes when you start to change code. Furthermore, the quality of the code will have an inverse affect on your ability to estimate how long it will take to finish the recoding.
Take the case where you find an execution hotspot in the application. You then proceed to reduce the strength of the underlying algorithm and in the process you break some a dependent part. You then are required to fix the dependency. If in that process of fixing the dependency you happen to break one or more other dependent parts, once again you will be forced to fix those also. While you may have accounted for some of the dependencies, if the code is highly coupled you may have missed a few which will result in an under-estimation of the amount of work needed to get the job done. In this case we have a clear definition for loose coupling and a dependency. So why can't we have a tool count the violations and report back to us? Such a count should help us understand our risk to schedule.
Take the case where you find an execution hotspot in the application. You then proceed to reduce the strength of the underlying algorithm and in the process you break some a dependent part. You then are required to fix the dependency. If in that process of fixing the dependency you happen to break one or more other dependent parts, once again you will be forced to fix those also. While you may have accounted for some of the dependencies, if the code is highly coupled you may have missed a few which will result in an under-estimation of the amount of work needed to get the job done. In this case we have a clear definition for loose coupling and a dependency. So why can't we have a tool count the violations and report back to us? Such a count should help us understand our risk to schedule.

Revision as of 13:24, 14 October 2008

Performance problems are a direct result of how you coded your application to use the available hardware. While one can sometimes solve the problem by adding more hardware, quite often the best or only solution is to alter code. By starting down that path you've just agreed to take on all the risk that comes when you start to change code. Furthermore, the quality of the code will have an inverse affect on your ability to estimate how long it will take to finish the recoding.

Take the case where you find an execution hotspot in the application. You then proceed to reduce the strength of the underlying algorithm and in the process you break some a dependent part. You then are required to fix the dependency. If in that process of fixing the dependency you happen to break one or more other dependent parts, once again you will be forced to fix those also. While you may have accounted for some of the dependencies, if the code is highly coupled you may have missed a few which will result in an under-estimation of the amount of work needed to get the job done. In this case we have a clear definition for loose coupling and a dependency. So why can't we have a tool count the violations and report back to us? Such a count should help us understand our risk to schedule.

In fact we have many ways of measuring the degree and depth of couplings in an application. Included in the list are Law of Demeter, Coupling between Objects (CBO), fan in, fan out, efferent and afferent couplings, depth of hierarchy and so on. These metrics describe features in our code that we can enumerate using a metrics tool. With a little experience, we can infer code quality by inspecting the magnitude of the counts. Consider fan out for example. Fan out is defined as the number of classes that is dependent upon a class of interest. Think of it as a count of the number of classes that require the class of interest to be compiled before it can be compiled. That number represents the fan out value for the class of interest. If for every class in an application this value is small, you'd conclude that the application was loosely coupled. The upside is that I can refactor with minimal risk that my breakages will also fan out.

Though the discussion has focused on measuring couplings, it could have easily focused on complexity, vocabulary and volume, cohesion and a host of other metrics. Each of these metrics is a measure of code quality and hence a way to determine risk to schedule should you have to touch the code.

We all believe that we write good code. That said, the truth is as close as a good metrics tool. And if you don’t like what the metrics tool is telling you, try a good dose of Uncle Bob’s book, Clean Code.


By Kirk Pepperdine

This work is licensed under a Creative Commons Attribution 3


Back to 97 Things Every Programmer Should Know home page

Personal tools