Lambda the Ultimate

Microsoft Phoenix
Phoenix is a software optimization and analysis framework that will be the basis for all future Microsoft compiler technologies.

I am not sure whether it is appropriate to ask for advice in this forum. If it isn't, please feel free to ignore/delete this message.

I have some questions regarding denotational semantics. I know operational semantics very well, but I did not yet understand some basic things about the denotational approach.

1. Every textbook says that "compositionality" is a very important property of d.s. I understand what this means. However, I have nowhere read *why* this is such an important property and what the consequences of being compositional are.

2. The examples of d.s. that are in most textbooks are so simple that they look trivially equivalent to a corresponding operational semantics. However, I read that d.s. is a more "abstract", "high-level" approach to describing the semantics. What would be an example where this property is evident in comparison to op. sem. ? Also, what are in general the advantages/disadvantages compared to op.sem.?

3. I have heard people say that writing an interpreter for a language in Haskell is roughly equivalent to writing a denotational semantics for it. Could somebody enlighten me why (or why not) this is the case?

A while ago I read about an alternative to SQL called something like 'Binary Query Language', which models data in (to me) the more intuitive way, thinking of sets and different types of relations (in the mathematical sense) between those sets, rather than using tables, foreign keys, joins etc like the relational model. It lets you do queries based around these relations using functions and multifunctions in a quite neat almost mathematical way.

Does anyone know what (if anything) became of these ideas? the only reference to BQL I can seem to trawl up through google is on this site, which offers an interesting explanation, some examples and a basic implementation in C++.

What I'm thinking at the moment is how useful would it be to write some kind of abstraction that translates these kind of queries into plain SQL on the fly, having generated a suitable SQL type database schema from the 'binary relations' type model.

I guess there are a lot of Object-Relational database things around at the moment designed for persisting object-oriented classes, but I don't think that's quite the same thing?

The Language List

Collected Information On About 2500 Computer Languages, Past and Present.

The History of Programming Languages

OCaml doesn't exist, and Smalltalk seems to have ceased before Java 1 was released - but we can see every point release for Python, PHP, Java, and Ruby (is an animal book a requirement for being on the poster?) and bizarrely Self (Has Self ever been used for real?).

Lush is a dialect of Lisp designed for scripting numerically intensive applications, particularly machine learning. Less verbose than Common Lisp, it seems better suited to quick scripting tasks, yet it compiles to C and integrates easily with existing C libraries.

From the Lush website:

Lush can be used advantageously for projects where one would otherwise use a combination of an interpreted language like Matlab, Python, Perl, S+, or even (gasp!) BASIC, and a compiled language like C. Lush brings the best of both worlds by wrapping three languages into one: (1) a weakly-typed, garbage-collected, dynamically scoped, interpreted language with a simple Lisp-like syntax, (2) a strongly-typed, lexically-scoped compiled language that uses the same Lisp-like syntax, and (3) the C language, which can be freely mixed with Lush code within a single program, even within a single function. It sounds complicated, but it is not. In fact, Lush is designed to be very simple to learn and easy to use.

Somebody else wants to embed XML fragments into their program code.

Some of what's proposed here really falls under PEP 318 for method decorators, I think.

Interpreted programming languages are increasingly gaining importance in both the commercial and scientific world.

Python, for instance, is used by both Hollywood's digital designers to script visual effects and astronomers, who like it because of its good support for numerical mathmatics. Perl has been the de facto standard for UNIX system administration for almost 20 years now and PHP already drives more than 15 million websites.

This world of interpreted programming languages, to which also C# and Java belong, is changing: New platforms and runtime environments like Microsoft.Net or Parrot (which will become the core of Perl 6) emerge while languages like PHP and Python evolve and younger languages like Ruby enter the stage.

The "1st International Workshop on Interpreted Languages" will take this into account and present current developments from the exciting world of interpreted languages as part of the Net.ObjectDays conference that is held September 27-30 2004 in Erfurt, Germany.

Since this shiny new forum is rather empty, let me get the ball rolling...

I have been thinking lately about ways to do programming without abstraction. Before you start yelling at me that this is not possible, don't take it too seriously, treat this as a thought exercise.

My motivation is twofold:

• non-programmers and beginners can't deal with abstractions, it is their biggest hurdle, they would rather just work with concrete stuff
• programmers (even good ones) aren't really any good at abstraction either. Being rather fanatic about abstracting driven by refactoring to get the best designs myself, it has become obvious to me that abstractions are a rather volatile and floating target. Programmers that think they create great abstractions ahead of time instead tend to produce stuff that just becomes a source of problems.

So the idea is to have a language where it is impossible to create abstractions, but rather the programming environment continuously refactors for you as you edit (yes this is a tall order, bear with me). This requires a visual editing environment rather than a tradition source + compiler environment.

My design sofar has you editing a tree based view of the actual unabstracted code. As you drag subtrees around, the environment marks things as shared/unshared (using a different background colour). This way, even functional abstraction can be created without the user even knowing what it is (creating a local change in a shared subtree is like having an argument to a function).

There are a lot of mucky details, but I believe it may be possible to have a system that always refactors for you to have the optimal sharing (thus abstraction) in the background, with the user needing to know next to nothing. Maybe a dream, but a fun experiment.

Most importantly: is there anything remotely similar to this out there? google wasn't particularly helpful sofar.