Valid HTML 4.0! Valid CSS!
%%% -*-BibTeX-*-
%%% ====================================================================
%%%  BibTeX-file{
%%%     author          = "Nelson H. F. Beebe",
%%%     version         = "1.04",
%%%     date            = "09 April 2021",
%%%     time            = "15:14:02 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",
%%%     FAX             = "+1 801 581 4148",
%%%     URL             = "http://www.math.utah.edu/~beebe",
%%%     checksum        = "09423 4181 20593 199416",
%%%     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.04, the year coverage looked
%%%                        like this:
%%%
%%%                             2013 (   1)    2016 (   3)    2019 (  19)
%%%                             2014 (   1)    2017 (   7)    2020 (  26)
%%%                             2015 (   5)    2018 (  18)    2021 (   3)
%%%
%%%                             Article:         15
%%%                             Book:            20
%%%                             InCollection:     4
%%%                             InProceedings:   43
%%%                             TechReport:       1
%%%
%%%                             Total entries:   83
%%%
%%%                        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" #
  "\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,
                    FAX: +1 801 581 4148,
                    e-mail: \path|beebe@math.utah.edu|,
                            \path|beebe@acm.org|,
                            \path|beebe@computer.org| (Internet),
                    URL: \path|http://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-IEEE-TRANS-NETWORKING = "IEEE\slash ACM Transactions on Networking"}

@String{j-IEEE-TRANS-SOFTW-ENG  = "IEEE Transactions on Software Engineering"}

@String{j-J-SYST-SOFTW          = "The Journal of Systems and Software"}

@String{j-OPER-SYS-REV          = "Operating Systems Review"}

@String{j-PACMPL                = "Proceedings of the ACM on Programming
                                   Languages (PACMPL)"}

@String{j-SIGADA-LETTERS        = "ACM SIGADA Ada Letters"}

@String{j-SOFTWAREX             = "SoftwareX"}

%%% ====================================================================
%%% 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-NO-STARCH           = "No Starch Press"}
@String{pub-NO-STARCH:adr       = "San Francisco, CA, 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'':
@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 =    "http://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 =    "http://www.math.utah.edu/pub/tex/bib/rust.bib;
                 http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://www.math.utah.edu/pub/tex/bib/ora.bib;
                 http://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 =    "http://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 =    "http://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 =    "http://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 =    "http://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 =    "http://www.math.utah.edu/pub/tex/bib/csharp.bib;
                 http://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 =    "http://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/;
                 http://www.math.utah.edu/pub/tex/bib/opersysrev.bib;
                 http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 http://www.math.utah.edu/pub/tex/bib/ora.bib;
                 http://www.math.utah.edu/pub/tex/bib/rust.bib",
  URL =          "http://proquest.safaribooksonline.com/9781491927274",
  abstract =     "Rust is a new systems programming language that
                 combines the performance and low-level control of C and
                 C++ with memory safety and thread safety. Rust's
                 modern, flexible types ensure your program is free of
                 null pointer dereferences, double frees, dangling
                 pointers, and similar bugs, all at compile time,
                 without runtime overhead. In multithreaded code, Rust
                 catches data races at compile time, making concurrency
                 much easier to use. Written by two experienced systems
                 programmers, this book explains how Rust manages to
                 bridge the gap between performance and safety, and how
                 you can take advantage of it. Topics include: How Rust
                 represents values in memory (with diagrams) Complete
                 explanations of ownership, moves, borrows, and
                 lifetimes Cargo, rustdoc, unit tests, and how to
                 publish your code on crates.io, Rust's public package
                 repository High-level features like generic code,
                 closures, collections, and iterators that make Rust
                 productive and flexible Concurrency in Rust: threads,
                 mutexes, channels, and atomics, all much safer to use
                 than in C or C++ Unsafe code, and how to preserve the
                 integrity of ordinary code that uses it. Extended
                 examples illustrating how pieces of the language fit
                 together.",
  acknowledgement = ack-nhfb,
  keywords =     "Rust programming language",
  libnote =      "Not in my library.",
  subject =      "UNIX (Computer file); UNIX (Computer file); C
                 (Computer program language); Text editors (Computer
                 programs); Software engineering; C (Computer program
                 language); Software engineering.; Text editors
                 (Computer programs)",
  tableofcontents = "Preface \\
                 Who Should Read This Book \\
                 Why We Wrote This Book \\
                 Navigating This Book \\
                 Conventions Used in This Book \\
                 Using Code Examples \\
                 O Reilly Safari \\
                 How to Contact Us \\
                 Acknowledgments \\
                 1. Why Rust? \\
                 Type Safety \\
                 2. A Tour of Rust \\
                 Downloading and Installing Rust \\
                 A Simple Function \\
                 Writing and Running Unit Tests \\
                 Handling Command-Line Arguments \\
                 A Simple Web Server \\
                 Concurrency \\
                 What the Mandelbrot Set Actually Is \\
                 Parsing Pair Command-Line Arguments \\
                 Mapping from Pixels to Complex Numbers \\
                 Plotting the Set \\
                 Writing Image Files \\
                 A Concurrent Mandelbrot Program \\
                 Running the Mandelbrot Plotter \\
                 Safety Is Invisible \\
                 3. Basic Types \\
                 Machine Types \\
                 Integer Types \\
                 Floating-Point Types \\
                 The bool Type \\
                 Characters \\
                 Tuples \\
                 Pointer Types \\
                 References \\
                 Boxes \\
                 Raw Pointers \\
                 Arrays, Vectors, and Slices \\
                 Arrays \\
                 Vectors \\
                 Slices \\
                 String Types \\
                 String Literals \\
                 Byte Strings \\
                 Strings in Memory \\
                 String \\
                 Using Strings \\
                 Other String-Like Types \\
                 Beyond the Basics \\
                 4. Ownership \\
                 Ownership \\
                 Moves \\
                 More Operations That Move \\
                 Moves and Control Flow \\
                 Moves and Indexed Content \\
                 Copy Types: The Exception to Moves \\
                 Rc and Arc: Shared Ownership \\
                 5. References \\
                 References as Values \\
                 Rust References Versus C++ References \\
                 Assigning References \\
                 References to References \\
                 Comparing References \\
                 References Are Never Null \\
                 Borrowing References to Arbitrary Expressions \\
                 References to Slices and Trait Objects \\
                 Reference Safety \\
                 Borrowing a Local Variable \\
                 Receiving References as Parameters \\
                 Passing References as Arguments \\
                 Returning References \\
                 Structs Containing References \\
                 Distinct Lifetime Parameters \\
                 Omitting Lifetime Parameters \\
                 Sharing Versus Mutation \\
                 Taking Arms Against a Sea of Objects \\
                 6. Expressions \\
                 An Expression Language \\
                 Blocks and Semicolons \\
                 Declarations \\
                 if and match \\
                 if let \\
                 Loops \\
                 return Expressions \\
                 Why Rust Has loop \\
                 Function and Method Calls \\
                 Fields and Elements \\
                 Reference Operators \\
                 Arithmetic, Bitwise, Comparison, and Logical Operators
                 \\
                 Assignment \\
                 Type Casts \\
                 Closures \\
                 Precedence and Associativity \\
                 Onward \\
                 7. Error Handling \\
                 Panic \\
                 Unwinding \\
                 Aborting \\
                 Result \\
                 Catching Errors \\
                 Result Type Aliases \\
                 Printing Errors \\
                 Propagating Errors \\
                 Working with Multiple Error Types \\
                 Dealing with Errors That Can t Happen \\
                 Ignoring Errors \\
                 Handling Errors in main() \\
                 Declaring a Custom Error Type \\
                 Why Results? \\
                 8. Crates and Modules \\
                 Crates \\
                 Build Profiles \\
                 Modules \\
                 Modules in Separate Files \\
                 Paths and Imports \\
                 The Standard Prelude \\
                 Items, the Building Blocks of Rust \\
                 Turning a Program into a Library \\
                 The src/bin Directory \\
                 Attributes \\
                 Tests and Documentation \\
                 Integration Tests \\
                 Documentation \\
                 Doc-Tests \\
                 Specifying Dependencies \\
                 Versions \\
                 Cargo.lock \\
                 Publishing Crates to crates.io \\
                 Workspaces \\
                 More Nice Things \\
                 9. Structs \\
                 Named-Field Structs \\
                 Tuple-Like Structs \\
                 Unit-Like Structs \\
                 Struct Layout \\
                 Defining Methods with impl \\
                 Generic Structs \\
                 Structs with Lifetime Parameters \\
                 Deriving Common Traits for Struct Types \\
                 Interior Mutability \\
                 10. Enums and Patterns \\
                 Enums \\
                 Enums with Data \\
                 Enums in Memory \\
                 Rich Data Structures Using Enums \\
                 Generic Enums \\
                 Patterns \\
                 Literals, Variables, and Wildcards in Patterns \\
                 Tuple and Struct Patterns \\
                 Reference Patterns \\
                 Matching Multiple Possibilities \\
                 Pattern Guards \\
                 @ patterns \\
                 Where Patterns Are Allowed \\
                 Populating a Binary Tree \\
                 The Big Picture \\
                 11. Traits and Generics \\
                 Using Traits \\
                 Trait Objects \\
                 Trait Object Layout \\
                 Generic Functions \\
                 Which to Use \\
                 Defining and Implementing Traits \\
                 Default Methods \\
                 Traits and Other People s Types \\
                 Self in Traits \\
                 Subtraits \\
                 Static Methods \\
                 Fully Qualified Method Calls \\
                 Traits That Define Relationships Between Types \\
                 Associated Types (or How Iterators Work) \\
                 Generic Traits (or How Operator Overloading Works) \\
                 Buddy Traits (or How rand::random() Works) \\
                 Reverse-Engineering Bounds \\
                 Conclusion \\
                 12. Operator Overloading \\
                 Arithmetic and Bitwise Operators \\
                 Unary Operators \\
                 Binary Operators \\
                 Compound Assignment Operators \\
                 Equality Tests \\
                 Ordered Comparisons \\
                 Index and IndexMut \\
                 Other Operators \\
                 13. Utility Traits \\
                 Drop \\
                 Sized \\
                 Clone \\
                 Copy \\
                 Deref and DerefMut \\
                 Default \\
                 AsRef and AsMut \\
                 Borrow and BorrowMut \\
                 From and Into \\
                 ToOwned \\
                 Borrow and ToOwned at Work: The Humble Cow \\
                 14. Closures \\
                 Capturing Variables \\
                 Closures That Borrow \\
                 Closures That Steal \\
                 Function and Closure Types \\
                 Closure Performance \\
                 Closures and Safety \\
                 Closures That Kill \\
                 FnOnce \\
                 FnMut \\
                 Callbacks \\
                 Using Closures Effectively \\
                 15. Iterators \\
                 The Iterator and IntoIterator Traits \\
                 Creating Iterators \\
                 iter and iter_mut Methods \\
                 IntoIterator Implementations \\
                 drain Methods \\
                 Other Iterator Sources \\
                 Iterator Adapters \\
                 map and filter \\
                 filter_map and flat_map \\
                 scan \\
                 take and take_while \\
                 skip and skip_while \\
                 peekable \\
                 fuse \\
                 Reversible Iterators and rev \\
                 inspect \\
                 chain \\
                 enumerate \\
                 zip \\
                 by_ref \\
                 cloned \\
                 cycle \\
                 Consuming Iterators \\
                 Simple Accumulation: count, sum, product \\
                 max, min \\
                 max_by, min_by \\
                 max_by_key, min_by_key \\
                 Comparing Item Sequences \\
                 any and all \\
                 position, rposition, and ExactSizeIterator \\
                 fold \\
                 nth \\
                 last \\
                 find \\
                 Building Collections: collect and FromIterator \\
                 The Extend Trait \\
                 partition \\
                 Implementing Your Own Iterators \\
                 16. Collections \\
                 Overview \\
                 Vec<T> \\
                 Accessing Elements \\
                 Iteration \\
                 Growing and Shrinking Vectors \\
                 Joining \\
                 Splitting \\
                 Swapping \\
                 Sorting and Searching \\
                 Comparing Slices \\
                 Random Elements \\
                 Rust Rules Out Invalidation Errors \\
                 VecDeque<T> \\
                 LinkedList<T> \\
                 BinaryHeap<T> \\
                 HashMap<K, V> and BTreeMap<K, V> \\
                 Entries \\
                 Map Iteration \\
                 HashSet<T> and BTreeSet<T> \\
                 Set Iteration \\
                 When Equal Values Are Different \\
                 Whole-Set Operations \\
                 Hashing \\
                 Using a Custom Hashing Algorithm \\
                 Beyond the Standard Collections \\
                 17. Strings and Text \\
                 Some Unicode Background \\
                 ASCII, Latin-1, and Unicode \\
                 UTF-8 \\
                 Text Directionality \\
                 Characters (char) \\
                 Classifying Characters \\
                 Handling Digits \\
                 Case Conversion for Characters \\
                 Conversions to and from Integers \\
                 String and str \\
                 Creating String Values \\
                 Simple Inspection \\
                 Appending and Inserting Text \\
                 Removing Text \\
                 Conventions for Searching and Iterating \\
                 Patterns for Searching Text \\
                 Searching and Replacing \\
                 Iterating over Text \\
                 Trimming \\
                 Case Conversion for Strings \\
                 Parsing Other Types from Strings \\
                 Converting Other Types to Strings \\
                 Borrowing as Other Text-Like Types \\
                 Accessing Text as UTF-8 \\
                 Producing Text from UTF-8 Data \\
                 Putting Off Allocation \\
                 Strings as Generic Collections \\
                 Formatting Values \\
                 Formatting Text Values \\
                 Formatting Numbers \\
                 Formatting Other Types \\
                 Formatting Values for Debugging \\
                 Formatting Pointers for Debugging \\
                 Referring to Arguments by Index or Name \\
                 Dynamic Widths and Precisions \\
                 Formatting Your Own Types \\
                 Using the Formatting Language in Your Own Code \\
                 Regular Expressions \\
                 Basic Regex Use \\
                 Building Regex Values Lazily \\
                 Normalization \\
                 Normalization Forms \\
                 The unicode-normalization Crate \\
                 18. Input and Output \\
                 Readers and Writers \\
                 Readers \\
                 Buffered Readers \\
                 Reading Lines \\
                 Collecting Lines \\
                 Writers \\
                 Files \\
                 Seeking \\
                 Other Reader and Writer Types \\
                 Binary Data, Compression, and Serialization \\
                 Files and Directories \\
                 OsStr and Path \\
                 Path and PathBuf Methods \\
                 Filesystem Access Functions \\
                 Reading Directories \\
                 Platform-Specific Features \\
                 Networking \\
                 19. Concurrency \\
                 Fork-Join Parallelism \\
                 spawn and join \\
                 Error Handling Across Threads \\
                 Sharing Immutable Data Across Threads \\
                 Rayon \\
                 Revisiting the Mandelbrot Set \\
                 Channels \\
                 Sending Values \\
                 Receiving Values \\
                 Running the Pipeline \\
                 Channel Features and Performance \\
                 Thread Safety: Send and Sync \\
                 Piping Almost Any Iterator to a Channel \\
                 Beyond Pipelines \\
                 Shared Mutable State \\
                 What Is a Mutex? \\
                 Mutex<T> \\
                 mut and Mutex \\
                 Why Mutexes Are Not Always a Good Idea \\
                 Deadlock \\
                 Poisoned Mutexes \\
                 Multi-Consumer Channels Using Mutexes \\
                 Read/Write Locks (RwLock<T>) \\
                 Condition Variables (Condvar) \\
                 Atomics \\
                 Global Variables \\
                 What Hacking Concurrent Code in Rust Is Like \\
                 20. Macros \\
                 Macro Basics \\
                 Basics of Macro Expansion \\
                 Unintended Consequences \\
                 Repetition \\
                 Built-In Macros \\
                 Debugging Macros \\
                 The json! Macro \\
                 Fragment Types \\
                 Recursion in Macros \\
                 Using Traits with Macros \\
                 Scoping and Hygiene \\
                 Importing and Exporting Macros \\
                 Avoiding Syntax Errors During Matching \\
                 Beyond macro_rules! \\
                 21. Unsafe Code \\
                 Unsafe from What? \\
                 Unsafe Blocks \\
                 Example: An Efficient ASCII String Type \\
                 Unsafe Functions \\
                 Unsafe Block or Unsafe Function? \\
                 Undefined Behavior \\
                 Unsafe Traits \\
                 Raw Pointers \\
                 Dereferencing Raw Pointers Safely \\
                 Example: RefWithFlag \\
                 Nullable Pointers \\
                 Type Sizes and Alignments \\
                 Pointer Arithmetic \\
                 Moving into and out of Memory \\
                 Example: GapBuffer \\
                 Panic Safety in Unsafe Code \\
                 Foreign Functions: Calling C and C++ from Rust \\
                 Finding Common Data Representations \\
                 Declaring Foreign Functions and Variables \\
                 Using Functions from Libraries \\
                 A Raw Interface to libgit2 \\
                 A Safe Interface to libgit2 \\
                 Conclusion \\
                 Index",
}

@InProceedings{Chifflier:2017:WPL,
  author =       "P. Chifflier and G. Couprie",
  booktitle =    "{2017 IEEE Security and Privacy Workshops (SPW)}",
  title =        "Writing Parsers Like it is 2017",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "80--92",
  year =         "2017",
  DOI =          "https://doi.org/10.1109/SPW.2017.39",
  bibdate =      "Thu Apr 8 06:41:17 2021",
  bibsource =    "http://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 =    "http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 http://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 =    "http://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 =    "http://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 =    "http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://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 =    "http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://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 =    "http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
                 http://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 =    "http://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 =    "http://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
                 http://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 =    "http://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 =    "http://www.math.utah.edu/pub/tex/bib/rust.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Rust programming language",
}

@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 =    "http://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 =    "http://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 =    "http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 http://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 =    "http://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 =    "http://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 =    "http://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 =    "http://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
                 http://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 =    "http://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 =    "http://www.math.utah.edu/pub/bibnet/authors/b/beebe-nelson-h-f.bib;
                 http://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 =    "http://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 =    "http://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-09-812253-4, 1-71850-044-0 (paperback)",
  ISBN-13 =      "978-1-09-812253-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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 http://www.math.utah.edu/pub/tex/bib/rust.bib",
  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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://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 =    "http://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 =    "http://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib;
                 http://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 =    "http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://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 =    "http://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 =    "http://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 =    "http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://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;
                 http://www.math.utah.edu/pub/tex/bib/master.bib;
                 http://www.math.utah.edu/pub/tex/bib/rust.bib",
  URL =          "http://proquest.safaribooksonline.com/?fpi=9781789346572",
  abstract =     "Rust is an empowering language that provides a rare
                 combination of safety, speed, and zero-cost
                 abstractions. \booktitle{Mastering Rust} --- Second
                 Edition is filled with clear and simple explanations of
                 the language features along with real-world examples,
                 showing you how you can build robust, scalable, and
                 reliable programs. This second edition of the book
                 improves upon the previous one and touches on all
                 aspects that make Rust a great language. We have
                 included the features from latest Rust 2018 edition
                 such as the new module system, the smarter compiler,
                 helpful error messages, and the stable procedural
                 macros. You'll learn how Rust can be used for systems
                 programming, network programming, and even on the web.
                 You'll also learn techniques such as writing
                 memory-safe code, building idiomatic Rust libraries,
                 writing efficient asynchronous networking code, and
                 advanced macros. The book contains a mix of theory and
                 hands-on tasks so you acquire the skills as well as the
                 knowledge, and it also provides exercises to hammer the
                 concepts in. After reading this book, you will be able
                 to implement Rust for your enterprise projects, write
                 better tests and documentation, design for performance,
                 and write idiomatic Rust code. What you will learn
                 Write generic and type-safe code by using Rust's
                 powerful type system How memory safety works without
                 garbage collection Know the different strategies in
                 error handling and when to use them Learn how to use
                 concurrency primitives such as threads and channels Use
                 advanced macros to reduce boilerplate code Create
                 efficient web applications with the Actix-web framework
                 Use Diesel for type-safe database interactions in your
                 web application Who this book is for The book is aimed
                 at beginner and intermediate programmers who already
                 have familiarity with any imperative language and have
                 only heard of Rust as a new language. If you are a
                 developer who wants to write robust, efficient and
                 maintainable software systems and want to become
                 proficient with Rust, this book is for you.",
  acknowledgement = ack-nhfb,
  keywords =     "Rust programming language",
  libnote =      "Not in my library.",
  remark =       "Previous edition published: 2017.",
  subject =      "Rust (Computer program language); Application
                 software; Development; Development.; Rust (Computer
                 program language)",
  tableofcontents = "Preface / 1 \\
                 Chapter 1: Getting Started with Rust / 7 \\
                 What is Rust and why should you care? / 8 \\
                 Installing the Rust compiler and toolchain / 15 \\
                 Using rustup.rs / 15 \\
                 A tour of the language / 18 \\
                 Primitive types / 21 \\
                 Declaring variables and immutability / 22 \\
                 Functions / 23 \\
                 Closures / 25 \\
                 Strings / 26 \\
                 Conditionals and decision making / 27 \\
                 Match expressions / 29 \\
                 Loops / 30 \\
                 User-defined types / 32 \\
                 Structs / 33 \\
                 Enums / 35 \\
                 Functions and methods on types / 37 \\
                 Impl blocks on structs / 38 \\
                 Impl blocks for enums / 40 \\
                 Modules, imports, and use statements / 42 \\
                 Collections / 42 \\
                 Arrays / 43 \\
                 Tuples / 43 \\
                 Vectors / 44 \\
                 Hashmaps / 44 \\
                 Slices / 45 \\
                 Iterators / 47 \\
                 Exercise fixing the word counter / 48 \\
                 Summary / 49 \\
                 Chapter 2: Managing Projects with Cargo / 50 \\
                 Package managers / 51 \\
                 Modules / 51 \\
                 Nested modules / 52 \\
                 File as a module / 54 \\
                 Directory as module / 55 \\
                 Cargo and crates / 57 \\
                 Creating a new Cargo project / 59 \\
                 Cargo and dependencies / 61 \\
                 Running tests with Cargo / 63 \\
                 Running examples with Cargo / 66 \\
                 Cargo workspace / 66 \\
                 Extending Cargo and tools / 68 \\
                 Subcommands and Cargo installation / 68 \\
                 cargo-watch / 68 \\
                 cargo-edit / 69 \\
                 cargo-deb / 69 \\
                 cargo-outdated / 70 \\
                 Linting code with clippy / 70 \\
                 Exploring the manifest file Cargo.toml / 71 \\
                 Setting up a Rust development environment / 74 \\
                 Building a project with Cargo imgtool / 78 \\
                 Summary / 81 \\
                 Chapter 3: Tests, Documentation, and Benchmarks / 82
                 \\
                 Motivation for testing / 83 \\
                 Organizing tests / 84 \\
                 Testing primitives / 84 \\
                 Attributes / 85 \\
                 Assertion macros / 86 \\
                 Unit tests / 87 \\
                 First unit test / 87 \\
                 Running tests / 88 \\
                 Isolating test code / 88 \\
                 Failing tests / 90 \\
                 Ignoring tests / 90 \\
                 Integration tests / 91 \\
                 First integration test / 92 \\
                 Sharing common code / 93 \\
                 Documentation / 95 \\
                 Writing documentation / 95 \\
                 Generating and viewing documentation / 96 \\
                 Hosting documentation / 96 \\
                 Doc attributes / 97 \\
                 Documentation tests / 98 \\
                 Benchmarks / 99 \\
                 Built-in micro-benchmark harness / 100 \\
                 Benchmarking on stable Rust / 102 \\
                 Writing and testing a crate logic gate simulator / 105
                 \\
                 Continuous integration with Travis CI / 109 \\
                 Summary / 113 \\
                 Chapter 4: Types, Generics, and Traits / 114 \\
                 Type systems and why they matter / 114 \\
                 Generics / 116 \\
                 Creating generic types / 117 \\
                 Generic functions / 118 \\
                 Generic types / 119 \\
                 Generic implementations / 119 \\
                 Using generics / 121 \\
                 Abstracting behavior with traits / 123 \\
                 Traits / 124 \\
                 The many forms of traits / 130 \\
                 Marker traits / 130 \\
                 Simple traits / 131 \\
                 Generic traits / 131 \\
                 Associated type traits / 131 \\
                 Inherited traits / 132 \\
                 Using traits with generics trait bounds / 132 \\
                 Trait bounds on types / 136 \\
                 Trait bounds on generic functions and impl blocks / 137
                 \\
                 Using + to compose traits as bounds / 138 \\
                 Trait bounds with impl trait syntax / 139 \\
                 Exploring standard library traits / 141 \\
                 True polymorphism using trait objects / 148 \\
                 Dispatch / 149 \\
                 Trait objects / 150 \\
                 Summary / 152 \\
                 Chapter 5: Memory Management and Safety / 153 \\
                 Programs and memory / 154 \\
                 How do programs use memory? / 156 \\
                 Memory management and its kinds / 157 \\
                 Approaches to memory allocation / 158 \\
                 The stack / 158 \\
                 The heap / 160 \\
                 Memory management pitfalls / 162 \\
                 Memory safety / 162 \\
                 Trifecta of memory safety / 165 \\
                 Ownership / 165 \\
                 A brief on scopes / 167 \\
                 Move and copy semantics / 169 \\
                 Duplicating types via traits / 170 \\
                 Copy / 171 \\
                 Clone / 171 \\
                 Ownership in action / 173 \\
                 Borrowing / 178 \\
                 Borrowing rules / 180 \\
                 Borrowing in action / 181 \\
                 Method types based on borrowing / 183 \\
                 Lifetimes / 184 \\
                 Lifetime parameters / 185 \\
                 Lifetime elision and the rules / 186 \\
                 Lifetimes in user defined types / 188 \\
                 Lifetime in impl blocks / 188 \\
                 Multiple lifetimes / 189 \\
                 Lifetime subtyping / 189 \\
                 Specifying lifetime bounds on generic types / 190 \\
                 Pointer types in Rust / 192 \\
                 References safe pointers / 193 \\
                 Raw pointers / 193 \\
                 Smart pointers / 194 \\
                 Drop / 194 \\
                 Deref and DerefMut / 196 \\
                 Types of smart pointers / 196 \\
                 Box<T> / 197 \\
                 Reference counted smart pointers / 199 \\
                 Rc<T> / 200 \\
                 Interior mutability / 205 \\
                 Cell<T> / 205 \\
                 RefCell<T> / 207 \\
                 Uses of interior mutability / 208 \\
                 Summary / 210 \\
                 Chapter 6: Error Handling / 211 \\
                 Error handling prelude / 211 \\
                 Recoverable errors / 214 \\
                 Option / 214 \\
                 Result / 218 \\
                 Combinators on Option/Result / 222 \\
                 Common combinators / 223 \\
                 Using combinators / 224 \\
                 Converting between Option and Result / 226 \\
                 Early returns and the ? operator / 226 \\
                 Non-recoverable errors / 228 \\
                 User-friendly panics / 232 \\
                 Custom errors and the Error trait / 232 \\
                 Summary / 237 \\
                 Chapter 7: Advanced Concepts / 238 \\
                 Type system tidbits / 238 \\
                 Blocks and expressions / 239 \\
                 Let statements / 242 \\
                 Loop as an expression / 247 \\
                 Type clarity and sign distinction in numeric types /
                 248 \\
                 Type inference / 250 \\
                 Type aliases / 252 \\
                 Strings / 253 \\
                 Owned strings String / 254 \\
                 Borrowed strings &str / 256 \\
                 Slicing and dicing strings / 258 \\
                 Using strings in functions / 259 \\
                 Joining strings / 260 \\
                 When to use &str versus String ? / 261 \\
                 Global values / 261 \\
                 Constants / 262 \\
                 Statics / 262 \\
                 Compile time functions const fn / 263 \\
                 Dynamic statics using the lazy_static! macro / 264 \\
                 Iterators / 265 \\
                 Implementing a custom iterator / 266 \\
                 Advanced types / 270 \\
                 Unsized types / 270 \\
                 Function types / 271 \\
                 Never type ! and diverging functions / 272 \\
                 Unions / 272 \\
                 Cow / 273 \\
                 Advanced traits / 274 \\
                 Sized and ?Sized / 274 \\
                 Borrow and AsRef / 274 \\
                 ToOwned / 274 \\
                 From and Into / 275 \\
                 Trait objects and object safety / 275 \\
                 Universal function call syntax / 276 \\
                 Trait rules / 277 \\
                 Closures in depth / 277 \\
                 Fn closures / 278 \\
                 FnMut closures / 278 \\
                 FnOnce closures / 279 \\
                 Consts in structs, enums, and traits / 280 \\
                 Modules, paths, and imports / 281 \\
                 Imports / 282 \\
                 Re-exports / 282 \\
                 Selective privacy / 283 \\
                 Advanced match patterns and guards / 283 \\
                 Match guards / 284 \\
                 Advanced let destructure / 284 \\
                 Casting and coercion / 285 \\
                 Types and memory / 286 \\
                 Memory alignment / 286 \\
                 Exploring the std::mem module / 287 \\
                 Serialization and deserialization using serde / 289 \\
                 Summary / 290 \\
                 Chapter 8: Concurrency / 291 \\
                 Program execution models / 292 \\
                 Concurrency / 293 \\
                 Approaches to concurrency / 294 \\
                 Kernel-based / 294 \\
                 User-level / 295 \\
                 Pitfalls / 296 \\
                 Concurrency in Rust / 298 \\
                 Thread basics / 299 \\
                 Customizing threads / 301 \\
                 Accessing data from threads / 302 \\
                 Concurrency models with threads / 304 \\
                 Shared state model / 304 \\
                 Shared ownership with Arc / 306 \\
                 Mutating shared data from threads / 307 \\
                 Mutex / 308 \\
                 Shared mutability with Arc and Mutex / 309 \\
                 RwLock / 310 \\
                 Communicating through message passing / 311 \\
                 Asynchronous channels / 311 \\
                 Synchronous channels / 313 \\
                 thread-safety in Rust / 314 \\
                 What is thread-safety? / 314 \\
                 Traits for thread-safety / 315 \\
                 Send / 315 \\
                 Sync / 316 \\
                 Concurrency using the actor model / 316 \\
                 Other crates / 319 \\
                 Summary / 319 \\
                 Chapter 9: Metaprogramming with Macros / 320 \\
                 What is metaprogramming? / 320 \\
                 When to use and not use Rust macros / 323 \\
                 Macros in Rust and their types / 324 \\
                 Types of macros / 327 \\
                 Creating your first macro with macro_rules! / 328 \\
                 Built-in macros in the standard library / 331 \\
                 macro_rules! token types / 332 \\
                 Repetitions in macros / 336 \\
                 A more involved macro writing a DSL for HashMap
                 initialization / 337 \\
                 Macro use case writing tests / 339 \\
                 Exercises / 341 \\
                 Procedural macros / 342 \\
                 Derive macros / 343 \\
                 Debugging macros / 349 \\
                 Useful procedural macro crates / 351 \\
                 Summary / 351 \\
                 Chapter 10: Unsafe Rust and Foreign Function Interfaces
                 / 352 \\
                 What is safe and unsafe really? / 352 \\
                 Unsafe functions and blocks / 357 \\
                 Unsafe traits and implementations / 360 \\
                 Calling C code from Rust / 362 \\
                 Calling Rust code from C / 366 \\
                 Using external C/C++ libraries from Rust / 369 \\
                 Creating native Python extensions with PyO3 / 372 \\
                 Creating native extensions in Rust for Node.js / 375
                 \\
                 Summary / 380 \\
                 Chapter 11: Logging / 381 \\
                 What is logging and why do we need it? / 381 \\
                 The need for logging frameworks / 383 \\
                 Logging frameworks and their key features / 384 \\
                 Approaches to logging / 386 \\
                 Unstructured logging / 386 \\
                 Structured logging / 386 \\
                 Logging in Rust / 387 \\
                 log Rust's logging facade / 388 \\
                 The env_logger / 390 \\
                 log4rs / 391 \\
                 Structured logging using slog / 393 \\
                 Summary / 399 \\
                 Chapter 12: Network Programming in Rust / 400 \\
                 Network programming prelude / 400 \\
                 Synchronous network I/O / 403 \\
                 Building a synchronous redis server / 404 \\
                 Asynchronous network I/O / 411 \\
                 Async abstractions in Rust / 412 \\
                 Mio / 412 \\
                 Futures / 413 \\
                 Tokio / 413 \\
                 Building an asynchronous redis server / 414 \\
                 Summary / 419 \\
                 Chapter 13: Building Web Applications with Rust / 420
                 \\
                 Web applications in Rust / 420 \\
                 Typed HTTP with Hyper / 421 \\
                 Hyper server APIs building a URL shortener / 422 \\
                 hyper as a client building a URL shortener client / 426
                 \\
                 Web frameworks / 428 \\
                 Actix-web basics / 429 \\
                 Building a bookmarks API using Actix-web / 429 \\
                 Summary / 440 \\
                 Chapter 14: Interacting with Databases in Rust / 441
                 \\
                 Why do we need data persistence? / 441 \\
                 SQLite / 443 \\
                 PostgreSQL / 449 \\
                 Connection pooling with r2d2 / 452 \\
                 Postgres and the diesel ORM / 455 \\
                 Summary / 462 \\
                 Chapter 15: Rust on the Web with WebAssembly / 463 \\
                 What is WebAssembly? / 463 \\
                 Design goals of WebAssembly / 466 \\
                 Getting started with WebAssembly / 467 \\
                 Trying it out online / 467 \\
                 Ways to generate WebAssembly / 468 \\
                 Rust and WebAssembly / 468 \\
                 Wasm-bindgen / 469 \\
                 Other WebAssembly projects / 476 \\
                 Rust / 477 \\
                 Other languages / 477 \\
                 Summary / 478 \\
                 Chapter 16: Building Desktop Applications with Rust /
                 479 \\
                 Introduction to GUI development / 480 \\
                 GTK+ framework / 481 \\
                 Building a hacker news app using gtk-rs / 482 \\
                 Exercise / 495 \\
                 Other emerging GUI frameworks / 495 \\
                 Summary / 496 \\
                 Chapter 17: Debugging / 497 \\
                 Introduction to debugging / 497 \\
                 Debuggers in general / 499 \\
                 Prerequisites for debugging / 499 \\
                 Setting up gdb / 500 \\
                 A sample program buggie / 501 \\
                 The gdb basics / 502 \\
                 Debugger integration with Visual Studio Code / 507 \\
                 RR debugger a quick overview / 513 \\
                 Summary / 516 \\
                 Other Books You May Enjoy / 517 \\
                 Index / 520",
}

