Tomas Petricek List of publications

Journal and conference publications

The following papers have been published in recognized top-tier programming language conferences and in journals and present my most important results. Further workshop publications and abstracts, many of which are highly-cited, are listed below.

Technical Dimensions of Programming Systems

Joel Jakubovic, Jonathan Edwards, Tomas Petricek. The Art, Science, and Engineering of Programming, 2023

We know how to study programming languages, but how to study stateful, interactive and graphical programming systems? This paper presents a qualitative framework for thinking and talking about programming systems.

Ascending the Ladder to Self-Sustainability: Achieving Open Evolution in an Interactive Graphical System

Joel Jakubovic, Tomas Petricek. In Proceedings of Onward! Essays 2022

Self-sustaining systems expose their implementation and can be modified and improved from within. However, the few examples that exist are tightly linked to textual language-based accounts of compiler bootstrapping. We explore how the bootstrapping process can work in more structured, visual programming environments.

AI Assistants: A Framework for Semi-Automated Data Wrangling

Tomas Petricek, Gerrit J J van den Burg, Alfredo Nazábal, Taha Ceritli, Ernesto Jiménez-Ruiz, Christopher K I Williams. IEEE Transactions on Knowledge and Data Engineering, 2022

Despite the rise of artificial intelligence, data wrangling remains a tedious and manual task. We introduce AI assistants, semi-automatic interactive tools to streamline data wrangling. An AI assistant guides the analyst through a specific data wrangling task and recommends suitable data transformation, respecting constraints obtained through interaction with the expert.

The Gamma: Programmatic Data Exploration for Non-programmers

Tomas Petricek. In Proceedings of VL/HCC 2022.

Data exploration tools based on code can access any data source, result in reproducible scripts and encourage users to verify, reuse and modify existing code, but can we make them accessible to non-experts? The Gamma is a novel text-based data exploration tool that answers the question in the affirmative.

Linked Visualisations via Galois Dependencies

Roly Perera, Minh Nguyen, Tomas Petricek and Meng Wang. In Proceedings of POPL 2022

We present new language-based dynamic analysis techniques for linking visualisations to data in a fine-grained way, allowing a user to interactively explore how data attributes map to visual or other output elements by selecting substructures of interest.

Covid-19, Charitable Giving and Collectivism: a data-harvesting approach

Peter Taylor-Gooby, Tomas Petricek and Jack Cunliffe. Journal of Social Policy, 2021

This paper charts responses to urgent appeals by welfare charities through crowd funding websites in order to examine the impact of the Covid-19 pandemic on public generosity and social cohesion in the UK.

Programming as Architecture, Design, and Urban Planning

Tomas Petricek. In Proceedings of Onward! Essays 2021

In this essay, I draw a parallel between the world of software and the world of architecture, design and urban planning. I hope to convince the reader that this is a well-justified parallel and I point to a number of discussions in architecture, design and urban planning from which the software world could learn.

Composable data visualizations

Tomas Petricek. Journal of Functional Programming, 2021

Compost is a data visualization library that lets you compose rich interactive data visualizations from a small number of basic primitives. The library is based on the functional programming idea of composable domain-specific languages. This functional programming pearl is a tutorial that introduces Compost through a wide range of examples.

What we talk about when we talk about monads

Tomas Petricek. The Art, Science, and Engineering of Programming, 2018

Computer science provides an in-depth understanding of technical aspects of programming concepts, but if we want to understand how programming concepts evolve, how programmers think about them and how they are used in practice, we need to consider a broader perspective. This paper explains how computer scientists and programmers talk about monads and why they do so.

Data exploration through dot-driven development

Tomas Petricek. In proceedings of ECOOP 2017.

Data literacy is becoming increasingly important. While spreadsheets make simple data analytics accessible to a large number of people, creating transparent scripts requires expert programming skills. In this paper, we describe the design of a data exploration language that makes the task more accessible by embedding advanced programming concepts into a simple core language.

Types from data: Making structured data first-class citizens in F#

Tomas Petricek, Gustavo Guerra and Don Syme. In Proceedings of PLDI 2016

The paper presents F# Data, a library of type providers that integrate external data in XML, CSV and JSON formats into the type system of the F# language. F# Data infers the shape of structured documents and uses it to guarantee a relative safety property.

Effect systems revisited - control-flow algebra and semantics

Alan Mycroft, Dominic Orchard, Tomas Petricek.
Semantics, Logics, and Calculi, 2016

This paper joins two recent developments related to effect systems - the development of richer effect systems based on complex algebraic structures and the development of semantic models based on monads. We show how graded joinads link the two developments.

Against a Universal Definition of 'Type'

