Scarcely variabled programming and Pascal. - Colin Runciman (ACM SIGPLAN Notices, 1979)

Semantic Errors - Diagnosis and Repair. - C. W. Johnson; Colin Runciman (SIGPLAN Symposium on Compiler Construction, 1982)

Interpreting algebraic specifications. - Colin Runciman (1983)

Deriving Functional Programs from Equational Specifications. - Colin Runciman (ADT, 1986)

Equal Opportunity Interactive Systems. - Colin Runciman; Harold W. Thimbleby (Int. J. Man Mach. Stud., 1986)

Adapting Combinator and SEC Machines to Display Snapshots of Functional Computations. - Ian Toyn; Colin Runciman (New Gener. Comput., 1986)

Interaction Models and the Principled Design of Interactive Systems. - Alan J. Dix; Michael D. Harrison; Colin Runciman; Harold W. Thimbleby (ESEC, 1987)

Performance polymorphism. - Ian Toyn; Alan J. Dix; Colin Runciman (FPCA, 1987)

Some software tools used in the development of the prototype york ada compiler. - Colin Runciman (Softw. Eng. J., 1987)

Transformation in a Non-Strict Language: An Approach to Instantiation. - Colin Runciman; Mike Firth; Nigel Jagger (Functional Programming, 1989)

Retrieving Re-Usable Software Components by Polymorphic Type. - Colin Runciman; Ian Toyn (FPCA, 1989)

What About the Natural Numbers? - Colin Runciman (Comput. Lang., 1989)

Formalised development of software by machine assisted transformation. - Colin Runciman; Mike Firth (Formal Methods in Software Development, 1990)

Problems & Proposals for Time & Space Profiling of Functional Programs. - Colin Runciman; David Wakeling (Functional Programming, 1990)

Relative Specification and Transformational Re-Use of Functional Programs. - Colin Runciman; Nigel Jagger (LISP Symb. Comput., 1990)

TIP in Haskell - another Exercise in Functional Programming. - Colin Runciman (Functional Programming, 1991)

Linearity and Laziness. - David Wakeling; Colin Runciman (FPCA, 1991)

Retrieving Reusable Software Components by Polymorphic Type. - Colin Runciman; Ian Toyn (J. Funct. Program., 1991)

Heap Profiling of a Lazy Functional Compiler. - Colin Runciman; David Wakeling (Functional Programming, 1992)

LZW Text Compression in Haskell. - Paul Sanders; Colin Runciman (Functional Programming, 1992)

A Relational Programming System with Inferred Representations. - Dave Cattrall; Colin Runciman (PLILP, 1992)

Profiling Parallel Functional Computations (Without Parallel Machines). - Colin Runciman; David Wakeling (Functional Programming, 1993)

Widening the Representation Bottleneck: A Functional Implementation of Relational Programming. - Dave Cattrall; Colin Runciman (FPCA, 1993)

An Incremental, Exploratory and Transformational Environment for the Lazy Functional Programming. - Colin Runciman; Ian Toyn; Mike Firth (J. Funct. Program., 1993)

Heap Profiling of Lazy Functional Programs. - Colin Runciman; David Wakeling (J. Funct. Program., 1993)

Techniques for Simplifying the Visualization of Graph Reduction. - Sandra P. Foubister; Colin Runciman (Functional Programming, 1994)

Binding-time Improvement and Fold/Unfold Transformation. - Colin Runciman (Functional Programming, 1994)

Type-Checked Message-Passing between Functional Processes. - Malcolm Wallace; Colin Runciman (Functional Programming, 1994)

Lambdas in the Liftshaft - Functional Programming and an Embedded Architecture. - Malcolm Wallace; Colin Runciman (FPCA, 1995)

Gadgets: Lazy Functional Components for Graphical User Interfaces - Rob Noble; Colin Runciman (PLILP, 1995)

