Lambda the Ultimate

Aggressive Type Inference

In talking with people at last year's Python Conference (IPC7), I mentioned the possibility of writing a Python compiler... in Python. Not content to stop there, I suggested that the idea could be taken further, to translate Python code into Perl.
[...]
What does this have to do with type inference? The translated Perl code must have the $@%&* type specifiers on all Perl variables.

Can we look at this as a constructive proof that funny characters are (mostly) not needed by compiler, and are there only to please the programmers?

I decided against posting this in the thread that mentioned ugly syntax (not of Python), as it was pretty long and losing focus already.

From the release notes (http://llvm.cs.uiuc.edu/releases/1.5/docs/ReleaseNotes.html):

The release now includes support for proper tail calls, as required to implement languages like Scheme... In LLVM 1.5, the X86 code generator is the only target that has been enhanced to support proper tail calls (other targets will be enhanced in future). Further, because this support was added very close to the release, it is disabled by default. Pass -enable-x86-fastcc to llc to enable it (this will be enabled by default in the next release).

Is it time to create a PLT front-end for LLVM?
George

For FractaSketch. My kids love it!

For "Logic programming in the context of multiparadigm programming: the Oz experience". I always knew Oz was interesting. But, without a lot of time to sit down and write programs, how does one come to grips with a new paradigm? This paper does the trick.

Thanks, Peter!

Having just got back from the Reynoldsfest at MFPS, where part of the emphasis was on encouraging folk to look at Reynolds work, let me write down some of what was recommended.

My personal favorites:
Definitional Interpreters (this one changed my life when I was a graduate student)
Gedanken
Towards a Theory of Type Structure
Types, Abstraction and Parametric Polymorphism
The Essence of Algol
Syntactic Control of Interference
Three Approaches to Type Structure (tutorial)
The Discoveries of Continuations (history)

Some papers recommended by others:
The Craft of Programming (recommended by Cliff Jones)
Relating direct and continuation semantics (Filinski's favorite -- this one is tough going)
Separation Logic: A Logic for Shared Mutable Data Structures

Also, while I'm at it, let me recommend
You and Your Research, by Richard Hamming. Want to do Nobel-class research? It's not just a matter of luck. Here is a nuts and bolts guide, from the third winner of the Turing Award.