scheme uk

Past Meetings

7 December 2005: Shriram Krishnamurthi: Verification and Change-Impact Analysis of Access-Control Policies

Sensitive data are increasingly available on-line through the Web and other distributed protocols. This heightens the need to carefully control access to data. Control means not only preventing the leakage of data but also permitting access to necessary information. Indeed, the same datum is often treated differently depending on context.

System designers create policies to express conditions on the access to data. To reduce source clutter and improve maintenance, developers increasingly use domain-specific, declarative languages to express these policies. In turn, administrators need to analyze policies relative to properties, and to understand the effect of policy changes even in the absence of properties.

This talk will discuss Margrave, a software suite for analyzing role-based access-control policies. Margrave includes a verifier that analyzes policies written in the XACML language, translating them into a form of decision-diagram to answer queries. It also provides semantic differencing information between versions of policies. Margrave is, of course, implemented in PLT Scheme.

(Joint work with Kathi Fisler, Leo A. Meyerovich and Michael Carl Tschantz)

1 June 2005: Nigel Walker: Computational modelling of communication networks

Network protocols can sometimes be interpreted as solving distributed optimisation problems. For example, a routing algorithm minimises the total cost of flow, given a certain demand pattern. This perspective opens up a unifying view of many processes and interactions occuring within communications networks. I will briefly explain the background theory, and will show how it leads to a programming idiom for models of network processes. I will describe a prototype implemented as an extension of Scheme.

6 April 2005: Jon Harrop: Functional Languages for Scientific Computing

