Publications

With workspaces frequently comprising hundreds, or even thousands, of artifacts, developers spend a considerable amount of time navigating the source code or searching for a specific source code artifact they need to work. With the aim of helping developers during their work, the authors propose a context-based approach to search, recommend and browse source code in the workspace. The source code structure stored in the workspace of the developer is represented in a knowledge base, and a context model represents the source code elements that are more relevant for the developer in a specific moment. These structures are then used to improve the retrieval, ranking and navigation of source code elements. The experiments conducted with developers showed that the use of contextual information is of valuable importance to help identify the most relevant source code elements for the developer at each moment.

The contextual information associated to the work of a developer can be used to identify the source code artifacts that are more relevant at a specific point in time. This information is essential to reduce the effort spent by developers when searching for needed source code artifacts. We propose a context model that represents the focus of attention of the developer at each moment. This context model adapts automatically to changes in the focus of attention of the developer by detecting context transitions. We have developed a prototype that was submitted to an experiment with a group of developers. The results collected show that the use of our context model to rank, elicit and filter relevant source code elements for the developer is very promising.

Although software development may include all the activities that result in a software product, from its conception to its realization, here we focus on the process of writing and maintaining the source code. Software development projects have been increasing in size and complexity, requiring developers to cope with a large amount of contextual information during their work. With workspaces frequently comprising hundreds, or even thousands, of artifacts, they spend a considerable amount of time navigating the source code or searching for a specific source code artifact they need to work with. With the aim of helping developers understand the source code structure and find what they need, modern IDE provide several features for searching and navigating the source code. But, according to some studies, developers still spend a considerable amount of time searching and navigating the source code structure.

With regard to search, the most commonly used approach is the matching of specific patterns in the lines of code that comprise a software system, requiring a direct correspondence between the pattern and the text in the source code. The limitations of this approach have been surpassed by the research carried out in the field of IR, encouraging researchers to use these techniques to help developers finding relevant source code for their current task. But, despite the fact that context is argued to improve the effectiveness of IR systems, as far as we know, none of the previous approaches have used the contextual information of the developer to improve the retrieval or ranking of relevant source code in the IDE.

Another interesting form of delivering relevant source code artifacts to a developer is using a recommender system. These systems have been used in a wide variety of domains, to help users find relevant information, deal with information overload and provide personalized recommendations of very different kinds of items. In software development, researchers studied ways of using contextual information to recommend source code artifacts that are potentially relevant for the current task of the developer. But, these approaches usually use a limited context model, or require contextual information to be explicitly provided.

The research described in this thesis is focused on the development of a context-based approach to search and recommendation of source code in the IDE. The source code structure stored in the workspace of the developer is represented in a knowledge base. A context model represents the source code elements that are more relevant for the developer in a specific moment. These structures are then used to improve the retrieval and ranking of source code elements, such as classes, interfaces and methods, taking into account their relevance to the current context of the developer. The relevance of the source code elements retrieved is computed based on the structural and lexical relations that exist between these elements and the elements in the context model.

We have implemented a prototype that implements and integrates our approach in the Eclipse IDE. This prototype was tested with a group of developers in order to validate our approach. The statistical information collected shows that the source code elements manipulated by the developer are highly related. This supports our claim that the relations that exist between source code artifacts can be used to measure the proximity between these artifacts, and to compute their relevance in the current context of the developer. Also, we have verified that the context components have a clear contribution to improve the ranking of search results, with the search results selected by the developers using our approach being better ranked in more than half of the times. With respect to recommendations, although the results are not so evident, we have shown that our context model can be used to retrieve relevant source code elements for the developer, being able to predict the needed source code element in more than half of the times.

Software development is a complex activity, where developers spend a lot of time exploring their own source code or the source code of other team members. Also, understanding the source code without any help beyond the source code itself can be difficult, especially in large projects and large teams. Although there are several tools that provide visualizations for different tasks of the software development process, they still suffer from limitations. Especially, concerning the browsing of source code, such visualizations commonly overload the developer with too much information, have poor design or usability issues and do not always integrate well with the work environment of the developer.

