Using code smells to shape code evolution and robustness in large development efforts

As the complexity of software has increased, software development has evolved from being predominantly performed by small groups of collocated developers to large groups of geographically distributed developers. To successfully work on complex and distributed projects, developers need to continuously discuss design decisions and the complexities associated with ever-evolving requirements or face increasing amounts of “technical debt” in the form of design decisions that don’t hold up and result in sub-optimal code. One measure of technical debt is code smell, a term used to describe bad design decisions in code, such as overly complex structures, poor compartmentalization of functionality, etc. Code smells have been associated with long-term maintainability problems, and have also been shown to negatively impact overall quality (buginess) of the software. Most of the previous research on code smells has focused on detecting and categorizing different smells. However, there is little research into how code smell could affect the collaborative development process or software quality. If code smells are not taken care of, they can effectively mask bugs, increase the time to find or fix bugs, and generally the time and effort needed to perform any future changes to the code. Though code smells are well-established in the academic literature, code smells are rarely used outside of academic circles. According to a study, 32% of software developers don’t know what code smells are, or how they can be used to evaluate code. My research is to investigate the relationship between code smells, bugs and code evaluation which in turn can be used by collaborative software development teams to make better design decisions and write better code.

Major Advisor: Carlos Jensen
Committee: Margaret Burnett
Committee: Anita Sarma
Committee: Arash Termehchy
GCR: Margaret L Niess