An Incremental Approach to Compiler Construction (2006) [pdf] | Hacker News Reader

An Incremental Approach to Compiler Construction (2006) [pdf]

scheme2006.cs.uchicago.edu

111 pointsrspivak13 comments

Nada Amin, who gave the keynote at Strange Loop in 2014 "Programming Should Eat Itself" https://www.youtube.com/watch?v=SrKj4hYic5A

has worked through the implementation https://github.com/namin/inc

and provided the corresponding workshop documentation in her github account. https://github.com/namin/inc/blob/master/docs/tutorial.pdf

She's also been involved in contributing to the next generation Scala compiler (Dotty).

Here are some related papers you might be interested in (If you haven't seen them already):

http://lambda-the-ultimate.org/node/1589

http://www.cs.indiana.edu/~dyb/pubs/nano-jfp.pdf

http://www.cs.indiana.edu/~dyb/pubs/commercial-nanopass.pdf

What I'd like to see is "An Approach to Incremental Compiler Construction", i.e., a compiler that outputs code which evaluates its input incrementally wrt. previous inputs.

The best example I know of is Papa Carlo: http://lakhin.com/projects/papa-carlo/

I had been working on an incremental-compiler-generator in C++, but suspended the project recently because it's a lot of work.

Or how about a live programming environment that incrementally recomputes a new programming execution based on incremental changes to the program's code. Anyways, I've been working on this problem for a few years now...the first step is incremental compilation.

You're probably aware of Smalltalk already but in case you're not, I think it might be of interest to you. There's an open source implementation of Smalltalk called Pharo. They have a few screencasts and recordings of presentations at their website. http://pharo.org/documentation

Edit: Checked your profile. Going to say that yes, you almost certainly know about Smalltalk -- far more than do I.

I would argue this a lot with people like Gilad Bracha :), but ya. Incremental compilation is pretty trivial in Smalltalk though given the lack of a static type system.

...and no explicit native macro system either (lot can be laid atop it of course...).

There is a lot to be said for a language where a single edit somewhere in a program can't have snowballing effects across the entire codebase. In practice, that means deferring logic to the runtime...

Perhaps a nanopass framework is of interest? "a compiler as a collection of many fine-grained passes, each of which performs a single task" http://www.cs.indiana.edu/~dyb/pubs/nano-jfp.pdf

Using purely functional data structures and an AST walking interpreter one could make this fairly compact.

A bit old and it is in Pascal, but still, Let's Build a Compiler by Jack Crenshaw is also fun to read:

http://compilers.iecc.com/crenshaw/

A friend and I used this paper as part of an independent study in compilers, it was a lot of fun and I think strikes the right balance of concepts core to compiler construction. I highly recommend it.

Reply on news.ycombinator.com