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.
When: 20-02-2014 — 10:00 am
Where: Room B-403 of the main pavilion, 4th floor Map: Building 1 on http://www.polymtl.ca/rensgen/en/coordonnees/campus.php
Talk Title: WSDarwin: A Framework for the Support of Web-Service System Evolution
Service-oriented architectures have risen to be the prominent paradigm for developing distributed software systems.
However, this exact distributed nature poses some unprecedented challenges to service providers, when they evolve said services. Software evolution may be constrained not only by the technical
properties of the architecture, but also by business and economic factors that shape the software ecosystem. In this presentation, I am shedding light to some of the less visible constraints and I am
discussing our own solution, the WSDarwin toolkit, which supports the decision making process of the service providers.
Marios Fokaefs is a PhD Candidate in the Department of Computing Science at the University of Alberta, Canada. He received his MSc from the same department and his BSc from the Department of Applied Informatics at the University of Macedonia, Greece. His research interests revolve around design and evolution of object-oriented and service-oriented software systems. More
specifically, he has worked on projects on software refactoring, detection of code smells, comparison of programming interfaces, automatic adaptation of software to changes and interoperability of client applications in distributed software systems. In the context
of his PhD, he is also considering the business and economic dimensions of software evolution, using such concepts as Game Theory and Constrained Optimizations.
Prof Massimiliano Di Penta – University of Sannio, Italy
When: August 8, 2013
Talk Title: Detecting Bad Smells in Source Code Using Change History Information
Code smells represent symptoms of poor implementation choices. Previous studies found that these smells make source code more difficult to maintain, possibly also increasing its fault-proneness. There are plethora of approaches that identify smells based on code analysis techniques. However, we observe that many code smells are intrinsically characterized by how code elements change over time. Thus, relying solely on structural information may not be sufficient to detect all the smells accurately.
We propose an approach to detect five different code smells, namely Divergent Change, Shotgun Surgery, Parallel Inheritance, Blob, and Feature Envy, by exploiting change history information mined from versioning systems. The approach, coined as HIST (Historical Information for Smell deTection), has been applied on eight software projects written in Java, and wherever possible
compared with existing state-of-the-art smell detectors based on source code analysis. The results indicate that HIST’s precision ranges between 61% and 80%, and its recall ranges between 61% and 100%. More importantly, the results confirm that HIST is able to identify code smells that cannot be identified through approaches solely based on code analysis.
Prof Arnaud Blouin – IRISA, France
When: May 27, 2013
Talk Title: Towards exploring and exploiting interactive system diversity
The diversification of devices, input devices, and usages is
continuously growing since the last decade. A same interactive system
has now to run on several heterogeneous platforms and needs to adapt
itself to current users and environments. Furthermore, while designers
usually sketch one or several GUIs, a myriad of GUIs may now exist
In this talk I will present my ongoing and future research work on
exploring and exploiting interactive system diversity, from a software
engineering point of view: exploiting at design time and runtime the
increasingly number of devices, input devices, and usages to build
adaptive interactive systems; exploring at design time and runtime the
solution space of existing user interactions / interfaces to discover
alternatives; understanding and testing interactive system diversity.
This work relies on research in model-driven engineering, such as model
slicing, I will introduce as well.
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.