Lambda the Ultimate

Normally, I wouldn't link to this thread since it isn't specifically about programming languages.

However, programming languages are being mentioned, and static analysis tools discussed (esp. SPARK). Moreover, I think the dynamics of the debate are quite similar to the dynamics of the ongoing (and eternal) debate in the discussion group regarding static typing. Perhaps, seeing this sort of quicksand action hapenning in a different context can help us learn how to focus PL-related debates and make them more productive.

Note: I am not trying to rain on anyone's parade. In fact, I think LtU is better than most other forums when it comes to this kind of debate. But non-productive debates on these issues are a common problem in PL discussions.

The RDF Data Access Working Group is busy doing a survey of query languages and access techniques that have been used with RDF. Many resemble SQL in syntax, despite operating on a graph. Amongst the WG's Design Evaluations Links there's a recent submission of a different style from Howard Katz : XQuery-style RDF Query Language (XsRQL), which actually looks very procedural (like XQuery).

CMU Common Lisp's compiler, known as Python, has a sophisticated implementation of Common Lisp's powerful type system. The system primarily enforces type safety at runtime, but it also performs static type inference. The static type information is used to detect type errors, eliminate unnecessary runtime type checks, and select efficient primitive code (e.g. avoid excessively generic arithmetic).

CMUCL's history stretches back around twenty years, though I believe the compiler was rewritten "just" 15 odd years ago. The system is still widely used, notably by ITA software as publicised by Paul Graham.

Sven-Olof Nyström presented his Soft-typing system for Erlang at the 2003 ACM Erlang Workshop. I haven't tried it, but I thought it looked promising. His conclusions are thought-provoking too.

Mono 1.0 has been released, following a speedy set of beta releases. The detailed release notes are interesting. Mono is also being used to build Nemerle a "functional .NET language compiler".

From Peeking Inside the Box.

An interesting look at the addition of annotations to the next generation Java. Not sure what the main purpose of this metadata is, but the author discusses it in terms of debugging and instrumentation.

Annotation definitions look a lot like interface definitions, but the keyword @interface is used instead of interface and only methods are supported (though they act more like fields).

   public @interface Status {
       String value();
   }

I can now define my method as follows:

   @Status("Connecting to database")
   public void connectToDB (String url) {
       ...
   }

Best way to prove you are still with us is to post something!

If you encounter any difficulties, let me know.

I don't recall seeing the link to this set of slides here before.

In this paper,we explain an elegant technique for enumerating the positive rationals without duplicates. Moreover, we show how to do so as a simple iteration, generating each element of the enumeration from the previous one alone,with constant cost per element (assuming unit cost for simple operations on arbitrary-precision rationals). Best of all, the resulting program is extremely simple...

Cute. Nothing earth shattering, but fun none the less.

My position is that the creation of domain specific languages that do not seamlessly support the ability to transform information along the refinement scale are not helpful to us. So, for example, a component designer that is a stand alone tool unconnected to the class designer that provides the next logical level of refinement (classes being used to construct components) is a pot hole in the road from concept to actual implementation. Now, this is not as I have said to indicate that domain specific languages are bad, just that many of us in this industry love to create new languages be they graphical, textual or conceptual. We have to beware of the tendency to build these disjoint languages that force the user to keep stopping and jumping across another gap.

I am not sure I want to go back to the argument between IBM and Microsoft about this stuff, but I think the notion of refinement is important from a linguistic point of view (e.g., embedding, language evolution, type systems, reasoning etc.)

But can refinement of the sort discussed here work in practice, or does it depend on language-design savvy architects? Maybe the difference between IBM and Microsoft is that the IBM approach assumes all modelling knowledge will come pre-packaged, being designed by modelling professionals and embedded in tools, where as the Microsoft approach assumes more design expertise from users?

Feel free to correct me, I am really unsure where all this is heading anyway...