Lambda the Ultimate

Some of you might be interested in the following Conference during the first weekend in June at UBC in Vancouver, Canada:

Conference: Foundational Methods in Computer Science (FMCS05)

Local organizer: John MacDonald
Location: All sessions are held in WMAX 110 - 1933 West Mall
Dates: June 3-5, 2005

Friday, June 3, 2005

9:00-10:30a.m. Ernie Manes, UMass Amherst, USA
From locally-Boolean rings to sum-ordered categories

11:00-12:30p.m. Vaughan Pratt, Stanford University, USA
Recent developments in Chu spaces

2:30-4:00p.m. Steve Bloom, Stevens Institute of Technology, USA
Regular words

4:30-6:00p.m. Robin Cockett, University of Calgary
Restriction Categories and Ehresmann's Theorem

Saturday, June 4, 2005

9:00-9:50a.m. Paul Taylor, Manchester, UK
Extension of ASD (from locally compact locales) to and
beyond general locales

9:50-10:30a.m. Cyrus Nourani, USA
Functorial Model Computations

11:00-11:30a.m TBA

11:30-12:15p.m. Art Stone, Vancouver, Canada
2-Dimensional Adjunctions

2:00-2:30p.m. Varmo Vene, University of Tartu, Estonia
Signals and Comonads

2:30-3:00p.m. Bob Rosebrugh, Mt. Allison University
TBA

3:00-3:30p.m. Chris Dutchyn, University of British Columbia
Aspects are Dual to Objects

4:00-5:00p.m. Philip Mulry, Colgate University, USA
Monad Compositions on Recursive Data Types

Sunday, June 5, 2005

9:00- 9:30a.m. Brian Redmond, University of Ottawa,
Categorical Models for Soft Linear Logic

9:30-10:00a.m. X. Guo, University of Calgary,
Range Restriction Categories

10:00-10:30a.m. Dana Harrington, University of Calgary
TBA

10:30-11:00a.m. Break

11:00-11:30a.m. David Oury, McGill University,
TBA

11:30-12:00 Pieter Hofstra, University of Ottawa,
TBA

12:00-12:30p.m. TBA

Last updated: 5/27/05

For further information see the conference website:
http://www.pims.math.ca/science/2005/05fmcs

I just came accross this interesting paper: Pure bigraphs: structure and dynamics. From the abstract:

"...it is shown that behavioural
analysis for Petri nets, pi-calculus and mobile ambients can all
be recovered in the uniform framework of bigraphs."

An interesting thing from my point of view is that an attempt is made to provide a descriptive explanation of the material, obviously along with math proofs.


There are also three, very basic, audio lectures(!) on pi-calculus at the following site: http://courses.cs.vt.edu/~cs5204/fall03/DayByDay.html.

Hi, I'm looking for some short algorithms that use state in tricky ways, where by "tricky" I mean:

1. State is used nonlinearly. That is, there should be multiple pointers to some of the state in the program.

2. The state should be "visible" to clients. Something like memoizing or caching is stateful and nonlinear, but it has no visible side-effects.

3. The state should have an indefinite lifetime -- that is, stack allocation isn't a sufficient memory management strategy.

4. Ideally, the state should be higher-order -- I'd like to see references of function (or object) types, so that there's a pointer to code. This is less critical than the others, but still nice.

Any ideas? I've thought of union-find, and I would guess there are graph algorithms that have these properties, but I'm relatively ignorant about them.

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.

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.

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?

I have been a lurker on LTU and have already learned a ton. I am currently developing an in house DSL, and I have come across a problem to which I haven't been able to find resources.

I am currently implementing the DSL in an object oriented language (ok, its Java, don't boo and hiss). I am not entirely sure how I should be handling errors that arise in the DSL (syntax errors, semantic errors). Is it enough for a log file? Should I have a DSLerror class of some sort?

Sorry if this is a naive question. DSL construction is a fascinating (yet relatively new) topic for me.

Thanks,

Michael

Based on the progress I’ve made with FORTRAN, I decided to start another effort at the Computer History Museum to track down source code and documents for the original M.I.T. LISP I/1.5 project. I have made some progress, and am assembling a LISP web site at the Museum to organize and present the materials I’ve collected so far, including:

• LISP 1.5: Assembly listing for IBM 709/7090 standalone system, and another for the CTSS port. Information about various other ports and reimplementations including Univac M-460, Q-32, and Univac 1108.
• PDP-1 Lisp: links to the documentation, source code and simulators
• MacLisp (PDP-6, PDP-10): links to documentatation and source code
• BBN-LISP: the manual for the original PDP-1 version and the Tenex version (coming soon: preliminary specifications for the 940 version)
• etc.

My hope for this project is to provide open online access to as much information as possible for students, historians, and other interested people.

Your comments are welcome (here, at my blog Dusty Decks, or by email. What am I missing? What facts have I gotten wrong? Please help fill in the gaps.

PyPy 0.6, the first public version of PyPy, was released today.
http://codespeak.net/pypy/

From their announcement:

"PyPy is a MIT-licensed reimplementation of Python written in Python itself. The long term goals are an implementation that is flexible and easy to experiment with and retarget to different platforms (also non-C ones) and such that high performance can be achieved through high-level implementations of dynamic optimisation techniques."

From the release notes (http://llvm.cs.uiuc.edu/releases/1.5/docs/ReleaseNotes.html):

The release now includes support for proper tail calls, as required to implement languages like Scheme... In LLVM 1.5, the X86 code generator is the only target that has been enhanced to support proper tail calls (other targets will be enhanced in future). Further, because this support was added very close to the release, it is disabled by default. Pass -enable-x86-fastcc to llc to enable it (this will be enabled by default in the next release).

Is it time to create a PLT front-end for LLVM?
George