Lambda the Ultimate

An old saw: IIUC, a problem faced by programming languages is that there are multiple dimensions which ideally could all be serviced, but in the end in 2D ASCII aren't. The "expression problem" is a classic example thereof. I am wondering what the current state of the art is / new promising directions people have seen?

For me, a big part of the problem is that "it depends". When I'm writing code it doesn't bug me to have it split up, but when I'm debugging code I'd rather see things "linearized" rather than have to chase through inheritance relationships to figure out the total gestalt. What underlying representation could we have to allow us to view the code in different ways?

Subtext (RIP?), CoreTalk (ok, that might be impenetrable), what else? Are we just doomed as long as we're still using ASCII? If so, what is the least offensive approach? Generic programming a la STL? Multimethods? How can we ground the investigation: what metrics tell us which approach is best / does the least harm?

FringeDC is a group in Washington DC interested in functional and fringe programming languages (Lisp, Haskell, Erlang, Clojure, Prolog, etc.)

www.lisperati.com/fringedc.html

In this presentation, Philip Fominykh will be presenting readtables, MOP, persistency of image, FFI, readtime/runtime separation and similar Common Lisp subjects. The presentation will be geared towards non Lispers, so don't be intimidated! The meeting is generously hosted by Clark & Parsia (tinyurl.com/6wmmbj) located at 926 N St NW rear Studio #1 Washington DC and is near the Convention Center Metro Stop.

Map: tinyurl.com/7mbc4o
(I recommend checking the Clark & Parsia website for detailed directions to the office)

Anyone is welcome to join our meetings!

In Semantics of Memory Management for Polymorphic Languages (1997) Greg Morrisett and Robert Harper

...present a static and dynamic semantics for an abstract machine that evaluates expressions of a polymorphic programming language. Unlike traditional semantics, our abstract machine exposes many important issues of memory management, such as value sharing and control representation. We prove the soundness of the static semantics with respect to the dynamic semantics using traditional techniques. We then show how these same techniques may be used to establish the soundness of various memory management strategies, including type-based, tag-free garbage collection; tail-call elimination; and environment strengthening.

This should keep the formal semantics LtUers happy for a little while. But is all the machinery necessary? Is there an easier way to prove that garbage can be thrown out?