Implementing Haskell Type Classes. - Kevin Hammond; Stephen Blott (Functional Programming, 1989)

An Algorithmic and Semantic Approach to Debugging. - Cordelia V. Hall; Kevin Hammond; John T. O'Donnell (Functional Programming, 1990)

A Parallel Functional Database on GRIP. - Gert Akerholt; Kevin Hammond; Simon L. Peyton Jones; Philip W. Trinder (Functional Programming, 1991)

Efficient Type Inference Using Monads (Summary). - Kevin Hammond (Functional Programming, 1991)

The Glasgow Haskell Compiler: A Retrospective. - Cordelia V. Hall; Kevin Hammond; Will Partain; Simon L. Peyton Jones; Philip Wadler (Functional Programming, 1992)

Improving Persistent Data Manipulation for Functional Languages. - Kevin Hammond; Dave McNally; Patrick M. Sansom; Philip W. Trinder (Functional Programming, 1992)

Report on the Programming Language Haskell, A Non-strict, Purely Functional Language. - Paul Hudak; Simon L. Peyton Jones; Philip Wadler; Brian Boutel; Jon Fairbairn; Joseph H. Fasel; María M. Guzmán; Kevin Hammond; John Hughes 001; Thomas Johnsson; Richard B. Kieburtz; Rishiyur S. Nikhil; et al. (ACM SIGPLAN Notices, 1992)

Spiking Your Caches. - Kevin Hammond; Geoffrey Livingston Burn; Denis B. Howe (Functional Programming, 1993)

Processing Transactions on GRIP, a Parallel Graph Reducer. - Gert Akerholt; Kevin Hammond; Simon L. Peyton Jones; Philip W. Trinder (PARLE, 1993)

Automatic Spark Strategies and Granularity for a Parallel Functional Language Reducer. - Kevin Hammond; James S. Mattson Jr.; Simon L. Peyton Jones (CONPAR, 1994)

Improving Granularity in Parallel Functional Programs: A Graphical Winnowing System for Haskell. - Kevin Hammond; Hans-Wolfgang Loidl; Andrew S. Partridge (Functional Programming, 1994)

Parallel Functional Programming: An Introduction. - Kevin Hammond (PASCO, 1994)

Database Manipulation in Haskell 1.3. - Kevin Hammond; Philip W. Trinder (Functional Programming, 1995)

On the Granularity of Divide-and-Conquer Parallelism. - Hans-Wolfgang Loidl; Kevin Hammond (Functional Programming, 1995)

Making a Packet: Cost-Effective Communication for a Parallel Graph Reducer. - Hans-Wolfgang Loidl; Kevin Hammond (Implementation of Functional Languages, 1996)

GUM: A Portable Parallel Implementation of Haskell. - Philip W. Trinder; Kevin Hammond; James S. Mattson Jr.; Andrew S. Partridge; Simon L. Peyton Jones (PLDI, 1996)

Benchmarking Implementations of Functional Languages with 'Pseudoknot', a Float-Intensive Benchmark. - Pieter H. Hartel; Marc Feeley; Martin Helmut Alt; Lennart Augustsson; Peter Baumann; Marcel Beemster; Emmanuel Chailloux; Christine H. Flood; Wolfgang Grieskamp; John H. G. van Groningen; Kevin Hammond; Bogumil Hausman; et al. (J. Funct. Program., 1996)

Type Classes in Haskell. - Cordelia V. Hall; Kevin Hammond; Simon L. Peyton Jones; Philip Wadler (ACM Trans. Program. Lang. Syst., 1996)

Naira: A Parallel² Haskell Compiler. - Sahalu B. Junaidu; Antony J. T. Davie; Kevin Hammond (Implementation of Functional Languages, 1997)

Algorithms + Strategy = Parallelism. - Philip W. Trinder; Kevin Hammond; Hans-Wolfgang Loidl; Simon L. Peyton Jones (J. Funct. Program., 1998)

