Matthias Felleisen, Web Scripting, Web Serving

Web scripting (cgi, applets) is becoming more and more important. Building interactive Web scripts is a complex problem, because browsers support backtracking, cloning, and bookmarking. I will indicate in this talk how PLT has solved the problem with a special-purpose server and a new script compiler.

Jacob Matthews, Compiling Web Scripts for Apache

CGI scripts must be organized by interaction with the user, not by logical computation. This requirement simplifies Web servers, but impairs program development. My talk demonstrates how to eliminate that drawback by compiling normal PLT Scheme programs into CGI style automatically.

Paul Graunke, From Web Scripts to GUI Wizardry

Web browsers permit consumers to backtrack, clone, and bookmark sites for future visits during interactions. My talk will show how to adapt this general and powerful form of interaction to a class of GUIs, including wizards.

Karl Lieberherr, Declarative Techniques for Improving Aspect Orthogonality

Subgraph specifications are fundamental to robust Aspect-Oriented Programming. We present a declarative notation for subgraph specifications and show (using AspectJ and DJ) how three semantics for the notation lead to aspects that are more loosely coupled with other aspects.

Doug Orleans, Incremental Programming With Extensible Decisions

Predicate dispatch makes decisions extensible by allowing the branches of a decision to be defined separately, which allows a program to be written as a set of increments. I will present a generalized form of predicate dispatch that supports an aspect-oriented programming style.

Johan Ovlinger, Aspectual Collaborations

Aspect-oriented programming attempts to significantly decrease maintainance burdens of complex applications by controlling the interaction of their various facets. We present yet another AOP implementation which provides a module-like construct with the novel feature of combining separate compilation of aspectual features with a powerful module language.

David Lorenz, Designing Components versus Objects

A good object-oriented design does not necessarily make a good component-based design, and vice versa. What design principles do components introduce? This talk examines component-based programming and how it expands the design space in the context of an event-based component architecture.

Galen Williamson, Small Step Analysis

We introduce a new proof technique for showing the correctness of 0CFA-like analyses with respect to small-step semantics. We illustrate the technique by proving the correctness of 0CFA for the pure lambda-calculus under arbitrary beta-reduction. This result was claimed by Palsberg in 1995; unfortunately, his proof was flawed. We provide a correct proof of this result, using a simpler and more general proof method. We illustrate the extensibility of the new method by showing the correctness of an analysis for the Abadi-Cardelli object calculus under small-step semantics.

Philippe Meunier, MrFlow: Why MrSpidey Failed

MrSpidey, DrScheme's static analyzer, uses a selector-based framework that is too conservative. Annotating selectors gives a better analysis, but a high running time. MrFlow, a new analyzer, uses a conditional-constraints-based framework that gives a precise analysis too and a good running time.

Mitch Wand, More Results on Small Step Analysis

We will present two results:

• Ordinary 0CFA is now known to be sound for unrestricted beta-reduction, so it is sound for both call-by-name and call-by-value reduction. We show simple modifications to 0CFA that can distinguish between call-by-name and call-by-value.
• We give a 0CFA-style analysis and show its soundness for a small-step environment/continuation/store machine. This provides a simpler alternative to the semantics of (Flanagan and Felleisen 95), and we show that it is more powerful than the semantics of (Palsberg 95).

Will Clinger, Oldest-Generation First Collections

Not available.

John Clements, Continuation Marks: A Lightweight Stack Inspection Mechanism

Continuation marks are a novel and lightweight mechanism for manipulating continuations. The talk shows how continuation marks enable the construction of a high-level debugger, independently of the compiler. I will also discuss how continuation marks are useful for non-intrusive stack inspections for security purposes and aspect-oriented programming.

Paul Steckler, Components for Scheme

We describe two pieces of software for PLT Scheme. MysterX is a COM toolkit allowing Scheme programs to script components. MzCOM is a COM class that allows COM clients to run Scheme code.

Paul Steckler, Databases

We describe preliminary work on integrating database access in PLT Scheme. SrPersist is an extension that offers ODBC to Scheme programs. Unfortunately, ODBC is a mismatch with the Scheme programming model. Can we build a functional layer atop ODBC?

Robby Findler, Behavioral Software Contracts for Java

In the object-oriented world, pre- and post-condition contracts on overriding methods must be properly related to the contracts on overridden methods. This talk demonstrates how existing contract checkers fail to enforce these relationships, why this causes problems, and how to fix it.