The RPython framework’s meta-tracing JIT compiler uses a single generic tracer for all interpreters written in the RPython language, but this genericity causes overhead: the tracer dispatches every operation through an opcode lookup and performs redundant bookkeeping even for pure operations. We propose GenExtension, which specializes the tracer to a given interpreter at translation time, eliminating dynamic dispatch and skipping recording and heap-cache invalidation for pure operations. We implemented a prototype in RPython and applied it to the PyPy interpreter. On 28 benchmarks from the PyPy benchmark suite, GenExtension reduces tracing time by 11% (geometric mean) and resume data generation (the metadata needed to deoptimize back to the interpreter) by 28%, while producing nearly equivalent machine code and leaving the steady-state performance unchanged (0.99 ×). Turning the tracing speedup into a visible warmup improvement is future work.

In cell-based computational notebooks, programmers repeatedly edit and execute cells. Recompiling and re-executing an entire cell on every execution is inefficient; ideally, stable code and data should be reused. We present annotation-guided edit-aware JIT compilation for Julia, a technique that leverages two user-provided annotations about code and data stabilities — @hole and @persistent — to avoid unnecessary recompilation and recomputation. It partitions a cell into a stable skeleton and an unstable hole, compiles them separately while folding stable data as inlined constants, and reuses the skeleton across executions. We prototyped this approach as nbjit.jl, an IJulia kernel extension. Across five editing scenarios, cumulative execution time ranges from 3.3 × (lightweight workloads) to 1/167 (compute-intensive workloads) relative to Julia’s standard eval. The prototype currently supports a subset of Julia: basic numeric types, control flow, and composite data structures. Automatic annotation inference and full Julia language coverage remain as future work.

The advent of shape-adaptive computers, which consist of microscale devices that can wirelessly interconnect and dynamically reconfigure their shapes and functions, presents new challenges for software development. Existing programming environments and languages are not well-suited for managing the complex state interactions and asynchronous processes inherent in such systems. In response to these challenges, we propose the design and current status of MorphLang, a declarative programming language specifically designed for shape-adaptive computers. MorphLang abstracts the complexities of device interaction, enabling developers to focus on high-level behavior definitions without the need for intricate state management. Through a practical example, we demonstrate MorphLang's ability to handle dynamic node interactions effectively, paving the way for more efficient and innovative applications in shape-adaptive computing. Our approach not only simplifies the de-velopment process but also lays the groundwork for future advancements in this emerging field.

Most virtual machines employ just-in-time (JIT) compilers to achieve high-performance. Trace-based compilation and method-based compilation are two major compilation strategies in JIT compilers. In general, the former excels in compiling programs with more in-depth method calls and more dynamic branches, while the latter is suitable for a wide range of programs. Some previous studies have suggested that each strategy has its advantages and disadvantages, and there is no clear winner.