Scheme '26: "An Incremental Approach to ..."
An Incremental Approach to JIT Compilation
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.
Article Search
Article: icfpws26schememain-p3-p 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.
Article Search
Article: icfpws26schememain-p2-p 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.
Article Search
Article: icfpws26schememain-p4-p 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.
Article Search
Article: icfpws26schememain-p5-p doi:10.1145/3830440.3832306
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.
Article Search
Article: icfpws26schememain-p2-p doi:10.1145/3830440.3832303
Scheme '26: "An Incremental Approach to ..."
An Incremental Approach to JIT Compilation
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.
Article Search
Article: icfpws26schememain-p3-p doi:10.1145/3830440.3832304
Scheme '26: "An Incremental Approach to ..."
An Incremental Approach to JIT Compilation
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.
Article Search
Article: icfpws26schememain-p3-p doi:10.1145/3830440.3832304
Scheme '26: "An Incremental Approach to ..."
An Incremental Approach to JIT Compilation
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.
Article Search
Article: icfpws26schememain-p3-p 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.
Article Search
Article: icfpws26schememain-p4-p 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.
Article Search
Article: icfpws26schememain-p5-p doi:10.1145/3830440.3832306