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.

If you're interested in attending the Programming Languages Day, please register by sending an e-mail with your name, affiliation, and contact information to Frank Tip.

Last updated monday Mar 13, 2000 by Frank Tip.