DrScheme is a programming environment for Scheme. It fully integrates a graphicsenriched editor, a parser for multiple variants of Scheme, a functional read-eval-print loop, and an algebraic printer. The environment is especially useful for students, because it has a tower of syntactically restricted variants of Scheme that are designed to catch typical student mistakes and explain them in terms the students understand. The environment is also useful for professional programmers, due to its sophisticated programming tools, such as the static debugger, and its advanced language features, such as units and mixins.Beyond the ordinary programming environment tools, DrScheme provides an algebraic stepper, a context-sensitive syntax checker, and a static debugger. The stepper reduces Scheme programs to values, according to the reduction semantics of Scheme. It is useful for explaining the semantics of linguistic facilities and for studying the behavior of small programs. The syntax checker annotates programs with font and color changes based on the syntactic structure of the program. On demand, it draws arrows that point from bound to binding occurrences of identifiers. It also supports α-renaming. Finally, the static debugger provides a type inference system that explains specific inferences in terms of a value-flow graph, selectively overlaid on the program text.

Financial companies, engineering firms and even scientists create increasingly larger spreadsheets and spreadsheet programs. The creators of large spreadsheets make errors and must track them down. One common class of errors concerns unit errors, because spreadsheets often employ formulas with physical or monetary units.In this paper, we describe XeLda, our tool for unit checking Excel spreadsheets. The tool highlights cells if their formulas process values with incorrect units and if derived units clash with unit annotations. In addition, it draws arrows to the sources of the formulas for debugging. The toolis sensitive to many of the intricacies of Excel spreadsheets including tables, matrices, and even circular references. Using XeLda, we have detected errors in some published scientific spreadsheets.

We consider the problem of selective and lightweight closure conversion, in which multiple procedure-calling prot o-COIS may coexist in the same code. Flow analysis is used to match the protocol expected by each procedure and the protocol used at each of its possible call sites. We formulate the flow analysis as the solution of a set of constraints, and show that any solution to the constraints justifies the resulting transformation.Some of the techniques used are suggested by those of abstract interpretation, but others arise out of alternative approaches.

VEC is a higher-order functional language of nested arrays, which includes a general folding operation. Static computation of the shape, of its programs is used to support a compositional cost calculus based:on a cost monad. This, in turn, is based on a cost algebra, whose operations may be customized to handle different cost regimes, especially for parallel programming. We present examples based on sequential costing and~on the PRAM model of parallel computation. The latter has been implemented in Haskell, and applied to some linear algebra examples. I n t r o d u c t i o nSecond-order combinators such as map, fold and zip provide programmers with a concise, abstract language for writing skeletons for implicitly parallel programs, as in [Ski94], but there is a hitch. These combinators are defined for list programs (see [BW88]), but efficient implementations (which is the point of parallelism, after all) are based on arrays. This disparity becomes acute when working with nested arrays, which are rarely supported in parallel practice. NESL [BCH+94] is a notable exception, but still does not support folding over them. Our approach is to redevelop the theory of arrays to support the combinators while retaining constant-time access. We illustrate the efficacy of this approach by implementing static estimates of shapes and parallel work, as compared to, say, the dynamically obtained estimates for NESL [BG96].Efficient array access is based on direct access to the storage of array entries, typically in contiguous blocks of memory. List storage, however, is by allocating cons cells during evaluation, which introduces significant access costs. Our approach to arrays uses the syntax of lists, so that combinators can be introduced in the functional style, but constrained so that a compiler can still determine the length, or more generally the shape, of any array expression. This process of shape analysis can be thought of as compile-time/run-time separation in a two-level operational semantics INN92]. Success requires that the program be shapely, that is, the shape of the result is determined by those of its inputs, as is typical in, say, linear algebra. Shapeliness, and successful shape analysis, require a new approach, which we have illustrated in a small functional language, VEC.1. This operation is shapely: the result is an integer, a datum whose shape is trivial and therefore unaffected by the condition.

We consider the problem of lightweight closure conversion, in which multiple procedure call protocols may coexist in the same code. A lightweight closure omits bindings for some of the free variables of the procedure that it represents. Flow analysis is used to match the protocol expected by each procedure and the protocol used at its possible call sites. We formulate the flow analysis as a deductive system that generates a labeled transition system and a set of constraints. We show that any solution to the constraints justifies the resulting transformation. Some of the techniques used are similar to those of abstract interpretation, but others appear to be novel.