Lambda the Ultimate

Ive been trying for some time to find out more information about this language. If anyone has any documents on it, could they please send me a copy?

According to this there should be some papers in the library of congress somewhere, but since I live in australia I obviously have problems getting to them. If anyone can get me copies of almost any of the papers listed there (the last one, for example, doesnt look interesting), I am willing to pay money for them. Of particular interest are items 75, 188, 192-195, 198, 204, 208 and 209.

The holy grail in this search (from what I know at the moment) would be the compiler developed at the IBM Almaden Research Center around 1990, and the FL Language Manual.

In my recent adventures researching modeling languages I came across a language not previously mentioned on Lambda-the-Ultimate.org called Kermeta. From the reference manual:

Kermeta is a Domain Specific Language dedicated to metamodel engineering. It fills the gap let by MOF which defines only the structure of meta-models, by adding a way to specify static semantic (similar to OCL) and dynamic semantic (using operational semantic in the operation of the metamodel). Kermeta uses the object-oriented paradigm like Java or Eiffel.

There is a list of published papers related to Kermeta here.

An implementation of this little language is now available. Genyris is a Lisp derivative with classes which allows an object to belong to multiple classes at once. (This is not multiple inheritance - each object has not just one class but a set of them.) Anything can be "tagged" as a member of a class (including cons cells, atoms). Once tagged, programmers can use OO-style methods, inheritance etc to play with the objects. The goal is to align the language with the world of RDF and OWL. This is a not an academic creation and makes no claims for originality - but it might amuse. If you like it please let me know.

Hi,

This is my first post to these forums, so I'm not sure its exactly the best place. If anyone can suggest a better places for the topic then I'd be very interested in hearing them. Also, I'm not sure exactly on the latest terminology so I'll explain in a bit more detail to start of what I'm attempting to do. Ok, that's the disclaimers out of the way.

I am currently designing a new programming language that is based on a non-text based representation. That is, you will need a more complex editor than just a text editor to modify the code. The programmer will be editing the AST directly. The aim of this programming language will be that everything will be stored & communicated in the same format. That includes language, the byte code, the data, etc. The language will be Object oriented with a lisp feel (closures, etc).

I know the idea of developing a programming language that is non-text based is not original. Does anyone know of any university or other projects that have developed this type of system?

The real reason for this post is that I'm interested in how this type of programming will change the semantics and basic structure of the language. An important aspect of this language will be modifying objects to become data, making objects from data, transforming data and executing data (ie transforming data to a series of instructions).

I'll show a few examples to explain what I'm talking about.

Objects to/from data
--------------------

I'll explain using a simple made up class.

class Foo {
int x;
String str;
Bar b;

int getX()
{
return x;
}
....
}

The Foo class will need to be transfered in communications, written to file etc. However, a lot of the time what is transfered is different from the data format. Lets say I have two formats:

Data FooData: { u32["x"], u8ascii["str"], BarData["b"] };
Data BasicFooData:{ u32["x"], u8ascii["str"] };

The first data FooData has all three bits of data transfered and the second one doesn't include the bar data.

One idea I've had is to create a first class function called a "cast" which allows the programmer to write a function to perform any conversions to other data structures.

Cast FooData(Foo f)
{
return (FooData f.x, f.str, f.b);
}

Cast BasicFooData(Foo f)
{
return (BasicFooData f.x, f.str);
}

And from data to Foo:

Cast Foo(FooData fd)
{
return new Foo(fd.x, fd.str, fd.b);
}

Obviously, I'm not too worried about syntax at the moment. I'm just looking for some good constructs to help the programmer out. From a java point of view these type of conversions are
usually handled by the object or by static helper methods. The idea of cast being a construct separate from the class is that it allows new data conversations to happen later.

So, what do people think of this as an addition to a language? Is this handled in other ways in other languages?

I've got some other ideas I'd like to discuss, but I'll see how this goes down first. :)

Thanks,
David.