Introduction. - Kevin Hammond; Greg Michaelson (Research Directions in Parallel Functional Programming, 1999)

Summary. - Greg Michaelson; Kevin Hammond (Research Directions in Parallel Functional Programming, 1999)

Foundations. - Greg Michaelson; Kevin Hammond; Chris Clack (Research Directions in Parallel Functional Programming, 1999)

Large Scale Functional Applications. - Philip W. Trinder; Hans-Wolfgang Loidl; Kevin Hammond (Research Directions in Parallel Functional Programming, 1999)

HaskSkel: Algorithmic Skeletons in Haskell. - Kevin Hammond; Álvaro J. Rebón Portillo (IFL, 1999)

Engineering parallel symbolic programs in GPH. - Hans-Wolfgang Loidl; Philip W. Trinder; Kevin Hammond; Sahalu B. Junaidu; Richard G. Morgan; Simon L. Peyton Jones (Concurr. Pract. Exp., 1999)

The Multi-architecture Performance of the Parallel Functional Language GP H (Research Note). - Philip W. Trinder; Hans-Wolfgang Loidl; Ed. Barry Jr.; Kei Davis; Kevin Hammond; Ulrike Klusik; Simon L. Peyton Jones; Álvaro J. Rebón Portillo (Euro-Par, 2000)

Hume: a bounded time concurrent language. - Kevin Hammond (ICECS, 2000)

The Dynamic Properties of Hume: A Functionally-Based Concurrent Language with Bounded Time and Space Behaviour. - Kevin Hammond (IFL, 2000)

Parallel heuristic search in Haskell. - Michelle Cope; Ian P. Gent; Kevin Hammond (Scottish Functional Programming Workshop, 2000)

GpH and Eden: Comparing two parallel functional languages on a Beowulf cluster. - Hans-Wolfgang Loidl; Ulrike Klusik; Kevin Hammond; Rita Loogen; Philip W. Trinder (Scottish Functional Programming Workshop, 2000)

Parallel Programming: Models, Methods and Programming Languages. - Kevin Hammond (Euro-Par, 2002)

Predictable Space Behaviour in FSM-Hume. - Kevin Hammond; Greg Michaelson (IFL, 2002)

Cost Analysis Using Automatic Size and Time Inference. - Álvaro J. Rebón Portillo; Kevin Hammond; Hans-Wolfgang Loidl; Pedro B. Vasconcelos (IFL, 2002)

The Design of Hume: A High-Level Language for the Real-Time Embedded Systems Domain. - Kevin Hammond; Greg Michaelson (Domain-Specific Program Generation, 2003)

Hume: A Domain-Specific Language for Real-Time Embedded Systems. - Kevin Hammond; Greg Michaelson (GPCE, 2003)

Inferring Cost Equations for Recursive, Polymorphic and Higher-Order Functional Programs. - Pedro B. Vasconcelos; Kevin Hammond (IFL, 2003)

Is it time for real-time functional programming? - Kevin Hammond (Trends in Functional Programming, 2003)

FSM-Hume is finite state. - Greg Michaelson; Kevin Hammond; Jocelyn Sérot (Trends in Functional Programming, 2003)

Comparing Parallel Functional Languages: Programming and Performance. - Hans-Wolfgang Loidl; Fernando Rubio 001; Norman Scaife; Kevin Hammond; Susumu Horiguchi; Ulrike Klusik; Rita Loogen; Greg Michaelson; Ricardo Pena; Steffen Priebe; Álvaro J. Rebón Portillo; Philip W. Trinder (High. Order Symb. Comput., 2003)

Automatic Skeletons in Template Haskell. - Kevin Hammond; Jost Berthold; Rita Loogen (Parallel Process. Lett., 2003)

FSM-Hume: programming resource-limited systems using bounded automata. - Greg Michaelson; Kevin Hammond; Jocelyn Sérot (SAC, 2004)

Exploiting Purely Functional Programming to Obtain Bounded Resource Behaviour: The Hume Approach. - Kevin Hammond (CEFP, 2005)

