Research Interests

Graphics Processing Units. The development of programming languages follows the development of the hardware. Thus, programming languages are likely to present more and more abstractions to handle parallelism, because the hardware is each day more parallel. Today, the Single Instruction, Multiple Data (SIMD) execution model, so conspicuous in graphics processing units (GPUs), seems like an affordable alternative to bring high-performance hardware to the everyday computer user. Nowadays, a typical GPU puts together a few hundred processing elements. However, using all this power is a challenge, because not every application is so parallel. Furthermore, programmers have problems to run even regular applications at maximum speed, because the GPU execution model is still very complicated. Our intention is to move this burden away from programmers, and transfer it to the compiler. We have invented the concept of divergence analysis, and have coded the first implementation of it that is today available in an open source compiler. We hope to keep working on code optimization techniques that target SIMD hardware; thus, helping to close the gap between the complexity of parallel applications, and the expressivity of the programming languages in which these problems should be solved.

Computer Security. Computer Security has been always an important problem in computer science, and in this new world where the everyday user can reach the doors of virtually any program, this problem is even more relevant. In this field of research our goal is to use the compiler as a tool to track vulnerabilities in programs. The compiler can give developers a holistic view of the code, telling them if sensitive functions can receive inputs from malicious users, or if important information can leak to the outside world. We have been experimenting with non-conventional program representations to speed up the analysis of programs. Our first success in this field was to use the Extended Static Single Assignment form to reduce the complexity of solving the Tainted Flow Problem in PHP programs. Our analysis is nowadays available in the PHC open source compiler. We are still pursuing new ways to boost up the analysis of programs. Speed is a problem once we start analyzing programs having millions of lines of code. Moreover, we hope to be able to track the flow of information across the program, even when this information is stored in memory. The graphs formed by the many data-structures that a program creates in memory are still "terra incognita" to the programming languages community, and we want to help to explore these vast lands.

Just-in-Time Compilation. I believe that, in the coming years, dynamic programming languages such as Python, Ruby and JavaScript will gain more and more popularity. These languages give application developers a simple and intuitive programming model, in which it is easy to prototype products, and to have them working in actual settings. However, this easy-of-use comes with a cost: it is hard to run programs written in dynamic programming languages efficiently. One of the hopes of surpassing this obstacle lays in the just-in-time compilers (JITs). JITs translate programs to native code while these programs are interpreted. Thus, they can rely on values known only at compilation time, plus speculation, to generate programs customized to a particular set of input data. We have been working with members of the Mozilla Foundation to make the compilation of JavaScritp programs more efficient and simple. Our first result in this field was an algorithm to eliminate overflow tests from native programs. We hope to be able to extend this result with more aggressive and effective optimizations; thus, improving the experience that Internet users have with JavaScript programs.

Previous Projects. My first attempt to do any work in programming languages was the implementation of LinF, a language for the specification of fractals using L-System grammars. During my masters I invested some time in distributed programming environments, and worked in the implementation of a middleware called Arcademis. Nevertheless, the interest in core programming language research started in grad school. Perhaps the most important among my projects, so far, was register allocation by puzzle solving. In this project we showed that the register assignment problem has polynomial time solution, even if we take registers of different sizes into consideration. Before finding the "puzzles", I was involved with SSA-based register allocation, when we had the chance of using chordal graphs to attack the register assignment problem. While researching register allocation, I end up working on a translator validator for register allocators, and on the implementation of a framework where different algorithms could be tested. Still in grad school, but while at google, I also had the opportunity to work with Dan Berlin on new algorithms for pointer analysis.