This paper (essentially [12, Chapter 8]) describes partial evaluation for the lambda calculus, augmented with an explicit fixed-point operator. The techniques used here diverge from those used in [12, Chapters 4, 5] and [11] in that they are not based on specialization of named program points. The algorithm essentially leaves some operators (applications, lambdas, etc.) untouched and reduces others as standard evaluation would do it. This simple scheme is able to handle programs that rely heavily on higher-order facilities. The requirements on binding-time analysis are formulated via a type system and an ecient binding-time analysis via constraint solving is outlined. The partial evaluator is proven correct.

I present a handy (though somewhat restrictive) way to implement mobile computation a la Telescript on top of standard Scheme. Background. Mobile computation is an ecient and eective approach to distributed programming where a program works by migrating from one host to another. The migration is called transparent if the execution state of the program is preserved before and after the migration. Transparent migration is preferable to non-transparent, because it is easier to use for application programmers. At the same time, however, it is harder to implement for language developers: all existing implementations (to my knowledge) of transparent migration need either a custom runtime system (e.g. [13]) or global source code transformation (e.g. [12]). Our Method. In this presentation, I describe a library to enable transparent migration in standard Scheme. Unlike existing implementations, it requires neither modication of the runtime system nor transformation of the source code. It ...

Recent research suggests that the goal of fully automatic and reliable program generation for a broad range of applications is coming nearer to feasibility. However, several interesting and challenging problems remain to be solved before it becomes a reality. Solving them is also necessary, if we hope ever to elevate software engineering from its current state (a highly-developed handiwork) into a successful branch of engineering, capable of solving a wide range of new problems by systematic, well-automated and well-founded methods.

This paper presents a hybrid method of partial evaluation (PE), which combines the power of online PE and the efficiency of offline PE, for a typed strict functional language. We begin with a naive online partial evaluator, and make it ecient without sacrificing its power. To this end, we (1) use state (instead of continuation) for let-insertion, (2) take a so-called cogen approach, and (3) decrease unnecessary computations - such as unnecessary let-insertions and unused values/expressions - with a type-based use analysis, which subsumes various monovariant binding-time analyses. Our method yields the same residual programs as the naive online partial evaluator, modulo inlining of redundant let-bindings. We implemented and compared our method and existing methods, both online and offline. Experiments show that our method is at least twice as fast as any ot...

We present a novel technique for offine partial evaluation of functional languages with an ML-style typing discipline. Our program specialization method comprises a polymorphic binding-time analysis with polymorphic recursion. Based on the region calculus of Tofte and Talpin, we develop a binding-time analysis as a constraint analysis on top of region inference. Our insight is to regard binding times as properties of regions.

Continuation-based partial evaluation is an implementation technique for program specializers that allows generated code contexts to commute with specialization-time values. Thus it enables additional specialization-time computations. As the name suggests, a popular implementation is based on the manipulation of continuations. We show that a...

The PGG system is a partial evaluation system for the full Scheme language as defined in the R5RS report [19]. It has the following features -- offline partial evaluation using the cogen approach; -- correct specialization of imperative code; -- side effects performed at specialization time; -- modular specialization; -- no restrictions on primitives and static inputs (they are not restricted to have first-order types); -- handles eval, apply, call-with-values, and control operators correctly; -- flexible control of memoization; -- language extensions (user-defined algebraic datatypes, make-cell, cell-set!, cell-ref, cell-eq?); -- representation analysis; -- fast specialization (the system produces generating extensions); -- multi-level specialization. As a non-feature, the system does not have a post-processor. This manual does not contain explanatory material about offline partial evaluation. Section 7.1 gives some pointers to relevant literature.

Monitored execution is a proven tool to enforce safety properties on