Lambda the Ultimate

A short news item about micro-rebooting courtesy of an ACM mail. Giving Bugs the Boot. Erlang anyone?

Hello everyone.

During my PhD I encountered a nice problem.

The system I was working on (an object-oriented database) evolved over time to use 4 different languages. Each language was tailored to one specific activity (querying, operations, data, meta-data).
They also are based on different programming paradigms: functional and imperative.

Over time I realized that the system could benefit from a merge of all these langauges in a single one.

I managed to do it and the result is interesting, but I could not find any material on such a procedure.

Does anyone of you know of some references/papers/articles related to the merging of programming languages?

On the same subject as the Scheme compiler in 90 Minutes, is the Essential Haskell Compiler. From the HC&AR summary:

The purpose of the EHC project is to provide a description a Haskell compiler which is as understandable as possible so it can be used for education as well as research


In order to avoid overwhelming the innocent reader, the description of the compiler is organised as a series of increasingly complex steps. Each step corresponds to a Haskell subset which itself is an extension of the previous step. The first step starts with the essentials, namely typed lambda calculus.



Sounds like BC Pierce's Types and Programming Languages.
Also notable is that EHC uses Utrecht's Attribute Grammars, which are interesting in their own right.

Not a terribly new paper, but things are slow and I don't think we've discussed it before:

Parameterized modules in Erlang

This is neat stuff, and it's actually been included in recent versions of Erlang. I once toyed with the idea of a language which emphasized an OO style with stateless objects (relying on Erlang-style concurrency patterns for management of state). It seems like Erlang has just made a huge leap toward being that language.

The caveat, though, is that I'm not actually an Erlang programmer, only an interested observer. Do any of the local Erlang folks have any thoughts on this?