%%% -*-BibTeX-*- %%% ==================================================================== %%% BibTeX-file{ %%% author = "Nelson H. F. Beebe", %%% version = "1.46", %%% date = "22 December 2025", %%% time = "09:52:11 MDT", %%% filename = "rust.bib", %%% address = "University of Utah %%% Department of Mathematics, 110 LCB %%% 155 S 1400 E RM 233 %%% Salt Lake City, UT 84112-0090 %%% USA", %%% telephone = "+1 801 581 5254", %%% URL = "https://www.math.utah.edu/~beebe", %%% checksum = "49109 6354 31239 305494", %%% email = "beebe at math.utah.edu, beebe at acm.org, %%% beebe at computer.org (Internet)", %%% codetable = "ISO/ASCII", %%% keywords = "bibliography; BibTeX: programming language; %%% Rust", %%% license = "public domain", %%% supported = "yes", %%% docstring = "This is a bibliography of publications about %%% the computer programming language, Rust. %%% %%% At version 1.46, the year coverage looked %%% like this: %%% %%% 2013 ( 2) 2018 ( 19) 2023 ( 13) %%% 2014 ( 1) 2019 ( 19) 2024 ( 12) %%% 2015 ( 5) 2020 ( 26) 2025 ( 12) %%% 2016 ( 3) 2021 ( 14) %%% 2017 ( 7) 2022 ( 7) %%% %%% Article: 61 %%% Book: 24 %%% InCollection: 4 %%% InProceedings: 44 %%% MastersThesis: 2 %%% Misc: 4 %%% PhdThesis: 1 %%% TechReport: 1 %%% %%% Total entries: 141 %%% %%% Spelling has been verified with the UNIX %%% spell and GNU ispell programs using the %%% exception dictionary stored in the companion %%% file with extension .sok. %%% %%% BibTeX citation tags are uniformly chosen as %%% name:year:abbrev, where name is the family %%% name of the first author or editor, year is a %%% 4-digit number, and abbrev is a 3-letter %%% condensation of important title %%% words. Citation tags were automatically %%% generated by software developed for the %%% BibNet Project. %%% %%% In this bibliography, entries are sorted %%% first by ascending year, and within each %%% year, alphabetically by author or editor, and %%% then, if necessary, by the 3-letter %%% abbreviation at the end of the BibTeX %%% citation tag, using the bibsort -byyear %%% utility. Year order has been chosen to make %%% it easier to identify the most recent work. %%% %%% The checksum field above contains a CRC-16 %%% checksum as the first value, followed by the %%% equivalent of the standard UNIX wc (word %%% count) utility output of lines, words, and %%% characters. This is produced by Robert %%% Solovay's checksum utility.", %%% } %%% ==================================================================== @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{ }" } %%% ==================================================================== %%% Acknowledgement abbreviations: @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, e-mail: \path|beebe@math.utah.edu|, \path|beebe@acm.org|, \path|beebe@computer.org| (Internet), URL: \path|https://www.math.utah.edu/~beebe/|"} %%% ==================================================================== %%% Institution abbreviations: @String{inst-UTAH-MATH = "University of Utah, Department of Mathematics"} @String{inst-UTAH-MATH:adr = "Salt Lake City, UT 84112-0090, USA"} %%% ==================================================================== %%% Journal abbreviations: @String{j-CACM = "Communications of the ACM"} @String{j-COMPUT-SCI-ENG = "Computing in Science and Engineering"} @String{j-COMPUT-SECUR = "Computers \& Security"} @String{j-EMPIR-SOFTWARE-ENG = "Empirical Software Engineering"} @String{j-IEEE-ACCESS = "IEEE Access"} @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-INT-J-COMP-APPL = "International Journal of Computer Applications"} @String{j-J-COMPUT-LANG = "Journal of Computer Languages"} @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-TECS = "ACM Transactions on Embedded Computing Systems"} @String{j-TOPLAS = "ACM Transactions on Programming Languages and Systems"} @String{j-TOS = "ACM Transactions on Storage"} @String{j-TOSEM = "ACM Transactions on Software Engineering and Methodology"} %%% ==================================================================== %%% Publishers and their addresses: @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."} %%% ==================================================================== %%% Bibliography entriesed sorted by year, and then by citation label, %%% with ``bibsort -byyear'': @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 \\ Accessing Elements \\ Iteration \\ Growing and Shrinking Vectors \\ Joining \\ Splitting \\ Swapping \\ Sorting and Searching \\ Comparing Slices \\ Random Elements \\ Rust Rules Out Invalidation Errors \\ VecDeque \\ LinkedList \\ BinaryHeap \\ HashMap and BTreeMap \\ Entries \\ Map Iteration \\ HashSet and BTreeSet \\ 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 \\ mut and Mutex \\ Why Mutexes Are Not Always a Good Idea \\ Deadlock \\ Poisoned Mutexes \\ Multi-Consumer Channels Using Mutexes \\ Read/Write Locks (RwLock) \\ 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 / 197 \\ Reference counted smart pointers / 199 \\ Rc / 200 \\ Interior mutability / 205 \\ Cell / 205 \\ RefCell / 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{Alhazmi:2021:MMO, author = "Elaf Alhazmi and Abdulwahab Aljubairy and Ahoud Alhazmi", title = "Memory Management via Ownership Concept {Rust} and {Swift}: Experimental Study", journal = j-INT-J-COMP-APPL, volume = "183", number = "??", pages = "1--10", month = aug, year = "2021", CODEN = "????", DOI = "https://doi.org/10.5120/ijca2021921572", ISSN = "0975-8887", ISSN-L = "0975-8887", bibdate = "Fri Jan 24 09:46:40 MST 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/intjcompappl.bib; https://www.math.utah.edu/pub/tex/bib/rust.bib", URL = "https://www.ijcaonline.org/archives/volume183/number22/32054-2021921572/", acknowledgement = ack-nhfb, ajournal = "Intern. J. of Computer Applications", articleno = "22", fjournal = "International Journal of Computer Applications", journal-URL = "https://www.ijcaonline.org/", } @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; Rust (Computer program language); Systems programming (Computer science)", 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{Pieper:2021:HLE, author = "Ricardo Pieper and J{\'u}nior L{\"o}ff and Renato B. Hoffmann and Dalvan Griebler and Luiz G. Fernandes", title = "High-level and efficient structured stream parallelism for {Rust} on multi-cores", journal = j-J-COMPUT-LANG, volume = "65", number = "??", pages = "1--14", month = aug, year = "2021", CODEN = "????", DOI = "https://doi.org/10.1016/j.cola.2021.101054", ISSN = "2665-9182 (print), 2590-1184 (electronic)", ISSN-L = "2590-1184", bibdate = "Mon Sep 29 08:54:33 MDT 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/jcomputlang.bib; https://www.math.utah.edu/pub/tex/bib/rust.bib", URL = "http://www.sciencedirect.com/science/article/pii/S2590118421000332", acknowledgement = ack-nhfb, ajournal = "J. Comput. Lang.", articleno = "101054", fjournal = "Journal of Computer Languages", journal-URL = "https://www.sciencedirect.com/journal/journal-of-computer-languages", } @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", } @Article{Duarte:2022:TSC, author = "Jos{\'e} Duarte and Ant{\'o}nio Ravara", title = "Taming stateful computations in {Rust} with typestates", journal = j-J-COMPUT-LANG, volume = "72", number = "??", pages = "1--13", month = oct, year = "2022", CODEN = "????", DOI = "https://doi.org/10.1016/j.cola.2022.101154", ISSN = "2665-9182 (print), 2590-1184 (electronic)", ISSN-L = "2590-1184", bibdate = "Mon Sep 29 08:54:36 MDT 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/jcomputlang.bib; https://www.math.utah.edu/pub/tex/bib/rust.bib", URL = "http://www.sciencedirect.com/science/article/pii/S259011842200051X", acknowledgement = ack-nhfb, ajournal = "J. Comput. Lang.", articleno = "101154", fjournal = "Journal of Computer Languages", journal-URL = "https://www.sciencedirect.com/journal/journal-of-computer-languages", } @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 management and enforces automatic deallocation of unused resources without using the garbage collector. It may therefore falsely deallocate reclaimed memory and lead to use-after-free or double-free issues. In this article, we study the problem of invalid memory deallocation and propose SafeDrop, a static path-sensitive data-flow analysis approach to detect such bugs. Our approach analyzes each function of a Rust crate iteratively in a flow-sensitive and field-sensitive way. It leverages a modified Tarjan algorithm to achieve scalable path-sensitive analysis and a cache-based strategy for efficient inter-procedural analysis. We have implemented our approach and integrated it into the Rust compiler. Experiment results show that the approach can successfully detect all such bugs in our experiments with a limited number of false positives and incurs a very small overhead compared to the original compilation time.", 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{Cui:2024:RDM, author = "Mohan Cui and Hui Xu and Hongliang Tian and Yangfan Zhou", title = "{rCanary}: Detecting Memory Leaks Across Semi-Automated Memory Management Boundary in {Rust}", journal = j-IEEE-TRANS-SOFTW-ENG, volume = "50", number = "9", pages = "2472--2484", month = sep, year = "2024", CODEN = "IESEDJ", DOI = "https://doi.org/10.1109/TSE.2024.3443624", ISSN = "0098-5589 (print), 1939-3520 (electronic)", ISSN-L = "0098-5589", bibdate = "Wed Oct 23 14:46:33 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 = "boolean satisfiability; Computer languages; Manuals; Memory leak; Memory management; model check; ownership; Program processors; Resource management; rust; Safety; semi-automated memory management; Vectors", } @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{Nitin:2024:YAD, author = "Vikram Nitin and Anne Mulhern and Sanjay Arora and Baishakhi Ray", title = "{Yuga}: Automatically Detecting Lifetime Annotation Bugs in the {Rust} Language", journal = j-IEEE-TRANS-SOFTW-ENG, volume = "50", number = "10", pages = "2602--2613", month = oct, year = "2024", CODEN = "IESEDJ", DOI = "https://doi.org/10.1109/TSE.2024.3447671", ISSN = "0098-5589 (print), 1939-3520 (electronic)", ISSN-L = "0098-5589", bibdate = "Wed Oct 23 14:46:33 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, fjournal = "IEEE Transactions on Software Engineering", journal-URL = "https://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32", keywords = "Annotations; Codes; Computer bugs; lifetimes; Memory management; Rust; Safety; Security; Static analysis; static analysis", } @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{RobatiShirzad:2024:SCB, author = "Mohammad {Robati Shirzad} and Patrick Lam", title = "A study of common bug fix patterns in {Rust}", journal = j-EMPIR-SOFTWARE-ENG, volume = "29", number = "2", pages = "??--??", month = mar, year = "2024", CODEN = "ESENFW", DOI = "https://doi.org/10.1007/s10664-023-10437-1", ISSN = "1382-3256 (print), 1573-7616 (electronic)", ISSN-L = "1382-3256", bibdate = "Tue Sep 30 07:25:20 MDT 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib; https://www.math.utah.edu/pub/tex/bib/rust.bib", URL = "https://link.springer.com/article/10.1007/s10664-023-10437-1", acknowledgement = ack-nhfb, ajournal = "Empir. Software. Eng.", articleno = "44", fjournal = "Empirical Software Engineering", journal-URL = "http://link.springer.com/journal/10664", online-date = "12 February 2024", } @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 rates.io enables the growth of the Rust ecosystem but comes with security risks by severe security advisories. Although Rust guarantees a software program to be safe via programming language features and strict compile-time checking, the unsafe keyword in Rust allows developers to bypass compiler safety checks for certain regions of code. Prior studies empirically investigate the memory safety and concurrency bugs in the Rust ecosystem, as well as the usage of unsafe keywords in practice. Nonetheless, the literature lacks a systematic investigation of the security risks in the Rust ecosystem.\par In this article, we perform a comprehensive investigation into the security risks present in the Rust ecosystem, asking ``what are the characteristics of the vulnerabilities, what are the characteristics of the vulnerable packages, and how are the vulnerabilities fixed in practice?''. To facilitate the study, we first compile a dataset of 433 vulnerabilities, 300 vulnerable code repositories, and 218 vulnerability fix commits in the Rust ecosystem, spanning over 7 years. With the dataset, we characterize the types, life spans, and evolution of the disclosed vulnerabilities. We then characterize the popularity, categorization, and vulnerability density of the vulnerable Rust packages, as well as their versions and code regions affected by the disclosed vulnerabilities. Finally, we characterize the complexity of vulnerability fixes and localities of corresponding code changes, and inspect how practitioners fix vulnerabilities in Rust packages with various localities.\par We find that memory safety and concurrency issues account for nearly two thirds of the vulnerabilities in the Rust ecosystem. It takes over 2 years for the vulnerabilities to become publicly disclosed, and one-third of the vulnerabilities have no fixes committed before their disclosure. In terms of vulnerability density, we observe a continuous upward trend at the package level over time, but a decreasing trend at the code level since August 2020. In the vulnerable Rust packages, the vulnerable code tends to be localized at the file level, and contains statistically significantly more unsafe functions and blocks than the rest of the code. More popular packages tend to have more vulnerabilities, while the less popular packages suffer from vulnerabilities for more versions. The vulnerability fix commits tend to be localized to a limited number of lines of code. Developers tend to address vulnerable safe functions by adding safe functions or lines to them, vulnerable unsafe blocks by removing them, and vulnerable unsafe functions by modifying unsafe trait implementations. Based on our findings, we discuss implications, provide recommendations for software practitioners, and outline directions for future research.", 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", } @Article{Blinowski:2025:FTE, author = "Grzegorz Blinowski and Micha{\l} Szaknis", title = "Fuzzing trusted execution environments with {Rust}", journal = j-COMPUT-SECUR, volume = "150", number = "??", pages = "??--??", month = mar, year = "2025", CODEN = "CPSEDU", DOI = "https://doi.org/10.1016/j.cose.2024.104196", ISSN = "0167-4048 (print), 1872-6208 (electronic)", ISSN-L = "0167-4048", bibdate = "Wed Jan 22 05:34:19 MST 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/computsecur2020.bib; https://www.math.utah.edu/pub/tex/bib/rust.bib", URL = "https://www.sciencedirect.com/science/article/pii/S0167404824005017", acknowledgement = ack-nhfb, ajournal = "Comput. Secur.", articleno = "104196", fjournal = "Computers \& Security", journal-URL = "http://www.sciencedirect.com/science/journal/01674048", } @Article{Gupta:2025:HRT, author = "Nayancy Gupta and Gourinath Banda and Neminath Hubballi and K. V. Srinivas", title = "A Hard Real-Time Kernel for {CPIoT} Systems With Safety Features in {Rust}", journal = j-IEEE-ACCESS, volume = "13", pages = "116803--116817", year = "2025", DOI = "https://doi.org/10.1109/access.2025.3586018", ISSN = "2169-3536", ISSN-L = "2169-3536", bibdate = "Sun Oct 5 10:31:31 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib", acknowledgement = ack-nhfb, fjournal = "IEEE Access", journal-URL = "https://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=6287639", } @Article{Hamer:2025:TCW, author = "Sivana Hamer and Nasif Imtiaz and Mahzabin Tamanna and Preya Shabrina and Laurie Williams", title = "Trusting Code in the Wild: Exploring Contributor Reputation Measures to Review Dependencies in the {Rust} Ecosystem", journal = j-IEEE-TRANS-SOFTW-ENG, volume = "51", number = "4", pages = "1319--1333", month = apr, year = "2025", CODEN = "IESEDJ", DOI = "https://doi.org/10.1109/TSE.2025.3551664", ISSN = "0098-5589 (print), 1939-3520 (electronic)", ISSN-L = "0098-5589", bibdate = "Wed Sep 24 16:34:43 2025", 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 = "Atmospheric measurements; Codes; Collaboration; Ecosystems; Open source security; Particle measurements; Reviews; Security; Social networking (online); Software; software developer network; software measurement; software supply chain security; Supply chains", } @Article{Hong:2025:RAA, author = "Jaemin Hong and Sukyoung Ryu", title = "Research and Advances: Automatically Translating {C} to {Rust}", journal = j-CACM, volume = "68", number = "11", pages = "58--65", month = nov, year = "2025", CODEN = "CACMA2", DOI = "https://doi.org/10.1145/3737696", ISSN = "0001-0782 (print), 1557-7317 (electronic)", ISSN-L = "0001-0782", bibdate = "Thu Oct 30 17:32:46 MDT 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/cacm2020.bib; https://www.math.utah.edu/pub/tex/bib/rust.bib", abstract = "Legacy system programs developed in C have suffered from prevalent memory bugs. Migrating these systems to Rust is a promising way to enhance reliability, thanks to Rust's strong safety guarantee. Due to the high cost of manual migration, automatic C-to-Rust \ldots{}", acknowledgement = ack-nhfb, ajournal = "Commun. ACM", fjournal = "Communications of the ACM", journal-URL = "https://dl.acm.org/loi/cacm", } @Article{Hong:2025:TMC, author = "Jaemin Hong and Sukyoung Ryu", title = "Type-migrating {C-to-Rust} translation using a large language model", journal = j-EMPIR-SOFTWARE-ENG, volume = "30", number = "1", pages = "??--??", month = jan, year = "2025", CODEN = "ESENFW", DOI = "https://doi.org/10.1007/s10664-024-10573-2", ISSN = "1382-3256 (print), 1573-7616 (electronic)", ISSN-L = "1382-3256", bibdate = "Fri May 9 06:49:10 MDT 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib; https://www.math.utah.edu/pub/tex/bib/rust.bib", URL = "https://link.springer.com/article/10.1007/s10664-024-10573-2", acknowledgement = ack-nhfb, ajournal = "Empir. Software. Eng.", articleno = "3", fjournal = "Empirical Software Engineering", journal-URL = "http://link.springer.com/journal/10664", } @Article{Jiang:2025:TLG, author = "Renshuang Jiang and Pan Dong and Yan Ding and Ran Wei and Zhe Jiang", title = "Thetis-lathe: Guidance on Reducing Residual Safety Obstacle in System Software from {Rust} Source Codes", journal = j-TECS, volume = "24", number = "4", pages = "56:1--56:25", month = jul, year = "2025", CODEN = "????", DOI = "https://doi.org/10.1145/3736729", ISSN = "1539-9087 (print), 1558-3465 (electronic)", ISSN-L = "1539-9087", bibdate = "Tue Sep 23 06:45:59 MDT 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib; https://www.math.utah.edu/pub/tex/bib/tecs.bib", abstract = "Programming languages play a crucial role in ensuring the safety of the Operating System (OS). Traditional low-level languages (e.g., C, C++), while high-performance, usually offer very limited protections on safety, and their vulnerability patches (e.g., C, C++), while high-performance, usually offer very limited protections on safety, and their vulnerability patches (e.g., AddressSanitizer, DangSan), while effective in mitigating some issues, are often too expensive. Rust language combines memory safety with performance, providing a fresh paradigm for constructing efficient, reliable, and dependable. However, existing Rust rely on unsafe code fragments to interface with low-level hardware and other programming languages, introducing critical issues: (1) compromised system-wide safety due to the presence of unsafe code, (2) inaccurate defect detection because of unavoidable interactions between unsafe and safe code; and (3) difficulty in finding an optimal balance between accuracy and efficiency of defect detection and elimination.\par In contrast to the previous work, we believe --- ``prevention is always better than cure'' Therefore, we propose a new methodology (namely Thetis) to detect and guide the minimization of unsafe fragments in Rust source code. For unsafe code detection, Thetis designs an automated inspection method based on feature extraction. For unsafe code elimination based on Unsafe Rust types and interchangeability, Thetis prop defect optimization suggestions and designs a framework to automatically provide safer code recommendations. We have designed and implemented a new tool called Thetis-lathe based on Thetis and have also ported Thetis-lathe to three mainstream Rust applications, i.e., BlogOS, rCore, and Miri Failure Set. Evaluations show that our tool improved the accuracy of defects and decreased the amount of unsafe code by 35\% and undefined behavior by approximately 50\%. Furthermore, Thetis-lathe speeds up the run-time about $ 5 \times $ compared with the sanitizer and LMbench results indicate that our approach introduces 7.6\% (average) performance overhead on the entire system.", acknowledgement = ack-nhfb, ajournal = "ACM Trans. Embed. Comput. Syst.", articleno = "56", fjournal = "ACM Transactions on Embedded Computing Systems", journal-URL = "https://dl.acm.org/loi/tecs", } @Article{Leblanc:2025:SUR, author = "Hayley Leblanc and Nathan Taylor and James Bornholt and Vijay Chidambaram", title = "{SquirrelFS}: Using the {Rust} Compiler to Check File-System Crash Consistency", journal = j-TOS, volume = "21", number = "4", pages = "27:1--27:39", month = nov, year = "2025", CODEN = "????", DOI = "https://doi.org/10.1145/3769109", ISSN = "1553-3077 (print), 1553-3093 (electronic)", ISSN-L = "1553-3077", bibdate = "Thu Dec 18 09:33:56 MST 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib; https://www.math.utah.edu/pub/tex/bib/tos.bib", abstract = "This work introduces a new approach to building crash-safe file systems for persistent memory. We exploit the fact that Rust's typestate pattern allows compile-time enforcement of a specific order of operations. We introduce a novel crash-consistency mechanism, Synchronous Soft Updates, that boils down crash safety to enforcing ordering among updates to file-system metadata. We employ this approach to build SquirrelFS, a new file system with crash-consistency guarantees that are checked at compile time. SquirrelFS avoids the need for separate proofs, instead incorporating correctness guarantees into the typestate itself. Compiling SquirrelFS only takes tens of seconds; successful compilation indicates crash consistency, while an error provides a starting point for fixing the bug. We evaluate SquirrelFS against state-of-the-art file systems such as NOVA and WineFS, and find that SquirrelFS achieves similar or better performance on a wide range of benchmarks and applications.", acknowledgement = ack-nhfb, articleno = "27", fjournal = "ACM Transactions on Storage", journal-URL = "https://dl.acm.org/loi/tos", } @Article{Li:2025:DRU, author = "Chenghao Li and Yifei Wu and Wenbo Shen and Rui Chang and Chengwei Liu and Yang Liu", title = "Demystifying {Rust} Unstable Features at Ecosystem Scale: Evolution, Propagation, and Mitigation", journal = j-IEEE-TRANS-SOFTW-ENG, volume = "51", number = "4", pages = "1284--1302", month = apr, year = "2025", CODEN = "IESEDJ", DOI = "https://doi.org/10.1109/TSE.2025.3550160", ISSN = "0098-5589 (print), 1939-3520 (electronic)", ISSN-L = "0098-5589", bibdate = "Wed Sep 24 16:34:43 2025", 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 = "ecosystem analysis; Ecosystems; Libraries; Prevention and mitigation; rust compiler; Rust unstable feature; Safety; Security; Semantics; Software reliability; Source coding; Standards; Syntactics", } @Article{Li:2025:SSS, author = "Shaowen Li and Hiroyuiki Sato", title = "{SBD}: Securing safe {Rust} automatically from unsafe {Rust}", journal = j-SCI-COMPUT-PROGRAM, volume = "243", number = "??", pages = "??--??", month = jul, year = "2025", CODEN = "SCPGD4", DOI = "https://doi.org/10.1016/j.scico.2025.103281", ISSN = "0167-6423 (print), 1872-7964 (electronic)", ISSN-L = "0167-6423", bibdate = "Fri Mar 7 06:30:34 MST 2025", 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/S0167642325000206", acknowledgement = ack-nhfb, ajournal = "Sci. Comput. Program.", articleno = "103281", fjournal = "Science of Computer Programming", journal-URL = "http://www.sciencedirect.com/science/journal/01676423", } @Misc{Wallach:2025:TTA, author = "Dan Wallach", title = "{TRACTOR: Translating All C to Rust}", howpublished = "US Government DARPA Web site.", year = "2025", bibdate = "Thu Jul 17 13:50:37 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib", note = "Video presention (1h14m) of upcoming DARPA grant solicitation.", URL = "https://www.darpa.mil/research/programs/translating-all-c-to-rust", abstract = "After more than two decades of grappling with memory safety issues in C and C++, the software engineering community has reached a consensus. It's not enough to rely on bug-finding tools.\par The preferred approach is to use ``safe'' programming languages that can reject unsafe programs at compile time, thereby preventing the emergence of memory safety issues.\par The TRACTOR program aims to automate the translation of legacy C code to Rust. The goal is to achieve the same quality and style that a skilled Rust developer would produce, thereby eliminating the entire class of memory safety security vulnerabilities present in C programs.\par This program may involve novel combinations of software analysis, such as static analysis and dynamic analysis, and machine learning techniques like large language models.", acknowledgement = ack-nhfb, } @Article{Watson:2025:IRI, author = "Robert N. M. Watson and John Baldwin and David Chisnall and Tony Chen and Jessica Clarke and Brooks Davis and Nathaniel Filardo and Brett Gutstein and Graeme Jenkinson and Ben Laurie and Alfredo Mazzinghi and Simon Moore and Peter G. Neumann and Hamed Okhravi and Alex Richardson and Alex Rebert and Peter Sewell and Laurence Tratt and Murali Vijayaraghavan and Hugo Vincent and Konrad Witaszczyk", title = "Inside Risks: It Is Time to Standardize Principles and Practices for Software Memory Safety", journal = j-CACM, volume = "68", number = "2", pages = "40--45", month = feb, year = "2025", CODEN = "CACMA2", DOI = "https://doi.org/10.1145/3708553", ISSN = "0001-0782 (print), 1557-7317 (electronic)", ISSN-L = "0001-0782", bibdate = "Wed Jan 22 09:53:46 MST 2025", 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/3708553", abstract = "Twenty-one authors, spanning academia and industry, with expertise in memory-safety research, deployment, and policy, argue that standardization is an essential next step to achieving universal strong memory safety.", acknowledgement = ack-nhfb, ajournal = "Commun. ACM", fjournal = "Communications of the ACM", journal-URL = "https://dl.acm.org/loi/cacm", } @Article{Zhang:2025:RFD, author = "Yehong Zhang and Jun Wu and Hui Xu", title = "{RuMono}: Fuzz Driver Synthesis for {Rust} Generic {APIs}", journal = j-TOSEM, volume = "34", number = "6", pages = "169:1--169:??", month = jul, year = "2025", CODEN = "ATSMER", DOI = "https://doi.org/10.1145/3709359", ISSN = "1049-331X (print), 1557-7392 (electronic)", ISSN-L = "1049-331X", bibdate = "Fri Jul 25 08:10:07 MDT 2025", bibsource = "https://www.math.utah.edu/pub/tex/bib/rust.bib; https://www.math.utah.edu/pub/tex/bib/tosem.bib", abstract = "Fuzzing is a popular technique for detecting bugs, which can be extended to libraries by constructing executables that call library APIs, known as fuzz drivers. Automated fuzz driver synthesis has been an important research topic in recent years since it can facilitate the library fuzzing process. Nevertheless, existing approaches generally ignore generic APIs or simply treat them as non-generic APIs. As a result, they cannot generate effective fuzz drivers for generic APIs.\par This article explores the challenge of automating fuzz driver synthesis for Rust libraries with generic APIs. The problem is essential because Rust prioritizes security and generic APIs are widely employed in Rust libraries. We propose a novel approach and develop a prototype, RuMono, to tackle the problem. Our approach initially infers the API reachability from the generic API dependency graph, discovering the reachable and valid monomorphic APIs within the library. Further, we apply a similarity-based filter to eliminate redundant monomorphic APIs. Experimental results from 29 popular open source libraries demonstrate that RuMono can achieve promising generic API coverage with a low rate of invalid fuzz drivers. Besides, we have identified 23 previously unknown bugs in these libraries, with 18 related to generic APIs.", acknowledgement = ack-nhfb, ajournal = "ACM Trans. Softw. Eng. Methodol.", articleno = "169", 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, }