License: 
Creative Commons Attribution 3.0 Unported license (CC BY 3.0)
When quoting this document, please refer to the following
DOI: 10.4230/LIPIcs.SNAPL.2017.12
URN: urn:nbn:de:0030-drops-71250
URL: http://dagstuhl.sunsite.rwth-aachen.de/volltexte/2017/7125/
Patterson, Daniel ;
Ahmed, Amal
Linking Types for Multi-Language Software: Have Your Cake and Eat It Too
Abstract
Large software systems are and should be implemented with many different languages, each suited to the domain of the task at hand. High-level business logic may be written in Java or OCaml, resource-intensive components may be written in C or Rust, and high-assurance components may be written in Coq. In some development shops, domain-specific languages are used in various parts of systems to better separate the logic of particular problems from the plumbing of general-purpose programming. But how are programmers to reason about such multi-language systems?
Currently, for a programmer to reason about a single source component within this multi-language system, it is not sufficient for her to consider how her component behaves in source-level contexts. Instead, she is required to understand the target contexts that her component will be run in after compilation - which requires not only understanding aspects of the compiler, but also how target components are linked together. These target contexts may have behavior inexpressible in the source, which can impact the notion of equivalence that justifies behavior-preserving modifications of code, whether programmer refactorings or compiler optimizations. But while programmers should not have to reason about arbitrary target contexts, sometimes multi-language linking is done exactly to gain access to features unavailable in the source.
To enable programmers to reason about components that link with behavior inexpressible in their language, we advocate that language designers incorporate specifications for linking into the source language. Such specifications should allow
a programmer to reason about inputs from other languages in a way that remains close to the semantics of her language. Linking types are a well-specified minimal extension of a source language that allow programmers to annotate where in their programs they can link with components that are not expressible in their unadulterated source language. This gives them fine-grained control over the contexts that they must reason about and the equivalences that arise.
BibTeX - Entry
@InProceedings{patterson_et_al:LIPIcs:2017:7125,
author = {Daniel Patterson and Amal Ahmed},
title = {{Linking Types for Multi-Language Software: Have Your Cake and Eat It Too}},
booktitle = {2nd Summit on Advances in Programming Languages (SNAPL 2017)},
pages = {12:1--12:15},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-032-3},
ISSN = {1868-8969},
year = {2017},
volume = {71},
editor = {Benjamin S. Lerner and Rastislav Bod{\'i}k and Shriram Krishnamurthi},
publisher = {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},
address = {Dagstuhl, Germany},
URL = {http://drops.dagstuhl.de/opus/volltexte/2017/7125},
URN = {urn:nbn:de:0030-drops-71250},
doi = {10.4230/LIPIcs.SNAPL.2017.12},
annote = {Keywords: Linking, program reasoning, equivalence, expressive power of languages, fully abstract compilation}
}
|
Keywords: |
|
Linking, program reasoning, equivalence, expressive power of languages, fully abstract compilation |
|
Collection: |
|
2nd Summit on Advances in Programming Languages (SNAPL 2017) |
|
Issue Date: |
|
2017 |
|
Date of publication: |
|
05.05.2017 |
