## Sketchpad: A man-machine graphical communication system

Ivan Sutherland's famous thesis has been rereleased in a new electronic edition. This is a freely downloadable and high-quality PDF version created by Alan Blackwell and Kerry Rodden.

## Dynamic Languages Wizards panel videos (rerun)

We have previously mentioned these videos of a series of panel discussions that were hosted by the MIT Dynamic Languages group in 2001. I just watched them again and I thought they were great, so I'm re-posting them for people who missed them the first time around and as a reminder for anyone who'd like to watch them again.

There are three separate panels on different topics: compilation, runtime, and language design. The panelists are distinguished people mostly from the Lisp/Scheme/MIT world. These panels were a precursor to the Lightweight Languages workshop series.

The videos are in QuickTime format. To play them on Linux I used VLC. mplayer wasn't able to synchronize the audio and video.

## Slideshow: Functional Presentations

Slideshow: Functional Presentations. Findler, Flatt. ICFP 2004.

Nothing earth shattering, but a nice example of DSL design none the less.

Might be useful for teaching (as well as for creating slideshows...)

## More content

I know the type system discussion is taking its toll, but I am sure things would be more interesting around here if we had more news items.

So all you editors out there: How about sharing?

## Simulators: Virtual Machines of the Past (and Future)

SIMH, the Computer History Simulation system, is a behavioral simulator for obsolete systems of historic interest. Originally intended as an educational project, it is increasingly being used in long-lived production environments as a substitute for real systems. SIMH is continuously being extended to simulate new machines.

This item isn't directly PL related, but since many LtU regulars are fond of programming language history, I assume there is interest in other apsects of computing history. On top of that, if and when you try to rescue an obsolete language implementation, there's a good chance you are going to need something like SIMH.

This ACM Queue article describes the design issues invloved in building SIMH, and the problems the arise when simulating old hardware systems.

## Acute: high-level programming language design for distributed computation

This work is exploring the design space of high-level languages for distributed computation, focussing on typing, naming, and version change. We have designed, formally specified and implemented an experimental language, Acute. This extends an OCaml core to support distributed development, deployment, and execution, allowing type-safe interaction between separately-built programs. It is expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store primitives, disentangling the language runtime from communication.

This requires a synthesis of novel and existing features:

• type-safe interaction between programs, with marshal and unmarshal primitives;
• modules and abstract types with abstraction boundaries that are respected by interaction;
• global names, generated either freshly or based on module hashes: at the type level, as runtime names for abstract types; and at the term level, as channel names and other interaction handles;
• versions and version constraints, integrated with type identity;
• local concurrency and thread thunkification; and
• second-order polymorphism with a namecase construct.
The language design deals with the interplay among these features and the core. The semantic definition tracks abstraction boundaries, global names, and hashes throughout compilation and execution, but still admits an efficient implementation strategy.

For more info, see the Main site, from which you can view papers and sample code.

## Dan Sugalski: Implementing an Interpreter

An annotated set of slides giving the inside story on the implementation details of Parrot.

Well worth checking if you are into this sort of thing.

## Eliminating Array Bound Checking through Non-dependent types

Oleg posted this pertinent message on the Haskell mailing list. It's always nice to see cool examples such as this.

Having saiod that, I must also say that I agree with Conor McBride who wrote that anyone who would argue (and I'm not saying you do) that work to try to make more advanced type systems and stronger static guarantees more convenient and well-supported is not necessary because it happens to be possible to bang out this or that example in Haskell as it stands if you think about it hard enough, is adopting the position of the ostrich.

Making type systems more expressive is a worthy goal. You want them to remain decidable (i.e., static), of course. Can we at least agree on that? ;-)

## A Visual Environment for Developing Context-Sensitive Term Rewriting Systems

(via an interesting discussion on the types list)

A Visual Environment for Developing Context-Sensitive Term Rewriting Systems. Matthews, Findler, Flatt, Felleisen. International Conference on Rewriting Techniques and Applications (RTA) 2004.

Over the past decade, researchers have found context-sensitive term-rewriting semantics to be powerful and expressive tools for modeling programming languages, particularly in establishing type soundness proofs. Unfortunately, developing such semantics is an error-prone activity. To address that problem, we have designed PLT Redex, an embedded domain-specific language that helps users interactively create and debug context-sensitive term-rewriting systems. We introduce the tool with a series of examples and discuss our experience using it in courses and developing an operational semantics for R5RS Scheme.

Seems like a nice tool (it's DrScheme based, of course). I guess I should try it out.

## TyPiCal: Type-based static analyzer for the Pi-Calculus

TyPiCal is a type-based static analyzer for the pi-calculus. The current version of TyPiCal provides four kinds of program analyses or program transformations: lock-freedom analysis, deadlock-freedom analysis, useless-code elimination, and information flow analysis.

Type system is an ordinary type system extended so that channel types carry precise information about how each channel is used. This allows a type inferencer to obtain information about the behavior of a process.