A Dependently Typed Framework for Static Analysis of Program Execution Costs. - Edwin C. Brady; Kevin Hammond (IFL, 2005)

The Embounded project (project start paper). - Kevin Hammond; Roy Dyckhoff; Christian Ferdinand; Reinhold Heckmann; Martin Hofmann 001; Steffen Jost; Hans-Wolfgang Loidl; Greg Michaelson; Robert F. Pointon; Norman Scaife; Jocelyn Sérot; Andy Wallace (Trends in Functional Programming, 2005)

A verified staged interpreter is a verified compiler. - Edwin C. Brady; Kevin Hammond (GPCE, 2006)

Worst-Case Execution Times for a Purely Functional Language. - Armelle Bonenfant; Christian Ferdinand; Kevin Hammond; Reinhold Heckmann (IFL, 2006)

Low-Level Programming in Hume: An Exploration of the HW-Hume Level. - Kevin Hammond; Gudmund Grov; Greg Michaelson; Andrew Ireland (IFL, 2006)

Using Intersection Types for Cost-Analysis of Higher-Order Polymorphic Functional Programs. - Hugo R. Simões; Kevin Hammond; Mário Florido; Pedro B. Vasconcelos (TYPES, 2006)

Towards Formally Verifiable WCET Analysis for a Functional Programming Language. - Kevin Hammond; Christian Ferdinand; Reinhold Heckmann; Roy Dyckhoff; Martin Hofmann 001; Steffen Jost; Hans-Wolfgang Loidl; Greg Michaelson; Robert F. Pointon; Norman Scaife; Jocelyn Sérot; Andy Wallace (WCET, 2006)

Towards formally verifiable resource bounds for real-time embedded systems. - Kevin Hammond; Christian Ferdinand; Reinhold Heckmann (SIGBED Rev., 2006)

SymGrid: A Framework for Symbolic Computation on the Grid. - Kevin Hammond; Abdallah Al Zain; Gene Cooperman; Dana Petcu; Philip W. Trinder (Euro-Par, 2007)

SymGrid-Par: Designing a Framework for Executing Computational Algebra Systems on Computational Grids. - Abdallah Al Zain; Kevin Hammond; Philip W. Trinder; Steve Linton; Hans-Wolfgang Loidl; Marco Costanti (International Conference on Computational Science (2), 2007)

Generic Access to Web and Grid-based Symbolic Computing Services: the SymGrid-Services Framework. - Alexandru Cârstea; Marc Frîncu; Georgiana Macariu; Dana Petcu; Kevin Hammond (ISPDC, 2007)

Towards resource-certified software: a formal cost model for time and its application to an image-processing example. - Armelle Bonenfant; Zezhi Chen; Kevin Hammond; Greg Michaelson; Andrew M. Wallace; Iain Wallace (SAC, 2007)

Constructing Correct Circuits: Verification of Functional Aspects of Hardware Specifications with Dependent Types. - Edwin C. Brady; James McKinna; Kevin Hammond (Trends in Functional Programming, 2007)

SymGrid: A Framework for Symbolic Computations on the Grid. - Kevin Hammond (SYNASC, 2007)

Automatic Amortised Worst-Case Execution Time Analysis. - Christoph A. Herrmann; Armelle Bonenfant; Kevin Hammond; Steffen Jost; Hans-Wolfgang Loidl; Robert F. Pointon (WCET, 2007)

Using application information to drive adaptive grid middleware scheduling decisions. - Vladimir Janjic; Kevin Hammond; Yang Yang (MAI@DisCoTec, 2008)

Parallelism without Pain: Orchestrating Computational Algebra Components into a High-Performance Parallel System. - Abdallah Al Zain; Philip W. Trinder; Kevin Hammond; Alexander Konovalov 001; Steve Linton; Jost Berthold (ISPA, 2008)

Lightweight Invariants with Full Dependent Types. - Edwin C. Brady; Christoph A. Herrmann; Kevin Hammond (Trends in Functional Programming, 2008)

