Hi, I'm Finnbar (they/them), a PhD student supervised by Dr Gihan Mudalige (2020-2024). My work considers the use of functional programming (particularly Haskell) in reactive programs, as to verify them more easily and thus prevent errors in contexts where they are particularly costly.
I also did my undergraduate degree (MEng Computer Science, first-class) here at Warwick (2016-2020).
My PhD work focuses on type systems and program transformations for reactive programs - programs which consume inputs over time to produce outputs at the same rate, thus causing said programs to react to their inputs. These programs tend to be used in safety-critical contexts such as flight control software and hospital equipment, so we need to be sure that such programs will not error during runtime.
Haskell is a good candidate for these kinds of programs: it has an expressive type system that lets you state some invariants, and the paradigm of functional reactive programming (FRP) allows you to elegantly state a reactive program declaratively. However, Haskell has not seen much use in this space: its type system misses some bugs specific to reactive programs, and its performance in this domain is lackluster compared to implementations written in C. The Copilot language makes some progress in this area by only using Haskell to verify C programs, rather than making it do the bulk of the work.
We therefore look at improving reactive programming within Haskell to make it a more compelling choice. We focus on one aspect of reactive programs which can cause bugs and performance issues when not dealt with properly: dependency analysis. We consider two problems in our work: dependency resolution and static scheduling:
- The correctness of reactive programs depends on correct dependency resolution: that is, identifying the order that we run program subparts so that their dependencies are satisfied. There can even be cases where there is no correct order due to cyclic dependencies, where a program subpart depends on its own output in order to run. This is where Haskell's existing type system fails, as the types used by reactive programming libraries do not contain any dependency information.
- The performance of reactive programs can be improved by static scheduling: that is, performing dependency resolution at compile time rather than runtime. Common reactive programming libraries use runtime dependency resolution via lazy evaluation due to again not having enough dependency information at compile time.
We therefore look at adding this dependency information to reactive programs through types and program transformations, to allow these issues to be solved.
My general research interests focus around effect systems (particularly graded monads), functional reactive programming, type-level programming and program transformations.
Publications Link opens in a new window
Keating, Finnbar and Gale, Michael B. (2023)
This Is Driving Me Loopy: Efficient Loops in Arrowized Functional Reactive Programs. (preprint pdf)
Published in Haskell Symposium '23. Will be available at DOI 10.1145/3609026.3609726.
Keating, Finnbar and Gale, Michael B. (2021)
Graded Monads and Type-Level Programming for Dependence Analysis. (pdf)
Published in Haskell Symposium '21. Available at DOI 10.1145/3471874.3472981.
Conferences and Workshops
|Date||Conference - Location||Contribution|
|September 2023||ICFP '23 - Seattle, USA||Will present at the Haskell Symposium.|
|March 2023||WPCCS'23 - Hybrid (Warwick)||Chaired the entire conference, did a talk (slides).|
|September 2022||ICFP '22 - Ljubljana, Slovenia||Attended|
|June 2022||Meeting on Graded Types - Hybrid (Kent)||Attended|
|Dec 2021||WPCCS 2021 - Hybrid (Warwick)||Talk (slides), which won an award for best presentation of the HPC morning session!|
|Aug 2021||ICFP '21 - Online (South Korea)||Talk at the Haskell Symposium (video, slides)|
|April 2021||Midlands Graduate School 2021 - Online (Sheffield)||Attended|
|March 2021||BCTCS 2021 - Online (Liverpool)||Talk (slides with speaker notes, abstract)|
|December 2020||WPCCS 2020 - Online (Warwick)||Attended|
|2018-2019 (as undergraduate)|
|December 2019||WPCCS 2019 - Warwick||Attended|
|September 2018||S-REPLS 10 - Birkbeck, University of London||Attended|
I have taught on the following modules. This has involved teaching in labs and marking coursework.
- Functional Programming (CS141): 2019-20 (as an undergraduate), 2020-22
- Compiler Design (CS325): 2020-23 (teaching labs), also gave a lecture (slides, video)
- Formal Systems Development (CS412): 2021-23 (only teaching labs)
I play trombone (grade 8) and bass trombone. Currently I play in Warwick Big Band, although played in Wind Orchestra before the pandemic. I also enjoy learning new instruments, although I'm not good enough at them yet to list them here!
I was also involved in the running of Warwick Tabletop Games and Roleplaying Society from 2018-22, taking a variety of positions in the Tabletop Exec (Comms Officer 2018-19, Secretary 2019-20, President 2020-21 and Web Admin 2021-22). During my time in exec, I was a big part of organising most of the society's special events - everything from megagames (one of which won an SU award) to three online charity streams (Tabletop Radio 2020 (online), 2021 (online), and 2022 (in-person) which together raised nearly £3700 for LGBT+ charities) and even an escape room. These involved leading teams of event runners, use of technical skills in complex streaming setups and building bespoke software for events, and using a kazoo to raise a surprising amount of money1.
While I am no longer directly responsible for running the society, I'm still a big part of it and am looking forward to all of the stuff run in the years to come! (Also you should come join us, we have games.)
1 Perhaps most surprisingly of all, none of this money was on the condition that I stopped playing kazoo.
Email: f.keating [at] warwick.ac.uk