Constructing software bears many similarities to constructing buildings. In a building project, each floor builds on the previous structures (walls of the previous floors) with some structures being more foundational (i.e. essential) for other structures and some periods of construction being more foundational (i.e. critical) to the final structure. In a software project, each change builds on the structures created by prior changes with some changes creating foundational structure and with some time periods of changes being more foundational than others. This thesis is inspired by this similarity between constructing buildings and constructing software. The thesis makes use of the similarity to study the evolution of software projects. In particular, we develop the concept of time dependence between code changes to study software evolution through empirical studies on two large open source projects (PostgreSQL and FreeBSD) with more than 25 years of development history. We show that time dependence can be used to study how changes build on prior changes and the impact of this building process on the quality of a project. We show how a development period impacts the development of future periods in a project. We also show how a subsystem (module) of a project builds on other subsystems and we identify the subsystems that have high impact on a project's development. Using this knowledge, managers can better monitor the progress of the projects and better plan for future changes. / Thesis (Master, Computing) -- Queen's University, 2010-05-29 11:25:39.005

As a software project ages, its source code is improved by refining existing features, adding new ones, and fixing bugs. Software developers can attest that such changes often require accompanying changes to the infrastructure that converts source code into executable software packages, i.e., the build system. Intuition suggests that these build system changes slow down development progress by diverting developer focus away from making improvements to the source code. While source code evolution and maintenance is studied extensively, there is little work that focuses on the build system. In this thesis, we empirically study the static and dynamic evolution of build system complexity in proprietary and open source projects. To help counter potential bias of the study, 13 projects with different sizes, domains, build technologies, and release strategies were selected for examination, including Eclipse, Linux, Mozilla, and JBoss. We find that: (1) similar to Lehman's first law of software evolution, Java build system specifications tend to grow unless explicit effort is invested into restructuring them, (2) the build system accounts for up to 31\% of the code files in a project, and (3) up to 27\% of source code related development tasks require build maintenance. Project managers should include build maintenance effort of this magnitude in their project planning and budgeting estimations. / Thesis (Master, Computing) -- Queen's University, 2011-01-31 12:46:06.082

Modern computer infrastructure continues to advance at an accelerating pace. This advancement affects all aspects of computing systems such as hardware, device types, operating systems, and software. The constant change creates a problem for software vendors who must support not only the latest systems, but also previous versions. This infrastructure updating requirement limits software vendors when implementing new software features and in turn product innovation. There is a significant and increasing cost associated with adhering to application infrastructure requirement changes. To accommodate infrastructure change requirements, immediate and measurable action must be taken. First, the current industrial software development practices and tooling need to be analyzed. Current industrial release patterns and product update tooling must be understood and their shortcomings investigated. Next, key use cases ought to be identified and new methodologies and extensions to existing frameworks ought to be proposed to circumvent these difficulties. Finally, systems must be architected and developed to test the solution hypotheses and then deployed in commercial applications. This thesis focuses on these critical steps in the call to action to change software infrastructure management. In this thesis, we analyze an industrial problem including a real case study. We illustrate the currently available approaches and then describe how they are not sufficient in solving the problem. Our approach is based on an extension of a previously developed framework (i.e., the SmartContext commerce framework). In particular, we design an architecture and implementation for our industrial problem domain. / Graduate / 0984

This thesis focuses on an Agent-Based Service-Oriented approach to evolving legacy system into a Pervasive Computing environment. The methodology consists of multiple phases: using reverse engineering techniques to comprehend and decompose legacy systems, employing XML and Web Services to transform and represent a legacy system as pervasive services, and integrating these pervasive services into pervasive computing environments with agent based integration technology. A legacy intelligent building system is used as a case study for experiments with the approach, which demonstrates that the proposed approach has the ability to evolve legacy systems into pervasive service environments seamlessly. Conclusion is drawn based on analysis and further research directions are also discussed.

The dynamic behaviour of a software system changes as a consequence of developer’s static source code modifications. In this thesis, we improve upon a previous approach that combines static and dynamic analyses to categorize behavioural changes by greatly improving its accuracy through polymorphic mapping. We further refine the previous model by introducing a change-centric state transition model that captures the flow of call pairs among different partitions based on static and dynamic call graphs. We also extend the approach by incorporating complete dynamic call stacks into the analysis. Finally, we perform a longitudinal analysis of three software systems to categorize how they have dynamically evolved across 100 program versions. In our evaluation, the polymorphic mapping algorithm decreased mismatches between the static and dynamic analyses by 53%. In particular, we decreased the mismatch by 71% in the most important category of changes from the developer’s point of view. We found that developers introduce new behaviour more often than eliminating old behaviour. Our results show that developers are more likely to remove unexecuted/dead code than code that is executed dynamically. In terms of change types, we found that changes made to fix defects encountered the least inconsistent and unexpected behaviour, while changes made to add new functionality experienced the highest unexecuted behaviour. Finally, we argue that augmenting the dynamic analyses with call stacks provides useful information that helps developers analyze the implications of the call pairs highlighted by our analyses.

