Nine Causes of Performance Bugs and ways to attack them

Performance bugs leads to reduced throughput, increased latency and waste of resources. As compared to functional bugs, performance bugs hide in software for much longer time. There can be numerous causes for performance inefficiencies some of them are listed below:

1.     Poor algorithmic design
2.     Inefficient use of data structures
3.     Developers misunderstand the performance feature of certain functions
4.     Side-effects of functional bugs
5.     Inefficient synchronization among threads
6.     Uncoordinated Functions - function calls take a long routine to generate results
7.     A function call with unused results
8.     Wrong misconception that performance is taken care of by hardware and compilers alone 
9.     Wrong understanding of load or API performance features.

How can we attack the Performance Bugs:

1. Awareness of Performance aspects of software development
2. Following best practices in Specification -> Design -> Coding -> Testing
3. Developing Performance Models
4. Making use of Profiling Tools
5. Continuous Monitoring the Performance Tests
6. Identifying the root cause and performing root cause analysis
7. Correcting the problem
8. Testing both individual components & overall system
9. Experiments – Where does the time go, Does it really go there, Has new bug introduced

How performance Bugs are different from Functional bugs:

1. Performance bugs hides in system for long times and emerge from non buggy places
2. Performance bugs can be easily escaped even when buggy code is executed
3. Regression testing and change impact analysis should consider load changes and performance impact
4. It is misunderstood that performance sometimes needs to be sacrificed for better productivity and functional correctness.
5. We can achieve significant performance improvement through a change in few lines of code

Conclusion:

Performance bugs have been largely being ignored compared to functional defects. Early detection of causes of performance bugs and fixing them by following best practices can result in better understanding of performance bugs throughout software development lifecycle and lead to increased  throughput, decreased latency and optimised and efficient use of resources throughout the software systems.