The program from the 1st Annual Programming Languages Day held at the IBM Thomas J. Watson Research Center on Monday, April 17, 2000 featured a keynote presentation by Martin Fowler and five regular presentations.
Keeping Software Soft, Martin Fowler
Do you remember when you first started programming? The magic that a little typing could cause so many things to happen. The fact that you could change what your program does with just a few changes to what you typed.
Now you're a professional software engineer you may think differently about software. Despite its name software is not soft at all, indeed it's a pig to change. So you have to work hard at figuring out the software before you run the compiler, much as the same way that real engineers use drawings before lathe is put to metal.
But I'll be talking about a new breed of processes that reject this view . Variously called "lightweight methodologies" or "glorified hacking" they promise a new approach to improve software development by accepting and encouraging change. Such methodologies include Crystal, Adaptive Software Development, and most (in)famously: Extreme Programming.
Fractal Symbolic Analysis, Keshav Pingali (Cornell University)
A well-known limitation of dependence analysis is that it examines only the memory locations read and written by a statement, and does not assume any particular interpretation for the operations in that statement. Symbolic execution of programs enables the exploitation of such semantic properties, but it is intractable for all but the simplest programs.
In this talk, we describe a new form of symbolic analysis for use in restructuring compilers. *Fractal* symbolic analysis compares a program and its transformed version by repeatedly simplifying these programs until symbolic analysis becomes tractable, while ensuring that equality of simplified programs is sufficient to guarantee equality of the original programs.
We discuss a prototype implementation of fractal symbolic analysis, and show how it can be used to optimize the cache performance of LU factorization with pivoting.
This is joint work with Vijay Menon (Cornell) and Nikolai Mateev (Cornell).
Issues in Escape Analysis for Java Programs, Jong-Deok Choi (IBM) and Manish Gupta (IBM) and Martin Rinard (MIT)
Researchers have recently developed a variety of escape analysis algorithms for Java. By detecting that objects do not escape method invocations, these analyses enable transformations that eliminate redundant synchronization and allocate objects on the call stack instead of on the heap.
In this combined presentation, we examine how different researchers have addressed the trade-off between analysis time and precision of the analysis results, and discuss the implications of these choices for the performance of the transformed program. We also present several new results in the field and speculate on future directions and uses of escape analysis and related analyses.
Data-level Interoperability, John Reppy (Bell Labs)
Practical implementations of high-level languages must address the problem of providing access to libraries and system services that have APIs specified in a low-level language (usually C). In this talk, I will describe the approach that the Moby implementation takes towards this problem. What makes our approach different from other recent work in the area, is that we focus on supporting direct manipulation of low-level data representations from Moby. Our mechanism supports data-level interoperability, which is an important capability when dealing with large external data sets or data that is in a fixed format. Our mechanism also supports foreign-interface generation tools, and I will describe a couple that we have built for our system.
This is joint work with Kathleen Fisher (AT&T) and Riccardo Pucella (Cornell).
Jalapeno: a new Java Virtual Machine for Servers, Vivek Sarkar (IBM)
In this talk, we give an overview of the Jalapeno Java Virtual Machine (JVM) research project at the IBM T. J. Watson Research Center. The goal of Jalapeno is to expand the frontier of JVM technologies for server nodes --- especially in the areas of dynamic optimized compilation and specialization, scalable exploitation of multiple processors in SMPs, and the use of a JVM as a 7x24 application server.
The Jalapeno JVM has two key distinguishing features. First, the Jalapeno JVM takes a compile-only approach to program execution. Instead of providing both an interpreter and a JIT/dynamic compiler, it provides two dynamic compilers --- a quick non-optimizing "baseline" compiler, and a slower production-strength optimizing compiler. Both compilers share the same interfaces with the rest of the JVM, thus making it easy to mix execution of unoptimized methods with optimized methods. Second, the Jalapeno JVM is itself implemented in Java! This design choice brings with it several advantages as well as technical challenges. The advantages include a uniform memory space for JVM objects and application objects, and ease of portability. The key technical challenge is to overcome the large performance penalties of executing Java code (compared to native code) that has been the experience of current JVMs; if we succeed in doing so, we will simultaneously improve the performance of our JVM as well as of the applications running on our JVM.
The Jalapeno project was initiated in end-1997 and is still work in progress. This talk will highlight our design decisions and early experiences in working towards our goal of building a high-performance JVM for SMP servers, with a focus on the design details of the Jalapeno optimizing compiler.
Functional Robotics, John Peterson (Yale) and Andrei Serjantov (Yale)
We present our experiences using a purely functional language, Haskell, in what has been traditionally the realm of low-level languages: robot control. Frob (Functional Robotics) is a domain-specific language embedded in Haskell for robot control. Frob is based on Functional Reactive Programming (FRP), as initially developed for Fran, a language of reactive animations. Frob presents the interaction between a robot and its stimuli, both onboard sensors and messages from other agents, in a purely functional manner. This serves as a basis for composable high level abstractions supporting complex control regimens in a concise and reusable manner.
We are using Frob to compete in Robocup 2000, a robotic soccer competition. In this environment, Frob controls an team of five radio-controlled robots as well as tracking the game using computer vision. We use many functional programming "tools of the trade" to build our controller such as polymorphic types, monads, and higher-order functions to build controllers that express complex interactive behaviors in a very declarative manner.