The dynamic behaviour of a software system changes as a consequence of developer’s static source code modifications. In this thesis, we improve upon a previous approach that combines static and dynamic analyses to categorize behavioural changes by greatly improving its accuracy through polymorphic mapping. We further refine the previous model by introducing a change-centric state transition model that captures the flow of call pairs among different partitions based on static and dynamic call graphs. We also extend the approach by incorporating complete dynamic call stacks into the analysis. Finally, we perform a longitudinal analysis of three software systems to categorize how they have dynamically evolved across 100 program versions. In our evaluation, the polymorphic mapping algorithm decreased mismatches between the static and dynamic analyses by 53%. In particular, we decreased the mismatch by 71% in the most important category of changes from the developer’s point of view. We found that developers introduce new behaviour more often than eliminating old behaviour. Our results show that developers are more likely to remove unexecuted/dead code than code that is executed dynamically. In terms of change types, we found that changes made to fix defects encountered the least inconsistent and unexpected behaviour, while changes made to add new functionality experienced the highest unexecuted behaviour. Finally, we argue that augmenting the dynamic analyses with call stacks provides useful information that helps developers analyze the implications of the call pairs highlighted by our analyses.

High security level must be guaranteed in applications in order to mitigate risks during the deployment of information systems in open network environments. However, a significant number of legacy systems remain in use which poses security risks to the enterprise' assets due to the poor technologies used and lack of security concerns when they were in design. Software reengineering is a way out to improve their security levels in a systematic way. Model driven is an approach in which model as defined by its type directs the execution of the process. The aim of this research is to explore how model driven approach can facilitate the software reengineering driven by security demand. The research in this thesis involves the following three phases. Firstly, legacy system understanding is performed using reverse engineering techniques. Task of this phase is to reverse engineer legacy system into UML models, partition the legacy system into subsystems with the help of model slicing technique and detect existing security mechanisms to determine whether or not the provided security in the legacy system satisfies the user's security objectives. Secondly, security requirements are elicited using risk analysis method. It is the process of analysing key aspects of the legacy systems in terms of security. A new risk assessment method, taking consideration of asset, threat and vulnerability, is proposed and used to elicit the security requirements which will generate the detailed security requirements in the specific format to direct the subsequent security enhancement. Finally, security enhancement for the system is performed using the proposed ontology based security pattern approach. It is the stage that security patterns derived from security expertise and fulfilling the elicited security requirements are selected and integrated in the legacy system models with the help of the proposed security ontology. The proposed approach is evaluated by the selected case study. Based on the analysis, conclusions are drawn and future research is discussed at the end of this thesis. The results show this thesis contributes an effective, reusable and suitable evolution approach for software security.

Structural changes, including moving, renaming, merging and splitting are important design change decisions made by programmers. However, during the process of software evolution, this information often gets lost. Recovering instances of structural changes in the past, as well as understanding them, are essential for us to achieve a better understanding of how and why software changes. In this thesis, we propose an approach that helps to recover and understand the lost information of structural changes.

Object-oriented systems that undergo repeated modifications commonly endure a loss of quality and design decay. This problem is often remedied by applying refactorings. Refactoring is one of the most important and commonly used techniques to improve the quality of the code by eliminating redundancy and reducing complexity; frequently refactored code is believed to be easier to understand, maintain and test. Object-oriented metrics provide an easy means to extract useful and measurable information about the structure of a software system. Metrics have been used to identify refactoring opportunities, detect refactorings that have previously been applied and gauge quality improvements after the application of refactorings. This thesis provides an in-depth analytical study of the relationship between metrics and refactorings. For this purpose we analyzed 136 versions of 4 different open source projects. We used RefactoringCrawler, an automatic refactoring detection tool to identify refactorings and then analyzed various metrics to study whether metrics can be used to (1) reliably identify refactoring opportunities, (2) detect refactorings that were previously applied, and (3) estimate the impact of refactoring on software quality. In conclusion, our study showed that metrics cannot be reliably used to either identify refactoring opportunities or detect refactorings. It is very difficult to use metrics to estimate the impact of refactoring, however studying the evolution of metrics at a system level indicates that refactoring does improve software quality and reduce complexity. / text

The theme of this thesis is to pave a path to vertically extract business intelligence (BI) from software code to business intelligence base, which is a tank of BI. Business intelligence is the atomic unit to build a piece of program comprehensibility in business logic point of view. It outstands because it covers all reverse engineering levels from code to specification. It refers to technologies for the localisation, extraction, analysis of business intelligence in software system. Such an approach naturally requires information transformation from software system to business intelligence base, and hence a novel set of automatic business intelligence recovery methods are needed. After a brief introduction of major issues covered by this thesis, the state of art of the area coined by the author as “business intelligence elicitation from software system”, in particular, the kinds of business intelligence that can be elicited from software system and their corresponding reverse engineering technical solutions are presented. Several new techniques are invented to pave the way towards realising this approach and make it light-weight. In particular, a programming-style-based method is proposed to partition a source program into business intelligence oriented program modules; concept recovery rules are defined to recover business intelligence concepts from the names embedded in a program module; formal concept analysis is built to model the recovered business intelligence and present business logic. The future research of this task is viewed as “automating business intelligence accumulation in Web” which is defined to bridge work in this thesis to nowadays Web computing trends. A prototype tool for recovering business intelligence from a Web-based mobile retailing system is then presented, followed by case study giving evaluation on the approach in different aspects. Finally, conclusions are drawn. Original contributions of this research work to the field of software reverse engineering are made explicit and future opportunities are explored.