System programming in Rust: Beyond safety

Abhiram Balasubramanian, Marek S. Baranowski, Anton Burtsev, Aurojit Panda, Zvonimir Rakamarić, Leonid Ryzhyk

Research output: Contribution to journalConference article

Abstract

Rust is a new system programming language that offers a practical and safe alternative to C. Rust is unique in that it enforces safety without runtime overhead, most importantly, without the overhead of garbage collection. While zero-cost safety is remarkable on its own, we argue that the superpowers of Rust go beyond safety. In particular, Rust's linear type system enables capabilities that cannot be implemented efficiently in traditional languages, both safe and unsafe, and that dramatically improve security and reliability of system software. We show three examples of such capabilities: zero-copy software fault isolation, efficient static information flow analysis, and automatic checkpointing. While these capabilities have been in the spotlight of systems research for a long time, their practical use is hindered by high cost and complexity. We argue that with the adoption of Rust these mechanisms will become commoditized.

Original languageEnglish (US)
Pages (from-to)94-99
Number of pages6
JournalOperating Systems Review (ACM)
Volume51
Issue number1
DOIs
StatePublished - Sep 11 2017
Event6th Brazilian Symposium on Computing System Engineering, SBESC 2016 - Joao Pessoa PB, Brazil
Duration: Nov 1 2016Nov 4 2016

Fingerprint

Computer systems programming
Computer programming languages
Costs

ASJC Scopus subject areas

  • Information Systems
  • Hardware and Architecture
  • Computer Networks and Communications

Cite this

Balasubramanian, A., Baranowski, M. S., Burtsev, A., Panda, A., Rakamarić, Z., & Ryzhyk, L. (2017). System programming in Rust: Beyond safety. Operating Systems Review (ACM), 51(1), 94-99. https://doi.org/10.1145/3139645.3139660

System programming in Rust : Beyond safety. / Balasubramanian, Abhiram; Baranowski, Marek S.; Burtsev, Anton; Panda, Aurojit; Rakamarić, Zvonimir; Ryzhyk, Leonid.

In: Operating Systems Review (ACM), Vol. 51, No. 1, 11.09.2017, p. 94-99.

Research output: Contribution to journalConference article

Balasubramanian, A, Baranowski, MS, Burtsev, A, Panda, A, Rakamarić, Z & Ryzhyk, L 2017, 'System programming in Rust: Beyond safety', Operating Systems Review (ACM), vol. 51, no. 1, pp. 94-99. https://doi.org/10.1145/3139645.3139660
Balasubramanian A, Baranowski MS, Burtsev A, Panda A, Rakamarić Z, Ryzhyk L. System programming in Rust: Beyond safety. Operating Systems Review (ACM). 2017 Sep 11;51(1):94-99. https://doi.org/10.1145/3139645.3139660
Balasubramanian, Abhiram ; Baranowski, Marek S. ; Burtsev, Anton ; Panda, Aurojit ; Rakamarić, Zvonimir ; Ryzhyk, Leonid. / System programming in Rust : Beyond safety. In: Operating Systems Review (ACM). 2017 ; Vol. 51, No. 1. pp. 94-99.
@article{821d3268b72d4da093e97447bfb83cd9,
title = "System programming in Rust: Beyond safety",
abstract = "Rust is a new system programming language that offers a practical and safe alternative to C. Rust is unique in that it enforces safety without runtime overhead, most importantly, without the overhead of garbage collection. While zero-cost safety is remarkable on its own, we argue that the superpowers of Rust go beyond safety. In particular, Rust's linear type system enables capabilities that cannot be implemented efficiently in traditional languages, both safe and unsafe, and that dramatically improve security and reliability of system software. We show three examples of such capabilities: zero-copy software fault isolation, efficient static information flow analysis, and automatic checkpointing. While these capabilities have been in the spotlight of systems research for a long time, their practical use is hindered by high cost and complexity. We argue that with the adoption of Rust these mechanisms will become commoditized.",
author = "Abhiram Balasubramanian and Baranowski, {Marek S.} and Anton Burtsev and Aurojit Panda and Zvonimir Rakamarić and Leonid Ryzhyk",
year = "2017",
month = "9",
day = "11",
doi = "10.1145/3139645.3139660",
language = "English (US)",
volume = "51",
pages = "94--99",
journal = "Operating Systems Review (ACM)",
issn = "0163-5980",
publisher = "Association for Computing Machinery (ACM)",
number = "1",

}

TY - JOUR

T1 - System programming in Rust

T2 - Beyond safety

AU - Balasubramanian, Abhiram

AU - Baranowski, Marek S.

AU - Burtsev, Anton

AU - Panda, Aurojit

AU - Rakamarić, Zvonimir

AU - Ryzhyk, Leonid

PY - 2017/9/11

Y1 - 2017/9/11

N2 - Rust is a new system programming language that offers a practical and safe alternative to C. Rust is unique in that it enforces safety without runtime overhead, most importantly, without the overhead of garbage collection. While zero-cost safety is remarkable on its own, we argue that the superpowers of Rust go beyond safety. In particular, Rust's linear type system enables capabilities that cannot be implemented efficiently in traditional languages, both safe and unsafe, and that dramatically improve security and reliability of system software. We show three examples of such capabilities: zero-copy software fault isolation, efficient static information flow analysis, and automatic checkpointing. While these capabilities have been in the spotlight of systems research for a long time, their practical use is hindered by high cost and complexity. We argue that with the adoption of Rust these mechanisms will become commoditized.

AB - Rust is a new system programming language that offers a practical and safe alternative to C. Rust is unique in that it enforces safety without runtime overhead, most importantly, without the overhead of garbage collection. While zero-cost safety is remarkable on its own, we argue that the superpowers of Rust go beyond safety. In particular, Rust's linear type system enables capabilities that cannot be implemented efficiently in traditional languages, both safe and unsafe, and that dramatically improve security and reliability of system software. We show three examples of such capabilities: zero-copy software fault isolation, efficient static information flow analysis, and automatic checkpointing. While these capabilities have been in the spotlight of systems research for a long time, their practical use is hindered by high cost and complexity. We argue that with the adoption of Rust these mechanisms will become commoditized.

UR - http://www.scopus.com/inward/record.url?scp=85058988614&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=85058988614&partnerID=8YFLogxK

U2 - 10.1145/3139645.3139660

DO - 10.1145/3139645.3139660

M3 - Conference article

AN - SCOPUS:85058988614

VL - 51

SP - 94

EP - 99

JO - Operating Systems Review (ACM)

JF - Operating Systems Review (ACM)

SN - 0163-5980

IS - 1

ER -