We extend positive supercompilation to handle negative as well as positive information. This is done by instrumenting the underlying unfold rules with a small rewrite system that handles constraints on terms, thereby ensuring perfect information propagation. We illustrate this by transforming a naively specialised string matcher into an optimal one. The presented algorithm is guaranteed to terminate by means of generalisation steps.

A certifying compiler takes a source language program and produces object code, as well as a "certificate" that can be used to verify that the object code satisfies desirable properties, such as type safety and memory safety. Certifying compilation helps to increase both compiler robustness and program safety. Compiler robustness is improved since some compiler errors can be caught by checking the object code against the certificate immediately after compilation. Program safety is improved because the object code and certificate alone are sufficient to establish safety: even if the object code and certificate are produced on an unknown machine by an unknown compiler and sent over an untrusted network, safe execution is guaranteed as long as the code and certificate pass the verifier. Existing work in certifying compilation has addressed statically generated code. In this paper, we extend this to code generated at run time. Our goal is to combine certifying compilation with run-time code generation to produce programs that are both verifiably safe and extremely fast. To achieve this goal, we present two new languages with explicit run-time code generation constructs: Cyclone, a type safe dialect of C, and TAL/T, a type safe assembly language. We have designed and implemented a system that translates a safe C program into Cyclone, which is then compiled to TAL/T, and finally assembled into executable object code. This paper focuses on our overall approach and the front end of our system; details about TAL/T will appear in a subsequent paper.

"Have you used it in anger yet?" The time is a dozen years ago, the place is Oxford, and my fellow postdoc has just scrutinized my new bike. He's admired the chrome, checked the gears, noted the Kryptonite lock. Now he wants to know if I've used it to serious purpose. Gleaming chrome is well and good, but will it run you through the woods? "Have you used it in anger yet?" Having read the title of this column, you may have just asked the same question, though perhaps in different words. You've scrutinized functional languages. You've admired the elegance of lambda calculus, checked the benchmarks from the compilers, noted the security provided by strong typing. Now you want to know if they have been used to serious purpose. Mathematical elegance is well and good, but will it run that mission-critical system? Here are a half-dozen examplars of functional programs used in anger.

Logic programming and functional programming row in the same boat. Methods used to achieve success with one often transpose to the other, and both face similar obstacles. Here I offer a compendium of success stories for functional programs, followed by a list of obstacles to more widespread use of functional programming, in the belief that much of this experience is relevant to logic programmers. This material first appeared as columns in ACM SIGPLAN Notices [29, 30]. The final section contains a few remarks specific to the relations between functional and logic programming. 1 An angry half dozen “Have you used it in anger yet?” The time is a dozen years ago, the place is Oxford, and my fellow postdoc has just scrutinized my new bike. He’s admired the chrome, checked the gears, noted the Kryptonite lock. Now he wants to know if I’ve used it to serious purpose. Gleaming chrome is well and good, but will it run you through the woods? “Have you used it in anger yet?”

We have developed a model for the Tail Assignment problem. The model is very general, in the sense that it captures individual operational constraints, including airport curfews, maintenance, and preassigned activities, and is also possible to extend to mixed fleets. Since all operational constraints are considered, the solutions obtained are possible to operate right away, which is a major benefit compared to most other approaches to this problem. We present a solution algorithm based on column generation, that is able to quickly obtain solutions to problems of substantial size, as well as near optimal solutions. We show how constraint programming can be used at several stages in the solution process, to substantially decrease running times as well as increasing solution quality. Preprocessing algorithms based on constraint programming are presented, that can reduce the size of the problem substantially more than standard balance-based preprocessing, resulting in major speedups and increased solution quality. We have developed various integer fixing heuristics to find integer solutions. Some of the heuristics are aimed at finding near optimal solutions, and one is aimed at finding initial solutions quickly. With this method, solutions can be found within about 15 minutes for problems with up to 30 aircraft and around 6000 flights during one month. We have further shown how constraint programming can be used to improve the performance of the integer heuristics.