Extending a Functional Programming System for Embedded Applications. - Malcolm Wallace; Colin Runciman (Softw. Pract. Exp., 1995)

Heap Profiling for Space Efficiency. - Colin Runciman; Niklas Röjemo (Advanced Functional Programming, 1996)

Astro-Gofer: Parallel Functional Programming with Co-ordinating Processes. - Andrew Douglas; Niklas Röjemo; Colin Runciman; Alan Wood (Euro-Par, Vol. I, 1996)

Lag, Drag, Void and Use - Heap Profiling and Space-Efficient Compilation Revisited. - Niklas Röjemo; Colin Runciman (ICFP, 1996)

Two-Pass Heap Profiling: A Matter of Life and Death. - Colin Runciman; Niklas Röjemo (Implementation of Functional Languages, 1996)

New Dimensions in Heap Profiling. - Colin Runciman; Niklas Röjemo (J. Funct. Program., 1996)

Auburn: A Kit for Benchmarking Functional Data Structures. - Graeme E. Moss; Colin Runciman (Implementation of Functional Languages, 1997)

Complete and Partial Redex Trails of Functional Computations. - Jan Sparud; Colin Runciman (Implementation of Functional Languages, 1997)

Tracing Lazy Functional Computations Using Redex Trails. - Jan Sparud; Colin Runciman (PLILP, 1997)

Lazy Wheel Sieves and Spirals of Primes. - Colin Runciman (J. Funct. Program., 1997)

An Interactive Approach to Profiling Parallel Functional Programs. - Nathan Charles; Colin Runciman (IFL, 1998)

The Bits Between The Lambdas: Binary Data in a Lazy Functional Language. - Malcolm Wallace; Colin Runciman (ISMM, 1998)

Performance Monitoring. - Nathan Charles; Colin Runciman (Research Directions in Parallel Functional Programming, 1999)

Automated Generalisation of Function Definitions. - Adam Bakewell; Colin Runciman (Fuji International Symposium on Functional and Logic Programming, 1999)

Haskell and XML: Generic Combinators or Type-Based Translation? - Malcolm Wallace; Colin Runciman (ICFP, 1999)

Automated Benchmarking of Functional Data Structures. - Graeme E. Moss; Colin Runciman (PADL, 1999)

Freja, Hat and Hood - A Comparative Evaluation of Three Systems for Tracing and Debugging Lazy Functional Programs. - Olaf Chitil; Colin Runciman; Malcolm Wallace (IFL, 2000)

A model for comparing the space usage of lazy evaluators. - Adam Bakewell; Colin Runciman (PPDP, 2000)

The space usage problem: An evaluation kit for graph reduction semantics. - Adam Bakewell; Colin Runciman (Scottish Functional Programming Workshop, 2000)

A Space Semantics for Core Haskell. - Adam Bakewell; Colin Runciman (Haskell, 2000)

Inductive benchmarking for purely functional data structures. - Graeme E. Moss; Colin Runciman (J. Funct. Program., 2001)

The accepting power of unary string logic programs. - Tatsuru Matsushita; Colin Runciman (Theor. Comput. Sci., 2001)

Testing and Tracing Lazy Functional Programs Using QuickCheck and Hat. - Koen Claessen; Colin Runciman; Olaf Chitil; John Hughes 001; Malcolm Wallace (Advanced Functional Programming, 2002)

Transforming Haskell for Tracing. - Olaf Chitil; Colin Runciman; Malcolm Wallace (IFL, 2002)

Checking the Shape Safety of Pointer Manipulations. - Adam Bakewell; Detlef Plump; Colin Runciman (RelMiCS, 2003)

Specifying Pointer Structures by Graph Reduction. - Adam Bakewell; Detlef Plump; Colin Runciman (AGTIVE, 2003)

Lazy Assertions. - Olaf Chitil; Dan McNeill; Colin Runciman (IFL, 2003)

A static checker for safe pattern matching in Haskell. - Neil Mitchell; Colin Runciman (Trends in Functional Programming, 2005)