Towards Hume SIMD vectorisation. - Abdallah Al Zain; Valerie Gibson; Greg J. Michaelson; Kevin Hammond; Steffen Jost; Hans-Wolfgang Loidl (EUSIPCO, 2009)

"Carbon Credits" for Resource-Bounded Computations Using Amortised Analysis. - Steffen Jost; Hans-Wolfgang Loidl; Kevin Hammond; Norman Scaife; Martin Hofmann 001 (FM, 2009)

Domain Specific Languages (DSLs) for Network Protocols (Position Paper). - Saleem Bhatti; Edwin C. Brady; Kevin Hammond; James McKinna (ICDCS Workshops, 2009)

Comparing and Optimising Parallel Haskell Implementations for Multicore Machines. - Jost Berthold; Simon Marlow; Kevin Hammond; Abdallah Al Zain (ICPP Workshops, 2009)

Low-pain, high-gain multicore programming in Haskell: coordinating irregular symbolic computations on multicore architectures. - Abdallah Al Zain; Kevin Hammond; Jost Berthold; Philip W. Trinder; Greg Michaelson; Mustafa Aswad (DAMP, 2009)

The Peter Landin prize. - Kevin Hammond; Greg Michaelson (High. Order Symb. Comput., 2009)

Granularity-Aware Work-Stealing for Computationally-Uniform Grids. - Vladimir Janjic; Kevin Hammond (CCGRID, 2010)

Scrapping your inefficient engine: using partial evaluation to improve domain-specific language implementation. - Edwin C. Brady; Kevin Hammond (ICFP, 2010)

Improving Your CASH Flow: The Computer Algebra SHell. - Christopher Brown 002; Hans-Wolfgang Loidl; Jost Berthold; Kevin Hammond (IFL, 2010)

Easy composition of symbolic computation software: a new lingua franca for symbolic computation. - Steve Linton; Kevin Hammond; Alexander Konovalov 001; Abdallah Al Zain; Philip W. Trinder; Peter Horn; Dan Roozemond (ISSAC, 2010)

Static determination of quantitative resource usage for higher-order programs. - Steffen Jost; Kevin Hammond; Hans-Wolfgang Loidl; Martin Hofmann 001 (POPL, 2010)

Correct-by-Construction Concurrency: Using Dependent Types to Verify Implementations of Effectful Resource Usage Protocols. - Edwin C. Brady; Kevin Hammond (Fundam. Informaticae, 2010)

Why Parallel Functional Programming Matters: Panel Statement. - Kevin Hammond (Ada-Europe, 2011)

Paraphrasing: Generating Parallel Programs Using Refactoring. - Christopher Brown 002; Kevin Hammond; Marco Danelutto; Peter Kilpatrick; Holger Schöner; Tino Breddin (FMCO, 2011)

The ParaPhrase Project: Parallel Patterns for Adaptive Heterogeneous Multicore Systems. - Kevin Hammond; Marco Aldinucci; Christopher Brown 002; Francesco Cesarini; Marco Danelutto; Horacio González-Vélez; Peter Kilpatrick; Rainer Keller; Michael Rossbory; Gilad Shainer (FMCO, 2011)

Counter Automata for Parameterised Timing Analysis of Box-Based Systems. - Christoph A. Herrmann; Kevin Hammond (FOPARA, 2011)

Engineering Concurrent Software Guided by Statistical Performance Analysis. - Clemens Grelck; Kevin Hammond; Heinz Hertlein; Philip K. F. Hölzenspies; Chris R. Jesshope; Raimund Kirner; Bernd Scheuermann; Alexander V. Shafarenko; Iraneus te Boekhorst; Volkmar Wieser (PARCO, 2011)

ParaForming: Forming Parallel Haskell Programs Using Novel Refactoring Techniques. - Christopher Brown 002; Hans-Wolfgang Loidl; Kevin Hammond (Trends in Functional Programming, 2011)

