The process of large-scale software development and maintenance can be unpredictable, with high costs, and a bug-prone and fragile output at times. It is estimated that 90% of the total cost of a software project is spent on evolution and maintenance, causing some authors to call it the legacy crisis (such as ). Refactoring is widely believed to have a positive impact on these costs. Without refactoring the gain in development costs can be easily lost in the form of increased maintenance costs . Refactoring can also benefit development costs, as shown by eXtreme Programming  which also advocates relentless refactoring throughout a project’s life cycle in order to eliminate redundancy, remove unused functionality, and restructure obsolete designs. Refactoring also enables changes during the life cycle of a software system by updating its structure and design and is crucial to the success of a system.
Automated techniques have been proposed to either identify refactoring opportunities (i.e., code fragments that can, but have not yet been restructured in a program), or reconstruct historical refactoring (i.e., code restructuring operations that have happened between different versions of a program). However, it remains challenging to consistently apply those techniques to large code bases containing millions of lines of code involving many versions. Besides scale, the main challenge is that refactoring may change the syntactic shape of a program while preserving functional equivalence. One particularly complex change involves moving code fragments across function boundaries for refactorings such as Extract Method, Preserve Whole Object, etc. Detecting such changes accurately requires that a refactoring detection tool should possess knowledge about precise code change patterns induced by refactoring and should flexibly omit or emphasize specific program elements when computing similarity between two code fragments.
This research thesis aims at addressing this challenge. The thesis asserts that efficient and effective detection of code fragments related by refactoring operations within large software can be achieved by performing abstraction and algebraic operations over high-dimensional vectors representing the code, potentially leading to great saving in software maintenance costs. (Abstract shortened by UMI.)
|School:||National University of Singapore (Singapore)|
|School Location:||Republic of Singapore|
|Source:||DAI-B 77/06(E), Dissertation Abstracts International|
Copyright in each Dissertation and Thesis is retained by the author. All Rights Reserved
The supplemental file or files you are about to download were provided to ProQuest by the author as part of a
dissertation or thesis. The supplemental files are provided "AS IS" without warranty. ProQuest is not responsible for the
content, format or impact on the supplemental file(s) on our system. in some cases, the file type may be unknown or
may be a .exe file. We recommend caution as you open such files.
Copyright of the original materials contained in the supplemental file is retained by the author and your access to the
supplemental files is subject to the ProQuest Terms and Conditions of use.
Depending on the size of the file(s) you are downloading, the system may take some time to download them. Please be