scheme uk

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)

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.

Flying Frog Consultancy (http://www.ffconsultancy.com) 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.

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.

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 http://convergepl.org/.

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 http://tratt.net/laurie/.

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

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

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.

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.

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.

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.

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.

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

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

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

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.

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!

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

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.

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.

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.

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

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