Glasgow Parallel Haskell (GpH). - Kevin Hammond (Encyclopedia of Parallel Computing, 2011)

Functional Languages. - Philip W. Trinder; Hans-Wolfgang Loidl; Kevin Hammond (Encyclopedia of Parallel Computing, 2011)

Code-level timing analysis of embedded software: emsoft'12 invited talk session outline. - Heiko Falk; Kevin Hammond; Kim G. Larsen; Björn Lisper; Stefan M. Petters (EMSOFT, 2012)

ParaPhrase Workshop 2012. - Marco Danelutto; Kevin Hammond; Horacio González-Vélez (Euro-Par Workshops, 2012)

Using Load Information in Work-Stealing on Distributed Systems with Non-uniform Communication Latencies. - Vladimir Janjic; Kevin Hammond (Euro-Par, 2012)

Automatic amortised analysis of dynamic memory allocation for lazy functional programs. - Hugo R. Simões; Pedro B. Vasconcelos; Mário Florido; Steffen Jost; Kevin Hammond (ICFP, 2012)

A language-independent parallel refactoring framework. - Christopher Brown 002; Kevin Hammond; Marco Danelutto; Peter Kilpatrick (WRT@ICSE, 2012)

Resource-Safe Systems Programming with Embedded Domain Specific Languages. - Edwin C. Brady; Kevin Hammond (PADL, 2012)

Repeating History: Execution Replay for Parallel Haskell Programs. - Henrique Ferreiro; Vladimir Janjic; Laura M. Castro; Kevin Hammond (Trends in Functional Programming, 2012)

Orchestrating computational algebra components into a high-performance parallel system. - Abdallah Al Zain; Philip W. Trinder; Kevin Hammond (Int. J. High Perform. Comput. Netw., 2012)

Guest Editors Note: High-Level Programming for Heterogeneous and Hierarchical Parallel Systems. - Gaétan Hains; Frédéric Gava; Kevin Hammond (Parallel Process. Lett., 2012)

Introduction to the Special Issue on Automatic Program Generation for Embedded Systems. - Kevin Hammond; Paul H. J. Kelly (Sci. Comput. Program., 2012)

Mapping parallel programs to heterogeneous CPU/GPU architectures using a Monte Carlo Tree Search. - Mehdi Goli 001; John A. W. McCall; Christopher Brown 002; Vladimir Janjic; Kevin Hammond (IEEE Congress on Evolutionary Computation, 2013)

How to be a Successful Thief - Feudal Work Stealing for Irregular Divide-and-Conquer Applications on Heterogeneous Distributed Systems. - Vladimir Janjic; Kevin Hammond (Euro-Par, 2013)

Space Exploration using Parallel Orbits: a Study in Parallel Symbolic Computing. - Vladimir Janjic; Christopher Brown 002; Max Neunhöffer; Kevin Hammond; Steve Linton; Hans-Wolfgang Loidl (PARCO, 2013)

Resource analyses for parallel and distributed coordination. - Philip W. Trinder; M. I. Cole; Kevin Hammond; Hans-Wolfgang Loidl; Greg Michaelson (Concurr. Comput. Pract. Exp., 2013)

Easy composition of symbolic computation software using SCSCP: A new Lingua Franca for symbolic computation. - Steve Linton; Kevin Hammond; Alexander Konovalov 001; Christopher Brown 002; Philip W. Trinder; Hans-Wolfgang Loidl; Peter Horn; Dan Roozemond (J. Symb. Comput., 2013)

Discovering parallel pattern candidates in Erlang. - István Bozó; Viktoria Fordós; Zoltán Horváth; Melinda Tóth; Dániel Horpácsi; Tamás Kozsik; Judit Köszegi; Adam D. Barwell; Christopher Brown 002; Kevin Hammond (Erlang Workshop, 2014)

Functional programming and the "megacore" era. - Kevin Hammond (Erlang Workshop, 2014)

