Abstract: Software reuse typically involves components specifically designed for reuse; ideally, these components should provide the exact functionality that a developer requires and fit within their system without structural or behavioural mismatch. When either of these conditions are not met, developers have the opportunity to investigate pragmatic software reuse approaches. In these situations, the software being reused may not have been designed specifically for reuse, or may not be a precise match for their desired functionality, but the developer could greatly reduce the time and cost of their software development by adapting existing source code, rather than developing similar software from scratch. To perform a pragmatic reuse task, developers must extract some portion of source code from an existing system, modify it to suit their needs, and integrate it into their own system.

Through interviews with industrial developers, I found that the majority of them have performed such pragmatic reuse tasks. My doctoral dissertation investigated new techniques to help developers to understand, to plan, and to execute pragmatic reuse tasks. The dissertation addressed three primary questions: (1) Is there a lightweight mechanism that developers can use to create a reuse plan? (2) Can tools use these plans to automatically carry out the reuse task? (3) Will supporting these tasks improve developer performance compared to the current state-of-the-art? To investigate these research questions in depth, I created the Gilligan pragmatic-reuse environment. Using Gilligan, developers were able to locate twice as many relevant program elements compared to traditional approaches; they needed to resolve 98% fewer compilation errors; and they took significantly less time to perform their pragmatic reuse tasks. Most interestingly, they were much more likely to successfully complete a pragmatic reuse task; this is encouraging due to the huge productivity and quality gains that can be realized through reusing tested code, rather than starting from scratch.

Short Bio: Reid Holmes is a Postdoctoral Fellow at the Department of Computer Science and Engineering at the University of Washington. His interests include understanding the cognitive aspects of software engineering, software reuse, example recommendation systems, and longitudinal dynamic analyses. He has published articles in top-tier publications including the International Conference on Software Engineering (ICSE) and IEEE Transactions on Software Engineering (TSE). Amongst other awards, he has won a Distinguished Paper Award at ICSE and a prestigious NSERC Postdoctoral Fellowship. His doctoral dissertation investigated pragmatic reuse, a new approach for software reuse, that aims to address some of the shortcomings of traditional reuse approaches. He received his Ph.D. at the University of Calgary, advised by Robert J. Walker, in 2008. He received his M.Sc. at the University of British Columbia, advised by Gail C. Murphy, in 2004.