Publications

2023

1. OOPSLA

   Fluent APIs in Functional Languages

   Ori Roth, and Yossi Gil

   Proc. ACM Program. Lang. Apr 2023

   Abs DOI PDF

   Fluent API is an object-oriented pattern for elegant APIs and embedded DSLs. A smart fluent API can enforce the API protocol or DSL syntax at compile time. Since fluent API implementations typically rely on overloading function names, they are hard to realize in functional programming languages. This work shows how functional fluent APIs can be implemented in the absence of name overloading, by relying on parametric polymorphism and Hindley-Milner type inference. The implementation supports fluent API protocols in the regular- and deterministic context-free language classes, and even beyond.

2022

1. arXiv

   Python Type Hints are Turing Complete

   Ori Roth

   Apr 2022

   Abs DOI PDF

   Grigore showed that Java generics are Turing complete by describing a reduction from Turing machines to Java subtyping. We apply Grigore’s algorithm to Python type hints and deduce that they are Turing complete. In addition, we present an alternative reduction in which the Turing machines are simulated in real time, resulting in significantly lower compilation times. Our work is accompanied by a Python implementation of both reductions that compiles Turing machines into Python subtyping machines.

2021

1. OOPSLA

   Study of the Subtyping Machine of Nominal Subtyping with Variance

   Ori Roth

   Proc. ACM Program. Lang. Oct 2021

   Abs DOI PDF

   This is a study of the computing power of the subtyping machine behind Kennedy and Pierce’s nominal subtyping with variance. We depict the lattice of fragments of Kennedy and Pierce’s type system and characterize their computing power in terms of regular, context-free, deterministic, and non-deterministic tree languages. Based on the theory, we present Treetop—a generator of C# implementations of subtyping machines. The software artifact constitutes the first feasible (yet POC) fluent API generator to support context-free API protocols in a decidable type system fragment.

2019

1. ECOOP

   Fling - A Fluent API Generator

   Yossi Gil, and Ori Roth

   In 33rd European Conference on Object-Oriented Programming (ECOOP 2019) Oct 2019

   Abs DOI PDF

   We present the first general and practical solution of the fluent API problem - an algorithm, that given a deterministic language (equivalently, LR(k), k >= 0 language) encodes it in an unbounded parametric polymorphism type system employing only a polynomial number of types. The theoretical result is accompanied by an actual tool Fling - a fluent API compiler-compiler in the venue of YACC, tailored for embedding DSLs in Java.

2017

1. VISSOFT

   Syntactic Zoom-Out / Zoom-In Code with the Athenizer

   Yossi Gil, Dor Ma’ayan, Niv Shalmon, and 2 more authors

   In 2017 IEEE Working Conference on Software Visualization (VISSOFT) Oct 2017

   Abs DOI

   Care and great effort are often taken to dress program code of libraries, just as model implementations, in its most presentable form, which includes adherence to strict coding standards, careful selection of identifiers, avoiding unnecessary constructs, etc. However, a presentable dress is not a janitor’s uniform and is often inferior to the more lax working outfit.The spartanizer is a tool that brings Java code into a canonical, short form. Trying to say the most with the fewest words. In contrast, the athenizer is a tool that expands the code, placing it in a more maintainable form, using plenty of auxiliary variables, many potential locations for breakpoints and for change.The tool reported on here allows developers to interactively use their joystick and its buttons for code navigation, and in particular for zooming-in into the code (athenizing) and zooming-out of it (spartanizing).

2. ASTESJ

   Pluggable Controllers and Nano-Patterns in Java with Lola

   Yossi Gil, Ori Marcovitch, Matteo Orru, and 1 more author

   Advances in Science, Technology and Engineering Systems Journal Oct 2017

   Abs DOI PDF

   Pluggable controllers are a different way to design control constructors such as if, while, do, switch, and operators such as short circuit con-junction (&&) and the “?.” operator of the Swift programming language. Adoption of pluggable controllers enables the final user to modify and extend the control flow constructs (if, while, etc.) of an underlying programming language, the same way they can do if they implement functions such as printf and class String in a standard library. In modular, pluggable controller based language design, beside core control constructors, there are others, defined in standard libraries, with the purpose of augmenting and enriching the language. These pluggable controllers are extensible and replaceable. Being less intertwined in the main language, control constructor libraries can evolve independently from it, and their releases do not mandate new language releases. We illustrate the implementation of pluggable controllers using Lola, a powerful language-independent preprocessor and macro language. We demonstrate the introduction of new pluggable controllers with two case studies. The implementation of a Java stenography based on prevalent Java idioms, called “nano-patterns” or nanos, and the introduction in Java of new code constructs inspired by the Mathematica language’s commands.