Lambda the Ultimate

I was wondering what people would consider Perlis languages, i.e. languages worth knowing because they should change how you think about programming. Obviously there is a lot of overlap between languages so what I'm looking for is a minimal set of established languages (by that I mean 10 years or older) that still provides a reasonably complete overview of different approaches to programming. My first try at a list would look something like:

Ada, C, Haskell, Java, Lisp, Smalltalk, Perl

I'm currently designing a small, uniquely typed language for a masters project. So far the semantics is pretty well mapped out and I'm looking for a suitable backend to compile to.

Although the language has been designed as an imperative language with referential transparency, it can be translated fairly directly into Haskel, however doing so loses most of the benefits of having uniqueness typing, i.e. object lifetime can be determined at compile time meaning no garbage collection and safe destructive updates. I'd like to find a suitable backend/vm to compile to that will allow me to take advantage of these properties.

It would be nice to be able to include laziness and implicit parallelism too, although neither is essential and are perhaps beyond the scope of my project. Having said that, a backend that supports concurrent programming would be very useful, as uniqueness typing allows for an interesting model of concurrency without deadlocks or race conditions....

I can happily provide more concrete information on the language (I should really give it a name) if needed, I'm not sure of the kind of thing that's important to consider.

A previous discussion on this site talked about how linear languages can be compiled using stack machines and permutations, so some sort of stack based vm might be a good idea.

Thanks!

Large Scale Graph Computing at Google - on the official Google Research blog.

Here is an extract -

... we have created scalable infrastructure, named Pregel, to mine a wide range of graphs. In Pregel, programs are expressed as a sequence of iterations. In each iteration, a vertex can, independently of other vertices, receive messages sent to it in the previous iteration, send messages to other vertices, modify its own and its outgoing edges' states, and mutate the graph's topology (experts in parallel processing will recognize that the Bulk Synchronous Parallel Model inspired Pregel).

I wouldn't say this is directly PLT related, but it is a parallel programming model - compute-communicate-synchronize-loop - that is probably of interest to language buffs from the DSL angle, like the GPU programming models.

The following personal request is not directly LtU related, but I know it might be of interest to some LtU members. I hope I am forgiven this minimal interruption.

Together with a colleague I am writing an introductory textbook on biological computation. The book is intended for people with limited or no background in biology and biological computation and introduces cellular automata, evolutionary computation, molecular computation, and neural networks. The book also includes more cursory introductions to several other techniques.

We are now finishing the draft, and will welcome comments about the material and the presentation from people interested or knowledgeable in this area who would like to review drafts of one or more chapters.

If anyone is interested, please drop me a line. Due to various constraints, we will only be able to send drafts to a limited number of people.

For future announcements related to the book please follow @BioComputing on twitter.

Ruby has method_missing.

What other languages have solid support for such interceptors?

There is much interest in considering catchalls for a future version of Javascript:
http://wiki.ecmascript.org/doku.php?id=strawman:catchalls

What are the pros and cons of having interceptors in a language?

Why FPL are (mostly) based on GRS instead of LTRS? Recursive let seems not be so useful, but cyclic links in data makes automatic reasoning very hard and gives another evil source of nontermination.

Perhaps if LTRS was selected we are full of useful total functional languages nowadays.

I am working on a rather simple object-oriented programming language. Here are some minor differences from a Java:

1. No downcasting (i.e. casting from a super-type to a sub-type [edit: thanks Ohad!])
2. A universal variant (i.e. can hold any value plus type information)
3. No virtual functions (dynamic dispatch through interfaces only)

What I am wondering about now (and I wrote a bit more on my blog) is whether preventing downcasting would cause any long term problems (in other words, has the community reached a consensus on this issues), and whether a variant type can cause violations of the Liskov substitution principle. Any insights into the problem, would be appreciated.

The famous three approaches to programming language semantics are axiomatic, operational and denotational semantics. The famous two approaches to logic semantics are proof theory and model theory.

I find denotational semantics similar to model theory, and operational semantics similar to proof theory. However, I find no analogue to axiomatic semantics, and I wonder if there is one, and if not, why?

In model theory, one takes an abstract logical language and defines its meaning within an existing theory: classical logic is interpreted in set theory (models are simple sets), intuitionistic logic in Kripke Scenarios (or Heyting Algebras), etc. In essence, we define the meaning of the new language in terms of existing, familiar languages. This is no other than denotational semantics, where our programs denote structures in existing, well-defined structures.

In proof theory, we associate no inner meaning with the language. Rather, the meaning emerges out of the symbol pushing that is the proofs. Operational semantics operates along the same lines, mechanically manipulating program text, and the meaning emerges out of the textual juggling. Moreover, many modern operational semantics are actually given as a proof system, the theorems being the valid executions of the language.

However, I do not recognise a similar analogy for axiomatic semantics. Am I missing something? Or is it simply because we do not want to explain one logic with another? Or perhaps the power of axiomatic semantics is the augmentation of the computable language with uncomputable/high complexity constructs, something that does not always interest logicians?

See here.

Hello All,

I hope this is not off topic.

Jacques Pitrat (one of France's first Artificial Intelligence researcher, working on symbolic and declarative meta-knowledge.) has just published his Malice constraint satisfaction problem solver (GPLv3 licence).

While the user interface of Malice is very primitive, the ideas and formalisms implemented inside Malice could interest some people.

I also found his book Artificial Beings (the conscience of a conscious machine) interesting, and provocative, explaining the interest of reflective software systems.

Regards.