Abstract not found

Interfaces --- the collection of procedures and data structures that define a library, a subsystem, a module --- are syntactically poor programming languages. They have state (defined both by the interface's data structures and internally), operations on this state (defined by the interface's procedures), and semantics associated with these operations. Given a way to incorporate interface semantics into compilation, interfaces can be compiled in the same manner as traditional languages such as ANSI C or FORTRAN. This paper makes two contributions. First, it proposes and explores the metaphor of interface compilation, and provides the beginnings of a programming methodology for exploiting it. Second, it presents Magik, a system built to support interface compilation. Using Magik, software developers can build optimizers and checkers for their interface languages, and have these extensions incorporated into compilation, with a corresponding gain in efficiency and safety. This organization contrasts with traditional compilation, which relegates programmers to the role of passive consumers, rather than active exploiters of a compiler's transformational abilities. 1

its execution to account for contention in the environment. Similarly, for maximum performance an application must be able to adapt itself to the structure of the data as it evolves throughout the execution of the application. 2 Coping with the Problem: An Example from Scientific Computing One example where the performance requirements imposed by dynamism are most evident is in scientific and engineering computing, which encompasses particle simulations, stock market predictions, weather forecasting, drug design, and product engineering. The scientific computing community has turned to concurrency (i.e., parallelism) in response to the need for maximum performance. The language approach: High Performance Fortran. An important focus for this community has been the development of improved programming languages to address the tension between performance and backward compatibility, both of which are vital in a rapidly changing environment. The High Perfor

A multi-mode software system contains several distinct modes of operation and a controller for deciding when to switch between modes. Even when developers rigorously test a multi-mode system before deployment, they cannot foresee and test for every possible usage scenario. As a result, unexpected situations in which the program fails or underperforms (for example, by choosing a non-optimal mode) may arise. This research aims to mitigate such problems by creating a new mode selector that examines the current situation, then chooses a mode that has been successful in the past, in situations like the current one. The technique, called program steering, creates a new mode selector via machine learning from good behavior in testing or in successful operation. Such a strategy, which generalizes the knowledge that a programmer has built into the system, may select an appropriate mode even when the original controller cannot. We have performed experiments on robot control programs written in a month-long programming competition. Augmenting these programs via our program steering technique had a substantial positive effect on their performance in new environments.