In this thesis, we present a software visualization tool that helps developers explore and comprehend the source code during software development. This tool provides source code visualization mechanisms, allowing developers to browse through source code elements and their most important relations, including inheritance, composition and behaviour. Moreover, this tool is integrated in the Software Development in Context (SDiC) research project, which provides two structures that are in the base of our tool. A knowledge base that stores the source code elements and their relations, stored in the workspace of the developer, and a context model that represents the source code elements that are more relevant for the developer. The elements displayed in the visualization are provided by the knowledge base and the contextual information of the developer is used to improve the visualization. It automatically focus on the source code elements being manipulated by the developer, adapting as this source code elements change. Furthermore, this tool provides different navigation mechanisms, such as a timeline that allows to move back and forward in the history of interactions. Also, we present a mechanism to reduce the number of nodes on screen, which takes into account the navigation context of the developer to choose which elements can be hidden, without cause confusion.

This tool was used in two controlled experiments, by a group of developers. The results of the first controlled experiment show that our approach has a positive impact in the comprehension of the source code structure, when compared to the existing Eclipse functionalities. Moreover, after the first experiment, the tool was improved with new functionalities. The results of the second experiment show that this new version allowed the developers to perform a set of tasks in less time and with more accurancy, when compared to the previous version of the tool. Furthermore, the results show that the developers considered the use of their contextual information very useful as a way to improve the visualization.

A software developer programming in an object-oriented programming language deals with a source code structure that may contain hundreds of source code elements. These elements are commonly related to each other and working on a specific element may require the developer to access other related elements. We propose a recommendation approach that uses the context of the developer to retrieve and rank recommendations of relevant source code elements in the IDE. These recommendations provide a shortcut to reach the desired elements and increase the awareness of the developer in relation to elements that may be of interest in that moment. We have tested our approach with a group of developers and the results show that context has a promising role in predicting and ranking the source code elements needed by a developer at each moment.

Software developers usually spend a large amount of time navigating their own source code or searching for a specific source code artifact they need to work with. We propose a context based search approach that focuses in the source code artifacts that exist in the workspace of the developer. These artifacts are stored in a knowledge base and represented using ontologies. The contextual information of the developer is used to rank the search results according to their relevance for the developer. The results of an experiment performed with two groups of developers show that our approach has a positive impact in retrieving relevant artifacts for the developer, helping them find what they need more quickly and easily.

As software development projects increase in size and complexity, developers are becoming overloaded and need to cope with a growing amount of contextual information. This information can be captured and processed in order to improve some of the tasks performed by developers during their work. We propose a context model that represents the focus of attention of the developer at each moment. This context model adapts to changes in the focus of attention of the developer through the automatic detection of context transitions. We have developed a prototype that was submitted to an experiment with a group of developers, to collect statistical information about the context modeling process and to manually validate the context transition mechanism.

While working in an IDE, developers typically deal with a large number of different artifacts at the same time. The software development process requires that they repeatedly switch between different artifacts, which often depends on searching for these artifacts in the source code structure. We propose a tool that integrates context-based search and recommendation of source code artifacts in Eclipse. The artifacts are collected from the workspace of the developer and represented using ontologies. A context model of the developer is used to improve search and give recommendations of these artifacts, which are ranked according to their relevance to the developer. The tool was tested by a group of developers and the results show that contextual information has an important role in retrieving relevant information for developers.

The use of contextual information is said to improve awareness in software development. But the context of a software developer is something hard to define and capture, as it represents a complex network of elements across different dimensions, that is not limited to the work developed on an IDE. We propose a software developer context model composed of four layers: personal, project, organization and domain. We describe this context model at the personal layer, present a prototype and discuss the results of an experiment conducted with a group of developers. The results show that developers consider the use of contextual information relevant to improve information retrieval, ranking and filtering, but usability plays an important role on how these improvements are perceived.

The context of a developer can be viewed as a rich and complex network of elements across different dimensions that are not limited to the work developed on an IDE. We propose the definition of a software developer context model that takes into account all the dimensions that characterize the work environment of the developer. We are especially focused on the project dimension and present a definition of what the context model encompasses at this level. The experimental work done on the context capture perspective show that useful contextual information can be extracted from project management tools. The extraction, analysis and availability of these contextual information can be used to enrich the work environment of the developer with additional knowledge that relate with the tasks being developed.

One of the problems that software development companies face today is the increasing dimension of software systems. The resources produced during the analysis, design and implementation phases of such projects are an important source of knowledge for software development companies. In general, this knowledge is not captured and its potential is underestimated. In order to make this knowledge accessible and easily reusable, efficient knowledge management systems are needed. In particular, it would be interesting to have this knowledge suggested to the user taking into account the context of the tasks s/he has at hands. The purpose of this work is to study and develop better ways of retrieving and suggesting relevant knowledge to the developer based on her/his contextual information. The techniques and models developed during this work will be integrated in Semantic Reuse System (SRS), which is a platform for knowledge management and reuse in software development.