Simon Peyton-Jones, Co-creator of Haskell

He is co-creator of Haskell, a Principal Researcher at Microsoft Research in Cambridge and thus; one of those who shapes the languages that you will be using in the future.

Simon Peyton Jones has a MA, MBCS, CEng and graduated from Trinity College Cambridge in 1980. After two years in industry, he spent seven years as a lecturer at University College London and nine years as a professor at Glasgow University. He is an Honorary Professor of the Computer Science Department at Glasgow University.

Simon Peyton Jones is mainly interested in functional programming languages, their implementation, and their application. In practical terms, that means he spends most of his time on the design and implementation of Haskell. In particular the Glasgow Haskell Compiler, and its ramifications. He has led a succession of research projects focused around the design and implementation of production-quality functional-language systems for both uniprocessors and parallel machines. He was a key contributor to the design of the now-standard functional language Haskell, and is the lead designer of the widely-used Glasgow Haskell Compiler (GHC). He has written two textbooks about the implementation of functional languages.

More generally, Simon Peyton Jones is interested in language design, rich type systems, software component architectures, compiler technology, code generation, runtime systems, virtual machines, and garbage collection. He is particularly motivated by direct use of principled theory to practical language design and implementation - that's one reason he loves functional programming so much.

Presentation: "Classes, Jim, But Not as We Know Them."

Time: Tuesday 09:00 - 09:45

Location: Store Sal

Abstract:

Haskell is a purely functional language designed in the early 90's, whose centre of gravity used to be academic, but which is increasingly used for commercial applications. One of Haskell's most distinctive features is its type system, especially so-called "type classes". Type classes serve a similar purpose to the classes of mainstream OO languages, but in a completely different way. As OOP languages acquire generics and, more recently, constrained polymorphism - both informed by their counterparts in functional languages - the comparison has become more interesting.

In this talk I'll sketch how type classes work, and contrast them with OOP classes. In so doing, I hope to give a somewhat new perspective on your familiar territory, and just possibly some ideas of what the future might hold. I'll give lots of examples, so you don't have to know Haskell.

Presentation: "Concurrency Expert Panel"

Track: The Concurrency challenge

Time: Tuesday 13:30 - 14:30

Location: Archauz

Abstract:

One theme of the panel is concurrent programming models. Specifically; classic locking, transactional memory and actors. And with concurrency we mean parallel systems (e.g. shared-memory multicore, cluster)

The goal is performance
One trust domain
Latencies are small and predicable
One failure => kill the program is just about tolerable
One of the goals for the discussion would be to get a better understanding of strengths and weaknesses; advice and discussion about when to use which model.

Another goal is:

for the audience to get to pick the brains of the experts
to get a good discussion going amongst the experts
to get concrete advice on choice of programming language (hence model) for certain problems.
advice on solving common problems that appear when using a particular model.

Presentation: "Data Parallel Haskell"

Track: The Concurrency challenge

Time: Tuesday 16:15 - 17:15

Location: Archauz

Abstract:

There are many approaches to exploiting multi-cores, but a particularly promising one is the "data-parallel" paradigm, because it combines massive parallelism (on both shared and distributed memory) with a simple, single control-flow programming model. Indeed, I think that data parallelism is the only way we will be able to exploit tens or hundreds of processors effectively.

Alas, data-parallel programming is usually restricted to "flat" data parallelism, which is good for implementers but bad for programmers. Instead, I'll describe the "nested" data parallel programming model, first developed in the 90's by Blelloch and Sabot. It is great for programmers but much harder to implement; as a result, it's virtually unknown in practice. It's really only feasible to support nested data parallelism in a purely functional language, so we are building a high-performance implementation in Haskell.

In this talk you'll learn what nested data parallelism is, why it's important, and how to use it in Haskell. Fear not: I won't assume you know any Haskell. Yet.

Keywords: Concurrency, data parallelism, functional programming, Haskell

Target audience: Developers who want to know what is just "over the horizon" for parallel programming.