@Preamble{
"\input bibnames.sty " #
"\input path.sty " #
"\def \TM {${}^{\sc TM}$} " #
"\ifx \undefined \booktitle \def \booktitle #1{{{\em #1}}} \fi" #
"\ifx \undefined \pkg \def \pkg #1{{{\tt #1}}} \fi" #
"\hyphenation{ }"
}
@String{ack-nhfb = "Nelson H. F. Beebe,
University of Utah,
Department of Mathematics, 110 LCB,
155 S 1400 E RM 233,
Salt Lake City, UT 84112-0090, USA,
Tel: +1 801 581 5254,
FAX: +1 801 581 4148,
e-mail: \path|beebe@math.utah.edu|,
\path|beebe@acm.org|,
\path|beebe@computer.org| (Internet),
URL: \path|https://www.math.utah.edu/~beebe/|"}
@String{inst-UTAH-MATH = "University of Utah, Department of Mathematics"}
@String{inst-UTAH-MATH:adr = "Salt Lake City, UT 84112-0090, USA"}
@String{j-CACM = "Communications of the ACM"}
@String{j-COMPUT-SCI-ENG = "Computing in Science and Engineering"}
@String{j-IEEE-SEC-PRIV = "IEEE Security \& Privacy"}
@String{j-IEEE-TRANS-NETWORKING = "IEEE\slash ACM Transactions on Networking"}
@String{j-IEEE-TRANS-SOFTW-ENG = "IEEE Transactions on Software Engineering"}
@String{j-J-SYST-SOFTW = "The Journal of Systems and Software"}
@String{j-OPER-SYS-REV = "Operating Systems Review"}
@String{j-PACMPL = "Proceedings of the ACM on Programming
Languages (PACMPL)"}
@String{j-SCI-COMPUT-PROGRAM = "Science of Computer Programming"}
@String{j-SIGADA-LETTERS = "ACM SIGADA Ada Letters"}
@String{j-SOFTWAREX = "SoftwareX"}
@String{j-TOPLAS = "ACM Transactions on Programming
Languages and Systems"}
@String{j-TOSEM = "ACM Transactions on Software Engineering and
Methodology"}
@String{pub-APRESS = "Apress"}
@String{pub-APRESS:adr = "Berkeley, CA, USA"}
@String{pub-IEEE = "IEEE Computer Society Press"}
@String{pub-IEEE:adr = "1109 Spring Street, Suite 300,
Silver Spring, MD 20910, USA"}
@String{pub-MANNING = "Manning Publications"}
@String{pub-MANNING:adr = "Greenwich, CT, USA"}
@String{pub-NO-STARCH = "No Starch Press"}
@String{pub-NO-STARCH:adr = "San Francisco, CA, USA"}
@String{pub-ORA = "O'Reilly \& {Associates, Inc.}"}
@String{pub-ORA:adr = "981 Chestnut Street, Newton, MA 02164, USA"}
@String{pub-ORA-MEDIA = "O'Reilly Media, Inc."}
@String{pub-ORA-MEDIA:adr = "1005 Gravenstein Highway North,
Sebastopol, CA 95472, USA"}
@String{pub-PACKT = "Packt Publishing"}
@String{pub-PACKT:adr = "Birmingham, UK"}
@String{pub-SV = "Spring{\-}er-Ver{\-}lag"}
@String{pub-SV:adr = "Berlin, Germany~/ Heidelberg,
Germany~/ London, UK~/ etc."}
@Misc{Evans:2013:URU,
author = "David Evans",
title = "Using {Rust} for an Undergraduate {OS} Course",
howpublished = "Web site.",
year = "2013",
bibdate = "Mon Jun 05 13:41:24 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://rust-class.org/0/pages/using-rust-for-an-undergraduate-os-course.html",
acknowledgement = ack-nhfb,
}
@InProceedings{Holk:2013:GPR,
author = "E. Holk and M. Pathirage and A. Chauhan and A.
Lumsdaine and N. D. Matsakis",
booktitle = "{2013 IEEE International Symposium on Parallel
Distributed Processing, Workshops and Phd Forum}",
title = "{GPU} Programming in {Rust}: Implementing High-Level
Abstractions in a Systems-Level Language",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "315--324",
year = "2013",
DOI = "https://doi.org/10.1109/IPDPSW.2013.173",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Article{Matsakis:2014:RL,
author = "Nicholas D. Matsakis and Felix S. {Klock II}",
title = "The {Rust} language",
journal = j-SIGADA-LETTERS,
volume = "34",
number = "3",
pages = "103--104",
month = dec,
year = "2014",
CODEN = "AALEE5",
DOI = "https://doi.org/10.1145/2692956.2663188",
ISSN = "1094-3641 (print), 1557-9476 (electronic)",
ISSN-L = "1094-3641",
bibdate = "Fri Feb 13 07:33:53 MST 2015",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib;
https://www.math.utah.edu/pub/tex/bib/sigada.bib",
abstract = "Rust is a new programming language for developing
reliable and efficient systems. It is designed to
support concurrency and parallelism in building
applications and libraries that take full advantage of
modern hardware. Rust's static type system is safe$^1$
and expressive and provides strong guarantees about
isolation, concurrency, and memory safety. Rust also
offers a clear performance model, making it easier to
predict and reason about program efficiency. One
important way it accomplishes this is by allowing
fine-grained control over memory representations, with
direct support for stack allocation and contiguous
record storage. The language balances such controls
with the absolute requirement for safety: Rust's type
system and runtime guarantee the absence of data races,
buffer overflows, stack overflows, and accesses to
uninitialized or deallocated memory.",
acknowledgement = ack-nhfb,
fjournal = "ACM SIGAda Ada Letters",
journal-URL = "http://portal.acm.org/citation.cfm?id=J32",
keywords = "Rust programming language",
remark = "HILT '14 conference proceedings.",
}
@Book{Balbaert:2015:RE,
author = "Ivo Balbaert",
title = "{Rust} Essentials",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "x + 161",
year = "2015",
ISBN = "1-78528-213-1",
ISBN-13 = "978-1-78528-213-3, 978-1-78528-576-9",
LCCN = "QA76.73.R87 B35 2015",
bibdate = "Tue Dec 10 05:44:53 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://proquest.safaribooksonline.com/9781785285769",
abstract = "Discover how to use Rust to write fast, secure, and
concurrent systems and applications In Detail Starting
by comparing Rust with other programming languages,
this book will show you where and how to use Rust. It
will discuss primitive types along with variables and
their scope, binding and casting, simple functions, and
ways to control execution flow in a program. Next, the
book covers flexible arrays, vectors, tuples, enums,
and structs. You will then generalize the code with
higher-order functions and generics applying it to
closures, iterators, consumers, and so on. Memory
safety is ensured by the compiler by using references,
pointers, boxes, reference counting, and atomic
reference counting. You will learn how to build macros
and crates and discover concurrency for multicore
execution. By the end of this book, you will have
successfully migrated to using Rust and will be able to
use it as your main programming language. What You Will
Learn Set up your Rust environment for maximum
productivity Bridge the performance gap between safe
and unsafe languages with Rust Use pattern matching to
create flexible code Apply generics and traits to
develop widely applicable code Organize your code in
modules and crates Build macros to extend Rust's
capabilities and reach Apply threads to tackle problems
concurrently and in distributed environments Interface
with C and isolate unsafe code Downloading the example
code for this book. You can download the example code
files for all Packt books you have purchased from your
account at http://www.PacktPub.com. If you purchased
this book elsewhere, you can visit
http://www.PacktPub.com/support and register to have
the files e-mailed directly to you.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
subject = "C (Computer program language); Software engineering; C
(Computer program language); Software engineering",
tableofcontents = "Preface \\
1: Starting with Rust \\
The advantages of Rust \\
The trifecta of Rust \\
safety, speed, and concurrency \\
Comparison with other languages \\
Using Rust \\
Servo \\
Installing Rust \\
The Rust compiler \\
rustc \\
Our first program \\
Working with Cargo \\
Developer tools \\
Using Sublime Text \\
Other tools \\
Summary \\
2: Using Variables and Types \\
Comments \\
Global constants \\
Printing with string interpolation \\
Values and primitive types \\
Consulting Rust documentation \\
Binding variables to values \\
Mutable and immutable variables \\
Scope of a variable and shadowing \\
Type checking and conversions \\
Aliasing \\
Expressions \\
The stack and the heap \\
Summary \\
3: Using Functions and Control Structures \\
Branching on a condition \\
Looping \\
Functions \\
Documenting a function \\
Attributes \\
Conditional compilation \\
Testing \\
Testing with cargo \\
Summary \\
4: Structuring Data and Matching Patterns \\
Strings \\
Arrays, vectors, and slices \\
Vectors \\
Slices \\
Strings and arrays \\
Tuples \\
Structs \\
Enums \\
Result and Option \\
Getting input from the console \\
Matching patterns 7: Organizing Code and Macros \\
Modules and crates \\
Building crates \\
Defining a module \\
Visibility of items \\
Importing modules and file hierarchy \\
Importing external crates \\
Exporting a public interface \\
Adding external crates to a project \\
The test module \\
Macros \\
Why do we use macros? \\
Developing macros \\
Repetition \\
Creating a new function \\
Using macros from crates \\
Summary \\
8: Concurrency and Parallelism \\
Concurrency and threads \\
Creating threads \\
Starting a number of threads \\
Panicking threads \\
Thread-safety \\
Shared mutable state \\
The Sync trait \\
Communication through channels \\
Sending and receiving data \\
Synchronous and asynchronous communication \\
Summary \\
9: Programming at the Boundaries \\
Program arguments \\
Unsafe \\
Raw pointers \\
Interfacing with C \\
Using a C library \\
Inlining assembly code \\
Calling Rust from other languages \\
Summary \\
Appendix: Exploring Further \\
Stability of Rust and the standard library \\
The ecosystem of crates \\
Other resources for learning Rust \\
Files and databases \\
Graphics and games \\
Web development \\
Index",
}
@Book{Blandy:2015:RPL,
author = "Jim Blandy",
title = "The {Rust} Programming Language: Fast, Safe, and
Beautiful",
publisher = pub-ORA-MEDIA,
address = pub-ORA-MEDIA:adr,
pages = "????",
year = "2015",
ISBN = "1-4919-2544-2",
ISBN-13 = "978-1-4919-2544-7",
LCCN = "????",
bibdate = "Thu Oct 31 18:43:15 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/ora.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
note = "Video file (1h10m).",
abstract = "Rust is a new programming language offering the
performance and control over memory of C and C++,
combined with a type system that catches memory leaks,
null pointer fetches, dangling pointers, and even the
nastier thread interactions. The price? You have to
think a bit more before you write. This webcast will
cover; How Rust ensures memory safety; lifetimes,
ownership, and borrowing; Polymorphism in Rust; traits,
generics, and how they work together; Modules, crates,
and Cargo; Concurrency, and how Rust forbids data
races.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
}
@InProceedings{Couprie:2015:NBO,
author = "G. Couprie",
booktitle = "{2015 IEEE Security and Privacy Workshops}",
title = "{Nom}, A Byte oriented, streaming, Zero copy, Parser
Combinators Library in {Rust}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "142--148",
year = "2015",
DOI = "https://doi.org/10.1109/SPW.2015.31",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Dewey:2015:FRT,
author = "K. Dewey and J. Roesch and B. Hardekopf",
booktitle = "{2015 30th IEEE\slash ACM International Conference on
Automated Software Engineering (ASE)}",
title = "Fuzzing the {Rust} Typechecker Using {CLP (T)}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "482--493",
year = "2015",
DOI = "https://doi.org/10.1109/ASE.2015.65",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Toman:2015:CBV,
author = "J. Toman and S. Pernsteiner and E. Torlak",
booktitle = "{2015 30th IEEE\slash ACM International Conference on
Automated Software Engineering (ASE)}",
title = "{Crust}: a Bounded Verifier for {Rust (N)}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "75--80",
year = "2015",
DOI = "https://doi.org/10.1109/ASE.2015.77",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Anderson:2016:ESW,
author = "B. Anderson and L. Bergstrom and M. Goregaokar and J.
Matthews and K. McAllister and J. Moffitt and S.
Sapin",
booktitle = "{2016 IEEE\slash ACM 38th International Conference on
Software Engineering Companion (ICSE-C)}",
title = "Engineering the {Servo} Web Browser Engine Using
{Rust}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "81--89",
year = "2016",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Cimler:2016:CRC,
author = "Richard Cimler and Ond{\v{r}}ej Dole{\v{z}}al and
Pavel Pscheidl",
booktitle = "{Computational Collective Intelligence: 8th
International Conference, ICCCI 2016, Halkidiki,
Greece, September 28--30, 2016. Proceedings, Part II}",
title = "Comparison of {RUST} and {C\#} as a Tool for Creation
of a Large Agent-Based Simulation for Population
Prediction of Patients with {Alzheimer}'s Disease in
{EU}",
publisher = pub-SV,
address = pub-SV:adr,
pages = "252--261",
year = "2016",
DOI = "https://doi.org/10.1007/978-3-319-45246-3_24",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/csharp.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-3-319-45246-3_24",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Terber:2016:DSC,
author = "Matthias Terber",
booktitle = "{Internet der Dinge}",
title = "{Dom{\"a}nenorientierte Softwarearchitektur mit
C{\'e}u und Rust am Beispiel eines Heizungsgateways zur
Fern{\"u}berwachung und Fernparametrisierung}.
({German}) [{Domain}-oriented software architecture
with {C{\'e}u} and {Rust} using the example of a
heating gateway for remote monitoring and remote
parameterization]",
publisher = pub-SV,
address = pub-SV:adr,
pages = "117--126",
year = "2016",
DOI = "https://doi.org/10.1007/978-3-662-53443-4_13",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-3-662-53443-4_13",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
language = "German",
}
@Article{Balasubramanian:2017:SPR,
author = "Abhiram Balasubramanian and Marek S. Baranowski and
Anton Burtsev and Aurojit Panda and Zvonimir Rakamari
and Leonid Ryzhyk",
title = "System Programming in {Rust}: Beyond Safety",
journal = j-OPER-SYS-REV,
volume = "51",
number = "1",
pages = "94--99",
month = aug,
year = "2017",
CODEN = "OSRED8",
DOI = "https://doi.org/10.1145/3139645.3139660",
ISSN = "0163-5980 (print), 1943-586X (electronic)",
ISSN-L = "0163-5980",
bibdate = "Fri Sep 15 10:37:05 MDT 2017",
bibsource = "http://portal.acm.org/;
https://www.math.utah.edu/pub/tex/bib/opersysrev.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
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.",
acknowledgement = ack-nhfb,
fjournal = "Operating Systems Review",
journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J597",
keywords = "Rust programming language",
}
@Book{Blandy:2017:PR,
author = "Jim Blandy and Jason Orendorff",
title = "Programming {Rust}",
publisher = pub-ORA-MEDIA,
address = pub-ORA-MEDIA:adr,
pages = "xx + 598",
year = "2017",
ISBN = "1-4919-2728-3 (paperback), 1-4919-2727-5,
1-4919-2723-2 (e-book), 1-4919-2725-9 (e-book)",
ISBN-13 = "978-1-4919-2728-1 (paperback), 978-1-4919-2727-4,
978-1-4919-2723-6 (e-book), 978-1-4919-2725-0
(e-book)",
LCCN = "QA76.73.R88 B53 2017",
bibdate = "Mon Dec 9 15:37:10 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
https://www.math.utah.edu/pub/tex/bib/ora.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://proquest.safaribooksonline.com/9781491927274",
abstract = "Rust is a new systems programming language that
combines the performance and low-level control of C and
C++ with memory safety and thread safety. Rust's
modern, flexible types ensure your program is free of
null pointer dereferences, double frees, dangling
pointers, and similar bugs, all at compile time,
without runtime overhead. In multithreaded code, Rust
catches data races at compile time, making concurrency
much easier to use. Written by two experienced systems
programmers, this book explains how Rust manages to
bridge the gap between performance and safety, and how
you can take advantage of it. Topics include: How Rust
represents values in memory (with diagrams) Complete
explanations of ownership, moves, borrows, and
lifetimes Cargo, rustdoc, unit tests, and how to
publish your code on crates.io, Rust's public package
repository High-level features like generic code,
closures, collections, and iterators that make Rust
productive and flexible Concurrency in Rust: threads,
mutexes, channels, and atomics, all much safer to use
than in C or C++ Unsafe code, and how to preserve the
integrity of ordinary code that uses it. Extended
examples illustrating how pieces of the language fit
together.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
subject = "UNIX (Computer file); UNIX (Computer file); C
(Computer program language); Text editors (Computer
programs); Software engineering; C (Computer program
language); Software engineering.; Text editors
(Computer programs)",
tableofcontents = "Preface \\
Who Should Read This Book \\
Why We Wrote This Book \\
Navigating This Book \\
Conventions Used in This Book \\
Using Code Examples \\
O Reilly Safari \\
How to Contact Us \\
Acknowledgments \\
1. Why Rust? \\
Type Safety \\
2. A Tour of Rust \\
Downloading and Installing Rust \\
A Simple Function \\
Writing and Running Unit Tests \\
Handling Command-Line Arguments \\
A Simple Web Server \\
Concurrency \\
What the Mandelbrot Set Actually Is \\
Parsing Pair Command-Line Arguments \\
Mapping from Pixels to Complex Numbers \\
Plotting the Set \\
Writing Image Files \\
A Concurrent Mandelbrot Program \\
Running the Mandelbrot Plotter \\
Safety Is Invisible \\
3. Basic Types \\
Machine Types \\
Integer Types \\
Floating-Point Types \\
The bool Type \\
Characters \\
Tuples \\
Pointer Types \\
References \\
Boxes \\
Raw Pointers \\
Arrays, Vectors, and Slices \\
Arrays \\
Vectors \\
Slices \\
String Types \\
String Literals \\
Byte Strings \\
Strings in Memory \\
String \\
Using Strings \\
Other String-Like Types \\
Beyond the Basics \\
4. Ownership \\
Ownership \\
Moves \\
More Operations That Move \\
Moves and Control Flow \\
Moves and Indexed Content \\
Copy Types: The Exception to Moves \\
Rc and Arc: Shared Ownership \\
5. References \\
References as Values \\
Rust References Versus C++ References \\
Assigning References \\
References to References \\
Comparing References \\
References Are Never Null \\
Borrowing References to Arbitrary Expressions \\
References to Slices and Trait Objects \\
Reference Safety \\
Borrowing a Local Variable \\
Receiving References as Parameters \\
Passing References as Arguments \\
Returning References \\
Structs Containing References \\
Distinct Lifetime Parameters \\
Omitting Lifetime Parameters \\
Sharing Versus Mutation \\
Taking Arms Against a Sea of Objects \\
6. Expressions \\
An Expression Language \\
Blocks and Semicolons \\
Declarations \\
if and match \\
if let \\
Loops \\
return Expressions \\
Why Rust Has loop \\
Function and Method Calls \\
Fields and Elements \\
Reference Operators \\
Arithmetic, Bitwise, Comparison, and Logical Operators
\\
Assignment \\
Type Casts \\
Closures \\
Precedence and Associativity \\
Onward \\
7. Error Handling \\
Panic \\
Unwinding \\
Aborting \\
Result \\
Catching Errors \\
Result Type Aliases \\
Printing Errors \\
Propagating Errors \\
Working with Multiple Error Types \\
Dealing with Errors That Can t Happen \\
Ignoring Errors \\
Handling Errors in main() \\
Declaring a Custom Error Type \\
Why Results? \\
8. Crates and Modules \\
Crates \\
Build Profiles \\
Modules \\
Modules in Separate Files \\
Paths and Imports \\
The Standard Prelude \\
Items, the Building Blocks of Rust \\
Turning a Program into a Library \\
The src/bin Directory \\
Attributes \\
Tests and Documentation \\
Integration Tests \\
Documentation \\
Doc-Tests \\
Specifying Dependencies \\
Versions \\
Cargo.lock \\
Publishing Crates to crates.io \\
Workspaces \\
More Nice Things \\
9. Structs \\
Named-Field Structs \\
Tuple-Like Structs \\
Unit-Like Structs \\
Struct Layout \\
Defining Methods with impl \\
Generic Structs \\
Structs with Lifetime Parameters \\
Deriving Common Traits for Struct Types \\
Interior Mutability \\
10. Enums and Patterns \\
Enums \\
Enums with Data \\
Enums in Memory \\
Rich Data Structures Using Enums \\
Generic Enums \\
Patterns \\
Literals, Variables, and Wildcards in Patterns \\
Tuple and Struct Patterns \\
Reference Patterns \\
Matching Multiple Possibilities \\
Pattern Guards \\
@ patterns \\
Where Patterns Are Allowed \\
Populating a Binary Tree \\
The Big Picture \\
11. Traits and Generics \\
Using Traits \\
Trait Objects \\
Trait Object Layout \\
Generic Functions \\
Which to Use \\
Defining and Implementing Traits \\
Default Methods \\
Traits and Other People s Types \\
Self in Traits \\
Subtraits \\
Static Methods \\
Fully Qualified Method Calls \\
Traits That Define Relationships Between Types \\
Associated Types (or How Iterators Work) \\
Generic Traits (or How Operator Overloading Works) \\
Buddy Traits (or How rand::random() Works) \\
Reverse-Engineering Bounds \\
Conclusion \\
12. Operator Overloading \\
Arithmetic and Bitwise Operators \\
Unary Operators \\
Binary Operators \\
Compound Assignment Operators \\
Equality Tests \\
Ordered Comparisons \\
Index and IndexMut \\
Other Operators \\
13. Utility Traits \\
Drop \\
Sized \\
Clone \\
Copy \\
Deref and DerefMut \\
Default \\
AsRef and AsMut \\
Borrow and BorrowMut \\
From and Into \\
ToOwned \\
Borrow and ToOwned at Work: The Humble Cow \\
14. Closures \\
Capturing Variables \\
Closures That Borrow \\
Closures That Steal \\
Function and Closure Types \\
Closure Performance \\
Closures and Safety \\
Closures That Kill \\
FnOnce \\
FnMut \\
Callbacks \\
Using Closures Effectively \\
15. Iterators \\
The Iterator and IntoIterator Traits \\
Creating Iterators \\
iter and iter_mut Methods \\
IntoIterator Implementations \\
drain Methods \\
Other Iterator Sources \\
Iterator Adapters \\
map and filter \\
filter_map and flat_map \\
scan \\
take and take_while \\
skip and skip_while \\
peekable \\
fuse \\
Reversible Iterators and rev \\
inspect \\
chain \\
enumerate \\
zip \\
by_ref \\
cloned \\
cycle \\
Consuming Iterators \\
Simple Accumulation: count, sum, product \\
max, min \\
max_by, min_by \\
max_by_key, min_by_key \\
Comparing Item Sequences \\
any and all \\
position, rposition, and ExactSizeIterator \\
fold \\
nth \\
last \\
find \\
Building Collections: collect and FromIterator \\
The Extend Trait \\
partition \\
Implementing Your Own Iterators \\
16. Collections \\
Overview \\
Vec<T> \\
Accessing Elements \\
Iteration \\
Growing and Shrinking Vectors \\
Joining \\
Splitting \\
Swapping \\
Sorting and Searching \\
Comparing Slices \\
Random Elements \\
Rust Rules Out Invalidation Errors \\
VecDeque<T> \\
LinkedList<T> \\
BinaryHeap<T> \\
HashMap<K, V> and BTreeMap<K, V> \\
Entries \\
Map Iteration \\
HashSet<T> and BTreeSet<T> \\
Set Iteration \\
When Equal Values Are Different \\
Whole-Set Operations \\
Hashing \\
Using a Custom Hashing Algorithm \\
Beyond the Standard Collections \\
17. Strings and Text \\
Some Unicode Background \\
ASCII, Latin-1, and Unicode \\
UTF-8 \\
Text Directionality \\
Characters (char) \\
Classifying Characters \\
Handling Digits \\
Case Conversion for Characters \\
Conversions to and from Integers \\
String and str \\
Creating String Values \\
Simple Inspection \\
Appending and Inserting Text \\
Removing Text \\
Conventions for Searching and Iterating \\
Patterns for Searching Text \\
Searching and Replacing \\
Iterating over Text \\
Trimming \\
Case Conversion for Strings \\
Parsing Other Types from Strings \\
Converting Other Types to Strings \\
Borrowing as Other Text-Like Types \\
Accessing Text as UTF-8 \\
Producing Text from UTF-8 Data \\
Putting Off Allocation \\
Strings as Generic Collections \\
Formatting Values \\
Formatting Text Values \\
Formatting Numbers \\
Formatting Other Types \\
Formatting Values for Debugging \\
Formatting Pointers for Debugging \\
Referring to Arguments by Index or Name \\
Dynamic Widths and Precisions \\
Formatting Your Own Types \\
Using the Formatting Language in Your Own Code \\
Regular Expressions \\
Basic Regex Use \\
Building Regex Values Lazily \\
Normalization \\
Normalization Forms \\
The unicode-normalization Crate \\
18. Input and Output \\
Readers and Writers \\
Readers \\
Buffered Readers \\
Reading Lines \\
Collecting Lines \\
Writers \\
Files \\
Seeking \\
Other Reader and Writer Types \\
Binary Data, Compression, and Serialization \\
Files and Directories \\
OsStr and Path \\
Path and PathBuf Methods \\
Filesystem Access Functions \\
Reading Directories \\
Platform-Specific Features \\
Networking \\
19. Concurrency \\
Fork-Join Parallelism \\
spawn and join \\
Error Handling Across Threads \\
Sharing Immutable Data Across Threads \\
Rayon \\
Revisiting the Mandelbrot Set \\
Channels \\
Sending Values \\
Receiving Values \\
Running the Pipeline \\
Channel Features and Performance \\
Thread Safety: Send and Sync \\
Piping Almost Any Iterator to a Channel \\
Beyond Pipelines \\
Shared Mutable State \\
What Is a Mutex? \\
Mutex<T> \\
mut and Mutex \\
Why Mutexes Are Not Always a Good Idea \\
Deadlock \\
Poisoned Mutexes \\
Multi-Consumer Channels Using Mutexes \\
Read/Write Locks (RwLock<T>) \\
Condition Variables (Condvar) \\
Atomics \\
Global Variables \\
What Hacking Concurrent Code in Rust Is Like \\
20. Macros \\
Macro Basics \\
Basics of Macro Expansion \\
Unintended Consequences \\
Repetition \\
Built-In Macros \\
Debugging Macros \\
The json! Macro \\
Fragment Types \\
Recursion in Macros \\
Using Traits with Macros \\
Scoping and Hygiene \\
Importing and Exporting Macros \\
Avoiding Syntax Errors During Matching \\
Beyond macro_rules! \\
21. Unsafe Code \\
Unsafe from What? \\
Unsafe Blocks \\
Example: An Efficient ASCII String Type \\
Unsafe Functions \\
Unsafe Block or Unsafe Function? \\
Undefined Behavior \\
Unsafe Traits \\
Raw Pointers \\
Dereferencing Raw Pointers Safely \\
Example: RefWithFlag \\
Nullable Pointers \\
Type Sizes and Alignments \\
Pointer Arithmetic \\
Moving into and out of Memory \\
Example: GapBuffer \\
Panic Safety in Unsafe Code \\
Foreign Functions: Calling C and C++ from Rust \\
Finding Common Data Representations \\
Declaring Foreign Functions and Variables \\
Using Functions from Libraries \\
A Raw Interface to libgit2 \\
A Safe Interface to libgit2 \\
Conclusion \\
Index",
}
@InProceedings{Chifflier:2017:WPL,
author = "P. Chifflier and G. Couprie",
booktitle = "{2017 IEEE Security and Privacy Workshops (SPW)}",
title = "Writing Parsers Like it is 2017",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "80--92",
year = "2017",
DOI = "https://doi.org/10.1109/SPW.2017.39",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Kikas:2017:SEP,
author = "R. Kikas and G. Gousios and M. Dumas and D. Pfahl",
booktitle = "{2017 IEEE\slash ACM 14th International Conference on
Mining Software Repositories (MSR)}",
title = "Structure and Evolution of Package Dependency
Networks",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "102--112",
year = "2017",
DOI = "https://doi.org/10.1109/MSR.2017.55",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Book{Klabnik:2017:RPL,
author = "Steve Klabnik and Carol Nichols",
title = "The {Rust} Programming Language",
publisher = pub-NO-STARCH,
address = pub-NO-STARCH:adr,
pages = "xxvii + 519",
year = "2017",
ISBN = "1-59327-828-4 (paperback), 1-59327-851-9 (e-pub)",
ISBN-13 = "978-1-59327-828-1 (paperback), 978-1-59327-851-9
(e-pub)",
LCCN = "QA76.73.R87 K53 2018",
bibdate = "Thu Oct 31 18:42:15 MDT 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
abstract = "\booktitle{The Rust Programming Language} is the
official book on Rust; a community-developed, systems
programming language that runs blazingly fast, prevents
segfaults, and guarantees thread safety. Rust's memory
safety guarantees, enforced at compile time, safeguard
your programs against the many problems that pervade
other systems languages. Rust offers the control and
performance of a low-level language with the helpful
abstractions of a high level one, and does this all
without having a garbage collector. These
characteristics make Rust useful for embedding in other
languages, programs with specific space and time
requirements, and writing low-level code, like device
drivers and operating systems. \booktitle{The Rust
Programming Language} begins with a quick hands-on
project to introduce the basics, then explores key
concepts in depth, such as ownership, the type system,
error handling, and fearless concurrency. Detailed
explanations of Rust-oriented takes on topics like
pattern matching, iterators, and smart pointers combine
with examples and exercises to take you from theory to
practice. In addition to its thorough coverage of more
granular topics, \booktitle{The Rust Programming
Language} will show you how to: * Grasp important
concepts unique to Rust like ownership, borrowing, and
lifetimes; * Use Cargo, Rust's built-in package
manager, to build your code, including downloading and
building dependencies; * Effectively use Rust's
zero-cost abstractions and learn to build your own.
Developed with help from the community, \booktitle{The
Rust Programming Language} is your official guide to
becoming a productive Rust programmer. The official
guide to Rust, a community-developed, systems
programming language. Begins with a hands-on project to
introduce the basics, then explores key concepts in
depth''",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
subject = "Computer programming; Programming languages
(Electronic computers); Computer programming;
Programming languages (Electronic computers)",
tableofcontents = "Foreword / by Nicholas Matsakis and Aaron Turon \\
Introduction \\
1: Getting Started \\
2: A Quick Tutorial \\
Guessing Game \\
3: Common Programming Concepts \\
4: Understanding Ownership \\
5: Structs \\
6: Enums and Pattern Matching \\
7: Modules \\
8: Common Collections \\
9: Error Handling \\
10: Generic Types, Traits, and Lifetimes \\
11: Testing \\
12: An Input\slash Output Project \\
13: Functional Language Features in Rust \\
Iterators and Closures \\
14: More about Cargo and Crates io \\
15: Smart Pointers \\
16: Concurrency \\
17: Is Rust Object Oriented? \\
18: Patterns \\
19: More About Lifetimes \\
20: Advanced Type System Features \\
Appendix A: Keywords \\
Appendix B: Operators \\
Appendix C: Derivable Traits \\
Appendix D: Nightly Rust\ \\
Nightly Rust \\
Glossary",
}
@InProceedings{Oda:2017:DIS,
author = "T. Oda and R. Obukata and M. Ikeda and L. Barolli and
M. Takizawa",
booktitle = "{2017 31st International Conference on Advanced
Information Networking and Applications Workshops
(WAINA)}",
title = "Design and Implementation of a Simulation System Based
on Deep {Q}-Network for Mobile Actor Node Control in
Wireless Sensor and Actor Networks",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "195--200",
year = "2017",
DOI = "https://doi.org/10.1109/WAINA.2017.67",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Uzlu:2017:URP,
author = "T. Uzlu and E. { aykol}",
booktitle = "{2017 9th International Conference on Computational
Intelligence and Communication Networks (CICN)}",
title = "On utilizing {Rust} programming language for {Internet
of Things}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "93--96",
year = "2017",
DOI = "https://doi.org/10.1109/CICN.2017.8319363",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Baranowski:2018:VRP,
author = "Marek Baranowski and Shaobo He and Zvonimir Rakamari",
booktitle = "{Automated Technology for Verification and Analysis:
16th International Symposium, ATVA 2018, Los Angeles,
CA, USA, October 7--10, 2018, Proceedings}",
title = "Verifying {Rust} Programs with {SMACK}",
publisher = pub-SV,
address = pub-SV:adr,
pages = "528--535",
year = "2018",
DOI = "https://doi.org/10.1007/978-3-030-01090-4_32",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-3-030-01090-4_32",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Book{Chanda:2018:NPR,
author = "Abhishek Chanda",
title = "Network Programming {Rust}: Build Fast and Resilient
Network Servers and Clients by Leveraging {Rust}'s
Memory-safety and Concurrency Features",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "iii + 265",
year = "2018",
ISBN = "1-78862-171-9 (e-book), 1-78862-489-0 (paperback)",
ISBN-13 = "978-1-78862-171-7 (e-book), 978-1-78862-489-3
(paperback)",
LCCN = "QA76.73.R88",
bibdate = "Tue Dec 10 06:07:22 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://proquest.safaribooksonline.com/?fpi=9781788624893",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
subject = "Rust (Computer program language); Programming
languages (Electronic computers); Computer programming;
Computer programming.; Programming languages
(Electronic computers); Rust (Computer program
language)",
tableofcontents = "Preface \\
1: Introduction to Client/Server Networking \\
A brief history of networks \\
Layering in networks \\
Addressing in networks \\
How IP routing works \\
How DNS works \\
Common service models \\
Connection-oriented service \\
Connectionless service \\
The network programming interface in Linux \\
Summary \\
2: Introduction to Rust and its Ecosystem \\
The Rust ecosystem \\
Getting started with Rust \\
Introduction to the borrow checker \\
Generics and the trait system \\
Error handling \\
The macro system \\
Syntactic macros \\
Procedural macros \\
Functional features in Rust \\
Higher-order functions \\
Iterators \\
Concurrency primitives \\
Testing \\
Summary \\
3: TCP and UDP Using Rust \\
A Simple TCP server and client \\
A Simple UDP server and client \\
UDP multicasting \\
Miscellaneous utilities in std::net \\
Some related crates \\
Summary \\
4: Data Serialization, Deserialization, and Parsing \\
Serialization and deserialization using Serde \\
Custom serialization and deserialization \\
Parsing textual data \\
Parsing binary data \\
Summary \\
5: Application Layer Protocols \\
Introduction to RPC \\
Introduction to SMTP \\
Introduction to FTP and TFTP \\
Summary \\
6: Talking HTTP in the Internet \\
Introducing Hyper \\
Introducing Rocket \\
Introducing reqwest \\
Summary \\
7: Asynchronous Network Programming Using Tokio \\
Looking into the Future \\
Working with streams and sinks \\
Heading to tokio \\
Socket multiplexing in tokio \\
Writing streaming protocols \\
The larger tokio ecosystem \\
Conclusion \\
8: Security \\
Securing the web \\
Letsencrypt using Rust \\
OpenSSL using Rust \\
Securing tokio applications \\
Cryptography using ring \\
Summary \\
9: Appendix \\
Introduction to coroutines and generators \\
How May handles coroutines \\
Awaiting the future \\
Data parallelism \\
Parsing using Pest \\
Miscellaneous utilities \\
Summary \\
Other Books You May Enjoy \\
Index",
}
@InProceedings{Denisov:2018:MIM,
author = "A. Denisov and S. Pankevich",
booktitle = "{2018 IEEE International Conference on Software
Testing, Verification and Validation Workshops
(ICSTW)}",
title = "{Mull} It Over: Mutation Testing Based on {LLVM}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "25--31",
year = "2018",
DOI = "https://doi.org/10.1109/ICSTW.2018.00024",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Book{EguiaMoraza:2018:RHP,
author = "Iban {Eguia Moraza}",
title = "{Rust} High Performance: Learn to Skyrocket the
Performance of Your {Rust} Applications",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "265",
year = "2018",
ISBN = "1-78847-823-1",
ISBN-13 = "978-1-78839-948-7, 978-1-78847-823-6",
LCCN = "QA76.7",
bibdate = "Tue Dec 10 05:42:07 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
abstract = "Sometimes it's difficult to get the best performance
out of Rust. This book teaches you how to optimize the
speed of your Rust code to the level of languages such
as C/C++. You'll understand and fix common pitfalls,
learn how to improve your productivity by using
metaprogramming, and speed up your code by concurrently
executing parts of it.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
subject = "Programming languages (Electronic computers); Computer
programming; Application software; Development;
Computers; Programming; Parallel; Software Development
and Engineering; Tools; software development; Parallel
processing; Programming Languages; C; Programming and
scripting languages: general; Development; Computer
programming; Programming languages (Electronic
computers)",
tableofcontents = "Preface \\
1: Common Performance Pitfalls \\
Asking the Rust compiler about performance \\
Optimizations \\
Build configuration \\
Optimization level \\
Debug information \\
Link-time optimizations \\
Debug assertions \\
Panic behavior \\
Runtime library paths \\
Translation issues \\
Indexing degradations \\
Using iterators \\
Iterator adaptors \\
Real-life example \\
Specialized adaptors \\
Interaction between adaptors \\
Itertools \\
Borrowing degradations \\
Cyclomatic complexity \\
Summary \\
2: Extra Performance Enhancements \\
Compile-time checks \\
Sequential state machines \\
Complex state machines \\
Real-life type system check example \\
Extra performance tips \\
Using closures to avoid runtime evaluation \\
Unstable sorting \\
Map hashing \\
Perfect hash functions \\
Standard library collections \\
Sequences \\
Maps \\
Sets \\
Summary \\
3: Memory Management in Rust \\
Mastering the borrow checker \\
Allocations \\
Mutability, borrowing, and owning \\
Lifetimes \\
Memory representation \\
Alignment \\
Complex enumerations \\
Unions \\
Shared pointers \\
The cell module \\
Cells \\
RefCell \\
The rc module \\
Summary \\
4: Lints and Clippy \\
Using Rust compiler lints \\
Lints \\
Avoiding anonymous parameters \\
Avoiding heap allocated box pointers \\
Avoiding missing implementations \\
Enforcing documentation \\
Pointing out trivial casts \\
Linting unsafe code blocks \\
Unused lints \\
Variant size differences \\
Lint groups \\
Clippy \\
Installation \\
Configuration \\
Lints \\
Casting \\
Bad practice \\
Performance lints \\
Unwraps \\
Shadowing \\
Integer overflow \\
Lint groups \\
Summary \\
5: Profiling Your Rust Application \\
Understanding the hardware \\
Understanding how the CPU works \\
Speeding up memory access with the cache \\
Cache misses \\
How can you fix it? \\
Cache invalidation \\
CPU pipeline \\
Branch prediction \\
The relevance of branch prediction for our code \\
Profiling tools \\
Valgrind \\
Callgrind \\
Cachegrind \\
OProfile \\
Summary \\
6: Benchmarking \\
Selecting what to benchmark \\
Benchmarking in nightly Rust \\
Benchmarking in stable Rust \\
Continuous integration for benchmarks \\
Travis-CI integration \\
Benchmark statistics with Criterion \\
Summary \\
7: Built-in Macros and Configuration Items \\
Understanding attributes \\
Trait derivations \\
Crate features \\
Configuration attributes \\
Macros \\
Console printing \\
String formatting \\
Compilation environment \\
Loading byte arrays and strings at compile time \\
Code paths \\
Checking preconditions and postconditions \\
Others \\
Nightly Rust \\
Conservative trait return \\
Constant functions \\
Inline assembly and naked functions \\
Using bigger integers \\
Single instruction multiple data \\
Allocation API \\
Compiler plugins \\
Summary \\
8: Must-Have Macro Crates \\
Working with external data \\
Data serialization and deserialization \\
Serializing and deserializing complex structures \\
Parsing byte streams \\
Learning about useful small crates \\
Creating lazily evaluated statics",
}
@InProceedings{Georgiou:2018:WYP,
author = "S. Georgiou and M. Kechagia and P. Louridas and D.
Spinellis",
booktitle = "{2018 IEEE\slash ACM 15th International Conference on
Mining Software Repositories (MSR)}",
title = "What are Your Programming Language's Energy-Delay
Implications?",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "303--313",
year = "2018",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://ieeexplore.ieee.org/document/8595213",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Book{Gomez:2018:RPE,
author = "Guillaume Gomez and Antoni Boucher",
title = "{Rust} Programming by Example: Enter the World of
{Rust} by Building Engaging, Concurrent, Reactive, and
Robust Applications",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "viii + 437",
year = "2018",
ISBN = "1-78839-063-6, 1-78847-030-3 (e-book)",
ISBN-13 = "978-1-78839-063-7, 978-1-78847-030-8 (e-book)",
LCCN = "QA76.73.R88",
bibdate = "Tue Dec 10 05:30:42 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://proquestcombo.safaribooksonline.com/9781788390637",
abstract = "Rust is an open source, safe, concurrent, practical
language created by Mozilla. It runs blazingly fast,
prevents segfaults, and guarantees safety. This book
gets you started with essential software development by
guiding you through the different aspects of Rust
programming. With this approach, you can bridge the gap
between learning and implementing immediately.
Beginning with an introduction to Rust, you'll learn
the basic aspects such as its syntax, data types,
functions, generics, control flows, and more. After
this, you'll jump straight into building your first
project, a Tetris game. Next you'll build a graphical
music player and work with fast, reliable networking
software using Tokio, the scalable and productive
asynchronous IO Rust library. Over the course of this
book, you'll explore various features of Rust
Programming including its SDL features, event loop,
File I/O, and the famous GTK+ widget toolkit. Through
these projects, you'll see how well Rust performs in
terms of concurrency --- including parallelism,
reliability, improved performance, generics, macros,
and thread safety. We'll also cover some asynchronous
and reactive programming aspects of Rust. By the end of
the book, you'll be comfortable building various
real-world applications in Rust. Style and approach.
This comprehensive guide uses practical examples to
implement various Rust programming features.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
subject = "Rust (System programming language); Programming
languages (Electronic computers); Computer programming;
Portable and handheld devices: consumer/user guides;
Mobile phones: consumer/user guides; Parallel
processing; Programming and scripting languages:
general; Computers; Programming; Parallel; Hardware;
Handheld Devices; Programming Languages; Java; Computer
programming; Programming languages (Electronic
computers)",
tableofcontents = "Preface \\
1: Basics of Rust \\
Getting to know Rust \\
Installing Rust \\
Windows \\
Linux/Mac \\
Test your installation \\
Documentation and reference \\
Main function \\
Variables \\
Built-in data types \\
Integer types \\
Floating-point types \\
Boolean type \\
Character type \\
Control flow \\
Writing a condition \\
Creating while loops \\
Creating functions \\
Creating structures \\
References \\
Clone types \\
Copy types \\
Mutable references \\
Methods \\
Constructors \\
Tuples \\
Enumerations \\
Pattern matching \\
Irrefutable patterns \\
Traits \\
Default methods \\
Associated types \\
Rules \\
Generics \\
The Option type \\
Arrays \\
Slices \\
For loops \\
Macros \\
Multiple pattern rules \\
Repetitions \\
Optional quantifier \\
Summary \\
2: Starting with SDL \\
Understanding Rust crates \\
Installing SDL2 \\
Installing SDL2 on Linux \\
Installing SDL2 on Mac \\
Installing SDL2 on Windows \\
Windows with Build Script \\
Windows (MinGW) \\
Windows (MSVC) \\
Setting up your Rust project \\
Cargo and crates.io \\
The docs.rs documentation \\
Back to our Cargo.toml file \\
Rust's modules \\
Tetris \\
Creating a window \\
Drawing \\
Playing with Options \\
Solution \\
Loading images \\
Installing SDL2\_image on Mac \\
Installing SDL2\_image on Linux \\
Installing SDL2\_image on Windows \\
Playing with features \\
Playing with images \\
Handling files \\
Saving/loading high scores \\
Iterators \\
Reading formatted data from files \\
Summary \\
3: Events and Basic Game Mechanisms \\
Writing Tetris \\
Tetrimino \\
Creating tetriminos \\
Generating a tetrimino \\
Rotating a tetrimino \\
Tetris struct \\
Interacting with the game map \\
SDL events \\
Score, level, lines sent \\
Levels and lines sent \\
Highscores loading/overwriting \\
Summary \\
4: Adding All Game Mechanisms \\
Getting started with game mechanisms \\
Rendering UI \\
Rendering initialization \\
Rendering \\
Playing with fonts \\
Install on OS X \\
Install on Linux \\
Other system/package manager \\
Loading font \\
Summary \\
5: Creating a Music Player \\
Installing the prerequisite \\
Installing GTK+ on Linux \\
Installing GTK+ on Mac \\
Installing GTK+ on Windows \\
Creating your first window \\
Closure \\
Preventing the default behavior of an event \\
Creating a toolbar \\
Stock item \\
Improving the organization of the application \\
Adding tool button events \\
Lifetime \\
Ownership \\
Containers \\
Types of containers \\
The Box container \\
Adding a playlist \\
The MVC pattern \\
Opening MP3 files \\
Reference-counting pointer \\
ID3 (??) \\
(??) \\
MP3 metadata \\
Opening files with a file dialog \\
Deleting a song \\
Displaying the cover when playing a song \\
Summary \\
6: Implementing the Engine of the Music Player \\
Installing the dependencies \\
Installing dependencies on Linux \\
Installing dependencies on Mac \\
Installing dependencies on Windows \\
Decoding MP3 files \\
Adding dependencies \\
Implementing an MP3 decoder \\
Getting the frame samples \\
Playing music \\
Event loop \\
Atomic reference counting \\
Mutual exclusion \\
Send trait \\
Sync trait",
}
@Book{Johnson:2018:HFP,
author = "Andrew Johnson",
title = "Hands-on Functional Programming in {Rust}: Build
Modular and Reactive Applications with Functional
Programming Techniques in {Rust 2018}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "v + 278",
year = "2018",
ISBN = "1-78883-935-8 (paperback)",
ISBN-13 = "978-1-78883-935-8 (paperback)",
LCCN = "QA76.62",
bibdate = "Tue Dec 10 05:57:08 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
subject = "Rust (System programming language); Functional
programming (Computer science); Programming languages
(Electronic computers); Application software;
Development; Development; Functional programming
(Computer science); Programming languages (Electronic
computers)",
tableofcontents = "1: Functional Programming --- a comparison \\
2: Functional Control Flow \\
3: Functional Data Structures \\
4: Generics and Polymorphism \\
5: Code Organization and Application Architecture \\
6: Mutability, Ownership, and Pure Functions \\
7: Design Patterns \\
8: Implementing Concurrency \\
9: Performance, Debugging, and Metaprogramming \\
Assessments \\
Other Books You May Enjoy \\
Index",
}
@Article{Jung:2018:RSF,
author = "Ralf Jung and Jacques-Henri Jourdan and Robbert
Krebbers and Derek Dreyer",
title = "{RustBelt}: securing the foundations of the {Rust}
programming language",
journal = j-PACMPL,
volume = "2",
number = "POPL",
pages = "66:1--66:??",
month = jan,
year = "2018",
CODEN = "????",
DOI = "https://doi.org/10.1145/3158154",
ISSN = "2475-1421",
bibdate = "Wed Jan 10 09:45:26 MST 2018",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
abstract = "Rust is a new systems programming language that
promises to overcome the seemingly fundamental tradeoff
between high-level safety guarantees and low-level
control over resource management. Unfortunately, none
of Rust's safety claims have been formally proven, and
there is good reason to question whether they actually
hold. Specifically, Rust employs a strong,
ownership-based type system, but then extends the
expressive power of this core type system through
libraries that internally use unsafe features. In this
paper, we give the first formal (and machine-checked)
safety proof for a language representing a realistic
subset of Rust. Our proof is extensible in the sense
that, for each new Rust library that uses unsafe
features, we can say what verification condition it
must satisfy in order for it to be deemed a safe
extension to the language. We have carried out this
verification for some of the most important libraries
that are used throughout the Rust ecosystem.",
acknowledgement = ack-nhfb,
articleno = "66",
fjournal = "Proceedings of the ACM on Programming Languages",
journal-URL = "https://pacmpl.acm.org/",
keywords = "Rust programming language",
}
@InProceedings{Kyriakou:2018:ICC,
author = "Kyriakos-Ioannis D. Kyriakou and Nikolaos D. Tselikas
and Georgia M. Kapitsaki",
booktitle = "{Open Source Systems: Enterprise Software and
Solutions: 14th IFIP WG 2.13 International Conference,
OSS 2018, Athens, Greece, June 8--10, 2018,
Proceedings}",
title = "Improving {C/C++} Open Source Software Discoverability
by Utilizing {Rust} and \pkg{Node.js} Ecosystems",
publisher = pub-SV,
address = pub-SV:adr,
pages = "181--192",
year = "2018",
DOI = "https://doi.org/10.1007/978-3-319-92375-8_15",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-3-319-92375-8_15",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Article{Lee:2018:RHL,
author = "Juneyoung Lee and Chung-Kil Hur and Ralf Jung and
Zhengyang Liu and John Regehr and Nuno P. Lopes",
title = "Reconciling high-level optimizations and low-level
code in {LLVM}",
journal = j-PACMPL,
volume = "2",
number = "OOPSLA",
pages = "125:1--125:28",
month = oct,
year = "2018",
DOI = "https://doi.org/10.1145/3276495",
bibdate = "Sat Aug 8 07:56:30 MDT 2020",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/abs/10.1145/3276495",
abstract = "LLVM miscompiles certain programs in C, C++, and Rust
that use low-level language features such as raw
pointers in Rust or conversion between integers and
pointers in C or C++. The problem is that it is
difficult for the compiler to implement aggressive,
high-level memory optimizations while also respecting
the guarantees made by the programming languages to
low-level programs. A deeper problem is that the memory
model for LLVM's intermediate representation (IR) is
informal and the semantics of corner cases are not
always clear to all compiler developers. We developed a
novel memory model for LLVM IR and formalized it. The
new model requires a handful of problematic IR-level
optimizations to be removed, but it also supports the
addition of new optimizations that were not previously
legal. We have implemented the new model and shown that
it fixes known memory-model-related miscompilations
without impacting the quality of generated code.",
acknowledgement = ack-nhfb,
articleno = "125",
fjournal = "Proceedings of the ACM on Programming Languages",
journal-URL = "https://pacmpl.acm.org/",
keywords = "Rust programming language",
}
@InProceedings{Lindner:2018:HLB,
author = "M. Lindner and J. Aparicio and H. Tjader and P.
Lindgren and J. Eriksson",
booktitle = "{2018 IEEE 23rd International Conference on Emerging
Technologies and Factory Automation (ETFA)}",
title = "Hardware-in-the-loop based {WCET} analysis with
{KLEE}",
volume = "1",
number = "",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "345--352",
year = "2018",
DOI = "https://doi.org/10.1109/ETFA.2018.8502510",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Lindner:2018:NPV,
author = "M. Lindner and J. Aparicius and P. Lindgren",
booktitle = "{2018 IEEE 16th International Conference on Industrial
Informatics (INDIN)}",
title = "No Panic! {Verification} of {Rust} Programs by
Symbolic Execution",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "108--114",
year = "2018",
DOI = "https://doi.org/10.1109/INDIN.2018.8471992",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@MastersThesis{Lundberg:2018:SKP,
author = "Johannes Lundberg",
title = "Safe Kernel Programming with {Rust}",
type = "{Master}'s thesis",
number = "2018:503",
school = "KTH, Software and Computer systems, SCS",
address = "Stockholm, Sweden",
pages = "56",
month = jul,
year = "2018",
bibdate = "Mon Sep 26 09:12:49 2022",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
series = "TRITA-EECS-EX",
URL = "http://www.diva-portal.org/smash/record.jsf?pid=diva2%3A1238890&dswid=-1806",
abstract = "Writing bug free computer code is a challenging task
in a low-level language like C. While C compilers are
getting better and better at detecting possible bugs,
they still have a long way to go. For application
programming we have higher level languages that
abstract away details in memory handling and concurrent
programming. However, a lot of an operating system's
source code is still written in C and the kernel is
exclusively written in C. How can we make writing
kernel code safer? What are the performance penalties
we have to pay for writing safe code? In this thesis,
we will answer these questions using the Rust
programming language. A Rust Kernel Programming
Interface is designed and implemented, and a network
device driver is then ported to Rust. The Rust code is
analyzed to determine the safeness and the two
implementations are benchmarked for performance and
compared to each other. It is shown that a kernel
device driver can be written entirely in safe Rust
code, but the interface layer require some unsafe code.
Measurements show unexpected minor improvements to
performance with Rust.",
acknowledgement = ack-nhfb,
keywords = "rust, kernel, safe, programming",
}
@Book{Milanesi:2018:BRN,
author = "Carlo Milanesi",
title = "Beginning {Rust}: From Novice to Professional",
publisher = pub-SV,
address = pub-SV:adr,
pages = "xvii + 376 + 3",
year = "2018",
DOI = "https://doi.org/10.1007/978-1-4842-3468-6",
ISBN = "1-4842-3467-7, 1-4842-3468-5 (e-book)",
ISBN-13 = "978-1-4842-3467-9, 978-1-4842-3468-6 (e-book)",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/book/10.1007/978-1-4842-3468-6",
abstract = "Learn to program with Rust in an easy, step-by-step
manner on Unix, Linux shell, macOS and the Windows
command line. As you read this book, you'll build on
the knowledge you gained in previous chapters and see
what Rust has to offer. Beginning Rust starts with the
basics of Rust, including how to name objects, control
execution flow, and handle primitive types. You'll see
how to do arithmetic, allocate memory, use iterators,
and handle input/output. Once you have mastered these
core skills, you'll work on handling errors and using
the object-oriented features of Rust to build robust
Rust applications in no time. Only a basic knowledge of
programming is required, preferably in C or C++. To
understand this book, it's enough to know what integers
and floating-point numbers are, and to distinguish
identifiers from string literals. After reading this
book, you'll be ready to build Rust applications. What
You'll Learn Get started programming with Rust
Understand heterogeneous data structures and data
sequences Define functions, generic functions, structs,
and more Work with closures, changeable strings, ranges
and slices Use traits and learn about lifetimes Who
This Book Is For Those who are new to Rust and who have
at least some prior experience with programming in
general: some C/C++ is recommended particularly.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
tableofcontents = "1. Printing on Terminal \\
2. Doing Arithmetic \\
3. Naming Objects \\
4. Controlling Execution Flow \\
5. Using Data Sequences \\
6. Using Primitive Types \\
7. Enumerating Cases \\
8. Using Heterogeneous Data Structures \\
9. Defining Functions \\
10. Defining Generic Functions and Structs \\
11. Allocating Memory \\
12. Data Implementation \\
13. Defining Closures \\
14. Using Changeable Strings \\
15. Ranges and Slices \\
16. Using Iterators \\
17. Input/Output and Error Handling \\
18. Using Traits \\
19. Object-Oriented Programming \\
20. Standard Library Collections \\
21. Drops, Moves, and Copies \\
22. Borrowing and Lifetimes \\
23. More about Lifetimes",
}
@InProceedings{Mindermann:2018:HUR,
author = "K. Mindermann and P. Keck and S. Wagner",
booktitle = "{2018 IEEE International Conference on Software
Quality, Reliability and Security (QRS)}",
title = "How Usable Are {Rust} Cryptography {APIs}?",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "143--154",
year = "2018",
DOI = "https://doi.org/10.1109/QRS.2018.00028",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Sydow:2018:SUF,
author = "S. Sydow and M. Nabelsee and H. Parzyjegla and P.
Herber",
booktitle = "{2018 26th Euromicro International Conference on
Parallel, Distributed and Network-based Processing
(PDP)}",
title = "A Safe and User-Friendly Graphical Programming Model
for Parallel Stream Processing",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "239--243",
year = "2018",
DOI = "https://doi.org/10.1109/PDP2018.2018.00040",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Book{Troutwine:2018:HCR,
author = "Brian L. Troutwine",
title = "Hands-on Concurrency with {Rust}: Confidently Build
Memory-safe, Parallel, and Efficient Software in
{Rust}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "v + 449",
year = "2018",
ISBN = "1-78839-997-8 (paperback), 1-78847-835-5",
ISBN-13 = "978-1-78839-997-5 (paperback), 978-1-78847-835-9",
LCCN = "QA76.76.A65",
bibdate = "Tue Dec 10 05:53:29 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://proquest.safaribooksonline.com/?fpi=9781788399975",
abstract = "Get to grips with modern software demands by learning
the effective uses of Rust's powerful memory safety.Key
Features Learn and improve the sequential performance
characteristics of your software Understand the use of
operating system processes in a high-scale concurrent
system Learn of the various coordination methods
available in the Standard library. Most programming
languages can really complicate things, especially with
regard to unsafe memory access. The burden on you, the
programmer, lies across two domains: understanding the
modern machine and your language's pain-points. This
book will teach you to how to manage program
performance on modern machines and build fast,
memory-safe, and concurrent software in Rust. It starts
with the fundamentals of Rust and discusses machine
architecture concepts. You will be taken through ways
to measure and improve the performance of Rust code
systematically and how to write collections with
confidence. You will learn about the Sync and Send
traits applied to threads, and coordinate thread
execution with locks, atomic primitives,
data-parallelism, and more.The book will show you how
to efficiently embed Rust in C++ code and explore the
functionalities of various crates for multithreaded
applications. It explores implementations in depth. You
will know how a mutex works and build several yourself.
You will master radically different approaches that
exist in the ecosystem for structuring and managing
high-scale systems. By the end of the book, you will
feel comfortable with designing safe, consistent,
parallel, and high-performance applications in
Rust.What you will learn Probe your programs for
performance and accuracy issues Create your own
threading and multi-processing environment in Rust Use
coarse locks from Rust's Standard library Solve common
synchronization problems or avoid synchronization using
atomic programming Build lock-free/wait-free structures
in Rust and understand their implementations in the
crates ecosystem Leverage Rust's memory model and type
system to build safety properties into your parallel
programs Understand the new features of the Rust
programming language to ease the writing of parallel
programs. Who this book is for. This book is aimed at
software engineers with a basic understanding of Rust
who want to exploit the parallel and concurrent nature
of modern computing environments, safely.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
subject = "Application software; Development; Computer
multitasking; Programming languages (Electronic
computers); Portable and handheld devices:
consumer/user guides; Mobile phones: consumer/user
guides; Parallel processing; Programming and scripting
languages: general; Computers; Programming; Parallel;
Hardware; Handheld Devices; Programming Languages; C;
Development; Computer multitasking; Programming
languages (Electronic computers)",
}
@InProceedings{Tsai:2018:RMH,
author = "P. Tsai and Y. L. Gan and D. Sanchez",
booktitle = "{2018 51st Annual IEEE\slash ACM International
Symposium on Microarchitecture (MICRO)}",
title = "Rethinking the Memory Hierarchy for Modern Languages",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "203--216",
year = "2018",
DOI = "https://doi.org/10.1109/MICRO.2018.00025",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Wang:2018:KFE,
author = "F. Wang and F. Song and M. Zhang and X. Zhu and J.
Zhang",
booktitle = "{2018 International Symposium on Theoretical Aspects
of Software Engineering (TASE)}",
title = "{KRust}: a Formal Executable Semantics of {Rust}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "44--51",
year = "2018",
DOI = "https://doi.org/10.1109/TASE.2018.00014",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Antelmi:2019:ERP,
author = "Alessia Antelmi and Gennaro Cordasco and Matteo D.
Auria and Daniele {De Vinco} and Alberto Negro and
Carmine Spagnuolo",
booktitle = "{Methods and Applications for Modeling and Simulation
of Complex Systems: 19th Asia Simulation Conference,
AsiaSim 2019, Singapore, October 30--November 1, 2019,
Proceedings}",
title = "On Evaluating {Rust} as a Programming Language for the
Future of Massive Agent-Based Simulations",
publisher = pub-SV,
address = pub-SV:adr,
pages = "15--28",
year = "2019",
DOI = "https://doi.org/10.1007/978-981-15-1078-6_2",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-981-15-1078-6_2",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Article{Astrauskas:2019:LRT,
author = "Vytautas Astrauskas and Peter M{\"u}ller and Federico
Poli and Alexander J. Summers",
title = "Leveraging {Rust} types for modular specification and
verification",
journal = j-PACMPL,
volume = "3",
number = "OOPSLA",
pages = "147:1--147:30",
month = oct,
year = "2019",
DOI = "https://doi.org/10.1145/3360573",
bibdate = "Fri Aug 7 19:22:30 MDT 2020",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/abs/10.1145/3360573",
abstract = "Rust's type system ensures memory safety: well-typed
Rust programs are guaranteed to not exhibit problems
such as dangling pointers, data races, and unexpected
side effects through aliased references. Ensuring
correctness properties beyond memory safety, for
instance, the guaranteed absence of assertion failures
or more-general functional correctness, requires static
program verification. For traditional system
programming languages, formal verification is
notoriously difficult and requires complex
specifications and logics to reason about pointers,
aliasing, and side effects on mutable state. This
complexity is a major obstacle to the more-widespread
verification of system software.\par
In this paper, we present a novel verification
technique that leverages Rust's type system to greatly
simplify the specification and verification of system
software written in Rust. We analyse information from
the Rust compiler and synthesise a corresponding core
proof for the program in a flavour of separation logic
tailored to automation. To verify correctness
properties beyond memory safety, users can annotate
Rust programs with specifications at the abstraction
level of Rust expressions; our technique weaves them
into the core proof to verify modularly whether these
specifications hold. Crucially, our proofs are
constructed and checked automatically without exposing
the underlying formal logic, allowing users to work
exclusively at the level of abstraction of the
programming language. As such, our work enables a new
kind of verification tool, with the potential to impact
a wide audience and allow the Rust community to benefit
from state-of-the-art verification techniques. We have
implemented our techniques for a subset of Rust; our
evaluation on several thousand functions from
widely-used Rust crates demonstrates its
effectiveness.",
acknowledgement = ack-nhfb,
articleno = "147",
fjournal = "Proceedings of the ACM on Programming Languages",
journal-URL = "https://pacmpl.acm.org/",
keywords = "Rust programming language",
}
@InProceedings{Baumgartner:2019:BDB,
author = "L. Baumg{\"a}rtner and J. H{\"o}chst and T. Meuser",
booktitle = "{2019 International Conference on Information and
Communication Technologies for Disaster Management
(ICT-DM)}",
title = "{B-DTN7}: Browser-based Disruption-tolerant Networking
via {Bundle Protocol 7}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "1--8",
year = "2019",
DOI = "https://doi.org/10.1109/ICT-DM47966.2019.9032944",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@TechReport{Beebe:2019:ARR,
author = "Nelson H. F. Beebe",
title = "{Appendix R}: {Rust} interface",
institution = inst-UTAH-MATH,
address = inst-UTAH-MATH:adr,
pages = "R-1--G-11 [994\slash 995]",
day = "13",
month = dec,
year = "2019",
bibdate = "Thu Jan 14 06:46:45 2021",
bibsource = "https://www.math.utah.edu/pub/bibnet/authors/b/beebe-nelson-h-f.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
abstract = "The Rust language was developed about the same time as
Go, and after the MathCW library. The syntax of the two
languages is quite different, but both languages have
similar goals of strong type safety and efficient
multithreading, both are compiled into native code, and
both promise upward compatibility for long-term
stability of software. Unlike Go, Rust does not supply
run-time garbage collection, but Rust's handling of
variables largely removes the need to free objects when
they are no longer needed. We address that topic later
in Section R.9 on page G-10. Nevertheless, the
experience of writing an interface from Go to the
MathCW library was helpful in making a companion
interface for Rust.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
ORCID-numbers = "Beebe, Nelson H. F./0000-0001-7281-4263",
xxnote = "This is an online supplement to
\cite{Beebe:2017:MFC}.",
}
@InProceedings{Chakraborty:2019:EAG,
author = "P. Chakraborty and R. Shahriyar and A. Iqbal",
booktitle = "{2019 IEEE 43rd Annual Computer Software and
Applications Conference (COMPSAC)}",
title = "Empirical Analysis of the Growth and Challenges of New
Programming Languages",
volume = "1",
number = "",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "191--196",
year = "2019",
DOI = "https://doi.org/10.1109/COMPSAC.2019.00034",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Emmerich:2019:CWN,
author = "P. Emmerich and S. Ellmann and F. Bonk and A. Egger
and E. G. S{\'a}nchez-Torija and T. G{\"u}nzel and S.
{di Luzio} and A. Obada and M. Stadlmeier and S. Voit
and G. Carle",
booktitle = "{2019 ACM\slash IEEE Symposium on Architectures for
Networking and Communications Systems (ANCS)}",
title = "The Case for Writing Network Drivers in High-Level
Programming Languages",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "1--13",
year = "2019",
DOI = "https://doi.org/10.1109/ANCS.2019.8901892",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Book{Klabnik:2019:RPL,
author = "Steve Klabnik and Carol Nichols",
title = "The {Rust} programming language",
publisher = pub-NO-STARCH,
address = pub-NO-STARCH:adr,
edition = "Second",
pages = "xxix + 526",
year = "2019",
ISBN = "1-0981-2253-4, 1-71850-044-0 (paperback)",
ISBN-13 = "978-1-0981-2253-9, 978-1-71850-044-0 (paperback)",
LCCN = "QA76.73.R87",
bibdate = "Fri Nov 8 05:59:02 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib;
https://doc.rust-lang.org/book",
URL = "http://proquest.safaribooksonline.com/?fpi=9781098122539;
https://nostarch.com/download/samples/RustProgrammingLanguage2018_Sample_ToC.pdf;
https://nostarch.com/Rust2018",
abstract = "\booktitle{The Rust Programming Language} is the
official book on Rust: an open source systems
programming language that helps you write faster, more
reliable software. Rust offers control over low-level
details (such as memory usage) in combination with
high-level ergonomics, eliminating the hassle
traditionally associated with low-level languages. The
authors of \booktitle{The Rust Programming Language},
members of the Rust Core Team, share their knowledge
and experience to show you how to take full advantage
of Rust's features-from installation to creating robust
and scalable programs. You'll begin with basics like
creating functions, choosing data types, and binding
variables and then move on to more advanced concepts,
such as: * Ownership and borrowing, lifetimes, and
traits * Using Rust's memory safety guarantees to build
fast, safe programs; * Testing, error handling, and
effective refactoring; * Generics, smart pointers,
multithreading, trait objects, and advanced pattern
matching; * Using Cargo, Rust's built-in package
manager, to build, test, and document your code and
manage dependencies; * How best to use Rust's advanced
compiler with compiler-led programming techniques
You'll find plenty of code examples throughout the
book, as well as three chapters dedicated to building
complete projects to test your learning: a number
guessing game, a Rust implementation of a command line
tool, and a multithreaded server. New to this edition:
An extended section on Rust macros, an expanded chapter
on modules, and appendixes on Rust development tools
and editions.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
subject = "Rust (Computer program language); Computer
programming; Computer programming.; Rust (Computer
program language)",
tableofcontents = "1: Getting started \\
2: Programming a guessing game \\
3: Common programming concepts \\
4: Understanding ownership \\
5: Using structs to structure related data \\
6: Enums and pattern matching \\
7: Managing growing projects with packages, crates, and
modules \\
8: Common collections \\
9: Error handling \\
10: Generic types, traits, and lifetimes \\
11: Writing automated tests \\
12: An I/O project: building a command line program \\
13: Functional language features: iterators and
closures \\
14: More about Cargo and Crates.io \\
15: Smart pointers \\
16: Fearless concurrency \\
17: Object-oriented programming features of Rust \\
18: Patterns and matching \\
19: Advanced features \\
20: Final project: building a multithreaded web server
\\
Appendix A: Keywords \\
Appendix B: Operators and Symbols \\
Appendix C: Derivable Traits \\
Appendix D: Useful Development Tools \\
Appendix E: Editions \\
Index",
}
@Book{Kolodin:2019:HMR,
author = "Denis Kolodin",
title = "Hands-on Microservices with {Rust}: Build, Test, and
Deploy Scalable and Reactive Microservices with {Rust
2018}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "511 (est.)",
year = "2019",
ISBN = "1-78934-198-1, 1-78934-275-9",
ISBN-13 = "978-1-78934-198-0, 978-1-78934-275-8",
LCCN = "QA76.73.R87",
bibdate = "Tue Dec 10 06:02:23 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://proquest.safaribooksonline.com/?fpi=9781789342758",
abstract = "A comprehensive guide in developing and deploying high
performance microservices with Rust Key Features Start
your microservices journey and get a broader
perspective on microservices development using RUST
2018, Build, deploy, and test microservices using AWS
Explore advanced techniques for developing
microservices such as actor model, Requests Routing,
and threads Book Description Microservice architecture
is sweeping the world as the de facto pattern for
building web-based applications. Rust is a language
particularly well-suited for building microservices. It
is a new system programming language that offers a
practical and safe alternative to C. This book
describes web development using the Rust programming
language and will get you up and running with modern
web frameworks and crates with examples of RESTful
microservices creation. You will deep dive into
Reactive programming, and asynchronous programming, and
split your web application into a set of concurrent
actors. The book provides several HTTP-handling
examples with manageable memory allocations. You will
walk through stateless high-performance microservices,
which are ideally suitable for computation or caching
tasks, and look at stateful microservices, which are
filled with persistent data and database interactions.
As we move along, you will learn how to use Rust macros
to describe business or protocol entities of our
application and compile them into native structs, which
will be performed at full speed with the help of the
server's CPU. Finally, you will be taken through
examples of how to test and debug microservices and
pack them into a tiny monolithic binary or put them
into a container and deploy them to modern cloud
platforms such as AWS. What you will learn Get
acquainted with leveraging Rust web programming Get to
grips with various Rust crates, such as hyper, Tokio,
and Actix Explore RESTful microservices with Rust
Understand how to pack Rust code to a container using
Docker Familiarize yourself with Reactive microservices
Deploy your microservices to modern cloud platforms
such as AWS Who this book is for This book is for
developers who have basic knowledge of RUST, and want
to learn how to build, test, scale, and manage RUST
microservices. No prior experience of writing
microservices in RUST is assumed. Downloading the
example code for this book You can download the example
code files for all Packt books you have purchased from
your account at http://www.PacktPub.com.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
subject = "Rust (Computer program language); Application
software; Development; Web applications; Development.;
Rust (Computer program language); Web applications.",
}
@InProceedings{Kruppe:2019:ELL,
author = "R. Kruppe and J. Oppermann and L. Sommer and A. Koch",
booktitle = "{2019 IEEE\slash ACM International Symposium on Code
Generation and Optimization (CGO)}",
title = "Extending {LLVM} for Lightweight {SPMD} Vectorization:
Using {SIMD} and Vector Instructions Easily from Any
Language",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "278--279",
year = "2019",
DOI = "https://doi.org/10.1109/CGO.2019.8661165",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Article{Kyriakou:2019:ECC,
author = "Kyriakos-Ioannis D. Kyriakou and Nikolaos D. Tselikas
and Georgia M. Kapitsaki",
title = "Enhancing {C\slash C++} based {OSS} development and
discoverability with {CBRJS}: a
\pkg{Rust/Node.js/WebAssembly} framework for
repackaging legacy codebases",
journal = j-J-SYST-SOFTW,
volume = "157",
number = "??",
pages = "Article 110395",
month = nov,
year = "2019",
CODEN = "JSSODM",
DOI = "https://doi.org/10.1016/j.jss.2019.110395",
ISSN = "0164-1212 (print), 1873-1228 (electronic)",
ISSN-L = "0164-1212",
bibdate = "Wed Oct 16 07:06:25 MDT 2019",
bibsource = "https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://www.sciencedirect.com/science/article/pii/S0164121219301700",
abstract = "Since the appearance of the C programming language and
later C++, a plethora of libraries have been developed
in both languages. Unfortunately, discovering such Open
Source Software (OSS) components efficiently is not
always an easy task. Nonetheless, recent advancements
in OSS technologies present an opportunity to improve
the status quo. In this paper, we introduce a prototype
framework, which utilizes the Rust and JavaScript
programming languages, as well as their respective
ecosystems, alongside the WebAssembly state-of-the-art
Web standard, for achieving boosted exposure for
hard-to-find C/C++ OSS components, by taking advantage
of their package discovery and delivery channels. By
demonstrating how this system works, we show that this
methodology is capable of increasing the exposure of
such libraries, and providing a modernized stage for
further development and maintenance. Provided metrics
exhibit a more than twofold increase in downloads for a
re-packaged library, superior discoverability compared
to standard public OSS code repositories, as well as
evidence that Web browser vendors invest heavily in
optimizing the underlying runtime.",
acknowledgement = ack-nhfb,
fjournal = "Journal of Systems and Software",
journal-URL = "http://www.sciencedirect.com/science/journal/01641212",
keywords = "C/C++; JavaScript; Open source software; Rust
programming language; Software discoverability;
WebAssembly",
}
@InProceedings{Lindner:2019:VSF,
author = "M. Lindner and N. Fitinghoff and J. Eriksson and P.
Lindgren",
booktitle = "{2019 IEEE 17th International Conference on Industrial
Informatics (INDIN)}",
title = "Verification of Safety Functions Implemented in {Rust}
--- a Symbolic Execution based approach",
volume = "1",
number = "",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "432--439",
year = "2019",
DOI = "https://doi.org/10.1109/INDIN41052.2019.8972014",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Book{Matzinger:2019:HDS,
author = "Claus Matzinger",
title = "Hands-on Data Structures and Algorithms with {Rust}:
Learn Programming Techniques to Build Effective,
Maintainable, and Readable Code in {Rust 2018}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "vii + 298",
year = "2019",
ISBN = "1-78899-149-4",
ISBN-13 = "978-1-78899-149-0, 978-1-78899-552-8",
LCCN = "Q76.73.R87",
bibdate = "Tue Dec 10 06:05:05 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
subject = "Rust (Computer program language); Computer
programming; Computer algorithms; Computer algorithms;
Computer programming; Rust (Computer program
language)",
tableofcontents = "Hello Rust! \\
Cargo and crates \\
Storing efficiently \\
Lists, lists, and more lists \\
Robust trees \\
Exploring maps and sets \\
Collections in Rust \\
Algorithm evaluation \\
Ordering things \\
Finding stuff \\
Random and combinatorial \\
Algorithms of the standard library",
}
@Book{Matzinger:2019:RPC,
author = "Claus Matzinger",
title = "{Rust} Programming Cookbook: Explore the Latest
Features of {Rust 2018} for Building Fast and Secure
Apps",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "434",
year = "2019",
ISBN = "1-78953-066-0, 1-78953-174-8 (PDF e-book)",
ISBN-13 = "978-1-78953-066-7, 978-1-78953-174-9 (PDF e-book)",
LCCN = "QA76.73.R87",
bibdate = "Tue Dec 10 05:37:41 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
abstract = "Practical solutions to overcome challenges in creating
console and web applications and working with
systems-level and embedded code, network programming,
deep neural networks, and much more. Key Features Work
through recipes featuring advanced concepts such as
concurrency, unsafe code, and macros to migrate your
codebase to the Rust programming language Learn how to
run machine learning models with Rust Explore error
handling, macros, and modularization to write
maintainable code Book Description Rust 2018, Rust's
first major milestone since version 1.0, brings more
advancement in the Rust language. The \booktitle{Rust
Programming Cookbook} is a practical guide to help you
overcome challenges when writing Rust code. This Rust
book covers recipes for configuring Rust for different
environments and architectural designs, and provides
solutions to practical problems. It will also take you
through Rust's core concepts, enabling you to create
efficient, high-performance applications that use
features such as zero-cost abstractions and improved
memory management. As you progress, you'll delve into
more advanced topics, including channels and actors,
for building scalable, production-grade applications,
and even get to grips with error handling, macros, and
modularization to write maintainable code. You will
then learn how to overcome common roadblocks when using
Rust for systems programming, IoT, web development, and
network programming. Finally, you'll discover what Rust
2018 has to offer for embedded programmers. By the end
of the book, you'll have learned how to build fast and
safe applications and services using Rust. What you
will learn Understand how Rust provides unique
solutions to solve system programming language problems
Grasp the core concepts of Rust to develop fast and
safe applications Explore the possibility of
integrating Rust units into existing applications for
improved efficiency Discover how to achieve better
parallelism and security with Rust Write Python
extensions in Rust Compile external assembly files and
use the Foreign Function Interface (FFI) Build web
applications and services using Rust for high
performance Who this book is for The Rust cookbook is
for software developers looking to enhance their
knowledge of Rust and leverage its features using
modern programming practices. Familiarity with Rust
language is expected to get the most out of this
book.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not yet in my library.",
remark = "How to do it\ldots{}",
subject = "Rust (Computer program language); Computer
programming; Computer programming; Rust (Computer
program language)",
tableofcontents = "Cover \\
Title Page \\
Copyright and Credits \\
Dedication \\
About Packt \\
Foreword \\
Contributors \\
Table of Contents \\
Preface \\
Chapter 1: Starting Off with Rust \\
Setting up your environment \\
Getting ready \\
How to do it\ldots{} \\
Managing the Rust installation with rustup.rs \\
Installing Visual Studio Code and extensions \\
Troubleshooting \\
How it works\ldots{} \\
Working with the command line I/O \\
How to do it\ldots{} \\
How it works\ldots{} \\
Creating and using data types \\
How to do it\ldots{} \\
How it works\ldots{} \\
Controlling execution flow \\
How to do it\ldots{} \\
How it works\ldots{} \\
Splitting your code with crates and modules \\
Getting ready \\
How to do it\ldots{} \\
How it works\ldots{} \\
Writing tests and benchmarks \\
Getting ready \\
How to do it\ldots{} \\
How it works\ldots{} \\
Documenting your code \\
Getting ready \\
How to do it\ldots{} \\
How it works\ldots{} \\
Testing your documentation \\
Getting ready \\
How to do it\ldots{} \\
How it works\ldots{} \\
Sharing code among types \\
How to do it\ldots{} \\
How it works\ldots{} \\
Sequence types in Rust \\
How to do it\ldots{} \\
How it works\ldots{} \\
Debugging Rust \\
Getting ready \\
How to do it\ldots{} \\
How it works\ldots{} \\
Chapter 2: Going Further with Advanced Rust \\
Creating meaningful numbers with enums \\
How to do it\ldots{} \\
How it works\ldots{} \\
There is no null \\
How to do itHow it works\ldots{}Complex conditions with
pattern matching \\
How to do it\ldots{} \\
How it works\ldots{} \\
Implementing custom iterators \\
Getting ready \\
How to do it\ldots{} \\
How it works\ldots{} \\
Filtering and transforming sequences efficiently \\
Getting ready \\
How to do it\ldots{} \\
How it works\ldots{} \\
Reading memory the unsafe way \\
How to do it\ldots{} \\
How it works\ldots{} \\
Shared ownership \\
Getting ready \\
How to do it\ldots{} \\
How it works\ldots{} \\
Shared mutable ownership \\
Getting ready \\
How to do it\ldots{} \\
How it works\ldots{} \\
Referencing with explicit lifetimes \\
How to do it\ldots{} \\
How it works\ldots{} \\
Enforcing behavior with trait bounds \\
How to do it\ldots{} \\
How it works\ldots{} \\
Working with generic data types \\
How to do it\ldots{} \\
How it works\ldots{} \\
Chapter 3: Managing Projects with Cargo \\
Organizing large projects with workspaces \\
How to do it\ldots{} \\
How it works\ldots{} \\
Uploading to crates.io \\
Getting ready \\
How to do it\ldots{} \\
How it works\ldots{} \\
Using dependencies and external crates \\
How to do it\ldots{} \\
How it works\ldots{} \\
See also\ldots{} \\
Extending cargo with sub-commands \\
Getting ready \\
How to do it\ldots{} \\
How it works\ldots{} \\
Testing your project with cargo \\
How to do it\ldots{} \\
How it works\ldots{} \\
Continuous integration with cargo \\
Getting ready \\
How to do it \\
How it works\ldots{} \\
Customizing the build \\
How to do it\ldots{} \\
How it works\ldots{} \\
Chapter 4: Fearless Concurrency \\
Moving data into new threads \\
How to do it\ldots{} \\
How it works\ldots{} \\
Managing multiple threads \\
How to do it\ldots{} \\
How it works\ldots{} \\
Using channels to communicate between threads \\
How to do it\ldots{} \\
How it works\ldots{} \\
Sharing mutable states \\
How to do it\ldots{} \\
How it works\ldots{} \\
Multiprocessing in Rust \\
How to do it\ldots{} \\
How it works\ldots{} \\
Making sequential code parallel \\
How to do it\ldots{} \\
How it works\ldots{} \\
Concurrent data processing in vectors \\
How to do it\ldots{} \\
How it works\ldots{} \\
Shared immutable states",
}
@InCollection{Modrzyk:2019:WR,
author = "Nicolas Modrzyk",
booktitle = "{Building Telegram Bots: Develop Bots in 12
Programming Languages using the Telegram Bot API}",
title = "Week 4: {Rust}",
publisher = pub-SV,
address = pub-SV:adr,
pages = "57--84",
year = "2019",
DOI = "https://doi.org/10.1007/978-1-4842-4197-4_4",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-1-4842-4197-4_4",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Pinho:2019:TRC,
author = "A. Pinho and L. Couto and J. Oliveira",
booktitle = "{2019 IEEE International Symposium on Software
Reliability Engineering Workshops (ISSREW)}",
title = "Towards {Rust} for Critical Systems",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "19--24",
year = "2019",
DOI = "https://doi.org/10.1109/ISSREW.2019.00036",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Pipek:2019:RCI,
author = "T. Pipek and M. Pirker",
booktitle = "{2019 International Conference on Software Security
and Assurance (ICSSA)}",
title = "Revisiting the Challenges of Input Parsing for Robust
and Secure Software",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "41--45",
year = "2019",
DOI = "https://doi.org/10.1109/ICSSA48308.2019.00012",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Book{Sharma:2019:CRP,
author = "Rahul Sharma and Vesa Kaihlavirta and Claus
Matzinger",
title = "The Complete {Rust} Programming Reference Guide:
Design, Develop, and Deploy Effective Software Systems
Using the Advanced Constructs of Rust",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "xii + 679",
year = "2019",
ISBN = "1-83882-810-9",
ISBN-13 = "978-1-83882-810-3",
LCCN = "????",
bibdate = "Tue Dec 10 05:51:46 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
}
@Book{Sharma:2019:MRL,
author = "Rahul Sharma and Vesa Kaihlavirta",
title = "Mastering {Rust}: Learn About Memory Safety, Type
System, Concurrency, and the New Features of {Rust
2018} Edition",
publisher = pub-PACKT,
address = pub-PACKT:adr,
edition = "Second",
pages = "543 (est.)",
year = "2019",
ISBN = "1-78934-118-3, 1-78934-657-6 (paperback)",
ISBN-13 = "978-1-78934-118-8, 978-1-78934-657-2 (paperback)",
LCCN = "QA76.73.R87",
bibdate = "Tue Dec 10 05:16:44 MST 2019",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://proquest.safaribooksonline.com/?fpi=9781789346572",
abstract = "Rust is an empowering language that provides a rare
combination of safety, speed, and zero-cost
abstractions. \booktitle{Mastering Rust} --- Second
Edition is filled with clear and simple explanations of
the language features along with real-world examples,
showing you how you can build robust, scalable, and
reliable programs. This second edition of the book
improves upon the previous one and touches on all
aspects that make Rust a great language. We have
included the features from latest Rust 2018 edition
such as the new module system, the smarter compiler,
helpful error messages, and the stable procedural
macros. You'll learn how Rust can be used for systems
programming, network programming, and even on the web.
You'll also learn techniques such as writing
memory-safe code, building idiomatic Rust libraries,
writing efficient asynchronous networking code, and
advanced macros. The book contains a mix of theory and
hands-on tasks so you acquire the skills as well as the
knowledge, and it also provides exercises to hammer the
concepts in. After reading this book, you will be able
to implement Rust for your enterprise projects, write
better tests and documentation, design for performance,
and write idiomatic Rust code. What you will learn
Write generic and type-safe code by using Rust's
powerful type system How memory safety works without
garbage collection Know the different strategies in
error handling and when to use them Learn how to use
concurrency primitives such as threads and channels Use
advanced macros to reduce boilerplate code Create
efficient web applications with the Actix-web framework
Use Diesel for type-safe database interactions in your
web application Who this book is for The book is aimed
at beginner and intermediate programmers who already
have familiarity with any imperative language and have
only heard of Rust as a new language. If you are a
developer who wants to write robust, efficient and
maintainable software systems and want to become
proficient with Rust, this book is for you.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
libnote = "Not in my library.",
remark = "Previous edition published: 2017.",
subject = "Rust (Computer program language); Application
software; Development; Development.; Rust (Computer
program language)",
tableofcontents = "Preface / 1 \\
Chapter 1: Getting Started with Rust / 7 \\
What is Rust and why should you care? / 8 \\
Installing the Rust compiler and toolchain / 15 \\
Using rustup.rs / 15 \\
A tour of the language / 18 \\
Primitive types / 21 \\
Declaring variables and immutability / 22 \\
Functions / 23 \\
Closures / 25 \\
Strings / 26 \\
Conditionals and decision making / 27 \\
Match expressions / 29 \\
Loops / 30 \\
User-defined types / 32 \\
Structs / 33 \\
Enums / 35 \\
Functions and methods on types / 37 \\
Impl blocks on structs / 38 \\
Impl blocks for enums / 40 \\
Modules, imports, and use statements / 42 \\
Collections / 42 \\
Arrays / 43 \\
Tuples / 43 \\
Vectors / 44 \\
Hashmaps / 44 \\
Slices / 45 \\
Iterators / 47 \\
Exercise fixing the word counter / 48 \\
Summary / 49 \\
Chapter 2: Managing Projects with Cargo / 50 \\
Package managers / 51 \\
Modules / 51 \\
Nested modules / 52 \\
File as a module / 54 \\
Directory as module / 55 \\
Cargo and crates / 57 \\
Creating a new Cargo project / 59 \\
Cargo and dependencies / 61 \\
Running tests with Cargo / 63 \\
Running examples with Cargo / 66 \\
Cargo workspace / 66 \\
Extending Cargo and tools / 68 \\
Subcommands and Cargo installation / 68 \\
cargo-watch / 68 \\
cargo-edit / 69 \\
cargo-deb / 69 \\
cargo-outdated / 70 \\
Linting code with clippy / 70 \\
Exploring the manifest file Cargo.toml / 71 \\
Setting up a Rust development environment / 74 \\
Building a project with Cargo imgtool / 78 \\
Summary / 81 \\
Chapter 3: Tests, Documentation, and Benchmarks / 82
\\
Motivation for testing / 83 \\
Organizing tests / 84 \\
Testing primitives / 84 \\
Attributes / 85 \\
Assertion macros / 86 \\
Unit tests / 87 \\
First unit test / 87 \\
Running tests / 88 \\
Isolating test code / 88 \\
Failing tests / 90 \\
Ignoring tests / 90 \\
Integration tests / 91 \\
First integration test / 92 \\
Sharing common code / 93 \\
Documentation / 95 \\
Writing documentation / 95 \\
Generating and viewing documentation / 96 \\
Hosting documentation / 96 \\
Doc attributes / 97 \\
Documentation tests / 98 \\
Benchmarks / 99 \\
Built-in micro-benchmark harness / 100 \\
Benchmarking on stable Rust / 102 \\
Writing and testing a crate logic gate simulator / 105
\\
Continuous integration with Travis CI / 109 \\
Summary / 113 \\
Chapter 4: Types, Generics, and Traits / 114 \\
Type systems and why they matter / 114 \\
Generics / 116 \\
Creating generic types / 117 \\
Generic functions / 118 \\
Generic types / 119 \\
Generic implementations / 119 \\
Using generics / 121 \\
Abstracting behavior with traits / 123 \\
Traits / 124 \\
The many forms of traits / 130 \\
Marker traits / 130 \\
Simple traits / 131 \\
Generic traits / 131 \\
Associated type traits / 131 \\
Inherited traits / 132 \\
Using traits with generics trait bounds / 132 \\
Trait bounds on types / 136 \\
Trait bounds on generic functions and impl blocks / 137
\\
Using + to compose traits as bounds / 138 \\
Trait bounds with impl trait syntax / 139 \\
Exploring standard library traits / 141 \\
True polymorphism using trait objects / 148 \\
Dispatch / 149 \\
Trait objects / 150 \\
Summary / 152 \\
Chapter 5: Memory Management and Safety / 153 \\
Programs and memory / 154 \\
How do programs use memory? / 156 \\
Memory management and its kinds / 157 \\
Approaches to memory allocation / 158 \\
The stack / 158 \\
The heap / 160 \\
Memory management pitfalls / 162 \\
Memory safety / 162 \\
Trifecta of memory safety / 165 \\
Ownership / 165 \\
A brief on scopes / 167 \\
Move and copy semantics / 169 \\
Duplicating types via traits / 170 \\
Copy / 171 \\
Clone / 171 \\
Ownership in action / 173 \\
Borrowing / 178 \\
Borrowing rules / 180 \\
Borrowing in action / 181 \\
Method types based on borrowing / 183 \\
Lifetimes / 184 \\
Lifetime parameters / 185 \\
Lifetime elision and the rules / 186 \\
Lifetimes in user defined types / 188 \\
Lifetime in impl blocks / 188 \\
Multiple lifetimes / 189 \\
Lifetime subtyping / 189 \\
Specifying lifetime bounds on generic types / 190 \\
Pointer types in Rust / 192 \\
References safe pointers / 193 \\
Raw pointers / 193 \\
Smart pointers / 194 \\
Drop / 194 \\
Deref and DerefMut / 196 \\
Types of smart pointers / 196 \\
Box<T> / 197 \\
Reference counted smart pointers / 199 \\
Rc<T> / 200 \\
Interior mutability / 205 \\
Cell<T> / 205 \\
RefCell<T> / 207 \\
Uses of interior mutability / 208 \\
Summary / 210 \\
Chapter 6: Error Handling / 211 \\
Error handling prelude / 211 \\
Recoverable errors / 214 \\
Option / 214 \\
Result / 218 \\
Combinators on Option/Result / 222 \\
Common combinators / 223 \\
Using combinators / 224 \\
Converting between Option and Result / 226 \\
Early returns and the ? operator / 226 \\
Non-recoverable errors / 228 \\
User-friendly panics / 232 \\
Custom errors and the Error trait / 232 \\
Summary / 237 \\
Chapter 7: Advanced Concepts / 238 \\
Type system tidbits / 238 \\
Blocks and expressions / 239 \\
Let statements / 242 \\
Loop as an expression / 247 \\
Type clarity and sign distinction in numeric types /
248 \\
Type inference / 250 \\
Type aliases / 252 \\
Strings / 253 \\
Owned strings String / 254 \\
Borrowed strings &str / 256 \\
Slicing and dicing strings / 258 \\
Using strings in functions / 259 \\
Joining strings / 260 \\
When to use &str versus String ? / 261 \\
Global values / 261 \\
Constants / 262 \\
Statics / 262 \\
Compile time functions const fn / 263 \\
Dynamic statics using the lazy_static! macro / 264 \\
Iterators / 265 \\
Implementing a custom iterator / 266 \\
Advanced types / 270 \\
Unsized types / 270 \\
Function types / 271 \\
Never type ! and diverging functions / 272 \\
Unions / 272 \\
Cow / 273 \\
Advanced traits / 274 \\
Sized and ?Sized / 274 \\
Borrow and AsRef / 274 \\
ToOwned / 274 \\
From and Into / 275 \\
Trait objects and object safety / 275 \\
Universal function call syntax / 276 \\
Trait rules / 277 \\
Closures in depth / 277 \\
Fn closures / 278 \\
FnMut closures / 278 \\
FnOnce closures / 279 \\
Consts in structs, enums, and traits / 280 \\
Modules, paths, and imports / 281 \\
Imports / 282 \\
Re-exports / 282 \\
Selective privacy / 283 \\
Advanced match patterns and guards / 283 \\
Match guards / 284 \\
Advanced let destructure / 284 \\
Casting and coercion / 285 \\
Types and memory / 286 \\
Memory alignment / 286 \\
Exploring the std::mem module / 287 \\
Serialization and deserialization using serde / 289 \\
Summary / 290 \\
Chapter 8: Concurrency / 291 \\
Program execution models / 292 \\
Concurrency / 293 \\
Approaches to concurrency / 294 \\
Kernel-based / 294 \\
User-level / 295 \\
Pitfalls / 296 \\
Concurrency in Rust / 298 \\
Thread basics / 299 \\
Customizing threads / 301 \\
Accessing data from threads / 302 \\
Concurrency models with threads / 304 \\
Shared state model / 304 \\
Shared ownership with Arc / 306 \\
Mutating shared data from threads / 307 \\
Mutex / 308 \\
Shared mutability with Arc and Mutex / 309 \\
RwLock / 310 \\
Communicating through message passing / 311 \\
Asynchronous channels / 311 \\
Synchronous channels / 313 \\
thread-safety in Rust / 314 \\
What is thread-safety? / 314 \\
Traits for thread-safety / 315 \\
Send / 315 \\
Sync / 316 \\
Concurrency using the actor model / 316 \\
Other crates / 319 \\
Summary / 319 \\
Chapter 9: Metaprogramming with Macros / 320 \\
What is metaprogramming? / 320 \\
When to use and not use Rust macros / 323 \\
Macros in Rust and their types / 324 \\
Types of macros / 327 \\
Creating your first macro with macro_rules! / 328 \\
Built-in macros in the standard library / 331 \\
macro_rules! token types / 332 \\
Repetitions in macros / 336 \\
A more involved macro writing a DSL for HashMap
initialization / 337 \\
Macro use case writing tests / 339 \\
Exercises / 341 \\
Procedural macros / 342 \\
Derive macros / 343 \\
Debugging macros / 349 \\
Useful procedural macro crates / 351 \\
Summary / 351 \\
Chapter 10: Unsafe Rust and Foreign Function Interfaces
/ 352 \\
What is safe and unsafe really? / 352 \\
Unsafe functions and blocks / 357 \\
Unsafe traits and implementations / 360 \\
Calling C code from Rust / 362 \\
Calling Rust code from C / 366 \\
Using external C/C++ libraries from Rust / 369 \\
Creating native Python extensions with PyO3 / 372 \\
Creating native extensions in Rust for Node.js / 375
\\
Summary / 380 \\
Chapter 11: Logging / 381 \\
What is logging and why do we need it? / 381 \\
The need for logging frameworks / 383 \\
Logging frameworks and their key features / 384 \\
Approaches to logging / 386 \\
Unstructured logging / 386 \\
Structured logging / 386 \\
Logging in Rust / 387 \\
log Rust's logging facade / 388 \\
The env_logger / 390 \\
log4rs / 391 \\
Structured logging using slog / 393 \\
Summary / 399 \\
Chapter 12: Network Programming in Rust / 400 \\
Network programming prelude / 400 \\
Synchronous network I/O / 403 \\
Building a synchronous redis server / 404 \\
Asynchronous network I/O / 411 \\
Async abstractions in Rust / 412 \\
Mio / 412 \\
Futures / 413 \\
Tokio / 413 \\
Building an asynchronous redis server / 414 \\
Summary / 419 \\
Chapter 13: Building Web Applications with Rust / 420
\\
Web applications in Rust / 420 \\
Typed HTTP with Hyper / 421 \\
Hyper server APIs building a URL shortener / 422 \\
hyper as a client building a URL shortener client / 426
\\
Web frameworks / 428 \\
Actix-web basics / 429 \\
Building a bookmarks API using Actix-web / 429 \\
Summary / 440 \\
Chapter 14: Interacting with Databases in Rust / 441
\\
Why do we need data persistence? / 441 \\
SQLite / 443 \\
PostgreSQL / 449 \\
Connection pooling with r2d2 / 452 \\
Postgres and the diesel ORM / 455 \\
Summary / 462 \\
Chapter 15: Rust on the Web with WebAssembly / 463 \\
What is WebAssembly? / 463 \\
Design goals of WebAssembly / 466 \\
Getting started with WebAssembly / 467 \\
Trying it out online / 467 \\
Ways to generate WebAssembly / 468 \\
Rust and WebAssembly / 468 \\
Wasm-bindgen / 469 \\
Other WebAssembly projects / 476 \\
Rust / 477 \\
Other languages / 477 \\
Summary / 478 \\
Chapter 16: Building Desktop Applications with Rust /
479 \\
Introduction to GUI development / 480 \\
GTK+ framework / 481 \\
Building a hacker news app using gtk-rs / 482 \\
Exercise / 495 \\
Other emerging GUI frameworks / 495 \\
Summary / 496 \\
Chapter 17: Debugging / 497 \\
Introduction to debugging / 497 \\
Debuggers in general / 499 \\
Prerequisites for debugging / 499 \\
Setting up gdb / 500 \\
A sample program buggie / 501 \\
The gdb basics / 502 \\
Debugger integration with Visual Studio Code / 507 \\
RR debugger a quick overview / 513 \\
Summary / 516 \\
Other Books You May Enjoy / 517 \\
Index / 520",
}
@InProceedings{Shetty:2019:CCC,
author = "Nishanth Shetty and Nikhil Saldanha and M. N.
Thippeswamy",
booktitle = "{Emerging Research in Computing, Information,
Communication and Applications: ERCICA 2018, Volume
1}",
title = "{CRUST}: A {C/C++} to {Rust} Transpiler Using a
Nano-parser Methodology to Avoid {C/C++} Safety Issues
in Legacy Code",
publisher = pub-SV,
address = pub-SV:adr,
pages = "241--250",
year = "2019",
DOI = "https://doi.org/10.1007/978-981-13-5953-8_21",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-981-13-5953-8_21",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Article{Ardito:2020:RCA,
author = "Luca Ardito and Luca Barbato and Marco Castelluccio
and Riccardo Coppola and Calixte Denizet and Sylvestre
Ledru and Michele Valsesia",
title = "rust-code-analysis: a {Rust} library to analyze and
extract maintainability information from source codes",
journal = j-SOFTWAREX,
volume = "12",
pages = "100635",
year = "2020",
CODEN = "????",
DOI = "https://doi.org/10.1016/j.softx.2020.100635",
ISSN = "2352-7110",
ISSN-L = "2352-7110",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://www.sciencedirect.com/science/article/pii/S2352711020303484",
abstract = "The literature proposes many software metrics for
evaluating the source code non-functional properties,
such as its complexity and maintainability. The
literature also proposes several tools to compute those
properties on source codes developed with many
different software languages. However, the Rust
language emergence has not been paired by the community
s effort in developing parsers and tools able to
compute metrics for the Rust source code. Also, metrics
tools often fall short in providing immediate means of
comparing maintainability metrics between different
algorithms or coding languages. We hence introduce
rust-code-analysis, a Rust library that allows the
extraction of a set of eleven maintainability metrics
for ten different languages, including Rust.
rust-code-analysis, through the Abstract Syntax Tree
(AST) of a source file, allows the inspection of the
code structure, analyzing source code metrics at
different levels of granularity, and finding code
syntax errors before compiling time. The tool also
offers a command-line interface that allows exporting
the results in different formats. The possibility of
analyzing source codes written in different programming
languages enables simple and systematic comparisons
between the metrics produced from different empirical
and large-scale analysis sources.",
acknowledgement = ack-nhfb,
fjournal = "SoftwareX",
journal-URL = "https://www.sciencedirect.com/journal/softwarex/issues",
keywords = "Algorithm, Software metrics, Software maintainability,
Software quality",
}
@Article{Astrauskas:2020:HDP,
author = "Vytautas Astrauskas and Christoph Matheja and Federico
Poli and Peter M{\"u}ller and Alexander J. Summers",
title = "How do programmers use unsafe {Rust}?",
journal = j-PACMPL,
volume = "4",
number = "OOPSLA",
pages = "136:1--136:27",
month = nov,
year = "2020",
DOI = "https://doi.org/10.1145/3428204",
bibdate = "Tue Mar 30 08:10:50 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3428204",
abstract = "Rust's ownership type system enforces a strict
discipline on how memory locations are accessed and
shared. This discipline allows the compiler to
statically prevent memory errors, data races,
inadvertent side effects through aliasing, and other
errors hat frequently occur in conventional imperative
programs. However, the restrictions imposed by Rust s
type system make it difficult or impossible to
implement certain designs, such as data structures that
require aliasing (e.g. doubly-linked lists and shared
caches). To work around this limitation, Rust allows
code blocks to be declared as unsafe and thereby
exempted from certain restrictions of the type system,
for instance, to manipulate C-style raw pointers.
Ensuring the safety of unsafe code is the
responsibility of the programmer. However, an important
assumption of the Rust language, which we dub the Rust
hypothesis, is that programmers use Rust by following
three main principles: use unsafe code sparingly, make
it easy to review, and hide it behind a safe
abstraction such that client code can be written in
safe Rust.\par
Understanding how Rust programmers use unsafe code and,
in particular, whether the Rust hypothesis holds is
essential for Rust developers and testers, language and
library designers, as well as tool developers. This
paper studies empirically how unsafe code is used in
practice by analysing a large corpus of Rust projects
to assess the validity of the Rust hypothesis and to
classify the purpose of unsafe code. We identify
queries that can be answered by automatically
inspecting the program s source code, its intermediate
representation MIR, as well as type information
provided by the Rust compiler; we complement the
results by manual code inspection. Our study supports
the Rust hypothesis partially: While most unsafe code
is simple and well-encapsulated, unsafe features are
used extensively, especially for interoperability with
other languages.",
acknowledgement = ack-nhfb,
articleno = "136",
fjournal = "Proceedings of the ACM on Programming Languages",
journal-URL = "https://pacmpl.acm.org/",
keywords = "Rust programming language",
}
@Book{Bhattacharjee:2020:PML,
author = "Joydeep Bhattacharjee",
title = "Practical Machine Learning with {Rust}: Creating
Intelligent Applications in {Rust}",
publisher = pub-SV,
address = pub-SV:adr,
pages = "xv + 354 + 28",
year = "2020",
DOI = "https://doi.org/10.1007/978-1-4842-5121-8",
ISBN = "1-4842-5120-2, 1-4842-5121-0 (e-book)",
ISBN-13 = "978-1-4842-5120-1, 978-1-4842-5121-8 (e-book)",
LCCN = "Q325.5; QA75.5-76.95",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/book/10.1007/978-1-4842-5121-8",
abstract = "Explore machine learning in Rust and learn about the
intricacies of creating machine learning applications.
This book begins by covering the important concepts of
machine learning such as supervised, unsupervised, and
reinforcement learning, and the basics of Rust.
Further, you'll dive into the more specific fields of
machine learning, such as computer vision and natural
language processing, and look at the Rust libraries
that help create applications for those domains. We
will also look at how to deploy these applications
either on site or over the cloud. After reading
Practical Machine Learning with Rust, you will have a
solid understanding of creating high computation
libraries using Rust. Armed with the knowledge of this
amazing language, you will be able to create
applications that are more performant, memory safe, and
less resource heavy. What You Will Learn. Write machine
learning algorithms in Rust. Use Rust libraries for
different tasks in machine learning. Create concise
Rust packages for your machine learning applications.
Implement NLP and computer vision in Rust. Deploy your
code in the cloud and on bare metal servers Who This
Book Is For Machine learning engineers and software
engineers interested in building machine learning
applications in Rust.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
tableofcontents = "1: Basics of Rust / 1--30 \\
2: Supervised Learning / 31--105 \\
3: Unsupervised and Reinforcement Learning / 107--139
\\
4: Working with Data / 141--186 \\
5: Natural Language Processing / 187--227 \\
6: Computer Vision / 229--276 \\
7: Machine Learning Domains / 277--313 \\
8: Using Rust Applications / 315--346 \\
Back Matter / 347--354",
}
@Article{Dang:2020:RMR,
author = "Hoang-Hai Dang and Jacques-Henri Jourdan and
Jan-Oliver Kaiser and Derek Dreyer",
title = "{RustBelt} meets relaxed memory",
journal = j-PACMPL,
volume = "4",
number = "POPL",
pages = "34:1--34:29",
month = jan,
year = "2020",
DOI = "https://doi.org/10.1145/3371102",
bibdate = "Fri Aug 7 18:46:52 MDT 2020",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/abs/10.1145/3371102",
abstract = "The Rust programming language supports safe systems
programming by means of a strong ownership-tracking
type system. In their prior work on RustBelt, Jung et
al. began the task of setting Rust's safety claims on a
more rigorous formal foundation. Specifically, they
used Iris, a Coq-based separation logic framework, to
build a machine-checked proof of semantic soundness for
a $ \lambda $-calculus model of Rust, as well as for a
number of widely-used Rust libraries that internally
employ unsafe language features. However, they also
made the significant simplifying assumption that the
language is sequentially consistent. In this paper, we
adapt RustBelt to account for the relaxed-memory
operations that concurrent Rust libraries actually use,
in the process uncovering a data race in the Arc
library. We focus on the most interesting technical
problem: how to reason about resource reclamation under
relaxed memory, using a logical construction we call
synchronized ghost state.",
acknowledgement = ack-nhfb,
articleno = "34",
fjournal = "Proceedings of the ACM on Programming Languages",
journal-URL = "https://pacmpl.acm.org/",
keywords = "Rust programming language",
}
@InProceedings{Evans:2020:RUS,
author = "Ana Nora Evans and Bradford Campbell and Mary Lou
Soffa",
booktitle = "{2020 IEEE\slash ACM 42nd International Conference on
Software Engineering (ICSE)}",
title = "Is {Rust} Used Safely by Software Developers?",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "246--257",
year = "2020",
DOI = "https://doi.org/10.1145/3377811.3380413",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Finkbeiner:2020:VRM,
author = "Bernd Finkbeiner and Stefan Oswald and Noemi Passing
and Maximilian Schwenger",
booktitle = "{Runtime Verification: 20th International Conference,
RV 2020, Los Angeles, CA, USA, October 6--9, 2020,
Proceedings}",
title = "Verified {Rust} Monitors for {Lola} Specifications",
publisher = pub-SV,
address = pub-SV:adr,
pages = "431--450",
year = "2020",
DOI = "https://doi.org/10.1007/978-3-030-60508-7_24",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-3-030-60508-7_24",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Article{Han:2020:SMF,
author = "J. Han and S. Kim and D. Cho and B. Choi and J. Ha and
D. Han",
title = "A Secure Middlebox Framework for Enabling Visibility
Over Multiple Encryption Protocols",
journal = j-IEEE-TRANS-NETWORKING,
volume = "28",
number = "6",
pages = "2727--2740",
year = "2020",
CODEN = "IEANEP",
DOI = "https://doi.org/10.1109/TNET.2020.3016785",
ISSN = "1063-6692 (print), 1558-2566 (electronic)",
ISSN-L = "1063-6692",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
fjournal = "IEEE\slash ACM Transactions on Networking",
journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J771",
keywords = "Rust programming language",
}
@Article{Jung:2020:SBA,
author = "Ralf Jung and Hoang-Hai Dang and Jeehoon Kang and
Derek Dreyer",
title = "Stacked borrows: an aliasing model for {Rust}",
journal = j-PACMPL,
volume = "4",
number = "POPL",
pages = "41:1--41:32",
month = jan,
year = "2020",
DOI = "https://doi.org/10.1145/3371109",
bibdate = "Fri Aug 7 18:46:52 MDT 2020",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/abs/10.1145/3371109",
abstract = "Type systems are useful not just for the safety
guarantees they provide, but also for helping compilers
generate more efficient code by simplifying important
program analyses. In Rust, the type system imposes a
strict discipline on pointer aliasing, and it is an
express goal of the Rust compiler developers to make
use of that alias information for the purpose of
program optimizations that reorder memory accesses. The
problem is that Rust also supports unsafe code, and
programmers can write unsafe code that bypasses the
usual compiler checks to violate the aliasing
discipline. To strike a balance between optimizations
and unsafe code, the language needs to provide a set of
rules such that unsafe code authors can be sure, if
they are following these rules, that the compiler will
preserve the semantics of their code despite all the
optimizations it is doing.
In this work, we propose Stacked Borrows, an
operational semantics for memory accesses in Rust.
Stacked Borrows defines an aliasing discipline and
declares programs violating it to have undefined
behavior, meaning the compiler does not have to
consider such programs when performing optimizations.
We give formal proofs (mechanized in Coq) showing that
this rules out enough programs to enable optimizations
that reorder memory accesses around unknown code and
function calls, based solely on intraprocedural
reasoning. We also implemented this operational model
in an interpreter for Rust and ran large parts of the
Rust standard library test suite in the interpreter to
validate that the model permits enough real-world
unsafe Rust code.",
acknowledgement = ack-nhfb,
articleno = "41",
fjournal = "Proceedings of the ACM on Programming Languages",
journal-URL = "https://pacmpl.acm.org/",
keywords = "Rust programming language",
}
@PhdThesis{Jung:2020:UER,
author = "Ralf Jung",
title = "Understanding and Evolving the {Rust} Programming
Language",
type = "{Doktors der Ingenieurwissenschaften}",
school = "{Fakult{\"a}t f{\"u}r Mathematik und Informatik der
Universit{\"a}t des Saarlandes}",
address = "Saarbr{\"u}cken, Germany",
pages = "x + 387",
month = aug,
year = "2020",
bibdate = "Mon Sep 26 08:59:36 2022",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://research.ralfj.de/phd/thesis-print.pdf",
abstract = "Rust is a young systems programming language that aims
to fill the gap between \emph{high-level languages} ---
which provide strong static guarantees like memory and
thread safety --- and \emph{low-level languages} ---
which give the programmer fine-grained control over
data layout and memory management. This dissertation
presents two projects establishing the first formal
foundations for Rust, enabling us to better
\emph{understand} and \emph{evolve} this important
language: \emph{RustBelt} and \emph{Stacked
Borrows}.\par
\emph{RustBelt} is a formal model of Rust's type
system, together with a soundness proof establishing
memory and thread safety. The model is designed to
verify the safety of a number of intricate APIs from
the Rust standard library, despite the fact that the
implementations of these APIs use \emph{unsafe}
language features.\par
Stacked Borrows is a proposed extension of the Rust
specification, which enables the compiler to use the
strong aliasing information in Rust's types to better
analyze and optimize the code it is compiling. The
adequacy of this specification is evaluated not only
formally, but also by running real Rust code in an
instrumented version of Rust's \emph{Miri} interpreter
that implements the Stacked Borrows
semantics.\par
RustBelt is built on top of \emph{Iris}, a
language-agnostic framework, implemented in the Coq
proof assistant, for building higher-order concurrent
separation logics. This dissertation begins by giving
an introduction to Iris, and explaining how Iris
enables the derivation of complex high-level reasoning
principles from a few simple ingredients. In RustBelt,
this technique is exploited crucially to introduce the
\emph{lifetime logic}, which provides a novel
separation-logic account of borrowing, a key
distinguishing feature of the Rust type system",
acknowledgement = ack-nhfb,
}
@InProceedings{Lagaillardie:2020:IMS,
author = "Nicolas Lagaillardie and Rumyana Neykova and Nobuko
Yoshida",
booktitle = "{Coordination Models and Languages: 2nd IFIP WG 6.1
International Conference, COORDINATION 2020, Held as
Part of the 15th International Federated Conference on
Distributed Computing Techniques, DisCoTec 2020,
Valletta, Malta, June 15--19, 2020, Proceedings}",
title = "Implementing Multiparty Session Types in {Rust}",
publisher = pub-SV,
address = pub-SV:adr,
pages = "127--136",
year = "2020",
DOI = "https://doi.org/10.1007/978-3-030-50029-0_8",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-3-030-50029-0_8",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Lankes:2020:RSR,
author = "Stefan Lankes and Jonathan Klimt and Jens Breitbart
and Simon Pickartz",
booktitle = "{High Performance Computing: ISC High Performance 2020
International Workshops, Frankfurt, Germany, June
21--25, 2020, Revised Selected Papers}",
title = "{RustyHermit}: A Scalable, {Rust}-Based Virtual
Execution Environment",
publisher = pub-SV,
address = pub-SV:adr,
pages = "331--342",
year = "2020",
DOI = "https://doi.org/10.1007/978-3-030-59851-8_22",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-3-030-59851-8_22",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Liu:2020:SUR,
author = "P. Liu and G. Zhao and J. Huang",
booktitle = "{2020 IEEE\slash ACM 42nd International Conference on
Software Engineering (ICSE)}",
title = "Securing UnSafe {Rust} Programs with {XRust}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "234--245",
year = "2020",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Lunnikivi:2020:TPR,
author = "Henri Lunnikivi and Kai Jylkk{\"a}Timo
H{\"a}m{\"a}l{\"a}inen",
booktitle = "{Embedded Computer Systems: Architectures, Modeling,
and Simulation: 20th International Conference, SAMOS
2020, Samos, Greece, July 5--9, 2020, Proceedings}",
title = "Transpiling {Python} to {Rust} for Optimized
Performance",
publisher = pub-SV,
address = pub-SV:adr,
pages = "127--138",
year = "2020",
DOI = "https://doi.org/10.1007/978-3-030-60939-9_9",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/python.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-3-030-60939-9_9",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InCollection{Lyu:2020:PCR,
author = "Shing Lyu",
booktitle = "{Practical Rust Projects: Building Game, Physical
Computing, and Machine Learning Applications}",
title = "Physical Computing in {Rust}",
publisher = pub-SV,
address = pub-SV:adr,
pages = "155--185",
year = "2020",
DOI = "https://doi.org/10.1007/978-1-4842-5599-5_5",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-1-4842-5599-5_5",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Book{Lyu:2020:PRP,
author = "Shing Lyu",
title = "Practical {Rust} Projects",
publisher = pub-APRESS,
address = pub-APRESS:adr,
pages = "xiii + 257 + 56 + 42",
year = "2020",
DOI = "https://doi.org/10.1007/978-1-4842-5599-5",
ISBN = "1-4842-5598-4, 1-4842-5599-2 (e-book)",
ISBN-13 = "978-1-4842-5598-8, 978-1-4842-5599-5 (e-book)",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/book/10.1007/978-1-4842-5599-5",
abstract = "Go beyond the basics and build complete applications
using the Rust programming language. The applications
in this book include a high-performance web client, a
microcontroller (for a robot, for example), a game, an
app that runs on Android, and an application that
incorporates AI and machine learning. Each chapter will
be organized in the following format: what this kind of
application looks like; requirements and user stories
of our example program; an introduction to the Rust
libraries used; the actual implementation of the
example program, including common pitfalls and their
solutions; and a brief comparison of libraries for
building each application, if there is no clear winner.
Practical Rust Projects will open your eyes to the
world of practical applications of Rust. After reading
the book, you will be able to apply your Rust knowledge
to build your own projects. You will: Write Rust code
that runs on microcontrollers Build a 2D game Create
Rust-based mobile Android applications Use Rust to
build AI and machine learning applications.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
tableofcontents = "1: Introduction \\
2: Building a Command-Line Program \\
3: Creating Graphical User Interfaces (GUIs) \\
4: Building a Game \\
5: Programming Embedded Devices \\
6: Artificial Intelligence and Machine Learning \\
7: Advanced Topics",
}
@InCollection{Lyu:2020:WEC,
author = "Shing Lyu",
booktitle = "{Practical Rust Projects: Building Game, Physical
Computing, and Machine Learning Applications}",
title = "What Else Can You Do with {Rust}?",
publisher = pub-SV,
address = pub-SV:adr,
pages = "237--250",
year = "2020",
DOI = "https://doi.org/10.1007/978-1-4842-5599-5_7",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-1-4842-5599-5_7",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InCollection{Lyu:2020:WWR,
author = "Shing Lyu",
booktitle = "{Practical Rust Projects: Building Game, Physical
Computing, and Machine Learning Applications}",
title = "Welcome to the World of {Rust}",
publisher = pub-SV,
address = pub-SV:adr,
pages = "1--8",
year = "2020",
DOI = "https://doi.org/10.1007/978-1-4842-5599-5_1",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-1-4842-5599-5_1",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Matsushita:2020:RCB,
author = "Yusuke Matsushita and Takeshi Tsukada and Naoki
Kobayashi",
booktitle = "{Programming Languages and Systems: 29th European
Symposium on Programming, ESOP 2020, Held as Part of
the European Joint Conferences on Theory and Practice
of Software, ETAPS 2020, Dublin, Ireland, April 25--30,
2020, Proceedings}",
title = "{RustHorn}: {CHC}-Based Verification for {Rust}
Programs",
publisher = pub-SV,
address = pub-SV:adr,
pages = "484--514",
year = "2020",
DOI = "https://doi.org/10.1007/978-3-030-44914-8_18",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-3-030-44914-8_18",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Article{Ning:2020:SMD,
author = "Pengxiang Ning and Boqin Qin",
title = "Stuck-me-not: A deadlock detector on blockchain
software in {Rust}",
journal = "Procedia Computer Science",
volume = "177",
pages = "599--604",
year = "2020",
DOI = "https://doi.org/10.1016/j.procs.2020.10.085",
ISSN = "1877-0509",
ISSN-L = "1877-0509",
bibdate = "Fri Apr 9 15:09:48 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
note = "The 11th International Conference on Emerging
Ubiquitous Systems and Pervasive Networks (EUSPN 2020)
/ The 10th International Conference on Current and
Future Trends of Information and Communication
Technologies in Healthcare (ICTH 2020) / Affiliated
Workshops",
URL = "https://www.sciencedirect.com/science/article/pii/S1877050920323565",
abstract = "Recent years have witnessed a boom in blockchain
systems written in Rust to utilize its efficiency and
safety. Unfortunately, deadlock bugs have become one of
the ubiquitous banes to these systems due to the heavy
use of locks for parallelism and the misunderstanding
of the lock mechanism in Rust. This paper analyzed the
common lock-related pitfalls in blockchain systems
written in Rust and proposed Stuck-me-not, the first
MIR-based static deadlock detector, for the most common
deadlock type: double-lock. We have discovered 29
previously unknown double-lock bugs in 11 popular
blockchain-related projects. We believe our work can
greatly improve the concurrency security of the current
blockchain ecosystem.",
acknowledgement = ack-nhfb,
journal-URL = "https://www.sciencedirect.com/journal/procedia-computer-science",
keywords = "deadlock detection; Rust programming language; static
analysis",
}
@Book{Nusairat:2020:RI,
author = "Joseph Faisal Nusairat",
title = "{Rust} for the {IoT}: Building {Internet of Things}
Apps with {Rust} and {Raspberry Pi}",
publisher = pub-APRESS,
address = pub-APRESS:adr,
year = "2020",
DOI = "https://doi.org/10.1007/978-1-4842-5860-6",
ISBN = "1-4842-5859-2, 1-4842-5860-6 (e-book)",
ISBN-13 = "978-1-4842-5859-0, 978-1-4842-5860-6 (e-book)",
LCCN = "QA76.73.R87 N87 2020",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/book/10.1007/978-1-4842-5860-6",
abstract = "Get started programming Rust applications for the
Internet of Things (IoT). This book is a programming
skills migration book that teaches you the Rust
programming techniques most useful for IoT
applications. You'll step through from server to board
development in creating a set of IoT applications. In
Rust for the IoT, you'll learn how to build a modern
server side application using Rust on the backend. Then
you'll use docker and Kubernetes to deploy these to a
managed cloud. Finally you will use a Raspberry Pi with
a SenseHat and Camera to capture the world around you
and send that information to the cloud. While you will
be able to follow along without any cloud or hardware,
to make the most of it we recommend a few cloud pieces
and hardware that is designed to integrate with the
software in this book. After reading and using this
book, you'll see how to apply Rust to the Internet of
Things. You will: Create a modern Rust backend complete
with handling eventual consistency and interacting via
a GraphQL interface Use the Raspberry PI to serve as a
cheap IoT device that one can easily deploy around the
house Capture temperature, video, and use the
interactive joystick to interact with the software
you've created Use OpenCV to perform facial detection
from the PIs camera and save that information to the
cloud. Create deployable helm charts for the cloud, and
for the device create complete ISOs that allow you to
easily deploy the Pi's OS + custom software.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
subject = "Rust (Computer program language); Internet of things;
Raspberry Pi (Computer); Computer hardware.; Web
programming.; Programming and scripting languages:
general.; Computers; Hardware; General.; Web; Web
Programming.; Programming Languages; Rust (Computer
program language); Raspberry Pi (Computer); Internet of
things.; Computer input-output equipment.; Computer
programming.; Programming languages (Electronic
computers)",
tableofcontents = "1: Introduction \\
2: Server Side \\
3: File Uploading and Parsing \\
4: Messaging and GraphQL \\
5: Performance \\
6: Security \\
7: Deployment \\
8: Sense HAT Part I \\
9: Sense HAT Part II \\
10: Camera \\
11: Integration \\
12: Final Thoughts",
}
@InProceedings{Romano:2020:WVT,
author = "A. Romano and W. Wang",
booktitle = "{2020 IEEE\slash ACM 42nd International Conference on
Software Engineering: Companion Proceedings
(ICSE-Companion)}",
title = "{WasmView}: Visual Testing for {WebAssembly}
Applications",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "13--16",
year = "2020",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://ieeexplore.ieee.org/document/9270402",
abstract = "WebAssembly is the newest language to arrive on the
web. It features a binary code format to serve as a
compilation target for native languages such as C, C++,
and Rust and allows native applications to be ported
for web usage. In the current implementation,
WebAssembly requires interaction with JavaScript at a
minimum to initialize and additionally to interact with
Web APIs. As a result, understanding the function calls
between WebAssembly and JavaScript is crucial for
testing, debugging, and maintaining applications
utilizing this new language. To this end, we develop a
tool, WasmView, to visualize function calls made
between WebAssembly and JavaScript in a web
application. WasmView also records the stack traces and
screenshots of applications. This tool can help in
supporting visual testing for interactive applications
and assisting refactoring for code updates. The demo
video for WasmView can be viewed at
https://youtu.be/kjKxL7L7zxI and the source code can be
found at
https://github.com/wasmview/wasmview.github.io.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Sydow:2020:TPG,
author = "S. Sydow and M. Nabelsee and S. Glesner and P.
Herber",
booktitle = "{2020 IEEE 32nd International Symposium on Computer
Architecture and High Performance Computing
(SBAC-PAD)}",
title = "Towards Profile-Guided Optimization for Safe and
Efficient Parallel Stream Processing in {Rust}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "289--296",
year = "2020",
DOI = "https://doi.org/10.1109/SBAC-PAD49847.2020.00047",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Takano:2020:ACC,
author = "K. Takano and T. Oda and M. Kohata",
booktitle = "{2020 IEEE 9th Global Conference on Consumer
Electronics (GCCE)}",
title = "Approach of a Coding Conventions for Warning and
Suggestion in Transpiler for {Rust} Convert to {RTL}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "789--790",
year = "2020",
DOI = "https://doi.org/10.1109/GCCE50665.2020.9292032",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Takano:2020:DDC,
author = "Keisuke Takano and Tetsuya Oda and Masaki Kohata",
booktitle = "{Advances in Internet, Data and Web Technologies: The
8th International Conference on Emerging Internet, Data
and Web Technologies (EIDWT-2020)}",
title = "Design of a {DSL} for Converting {Rust} Programming
Language into {RTL}",
publisher = pub-SV,
address = pub-SV:adr,
pages = "342--350",
year = "2020",
DOI = "https://doi.org/10.1007/978-3-030-39746-3_36",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/chapter/10.1007/978-3-030-39746-3_36",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Tomb:2020:STC,
author = "A. Tomb and S. Pernsteiner and M. Dodds",
booktitle = "{2020 IEEE Secure Development (SecDev)}",
title = "Symbolic Testing for {C} and {Rust}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "33--33",
year = "2020",
DOI = "https://doi.org/10.1109/SecDev45635.2020.00021",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@InProceedings{Wen:2020:WBE,
author = "E. Wen and G. Weber",
booktitle = "{2020 IEEE 13th International Conference on Cloud
Computing (CLOUD)}",
title = "{Wasmachine}: Bring the Edge up to Speed with a
{WebAssembly OS}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "353--360",
year = "2020",
DOI = "https://doi.org/10.1109/CLOUD49709.2020.00056",
bibdate = "Thu Apr 8 06:41:17 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
}
@Article{Ardito:2021:ERC,
author = "Luca Ardito and Luca Barbato and Riccardo Coppola and
Michele Valsesia",
title = "Evaluation of {Rust} code verbosity, understandability
and complexity",
journal = "{PeerJ} Computer Science",
volume = "7",
pages = "e406:1--e406:33",
month = feb,
year = "2021",
DOI = "https://doi.org/10.7717/peerj-cs.406",
ISSN = "2167-8359",
ISSN-L = "2167-8359",
bibdate = "Tue Jun 15 14:19:54 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
abstract = "Rust is an innovative programming language initially
implemented by Mozilla, developed to ensure high
performance, reliability, and productivity. The final
purpose of this study consists of applying a set of
common static software metrics to programs written in
Rust to assess the verbosity, understandability,
organization, complexity, and maintainability of the
language. To that extent, nine different
implementations of algorithms available in different
languages were selected. We computed a set of metrics
for Rust, comparing them with the ones obtained from C
and a set of object-oriented languages: C++, Python,
JavaScript, TypeScript. To parse the software artifacts
and compute the metrics, it was leveraged a tool called
rust-code-analysis that was extended with a software
module, written in Python, with the aim of uniforming
and comparing the results. The Rust code had an average
verbosity in terms of the raw size of the code. It
exposed the most structured source organization in
terms of the number of methods. Rust code had a better
Cyclomatic Complexity, Halstead Metrics, and
Maintainability Indexes than C and C++ but performed
worse than the other considered object-oriented
languages. Lastly, the Rust code exhibited the lowest
COGNITIVE complexity of all languages. The collected
measures prove that the Rust language has average
complexity and maintainability compared to a set of
popular languages. It is more easily maintainable and
less complex than the C and C++ languages, which can be
considered syntactically similar. These results, paired
with the memory safety and safe concurrency
characteristics of the language, can encourage wider
adoption of the language of Rust in substitution of the
C language in both the open-source and industrial
environments.",
acknowledgement = ack-nhfb,
journal-URL = "https://peerj.com/cs/",
}
@Book{Blandy:2021:PRF,
author = "Jim Blandy and Jason Orendorff and Leonora F. S.
Tindall",
title = "Programming {Rust}: Fast, Safe Systems Development",
publisher = pub-ORA,
address = pub-ORA:adr,
edition = "Second",
pages = "xix + 713",
year = "2021",
ISBN = "1-4920-5259-0",
ISBN-13 = "978-1-4920-5259-3 (paperback)",
LCCN = "QA76.73.R87 B58 2021",
bibdate = "Mon Jun 5 12:25:50 MDT 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/ora.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib;
z3950.loc.gov:7090/Voyager",
abstract = "Systems programming provides the foundation for the
world's computation. Developing performance-sensitive
code requires a programming language that puts
programmers in control of how memory, processor time,
and other system resources are used. The Rust systems
programming language combines that control with a
modern type system that catches broad classes of common
mistakes, from memory management errors to interthread
data races. With this practical guide, experienced
systems programmers will learn how to successfully
bridge the gap between performance and safety using
Rust. Jim Blandy, Jason Orendorff, and Leonora Tindall
demonstrate how Rust's features put programmers in
control over memory consumption and processor use by
combining predictable performance with memory safety
and trustworthy concurrency. This book explores: Rust's
fundamental data types, and the core concepts of
ownership and borrowing. Language basics including
error handling, crates and modules, structs, and enums.
How to write flexible, efficient code with traits and
generics. Rust's key power tools: closures, iterators,
and asynchronous programming. Collections, strings and
text, input and output, concurrency, macros, unsafe
code, and interfacing with foreign functions.",
acknowledgement = ack-nhfb,
subject = "Rust (Computer program language); Programming
languages (Electronic computers); Computer programming;
Rust (Langage de programmation); Programmation
(Informatique)",
tableofcontents = "Systems programmers can have nice things \\
A tour of Rust \\
Fundamental types \\
Ownership and more \\
References \\
Expressions \\
Error handling \\
Crates and modules \\
Structs \\
Enums and patterns \\
Traits and generics \\
Operator overloading \\
Utility traits \\
Closures \\
Iterators \\
Collections \\
Strings and text \\
Input and output \\
Concurrency \\
Asynchronous programming \\
Macros \\
Unsafe code \\
Foreign functions",
}
@Article{Emre:2021:TCS,
author = "Mehmet Emre and Ryan Schroeder and Kyle Dewey and Ben
Hardekopf",
title = "Translating {C} to safer {Rust}",
journal = j-PACMPL,
volume = "5",
number = "OOPSLA",
pages = "121:1--121:29",
month = oct,
year = "2021",
CODEN = "????",
DOI = "https://doi.org/10.1145/3485498",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Wed Mar 2 07:00:43 MST 2022",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3485498",
abstract = "Rust is a relatively new programming language that
targets efficient and safe systems-level applications.
It includes a sophisticated type system that allows for
provable memory- and thread-safety, and is explicitly
designed to take the place of unsafe \ldots{}",
acknowledgement = ack-nhfb,
articleno = "121",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@Article{Jung:2021:SSP,
author = "Ralf Jung and Jacques-Henri Jourdan and Robbert
Krebbers and Derek Dreyer",
title = "Safe systems programming in {Rust}",
journal = j-CACM,
volume = "64",
number = "4",
pages = "144--152",
month = apr,
year = "2021",
CODEN = "CACMA2",
DOI = "https://doi.org/10.1145/3418295",
ISSN = "0001-0782 (print), 1557-7317 (electronic)",
ISSN-L = "0001-0782",
bibdate = "Tue Mar 23 08:35:26 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/cacm2020.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3418295",
abstract = "The promise and the challenges of the first
industry-supported language to master the trade-off
between safety and control.",
acknowledgement = ack-nhfb,
fjournal = "Communications of the ACM",
journal-URL = "https://dl.acm.org/loi/cacm",
keywords = "Rust programming language",
}
@Book{Lyu:2021:PRW,
author = "Shing Lyu",
title = "Practical {Rust} {Web} Projects: Building Cloud and
{Web}-Based Applications",
publisher = pub-SV,
address = pub-SV:adr,
pages = "xi + 256 + 30",
year = "2021",
DOI = "https://doi.org/10.1007/978-1-4842-6589-5",
ISBN = "1-4842-6588-2, 1-4842-6589-0, 1-4842-6590-4",
ISBN-13 = "978-1-4842-6588-8 (print), 978-1-4842-6589-5,
978-1-4842-6590-1 (print)",
LCCN = "QA76.73.R87",
bibdate = "Fri Apr 9 11:06:38 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "http://link.springer.com/book/10.1007/978-1-4842-6589-5",
abstract = "Go beyond the basics of Rust and build web and
serverless cloud applications. The applications
explained in this practical book include web sites,
RESTful APIs, a real-time web chat application, and
frontend application with WebAssembly. Each chapter is
organized in the following format: what this kind of
application looks like; requirements for the example
program; an introduction to the Rust libraries used;
step-by-step implementation of the example program,
including common pitfalls and best practices; and a
brief comparison of libraries and frameworks in the
same domain. This book will open your eyes to the world
of practical web applications of Rust. After reading
the book, you will be able to apply your Rust knowledge
to build your own web projects. You will: Build dynamic
websites with databases Build RESTful APIs Write a
WebSocket server that can power a real-time chat app in
Rust Discover the benefits of serverless computing
using Amazon Web Service's Rust support Compile Rust to
WebAssembly for high-performance frontend
applications.",
acknowledgement = ack-nhfb,
keywords = "Rust programming language",
tableofcontents = "1: Rust in the Web World \\
2: Developing Websites \\
3: REST APIs \\
4: Chatting in Real Time with WebSocket \\
5: Going Serverless \\
6: High Performance Web Frontend using WebAssembly",
}
@Article{Matsushita:2021:RCB,
author = "Yusuke Matsushita and Takeshi Tsukada and Naoki
Kobayashi",
title = "{RustHorn}: {CHC}-based Verification for {Rust}
Programs",
journal = j-TOPLAS,
volume = "43",
number = "4",
pages = "15:1--15:54",
month = dec,
year = "2021",
CODEN = "ATPSDT",
DOI = "https://doi.org/10.1145/3462205",
ISSN = "0164-0925 (print), 1558-4593 (electronic)",
ISSN-L = "0164-0925",
bibdate = "Fri Dec 17 15:53:27 MST 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib;
https://www.math.utah.edu/pub/tex/bib/toplas.bib",
URL = "https://dl.acm.org/doi/10.1145/3462205",
abstract = "Reduction to satisfiability of constrained Horn
clauses (CHCs) is a widely studied approach to
automated program verification. Current CHC-based
methods, however, do not work very well for
pointer-manipulating programs, especially those with
dynamic memory allocation. This article presents a
novel reduction of pointer-manipulating Rust programs
into CHCs, which clears away pointers and memory states
by leveraging Rust's guarantees on permission. We
formalize our reduction for a simplified core of Rust
and prove its soundness and completeness. We have
implemented a prototype verifier for a subset of Rust
and confirmed the effectiveness of our method.",
acknowledgement = ack-nhfb,
articleno = "15",
fjournal = "ACM Transactions on Programming Languages and
Systems",
journal-URL = "https://dl.acm.org/loi/toplas",
}
@Book{McNamara:2021:RAS,
author = "Timothy Samuel McNamara",
title = "{Rust} in Action: Systems Programming Concepts and
Techniques",
publisher = pub-MANNING,
address = pub-MANNING:adr,
pages = "xxiii + 430",
year = "2021",
ISBN = "1-61729-455-1 (paperback)",
ISBN-13 = "978-1-61729-455-6 (paperback)",
LCCN = "QA76.73.R87 M36 2021",
bibdate = "Mon Jun 5 12:29:22 MDT 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib;
z3950.loc.gov:7090/Voyager",
abstract = "This well-written book will help you make the most of
what Rust has to offer. Ramnivas Laddad, author of
AspectJ in Action Rust in Action introduces the Rust
programming language by exploring numerous systems
programming concepts and techniques. You'll be learning
Rust by delving into how computers work under the hood.
You'll find yourself playing with persistent storage,
memory, networking and even tinkering with CPU
instructions. The book takes you through using Rust to
extend other applications and teaches you tricks to
write blindingly fast code. You'll also discover
parallel and concurrent programming. Filled to the brim
with real-life use cases and scenarios, you'll go
beyond the Rust syntax and see what Rust has to offer
in real-world use cases. about the technology Rust is
the perfect language for systems programming. It
delivers the low-level power of C along with rock-solid
safety features that let you code fearlessly. Ideal for
applications requiring concurrency, Rust programs are
compact, readable, and blazingly fast. Best of all,
Rust's famously smart compiler helps you avoid even
subtle coding errors. about the book Rust in Action is
a hands-on guide to systems programming with Rust.
Written for inquisitive programmers, it presents
real-world use cases that go far beyond syntax and
structure. You'll explore Rust implementations for file
manipulation, networking, and kernel-level programming
and discover awesome techniques for parallelism and
concurrency. Along the way, you'll master Rust's unique
borrow checker model for memory management without a
garbage collector. what's inside Elementary to advanced
Rust programming Practical examples from systems
programming Command-line, graphical and networked
applications about the audience For intermediate
programmers. No previous experience with Rust required.
about the author Tim McNamara uses Rust to build data
processing pipelines and generative art. He is an
expert in natural language processing and data
engineering. Engaging writing style and crisp,
easy-to-grasp examples help the reader get off the
ground in no time. Sumant Tambe, Linkedin Rust in
Action is remarkably polished! Christopher Haupt,
Swoogo Makes it easy to explore the language and get
going with it. Federico Hernandez, Meltwater I highly
recommend this book to those who want to learn Rust",
acknowledgement = ack-nhfb,
subject = "Rust (Computer program language); Computer
programming; Systems programming (Computer science);
Computer programming. $0 (OCoLC)fst00872390; Rust
(Computer program language) $0 (OCoLC)fst02002371;
Systems programming (Computer science) $0
(OCoLC)fst01141475",
tableofcontents = "Introducing Rust \\
Part 1, Rust language distinctives. Language
foundations \\
Compound data types \\
Lifetimes, ownership, and borrowing \\
Part 2, Demystifying systems programming \\
Data in depth \\
Memory \\
Files and storage \\
Networking \\
Time and timekeeping \\
Processes, threads, and containers \\
Kernel \\
Signals, interrupts, and exceptions",
}
@Article{Pearce:2021:LFR,
author = "David J. Pearce",
title = "A Lightweight Formalism for Reference Lifetimes and
Borrowing in {Rust}",
journal = j-TOPLAS,
volume = "43",
number = "1",
pages = "3:1--3:73",
month = apr,
year = "2021",
CODEN = "ATPSDT",
DOI = "https://doi.org/10.1145/3443420",
ISSN = "0164-0925 (print), 1558-4593 (electronic)",
ISSN-L = "0164-0925",
bibdate = "Tue Apr 27 08:36:42 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib;
https://www.math.utah.edu/pub/tex/bib/toplas.bib",
URL = "https://dl.acm.org/doi/10.1145/3443420",
abstract = "Rust is a relatively new programming language that has
gained significant traction since its v1.0 release in
2015. Rust aims to be a systems language that competes
with C/C++. A claimed advantage of Rust is a strong
focus on memory safety without garbage collection. This
is primarily achieved through two concepts, namely,
reference lifetimes and borrowing. Both of these are
well-known ideas stemming from the literature on
region-based memory management and
linearity/uniqueness. Rust brings both of these ideas
together to form a coherent programming model.
Furthermore, Rust has a strong focus on stack-allocated
data and, like C/C++ but unlike Java, permits
references to local variables.\par
Type checking in Rust can be viewed as a two-phase
process: First, a traditional type checker operates in
a flow-insensitive fashion; second, a borrow checker
enforces an ownership invariant using a flow-sensitive
analysis. In this article, we present a lightweight
formalism that captures these two phases using a
flow-sensitive type system that enforces ``type and
borrow safety.'' In particular, programs that are type
and borrow safe will not attempt to dereference
dangling pointers. Our calculus core captures many
aspects of Rust, including copy- and move-semantics,
mutable borrowing, reborrowing, partial moves, and
lifetimes. In particular, it remains sufficiently
lightweight to be easily digested and understood and,
we argue, still captures the salient aspects of
reference lifetimes and borrowing. Furthermore,
extensions to the core can easily add more complex
features (e.g., control-flow, tuples, method
invocation). We provide a soundness proof to verify our
key claims of the calculus. We also provide a reference
implementation in Java with which we have model checked
our calculus using over 500B input programs. We have
also fuzz tested the Rust compiler using our calculus
against 2B programs and, to date, found one confirmed
compiler bug and several other possible issues.",
acknowledgement = ack-nhfb,
articleno = "3",
fjournal = "ACM Transactions on Programming Languages and
Systems",
journal-URL = "https://dl.acm.org/loi/toplas",
}
@Article{Popescu:2021:SSA,
author = "Natalie Popescu and Ziyang Xu and Sotiris Apostolakis
and David I. August and Amit Levy",
title = "Safer at any speed: automatic context-aware safety
enhancement for {Rust}",
journal = j-PACMPL,
volume = "5",
number = "OOPSLA",
pages = "103:1--103:23",
month = oct,
year = "2021",
CODEN = "????",
DOI = "https://doi.org/10.1145/3485480",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Wed Mar 2 07:00:43 MST 2022",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3485480",
abstract = "Type-safe languages improve application safety by
eliminating whole classes of vulnerabilities-such as
buffer overflows-by construction. However, this safety
sometimes comes with a performance cost. As a result,
many modern type-safe languages provide \ldots{}",
acknowledgement = ack-nhfb,
articleno = "103",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@MastersThesis{Rivera:2021:PMS,
author = "Elijah E. Rivera",
title = "Preserving Memory Safety in {Safe Rust} during
Interactions with Unsafe Languages",
type = "{Master of Engineering in Electrical Engineering and
Computer Science}",
school = "Massachusetts Institute of Technology",
address = "Cambridge, MA, USA",
pages = "66",
month = jun,
year = "2021",
bibdate = "Mon Sep 26 08:54:49 2022",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dspace.mit.edu/bitstream/handle/1721.1/139052/Rivera-eerivera-meng-eecs-2021-thesis.pdf",
abstract = "Rust is a programming language that simultaneously
offers high performance and strong security guarantees.
However, these guarantees come at the cost of strict
compiler checks that sometimes prevent necessary code
patterns. The unsafe keyword allows developers to
bypass these compiler checks, and is used in both pure
Rust and mixed-language applications. But the use of
unsafe undermines the security guarantees of Rust that
make it an attractive option in the first place.\par
We first demonstrate that within a real-world pure Rust
application, many uses of unsafe can be eliminated,or
reduced to formally verifiable standard libraries. We
then present Galeed, a system for isolating and
protecting the Rust heap from access by other
programming languages using Intel's Memory Protection
Key (MPK) technology. We demonstrate both the
effectiveness and efficiency of Galeed on Firefox, a
web browser written in Rust and C++.",
acknowledgement = ack-nhfb,
}
@Article{Wolff:2021:MSV,
author = "Fabian Wolff and Aurel B{\'\i}l{\'y} and Christoph
Matheja and Peter M{\"u}ller and Alexander J. Summers",
title = "Modular specification and verification of closures in
{Rust}",
journal = j-PACMPL,
volume = "5",
number = "OOPSLA",
pages = "145:1--145:29",
month = oct,
year = "2021",
CODEN = "????",
DOI = "https://doi.org/10.1145/3485522",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Wed Mar 2 07:00:43 MST 2022",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3485522",
abstract = "Closures are a language feature supported by many
mainstream languages, combining the ability to package
up references to code blocks with the possibility of
capturing state from the environment of the closure's
declaration. Closures are powerful, but complicate
understanding and formal reasoning, especially when
closure invocations may mutate objects reachable from
the captured state or from closure arguments. This
paper presents a novel technique for the modular
specification and verification of closure-manipulating
code in Rust. Our technique combines Rust's type system
guarantees and novel specification features to enable
formal verification of rich functional properties. It
encodes higher-order concerns into a first-order logic,
which enables automation via SMT solvers. Our technique
is implemented as an extension of the deductive
verifier Prusti, with which we have successfully
verified many common idioms of closure usage.",
acknowledgement = ack-nhfb,
articleno = "145",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@Article{Yanovski:2021:PGS,
author = "Joshua Yanovski and Hoang-Hai Dang and Ralf Jung and
Derek Dreyer",
title = "\pkg{GhostCell}: separating permissions from data in
{Rust}",
journal = j-PACMPL,
volume = "5",
number = "ICFP",
pages = "92:1--92:30",
month = aug,
year = "2021",
CODEN = "????",
DOI = "https://doi.org/10.1145/3473597",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Wed Mar 2 07:00:41 MST 2022",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3473597",
abstract = "The Rust language offers a promising approach to safe
systems programming based on the principle of aliasing
XOR mutability: a value may be either aliased or
mutable, but not both at the same time. However, to
implement pointer-based data structures \ldots{}",
acknowledgement = ack-nhfb,
articleno = "92",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@InProceedings{Fluet:2022:ERT,
author = "M. Fluet",
editor = "????",
booktitle = "Proceedings of the Rust-Edu Workshop",
title = "Experience report: Two semesters teaching {Rust}",
publisher = "????",
address = "????",
pages = "48--58",
month = aug,
year = "2022",
bibdate = "Mon Jun 05 13:43:01 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://rust-edu.org/workshop/proceedings.pdf",
acknowledgement = ack-nhfb,
}
@Article{Hardin:2022:HSC,
author = "David Hardin",
title = "Hardware\slash Software Co-Assurance for the {Rust}
Programming Language Applied to Zero Trust Architecture
Development",
journal = j-SIGADA-LETTERS,
volume = "42",
number = "2",
pages = "55--61",
month = dec,
year = "2022",
CODEN = "AALEE5",
DOI = "https://doi.org/10.1145/3591335.3591340",
ISSN = "1094-3641 (print), 1557-9476 (electronic)",
ISSN-L = "0736-721X",
bibdate = "Tue Apr 11 11:46:30 MDT 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib;
https://www.math.utah.edu/pub/tex/bib/sigada.bib",
URL = "https://dl.acm.org/doi/10.1145/3591335.3591340",
abstract = "Zero Trust Architecture requirements are of increasing
importance in critical systems development. Zero trust
tenets hold that no implicit trust be granted to assets
based on their physical or network location. Zero Trust
development focuses on \ldots{}",
acknowledgement = ack-nhfb,
fjournal = "ACM SIGADA Ada Letters",
journal-URL = "https://dl.acm.org/loi/sigada",
}
@Article{Ho:2022:ARV,
author = "Son Ho and Jonathan Protzenko",
title = "{Aeneas}: Rust verification by functional
translation",
journal = j-PACMPL,
volume = "6",
number = "ICFP",
pages = "116:1--116:??",
month = aug,
year = "2022",
CODEN = "????",
DOI = "https://doi.org/10.1145/3547647",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Sat Mar 11 09:08:35 MST 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3547647",
abstract = "We present Aeneas, a new verification toolchain for
Rust programs based on a lightweight functional
translation. We leverage Rust's rich region-based type
system to eliminate memory reasoning for a large class
of Rust programs, as long as they do not rely on
interior mutability or unsafe code. Doing so, we
relieve the proof engineer of the burden of
memory-based reasoning, allowing them to instead focus
on functional properties of their code.\par
The first contribution of Aeneas is a new approach to
borrows and controlled aliasing. We propose a pure,
functional semantics for LLBC, a Low-Level Borrow
Calculus that captures a large subset of Rust programs.
Our semantics is value-based, meaning there is no
notion of memory, addresses or pointer arithmetic. Our
semantics is also ownership-centric, meaning that we
enforce soundness of borrows via a semantic criterion
based on loans rather than through a syntactic
type-based lifetime discipline. We claim that our
semantics captures the essence of the borrow mechanism
rather than its current implementation in the Rust
compiler.\par
The second contribution of Aeneas is a translation from
LLBC to a pure lambda-calculus. This allows the user to
reason about the original Rust program through the
theorem prover of their choice, and fulfills our
promise of enabling lightweight verification of Rust
programs. To deal with the well-known technical
difficulty of terminating a borrow, we rely on a novel
approach, in which we approximate the borrow graph in
the presence of function calls. This in turn allows us
to perform the translation using a new technical device
called backward functions.\par
We implement our toolchain in a mixture of Rust and
OCaml; our chief case study is a low-level, resizing
hash table, for which we prove functional correctness,
the first such result in Rust. Our evaluation shows
significant gains of verification productivity for the
programmer. This paper therefore establishes a new
point in the design space of Rust verification
toolchains, one that aims to verify Rust programs
simply, and at scale.\par
Rust goes to great lengths to enforce static control of
aliasing; the proof engineer should not waste any time
on memory reasoning when so much already comes ``for
free''!",
acknowledgement = ack-nhfb,
articleno = "116",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@Article{Miller:2022:RCF,
author = "Barton P. Miller and Mengxiao Zhang and Elisa R.
Heymann",
title = "The Relevance of Classic Fuzz Testing: Have We Solved
This One?",
journal = j-IEEE-TRANS-SOFTW-ENG,
volume = "48",
number = "6",
pages = "2028--2039",
month = jun,
year = "2022",
CODEN = "IESEDJ",
DOI = "https://doi.org/10.1109/TSE.2020.3047766",
ISSN = "0098-5589 (print), 1939-3520 (electronic)",
ISSN-L = "0098-5589",
bibsource = "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2020.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib;
https://www.math.utah.edu/pub/tex/bib/texbook3.bib;
https://www.math.utah.edu/pub/tex/bib/unix.bib",
URL = "https://arxiv.org/abs/2008.06537;
https://ieeexplore.ieee.org/document/9309406",
abstract = "As fuzz testing has passed its 30th anniversary, and
in the face of the incredible progress in fuzz testing
techniques and tools, the question arises if the
classic, basic fuzz technique is still useful and
applicable? In that tradition, we have updated the
basic fuzz tools and testing scripts and applied them
to a large collection of Unix utilities on Linux,
FreeBSD, and MacOS. As before, our failure criteria was
whether the program crashed or hung. We found that 9
crash or hang out of 74 utilities on Linux, 15 out of
78 utilities on FreeBSD, and 12 out of 76 utilities on
MacOS. A total of 24 different utilities failed across
the three platforms. We note that these failure rates
are somewhat higher than our in previous 1995, 2000,
and 2006 studies of the reliability of command line
utilities. In the basic fuzz tradition, we debugged
each failed utility and categorized the causes the
failures. Classic categories of failures, such as
pointer and array errors and not checking return codes,
were still broadly present in the current results. In
addition, we found a couple of new categories of
failures appearing. We present examples of these
failures to illustrate the programming practices that
allowed them to happen. As a side note, we tested the
limited number of utilities available in a modern
programming language (Rust) and found them to be of no
better reliability than the standard ones.",
acknowledgement = ack-nhfb,
fjournal = "IEEE Transactions on Software Engineering",
journal-URL = "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
keywords = "Rust programming language",
}
@Article{Xu:2022:MSC,
author = "Hui Xu and Zhuangbin Chen and Mingshen Sun and Yangfan
Zhou and Michael R. Lyu",
title = "Memory-Safety Challenge Considered Solved? {An}
In-Depth Study with All {Rust} {CVEs}",
journal = j-TOSEM,
volume = "31",
number = "1",
pages = "3:1--3:25",
month = jan,
year = "2022",
CODEN = "ATSMER",
DOI = "https://doi.org/10.1145/3466642",
ISSN = "1049-331X (print), 1557-7392 (electronic)",
ISSN-L = "1049-331X",
bibdate = "Fri Jan 7 07:51:00 MST 2022",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib;
https://www.math.utah.edu/pub/tex/bib/tosem.bib",
URL = "https://dl.acm.org/doi/10.1145/3466642",
abstract = "Rust is an emerging programming language that aims at
preventing memory-safety bugs without sacrificing much
efficiency. The claimed property is very attractive to
developers, and many projects start using the language.
However, can Rust achieve the memory-safety promise?
This article studies the question by surveying 186
real-world bug reports collected from several origins,
which contain all existing Rust common vulnerability
and exposures (CVEs) of memory-safety issues by
2020-12-31. We manually analyze each bug and extract
their culprit patterns. Our analysis result shows that
Rust can keep its promise that all memory-safety bugs
require unsafe code, and many memory-safety bugs in our
dataset are mild soundness issues that only leave a
possibility to write memory-safety bugs without unsafe
code. Furthermore, we summarize three typical
categories of memory-safety bugs, including automatic
memory reclaim, unsound function, and unsound generic
or trait. While automatic memory claim bugs are related
to the side effect of Rust newly-adopted
ownership-based resource management scheme, unsound
function reveals the essential challenge of Rust
development for avoiding unsound code, and unsound
generic or trait intensifies the risk of introducing
unsoundness. Based on these findings, we propose two
promising directions toward improving the security of
Rust development, including several best practices of
using specific APIs and methods to detect particular
bugs involving unsafe code. Our work intends to raise
more discussions regarding the memory-safety issues of
Rust and facilitate the maturity of the language.",
acknowledgement = ack-nhfb,
articleno = "3",
fjournal = "ACM Transactions on Software Engineering and
Methodology",
journal-URL = "https://dl.acm.org/loi/tosem",
}
@Book{Youens-Clark:2022:CLR,
author = "Ken Youens-Clark",
title = "Command-line {Rust}: a Project-Based Primer for
Writing {Rust CLIs}",
publisher = pub-ORA-MEDIA,
address = pub-ORA-MEDIA:adr,
pages = "xviii + 377",
year = "2022",
ISBN = "1-0981-0943-0 (paperback)",
ISBN-13 = "978-1-0981-0943-1 (paperback)",
LCCN = "QA76.73.R87 Y68 2022",
bibdate = "Mon Jun 5 12:22:38 MDT 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/ora.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib;
z3950.loc.gov:7090/Voyager",
abstract = "For several consecutive years, Rust has been voted
``most loved programming language'' in Stack Overflow's
annual developer survey. This open source systems
programming language is now used for everything from
game engines and operating systems to browser
components and virtual reality simulation engines. But
Rust is also an incredibly complex language with a
notoriously difficult learning curve. Rather than
focusing on the language as a whole, this guide teaches
Rust using a single small, complete, focused program in
each chapter. Author Ken Youens-Clark shows you how to
start, write, and test each of these programs to create
a finished product. You'll learn how to handle errors
in Rust, read and write files, and use regular
expressions, Rust types, structs, and more. Discover
how to: Use Rust's standard libraries and data types
such as numbers, strings, vectors, structs, Options,
and Results to create command-line programs; Write and
test Rust programs and functions; Read and write files,
including stdin, stdout, and stderr; Document and
validate command-line arguments; Write programs that
fail gracefully; Parse raw and delimited text manually,
using regular expressions and Rust crates; Use and
control randomness.",
acknowledgement = ack-nhfb,
subject = "Rust (Computer program language); User interfaces
(Computer systems); User-Computer Interface; Rust
(Langage de programmation); Interfaces utilisateurs
(Informatique); Rust (Computer program language); User
interfaces (Computer systems)",
}
@Article{Bagnara:2023:CRA,
author = "Roberto Bagnara and Abramo Bagnara and Federico
Serafini",
title = "{C}-rusted: The Advantages of {Rust}, in {C}, without
the Disadvantages",
journal = "arXiv.org",
volume = "??",
number = "??",
pages = "1--12",
day = "10",
month = feb,
year = "2023",
bibdate = "Tue Aug 29 07:43:38 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://arxiv.org/abs/2302.05331",
abstract = "C-rusted is an innovative technology whereby C
programs can be (partly) annotated so as to express:
ownership, exclusivity and shareability of language,
system and user-defined resources; dynamic properties
of objects and the way they evolve during program
execution; nominal typing and subtyping. The
(partially) annotated C programs can be translated with
unmodified versions of any compilation toolchain
capable of processing ISO C code. The annotated C
program parts can be validated by static analysis: if
the static analyzer flags no error, then the
annotations are provably coherent among themselves and
with respect to annotated C code, in which case said
annotated parts are provably exempt from a large class
of logic, security, and run-time errors.",
acknowledgement = ack-nhfb,
}
@Book{Bos:2023:RAL,
author = "Mara Bos",
title = "{Rust} Atomics and Locks: Low-Level Concurrency in
Practice",
publisher = pub-ORA-MEDIA,
address = pub-ORA-MEDIA:adr,
pages = "xvii + 230",
year = "2023",
ISBN = "1-0981-1944-4",
ISBN-13 = "978-1-0981-1944-7",
LCCN = "QA76.73.R87 B67 2023",
bibdate = "Mon Jun 5 12:19:57 MDT 2023",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/ora.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
abstract = "The Rust programming language is extremely well suited
for concurrency, and its ecosystem has many libraries
that include lots of concurrent data structures, locks,
and more. But implementing those structures correctly
can be very difficult. Even in the most well-used
libraries, memory ordering bugs are not uncommon. In
this practical book, Mara Bos, leader of the Rust
library team, helps Rust programmers of all levels gain
a clear understanding of low-level concurrency. You'll
learn everything about atomics and memory ordering and
how they're combined with basic operating system APIs
to build common primitives like mutexes and condition
variables. Once you're done, you'll have a firm grasp
of how Rust's memory model, the processor, and the role
of the operating system all fit together. With this
guide, you'll learn: How Rust's type system works
exceptionally well for programming concurrency
correctly All about mutexes, condition variables,
atomics, and memory ordering What happens in practice
with atomic operations on Intel and ARM processors How
locks are implemented with support from the operating
system How to write correct code that includes
concurrency, atomics, and locks How to build your own
locking and synchronization primitives correctly.",
acknowledgement = ack-nhfb,
subject = "Rust (Computer program language); Computer
programming",
tableofcontents = "1. Basics of Rust Concurrency \\
2. Atomics \\
3. Memory Ordering \\
4. Building Our Own Spin Lock \\
5. Building Our Own Channels \\
6. Building Our Own ``Arc'' \\
7. Understanding the Processor \\
8. Operating System Primitives \\
9. Building Our Own Locks \\
10. Ideas and Inspiration",
}
@Article{Cogo:2023:AAB,
author = "Filipe Roseiro Cogo and Xin Xia and Ahmed E. Hassan",
title = "Assessing the Alignment between the Information Needs
of Developers and the Documentation of Programming
Languages: a Case Study on {Rust}",
journal = j-TOSEM,
volume = "32",
number = "2",
pages = "43:1--43:??",
month = apr,
year = "2023",
CODEN = "ATSMER",
DOI = "https://doi.org/10.1145/3546945",
ISSN = "1049-331X (print), 1557-7392 (electronic)",
ISSN-L = "1049-331X",
bibdate = "Mon Apr 17 12:10:06 MDT 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib;
https://www.math.utah.edu/pub/tex/bib/tosem.bib",
URL = "https://dl.acm.org/doi/10.1145/3546945",
abstract = "Programming language documentation refers to the set
of technical documents that provide application
developers with a description of the high-level
concepts of a language (e.g., manuals, tutorials, and
API references). Such documentation is essential to
support application developers in effectively using a
programming language. One of the challenges faced by
documenters (i.e., personnel that design and produce
documentation for a programming language) is to ensure
that documentation has relevant information that aligns
with the concrete needs of developers, defined as the
missing knowledge that developers acquire via voluntary
search. In this article, we present an automated
approach to support documenters in evaluating the
differences and similarities between the concrete
information need of developers and the current state of
documentation (a problem that we refer to as the
topical alignment of a programming language
documentation). Our approach leverages semi-supervised
topic modelling that uses domain knowledge to guide the
derivation of topics. We initially train a baseline
topic model from a set of Rust-related Q\&A posts. We
then use this baseline model to determine the
distribution of topic probabilities of each document of
the official Rust documentation. Afterwards, we assess
the similarities and differences between the topics of
the Q\&A posts and the official documentation. Our
results show a relatively high level of topical
alignment in Rust documentation. Still, information
about specific topics is scarce in both the Q\&A
websites and the documentation, particularly related
topics with programming niches such as network, game,
and database development. For other topics (e.g.,
related topics with language features such as structs,
patterns and matchings, and foreign function
interface), information is only available on Q\&A
websites while lacking in the official documentation.
Finally, we discuss implications for programming
language documenters, particularly how to leverage our
approach to prioritize topics that should be added to
the documentation.",
acknowledgement = ack-nhfb,
articleno = "43",
fjournal = "ACM Transactions on Software Engineering and
Methodology",
journal-URL = "https://dl.acm.org/loi/tosem",
}
@Article{Crichton:2023:GCM,
author = "Will Crichton and Gavin Gray and Shriram
Krishnamurthi",
title = "A Grounded Conceptual Model for Ownership Types in
{Rust}",
journal = j-PACMPL,
volume = "7",
number = "OOPSLA2",
pages = "265:1--265:??",
month = oct,
year = "2023",
CODEN = "????",
DOI = "https://doi.org/10.1145/3622841",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Fri May 10 10:23:32 MDT 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3622841",
abstract = "Programmers learning Rust struggle to understand
ownership types, Rust's core mechanism for ensuring
memory safety without garbage collection. This
\ldots{}",
acknowledgement = ack-nhfb,
ajournal = "Proc. ACM Program. Lang.",
articleno = "265",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@Article{Cui:2023:SDM,
author = "Mohan Cui and Chengjun Chen and Hui Xu and Yangfan
Zhou",
title = "{SafeDrop}: Detecting Memory Deallocation Bugs of
{Rust} Programs via Static Data-flow Analysis",
journal = j-TOSEM,
volume = "32",
number = "4",
pages = "82:1--82:??",
month = jul,
year = "2023",
CODEN = "ATSMER",
DOI = "https://doi.org/10.1145/3542948",
ISSN = "1049-331X (print), 1557-7392 (electronic)",
ISSN-L = "1049-331X",
bibdate = "Mon Jul 3 08:45:48 MDT 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib;
https://www.math.utah.edu/pub/tex/bib/tosem.bib",
URL = "https://dl.acm.org/doi/10.1145/3542948",
abstract = "Rust is an emerging programming language that aims to
prevent memory-safety bugs. However, the current design
of Rust also brings side effects, which may increase
the risk of memory-safety issues. In particular, it
employs ownership-based resource \ldots{}",
acknowledgement = ack-nhfb,
ajournal = "ACM Trans. Softw. Eng. Methodol.",
articleno = "82",
fjournal = "ACM Transactions on Software Engineering and
Methodology",
journal-URL = "https://dl.acm.org/loi/tosem",
}
@Article{Emre:2023:ALT,
author = "Mehmet Emre and Peter Boyland and Aesha Parekh and
Ryan Schroeder and Kyle Dewey and Ben Hardekopf",
title = "Aliasing Limits on Translating {C} to Safe {Rust}",
journal = j-PACMPL,
volume = "7",
number = "OOPSLA1",
pages = "94:1--94:??",
month = apr,
year = "2023",
CODEN = "????",
DOI = "https://doi.org/10.1145/3586046",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Wed May 17 09:16:15 MDT 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3586046",
abstract = "The Rust language was created to provide safe
low-level systems programming. There is both industrial
and academic interest in the problem of
(semi-)automatically translating C code to Rust in
order to exploit Rust's safety guarantees. We study the
effectiveness and limitations of existing techniques
for automatically translating unsafe raw pointers (in
Rust programs translated from C) into safe Rust
references via ownership and lifetime inference. Our
novel evaluation methodology enables our study to
extend beyond prior studies, and to discover new
information contradicting the conclusions of prior
studies. We find that existing translation methods are
severely limited by a lack of precision in the Rust
compiler's safety checker, causing many safe pointer
manipulations to be labeled as potentially unsafe.
Leveraging this information, we propose methods for
improving translation, based on encoding the results of
a more precise analysis in a manner that is
understandable to an unmodified Rust compiler. We
implement one of our proposed methods, increasing the
number of pointers that can be translated to safe Rust
references by 75\% over the baseline (from 12\% to 21\%
of all pointers).",
acknowledgement = ack-nhfb,
articleno = "94",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@Article{Fiala:2023:LRT,
author = "Jon{\'a}{\v{s}} Fiala and Shachar Itzhaky and Peter
M{\"u}ller and Nadia Polikarpova and Ilya Sergey",
title = "Leveraging {Rust} Types for Program Synthesis",
journal = j-PACMPL,
volume = "7",
number = "PLDI",
pages = "164:1--164:??",
month = jun,
year = "2023",
CODEN = "????",
DOI = "https://doi.org/10.1145/3591278",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Fri May 10 10:23:34 MDT 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3591278",
abstract = "The Rust type system guarantees memory safety and
data-race freedom. However, to satisfy Rust's type
rules, many familiar implementation patterns must
\ldots{}",
acknowledgement = ack-nhfb,
ajournal = "Proc. ACM Program. Lang.",
articleno = "164",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@Article{Lattuada:2023:VVR,
author = "Andrea Lattuada and Travis Hance and Chanhee Cho and
Matthias Brun and Isitha Subasinghe and Yi Zhou and Jon
Howell and Bryan Parno and Chris Hawblitzel",
title = "{Verus}: Verifying {Rust} Programs using Linear Ghost
Types",
journal = j-PACMPL,
volume = "7",
number = "OOPSLA1",
pages = "85:1--85:??",
month = apr,
year = "2023",
CODEN = "????",
DOI = "https://doi.org/10.1145/3586037",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Wed May 17 09:16:15 MDT 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3586037",
abstract = "The Rust programming language provides a powerful type
system that checks linearity and borrowing, allowing
code to safely manipulate memory without garbage
collection and making Rust ideal for developing
low-level, high-assurance systems. For such systems,
formal verification can be useful to prove functional
correctness properties beyond type safety. This paper
presents Verus, an SMT-based tool for formally
verifying Rust programs. With Verus, programmers
express proofs and specifications using the Rust
language, allowing proofs to take advantage of Rust's
linear types and borrow checking. We show how this
allows proofs to manipulate linearly typed permissions
that let Rust code safely manipulate memory, pointers,
and concurrent resources. Verus organizes proofs and
specifications using a novel mode system that
distinguishes specifications, which are not checked for
linearity and borrowing, from executable code and
proofs, which are checked for linearity and borrowing.
We formalize Verus' linearity, borrowing, and modes in
a small lambda calculus, for which we prove type safety
and termination of specifications and proofs. We
demonstrate Verus on a series of examples, including
pointer-manipulating code (an xor-based doubly linked
list), code with interior mutability, and concurrent
code.",
acknowledgement = ack-nhfb,
articleno = "85",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@Article{Lehmann:2023:FLT,
author = "Nico Lehmann and Adam T. Geller and Niki Vazou and
Ranjit Jhala",
title = "{Flux}: Liquid Types for {Rust}",
journal = j-PACMPL,
volume = "7",
number = "PLDI",
pages = "169:1--169:??",
month = jun,
year = "2023",
CODEN = "????",
DOI = "https://doi.org/10.1145/3591283",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Fri May 10 10:23:34 MDT 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bibb;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3591283",
abstract = "We introduce Flux, which shows how logical refinements
can work hand in glove with Rust's ownership mechanisms
to yield ergonomic type-based \ldots{}",
acknowledgement = ack-nhfb,
ajournal = "Proc. ACM Program. Lang.",
articleno = "169",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@Article{Li:2023:ESY,
author = "Hao Li and Filipe R. Cogo and Cor-Paul Bezemer",
title = "An Empirical Study of Yanked Releases in the {Rust}
Package Registry",
journal = j-IEEE-TRANS-SOFTW-ENG,
volume = "49",
number = "1",
pages = "437--449",
month = jan,
year = "2023",
CODEN = "IESEDJ",
DOI = "https://doi.org/10.1109/TSE.2022.3152148",
ISSN = "0098-5589 (print), 1939-3520 (electronic)",
ISSN-L = "0098-5589",
bibdate = "Sat Feb 18 16:46:58 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2020.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
fjournal = "IEEE Transactions on Software Engineering",
journal-URL = "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}
@Article{Thy:2023:ALE,
author = "Sewen Thy and Andreea Costea and Kiran Gopinathan and
Ilya Sergey",
title = "Adventure of a Lifetime: Extract Method Refactoring
for {Rust}",
journal = j-PACMPL,
volume = "7",
number = "OOPSLA2",
pages = "245:1--245:??",
month = oct,
year = "2023",
CODEN = "????",
DOI = "https://doi.org/10.1145/3622821",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Fri May 10 10:23:32 MDT 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3622821",
abstract = "We present a design and implementation of the
automated ``Extract Method'' refactoring for Rust
programs. Even though Extract Method is one \ldots{}",
acknowledgement = ack-nhfb,
ajournal = "Proc. ACM Program. Lang.",
articleno = "245",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@Article{vanOorschot:2023:MEMb,
author = "Paul C. van Oorschot",
title = "Memory Errors and Memory Safety: a Look at {Java} and
{Rust}",
journal = j-IEEE-SEC-PRIV,
volume = "21",
number = "3",
pages = "62--68",
month = may # "\slash " # jun,
year = "2023",
DOI = "https://doi.org/10.1109/MSEC.2023.3249719",
ISSN = "1540-7993 (print), 1558-4046 (electronic)",
ISSN-L = "1540-7993",
bibdate = "Mon Jun 5 11:33:11 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/ieeesecpriv.bib;
https://www.math.utah.edu/pub/tex/bib/java2020.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
fjournal = "IEEE Security \& Privacy",
journal-URL = "https://publications.computer.org/security-and-privacy/",
}
@Misc{Caballar:2023:MMS,
author = "Rina Diane Caballar",
title = "The Move to Memory-Safe Programming: Shifting from {C}
and {C++} to memory-safe programming languages like
{Rust} is gaining ground",
howpublished = "IEEE Spectrum Web site",
day = "20",
month = mar,
year = "2023",
bibdate = "Thu Aug 08 16:34:42 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://spectrum.ieee.org/memory-safe-programming-languages",
acknowledgement = ack-nhfb,
remark = "News story: not in IEEE Spectrum journal.",
}
@Article{Bitar:2024:RJS,
author = "Mohamad Bitar",
title = "{Rust} and {Julia} for Scientific Computing",
journal = j-COMPUT-SCI-ENG,
volume = "26",
number = "1",
pages = "72--76",
month = jan # "\slash " # mar,
year = "2024",
CODEN = "CSENFA",
DOI = "https://doi.org/10.1109/MCSE.2024.3369988",
ISSN = "1521-9615 (print), 1558-366X (electronic)",
ISSN-L = "1521-9615",
bibdate = "Sat Aug 24 09:25:48 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/computscieng.bib;
https://www.math.utah.edu/pub/tex/bib/julia.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
fjournal = "Computing in Science and Engineering",
journal-URL = "https://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5992",
keywords = "Computer languages; Performance evaluation; Scientific
computing",
}
@Article{Cloosters:2024:MCB,
author = "Tobias Cloosters and Oussama Draissi and Johannes
Willbold and Thorsten Holz and Lucas Davi",
title = "Memory Corruption at the Border of Trusted Execution",
journal = j-IEEE-SEC-PRIV,
volume = "22",
number = "4",
pages = "87--96",
month = jul # "\slash " # aug,
year = "2024",
DOI = "https://doi.org/10.1109/MSEC.2024.3381439",
ISSN = "1540-7993 (print), 1558-4046 (electronic)",
ISSN-L = "1540-7993",
bibdate = "Thu Aug 8 11:50:27 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/ieeesecpriv.bib;
https://www.math.utah.edu/pub/tex/bib/risc-v.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
fjournal = "IEEE Security \& Privacy",
journal-URL = "https://publications.computer.org/security-and-privacy/",
keywords = "AMD Secure Encrypted Virtualization; ARM Trustzone;
Codes; Computer security; Fuzzing; Instruction sets;
Kernel; Libraries; Protection; Random access memory;
RISC-V Keystone; Rust SGX SDK; Security; Trusted
computing",
}
@Article{Hong:2024:TSM,
author = "Jaemin Hong and Sunghwan Shim and Sanguk Park and Tae
Woo Kim and Jungwoo Kim and Junsoo Lee and Sukyoung Ryu
and Jeehoon Kang",
title = "Taming shared mutable states of operating systems in
{Rust}",
journal = j-SCI-COMPUT-PROGRAM,
volume = "238",
number = "??",
pages = "103152:1--103152:11",
month = dec,
year = "2024",
CODEN = "SCPGD4",
DOI = "https://doi.org/10.1016/j.scico.2024.103152",
ISSN = "0167-6423 (print), 1872-7964 (electronic)",
ISSN-L = "0167-6423",
bibdate = "Tue Aug 27 08:33:19 MDT 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib;
https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
URL = "http://www.sciencedirect.com/science/article/pii/S0167642324000753",
acknowledgement = ack-nhfb,
articleno = "103152",
fjournal = "Science of Computer Programming",
journal-URL = "http://www.sciencedirect.com/science/journal/01676423",
}
@Article{Lamba:2024:CSI,
author = "Ada Lamba and Max Taylor and Vincent Beardsley and
Jacob Bambeck and Michael D. Bond and Zhiqiang Lin",
title = "{Cocoon}: Static Information Flow Control in {Rust}",
journal = j-PACMPL,
volume = "8",
number = "OOPSLA1",
pages = "100:1--100:??",
month = apr,
year = "2024",
CODEN = "????",
DOI = "https://doi.org/10.1145/3649817",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Fri May 10 10:23:37 MDT 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3649817",
abstract = "Information flow control (IFC) provides
confidentiality by enforcing noninterference, which
ensures that high-secrecy values cannot \ldots{}",
acknowledgement = ack-nhfb,
ajournal = "Proc. ACM Program. Lang.",
articleno = "100",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@Article{Larsen:2024:MCR,
author = "Per Larsen",
title = "Migrating {C} to {Rust} for Memory Safety",
journal = j-IEEE-SEC-PRIV,
volume = "22",
number = "4",
pages = "22--29",
month = jul # "\slash " # aug,
year = "2024",
DOI = "https://doi.org/10.1109/MSEC.2024.3385357",
ISSN = "1540-7993 (print), 1558-4046 (electronic)",
ISSN-L = "1540-7993",
bibdate = "Thu Aug 8 11:50:27 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/ieeesecpriv.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
fjournal = "IEEE Security \& Privacy",
journal-URL = "https://publications.computer.org/security-and-privacy/",
keywords = "Automation; Codes; Computer languages; Costs; Memory
management; Program processors; Quality assessment;
Resource management; Safety; Security",
}
@Article{Qin:2024:UDR,
author = "Boqin Qin and Yilun Chen and Haopeng Liu and Hua Zhang
and Qiaoyan Wen and Linhai Song and Yiying Zhang",
title = "Understanding and Detecting Real-World Safety Issues
in {Rust}",
journal = j-IEEE-TRANS-SOFTW-ENG,
volume = "50",
number = "6",
pages = "1306--1324",
year = "2024",
CODEN = "IESEDJ",
DOI = "https://doi.org/10.1109/TSE.2024.3380393",
ISSN = "0098-5589 (print), 1939-3520 (electronic)",
ISSN-L = "0098-5589",
bibdate = "Mon Mar 25 11:08:05 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2020.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
acknowledgement = ack-nhfb,
ajournal = "IEEE Trans. Softw. Eng.",
fjournal = "IEEE Transactions on Software Engineering",
journal-URL = "https://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
keywords = "bug study; Codes; Computer bugs; concurrency bug;
Detectors; Libraries; memory bug; Programming; Runtime;
Rust; Safety; static bug detection",
}
@Article{Wei:2024:PRT,
author = "Guannan Wei and Oliver Bra{\v{c}}evac and Songlin Jia
and Yuyan Bao and Tiark Rompf",
title = "Polymorphic Reachability Types: Tracking Freshness,
Aliasing, and Separation in Higher-Order Generic
Programs",
journal = j-PACMPL,
volume = "8",
number = "POPL",
pages = "14:1--14:??",
month = jan,
year = "2024",
CODEN = "????",
DOI = "https://doi.org/10.1145/3632856",
ISSN = "2475-1421 (electronic)",
ISSN-L = "2475-1421",
bibdate = "Fri May 10 10:23:39 MDT 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3632856",
abstract = "Fueled by the success of Rust, many programming
languages are adding substructural features to their
type systems. The promise of \ldots{}",
acknowledgement = ack-nhfb,
ajournal = "Proc. ACM Program. Lang.",
articleno = "14",
fjournal = "Proceedings of the ACM on Programming Languages
(PACMPL)",
journal-URL = "https://dl.acm.org/loi/pacmpl",
}
@Article{Williams:2024:BIM,
author = "Alex Williams",
title = "{BLOG@CACM}: Improving Memory Management, Performance
with {Rust}: Why {Rust} is becoming the programming
language of choice for many high-level developers",
journal = j-CACM,
volume = "67",
number = "9",
pages = "8--9",
month = sep,
year = "2024",
CODEN = "CACMA2",
DOI = "https://doi.org/10.1145/3673648",
ISSN = "0001-0782 (print), 1557-7317 (electronic)",
ISSN-L = "0001-0782",
bibdate = "Tue Aug 27 10:48:39 MDT 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/cacm2020.bib;
https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://dl.acm.org/doi/10.1145/3673648",
acknowledgement = ack-nhfb,
ajournal = "Commun. ACM",
fjournal = "Communications of the ACM",
journal-URL = "https://dl.acm.org/loi/cacm",
}
@Article{Zheng:2024:CLS,
author = "Xiaoye Zheng and Zhiyuan Wan and Yun Zhang and Rui
Chang and David Lo",
title = "A Closer Look at the Security Risks in the {Rust}
Ecosystem",
journal = j-TOSEM,
volume = "33",
number = "2",
pages = "34:1--34:??",
month = feb,
year = "2024",
CODEN = "ATSMER",
DOI = "https://doi.org/10.1145/3624738",
ISSN = "1049-331X (print), 1557-7392 (electronic)",
ISSN-L = "1049-331X",
bibdate = "Wed Apr 10 09:12:08 MDT 2024",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib;
https://www.math.utah.edu/pub/tex/bib/tosem.bib",
URL = "https://dl.acm.org/doi/10.1145/3624738",
abstract = "Rust is an emerging programming language designed for
the development of systems software. To facilitate the
reuse of Rust code, crates.io, as a central package
registry of the Rust ecosystem, hosts thousands of
third-party Rust packages. The openness of \ldots{}",
acknowledgement = ack-nhfb,
ajournal = "ACM Trans. Softw. Eng. Methodol.",
articleno = "34",
fjournal = "ACM Transactions on Software Engineering and
Methodology",
journal-URL = "https://dl.acm.org/loi/tosem",
}
@Misc{Dreyer:202x:EPR,
author = "Derek Dreyer",
title = "{ERC} Project ``{RustBelt}''",
howpublished = "Web site",
year = "202x",
bibdate = "Mon Sep 26 09:09:45 2022",
bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib",
URL = "https://plv.mpi-sws.org/rustbelt/",
acknowledgement = ack-nhfb,
}
