Bernie Pope

Presentations and Posters

Colorectal cancer susceptibility genes: findings from whole exome, genome and targeted sequencing of multiple-case families

Bernard Pope, Khalid Mahmood, Mark Clendenning, Christophe Rosty, Marie Lorans, Harindra Jayasekara, Neil O’Callaghan, Susan Preston, Daniel J. Park, Fleur Hammet, Tu Nguyen-Dumont, Ashton Connor, Steven Gallinger, David Duggan, Graham Casey, Stephen N. Thibodeau, John L. Hopper, Melissa C. Southey, Aung K. Win, Finlay A. Macrae, Ingrid M. Winship, Mark A. Jenkins, Bernard Pope, Daniel D. Buchanan for the Australasian Colorectal Cancer Family Registry.

Familial Aspects of Cancer Research Practice, Kingscliff, Australia, 2017.

Slides

Abstract

Only a small proportion of the heritable risk for colorectal cancer (CRC) can be attributed to mutations within known CRC-associated genes, suggesting that additional CRC-predisposition genes are yet to be discovered. The aim of this study is to develop a mutational landscape of CRC predisposition from a family based cohort using a mixture of whole genome, exome and targeted sequencing. 200 CRC-affected individuals were selected for whole genome and exome sequencing from 100 Australasian Colorectal Cancer Family Registry (ACCFR) families (criteria: Familial Colorectal Cancer Type X (FCCTX), multiple-case families not meeting clinical criteria or had Oligopolyposis). Another set of 830 early-onset CRC cases from ACCFR were screened using multiplexed PCR-based target-enrichment (Hi-Plex).