Agricultural Reform: More Efficient Farming Using Advanced Parallel Refactoring Tools. - Christopher Brown 002; Vladimir Janjic; Kevin Hammond; Holger Schöner; Kamran Idrees; Colin W. Glass (PDP, 2014)

Cost-Directed Refactoring for Parallel Erlang Programs. - Christopher Brown 002; Marco Danelutto; Kevin Hammond; Peter Kilpatrick; Archibald Elliott (Int. J. Parallel Program., 2014)

Type-Based Allocation Analysis for Co-recursion in Lazy Functional Languages. - Pedro B. Vasconcelos; Steffen Jost; Mário Florido; Kevin Hammond (ESOP, 2015)

Timing Properties and Correctness for Structured Parallel Programs on x86-64 Multicores. - Kevin Hammond; Christopher Brown 002; Susmit Sarkar (FOPARA, 2015)

Lapedo: Hybrid Skeletons for Programming Heterogeneous Multicore Machines in Erlang. - Vladimir Janjic; Christopher Brown 002; Kevin Hammond (PARCO, 2015)

Kindergarten cop: dynamic nursery resizing for GHC. - Henrique Ferreiro; Laura M. Castro; Vladimir Janjic; Kevin Hammond (CC, 2016)

Towards semi-automatic data-type translation for parallelism in Erlang. - Adam D. Barwell; Christopher Brown 002; David Castro 006; Kevin Hammond (Erlang Workshop, 2016)

Farms, pipes, streams and reforestation: reasoning about structured parallel processes using types and hylomorphisms. - David Castro 006; Kevin Hammond; Susmit Sarkar (ICFP, 2016)

Coinductive Soundness of Corecursive Type Class Resolution. - Frantisek Farka; Ekaterina Komendantskaya; Kevin Hammond (LOPSTR, 2016)

RPL: A Domain-Specific Language for Designing and Implementing Parallel C++ Applications. - Vladimir Janjic; Christopher Brown 002; Kenneth MacKenzie; Kevin Hammond; Marco Danelutto; Marco Aldinucci; José Daniel García (PDP, 2016)

Using Program Shaping and Algorithmic Skeletons to Parallelise an Evolutionary Multi-Agent System in Erlang. - Adam D. Barwell; Christopher Brown 002; Kevin Hammond; Wojciech Turek; Aleksander Byrski (Comput. Informatics, 2016)

HPC-GAP: engineering a 21st-century high-performance computer algebra system. - Reimer Behrends; Kevin Hammond; Vladimir Janjic; Alexander Konovalov 001; Steve Linton; Hans-Wolfgang Loidl; Patrick Maier 001; Phil Trinder (Concurr. Comput. Pract. Exp., 2016)

Coinductive Soundness of Corecursive Type Class Resolution. - Frantisek Farka; Ekaterina Komendantskaya; Kevin Hammond; Peng Fu 001 (CoRR, 2016)

PAEAN: Portable and scalable runtime support for parallel Haskell dialects. - Jost Berthold; Hans-Wolfgang Loidl; Kevin Hammond (J. Funct. Program., 2016)

In search of a map: using program slicing to discover potential parallelism in recursive functions. - Adam D. Barwell; Kevin Hammond (FHPC@ICFP, 2017)

Type-Based Cost Analysis for Lazy Functional Languages. - Steffen Jost; Pedro B. Vasconcelos; Mário Florido; Kevin Hammond (J. Autom. Reason., 2017)

Special issue on Parallel and distributed computing based on the functional programming paradigm. - Wojciech Turek; Aleksander Byrski; John Hughes 001; Kevin Hammond; Marek Zaionc (Concurr. Comput. Pract. Exp., 2018)

Finding parallel functional pearls: Automatic parallel recursion scheme detection in Haskell functions via anti-unification. - Adam D. Barwell; Christopher Brown 002; Kevin Hammond (Future Gener. Comput. Syst., 2018)

Special section on functional paradigm for high performance computing. - Aleksander Byrski; Katarzyna Rycerz; John Hughes 001; Kevin Hammond (Future Gener. Comput. Syst., 2018)

