Lambda the Ultimate

I'm currently learning about somebody's home-grown distributed object system in Java, which makes lots of use of source-code augmentation; you run your code through a processor that adds magic code to your .java file to support distributivity. It kinda sucks because there's all this extra gunk that is either missing and you don't realize it, or is there and is in your way and has scary comments around it saying it is auto-generated code and shouldn't be touched. Timor will supposedly help make component-based reuse a reality and lets you augment things without disturbing the originals, so that sounds nice to me just now. (Not that I will get to use it any time soon, probably.) Maybe it is all just fancy-talk for AOP?

Hi

After reading some of Paul Graham's stuff more than a year back, I picked up a (very old) copy of LL a while back, and am slowly getting through it. Having looked at some of the intro threads here, it seems I'm far from the only one to come this route.

Coming from an EE background, with no prior knowledge of "language design" (to me PL's have always been just tools to get the job done, my formal education in the subject is most rudimentary), this is quite an eye opener. I'm doing examples an exercises using DrScheme, and the fact that I seem to be able to get things to work is reassuring. But it is a VERY odd feeling to write functions that DO work, sort of know why they work ... and yet have all my usual tools for "reading code", erm, rearranged. The process has made me want to look at functional programming in much more depth, and check out languages liek Haskell ... but one thing at a time.

Anyhow, it's a lot of fun, and I'm happy to have found this stuff, although I've no idea where it's going (well, I did read ahead a few pages and it looks fairly mind boggling ...)

This was just to say "hi". I'll lurk around here and maybe ask the odd inane question, but I'll try not to make it *too* dumb.

Daniel

Narrative Javascript is an extension to Javascript that adds an operator to convert asynchronous operations into synchronous ones. It has a compiler that compiles the extended Javascript into normal Javascript.

It provides on the client side what continuation based web frameworks do on the server side. Instead of manually splitting up your code into callbacks and handlers for events, setTimeout, XMLHttpRequest callbacks, etc you write your code in a sequential manner.

The code is CPS transformed and the continuations at the point of use of the new operator are used for the callbacks - allowing continuation of the function when done.

It looks pretty nifty.

I have been looking at and using programming languages for nearly 30 years now. I have just finished reading http://lambda-the-ultimate.org/node/100 and have found the various disussions "interesting". In terms of language design, I have looked at Chris Strachey and Robert milne's book "A Theory of Programming Language Semantics", Dana Scott's "Denottaional Semantics" and David Harland's "Polymorphic Programming Langugaes" and "Comcurrency and Programming Languages".

What I am interested in is the following question. In Static Type checking systems as well as Dynamic Type Checking systems, what is the effect of making Types (or Type Tags) first class citizens of the programming language? What is the effect of being able to create new types within the code, in other words having a function that on different invocations returns a new type? How does ST handle this (either theorectically or practically)?

Secondly, in ST languages, how is one able to create polymorphic structures without recource to "type variables"? Or another way to put it, how does St languages determine the type of a type variable?

I may not be grokking the way types are used in OCAML and CLEAN. An minor example of one problem I see with them is that I cannot (that I have yet found - if anyone knows how this would be achieved please let me know) create types that take any kind of value of any type.

Let me explain. I understand that it is easy to create a structure in these languages using "type variables". So I can create a list that can take any type of value, as long as all element values are the same type. What I want to do is create a list that has a variety of values of different types (simultaneosly) without having to create a union type. There are problems I have been involved in that required this kind of solution. Solutions developed ended up being far more complicated that the problem required because of static type checking available at the time.

[ 1 2.0 array.of.something "a atring" true ]

In OCAML the following creates a tree

type 'a btree = Empty | Node of 'a * 'a btree * 'a btree;;

My problem is that 'a sets all Nodes to have the same type for the datum values, where I really need the datum values to be of different types.

The requirement is that the code should not be required to be recompiled to add in an additional type signature for the structure. In other words, it needs to be future proof.

An area that I see types as being first class values is in a compiler. It has to be able to create new types on the fly and process them in the analysis of a programming language source file.

I have been working on a personal project of a new language that has types, code, processes, environments, etc as first class values - some of the facilities are to allow the creation of new code values (from within functions) and having functions defined as either lazy or eager. It purpose is to investigate abstraction. One area of abstraction is to see how to add code in the definition of a function that evaulates lazy parameters to give an eager parameter scheme.

Where I can use ideas from existing languages I will do so.

n/a

A prototype Cat interpreter, has just been released into the public domain, and is available for download with C# source code at http://www.cdiggins.com/cat.zip. An introduction to Cat is available at http://www.cdiggins.com/cat.html

Cat is a stack based functional language inspired by the Joy programming language Like Joy, Cat is a cross between Forth and the FP language.

Cat has no variables, no arguments, no constants, and no side-effects. Every Cat program takes a single stack as input, and returns a single stack as output. A Cat program is made up of a sequence of sub-programs. A sub-program may be either a user-defined or atomic (built-in) program. That's about it. It is very easy to implement, analyze, rewrite and optimize.

Microsoft's Phoenix Framework, previously available only to registered researchers, is now publicly available for download. Phoenix is a Microsoft Research project focused on code optimization and analysis, with the stated goal of designing a framework to be used as the middle- and back-end components of all future Microsoft compilers.

Individual support and access to a community forum for Phoenix is available to qualified academic faculty and researchers.

Phoenix was previously mentioned on LtU.

Buried Treasure pdf

The trend toward dynamically typed languages is both widespread and strong. Less obvious, though, is a resurgence of interest in functional programming and functional languages. ... Haskell ... Objective CAML ... Scala ...

Is it double-think that allows the promotion of both dynamically typed languages and, by name, Haskell OCAML Scala without any acknowledgement that those powerful and efficient functional languages are ... statically type checked?

The Ravenscar Profile for SPARK/ADA supposedly makes concurrency safe in that static tools can analyze the program. Might any LTU readers have real-world Ravenscar experience to share with us? It appears to be shared-state concurrency, which I think is considered less than ideal on LTU, but if it can be statically checked perhaps that ameliorates some of the evil?

BlackBox is a RAD IDE for the Component Pascal language (not really Pascal, it is a superset of Oberon).
Personally, I don´t like much the language, but the framework and
environment are really interesting. It is very light and as integrated as Smalltalk. It is also nice for literate programming.
The sources are included in the installer.