Operational semantics for multi-language programs

Abstract

Interoperability is big business, a fact to which .NET, the JVM, and COM can attest. Language designers are well aware of this, and they are designing programming languages that reflect it-for instance, SML.NET, F#, Mondrian, and Scala all treat interoperability as a central design feature. Still, current multi-language research tends not to focus on the semantics of these features, but only on how to implement them efficiently. In this article, we attempt to rectify that by giving a technique for specifying the operational semantics of a multi-language system as a composition of the models of its constituent languages. Our technique abstracts away the low-level details of interoperability like garbage collection and representation coherence, and lets us focus on semantic properties like type-safety, equivalence, and termination behavior. In doing so it allows us to adapt standard theoretical techniques such as subject-reduction, logical relations, and operational equivalence for use on multi-language systems. Generally speaking, our proofs of properties in a multi-language context are mutually referential versions of their single language counterparts.We demonstrate our technique with a series of strategies for embedding a Scheme-like language into an ML-like language. We start by connecting very simple languages with a very simple strategy, and work our way up to languages that interact in sophisticated ways and have sophisticated features such as polymorphism and effects. Along the way, we prove relevant results such as typesoundness and termination for each system we present using adaptations of standard techniques.Beyond giving simple expressive models, our studies have uncovered several interesting facts about interoperability. For example, higher-order function contracts naturally emerge as the glue to ensure that interoperating languages respect each other's type systems. Our models also predict that the embedding strategy where foreign values are opaque is as expressive as the embedding strategy where foreign values are translated to corresponding values in the other language, and we were able to experimentally verify this behavior using PLT Scheme's foreign function interface.

Fully-abstract compilation by approximate back-translation

“…The techniques devised in these works were further developed into Relational Transition Systems (RTS) and Parametric Inter-Language Simulations (PILS) in order to prove both vertically-and horizontally-composable compiler correctness [Hur et al, 2012, Neis et al, 2015. A different approach to cross-language relations could have been adopting a Matthews and Findler-style multi-language semantics, where source and target language are combined [Matthews and Findler, 2009]. For example, Perconti and Ahmed [2014] devised a two-step correct compiler for System F with existential and recursive types to typed assembly language using multi-language logical relations.…”

Fab ous Interoperability for ML and a Linear Language

“…If the linear language could not interact with lumped values at all, our multilanguage programs would be rather boring, as the only way for the linear extension to provide a value back to ML would be to have received it from λ U and pass it back unchanged (as in the lump embedding of Matthews and Findler [2009]). To provide a real interaction, we provide a way to extract values out of a lump !…”

“…Our multi-language semantics builds on the seminal work by Matthews and Findler [2009], who gave a formal semantics of interoperability between a dynamically and a statically typed language. Others have followed the Matthews-Findler approach of designing multi-language systems with fine-grained boundaries-for instance, formalizing interoperability between a simply and dependently typed language [Osera, Sjöberg, and Zdancewic, 2012]; between a functional and typed assembly language [Patterson, Perconti, Dimoulas, and Ahmed, 2017]; between an ML-like and an affinely typed language, where linearity is enforced at runtime on the ML side using stateful contracts [Tov and Pucella, 2010]; and between the source and target languages of compilation to specify compiler correctness [Perconti and Ahmed, 2014].…”

Programmable semantic fragments: the design and implementation of typy

“…Unfortunately, this approach is unnatural (the syntactic and semantic conveniences of the sibling language are unavailable) and unsafe (the type system of the sibling language is not enforced, and the internal representations of the compiler are exposed.) This problem can, at best, be mitigated by inserting dynamic checks at language boundaries [46]. It appears then that the language-oriented approach [75] is difficult to reconcile with the best practices of "programming in the large" [22].…”