Neil Mitchell's home page

Henry Mitchell photo Neil Mitchell photo I'm a Haskell programmer who lives in Cambridge with my wife Emily and son Henry (who has grown up a little since the photo on the right was taken). I have a PhD in Computer Science from York University, working on making functional programs shorter, faster and safer. Since then I've worked with F# at Credit Suisse and Haskell/F#/C++ at Standard Chartered, taking the lessons of functional programming and applying them in finance. I'm a strong believer in the functional approach, finding the combination of conciseness, static-typing and testability to offer significant advantages. I've got a blog mostly about Haskell, and I'm also on Twitter, LinkedIn and GitHub. To get in touch email me at ndmitchell@gmail.com.

Open Source Projects

I develop a number of open source Haskell projects, all of which can be found at my Github page or on Hackage. I welcome both contributions via pull requests and bug reports via the GitHub issue trackers. Some of my more popular projects include:

Papers and talks

All papers and talks are listed below, most recent first. Show all abstracts or citations.

Paper: Shake Before Building - Replacing Make with Haskell

Paper, slides, video, citation, abstract from ICFP 2012, 10 Sep 2012.

@inproceedings{mitchell:shake_10_sep_2012 ,title = {Shake Before Building - Replacing Make with {Haskell}} ,author = {Neil Mitchell} ,year = {2012} ,month = {September} ,day = {10} ,location = {Copenhagen, Denmark} ,booktitle = {ICFP '12: Proceedings of the 17th ACM SIGPLAN International Conference on Functional Programming} ,publisher = {ACM} ,isbn = {978-1-4503-1054-3} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-shake_before_building-10_sep_2012.pdf'} }

Abstract: Most complex software projects are compiled using a build tool (e.g. make), which runs commands in an order satisfying user-defined dependencies. Unfortunately, most build tools require all dependencies to be specified before the build starts. This restriction makes many dependency patterns difficult to express, especially those involving files generated at build time. We show how to eliminate this restriction, allowing additional dependencies to be specified while building. We have implemented our ideas in the Haskell library Shake, and have used Shake to write a complex build system which compiles millions of lines of code.

An introduction to Shake, focusing on the theoretical side.

Talk: Hoogle: Finding Functions from Types

Slides, citation from TFP 2011, 16 May 2011.

