Scheme '26: "An Incremental Approach to ..."
An Incremental Approach to JIT Construction
Shaurya Raswan, Mark Barbone, Nico Lehmann, and Joe Gibbs Politz
(University of California at San Diego, USA; Cornell University, USA; University of Chile, Chile)
Just-in-time (JIT) compilation has become a common tool for language runtimes. JIT compilers have a reputation for being complex, leaving a pedagogical gap between foundational Ahead-of-Time (AOT) concepts and dynamic code generation. This paper presents an incremental, classroom-scale approach to building a JIT compiler in manageable steps. By contrasting an AOT and a JIT backend, we expose core dynamic concerns, including executable buffers, persistent interactive state, mutation, and runtime type optimizations. The result is a minimal yet realistic educational JIT that successfully supports a Read-Eval-Print Loop (REPL) and a first-call specialization mechanism.
@InProceedings{Scheme26p14,
author = {Shaurya Raswan and Mark Barbone and Nico Lehmann and Joe Gibbs Politz},
title = {An Incremental Approach to JIT Construction},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {14-26},
doi = {10.1145/3830440.3832304},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-p3-p (type: Full Paper) doi:10.1145/3830440.3832304
Scheme '26: "Regions as Continuation Marks ..."
Regions as Continuation Marks
Paulette Koronkevich and William J. Bowman
(University of British Columbia, Canada)
Region-based memory management started as a compiler pass to optimize Standard ML programs. Garbage collection was expensive, manual memory management was unsafe, and so instead one infers a stack of memory regions to enable the compiler to insert explicit memory allocation and deallocation instructions. The result of region inference is a ML program with lexically-scoped regions. Unfortunately, the stack-based region inference interferes with the correct behaviour of tail recursion: that tail recursion must run in constant space, and much work was required to correct their behaviour in practice.
We show a formal connection between these lexical regions and continuation marks, which elucidates the behaviour of regions with respect to tail calls, and provide insights into possible implementation techniques and new semantics. Continuation marks enable placing a value on the dynamic program frame, and were designed and implemented to behave correctly with respect to tail recursion. We provide a translation from regions to continuation marks and theorize what this connection could entail for both languages with region-based memory management and our favourite Schemes (and Racket) with continuation marks.
@InProceedings{Scheme26p3,
author = {Paulette Koronkevich and William J. Bowman},
title = {Regions as Continuation Marks},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {3-13},
doi = {10.1145/3830440.3832303},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-p2-p (type: Full Paper) doi:10.1145/3830440.3832303
Scheme '26: "An Array-Oriented Language ..."
An Array-Oriented Language via the Design Recipe
Martin Scheele and Stephen Chang
(University of Massachusetts at Boston, USA)
We present a new “intertwined” data definition example, the multidimensional array, for How to Design Programs (HtDP). The example has important real-world relevance in many areas of modern computing and thus appeals to a diverse variety of students, yet is straightforward enough to use in lectures and assignments. Best of all, functions dealing with this kind of data can be incorporated into a full programming language, and thus our example complements prior ones and enhances existing ideas. This paper describes our ideas and also presents a first-hand student experience of how they are amenable to and motivated the lessons of HtDP.
@InProceedings{Scheme26p27,
author = {Martin Scheele and Stephen Chang},
title = {An Array-Oriented Language via the Design Recipe},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {27-39},
doi = {10.1145/3830440.3832305},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-p4-p (type: Full Paper) doi:10.1145/3830440.3832305
Scheme '26: "Using the Design Recipe in ..."
Using the Design Recipe in Theory of Computation
Martin Scheele and Stephen Chang
(University of Massachusetts at Boston, USA)
It is well known that computer science students often strug- gle to understand recursion and theory of computation (ToC) students are no exception. The difference is that ToC stu- dents encounter recursion not while programming, but while writing proofs. Fortunately, educators have already devel- oped many strategies for helping students write recursive programs, with many of the ideas coming from the func- tional programming community. This paper explains how we adapted one of these ideas, that of “Design Recipes” from the “How to Design Programs” textbook, into a technique to help theory of computation students write inductive proofs. With our approach, we have seen improved results over sev- eral semesters. Even better, students leave the course with a deeper understanding of the fundamental ideas and rely less on memorizing opaque rules and copying from tangentially related examples.
@InProceedings{Scheme26p40,
author = {Martin Scheele and Stephen Chang},
title = {Using the Design Recipe in Theory of Computation},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {40-47},
doi = {10.1145/3830440.3832306},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-p5-p (type: Full Paper) doi:10.1145/3830440.3832306
Scheme '26: "Rhombus: The Non-shrubbery ..."
Rhombus: The Non-shrubbery Parts (Keynote)
Matthew Flatt
(University of Utah, USA)
Rhombus is a new language that provides Racket-style extensibility with conventional (infix) notation. This talk is is not about that notation; it's about many other design choices in Rhombus that that are different than Scheme and Racket. We'll look at Rhombus's pervasive pattern matching, generalized repetitions, Lisp-N binding, lists as RRB trees, and mixture of static and dynamic hierarchical binding.
@InProceedings{Scheme26p1,
author = {Matthew Flatt},
title = {Rhombus: The Non-shrubbery Parts (Keynote)},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {1-1},
doi = {10.1145/3830440.3839164},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-key1-p (type: Keynote) doi:10.1145/3830440.3839164
Scheme '26: "Regions as Continuation Marks ..."
Regions as Continuation Marks
Paulette Koronkevich and William J. Bowman
(University of British Columbia, Canada)
Region-based memory management started as a compiler pass to optimize Standard ML programs. Garbage collection was expensive, manual memory management was unsafe, and so instead one infers a stack of memory regions to enable the compiler to insert explicit memory allocation and deallocation instructions. The result of region inference is a ML program with lexically-scoped regions. Unfortunately, the stack-based region inference interferes with the correct behaviour of tail recursion: that tail recursion must run in constant space, and much work was required to correct their behaviour in practice.
We show a formal connection between these lexical regions and continuation marks, which elucidates the behaviour of regions with respect to tail calls, and provide insights into possible implementation techniques and new semantics. Continuation marks enable placing a value on the dynamic program frame, and were designed and implemented to behave correctly with respect to tail recursion. We provide a translation from regions to continuation marks and theorize what this connection could entail for both languages with region-based memory management and our favourite Schemes (and Racket) with continuation marks.
@InProceedings{Scheme26p3,
author = {Paulette Koronkevich and William J. Bowman},
title = {Regions as Continuation Marks},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {3-13},
doi = {10.1145/3830440.3832303},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-p2-p (type: Full Paper) doi:10.1145/3830440.3832303
Scheme '26: "An Incremental Approach to ..."
An Incremental Approach to JIT Construction
Shaurya Raswan, Mark Barbone, Nico Lehmann, and Joe Gibbs Politz
(University of California at San Diego, USA; Cornell University, USA; University of Chile, Chile)
Just-in-time (JIT) compilation has become a common tool for language runtimes. JIT compilers have a reputation for being complex, leaving a pedagogical gap between foundational Ahead-of-Time (AOT) concepts and dynamic code generation. This paper presents an incremental, classroom-scale approach to building a JIT compiler in manageable steps. By contrasting an AOT and a JIT backend, we expose core dynamic concerns, including executable buffers, persistent interactive state, mutation, and runtime type optimizations. The result is a minimal yet realistic educational JIT that successfully supports a Read-Eval-Print Loop (REPL) and a first-call specialization mechanism.
@InProceedings{Scheme26p14,
author = {Shaurya Raswan and Mark Barbone and Nico Lehmann and Joe Gibbs Politz},
title = {An Incremental Approach to JIT Construction},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {14-26},
doi = {10.1145/3830440.3832304},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-p3-p (type: Full Paper) doi:10.1145/3830440.3832304
Scheme '26: "The R7RS-Large Roadmap (Invited ..."
The R7RS-Large Roadmap (Invited Talk)
Peter McGoron
(Georgia Institute of Technology, USA)
The R7RS-Large is an extension to the R7RS designed to address the practical needs of mainstream software development. It is organized into three volumes: Foundations for non-portable modifications to the R7RS such as the syntax-case system, Batteries for libraries that can be built on top of the Foundations such as hash tables, and Environments for implementation-specific libraries such as I/O facilities. The Working Group has made great progress in specifying the R7RS-Large over the past year. I will present the new features we have added, a roadmap for features we plan to add, and challenges along the way that we will have to solve.
@InProceedings{Scheme26p2,
author = {Peter McGoron},
title = {The R7RS-Large Roadmap (Invited Talk)},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {2-2},
doi = {10.1145/3830440.3839165},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-key2-p (type: Invited Talk Abstract) doi:10.1145/3830440.3839165
Scheme '26: "An Incremental Approach to ..."
An Incremental Approach to JIT Construction
Shaurya Raswan, Mark Barbone, Nico Lehmann, and Joe Gibbs Politz
(University of California at San Diego, USA; Cornell University, USA; University of Chile, Chile)
Just-in-time (JIT) compilation has become a common tool for language runtimes. JIT compilers have a reputation for being complex, leaving a pedagogical gap between foundational Ahead-of-Time (AOT) concepts and dynamic code generation. This paper presents an incremental, classroom-scale approach to building a JIT compiler in manageable steps. By contrasting an AOT and a JIT backend, we expose core dynamic concerns, including executable buffers, persistent interactive state, mutation, and runtime type optimizations. The result is a minimal yet realistic educational JIT that successfully supports a Read-Eval-Print Loop (REPL) and a first-call specialization mechanism.
@InProceedings{Scheme26p14,
author = {Shaurya Raswan and Mark Barbone and Nico Lehmann and Joe Gibbs Politz},
title = {An Incremental Approach to JIT Construction},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {14-26},
doi = {10.1145/3830440.3832304},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-p3-p (type: Full Paper) doi:10.1145/3830440.3832304
Scheme '26: "An Incremental Approach to ..."
An Incremental Approach to JIT Construction
Shaurya Raswan, Mark Barbone, Nico Lehmann, and Joe Gibbs Politz
(University of California at San Diego, USA; Cornell University, USA; University of Chile, Chile)
Just-in-time (JIT) compilation has become a common tool for language runtimes. JIT compilers have a reputation for being complex, leaving a pedagogical gap between foundational Ahead-of-Time (AOT) concepts and dynamic code generation. This paper presents an incremental, classroom-scale approach to building a JIT compiler in manageable steps. By contrasting an AOT and a JIT backend, we expose core dynamic concerns, including executable buffers, persistent interactive state, mutation, and runtime type optimizations. The result is a minimal yet realistic educational JIT that successfully supports a Read-Eval-Print Loop (REPL) and a first-call specialization mechanism.
@InProceedings{Scheme26p14,
author = {Shaurya Raswan and Mark Barbone and Nico Lehmann and Joe Gibbs Politz},
title = {An Incremental Approach to JIT Construction},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {14-26},
doi = {10.1145/3830440.3832304},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-p3-p (type: Full Paper) doi:10.1145/3830440.3832304
Scheme '26: "An Array-Oriented Language ..."
An Array-Oriented Language via the Design Recipe
Martin Scheele and Stephen Chang
(University of Massachusetts at Boston, USA)
We present a new “intertwined” data definition example, the multidimensional array, for How to Design Programs (HtDP). The example has important real-world relevance in many areas of modern computing and thus appeals to a diverse variety of students, yet is straightforward enough to use in lectures and assignments. Best of all, functions dealing with this kind of data can be incorporated into a full programming language, and thus our example complements prior ones and enhances existing ideas. This paper describes our ideas and also presents a first-hand student experience of how they are amenable to and motivated the lessons of HtDP.
@InProceedings{Scheme26p27,
author = {Martin Scheele and Stephen Chang},
title = {An Array-Oriented Language via the Design Recipe},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {27-39},
doi = {10.1145/3830440.3832305},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-p4-p (type: Full Paper) doi:10.1145/3830440.3832305
Scheme '26: "Using the Design Recipe in ..."
Using the Design Recipe in Theory of Computation
Martin Scheele and Stephen Chang
(University of Massachusetts at Boston, USA)
It is well known that computer science students often strug- gle to understand recursion and theory of computation (ToC) students are no exception. The difference is that ToC stu- dents encounter recursion not while programming, but while writing proofs. Fortunately, educators have already devel- oped many strategies for helping students write recursive programs, with many of the ideas coming from the func- tional programming community. This paper explains how we adapted one of these ideas, that of “Design Recipes” from the “How to Design Programs” textbook, into a technique to help theory of computation students write inductive proofs. With our approach, we have seen improved results over sev- eral semesters. Even better, students leave the course with a deeper understanding of the fundamental ideas and rely less on memorizing opaque rules and copying from tangentially related examples.
@InProceedings{Scheme26p40,
author = {Martin Scheele and Stephen Chang},
title = {Using the Design Recipe in Theory of Computation},
booktitle = {Proc.\ Scheme},
publisher = {ACM},
pages = {40-47},
doi = {10.1145/3830440.3832306},
year = {2026},
}
Publisher's Version
Article: icfpws26schememain-p5-p (type: Full Paper) doi:10.1145/3830440.3832306