Automatically deriving cost models for structured parallel processes using hylomorphisms. - David Castro 006; Kevin Hammond; Susmit Sarkar; Yasir Alguwaifli (Future Gener. Comput. Syst., 2018)

The Missing Link! A New Skeleton for Evolutionary Multi-agent Systems in Erlang. - Jan Stypka; Wojciech Turek; Aleksander Byrski; Marek Kisiel-Dorohinicki; Adam D. Barwell; Christopher Brown 002; Kevin Hammond; Vladimir Janjic (Int. J. Parallel Program., 2018)

Reengineering for parallelism in heterogeneous parallel platforms. - José Daniel García; Kevin Hammond; Lutz Schubert (J. Supercomput., 2018)

Proof-relevant Horn Clauses for Dependent Type Inference and Term Synthesis. - Frantisek Farka; Ekaterina Komendantskaya; Kevin Hammond (Theory Pract. Log. Program., 2018)

Proof-Carrying Plans. - Christopher Schwaab; Ekaterina Komendantskaya; Alasdair Hill; Frantisek Farka; Ronald P. A. Petrick; Joe B. Wells; Kevin Hammond (PADL, 2019)

Learning-Based Dynamic Pinning of Parallelized Applications in Many-Core Systems. - Georgios C. Chasparis; Michael Rossbory; Vladimir Janjic; Kevin Hammond (PDP, 2019)

Extending the "Open-Closed Principle" to Automated Algorithm Configuration. - Jerry Swan; Steven Adriænsen; Adam D. Barwell; Kevin Hammond; David R. White 003 (Evol. Comput., 2019)

Flexible Formality Practical Experience with Agile Formal Methods. - Philipp Kant; Kevin Hammond; Duncan Coutts; James Chapman 001; Nicholas Clarke; Jared Corduan; Neil J. Davies; Javier Díaz; Matthias Güdemann; Wolfgang Jeltsch; Marcin Szamotulski; Polina Vinogradova (TFP, 2020)

Refactoring for introducing and tuning parallelism for heterogeneous multicore machines in Erlang. - Vladimir Janjic; Christopher Brown 002; Adam D. Barwell; Kevin Hammond (Concurr. Comput. Pract. Exp., 2021)

Mind Your Outcomes: The ΔQSD Paradigm for Quality-Centric Systems Development and Its Application to a Blockchain Case Study. - Seyed H. Haeri; Peter Thompson 002; Neil J. Davies; Peter Van Roy; Kevin Hammond; James Chapman 001 (Comput., 2022)

Metaheuristics "In the Large". - Jerry Swan; Steven Adriænsen; Alexander E. I. Brownlee; Kevin Hammond; Colin G. Johnson; Ahmed Kheiri; Faustyna Krawiec; Juan Julián Merelo; Leandro L. Minku; Ender Özcan; Gisele L. Pappa; Pablo García-Sánchez; et al. (Eur. J. Oper. Res., 2022)

Host-directed vibroacoustic biosignature of viral respiratory infection. - Andreas Schuh; Michael Morimoto; Piotr Kaszuba; Kevin Hammond; Jerry Swan; Krzysztof Krawiec; Nl Shasha Jumbe (BHI, 2023)

Synthesizing Effective Diagnostic Models from Small Samples using Structural Machine Learning: a Case Study in Automating COVID-19 Diagnosis. - Piotr Kaszuba; Andrew Turner; Bartosz Mikulski; Nl Shasha Jumbe; Andreas Schuh; Michael Morimoto; Peter Rexelius; Ryan Hafen; Ron Deiotte; Kevin Hammond; Jerry Swan; Krzysztof Krawiec (GECCO Companion, 2023)

Algebraic Reasoning About Timeliness. - Seyed Hossein Haeri; Peter W. Thompson 002; Peter Van Roy; Magne Haveraaen; Neil J. Davies; Mikhail Barash; Kevin Hammond; James Chapman 001 (ICE, 2023)