Lambda the Ultimate

Ulf Wiger previously opined: "Perhaps your best bet is to simply go with JCSP, if you really need to use Java..."

"It'd be nice if Java supported an easy way to extend its syntax"
Open Java?

I did not know that something like OpenJava could be possible. When I was thinking of compile-time programming, I thought of complex protocols including special keywords, special operations etc which made my efforts to design a programming language problematic...but now I realize it was actually very simple: what is needed is to mark the code as 'compile-time', as in OpenJava's metaclasses, so as that it is run at compile time.

For Java it is especially easy due to bytecode nature. But now that I have seen it for C++ (OpenC++, just follow the links from the above URL), what can I say? I think that it this way of extending programming languages must be a defacto way in the future. If people can do it with such ease on a difficult compiled language that is C++, then anything is possible...

...I think one of the next major evolutionary steps in programming is going to be growing acceptance of multi-stage programming and languages that are explicitly designed to exploit it. Syntactic extension plus runtime code-generation plus just-in-time compilation is just too powerful to ignore, and multi-stage programming puts it all on a firm foundation.

Although I do enjoy the concept, I'm scared that this might make "quick" programming more difficult in the long run, as one might need to play the full orchestra (language, meta-language, meta-typing, etc.) to develop simple stuff.

Kind of like C++ templates. :)

There are plenty of things that can be done when an application compiles:

-check the environment
-automatically download latest patches for libraries before compiling
-create/update the database
-create unit tests
-check the code against specifications
-automatically install new versions
-notify developers for new versions

...and probably many more than I can imagine.

OO is nothing more than pattern matching on the type of object: if the object is of type A, then do this, otherwise if the object is of type B, then do that etc.

A good resource on the subject is Mark Miller's thesis on Robust Composition and the E Programming Language.

That is, the caller is dictating what code will be run on the called object.

Isn't the above valid in Smalltalk as well? when you use an object, you are calling it. If you called a different object, different code might be executed. In both cases, the caller determines what code will be executed.

What you've just described is predicated dispatch right? I would prefer dynamic inheritance: a button or text box can inherit from the Enabled trait when it is enabled, otherwise it does not. Solves pretty much the same problem with a different mechanism. Of course, dynamic inheritance with static typing is a bit tricky, but dynamic inheritance works well enough in a dynamically typed language (e.g., Self, JavaScript).

As Sean pointed this is basically just predicate dispatch. Google is your friend.

The paper explains that laziness can be added easily to a language with dataflow variables. The ADT is as follows:

• {NewVar X}: create new dataflow variable X.
• {Bind X V}: bind dataflow variable X to value V.
• {Wait X}: suspend the current thread until X is bound in another thread.
• {WaitNeeded X}: suspend the current thread until another thread calls {Wait X}. This is the operation that adds laziness.

The power comes when these operations are done implicitly. That is, when you do an addition Z=X+Y, the + operation implicitly does a Wait for each argument and the binding to Z implicitly does a Bind. This makes dataflow programs very concise, much more concise than explicit calls to synchronized buffers in Java. An experiment was done to add this implicitness to Java, giving a new language called FlowJava (see the paper on FlowJava). Simple concurrent programs in FlowJava are possible in half the number of lines of code as in Java. The difference is even bigger in Oz: a bounded buffer can be completely implemented in just a few lines of code (see the paper by Raphaël Collet or chapter 4 in CTM). This uses WaitNeeded. Another example is making a program incremental: any program can be made incremental by sprinkling it with WaitNeeded calls. The WaitNeeded operation is extremely powerful.

Improving expressiveness by adding implicit operations reminds me of the famous quote by A. N. Whitehead:

Civilization advances by extending the number of important operations which we can perform without thinking of them.

This applies to programming languages as well!

"The power comes when these operations are done implicitly."

So a C++ solution with overloaded operators that implicitly synchronize operations (so as that Z=X+Y) is the same as in Oz?

I still don't get the difference/advantage. Ok, Java can not overload operators, but synchronization can be built into classes, and then be implicitly used, just like in Oz.

In the Oz language, dataflow has the following four properties:

• It is concise: No extra syntax is needed beyond using the identifiers and the operations in the usual way. An unbound variable when bound becomes its value transparently.
• It is ubiquitous: All variables and all operations do implicit dataflow synchronization.
• It is factored: Dataflow does not interfere with other concepts in the language. It works well together with functions, objects, classes, etc.
• It is optimized: The implementation is optimized to reduce the overhead of the implicit synchronization operations.

A final point is that the Oz implementation makes threads cheap enough so that the programmer is not discouraged from using them when doing so would improve program structure.

If you want the same kind of expressive power in C++ or Java, then you have to add as many of these properties as possible.