@misc{mitchell:hoogle_16_may_2011 ,title = {Hoogle: Finding Functions from Types} ,author = {Neil Mitchell} ,year = {2011} ,month = {May} ,day = {16} ,note = {Presentation from TFP 2011} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-hoogle_finding_functions_from_types-16_may_2011.pdf'} }

An overview of how type-search works in Hoogle v1 to v4.

Talk: Shake: A Better Make

Slides, video, citation from Haskell Implementors Workshop 2010, 01 Oct 2010.

@misc{mitchell:shake_01_oct_2010 ,title = {Shake: A Better Make} ,author = {Neil Mitchell} ,year = {2010} ,month = {October} ,day = {1} ,note = {Presentation from Haskell Implementors Workshop 2010} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-shake_a_better_make-01_oct_2010.pdf'} }

Early details about the design of Shake.

Paper: Rethinking Supercompilation

Paper, slides, video, citation, abstract from ICFP 2010, 29 Sep 2010.

@inproceedings{mitchell:supercompilation_29_sep_2010 ,title = {Rethinking Supercompilation} ,author = {Neil Mitchell} ,year = {2010} ,month = {September} ,day = {29} ,location = {Baltimore, Maryland, USA} ,pages = {309--320} ,booktitle = {ICFP '10: Proceedings of the 15th ACM SIGPLAN International Conference on Functional Programming} ,doi = {http://doi.acm.org/10.1145/1863543.1863588} ,publisher = {ACM} ,isbn = {978-1-60558-794-3} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-rethinking_supercompilation-29_sep_2010.pdf'} }

Abstract: Supercompilation is a program optimisation technique that is particularly effective at eliminating unnecessary overheads. We have designed a new supercompiler, making many novel choices, including different termination criteria and handling of let bindings. The result is a supercompiler that focuses on simplicity, compiles programs quickly and optimises programs well. We have benchmarked our supercompiler, with some programs running more than twice as fast than when compiled with GHC.

Thoughts about making supercompilation faster, based on my experiments with Supero.

Paper: Deriving a Relationship from a Single Example

Paper, slides, citation, abstract from Approaches and Applications of Inductive Programming 2009, 04 Sep 2009.

@inproceedings{mitchell:derive_04_sep_2009 ,title = {Deriving a Relationship from a Single Example} ,author = {Neil Mitchell} ,year = {2009} ,month = {September} ,day = {4} ,location = {Edinburgh, Scotland, UK} ,series = {Lecture Notes in Computer Science, Vol. 5812} ,editors = {Ute Schmid, Emanuel Kitzelmann, Rinus Plasmeijer} ,isbn = {978-3-642-11930-9} ,pages = {1--24} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-deriving_a_relationship_from_a_single_example-04_sep_2009.pdf'} }

Abstract: Given an appropriate domain specific language (DSL), it is possible to describe the relationship between Haskell data types and many generic functions, typically type-class instances. While describing the relationship is possible, it is not always an easy task. There is an alternative - simply give one example output for a carefully chosen input, and have the relationship derived.

When deriving a relationship from only one example, it is important that the derived relationship is the intended one. We identify general restrictions on the DSL, and on the provided example, to ensure a level of predictability. We then apply these restrictions in practice, to derive the relationship between Haskell data types and generic functions. We have used our scheme in the Derive tool, where over 60% of type classes are derived from a single example.

Assuming you have a single example of a type class, what should the data type be, and what range of instances can be described. Implemented in the Derive tool.

Paper: Losing Functions without Gaining Data

Paper, slides, video, citation, abstract from Haskell Symposium 2009, 03 Sep 2009.

@inproceedings{mitchell:defunctionalisation_03_sep_2009 ,title = {Losing Functions without Gaining Data} ,author = {Neil Mitchell and Colin Runciman} ,year = {2009} ,month = {September} ,day = {3} ,booktitle = {Haskell '09: Proceedings of the second ACM SIGPLAN symposium on Haskell} ,pages = {49--60} ,location = {Edinburgh, Scotland, UK} ,doi = {http://doi.acm.org/10.1145/1411286.1411293} ,publisher = {ACM} ,isbn = {978-1-60558-508-6} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-losing_functions_without_gaining_data-03_sep_2009.pdf'} }

Abstract: We describe a transformation which takes a higher-order program, and produces an equivalent first-order program. Unlike Reynolds-style defunctionalisation, it does not introduce any new data types, and the results are more amenable to subsequent analysis operations. We can use our method to improve the results of existing analysis operations, including strictness analysis, pattern-match safety and termination checking. Our transformation is implemented, and works on a Core language to which Haskell programs can be reduced. Our method cannot always succeed in removing all functional values, but in practice is remarkably successful.

An algorithm for making higher-order programs first-order without introducing new data types (e.g. without doing Reynold's style defunctionalisation). The resulting program may have worse time complexity, but that's fine for certain types of analysis. Implemented as Firstify and used in Catch.

Talk: Supercompilation for Haskell

Slides, citation from Fun in the Afternoon Spring 2009, 03 Mar 2009.

@misc{mitchell:supercompilation_03_mar_2009 ,title = {Supercompilation for {Haskell}} ,author = {Neil Mitchell} ,year = {2009} ,month = {March} ,day = {3} ,note = {Presentation from Fun in the Afternoon Spring 2009} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-supercompilation_for_haskell-03_mar_2009.pdf'} }

Details of how to apply supercompilation to Haskell.

Paper: Hoogle Overview

Paper, citation, abstract from The Monad.Reader, 19 Nov 2008.

@article{mitchell:hoogle_19_nov_2008 ,title = {Hoogle Overview} ,author = {Neil Mitchell} ,year = {2008} ,month = {November} ,day = {19} ,journal = {The Monad.Reader} ,number = {12} ,pages = {27--35} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-hoogle_overview-19_nov_2008.pdf'} }

Abstract: This article gives an overview of the Hoogle tool. We describe the history of Hoogle, the improvements that have been made this summer, and plans for future features. Finally, we discuss the design guidelines of Hoogle 4 - which may be of interest both to budding Hoogle developers and other Haskell projects. This article does not cover the theoretical background of Hoogle.

An overview of Hoogle, including both the algorithms and code structure.

Paper: Not All Patterns, But Enough - an automatic verifier for partial but sufficient pattern matching

Paper, slides, video, citation, abstract from Haskell Symposium 2008, 25 Sep 2008.

@inproceedings{mitchell:catch_25_sep_2008 ,title = {Not All Patterns, But Enough - an automatic verifier for partial but sufficient pattern matching} ,author = {Neil Mitchell and Colin Runciman} ,year = {2008} ,month = {September} ,day = {25} ,booktitle = {Haskell '08: Proceedings of the first ACM SIGPLAN symposium on Haskell} ,pages = {49--60} ,location = {Victoria, BC, Canada} ,doi = {http://doi.acm.org/10.1145/1411286.1411293} ,publisher = {ACM} ,isbn = {978-1-60558-064-7} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-not_all_patterns_but_enough-25_sep_2008.pdf'} }

Abstract: We describe an automated analysis of Haskell 98 programs to check statically that, despite the possible use of partial (or nonexhaustive) pattern matching, no pattern-match failure can occur. Our method is an iterative backward analysis using a novel form of pattern-constraint to represent sets of data values. The analysis is defined for a core first-order language to which Haskell 98 programs are reduced. Our analysis tool has been successfully applied to a range of programs, and our techniques seem to scale well. Throughout the paper, methods are represented much as we have implemented them in practice, again in Haskell.

A static analysis for automatically proving a program will not raise an error at runtime, implemented as Catch. The analysis was able to detect 3 bugs in the HsColour program.

Talk: Hoogle: Fast Type Searching

Slides, audio, citation from AngloHaskell 2008, 09 Aug 2008.

@misc{mitchell:hoogle_09_aug_2008 ,title = {Hoogle: Fast Type Searching} ,author = {Neil Mitchell} ,year = {2008} ,month = {August} ,day = {9} ,note = {Presentation from AngloHaskell 2008} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-hoogle_fast_type_searching-09_aug_2008.pdf'} }

An early overview of how both type and text search works in Hoogle.

Thesis: Transformation and Analysis of Functional Programs

Paper, slides, citation, abstract, 04 Jun 2008.

@phdthesis{mitchell:thesis_04_jun_2008 ,title = {Transformation and Analysis of Functional Programs} ,author = {Neil Mitchell} ,year = {2008} ,month = {June} ,day = {4} ,school = {University of York} ,pages = {225} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-transformation_and_analysis_of_functional_programs-4_jun_2008.pdf'} }

Abstract: This thesis describes techniques for transforming and analysing functional programs. We operate on a core language, to which Haskell programs can be reduced. We present a range of techniques, all of which have been implemented and evaluated.

We make programs shorter by defining a library which abstracts over common data traversal patterns, removing boilerplate code. This library only supports traversals having value-specific behaviour for one type, allowing a simpler programming model. Our library allows concise expression of traversals with competitive performance.

We make programs faster by applying a variant of supercompilation. As a result of practical experiments, we have identified modifications to the standard supercompilation techniques -- particularly with respect to let bindings and the generalisation technique.

We make programs safer by automatically checking for potential pattern-match errors. We define a transformation that takes a higher-order program and produces an equivalent program with fewer functional values, typically a first-order program. We then define an analysis on a first-order language which checks statically that, despite the possible use of partial (or non-exhaustive) pattern matching, no pattern-match failure can occur.

My PhD thesis, covering a generics library (Uniplate), a supercompiler (Supero), a defunctionalisation algorithm (Firstify) and a pattern-match safety verifier (Catch).

Talk: Instances for Free

Slides, citation from PLASMA, 22 May 2008.

@misc{mitchell:deriving_22_may_2008 ,title = {Instances for Free} ,author = {Neil Mitchell} ,year = {2008} ,month = {May} ,day = {22} ,note = {Presentation from PLASMA} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-instances_for_free-22_may_2008.pdf'} }

Generating Haskell instances from examples, as found in the Derive tool.

Paper: A Supercompiler for Core Haskell

Paper, citation, abstract from IFL 2007 post proceedings, 01 May 2008.

@inproceedings{mitchell:supero_01_may_2008 ,title = {A Supercompiler for Core {Haskell}} ,author = {Neil Mitchell and Colin Runciman} ,year = {2008} ,month = {May} ,day = {1} ,pages = {147--164} ,booktitle = {IFL 2007} ,editor = {Olaf Chitil et al.} ,series = {LNCS} ,volume = {5083} ,publisher = {Springer-Verlag} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-a_supercompiler_for_core_haskell-01_may_2008.pdf'} }

Abstract: Haskell is a functional language, with features such as higher order functions and lazy evaluation, which allow succinct programs. These high-level features present many challenges for optimising compilers. We report practical experiments using novel variants of supercompilation, with special attention to let bindings and the generalisation technique.

An early design of the Supero supercompiler.

Talk: Detecting Pattern-Match Failures in Haskell

Slides, citation from The Oxford Centre for Metacomputation, 26 Nov 2007.

@misc{mitchell:catch_26_nov_2007 ,title = {Detecting Pattern-Match Failures in {Haskell}} ,author = {Neil Mitchell} ,year = {2007} ,month = {November} ,day = {26} ,note = {Presentation from The Oxford Centre for Metacomputation} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-detecting_pattern_match_failures_in_haskell-26_nov_2007.pdf'} }

Details about Catch, including worked examples.

Paper: Deriving Generic Functions by Example

Paper, slides, citation, abstract from York Doctoral Symposium 2007, 26 Oct 2007.

@inproceedings{mitchell:deriving_26_oct_2007 ,title = {Deriving Generic Functions by Example} ,author = {Neil Mitchell} ,year = {2007} ,month = {October} ,day = {26} ,pages = {55--62} ,publisher = {Tech. Report YCS-2007-421, Dept. of Computer Science, University of York, UK} ,editor = {Jan Tobias M\"{u}hlberg and Juan Ignacio Perna} ,booktitle = {Proceedings of the First York Doctoral Syposium 2007} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-deriving_generic_functions_by_example-26_oct_2007.pdf'} }

Abstract: A function is said to be generic if it operates over values of any data type. For example, a generic equality function can test pairs of booleans, integers, lists, trees etc. In most languages programmers must define generic functions multiple times, specialised for each data type. Alternatively, a tool could be used to specify the relationship between the data type and the implementation, but this relationship may be complex. This paper describes a solution: given a single example of the generic function on one data type, we can infer the relationship between a data type and the implementation. We have used our method in the Derive tool, allowing the implementation of 60% of the generic functions to be inferred.

An early version of the generic deriving work from Derive.

Paper: Uniform Boilerplate and List Processing

Paper, slides, video, citation, abstract from Haskell Workshop 2007, 30 Sep 2007.

@inproceedings{mitchell:uniplate_30_sep_2007 ,title = {Uniform Boilerplate and List Processing} ,author = {Neil Mitchell and Colin Runciman} ,year = {2007} ,month = {September} ,day = {30} ,booktitle = {Haskell '07: Proceedings of the ACM SIGPLAN workshop on Haskell} ,pages = {49--60} ,location = {Freiburg, Germany} ,doi = {http://doi.acm.org/10.1145/1291201.1291208} ,publisher = {ACM} ,isbn = {978-1-59593-674-5} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-uniform_boilerplate_and_list_processing-30_sep_2007.pdf'} }

Abstract: Generic traversals over recursive data structures are often referred to as boilerplate code. The definitions of functions involving such traversals may repeat very similar patterns, but with variations for different data types and different functionality. Libraries of operations abstracting away boilerplate code typically rely on elaborate types to make operations generic. The motivating observation for this paper is that most traversals have value-specific behaviour for just one type. We present the design of a new library exploiting this assumption. Our library allows concise expression of traversals with competitive performance.

Details of the Uniplate generics library, including information on how to use the Uniplate operations.

Paper: Supero: Making Haskell Faster

Paper, slides, citation, abstract from IFL 2007, 27 Sep 2007.

@inproceedings{mitchell:supercompilation_27_sep_2007 ,title = {Supero: Making {Haskell} Faster} ,author = {Neil Mitchell and Colin Runciman} ,year = {2007} ,month = {September} ,day = {27} ,booktitle = {IFL 2007: Draft Proceedings of the 19th International Symposium on Implementation and Application of Functional Languages} ,location = {Freiburg, Germany} ,publisher = {Tech. Report No. 12-07 of the Computing Laboratory, University of Kent, UK} ,editor = {Olaf Chitil} ,pages = {334--349} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-supero_making_haskell_faster-27_sep_2007.pdf'} }

Abstract: Haskell is a functional language, with features such as higher order functions and lazy evaluation, which allow succinct programs. These high-level features are difficult for fast execution, but GHC is a mature and widely used optimising compiler. This paper presents a whole-program approach to optimisation, which produces speed improvements of between 10% and 60% when used with GHC, on eight benchmarks.

A very early version of Supero, before it was an actual supercompiler.

Talk: Yhc: Past, Present, Future

Slides, citation from Anglo Haskell 2007, 10 Aug 2007.

@misc{mitchell:yhc_10_aug_2007 ,title = {Yhc: Past, Present, Future} ,author = {Neil Mitchell} ,year = {2007} ,month = {August} ,day = {10} ,note = {Presentation from Anglo Haskell 2007} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-yhc_past_present_future-10_aug_2007.pdf'} }

The history behind Yhc, along with future plans and intentions.

Talk: Faster Haskell

Slides, citation from Anglo Haskell 2007, 10 Aug 2007.

@misc{mitchell:supercompilation_10_aug_2007 ,title = {Faster {Haskell}} ,author = {Neil Mitchell} ,year = {2007} ,month = {August} ,day = {10} ,note = {Presentation from Anglo Haskell 2007} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-faster_haskell-10_aug_2007.pdf'} }

Early work on Supercompilation.

Talk: Transformation and Analysis of Haskell Source Code

Slides, citation from my thesis seminar, 02 Jul 2007.

@misc{mitchell:thesis_02_jul_2007 ,title = {Transformation and Analysis of {Haskell} Source Code} ,author = {Neil Mitchell} ,year = {2007} ,month = {July} ,day = {2} ,note = {Presentation from my thesis seminar} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-transformation_and_analysis_of_haskell_source_code-02_jul_2007.pdf'} }

Slides giving a very quick overview of my thesis.

Talk: Fastest Lambda First

Slides, citation from PLASMA, 30 May 2007.

@misc{mitchell:supercompilation_30_may_2007 ,title = {Fastest Lambda First} ,author = {Neil Mitchell} ,year = {2007} ,month = {May} ,day = {30} ,note = {Presentation from PLASMA} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-fastest_lambda_first-30_may_2007.pdf'} }

Details of a whole-program optimiser for Haskell, early work on Supero.

Paper: Yhc.Core - from Haskell to Core

Paper, citation, abstract from The Monad.Reader, 30 Apr 2007.

@article{mitchell:yhc_30_apr_2007 ,title = {{Yhc.Core} - from {Haskell} to Core} ,author = {Dimitry Golubovsky and Neil Mitchell and Matthew Naylor} ,year = {2007} ,month = {April} ,day = {30} ,journal = {The Monad.Reader} ,number = {7} ,pages = {45--61} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-yhc_core-30_apr_2007.pdf'} }

Abstract: The Yhc compiler is a hot-bed of new and interesting ideas. We present Yhc.Core - one of the most popular libraries from Yhc. We describe what we think makes Yhc.Core special, and how people have used it in various projects including an evaluator, and a Javascript code generator.

Information about the Yhc core language, its constructors and semantics.

Talk: First Order Haskell

Slides, citation from BCTCS 2007, 06 Apr 2007.

@misc{mitchell:defunctionalisation_06_apr_2007 ,title = {First Order {Haskell}} ,author = {Neil Mitchell} ,year = {2007} ,month = {April} ,day = {6} ,note = {Presentation from BCTCS 2007} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-first_order_haskell-06_apr_2007.pdf'} }

An early version of a mechanism for defunctionalising Haskell programs, which later became Firstify.

Talk: Ada: Generics

Slides, citation from the Algorithms and Data Structures course, 07 Mar 2007.

@misc{mitchell:ada_07_mar_2007 ,title = {Ada: Generics} ,author = {Neil Mitchell} ,year = {2007} ,month = {March} ,day = {7} ,note = {Presentation from the Algorithms and Data Structures course} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-ada_generics-07_mar_2007.pdf'} }

First-year lecture notes on generics in Ada.

Paper: A Static Checker for Safe Pattern Matching in Haskell

Paper, citation, abstract from TFP 2005 post proceedings, 01 Feb 2007.

@inproceedings{mitchell:catch_01_feb_2007 ,title = {A Static Checker for Safe Pattern Matching in {Haskell}} ,author = {Neil Mitchell and Colin Runciman} ,year = {2007} ,month = {February} ,day = {1} ,publisher = {Intellect} ,booktitle = {Trends in Functional Programming} ,volume = {6} ,isbn = {978-1-84150-176-5} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-a_static_checker_for_safe_pattern_matching_in_haskell-01_feb_2007.pdf'} }

Abstract: A Haskell program may fail at runtime with a pattern-match error if the program has any incomplete (non-exhaustive) patterns in definitions or case alternatives. This paper describes a static checker that allows non-exhaustive patterns to exist, yet ensures that a pattern-match error does not occur. It describes a constraint language that can be used to reason about pattern matches, along with mechanisms to propagate these constraints between program components.

An early version of Catch.

Talk: Playing with Haskell Data

Slides, citation from PLASMA, 18 Jan 2007.

@misc{mitchell:uniplate_18_jan_2007 ,title = {Playing with {Haskell} Data} ,author = {Neil Mitchell} ,year = {2007} ,month = {January} ,day = {18} ,note = {Presentation from PLASMA} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-playing_with_haskell_data-18_jan_2007.pdf'} }

Generic traversals and transformations over Haskell data types, what would later become Uniplate.

Talk: Haskell With Go Faster Stripes

Slides, citation from PLASMA, 30 Nov 2006.

@misc{mitchell:supercompilation_30_nov_2006 ,title = {Haskell With Go Faster Stripes} ,author = {Neil Mitchell} ,year = {2006} ,month = {November} ,day = {30} ,note = {Presentation from PLASMA} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-haskell_with_go_faster_stripes-30_nov_2006.pdf'} }

How to make Haskell faster.

Talk: Hat: Windows and WIMP

Slides, citation from Hat Day 2006 (Kent), 05 Oct 2006.

@misc{mitchell:hat_05_oct_2006 ,title = {Hat: {Windows} and {WIMP}} ,author = {Neil Mitchell} ,year = {2006} ,month = {October} ,day = {5} ,note = {Presentation from Hat Day 2006 (Kent)} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-hat_windows_and_wimp-05_oct_2006.pdf'} }

Thoughts about how the Hat tools could benefit from GUI elements.

Talk: Catch, A Practical Tool

Slides, citation from BCTCS 2006, 06 Apr 2006.

@misc{mitchell:catch_06_apr_2006 ,title = {Catch, A Practical Tool} ,author = {Neil Mitchell} ,year = {2006} ,month = {April} ,day = {6} ,note = {Presentation from BCTCS 2006} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-catch-06_apr_2006.pdf'} }

Very early notes on Catch.

Talk: Catch, Lazy Termination

Slides, citation from PLASMA, 16 Mar 2006.

@misc{mitchell:catch_16_mar_2006 ,title = {Catch, Lazy Termination} ,author = {Neil Mitchell} ,year = {2006} ,month = {March} ,day = {16} ,note = {Presentation from PLASMA} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-catch-16_mar_2006.pdf'} }

Discussions about what termination means in a lazy language, and how to detect it.

Talk: Hoogle

Slides, citation from PLASMA, 08 Dec 2005.

@misc{mitchell:hoogle_08_dec_2005 ,title = {Hoogle} ,author = {Neil Mitchell} ,year = {2005} ,month = {December} ,day = {8} ,note = {Presentation from PLASMA} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-hoogle-08_dec_2005.pdf'} }

An early introduction to Hoogle.

Paper: Visual Hat

Paper, slides, citation, abstract from Hat Day 2005 (York), 28 Oct 2005.

@inproceedings{mitchell:hat_28_oct_2005 ,title = {Visual {Hat}} ,author = {Neil Mitchell} ,year = {2005} ,month = {October} ,day = {28} ,booktitle = {Hat Day 2005: work in progress on the Hat tracing system for Haskell} ,pages = {23--26} ,publisher = {Tech. Report YCS-2005-395, Dept. of Computer Science, University of York, UK} ,editor = {Colin Runciman} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-hatday-28_oct_2005.pdf'} }

Abstract: This paper describes a new approach to visualizing the data contained in Hat traces. The aim is to cater for Windows users who are more familiar with graphical debugging tools.

Thoughts on how to make the Hat tools work in a GUI.

Paper: Unfailing Haskell: A Static Checker for Pattern Matching

Paper, slides, citation, abstract from TFP 2005, 24 Sep 2005.

@inproceedings{mitchell:catch_24_sep_2005 ,title = {Unfailing {Haskell}: A Static Checker for Pattern Matching} ,author = {Neil Mitchell and Colin Runciman} ,year = {2005} ,month = {September} ,day = {24} ,booktitle = {Proceedings of the Sixth Symposium on Trends in Functional Programming} ,pages = {313--328} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-unfailing_haskell_a_static_checker_for_pattern_matching-24_sep_2005.pdf'} }

Abstract: A Haskell program may fail at runtime with a pattern-match error if the program has any incomplete (non-exhaustive) patterns in definitions or case alternatives. This paper describes a static checker that allows non-exhaustive patterns to exist, yet ensures that a pattern-match error does not occur. It describes a constraint language that can be used to reason about pattern matches, along with mechanisms to propagate these constraints between program components.

A very early version of Catch.

Paper: Qualifying Dissertation: Unfailing Haskell

Paper, citation, abstract, 30 Jun 2005.

@misc{mitchell:thesis_30_jun_2005 ,title = {Qualifying Dissertation: Unfailing {Haskell}} ,author = {Neil Mitchell} ,year = {2005} ,month = {June} ,day = {30} ,institution = {University of York} ,url = {\verb'http://community.haskell.org/~ndm/downloads/paper-qualifying_dissertation-30_jun_2005.pdf'} }

Abstract: Programs written in Haskell may fail at runtime with either a pattern match error, or with non-termination. Both of these can be thought of as giving the value $\bot$ as a result. Other forms of failure, for example heap exhaustion, are not considered.

The first section of this document reviews previous work, including total functional programming and sized types. Attention is paid to termination checkers for both Prolog and various functional languages.

The main result from work so far is a static checker for pattern match errors that allows non-exhaustive patterns to exist, yet ensures that a pattern match error does not occur. It includes a constraint language that can be used to reason about pattern matches, along with mechanisms to propagate these constraints between program components.

The proposal deals with future work to be done. It gives an approximate timetable for the design and implementation of a static checker for termination and pattern match errors.

Discussions of total functional programming, an an early prototype of Catch.

Talk: Total Pasta

Slides, citation from BCTCS 2005, 23 Mar 2005.

@misc{mitchell:total_23_mar_2005 ,title = {Total {Pasta}} ,author = {Neil Mitchell} ,year = {2005} ,month = {March} ,day = {23} ,note = {Presentation from BCTCS 2005} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-total_pasta-23_mar_2005.pdf'} }

An algorithm for automatically proving totality of a simple pointer-based programming language.

Talk: Termination checking for a lazy functional language

Slides, citation from my first year literature review seminar, 21 Dec 2004.

@misc{mitchell:termination_21_dec_2004 ,title = {Termination checking for a lazy functional language} ,author = {Neil Mitchell} ,year = {2004} ,month = {December} ,day = {21} ,note = {Presentation from my first year literature review seminar} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-termination_checking_for_a_lazy_functional_language-21_dec_2004.pdf'} }

A review of the literature around termination checking, particular in lazy languages.

Talk: A New Parser

Slides, citation from PLASMA, 17 Nov 2004.

@misc{mitchell:parser_17_nov_2004 ,title = {A New Parser} ,author = {Neil Mitchell} ,year = {2004} ,month = {November} ,day = {17} ,note = {Presentation from PLASMA} ,url = {\verb'http://community.haskell.org/~ndm/downloads/slides-a_new_parser-17_nov_2004.pdf'} }

Thoughts about an alternative way to do parsing.