A supercompiler is a program transformer of a certain type. It traces the possible generalized histories of computation by the original program, and compiles an equivalent program, reducing in the process the redundancy that could be present in the original program. The nature of the redundancy that can be eliminated by supercompilation may be various, e.g., some variables might have predefined values (as in partial evaluation), or the structure of control transfer could be made more efficient (as in lazy evaluation), or it could simply be the fact that the same variable is used more than once. The general principles of supercompilation are described and compared with the usual approach to program transformation as a stepwise application of a number of equivalence rules. It is argued that the language Refal serves the needs of supercompilation best. Refal is formally defined and compared with Prolog and other languages. Examples are given of the operation of a Refal supercompiler implemented at CCNY on an IBM/370.

This paper presents our toolkit for developing a Java-bytecode translator. Bytecode translation is getting important in various domains such as generative programming and aspect-oriented programming. To help the users easily develop a translator, the design of our toolkit is based on the reflective architecture. However, the previous implementations of this architecture involved serious runtime penalties. To address this problem, our toolkit uses a custom compiler so that the runtime penalties are minimized. Since the previous version of our toolkit named Javassist has been presented in another paper, this paper focuses on this new compiler support for performance improvement. This feature was not included in the previous version.

This paper gives a gentle introduction to Turchin's supercompilation and its applications in metacomputation with an emphasis on recent developments. First, a complete supercompiler, including positive driving and generalization, is defined for a functional language and illustrated with examples. Then a taxonomy of related transformers is given and compared to the supercompiler. Finally, we put supercompilation into the larger perspective of metacomputation and consider three metacomputation tasks: specialization, composition, and inversion.

We describe generative programming, an approach to generating customized programming components or systems, and active libraries, which are based on this approach. In contrast to conventional libraries, active libraries may contain metaprograms implementing domainspecific code generation, optimizations, debugging, profiling and testing. Several working examples (Blitz++, GMCL, Xroma) are presented to illustrate the potential of active libraries. We discuss relevant implementation technologies.

This paper describes three techniques for efficiently implementing reflective languages, which have been proposed by several researchers including the author. The paper presents that, despite their superficial differences, the three techniques are similar techniques based on the same idea, which is to perform meta computation as early as possible. The differences are the way to transform the protocol and what kind of languages the technique is suitable for. This paper also shows that one of the three techniques, a compile-time MOP, is suitable for statically typed languages, and experimentally illustrates that the technique actually improves the execution performance while keeping the ability for extension. 1 Introduction Reflective languages allow programmers to extend the languages through meta interface often called a metaobject protocol (MOP). Their practical significance have been presented by a number of researchers [20, 4, 19, 11, 23], while the difficulty of efficient implemen...

this report is to provide information concerning work done, problems encountered, and difficulties overcome while the project for the EL1 partial evaluator has been underway since October, 1972

: A reasoning method that proves a predicate logic formula by reducing its graph representation is proposed. Since the method directly reduces a logic formula represented by a graph, it can be understood to self-optimize a graph representation, meaning that it automatically transforms a logic formula into an efficient form equivalent to that acquired by Explanation-Based Learning. By sharing the original subgraphs between the learned formulae, reasoning efficiency does not deteriorate even after learning several examples. Therefore, the utility problem is overcome in the sense that no extra search is necessary for macros. The present paper demonstrates these facts in simple list manipulation problems and by proving geometric theories. 1 Introduction Neural networks are superior to knowledge representation due to their natural learning ability. However, in contrast to pattern recognition or voice synthesis, AI applications require structured descriptions with variables, which are not ...

The recent expert pro) ammers who have been fo rcedto develo large and co plicated proU ams have str o g desire to write"go o dco des" fr the viewpo intso f bo th runtime e#ciency and understandability, and they expect a translato to generate ago o dco de justto fit theiro wn needs if p o sible. This fitting usually requires co plicated custo izatio o f the translato which co ld o ly be do ne by the experienced co piler experts, and the proU ammers canno t reflect their ideas o the translato s so easily, especially when the proU ammer's demandsto the qualityo f practical proC amming to o are severe. These situatio s lead usto the necessityto develo a mo re flexible appro ach by which the specificpro grammers can reflect their experience and kno wledge o the translato s by themselves. The techno lo+ that enables the reuseo f larger s o tware co po nents have beco e available with the emergence o theo bject-o iented paradigm, which have widened the applicabilityo f reusable co de pieces. Ho wever, the class-basedo bjecto iented mo dularizatio canno t always encapsulate every design decisio s perfectly; especially when they cr o scut the mo dule structure o a proC am, co de pieces cr o scutting a pro) am tangle with oz er co des and scattero ver the entire proU am; hence, class-based mo dularizatio is eventually vioCCCS . This kind o vioUNLN( may happen mo dern netwo k proS amming invo lving distributio no r security issues. This thesis addresses ho w to so lve these cro sscuttingpro blems witho ut lo ing o ject-o iented framewo rk's appearance o runtime perfo rmance. To co e with bo th o these two pr o lems, transfo rmatio al system is to be used to embed the cr o scuttingco de am o g the entire proS am au to atically and hide the scattered co de fro m the appearance. Ru...

A connection graph represents resolvability in a set of clauses explicitly. The corresponding connection graph proof procedure has the deficiency that the graphs may grow, becoming impractical to handle. We present a novel proof procedure for condition graphs, which is a refinement of connection graphs. Our idea is to control the growth of the graph by recognizing tests in clauses and translating them to restrictions on the resolvability of links. A link is not selected for resolution unless all its associated tests have been determined to be true.

Meta-level compositions of object logic programs are naturally implemented by means of meta-programming techniques. Meta-interpreters defining program compositions however suffer from a computational overhead that is due partly to the interpretation layer present in all meta-programs, and partly to the specific interpretation layer needed to deal with program compositions. We show that meta-interpreters implementing compositions of object programs can be fruitfully specialised w.r.t. meta-level queries of the form Demo(E,G), where E denotes a program expression and G denotes a (partially instantiated) object level query. More precisely, we describe the design and implementation of a declarative program specialiser that suitably transforms such meta-interpreters so as to sensibly reduce --- if not to completely remove --- the overhead due to the handling of program compositions. In many cases the specialiser succeeds in eliminating also the overhead due to meta-interpretation...