Lambda the Ultimate

Apparently there's a new book version of these excellent lecture notes.

Anyone see this? I'd be glad to know more about this book.

From Ars Technica:

Today marks the official launch of PeakStream, a software start-up that has been operating in stealth mode for over a year now while developing a new type of software platform aimed at making multiprocessor systems easier to program. PeakStream's product [...] is basically a set of tools -- APIs, a virtual machine, a system profiler, a JIT compiler, etc. -- that present a standardized, stream-processing-based programming model for which programmers can develop multithreaded applications.

The article goes on to describe the stream processing model, and notes that the startup grew out of Stanford's Brook project. While PeakStream's web site talks about C and C++, it seems to me that functional programming would be a natural fit for their concept of "kernels" of code that operate on streams of data. Perhaps if the PeakStream toolkit becomes popular, we'll eventually see a Haskell binding for it? :-)

Not particularly academic so hope this isn't too off-topic, but thought this article in the non-geek media (salon.com) might interest some here:

Why Johnny can't code

'BASIC used to be on every computer a child touched -- but today there's no easy way for kids to get hooked on programming.'

I have to say that, much as I love more modern higher-level languages (why else would I be here), BASIC was what I grew up on, and really was ideal for picking up a first understanding of what programming is all about. With its global variables, GOTOs and all. It gets the computer obeying your command and following your logic with the absolute minimum learning curve. You don't have to learn any more abstractions than are absolutely necessary in order to feel that power (wow, it actually does what I tell it to, step by step!) and get yourself hooked.

Yield Prolog lets you embed Prolog programs directly in Python or C# (or JavaScript, coming soon) by using the yield keyword.

"CleanJ is a project for running Concurrent Clean programs on Java VM.

Concurrent Clean is a pure and non-strict functional language whose syntax is similar to that of Haskell. It is characterized by uniqueness typing to allow side-effect.

CleanJ's approach is to translate ABC code into Java program. ABC code is a intermediate language generated by Clean compiler. CleanJ system consists of a ABC-Java translator and translated runtime libraries."

Lately I started learning by myself the domain theory approach to semantics using G. Plotkin's "Domains" (1983). While doing the excercises, I bumped into the next question regarding fixed-point induction:

Let f,g: D -> D be continuous functions, such that f.f.g = g.f, and f _|_ = g_|_. Show that Yf = Yg.

(Here `.' is the analytic function composition: f.g(x) = f(g(x)) and _|_ denotes the least element, of course).

[Chap. 2 question 21]

It is more or less clear how to prove it using normal induction and the least fixed point formula, but I have no idea which inclusive predicates to choose. I was hoping someone here could supply some hints\directions.

On a more general note: Is there an intuition as to how to choose these inclusive predicates? I imagine it is acquired in time and practice, so do you know of a list of properties that can be proved using fixed-point induction?

Thanks in advance,
Ohad.

"... I believe that the development of AppleScript is a story worth telling, and I have been encouraged to attempt it despite the inherent difficulty of the task. I can only offer my own subjective views on the project, as someone who was intimately involved with all its aspects. ..."

Since I've seen things like TyPiCal claim to perform static deadlock detection, I wonder why such presumably powerful tools don't seem to be more prevalent. There seem to be a few formal method languages and tools which help folks avoid deadlock etc., but then you have to convert that into the final language and hope it really does match the theory. And, most programmers don't know the theory or tools enough to use formal methods, or think they are in too much of a rush to afford them.

So I'm just wondering if there any less-formal programming language systems that have static deadlock, livelock, etc. detection? E.g. Erlang is great, but does it have any tools to help dis/prove such useful and important aspects of your final system? Might there be a relatively simple way to use TyPiCal with, say, occam-pi? Are there research-y programming systems that might address these bugaboos?

There seem to be a few scattered references to strongtalk in the archives, but no threads dedicated to it. Sun apparently just released the source code with a BSD style license, so feel free to look at the code or steal it for your own devious purposes. The following snippet from the homepage made me think of lambda-the-ultimate.

Type System: It contains the first fully developed strong, static type system for Smalltalk (hence the name Strongtalk). The type system is both optional and incremental, and operates completely independently of the compiler technology (which means that normal untyped Smalltalk code runs just as fast as typed code). It also contains a re-designed, strongly-typed "Blue Book" class library.

Get it here

With the wide availability of multicore and multiple processor systems, I've decided it's time for me to learn a new language. Until now it's been pretty much straight C, but I really don't want to do explicit threads if possible. I have a few projects that should be highly parallelizable, eg counting the number of random graphs with a particular property. But what language to use?

Functional languages seem like a natural, but how are the actual implementations? Which implementations of which languages will handle the concurrency without having to explicitly count processors and create threads. It should be fairly readable, and available for Linux and Mac OS X. Any suggestions?