GraalSqueak: toward a smalltalk-based tooling platform for polyglot programming

@article{Niephaus2019GraalSqueakTA,
  title={GraalSqueak: toward a smalltalk-based tooling platform for polyglot programming},
  author={Fabio Niephaus and Tim Felgentreff and Robert Hirschfeld},
  journal={Proceedings of the 16th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes},
  year={2019}
}
Polyglot programming provides software developers with a broader choice in terms of software libraries and frameworks available for building applications. Previous research and engineering activities have focused on language interoperability and the design and implementation of fast polyglot runtimes. To make polyglot programming more approachable for developers, novel software development tools are needed that help them build polyglot applications. We believe a suitable prototyping platform… Expand
Polyglot code finder
TLDR
The approach enables developers to find code for reuse written in different languages, which is especially useful when building polyglot applications, and users can filter code by providing example input and expected output. Expand
User-defined interface mappings for the GraalVM
TLDR
To reduce the mental complexity for developers and let them focus on the business logic, this work introduces user-defined interface mappings - an approach for adapting cross-language messages at run-time to match an expected interface. Expand
Example-based live programming for everyone: building language-agnostic tools for live programming with LSP and GraalVM
TLDR
This paper shows how an ELP system can be built in a language-agnostic way by leveraging the Language Server Protocol (LSP) and language implementation frameworks such as GraalVM's Truffle. Expand
Threaded Code Generation with a Meta-tracing JIT Compiler
TLDR
A meta-hybrid JIT compiler framework to take advantages of the two strategies as a language implementation framework and to use it for further speed-up by preventing the path-divergence problem, which causes serious slowdown. Expand
Example-Based Live Programming for Everyone
Our community has explored various approaches to improve the programming experience. Although many of them, such as Example-based Live Programming (elp), have shown to be effective, they are stillExpand
Toward presizing and pretransitioning strategies for GraalPython
TLDR
This paper explores and analyzes an approach for implementing presizing and pretransitioning in the context of GraalVM, using the Python implementation forGraalVM as an example and investigates rough performance numbers taken from the prototype on which different presizing strategies were tested. Expand
Framework-aware debugging with stack tailoring
TLDR
This paper introduces Sarto, a call-stack instrumentation layer that allows developers to tailor the stack to make debugging framework-aware, and proposes a set of six stack operations that combined hide irrelevant information, introduce missing information, and relate dispersed debugging sources to the debugger. Expand
Amalgamating different JIT compilations in a meta-tracing JIT compiler framework
TLDR
This paper presents a new approach, namely, the meta-hybrid JIT compilation strategy that combines trace-based and method-based compilations to utilize the advantages of both strategies and performs a synthetic experiment to confirm that there are programs that run faster by hybrid compilation. Expand

References

SHOWING 1-10 OF 25 REFERENCES
PolyJuS: a Squeak/Smalltalk-based polyglot notebook system for the GraalVM
TLDR
This work builds a Squeak/Smalltalk-based notebook UI that is compatible with the Jupyter notebook file format and evaluates PolyJuS, a more direct programming experience by executing notebooks on top of a polyglot execution environment. Expand
Fast, Flexible, Polyglot Instrumentation Support for Debuggers and other Tools
TLDR
Experience with Truffle Instrumentation validates the notion that addressing developer tools support as a forethought can change expectations about the availability of practical, efficient tools for high-performance languages. Expand
Language-independent development environment support for dynamic runtimes
TLDR
A language-agnostic approach to add this missing tooling by making the LSP available automatically to all language implementations on the Truffle framework is proposed and it is shown how this approach can utilize runtime information to provide IDE features rarely available for dynamic programming languages. Expand
Interleaving of Modification and Use in Data-driven Tool Development
TLDR
A data-driven perspective on graphical tools is proposed that uses concise scripts as glue between data and views but also as means to express missing data transformations and view items and can inspire the creation of new trade-offs in modularity for both data-providing projects and interactive views. Expand
Live Multi-language Development and Runtime Environments
TLDR
A novel approach for tool reuse that aims to improve the experience with regard to working with multiple high-level dynamic, object-oriented programming languages is presented and it provides convenient means to reuse and even mix software libraries and frameworks written in different languages without breaking tool support. Expand
Efficient implementation of Smalltalk activation records in language implementation frameworks
TLDR
This work presents an approach for efficiently implementing Smalltalk context objects in frameworks that do not support unrestricted modification of activation records. Expand
Sista: Saving Optimized Code in Snapshots for Fast Start-Up
TLDR
Sista (Speculative Inlining SmallTalk Architecture) is proposed to persist optimized code in a platform-independent representation as part of a snapshot to reach peak performance almost immediately after start-up when using a snapshot where optimized code was persisted. Expand
Two decades of smalltalk VM development: live VM development through simulation tools
TLDR
The VM simulation infrastructure is detailed and the experience developing and debugging the garbage collector and the just-in-time compiler (JIT) within it is reported. Expand
An object storage model for the truffle language implementation framework
TLDR
The initial evaluation indicates that the Truffle OSM can be used to implement high-performance language runtimes, with no performance overhead when compared to language-specific solutions. Expand
SqueakJS: a modern and practical smalltalk that runs in any browser
TLDR
The experience in implementing SqueakJS, a bit-compatible implementation of SqueAK/Smalltalk written in pure JavaScript, is reported, notable for simplicity and performance gained through adaptation to the host object memory and deployment leverage gained through the Lively Web development environment. Expand
...
1
2
3
...