Lambda the Ultimate

(Note: The title is meant to be humorous!)

XMLisp is the integration of Lisp with XML. The Lisp Meta Object Protocol is used to establish a simple and highly efficient mapping between CLOS objects and the XML extensible markup language. It is not just an API to read XML files and turn them into some Lisp flavored representation. Instead, it integrates Lisp and XML into one environment at two levels. At a language level it allows the arbitrary combination of Lisp expressions and XML elements. CLOS objects can be printed as XML elements. XML elements evaluate into CLOS objects. At a tool level XMLisp allows users to fluidly experiment with XML. Type XML elements into the lisp listener. Evaluate complete or parts of hierarchical XML elements. Inspect complex XML elements using the inspector. Get support from symbol completion when editing XML.

I stumbled across this while porting more layers of the Open Agent Engine to OpenMCL. While at first it seems a little weird, it's actually quite an amazingly natural way of integrating Lisp and XML.

It's neat to work with XML fragments as an inspectable CLOS object hierarchy. I think XMLisp is also a great example of the flexibility available to Lisps of all flavors; I'm sure some industrious soul could easily port it to PLT Scheme or something similar!

I've been asked to review some papers on the topic of application development using dynamically typed languages. Many of these papers make claims about static typing that I believe are untrue. However, I believe there is a limit on what can practically be achieved with static typing, and there certainly is a limit on what can practically be achieved right now. Where do you think that limit lies? Some ideas: Anything involving runtime code modification seems difficult. Meta-circularity likewise. Most current statucally typed languages offer no useful support for arrays.

Concoqtion: Indexed Types Now!

Almost twenty years after the pioneering efforts of Cardelli, the programming languages community is vigorously pursuing ways to incorporate F_ω-style indexed types into programming languages. This paper advocates Concoqtion, a practical approach to adding such highly expressive types to full-fledged programming languages. The approach is applied to MetaOCaml using the Coq proof checker to conservatively extend Hindley-Milner type inference. The implementation of MetaOCaml Concoqtion requires minimal modifications to the syntax, the type checker, and the compiler; and yields a language comparable in notation to the leading
proposals. The resulting language provides unlimited expressiveness in the type system while maintaining decidability. Furthermore, programmers can take advantage of a wide range of libraries not only for the programming language but also for the indexed types. Programming in MetaOCaml Concoqtion is illustrated with small examples and a case study implementing a statically-typed domain-specific language.

The follow-up to Concoqtion: Mixing Indexed Types and Hindley-Milner Type Inference, discussed earlier. Good stuff.

Update: There's now a public Concoqtion web site!

Josh, does this answer your question? :-)

When published, this collection of essays edited by Greg Wilson and Andy Oram will likely be of interest to LtU readers.

Among the contributors are Brian Kernighan, Simon Peyton Jones (whose contribution we already discussed) and Kent Dybvig.

Take a look at the ToC and let us know which essay titles intrigue you the most...

The Pirahã were discussed here a couple of times, in the context of the linguistic relativity hypothesis (Sapir-Whorf). One of the controversial claims about the Pirahã language was that it lacked recursion (which is found in all human languages, and is seen as an essential feature of human language).

This paper by Andrew Ira Nevins, David Pesetsky, and Cilene Rodrigues attempts to refute many of the fantastic claims about Pirahã, and includes a detailed argument against the claims about the lack of syntactic recursion and embedding (to get to the full text, click on the title at the top of the page).

The intent of this workshop is to examine more closely the intersection between programming languages and mechanized mathematics systems (MMS). By MMS, we understand computer algebra systems (CAS), [automated] theorem provers (TP/ATP), all heading towards the development of fully unified systems (the MMS), sometimes also called universal mathematical assistant systems (MAS) (see Calculemus 2007).