Joel Jakubovic

Postdoc

Department of Distributed and Dependable Systems
Faculty of Mathematics and Physics
Charles University

Malostranské náměstí 25
118 00 Praha 1
Czech Republic

E-mail: jakubovic@d3s.mff.cuni.cz
Web: https://programmingmadecomplicated.wordpress.com
Office: 204, 2nd floor

Research

My research follows from a simple intuition: the human mind is good at certain things and bad at others. We invented computers to do the things our minds are bad at. To the extent that programming requires the human mind to simulate a computer, programming is a misallocation of cognitive tasks. Programming should be improved to the point where the programmer can work in a manner that makes the best use of his mind, while the computer handles all the things that the human mind finds tedious or error-prone.

This intuition leads me to my basic heuristic: premature commitment delenda est - “premature commitment must be destroyed”. Practically all existing programming systems commit their user to a very specific syntax, semantics, notations, and interfaces - not because the user requested this, but simply because that’s the path of least resistance on the implementation side. I am interested in highly flexible, dynamic, late-bound programming systems that provide maximum freedom from the get-go. The user is then in a position to revoke certain freedoms, or trade them off for performance / safety / simplicity / etc. deliberately, and in a scoped manner, instead of prematurely in an all-or-nothing manner.

My main interest downstream of this principle is Notational Freedom: where the system encourages the mixing of domain-specific notations for different parts of code or data, and supports the user supplying their own such mini-notations. Every user should be able to use their subjectively-determined “Right Tool For The Job” when working with digital information structures. Resolving the inevitable conflicts between different preferred notations and formats is a worthy open problem, rather than a reason to give up and force everybody to use text forever more.

At Charles University, I’m studying the history of graphical constraint programming as an ingredient of Notational Freedom. We can debate the appropriate domain of “visual programming”, but it is quite reasonable to expect to be able to simply draw diagrams, instead of being forced to describe them using words and pixel coordinates. Graphical constraint programming is simply an extension of this idea to drawings that change over time (animations) and respond to input (dynamic simulations). It is entirely reasonable that the computer should know what a rectangle is and how its different parts relate, so that it can adjust it correctly no matter which corner we move. Programmers should be able to specify this information at most once, instead of having to write special code over and over again for the different cases.

1979’s ThingLab and its 1989 successor ThingLab II were an extensive exploration of this idea. Why have you never heard of these systems? Why did the constraint engine not become as standard as the garbage collector or the text input/output library across many programming systems today? For which tasks are constraints the Right Tool For The Job? And which notations are good for manipulating constraints? These are some of the questions I’m investigating at CUNI.

PhD Dissertation

Achieving Self-Sustainability in Interactive Graphical Programming Systems, University of Kent, 2023.

Publications

 @inproceedings{jakubovic_ascending_2022,
    title = {{Ascending the ladder to self-sustainability}},
    author = {Jakubovic, Joel and Petricek, Tomas},
    year = {2022},
    booktitle = {{To appear in Onward! 2022: Proceedings of the 2022 ACM SIGPLAN international symposium on new ideas, new paradigms, and reflections on programming and software, Auckland, New Zealand, December, 2022}},
    editor = {Singer, Jeremy and Scholliers, Christophe},
    publisher = {ACM},
}
 

 @article{jakubovic_technical_2023,
    title = {{Technical Dimensions of Programming Systems}},
    author = {Jakubovic, Joel and Edwards, Jonathan and Petricek, Tomas},
    year = {2023},
    journal = {{The Art, Science, and Engineering of Programming}},
    number = {3},
    doi = {10.22152/programming-journal.org/2023/7/13},
    issn = {2473-7321},
    pages = {13:1--13:59},
    url = {https://programming-journal.org/2023/7/13/},
    volume = {7},
}
 

 @inproceedings{jakubovic_what_2020,
    title = {{What it takes to create with domain-appropriate tools: reflections on implementing the “id” system}},
    author = {Jakubovic, Joel},
    year = {2020},
    booktitle = {{Companion Proceedings of the 4th International Conference on Art, Science, and Engineering of Programming}},
    publisher = {Association for Computing Machinery},
    series = {{Programming '20}},
    location = {New York, NY, USA},
    doi = {10.1145/3397537.3397549},
    isbn = {978-1-4503-7507-8},
    pages = {197--207},
    url = {https://doi.org/10.1145/3397537.3397549},
    shorttitle = {What it takes to create with domain-appropriate tools},
}