@InProceedings{Shetty:2019:CCC,
  author =       "Nishanth Shetty and Nikhil Saldanha and M. N.
                 Thippeswamy",
  booktitle =    "{Emerging Research in Computing, Information,
                 Communication and Applications: ERCICA 2018, Volume
                 1}",
  title =        "{CRUST}: A {C/C++} to {Rust} Transpiler Using a
                 Nano-parser Methodology to Avoid {C/C++} Safety Issues
                 in Legacy Code",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "241--250",
  year =         "2019",
  DOI =          "https://doi.org/10.1007/978-981-13-5953-8_21",
  bibdate =      "Fri Apr 9 11:06:38 MDT 2021",
  bibsource =    "http://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 =    "http://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 =    "http://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
                 http://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 =    "http://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 =    "http://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
                 http://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 =       "A. N. Evans and B. Campbell and M. L. 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",
  bibdate =      "Thu Apr 8 06:41:17 2021",
  bibsource =    "http://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 =    "http://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 =    "http://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 =    "http://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
                 http://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",
}

@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 =    "http://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 =    "http://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 =    "http://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 =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://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 =    "http://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 =    "http://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 =    "http://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 =    "http://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 =    "http://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{Miller:2020: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,
  pages =        "1--1",
  year =         "2020",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2020.3047766",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Apr 8 06:41:17 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/rust.bib",
  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.\par 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{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 =    "http://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 http://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 =    "http://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 =    "http://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 =    "http://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 =    "http://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 =    "http://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 =    "http://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 =    "http://www.math.utah.edu/pub/tex/bib/rust.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Rust programming language",
}

@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 =    "http://www.math.utah.edu/pub/tex/bib/cacm2020.bib;
                 http://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 =    "http://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{Miller:2021: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 =       "??",
  number =       "?",
  pages =        "1--11",
  month =        "????",
  year =         "2021",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2020.3047766",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Apr 08 14:13:22 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 http://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2020.bib;
                 http://www.math.utah.edu/pub/tex/bib/rust.bib;
                 http://www.math.utah.edu/pub/tex/bib/texbook3.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",
}