Flying Frog Consultancy ( are a Cambridge UK based consultancy specialising in scientific software. Work to date includes real-time 3-D visualisation, development of a JIT compiler for Mathematica, and vector graphics.

Flying Frog Consultancy does a large portion of their work in the functional language O'Caml. They have just published a book entitled Objective CAML for Scientists

Jon Harrop from Flying Frog will present some of their work, and discuss the applicability and advantages of functional languages. Copies of Objective CAML for Scientists will be available at a discounted price.

2 March 2005: John Kozak: Virtual Hardware

How do you test a device driver for hardware that doesn't exist yet? Scheme comes to the rescue, in this heartwarming tale of everyday bit-twiddling folk.

Slides are available as PDF or the original PLT Scheme sourcecode.

9 February 2005: Laurence Tratt: The Converge programming language

Converge is a dynamic object orientated programming language with compile-time meta-programming facilities and an extendable syntax, designed and implemented by Laurence Tratt. Mixing influences from Python, Icon, Template Haskell, ObjVLisp, and others, into a coherent whole, Converge is a powerful and modern programming language. More information and early implementations can be found at

In this talk, I will present an overview of Converge, with particular emphasis on its more novel aspects such as compile-time meta-programming and its extendable syntax. I will conclude with a list of some of the lessons learned from designing and implementing such features into Converge that could be applied to similar programming languages.

Laurence Tratt is a Teaching Fellow in the Department of Computer Science at King's College London. He is an active member of the OMG, and a member of the IEEE Software Industry Advisory Board. His current research interests include model transformations, domain specific languages, and programming language design and implementation. His homepage is

15 December 2004: Richard Brooksby holds forth

Richard Brooksby from Ravenbrook will hold forth on garbage collectors, the failure of Dylan, and anything else that he can get away with

6 October 2004: Emacs Lisp in Hemlock

Ingvar Mattsson will discuss how he managed to implement Emacs Lisp within the Hemlock editor, using nothing but a few macros, the odd function, and a ball of string

2 September 2004: The Scheme Cookbook

The (soon to be announced) Scheme Cookbook is an effort to produce practical documentation for Scheme, presently online but with an eye to future publication. Noel Welsh will discuss the implementation of the Cookbook, the goals and some of the thorny issues such as the currently contentious licence.

11th August 2004: Bring out yer dead! A Transputer interpreter in two acts

ACT I: Scheme

occam is a small (dead?) language based on an the Concurrent Sequential Processes algebra[1]. Scheme is a small (not so dead?) language based on the lambda calculus[2]. However, Scheme is the All Language, descended from the Mighty LISP, blessed by Guy Steele. What better language to write an interpreter of Transputer bytecode (the compiled form of occam programs) than Scheme?


Unfortunately, while semantically clear, a Scheme interpreter runneth not on the LEGO Mindstorms. So, the Scheme interpreter was rewritten, largely line-for-line, in C, and it became many times faster and many times smaller. What we ended up with is a small, portable runtime for occam programs, that currently runs on Linux/x86, Linux/MIPS, Windows, Mac OSX, and the LEGO Mindstorms[3].

This play will present a bit of background on occam (for those who are unfamiliar), the interpreter itself, and most importantly, some bits about why we think it is a good thing that we can now run occam on the LEGO Mindstorms. If FedEx is willing, little robots will be present.

(For those following along at home, the first paper found at reference number three is probably the most interesting for you to glance at, if you wish, before the talk.)

23 June 2004: Circuit Design in Lava

Satnam Singh, of Microsoft, will present a circuit design system called Lava which is embedded in the lazy functional language Haskell. Lava is a set of higher order combinators that are used to compose circuits in interesting ways. Many comnbinators compose behaviour and layout which gives the designer good control over the layout of circuits which in turn influences their performance. We illustrate circuit design in Lava with an example design and implementation of a sorting network and (possibly) a live demonstration of the sorting network running on an FPGA chip. We shall also show how circuit descriptions cast in Lava enjoy easier transformation for optimization and verification.

Satnam Singh obtained his BSc in Computing Science at the University of Glasgow in 1987 and his PhD at the same department in 1991. As a lecturer in Electrical Engineering and then in Computing Science at Glasgow he formed a research group focused on applying functional programming techniques to the design and analysis of reconfigurable circuits. In 1998 he joined Xilinx?s research laboratory in San Jose, California where he appliedfunctional programming and formal verification techniques to help solve industrial CAD problems. He has recently joined Microsoft in Redmond, Washington, where he continues to peruse his interests in novel architectures, formal methods and programming languages.

12 May 2004: Shriram Krishnamurthi from PLT

Shriram Krishnamurthi, from Brown and PLT, was generous enough to give two talks. The first discussed a method for identifying meaningful features of evolving programs by considering the test suite coverage of program edits. The second talk discussed functional reactive programming, as embodied by FatherTime, as a technique for cleanly expressing time variant programs such as GUIs and animations. We had a very good turnout, with many people from the UK Lispers group in attendence, and I believe a good time was had by all.

7 April 2004: Threading Implementations in Common Lisp

This meeting will be held in conjuction with UK Lispers.

Dan Barlow will lead a discussion about threading implementations in Common Lisp (probably with a certain amount of focus on what to do with special bindings).

See here and here for more detail.

4 February 2004: L-Systems

Noel Welsh talked about L-Systems, their applications to computer graphics and floated some ideas about using combinators to evolve L-system like designs. Notes and code are in progress.

3 December 2003: Pi Calculus presented by Tony Garnock-Jones

Where conventional languages default to performing tasks sequentially, occasionally providing ways of starting concurrent threads of control, process languages default to performing tasks in parallel, providing means of specifying sequencing (when it is required).

This (fairly subtle) shift in emphasis leads to a programming style well suited to current programming problems, particularly in areas with a distributed-systems aspect:

* programming for the web

* programming for telecommunications

* coordinating disparate distributed services

3 December 2003: Pi Calculus presented by Tony Garnock-Jones

Where conventional languages default to performing tasks sequentially, occasionally providing ways of starting concurrent threads of control, process languages default to performing tasks in parallel, providing means of specifying sequencing (when it is required).

This (fairly subtle) shift in emphasis leads to a programming style well suited to current programming problems, particularly in areas with a distributed-systems aspect:

* programming for the web

* programming for telecommunications

* coordinating disparate distributed services

5 November 2003: Cancelled

The meeting was cancelled because I didn't have any talks up my sleeve

8 October 2003: 'Run Once, Write Anyway'

The Schemix talk which was to be presented by Dr William Bland, has been cancelled - due to his moving to sunny California. Good Luck! instead:

Run Once, Write Anyway, Presented by Matthias Radestock.

Scheme is one of only a few languages with a concise specification and formal semantics. With such a foundation it should be easy to write portable code that, without modification, runs correctly on different Scheme implementations. Yet this goal has proved elusive - there are more than fifty Schemes and writing programs that are portable between even just a few of these implementations is tedious at best and impossible at worst.

We examine the reasons behind the Scheme community's failure to provide developers with a basis for writing portable code. We look at the various Scheme standardization efforts and identify their contributions and shortcomings. Finally we present a series of recommendations for resolving the key portability issues: a minor revision of the Scheme standard, specifically aimed at improving portability, the creation of a standard library, and the CPAN-style central code repository and package management system.

4 September 2003: Scheme SuperCollider client

Presented by Rohan Drape

SuperCollider is an environment and programming language for real time audio synthesis. You can write programs to generate or process sound in real time or non real time. SuperCollider can be controlled by MIDI, the mouse, Wacom graphics tablet, and over a network via Open Sound Control. SuperCollider can read and write sound files in AIFF, WAV, Sound Designer 2, and NeXT/Sun formats. SuperCollider supports sound cards using Steinberg's ASIO driver api. Super Collider

I wanted to thank Rohan Drape for his fascinating talk on his scheme SuperCollider client. Many of us were left with an immediate need to try it out . The talk covered some interesting history of sound synthesis, which led naturally to the motivation for super collider, and we finished by listening to some example output. More of you should have been there!

7 August 2003: Linear Logic Part 3

Johannes Flieger continued his series of presentations on logic and programming.

5 June 2003: Scheme .Net and The Death of Design Patterns

Tom Bergen and Tony Garnock-Jones will discuss how and why they developed Scheme compilers for the .Net platform

It was too nice a day too stay inside so we went to Hoxton Square. A few drinks later I don't think Scheme was on anyone's mind. Oh well, we'll have to have the talks another time. In the meantime there is a draft of The Death of Design Patterns.

7 May 2003: Practical Applications: NMK and SRFIs

Mike Bridgen discussed how he built the website for NMK using SISC as the core technology.

MJ Ray lead a lively discussion on the objectives and merits of the SRFI process.

The NMK case study is available here.

2 April 2003: Compilers, and Linear Logic

Matt Jadud presented his Scheme compiler, Scorth. Scorth was implemented when Matt take the P523 compiler course as Indiana University. The course is taught by Kent Dybvig, author of Chez Scheme, and moves at a cracking pace: they build a compiler that goes all the way from Scheme to SPARC assembler. Scorth is targeted at the Lego Mindstorm, so it doesn't generate SPARC but rather Forth, a simple postfix language. Scorth consists of about 30 passes, the majority of which transform Scheme into Universal Intermediate Language (UIL), a simplified version of Scheme. A few more passes are necessary to go from UIL to Forth. With a bit of macrology the output of every pass is executable, which makes testing much easier. Since Scorth is based on the IU compiler course Matt can't release the source code without giving away the answers to every P523 homework assignment! However he is thinking about reimplementing Scorth to use continuation passing style, and will Scorth if this eventuates.

Johannes Flieger continued his series of presentations on logic and programming. This time we looked at relevance and linear logics. Both types of logic deal with premises as resources. The key idea behind relevance logic is to avoid using unnecessary premises. Linear logic introduces the additional constraint that premises are used during derivation. Hence linear logics are good for modelling finite resources such as time, money and computer memory. Notes to Johannes talk are here.

5 March 2003: Logic And Programming

As a lead up to talking about resource logics (linear logic etc.), Johannes Flieger revised basic classical and intuitionistic logic, some basic proof theory, and introduced the notion of `proofs as programs'. Johannes' notes are here. Note that the notes have been updated since the meeting was held.

In general discussion a number of interesting projects were raised: Scheme as a replacement of Ant, Scheme as a language to manipulate Mozilla and Scheme running a MUD

5 February 2003: Continuations

Noel Welsh gave a talk about continuations and their use in web applications. Notes are online.

8 January 2003: SXML Transformations

See the notes

4 December 2002: SXML and SSAX

See the notes

13 November 2002: Lists and Trees

See the notes

6 November 2002: Basics of Scheme

See the notes

This file generated Friday, October 28th, 2005 using the WebIt! toolkit