Lambda the Ultimate

More political or economical than technological - software patents again:

Kodak wins Java lawsuit

It returns to court next week to seek $1.06 billion in damages from Sun Rochester's largest employer claimed during a three-week trial that portions of Java infringed on patents Kodak purchased from Wang Laboratories Inc. in late 1997. The patents describe a method by which a program can "ask for help" from another application to carry out certain computer-oriented functions. That's generally similar to the way Java operates, according to Kodak and other experts.

Will dinosaurs kill each other with patents? Who will be the last saur standing? I know of a three-letter acronym company (not SCO) with a huge patent base - will it subsume all the (interesting) others (de facto, if not de jure)? How will it affect the progress?

Know any such languages? I am not sure exactly what such a language should like; I am fishing for ideas...

pLogo anyone?

You might remember qmail from the MFA trial run discussed here before.

If so you might be interested in the paper The Security Architecture of qmail by M. Hafiz, R. Johnson, R. Afandi, PLoP2004.

I believe there was a conversation on LtU once (perhaps LtU1?) where someone was explaining World-passing style in Clean (I think it was Clean), and explained that there was some syntax for making the World-passing implicit, so that it'll just automatically thread it through for you. I've searched the archives for a while to no avail. Does anyone remember the conversation I'm referring to?

The ICFP 2004 program now links to the invited talks, in particular PowerPoint slides and MP3 audio for John Launchbury's excellent talk on bringing functional programming to the real world at Galois Connections.

The Cocoon project has introduced FlowScript. Flowscript is a
modified
version of javascript which supports continuations and is used to write web applications that span pages.



Here is an example from the site of a calculator application which uses multiple pages to request the numbers and
operator.



"In this example, the calculator function is called to start the calculator application. We'd like the sendPageAndWait function to be a special function, that takes as arguments an HTML file to be sent as response, and some optional data that needs to be placed dynamically in it. We would like sendPageAndWait to send the response page and then block the executing thread, until the user clicks on a link in the response page, which sends a request back to the server. This request resumes the processing at the point it was left, right after the call to sendPageAndWait."

function calculator()
{
  var a, b, operator;

  cocoon.sendPageAndWait("getA.html");
  a = cocoon.request.get("a");

  cocoon.sendPageAndWait("getB.html");
  b = cocoon.request.get("b");

  cocoon.sendPageAndWait("getOperator.html");
  operator = cocoon.request.get("op");

  try {
    if (operator == "plus")
      cocoon.sendPage("result.html", {result: a + b});
    else if (operator == "minus")
      cocoon.sendPage("result.html", {result: a - b});
    else if (operator == "multiply")
      cocoon.sendPage("result.html", {result: a * b});
    else if (operator == "divide")
      cocoon.sendPage("result.html", {result: a / b});
    else
      cocoon.sendPage("invalidOperator.html", {operator: operator});
  }
  catch (exception) {
    cocoon.sendPage("error.html", {message: "Operation failed: " + exception.toString()});
  }
}

While working on implementing monads and comprehensions, I ran into a complication in translating comprehensions to their underlying monadic expressions. Looking at other languages for insight, I realized that all languages which make use of monads use type deduction and that this feature appears to be critical to making comprehensions work.

To translate a comprehension for a monad M, you need to translate expressions like [x+1 | x <- xm] where you know that xm:M(int) for a statically unknown monad M. But how do you typecheck "x+1", which requires that x is a numeric type? Nothing in this expression explicitly indicates that x is numeric. Thus one would need type deduction and explicit universal quantification with matching to deduce that x is numeric, or ugly explicit type specification on comprehensions like [x+1 | x::int <- xm].

My conjecture is that this is why monads happen to be widely-used only in languages supporting Hindley-Milner type deduction, while traditional languages use imperative constructs like iterators, exceptions and side-effects for roughly similar tasks. Monads would be awfully inconvenient without this syntactic sugar, which happens to rely on a rather narrowly-available language feature.

I would appreciate any counterarguments on this conjecture. Also any references to non Hindley-Milner languages supporting monads conveniently.

In "No Silver Bullet --Essence and Accidents of Software Engineering", author Fred Brooks argues about the inherent unreliability in software, and that there is perhaps no 'silver bullet' that will ever be found to correct the situation.

Louis Savain has something to say about that.

In "The Silver Bullet" he counters by saying:

There Is a Silver Bullet After All The brains of humans and animals are the existence proof that there is a silver bullet. Robustness and reliability are measured in terms of defects vs. complexity. Because of its sheer astronomical complexity, the brain is the most reliable complex system in the world. In fact, the more complex the brain gets (as it learns), the more reliable it becomes. By contrast, the reliability of software gets worse as its complexity increases. Any handcrafted software with the complexity of the brain would be so riddled with bugs as to be unusable. Conversely, given their low relative complexity, any handcrafted software with the reliability of the brain would almost never fail.

This all leads into the description of Louis' brain child: Project COSA. Project COSA is a revolutionary take on software development. It removes the notion of a system of heterogeneous executable binaries, and instead presents a model consisting of a single execution kernel which passes over an entire network of 'cells' taking signals from output plugs and moving them to input sockets on other cells.

Perhaps it could be thought of as programming using software integrated circuits, but in an abstract sense.

If anything, it is certainly a departure from the normal syntax driven, algorithm based languages used now.

While still a work in progress, it is something that all LtUers would be interesting in checking out.

I guess many people may already know, but the ICFP contest results are out. The judge's prize went to the OCaml people for designing and using AML (Ant Meta Language) as the ant language. In the main division, the second place used C++ and Haskell, and the first place used Haskell exclusively. Might be interesting to look at the language statistics for the submissions.

A collection organized by Benjamin C. Pierce.

In September, 2004, I posted a query to the Types list asking people to name the five most important papers ever written in the area of programming languages. This page collects the responses I received. (A few are missing because I am still tracking down bibliographic information.)

Seems prime material here for Lambda.