Fine-grained Visualization Pipelines and Lazy Functional Languages. - David J. Duke; Malcolm Wallace; Rita Borgo; Colin Runciman (IEEE Trans. Vis. Comput. Graph., 2006)

Haskell program coverage. - Andy Gill; Colin Runciman (Haskell, 2007)

Uniform boilerplate and list processing. - Neil Mitchell; Colin Runciman (Haskell, 2007)

A functional-logic library for wired. - Matthew Naylor; Emil Axelsson; Colin Runciman (Haskell, 2007)

A Supercompiler for Core Haskell. - Neil Mitchell; Colin Runciman (IFL, 2007)

The Reduceron: Widening the von Neumann Bottleneck for Graph Reduction Using an FPGA. - Matthew Naylor; Colin Runciman (IFL, 2007)

Finding Inputs that Reach a Target Expression. - Matthew Naylor; Colin Runciman (SCAM, 2007)

Not all patterns, but enough: an automatic verifier for partial but sufficient pattern matching. - Neil Mitchell; Colin Runciman (Haskell, 2008)

Smallcheck and lazy smallcheck: automatic exhaustive testing for small values. - Colin Runciman; Matthew Naylor; Fredrik Lindblad (Haskell, 2008)

Experience report: visualizing data through functional pipelines. - David J. Duke; Rita Borgo; Colin Runciman; Malcolm Wallace (ICFP, 2008)

Losing functions without gaining data: another look at defunctionalisation. - Neil Mitchell; Colin Runciman (Haskell, 2009)

Huge Data But Small Programs: Visualization Design via Multiple Embedded DSLs. - David J. Duke; Rita Borgo; Malcolm Wallace; Colin Runciman (PADL, 2009)

Expressible sharing for functional circuit description. - Matthew Naylor; Colin Runciman (High. Order Symb. Comput., 2009)

The reduceron reconfigured. - Matthew Naylor; Colin Runciman (ICFP, 2010)

Lazy Generation of Canonical Test Programs. - Jason S. Reich; Matthew Naylor; Colin Runciman (IFL, 2011)

Advances in Lazy SmallCheck. - Jason S. Reich; Matthew Naylor; Colin Runciman (IFL, 2012)

The Reduceron reconfigured and re-evaluated. - Matthew Naylor; Colin Runciman (J. Funct. Program., 2012)

Improving implicit parallelism. - José Manuel Calderón Trilla; Colin Runciman (Haskell, 2015)

Déjà Fu: a concurrency testing library for Haskell. - Michael Walker 004; Colin Runciman (Haskell, 2015)

Weaving Parallel Threads - Searching for Useful Parallelism in Functional Programs. - José Manuel Calderón Trilla; Simon M. Poulding; Colin Runciman (SSBSE, 2015)

A Reference Interpreter for the Graph Programming Language GP 2. - Christopher Bak; Glyn Faulkner; Detlef Plump; Colin Runciman (GaM, 2015)

FitSpec: refining property sets for functional testing. - Rudy Braquehais; Colin Runciman (Haskell, 2016)

A Lightweight Hat: Simple Type-Preserving Instrumentation for Self-Tracing Lazy Functional Programs. - Olaf Chitil; Maarten Faddegon; Colin Runciman (IFL, 2016)

Speculate: discovering conditional equations and inequalities about black-box functions by reasoning from test results. - Rudy Braquehais; Colin Runciman (Haskell, 2017)

Extrapolate: generalizing counterexamples of functional test properties. - Rudy Braquehais; Colin Runciman (IFL, 2017)

Cheap Remarks About Concurrent Programs. - Michael Walker 004; Colin Runciman (FLOPS, 2018)

Super-naturals. - Ralf Hinze; Colin Runciman (J. Funct. Program., 2022)

Simplifying regular expressions further. - Stefan Kahrs; Colin Runciman (J. Symb. Comput., 2022)