When: 04-04-2014 — 14 p.m
Talk Title: An Exploratory Study of How Developers Seek, Relate, and Collect Relevant Information during Software Maintenance Tasks
Much of software developers’ time is spent understanding unfamiliar code. To better understand how developers gain this understanding and how software development environments might be involved, a study was performed in which developers were given an unfamiliar program and asked to work on two debugging tasks and three enhancement tasks for 70 minutes. The study found that developers interleaved three activities. They began by searching for relevant code both manually and using search tools; however, they based their searches on limited and misrepresentative cues in the code, environment, and executing program, often leading to failed searches. When developers found relevant code, they followed its incoming and outgoing dependencies, often returning to it and navigating its other dependencies; while doing so, however, Eclipse’s navigational tools caused significant overhead. Developers collected code and other information that they believed would be necessary to edit, duplicate, or otherwise refer to later by encoding it in the interactive state of Eclipse’s package explorer, file tabs, and scroll bars. However, developers lost track of relevant code as these interfaces were used for other tasks, and developers were forced to find it again. These issues caused developers to spend, on average, 35 percent of their time performing the mechanics of navigation within and between source files. These observations suggest a new model of program understanding grounded in theories of information foraging and suggest ideas for tools that help developers seek, relate, and collect information in a more effective and explicit manner.
Qiuye He (Leon)
When: 21-03-2014 — 14 p.m
Talk Title: Automated Build Performance Analysis
Build system transforms source codes and resources into deliverable. The problem of build system is simple: they are not fast enough.
Yet, there is no automatic build performance analysis tool, ultimately we want develop such kind of tool. However the very first step is to identify a small group of files that cause the build to be slow. We define build hotspot files as files that takes long time to rebuild and are frequent to rebuild.
Are these hotspot files really the bottle neck that make the build slow?
When: 13-03-2014 — 10 a.m
Talk Title: Simplified data-flow analysis with Datalog
Static program analysis refers to the class of analyzes that can be performed without executing the program. Static analysis finds applications in code optimization, design recovery, metric extraction, software testing, program comprehension, application security, etc.. Data-flow analysis is a static analysis that aims at estimating the possible values of a property at various points in a program. Reaching definitions is a classical example of data-flow analysis. While data-flow analysis is conceptually easy to understand, implementation of a full-fledged, flexible data-flow environment can be tedious. This is where Datalog comes to the rescue! In this talk, I will show how data-flow analyzes can be implemented in a very simple and flexible manner using a Datalog engine. Starting from simple programs, I will show, using an online Datalog solver, how analyzes like reaching definitions or points-to analysis can be implemented with 10-20 lines of Datalog. I will conclude the talk by presenting how, in the context of my research, I developed a novel data-flow analysis to propagate, pattern-based security properties in PHP applications.
When: 27-02-2014 — 10 a.m
Talk Title: On the use of genetic programming for automated refactoring and the introduction of design patterns
Maintaining an object-oriented design for a piece of software is a difficult, time-consuming task. Prior approaches to automated design refactoring have focused on making small, iterative changes to a given software design. However, such approaches do not take advantage of composition of design changes, thus limiting the richness of the refactoring strategies that they can generate. In order to address this problem, this paper introduces an approach that supports composition of design changes and makes the introduction of design patterns a primary goal of the refactoring process. The proposed approach uses genetic programming and software engineering metrics to identify the most suitable set of refactorings to apply to a software design. We illustrate the efficacy of this approach by applying it to a large set of published models, as well as a real-world case study.
When: 06-02-2014 — 10:00 am
Where: M-4225, Pavillons Lassonde
Talk Title: Toward understanding program comprehension: investigating the impacts of gender and the type of artifacts
The purpose of software maintenance is to enhance and optimize an existing system while preserving its integrity. The software maintenance can cost more than 60\% of the budget of a software system, thus improving the maintainability of software is important for both the software industry and its customers. Program comprehension is the initial step of software maintenance which requires the major amount of maintenance’s time and effort to perform. We conjuncture that to enhance the maintenance activity, we need to enhance the program comprehension by better understanding the cognitive process underlying comprehension activity. This research aims at studying the impact of two important factors namely the types of artifacts and developers’ individual characteristics on program comprehension. Moreover, we investigate the viewing strategies deployed by developers to better understand how developers find relevant data and use different artifacts effectively for program comprehension.
Laleh M. Eshkevari
When: 30-01-2014 — 10:00 am
Where: M-4225, Pavillons Lassonde
Talk Title: Identifying and locating interference issues in Content Management Systems
The large success of Content management Systems (CMS) such as WordPress is largely due to the rich ecosystem of themes and plugins developed around the CMS that allows users to easily build and customize complex Web appli- cations featuring photo galleries, contact forms, and blog pages. However, the design of the CMS, the plugin-based architecture, and the implicit characteristics of the program- ming language used to develop them (often PHP), can cause interference or unwanted side effects between the resources declared and used by different plugins. This paper describes the problem of interference between plugins in CMS, specif- ically those developed using PHP, and outlines an approach combining static and dynamic analysis to detect and locate such interference. Results of a case study conducted over 10 WordPress plugins shows that the analysis can help to identify and locate plugin interference, and thus be used to enhance CMS quality assurance.