Software pipelines were developed to identify variants from all sequencing platforms (available from https://github.com/khalidm). Variant calls were filtered on quality metrics such as depth of coverage and genotype qualities. Individual variants were prioritized as being likely pathogenic based on the criteria: (1) rare variants (ExAC MAF < 0.05%), (2) variants annotated as being protein truncating (stop gained, frameshifts and splice sites), (3) non-synonymous mutations with predicted impact on protein function derived from CADD score > 20 or REVEL score > 0.5. Gene level prioritization was performed by comparing frequencies of likely pathogenic variants observed in cases compared to the general population described in ExAC.

Sequencing analysis has identified 3 likely pathogenic FAN1 variants in 4 multi-case CRC families. The variant (FAN1:p.Arg952*) was found in 4 individuals from a family (3 CRC and 1 bone marrow cancer case). We have identified additional likely pathogenic variants in NTHL1, POLE and POLD1 genes using the WGS/WES and Hi-Plex data from these cohorts. We will also present novel likely pathogenic variants and genes as well as a complete landscape of likely pathogenic variants and genes across the cohorts. These data suggests that WES/WGS and targeted sequencing together are important tools for studying the underlying genetic causes for CRC-predisposition.


The Genetics of Colonic Polyposis Study: identifying the genetic basis of unexplained colonic polyposis

Sharelle Joseland, Mark Clendenning, Bernard J. Pope, Khalid Mahmood, Julie Arnold, Sonja Woodall, Marie Lorans, Neil O’Callaghan, Susan Preston, Chloe Wheatland, Kevin Sweet, Kara Semotiuk, Melissa C. Southey, Aung Ko Win, Mark A. Jenkins, Christophe Rosty, Finlay A. Macrae, Ingrid M. Winship, Susan Parry, Daniel D. Buchanan and FCCs

Familial Aspects of Cancer Research Practice, Kingscliff, Australia, 2017. Poster.


Hi-Plex Origin for the high-throughput screening of disease genes

Thomas Green, Fleur Hammet, Khalid Mahmood, Tu Nguyen-Dumont, Melissa Southey, Bernard Pope and Daniel Park

Familial Aspects of Cancer Research Practice, Kingscliff, Australia, 2017. Poster.


Characterisation of Mismatch Repair variants submitted to the International Mismatch Repair Consortium (IMRC)

Jeanette Reece, Daniel Buchanan, John-Paul Plazzer, Khalid Mahmood, Bernard Pope, Mark Clendenning, Grant Lee, Aung Win, Allyson Templeton, Robert Haile, Gabriela Moslein, Finlay Macrae, Mark Jenkins

The International Society for Gastrointestinal Hereditary Tumours (InSiGHT), 7th Biennial Meeting, Florence, Italy, 2017. Poster.


A registry of Australian Genomics bioinformatics pipelines incorporating a structured representation and interactive visualisation

Mailie Gall, Bernard Pope, John Pearson and Natalie Thorne

Australian Genomics National Conference, Brisbane, Australia, 2017.

Poster


Whole genome sequencing as a diagnostic tool for Lynch syndrome

B Pope, M Clendenning, K Mahmood, C Rosty, R Walters, A Win, J Hopper, M Southey, F Macrae, I Winship, M Jenkins, A Spurdle, D Buchanan.

The International Society for Gastrointestinal Hereditary Tumours (InSiGHT), 7th Biennial Meeting, Florence, Italy, 2017 (selected for oral presentation).

Slides

Abstract

Background: A high proportion of patients with tumours that have mismatch repair (MMR) deficiency are categorised as having “Lynch-like syndrome” (LLS) because standard screening approaches have been unable to identify a causative germline MMR gene mutation or somatic MLH1 methylation. The aim of this study was to investigate the application of whole genome sequencing (WGS) to identify novel germline causes, including structural variation, of tumour MMR-deficiency and Lynch syndrome.

Methods: We performed WGS on 16 LLS patients (including 2 relative pairs), in whom no MMR mutation had been found after Sanger sequencing and MLPA testing, who were selected for family history of cancer and/or young age at diagnosis. Two previously identified mutation carriers (MSH2 exon 6 deletion and MSH2 intron 1 c.212-478T>G mutation) were also sequenced as positive controls. Single nucleotide variants (SNVs) and short insertions and deletions (INDELS) were called using the GATK Best Practices Pipeline and annotated using the Ensembl, SnpEff and CADD Variant Effect Predictor tools. Structural variants (SVs) were detected using four tools: DELLY, LUMPY, Socrates and GRIDSS, prioritising high- confidence SV calls by applying quality filters and concordance between tools. Gene variants were prioritised based on occurrence in the MMR genes (Tier 1) and then other DNA repair genes (Tier II: including MUTYH, POLE, EXO1).

Results: SV analysis identified a 47.7MB inversion including exons 1-7 of MSH2 in a mother-daughter pair, both with MSH2-deficient colorectal cancers (CRCs). Validation by PCR-based assay confirmed the inversion and identified a further 3 carriers, 2 of whom had CRC. Additional candidate SVs identified included an intronic deletion in MSH2 in a woman with the endometrial cancer and an inversion in MUTYH gene in a man with MLH1/PMS2-deficient CRC. After filtering and annotation, we obtained a list of 9631 SNVs/INDELs across all samples. The top candidate likely pathogenic SNVs identified were in EXO1, LIG1, MUTYH and POLE including the POLE p.Arg680Cys SNV which showed evidence of segregation with CRC and polyp affected relatives.

Conclusions: WGS can identify people with Lynch syndrome among those with LLS. It also has the potential to identify novel susceptibility genes and mutations outside the current gene screening paradigm and, therefore, enables stratification of people with LLS and their families into different risk categories for more optimal clinical management.


Fuzz testing with American Fuzzy Lop (AFL)

VASET group, The University of Melbourne, Thursday 18 August 2016. Also given as a guest lecture in the University of Melbourne Masters subject Software Testing and Reliability (SWEN90006), 18 October 2016.

Slides

Abstract

American Fuzzy Lop (AFL) is a fuzz testing tool that has helped detect an impressive set of bugs. It uses compile-time program instrumentation and simple run-time statistics to detect program inputs which trigger novel execution paths. An initial program input is supplied by the user, from which a stream of new cases are generated based on a carefully tuned “genetic” algorithm (author’s terminology). In some cases AFL can synthesise complex input file structure from fairly distant starting points. A useful by-product of running AFL is a compact collection of synthetic test inputs which can be used for other testing regimes. AFL’s runtime overheads are very low, and, according to the author, real-word fuzzed programs can run at near-native speed. In this talk I give an overview of AFL and attempt to explain some of its implementation details.


Clinical Genomics: a Computational Perspective

linux.conf.au, Geelong, Monday 1 February 2016

Abstract

Low cost highly accurate DNA sequencing is quickly becoming an option for clinical diagnosis and treatment. In this talk I discuss the computational aspects of Clinical Genomics, based on recent experiences with the Melbourne Genomics Health Alliance. This was an invited talk for the Open Source and Bioinformatics miniconf, as part of the Linux Conference in Geelong 2016.


OptimusPrime: Multiplex Primer Design Tool for Hi-Plex Sequencing

E Lau, D Park, B Pope.

Australasian Genomic Technologies Association (AGTA), Annual Conference, Auckland, New Zealand, 2016.

Abstract

The advent of Massively Parallel Sequencing (MPS) has dramatically reduced the cost and increased the throughput of DNA sequencing. A number of methods have been developed that target specified genomic regions for MPS. However, these, variously, are compromised by issues of relative expense, accuracy, requirement for specialist equipment and the cumbersome nature of protocols. In this work we present Hi-Plex, a novel MPS platform, and multiplex Polymerase Chain Reaction (PCR) primer design software to meet the challenges the platform presents.


P Griffin, R Appels, D Bulach, K Dudley, G Keeble-Gagnere, A Pask, B Pope, U Roessner, T Seemann, D Bolser, J Khadake, S Lewis, S Orchard, S Tyagi, A Lonie, MV Schneider.

The Australian Bioinformatics and Computational Biology Society (AB3ACBS) Conference, Queensland, Australia, 2016. Poster.


RNASEL, a modifier of breast cancer risk in BRCA1 and BRCA2 carriers?

T Nguyen-Dumont, A Roberge, D Park, M Kapuscinski, Z Teo, F Hammet, M Mahmoodi, H Tsimiklis, B Pope, A Lonie, K Mahmood, kConFab, ABCFR, J Hopper, G Giles, M Southey.

6th International Symposium on Hereditary Breast and Ovarian Cancer, Montreal, Canada, 2016. Poster.



Whole-genome analysis of paediatric cancer from cases with a family cancer history: early insights from Victoria, Australia.

T Nguyen-Dumont, B Feng, H Tsimiklis, D Amor, E Algar, E Milne, L Spector, J Ng, A Lonie, D Park, B Pope, E Smibert, G Dite, M Southey, J Heath, J Hopper.

American Society of Human Genetics (ASHG) annual meeting, Vancouver, Canada 2016. Poster.


Another look at declarative debugging for Haskell

VASET group, The University of Melbourne, Friday 30 October 2015.

Slides

Abstract

Despite rising notoriety, Haskell still lacks effective debugging support. A breakpoint debugger exists, but, as expected, it is difficult to use in the presence of lazy evaluation and higher-order functions. We have previously considered declarative debugging as a more suitable approach for Haskell, but a number of technical challenges remain unsolved. In this talk I will revisit the main ideas behind declarative debugging and outline a few interesting areas of potential research in the context of non-strict purely functional languages, namely:

  • Generalising the structure of the debugging tree.
  • Interleaving debugging and program execution to reduce memory consumption.

Mutation screening of RNASEL, a candidate breast cancer susceptibility gene identified via whole-exome sequencing.

A Roberge, T Nguyen-Dumont, D Park, M Kapuscinski, F Hammet, M Mahmoodi, H Tsimiklis, B Pope, A Lonie, K Mahmood, kConFab, ABCFS, J Hopper, M Southey.

Familial Aspects of Cancer, Kingscliff, NSW, Australia, 2015. Poster.


Lindenmayer Systems

Foundations of Computing Advanced Lecture, The University of Melbourne, Friday 22 August 2014.

Slides

Abstract

These slides introduce the idea of turtle graphics in Python and show how they can be used to implement Lindenmayer Systems (term rewriting languages with interesting interpretations as graphics).


Visualizing and analyzing heterogeneous DNA methylation patterns by massively parallel sequencing using methpat.

N Wong, I Candiloro, B Pope, D Korbie, M Trau, S Wong, T Mikeska, X Zhang, M Pitman, A Dobrovic.

Australian Bioinformatics Conference (ABiC), Melbourne, Australia, 2014. Poster.


Introducing RedDog, a mapping-based genome comparison pipeline for bacterial high-throughput sequence data.

D Edwards, B Pope, and K Holt.

Lorne Infection and Immunity Conference, Victoria, Australia, 2014. Poster.


Hi-Plex: a flexible, streamlined and cost-effective approach to targeted massively parallel sequencing.

T Nguyen-Dumont, B Pope, F Hammet, M Mahmoodi, H Tsimiklis, M Southey, D Park.

American Society of Human Genetics (ASHG) annual meeting, San Diego, CA, USA 2014. Poster.


Hi-Plex: a flexible streamlined and cost-effective approach to targeted massively parallel sequencing.

T Nguyen-Dumont, B Pope, F Hammet, M Mahmoodi, H Tsimiklis, M Southey.

10th Australasian Mutation Detection meeting, Whitsundays, QLD, Australia, 2014. Poster.


ALLOCATE: sorting ovarian cancer patients into treatment arms based on molecular and genetic make up of their tumours.

O Kondrashova, S Lunke, L Melishkin, C Scott, B Tran, D Bowtell, O McNally, M Wakefield, C Sloggett, B Pope, C Anderson, G Taylor, P Waring.

Lorne Cancer Conference, Victoria, Australia, 2014.


Ray tracing in Python

Foundations of Computing Advanced Lecture, The University of Melbourne, Friday 5 September 2014.

Slides

Abstract

These slides explain the central ideas behind the recursive ray-tracing algorithm and demonstrate how to implement it in Python. A basic Phong Illumination model is used in the slides and program.

Code


Computer games in Python

Foundations of Computing Advanced Lecture, The University of Melbourne, Friday 19 September 2014.

Slides

Abstract

These slides show how to implement arcade games in Python using the PyGame library. To demonstrate the main ideas of game programming in Python I wrote a simple asteroids game which is available in the repository linked below.

Code


How Python works

Foundations of Computing Advanced Lecture, The University of Melbourne, Friday 10 October 2014.

Slides

Abstract

An overview of how Python works (CPython specifically). Covers syntax analysis (lexing and parsing), compilation to bytecode and program exeuction. The slides conclude with an example bytecode execution of a simple Python program.


Implementing Python in Haskell, twice

The Melbourne Python Users Group, Monday 7th July 2014.

Slides

Abstract

Over the past couple of years I’ve developed an unusual hobby: implementing Python in Haskell.

The first iteration resulted in berp, a Python-to-Haskell translator. The second iteration resulted in blip, which compiles Python to bytecode, and is compatible with the standard Python implementation CPython.

Note: I’ve given a similar talk to the Haskell User’s Group (see below). In this version of the talk the focus is oriented to a Python audience.


Functional graphics in Scala

The Melbourne Scala Users Group, Monday 26th May 2014.

Slides

Abstract

Computer graphics are typically represented using two-dimensional arrays of pixels. In this talk I will demonstrate an alternative, and perhaps surprising, representation based on functions:

   type Image[T] = (Double, Double) => T

We assume that images are defined (infinitely) over the two-dimensional real coordinate space, which avoids the need to worry about boundary conditions or discretisation.

I will also show how this idea can be extended to animations, by making them functions over time:

   type Animation[T] = Double => Image[T]

In addition to showing some pretty pictures, I demonstrate that higher-order functions are a powerful tool for program abstraction.

All the code for my talk is available on github: https://github.com/bjpop/scala-fungraph


Implementing Python in Haskell, twice

The Melbourne Haskell Users Group, Thursday 24th April 2014.

Slides

Abstract

Over the past couple of years I’ve developed an unusual hobby: implementing Python in Haskell.

The first iteration resulted in berp, a Python-to-Haskell translator. The second iteration resulted in blip, which compiles Python to bytecode, and is compatible with the standard Python implementation CPython.

In this talk I explain how I picked up this hobby, and where it might be going. I also talk about various Haskell features which underpin the two implementations.


Rubra - flexible distributed pipelines.

C Sloggett, M Wakefield, G Philip, B Pope.

Bioinformatics Open Source Conference (BOSC), Berlin, Germany, 2013. Poster.


Automating Pipelines for Variant Detection.

C Sloggett, G Philip, B Pope.

Lorne Genome Conference, Victoria, Australia, 2013. Poster.


Hi-Plex: a PCR-based approach for simple, rapid and cost-effective massively parallel sequencing library building.

T Nguyen-Dumont, B Pope, F Hammet, M Southey, D Park.

Familial Aspects of Cancer, Kingscliff, NSW, Australia, 2013. Poster.


FAVR (Filtering and Annotation of Variants that are Rare): methods to facilitate the analysis of new germline genetics variants from SOLiD and Illumina datasets.

T Nguyen-Dumont, B Pope, F Odefrey, R Bell, S Tavtigian, A Lonie, M Southey, D Park.

European Society of Human Genetics annual meeting, Paris, France, 2013. Poster.


A single-tube high-plex PCR approach for targeted massively parallel sequencing applied to FFPE-tumour derived material.

T Nguyen-Dumont, B Pope, F Hammet, M Southey, D Park.

American Society of Human Genetics (ASHG) annual meeting, Boston, MA, USA, 2013. Poster.


Functional Graphics in Python

An advanced lecture in COMP10001 Foundations of Computing at The University of Melbourne, 2013.

Slides

Abstract

The conventional way to represent computer graphics is with a two-dimensional array of pixels. In these slides we illustrate an alternative approach using functions from continuous coordinates to pixel values. Apart from being a neat idea, this representation provides great expressiveness for image transformations, and allows us to do impressive things with only a small amount of code. In these slides we use Python, but the same idea can be applied in any language with higher-order functions.


FAVR (Filtering and Annotation of Variants that are rare): methods to facilitate the analysis of rare germline genetic variants from SOLiD and Illumina datasets.

T Nguyen-Dumont, B Pope, F Odefrey, A Lonie, M Southey, D Park.

Familial Aspects of Cancer, Kingscliff, NSW, Australia, 2012. Poster.


Early insights from whole-exome analysis of early-onset, multiple-case breast cancer pedigrees.

T Nguyen-Dumont, D Park, F Odefrey, F Hammet, Z Teo, BCFR, BRCAX Consortium, D Goldgar D, S Tavtigian S, B Pope, A Lonie, M Southey.

Combined American Society of Human Genetics, International Congress of Human Genetics meetings, Montreal, Canada, 2011. Poster.


Identification of new breast cancer predisposition genes via whole-exome sequencing.

M Southey, D Park D, F Lesueur, F Odefrey, T Nguyen-Dumont, F Hammet, D Neuhausen, L Baglietto, A Lonie, B Pope, O Sinilnikova, H Tsimiklis, MCCS, BCFR, kConFab, G Giles, J Hopper, S Tavtigian, D Goldgar.

Familial Aspects of Cancer, Kingscliff, NSW, Australia, 2011. Poster.


Precision Medicine: Dawn of Supercomputing in omics Research.

M Reumann, K Holt, M Inouye, T Stinear, B Goudey, G Abraham, Q Wang, F Shi, A Kowalczyk, A Pearce, A Isaac, B Pope, H Butzkueven, J Wagner, S Moore, M Downton, P Church, S Turner, J Field, M Southey, D Bowtell, D Schmidt, E Makalic, J Zobel, J Hopper, S Petrovski, T O’Brien.

5th eResearch Australasia Conference (eResearch), Melbourne, Australia, 2011.


Open recursion and fixed points (in Scala)

The Melbourne Scala Users Group, Monday 25 July 2011.

Slides

Abstract

Classes in object oriented languages combine many different programming language features into a single abstraction. One of the key features is open recursion - the recursion on the self parameter which provides a late binding mechanism on method calls. In these slides we show how the same kind of extensibility can be achieved with ordinary higher order functions and fixed points (no classes). We use Scala to demonstrate the key ideas, but they can be easily translated to any language with higher-order functions.


The road to dependent types

The Melbourne Scala Users Group, Monday 28 March 2011.

Slides

Abstract

Barendregt’s Lambda Cube provides a neat characterisation of various kinds of typed Lambda Calculi. In these slides I show how we can explore the axes of the Lambda Cube by studying families of languages indexed by (possibly other) languages. For example the Simply Typed Lambda Calculus supports terms indexed by terms, whereas the Polymorphic Lambda Calculus extends this with terms indexed by types. Taking this idea further we can also consider types indexed by types and finally arrive at types indexed by terms, which is what most people call Dependent Types.


Haskell bindings to MPI

The Melbourne Functional Programming Union, Friday 30 July 2010.

Slides

Abstract

MPI (the Message Passing Interface) is a popular communication protocol for distributed parallel programming, providing both point-to- point and collective communication operators. Traditionally MPI is used in high-performance computing applications written in imperative languages, such as C, C++ and Fortran. I’ve recently been working on a Haskell binding to MPI via C and the Foreign Function Interface (FFI). One of the main challenges in writing such a binding is deciding how to map the low-level C API into idiomatic Haskell. In this talk I provide a brief overview of MPI, and then discuss the hows and whys of my current implementation effort.


Berp - an implementation of Python 3 in Haskell

The Melbourne Functional Programming Union, Friday 18 June 2010.

Slides

Abstract

Berp is an implementation of Python 3. At its heart is a translator, which takes Python code as input and generates Haskell code as output. The Haskell code is fed into a Haskell compiler (GHC) for compilation to machine code or interpretation as byte code.


Static Pattern Calculus

The Melbourne Functional Programming Union, Friday 22 January 2010.

Slides

Abstract

The Pattern Calculus extends the Lambda Calculus with first class patterns. Barry Jay recently published a book on the Pattern Calculus (which has been briefly discussed on this list), and I have been reading through it over the summer break. In this talk I give an overview of the term rewriting system which underpins the calculus. The term rewriting system is developed in four stages in the book. The first stage is the Lambda Calculus which is well known. The second stage is the Compound Calculus which is essentially a core version of LISP. The third stage is the Static Pattern Calculus which adds static patterns. The fourth stage is the Dynamic Pattern Calculus which adds dynamic patterns. This talk covers the static variant of the calculus only.


Monads in Scala

The Melbourne Scala Users Group, Monday 26 October 2009.

Slides

Abstract

Monads are a concept from Category Theory which has found many applications in both programming language theory and programming practice (particularly in functional languages such as Haskell). In this talk I discuss the way that monads underpin the for-comprehension notation used in Scala, and provide a simple term language evaluator as an example. I also discuss how the quest for modular denotational semantics in programming language theory led to the use of monads in programming practice.


Parser combinators in Scala

The Melbourne Scala Users Group, Monday 22 June 2009.

Slides

Abstract

Parser combinators provide an elegant way to specify parsing functions declaratively. Parsers written in this style have a structure which closely follows the EBNF grammar for the accepted language. This results in concise programs which can be readily checked against their formal specifications. Parsers are written entirely in the host language (in this case Scala), which avoids the need for additional languages and tools and their concomitant problems for software development. In this talk I will demonstrate Scala’s parser combinator library by constructing a parser for (a non-trivial subset of) XML. If time permits, I will also discuss the key ideas which underpin the implementation of parser combinators, and their historical roots in functional programming.


Applicative Functors

The Melbourne Functional Programming Union, Friday 3 July 2009.

Slides.

Abstract

Applicative functors provide a programming abstraction which sits between functors and monads. They capture a common pattern of programming with “effects”, which do not require the full expressiveness of monads.

One of the benefits of applicative functors over monads is that they allow effectful code to be written in direct style. For example, when using monadic parser combinators such as Parsec, one often writes code like this:

do { x <- e1; y <- e2; z <- e3; return (f x y z) }

where e1,e2,e3 are themselves parsers and f is some pure function which builds the result of the overall parser.

With applicative functors the same parser can be written like so:

f <$> e1 <*> e2 <*> e3

which resembles ordinary function application (hence the name applicative).

In cases like this, the monadic style obscures the important structure of the code, and requires redundant naming of the results of sub-computations (the x,y,z variables). Furthermore, in such cases the full expressiveness of monads is not warranted, and it is arguably better to use less expressive constructs where possible.

Applicative functors were introduced in the paper Applicative Programming with Effects (2008) by McBride and Paterson.


Simple graph reduction with visualisation

The Melbourne Functional Programming Union, Friday 12 May 2009.

Slides

Abstract

In 2008, whilst teaching the fourth year functional programming subject, I wrote a little functional language called miniFP for demonstration purposes. Near the end of the course we covered graph reduction. I extended miniFP to compile to a simple graph reduction system, implemented in C. One of the more interesting and useful aspects of the system is that it can produce pictures of the graph at each step of reduction. This allows the user to visualise the graph reduction process. It is especially helpful for understanding how cyclic data structures can be produced by ‘tying the knot’, which is a difficult topic to explain on paper. In this talk I outline some of the interesting aspects of the implementation, and show how it can be used.


Stack tracing in Haskell - an exploration of the design space

The Haskell Implementors Workshop, Saturday 5 2009, Edinburgh, Scotland.

Slides

Video from the Haskell Implementors Workshop

Abstract

The development of debugging tools for Haskell has tended to lag behind its imperative peers. The main technical reason for this is the difficulty of reconciling the operational behaviour of code under lazy evaluation with its static source description. Recently GHC has incorporated a breakpoint debugger into its byte-code interpreter. Experience with the debugger suggests that, while it is a useful addition to the programmer’s tool-set, the problems associated with lazy evaluation are (unsurprisingly) still present. Users often find it difficult to understand the chain of causation that leads to a particular expression being evaluated. Normally the chain of causation is represented as a stack of procedure invocations, but this is difficult in Haskell because the context in which a function application is constructed can differ considerably with the context in which it is evaluated. In this talk I will address the question “How can stack tracing be done in Haskell?”. The structure of the talk will consist of three main parts: 1) the desirable features of a stack trace; 2) the current state of the art; 3) implementation issues, focusing on GHC. Overall I hope to sketch out the design space and spur interest in possible future implementation efforts.


Continuations

The Melbourne Functional Programming Union, Friday 3 October 2008.

Slides

Abstract

Continuations are a method of reifying the evaluation context of a term within some computation. Intuitively, the continuation describes what may become of the value of the term in the overall computation. In this sense, a continuation provides a concrete representation of program control, and allows it to be manipulated. This “purely functional” account of program control has many useful results, such as: the extension of denotational semantics from the lambda calculus to (constructs from) conventional imperative languages, such as jumps; techniques for compiling high-level languages to machine code; and first class control operators, such as exception handlers. In recent times, more refined versions of continuations have emerged, such as the delimited continuations (or subcontinuations), which reify only a part of the evaluation context of a term. This talk covers: the continuation passing style (CPS); the history of continuations; some interesting applications of continuations; the use of continuations in the “direct style” of programming via primitives such as call/cc of Scheme; and connections to logic.


Reification in Haskell

B Pope and L Naish.

Implementation of Functional Languages (IFL), 13th International Workshop, Stockholm, Sweden, 2001 (oral presentation).


Specialisation of Higher-Order Functions for Debugging.

B Pope and L Naish.

Workshop on Functional and Logic Programming, Kiel, Germany, 2001 (oral presentation).