I have the privilege of supervising the following students:
- Tahmid Ahmad (Ph.D. in Software Engineering)
- Mehran Hassani (Master in Software Engineering, co-supervised with Dr. Weiyi Shang)
I have the privilege of supervising the following students:
Our research group focuses on the area of software maintenance, and particularly on design quality improvement and design evolution analysis.
We currently offer several interesting projects (see below) for Master's and PhD students. If you are interested in these projects or have your own ideas for projects in the aforementioned research areas, please contact me at tsantalis [at] cse.concordia.ca. Don't forget to attach your CV and provide details about previous research projects you have worked on, and software projects you have developed. Candidates are expected to meet the following criteria:
It has been observed that the design quality of a software system deteriorates throughout its evolution (software aging) due to changes in the requirements that were not anticipated in the original design or poor design decisions for the implementation of new requirements caused by the pressure to meet deadlines.
Design quality deterioration manifests itself in the form of design defects or flaws that make the system harder to comprehend, test, extend and maintain in general. Refactorings are source code transformations that do not alter the external behavior of a program, but improve its internal structure . The cumulative effect of these code transformations can radically improve the design quality of a system and reverse software decay.
Despite the wide support of refactoring application mechanics in modern IDEs, the refactoring process is not supported in its entirety, since the developers have to manually detect refactoring opportunities and assess their impact on design quality. Over the last years, several approaches have been proposed in the literature for the detection of specific refactoring opportunities in a systematic manner  - . However, there is still a large list of refactorings and design problem resolution strategies   to be explored.
Have a look at JDeodorant, an Eclipse plug-in that supports the detection of refactoring opportunities in Java projects and has been used by several companies and organizations to improve the design quality of their software products. JDeodorant provides a powerful infrastructure for the analysis of source code allowing the implementation of detectors for a large variety of refactoring opportunities.
Working on this project will give you experience in source code analysis techniques and major Eclipse frameworks, such as JDT (Java Development Tools) and LTK (Refactoring Language Toolkit), as well as the satisfaction to see that your contribution is used by hundreds of developers around the world. JDeodorant is available through Eclipse Marketplace and has already a large install base.
Another interesting research direction is the investigation of refactoring opportunities in dynamic languages, such as Ruby , and style sheet languages, such as Cascading Style Sheets (CSS)  - .
The classification of source code changes can provide insight in the intention/purpose of the maintenance activities. Furthermore, it can be used to detect development phases throughout the evolution of a project as a means to a) support project management/awareness, b) reveal the development processes and practices being applied by the development team, and c) find patterns of interleaved maintenance activity types. Finally, it can also be used to detect software modules which are stable, error-prone, critical with respect to extension, or frequently refactored.
Previous research work, has mainly focused on commit information (i.e., commit message, author and modified modules) in order to perform this classification  . This approach has two main disadvantages: a) it depends on the quality and clarity of the comments provided by the developers, and b) it classifies each revision into a single maintenance category, although the changes may correspond to multiple categories. Other research works employ program differencing in order to extract the system’s evolution profile as a sequence of change trees , detect non-essential changes (such as the replacement of simple types with qualified ones, extraction of local variables, keyword modifications and local variable renames) through sophisticated source code analysis techniques (i.e., Partial Program Analysis) , detect the introduction of Java Generics , and automatically discover and summarize systematic code changes (such as refactorings, feature additions, and updates to code clones) as logic rules . However, these approaches do not cover completely all maintenance types.
This research problem is ideal for students with background or interest in source code analysis and differencing, as well as text mining techniques.
Software systems may present a very large number and variety of refactoring opportunities. As a result, the existence of conflicts and dependencies in the application of specific refactorings is quite possible.
A conflict usually takes place when two or more refactoring opportunities affect a common piece of code. In this case, the refactorings should be applied according to the scope of the code that they affect and the semantics of the involved refactoring types.
For example, let us assume that there are two refactoring opportunities for method m. The first opportunity suggests the move of method m from class A to class B (because it accesses field and/or methods from class B), while the second one suggests the extraction of a code fragment from the body of method m into a separate method. By applying the Extract Method refactoring first, method m becomes more dependent to class A (since after the application of the refactoring method m will access the extracted method in class A as well) and thus the Move Method refactoring opportunity may become weaker (i.e., less effective) or even disappear. On the other hand, if the Move Method refactoring is applied first, then the Extract method refactoring can be applied afterwards without any problem.
A dependency takes place when two refactoring opportunities affect different pieces of code that are dependent with each other. In this case, the order of refactoring application depends on the direction of the dependency.
For example, let us assume that there are two Move Method refactoring opportunities for methods x and y, respectively, and method x calls method y. The refactoring corresponding to method y should be applied first, since the move of the called method (i.e., method y) may affect the target class for the calling method (i.e., method x).
Some previous research approaches to this problem, proposed the representation of refactorings as graph transformations  , where the detection of conflicts and dependencies is based on critical pair analysis and sequential dependency analysis. Other approaches treat the problem of finding an optimal sequence of refactoring applications as a search problem on Deterministic Finite Automata , where nodes represent system states and edges represent the application of specific refactorings. Finally, there is a category of approaches that treat this problem as a scheduling problem  , where the goal is to optimize certain functions (e.g., design quality, understandability, maintainability, refactoring effort) with respect to the constraints imposed by refactoring conflicts and dependencies.
This research problem is ideal for students with background or interest in search and optimization techniques.
The goal of empirical studies is to investigate the processes and practices being applied in software projects and development teams as a means to propose, validate and improve models and analytical tools.
Within the context of refactoring activity, prior empirical studies investigated its relation with the number and duration of bug fixes , software release dates , testing periods , as well as the impact of refactorings on software metrics  . More recent empirical studies investigated the evolution and lifespan of code smells in the history of software projects   , as well as the impact of code smells on software change-proneness .
However, the relationship between code smells and refactoring activity has not been investigated yet. It is particularly interesting to examine the specific reasons that motivate the developers to apply refactorings and how refactoring activity is interleaved with other maintenance activities, such as bug fixing, addition of features, unit testing and design improvement.
This research problem is ideal for students with background or interest in mining software repositories (MSR) and statistical analysis.
Source code repositories are becoming larger and larger, both with respect to their codebase and their evolution history. As a result, the analysis of software repositories has become a computation- and data-intensive task that requires parallel and distributed processing.
The goal of this research project is to investigate the use of frameworks supporting distributed applications  , such as Apache Hadoop, for the distributed analysis of source code.
This research problem is ideal for students with background or interest in parallel algorithms, distributed computing, algorithm optimization, and scalability studies.