Modern programming languages and runtimes are huge things. They are built by large teams of people over long periods of time. As a result, making even a small experimental change to them is a huger amount of work. How then can we explore new research designs for programming systems? And how can we teach students to think about programming systems?

In this talk, I will present my experience implementing and teaching “tiny programming systems”. I believe that even a very small programming system implementation that is restricted to work reasonably well for a small carefully selected case study can convey interesting design ideas about programming systems. I also believe that we can teach students to implement key ideas behind many influential programming systems by letting them implement them in a context of a tiny programming system.

The talk will be based on my recent experience designing and teaching the “Write your own tiny programming system(s)!” course at Charles University and also based on my recent experimental research projects that included writing a small emulator of Commodore BASIC and an experimental interactive programming system for data exploration based on recording past interactions with the user. I will cover methodological foundations for the research and my own experience using the F# programming language for many of the tiny programming systems projects (including the one tiny programming system for which it turned out not to be the perfect choice!)

Tomas is an Assistant Professor at Charles University in Prague. He is interested in understanding the nature of programming and finding new and better ways of doing it. He uses various methods ranging from theoretical programming langauge research, applied work resulting in open-source software, as well as interdisciplinary approaches that look at programming through the perspectives of history and philosophy. He believes that the most interesting developments in programming happen when a new way of thinking makes difficult problems disappear.

His current work is focused on programming systems. Programs are created not by just writing code, but by interacting with rich stateful programming systems or environments. Programming systems still include code, but they also encompass live or structure editors, runtime environment and other developer tools. He believes that we need to (i) find new fundamental ways of studying programming systems, (ii) revisit past programming systems that offered interesting ways of interaction, and (iii) apply those ideas to domains such as data science tooling or low-code and no-code programming.

In recent years, he also worked on functional programming and contributed to the development of the F# language and type providers at Microsoft Research. His PhD from University of Cambridge was on coeffects, a theory of context-aware programming languages. At University of Kent and The Alan Turing Institute, he spent most of his time working on programming tools for data science.