About

The Scottish Programming Languages Seminar (SLPS) is an informal meeting to discuss any aspect of programming language theory, design and implementation. The next seminar will be held on Wednesday 24th of Feburary at the University of Glasgow, School of Computing Science.

Please RSVP using the following Doodle poll if you intend on coming along.

Acknowledgements

This meeting of SPLS has received financial support from the Complex Systems Engineering theme of the Scottish Informatics and Computer Science Alliance (SICSA).

Location

School of Computing Science, University of Glasgow
Sir Alwyn Williams Building
Level 5
Lilybank Gardens, Glasgow G12 8QQ

Please note the change in room from what was previously advertised.



Information on travelling to the School of Computing Science of the University of Glasgow may be found here.

Programme

Time Title / Speaker Abstract
12:00 Lunch
13:00 It was finally Christmas: Perl 6 is here

Wim Vanderbauwhede
University of Glasgow		 Perl 6, the successor of the influential and divisive Perl programming language, has finally been released, after 15 years of development. In this talk I would like to introduce this new language focusing on some of its cutting-edge features such as gradual typing and roles, grammars and rules, advanced list operations and laziness, the meta-object protocol, multi-dispatch and promises.
Developing a Haskell MOOC at Glasgow

Jeremy Singer & Wim Vanderbauwhede
University of Glasgow		 The Massive Open Online Course (MOOC) is the latest trend in higher education, exposing university learning and teaching to anyone on the net. At Glasgow, we are developing a MOOC to teach Haskell to non-functional (!) programmers. Our #haskellmooc is due to launch in September 2016 on the FutureLearn platform. In this talk we will share some background motivation and let you critique our learning materials.
14:10 Coffee
14:40 Complements Witness Consistency

James McKinna
University of Edinburgh		 In recent years, especially in the work of Benjamin Pierce and his coworkers on lenses, the focus of the PL community has been on extensional, state-based formalisms to describe bidirectional transformations (bx). More recently, attention has turned to incorporating intensional information about edits (typically based on monoid actions), or more generally, deltas (typically based on categories), describing how models are updated.

Pervasive in both the conceptual modelling, and the mathematics, of varieties of such bx, is the role played by the complement, which generalises the `constant complement' case of the view-update problem in databases. Complements typically reify, or correspond to, data which is abstracted away by passing from a source to a view.

In this talk, I'll present an alternative perspective, which has perhaps been implicit in the lens literature, but not, to our knowledge, previously made explicit anywhere: namely that elements of the complement are witnesses to the consistency relation maintained by the transformation. We illustrate this idea with examples drawn from the bx literature, especially that on varieties of lenses.
Adding Profiling and Code Coverage to GAP

Chris Jefferson
University of St. Andrews		 GAP is a dynamically typed language designed for discrete algebra, in particular computational group theory. GAP has several unique features, most notably the types of variables evolve during the execution of programs.

Recently a new project, known as HPC-GAP, is working on moving GAP into a multi-core world, while still allowing the large body of code written in GAP to continue to function with no changes, and be parallelised with minimal changes. This revealed that GAP's current testing framework is insufficient.

This talk will give an overview of GAP, how we parallelised GAP, and how we needed profiling and code coverage to achieve parallelisation.
15:50 Coffee
16:20 Compositional Compilation for Sparse, Irregular Data Parallelism

Adam Harries
University of Edinburgh 		Contemporary GPU architectures are heavily biased towards the execution of predictably regular data parallelism, while many real world application domains are based around data structures which are naturally sparse and irregular. This makes efficiently parallelising and executing sparse applications on GPUs difficult, as programmers must resort to low level, domain specific optimisations which are often non-portable, and difficult to express in current higher level languages.

In this talk, I will discuss our efforts to enable efficient high level sparse and irregular operations by embedding them in the space of high level dense data parallel operations. As part of this, I'll discuss how we implemented a specific sparse structure and algorithm within a regular pattern based programming framework, the correlations we found between good implementation choices and input irregularity and some promising preliminary performance results.
An Interference Controlled Language for Parallel Imperative Programming

Robert Atkey
University of Strathclyde		 Programs have two conflicting roles. In a single artefact, the programmer must simultaneously express what is to be computed, and also how the hardware resources must be marshalled to accomplish this task. As a gross generalisation, functional languages are well-suited to the former, while imperative languages excel at explicit control of resources.

I will talk about a programming language that combines functional and imperative programming orthogonally to gain the benefits of both, making use of a linear type system to ensure non-interference between program phrases, enabling parallelisation.. This language is based on John Reynolds' Syntactic Control of Interference variant of Idealised Algol, extended with features for array programming.

This is ongoing work with Michel Steuwer and Christophe Dubach of the University of Edinburgh.
17:30 Pub

Organisers