Lambda the Ultimate

From the Past to the Future: Tim Sweeney Talks

An interview with our own Tim Sweeney. There's admittedly not a lot of PLT here, but there's an interesting observation about the integration of an "editor" with a "game engine," beginning with ZZT and culminating in the Unreal technology, that might tease out some interesting discussion about how PLT can help build certain kinds of software (think live programming, JITs, type theory, reflection, "meta" vs. "object" languages, etc.) And perhaps Tim can respond to anything we come up with when he has the time.

In Mathematics one often writes f(X) instead of {f(x) | x in X} where X is a set. Array languages like J allow you to write a+b for elementwise addition of arrays. Mathematicians also write f+g = lambda x -> f(x) + g(x) for pointwise addition of functions. Other examples are using functions on symbolic data or on time varying values (like in FRP).

Do you have ideas on how to use this notation in programming languages? Are there languages that allow you to do this in a general way? (i.e. without defining every operator +, *, /, etc. to work on different types of data seperately) Can this work in both statically and dynamically typed languages? How can you handle cases like a + f where a and f aren't of the same type, for example a is a time-varying value and b is a function?

Another example:

I'd expect A+B where A and B are sets to produce {a+b | a in A, b in B}. What should A+f do?

1) {lambda x -> a+x | a in A}, a set of functions
2) lambda x -> {a+x | a in A}, a function that returns sets
3) Error.

Maybe it's possible to determine what to do from the context.

Thank you for your ideas.

It is a bit late for today's meetup, but not too late:

www.meetup.com/fp-bud/calendar/10412377/

The program is as follows:

I. ---------------------------------------
Permissive operators as a mechanism for language extensibility
by Diego Echeverri (IntelliFactory)

Abstract: We explore an extensibility mechanism for programming languages based on a subset of distfix(mixfix) operators. This mechanism gives tools to the programmer to increase conciseness by allowing him to build more complex operators via composition. We also show that some common features that are usually "built-in's" can be constructed as "libraries" using these operators.

II. ---------------------------------------
Reverse Execution
by Ersoy Bayramoglu (IntelliFactory)

Abstract: Undo operation, mostly popularized by text editors, goes back to the ENIAC times. It has important uses in areas like debugging and error recovery. Since the pioneering Interlisp environment, different kinds of undos have been studied with different implementation methodologies. In this talk I will briefly summarize the previous work, and discuss various issues related to reverse excution of programs.

III. ---------------------------------------
EDSLs in Haskell
by Joel Bjornson (IntelliFactory)

Abstract: In this talk I will show how Haskell can be used as a platform for implementing Embedded Domain Specific Languages (EDSLs), utilising

* Generalized Algebraic Data Types (GADTs) for representing typed expressions
* Type Classes for overloading operators
* Monads for mimicing imperative constructs and adding syntactic sugar

There's something about seeing "Microsoft Visual F#" listed alongside C# on a Visual Studio Team System 2010 beta screenshot that makes it seem almost real.

Maybe it's a fake screenshot.

I wonder if there'll be a Visual F# 2010 Express Edition? Wouldn't that be something!

Alert! The May 11, 2009 issue of The New Yorker ran a poem that name-checks our man Guy L. Steele along with Eric S. Raymond--apparently in their role as lexicographers of the hacker argot: Hackers Can Sidejack Cookies. Worth groking if you have the time.

Here is a neat little thing that is tying my brain up into knots: Given a Java-like language, what would you prefer Extension Methods (ala C#) or Traits + Structural Typing. My working (read as: probably incomplete) definition of a trait is an interface with concrete methods. Unless I am mistaken the expressiveness of the two techniques would overlap significantly:

Example 1 (extension methods):

class A {
  int m = 42;
  int f() { 
    return m; 
  }
}

extension B of A {
  int g() { 
    return f() * 2; 
  }
}

A x = new A();
print(x.g());

Example 2 (traits + structural-typing)

class A {
  int m = 42;
  int f() { return m; }
}

trait B {
  abstract int f(); 
  concrete int g() { return f() * 2; }
}

B x = new A(); // Notice: A never explicitly "implements" B
print(x.g());

I haven't looked at Scala in a while, so can you do this in it yet? I believe it is a direction they were going.

For what its worth, the second approach appeals to me a bit more, because it is more discplined, and doesn't clobber the nice encapsulation advantages of classes.

Now if I am not already way out in left-field, are these not both examples of solutions to the "expression problem" (http://www.daimi.au.dk/~madst/tool/papers/expression.txt)?

Well I know that in example two I am cheating because there is a cast of "A" to "B". So I would call it a solution to the "weak expression problem". You can guess what I mean by that.

A couple of months ago the topic of psychology and computer programming came up in a thread; it was noted there didn't seem to be a lot of work done in the area (iirc). This paper actually has some hard data about novice developers who were given multiple different IQ/psych test then their success in implementing 'knowledge based' systems was measured. Interesting read:

http://www.scribd.com/doc/15554396/Knowledge-Based-Systems-A-Study-of-new-Developers

This is kind of obscure. In the "A Tutorial on (Co)Algebras and (Co)Induction" we find the remark (page 28):

If A has more than two elements, then conc(x, y) /= conc(y, x), because they give rise to different observations...

Why is it "more than two" instead of "two or more"?

Microsoft just released a new concurrent programming language for the .NET platform called Axum:

Axum is a language that builds upon the architecture of the Web and principles of isolation, actors, and message-passing to increase application safety, responsiveness, scalability, and developer productivity.

Other advanced concepts we are exploring are data flow networks, asynchronous methods, and type annotations for taming side-effects.

Via Slashdot.

I'm not sure what WolframAlpha exactly does, but Stephen Wolfram's post about it definitely has my ears all perked up for its launch ... which should be any time soon.