Lambda the Ultimate

Now that we have considered how users can help each other avoid bugs in GUI applications, we would look to think about ways in which users can have more control in software development.

One idea is to develop a system to help millions of users collaboratively build and evolve a specification for a GUI app.

For example, how would a million users specify a paragraph formatting dialog box?

How would a million users specify the behavior of the cursor in a scientific word processor with math formulas, tables, etc.?

Some issues:

• users may not agree; CollaborativeRank might help
• users can build the GUI (a partial spec) using something like Qt designer and their combined work can then be used by the developers directly; issue: how to automatically combine their suggestions into a coherent GUI?
• non-standard GUI elements (e.g., the main view of a scientific word processor), the specification by users can't be used directly; but it probably should be visual and should be something that can be mixed with a running GUI app (e.g., as a visual placeholder for something that is not implemented yet)

Some connections to existing ideas:

• extreme programming: we could have users develop higher level visual test cases (e.g., before/after images of cursor movement); developers could then compete to satisfy those test cases; How do you automate a visual test case? Is machine learning helpful?
• intentional programming: like IP, we can focus features; application boundaries may be nebulous; perhaps we could have automated forking and merging of applications
• wikis: this is sort of like a wiki with visual placeholders for non-implemented parts

Is any of this novel?

This paper was mentioned here before, but not on the home page.

It deserves to get more attention, since it is quite cool.

Warning: This one isn't for the faint of heart, and uses scary terms like polynomial functors, initial algebras and terminal coalgebras, constructive set theory and more...

Some here will find this discussion on language choice for building an industrial strength poker server to be of interest.

PLT needs your help. From the mailing list:

Financial support for our implementation and infrastructure work is running out over the next year. I am hoping to raise money from the National Science Foundation (NSF) with a proposal to the infrastructure initiative. The purpose of this initiative is to help with the maintenance of projects that are useful in research and advanced development, but also teaching and education. The emphasis is on the former two; the latter two are acknowledged, and I don't think we need to worry about the latter.

So, if you have used DrScheme/MzScheme/MrEd/Web Server etc for research or advanced development and you don't want the project to die, could you please send a short one-page, signed letter of support to me c/o Eli Barzilay on some formal looking letter head please? The letter should state what you do, where you work, and that you have used PLT Scheme for research and advanced development. If you are so inclined, you can also add that it is critical and what you have done with it.

For addresses, see below. Thanks! -- Matthias

P.S. Electronic signatures are okay, too, indeed they are ideal.

Matthias Felleisen
c/o Eli Barzilay
Trustee Professor
College of Computer Science
Northeastern University
Boston, MA 02115

The deadline for letters of support is 1 July 2005.

I'm pleased to announce the 1.0 release of Context Free: an environment for writing and rendering graphic design grammars for Mac OS X, Windows and Posix/Unix.

In Context Free, you write a context free grammar where the only two terminals are the shapes CIRCLE and SQUARE. Given a starting symbol, the program keeps expanding symbols that have rules until all that is left are terminal shapes, which are then drawn. In essence, the rendered images are legal sentences in the language described by your grammar!

Context Free is based on Chris Coyne's earlier CFDG, mentioned on LtU in the Fun department.

Martin Bravenboer writes about generic wildcards in Java, and concludes that it is unfortunate that C# will not support wildcards or a similar mechanism.

Eric Gunnerson from Microsoft replies.

I was originally a type-erasure fan, but these days I am not so sure. I hope this turns into a fruitful discussion that helps me decide...

P.S

The Java paper was mentioned on LtU before.

Hi everyone,

I need to perform a data flow analysis on a lamda-calculus like functional language.

Ideally, this should be a type-based approach. Can anyone on this forum direct me a mean to do this.

What is particularly troublesome is that a data flow analysis naturally necessitates a fix-point analysis which is done recursively on the structure of the program whereas a type analysis is done in one pass over the program.

I would be grateful for any insight anyone might have to help me solve this problem.

R.K.