Tomas Petricek. In Proceedings of Onward! Essays 2015

What is the definition of type? Having a clear and precise answer to this question would avoid many misunderstandings but it would hurt science, "hamper the growth of knowledge" and "deflect the course of investigation into narrow channels of things already understood".

Coeffects: A calculus of context-dependent computation

Tomas Petricek, Dominic Orchard and Alan Mycroft. In Proceedings of ICFP 2014

We present a general calculus for tracking contextual properties of computations, including per-variable properties (usage patterns, caching requirements) and whole-context properties (platform version, rebindable resources). This resolves questions that were left unanswered in the ICALP 2013 paper below.

Coeffects: Unified static analysis of context-dependence

Tomas Petricek, Dominic Orchard and Alan Mycroft. In Proceedings of ICALP 2013.

Effects capture how computations affect the environment, coeffects capture the requirements that computations place on the environment. We present a unified coeffect system that can be used for checking liveness and properties of data-flow or distributed programs,

Recent workshop papers

The following papers cover a wide range of topics from data journalism, theory and practice of programming to philosophy and history of compter science. They appeared in workshop and conference proceedings, but many have been highly influential.

Live & Local Schema Change: Challenge Problems

Jonathan Edwards, Tomas Petricek, Tijs van der Storm. Presented at LIVE 2023

Schema change is an unsolved problem in both live programming and local-first software. It can create a mismatch between the code and data in the running environment and mismatches between data in different replicas. We contribute a set of challenges involving schema change, offered to the live and local-first communities.

Interaction vs. Abstraction: Managed Copy and Paste

Jonathan Edwards, Tomas Petricek. Proceedings of PAINT 2022

Inspired by version control systems like git, we propose managed copy & paste, in which the programming environment records copy & paste operations, along with structural edit operations, so that it can track the differences between copies and reconcile them on command.

Complementary science of interactive programming systems

Tomas Petricek, Joel Jakubovic. Presented at HaPoC 2021

Is it worth looking at the history of programming in order to discover lost ideas that could be utilized by present-day computer scientists? This paper argues that this is the case and presents an early experiment that recovers a number of interesting programming ideas from, against all odds, Commodore 64 BASIC.

Typed Image-based Programming with Structure Editing

Jonathan Edwards and Tomas Petricek. Human Aspects of Types and Reasoning Assistants, 2021

Many beloved programming system like Smalltalk and LISP are image-based. This encourages exploration and allows flexibility, but it makes collaboration hard. We tackle the problem of schema change in image-based programming systems using static types.

Report on HOPL IV - ACM SIGPLAN History of Programming Languages Conference

Mark Priestley, and Tomas Petricek and David Hemmendinger, IEEE Ann. Hist. Comput. vol 43, no 3

Report on HOPL IV, the latest in the ACM's occasional series of conferences on the history of programming languages that took place on June 20–22, 2021, in association with PLDI 2021.

Foundations of a live data exploration environment

Tomas Petricek. The Art, Science, and Engineering of Programming, 2020

The way data analysts write code is different from the way software engineers do so. They use few abstractions, work interactively and rely heavily on external libraries. We capture this way of working and build a programming environment that makes data exploration easier by providing instant live feedback.

Evaluating programming systems design

Jonathan Edwards, Stephen Kell, Tomas Petricek, Luke Church. Proceedings of PPIG 2019

Research on programming systems design needs to consider a wide range of aspects in their full complexity. In this paper, we ask whether new media such as multimedia essays can serve as publication formats, more suitable for evaluating programming systems design.

Stories of storytelling about UK’s EU funding

Mariana Marasoiu et al. Proceedings of European Data and Computational Journalism Conference, 2018

We explore the difficulties of open data analysis using the data available on EU funding to the UK. We report on some of the fundamental difficulties we observed whilst analysing this data and we suggest ways of addressing such difficulties.

You guessed it! Reflecting on preconceptions and exploring data without statistics

Pablo León-Villagrá et al. Proceedings of European Data and Computational Journalism Conference, 2018

We live in times in which information is abundant, but trust in expert analysis is low. How can we make complex issues accessible for readers and overcome their preconceptions? We propose a novel way of presenting readers with data and raising awareness for individual bias and preconceptions.

Wrattler: Reproducible, live and polyglot notebooks

Tomas Petricek, James Geddes, Charles Sutton. In Proceedings of TaPP 2018

Notebook systems such as Jupyter are a popular environment for data science, but they use an architecture that leads to a limited model of interaction and makes versioning and reproducibility difficult. Wrattler revisits the architecture and allows richer forms of interactivity, efficient evaluation and guaranteed reproducibility.