The official book on the Rust programming language, written by the Rust development team at the Mozilla Foundation, fully updated for Rust 2018. 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 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.

The Rust programming language is consistent and does its best to avoid surprising the programmer. Like all languages, though, Rust still has its quirks. But these quirks present a teaching opportunity. In this book, you'll work through a series of brain teasers that will challenge your understanding of Rust. By understanding the gaps in your knowledge, you can become better at what you do and avoid mistakes. Many of the teasers in this book come from the author's own experience creating software. Others derive from commonly asked questions in the Rust community. Regardless of their origin, these brain teasers are fun, and let's face it: who doesn't love a good puzzle, right? What better way to exercise your brain and increase your Rust programming knowledge than with a collection of dynamic brain teasers? As you read through each of these puzzles and try to work out the answers, you'll not only learn about Rust's unique quirks and peculiarities, you'll also have loads of fun along the way. Dive right in and get started with example code and sample problems that cover numbers and text, shadowing and memory, and everything in between. Try to figure out why a particular program won't compile, why it produces unexpected output, or why it panics and terminates with an error message. Once you've run the code and read the answer, it's time to get to the heart of the matter with a detailed explanation. Learn why a program produced the result it did, and discover how similar issues might affect the code you write in your own programs, even in production. Sourced from engaging discussions within the Rust community, real-world problems, and even reader feedback, these challenges will certainly surprise, enlighten, and entertain you. Are you ready to experience Rust like never before? Then sharpen your brain and get ready for a challenge! What You Need: This book assumes you have some knowledge of the Rust programming language. To work through the brain teasers in this book, you'll need a working Rust environment on any platform. You can install Rust by visiting https://rustup.rs/. You'll also need a text editor or Rust-friendly IDE.

Understanding the Machine, the first volume in the landmark Write Great Code series by Randall Hyde, explains the underlying mechanics of how a computer works. This, the first volume in Randall Hyde's Write Great Code series, dives into machine organization without the extra overhead of learning assembly language programming. Written for high-level language programmers, Understanding the Machine fills in the low-level details of machine organization that are often left out of computer science and engineering courses. Learn: How the machine represents numbers, strings, and high-level data structures, so you'll know the inherent cost of using them. How to organize your data, so the machine can access it efficiently. How the CPU operates, so you can write code that works the way the machine does. How I/O devices operate, so you can maximize your application's performance when accessing those devices. How to best use the memory hierarchy to produce the fastest possible programs. Great code is efficient code. But before you can write truly efficient code, you must understand how computer systems execute programs and how abstractions in programming languages map to the machine's low-level hardware. After all, compilers don't write the best machine code; programmers do. This book gives you the foundation upon which all great software is built. NEW IN THIS EDITION, COVERAGE OF: Programming languages like Swift and Java Code generation on modern 64-bit CPUs ARM processors on mobile phones and tablets Newer peripheral devices Larger memory systems and large-scale SSDs

Explains how compilers translate high-level language source code (like code written in Python) into low-level machine code (code that the computer can understand) to help readers understand how to produce the best low-level, computer readable machine code. In the beginning, most software was written in assembly, the CPU's low-level language, in order to achieve acceptable performance on relatively slow hardware. Early programmers were sparing in their use of high-level language code, knowing that a high-level language compiler would generate crummy, low-level machine code for their software. Today, however, many programmers write in high-level languages like Python, C/C++/C#, Java, Swift. The result is often sloppy, inefficient code. But you don't need to give up the productivity and portability of high-level languages in order to produce more efficient software. In this second volume of the Write Great Code series, you'll learn: • How to analyze the output of a compiler to verify that your code does, indeed, generate good machine code • The types of machine code statements that compilers typically generate for common control structures, so you can choose the best statements when writing HLL code • Just enough 80x86 and PowerPC assembly language to read compiler output • How compilers convert various constant and variable objects into machine data, and how to use these objects to write faster and shorter programs NEW TO THIS EDITION, COVERAGE OF: • Programming languages like Swift and Java • Code generation on modern 64-bit CPUs • ARM processors on mobile phones and tablets • Stack-based architectures like the Java Virtual Machine • Modern language systems like the Microsoft Common Language Runtime With an understanding of how compilers work, you'll be able to write source code that they can translate into elegant machine code. That understanding starts right here, with Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level.

This book constitutes the refereed proceedings of the 24th IFIP WG 6.1 International Conference on Coordination Models and Language, COORDINATION 2022, held in Lucca, Italy, in June 2022, as part of the 17th International Federated Conference on Distributed Computing Techniques, DisCoTec 2022. The 11 regular papers and one short paper presented in this book were carefully reviewed and selected from 22 submissions. COORDINATION provides a well-established forum for the growing community of researchers interested in coordination models and languages, architectures, verification and implementation techniques necessary to cope with the complexity induced by the demands of today's software development.

Understand the basic building blocks of WebAssembly and learn, install, and use various tools from the Rust and WebAssembly ecosystem Key Features • Understand the Rust programming language and WebAssembly concepts for web development • Build web, mobile, and embedded apps using WebAssembly • Enhance the scalability and resilience of your web apps Book Description Rust is an open source language tuned toward safety, concurrency, and performance. WebAssembly brings all the capabilities of the native world into the JavaScript world. Together, Rust and WebAssembly provide a way to create robust and performant web applications. They help make your web applications blazingly fast and have small binaries. Developers working with JavaScript will be able to put their knowledge to work with this practical guide to developing faster and maintainable code. Complete with step-by-step explanations of essential concepts, examples, and self-assessment questions, you'll begin by exploring WebAssembly, using the various tools provided by the ecosystem, and understanding how to use WebAssembly and JavaScript together to build a high-performing application. You'll then learn binary code to work with a variety of tools that help you to convert native code into WebAssembly. The book will introduce you to the world of Rust and the ecosystem that makes it easy to build/ship WebAssembly-based applications. By the end of this WebAssembly Rust book, you'll be able to create and ship your own WebAssembly applications using Rust and JavaScript, understand how to debug, and use the right tools to optimize and deliver high-performing applications. What you will learn • Explore WebAssembly and the different tools available in the WebAssembly ecosystem • Understand the raw WebAssembly binary and the WebAssembly text format • Use the Web and JavaScript API with wasm-bindgen • Optimize Rust and WebAssembly for high performance • Run and debug WebAssembly and Rust code • Explore various tools available in the RustWASM ecosystem Who this book is for This book is for JavaScript developers who want to deliver better performance and ship type-safe code. Rust developers or backend engineers looking to build full-stack applications without worrying too much about JavaScript programming will also find the book useful.

This book constitutes the proceedings of the 14th International Symposium on NASA Formal Methods, NFM 2022, held in Pasadena, USA, during May 24-27, 2022. The 33 full and 6 short papers presented in this volume were carefully reviewed and selected from 118submissions. The volume also contains 6 invited papers. The papers deal with advances in formal methods, formal methods techniques, and formal methods in practice. The focus on topics such as interactive and automated theorem proving; SMT and SAT solving; model checking; use of machine learning and probabilistic reasoning in formal methods; formal methods and graphical modeling languages such as SysML or UML; usability of formal method tools and application in industry, etc.

A fast-paced, thorough introduction to modern C++ written for experienced programmers. After reading C++ Crash Course, you'll be proficient in the core language concepts, the C++ Standard Library, and the Boost Libraries. C++ is one of the most widely used languages for real-world software. In the hands of a knowledgeable programmer, C++ can produce small, efficient, and readable code that any programmer would be proud of. Designed for intermediate to advanced programmers, C++ Crash Course cuts through the weeds to get you straight to the core of C++17, the most modern revision of the ISO standard. Part 1 covers the core of the C++ language, where you'll learn about everything from types and functions, to the object life cycle and expressions. Part 2 introduces you to the C++ Standard Library and Boost Libraries, where you'll learn about all of the high-quality, fully-featured facilities available to you. You'll cover special utility classes, data structures, and algorithms, and learn how to manipulate file systems and build high-performance programs that communicate over networks. You'll learn all the major features of modern C++, including: Fundamental types, reference types, and user-defined types The object lifecycle including storage duration, memory management, exceptions, call stacks, and the RAII paradigm Compile-time polymorphism with templates and run-time polymorphism with virtual classes Advanced expressions, statements, and functions Smart pointers, data structures, dates and times, numerics, and probability/statistics facilities Containers, iterators, strings, and algorithms Streams and files, concurrency, networking, and application development With well over 500 code samples and nearly 100 exercises, C++ Crash Course is sure to help you build a strong C++ foundation.

Network Programming with Go teaches you how to write clean, secure network software with the programming language designed to make it seem easy. Build simple, reliable, network software Combining the best parts of many other programming languages, Go is fast, scalable, and designed for high-performance networking and multiprocessing. In other words, it’s perfect for network programming. Network Programming with Go will help you leverage Go to write secure, readable, production-ready network code. In the early chapters, you’ll learn the basics of networking and traffic routing. Then you’ll put that knowledge to use as the book guides you through writing programs that communicate using TCP, UDP, and Unix sockets to ensure reliable data transmission. As you progress, you’ll explore higher-level network protocols like HTTP and HTTP/2 and build applications that securely interact with servers, clients, and APIs over a network using TLS. You'll also learn: Internet Protocol basics, such as the structure of IPv4 and IPv6, multicasting, DNS, and network address translation Methods of ensuring reliability in socket-level communications Ways to use handlers, middleware, and multiplexers to build capable HTTP applications with minimal code Tools for incorporating authentication and encryption into your applications using TLS Methods to serialize data for storage or transmission in Go-friendly formats like JSON, Gob, XML, and protocol buffers Ways of instrumenting your code to provide metrics about requests, errors, and more Approaches for setting up your application to run in the cloud (and reasons why you might want to) Network Programming with Go is all you’ll need to take advantage of Go’s built-in concurrency, rapid compiling, and rich standard library. Covers Go 1.15 (Backward compatible with Go 1.12 and higher)

A practical guide to understanding the latest features of the Rust programming language, useful libraries, and frameworks that will help you design and develop interesting projects Key FeaturesWork through projects that will help you build high-performance applications with RustDelve into concepts such as error handling, memory management, concurrency, generics, and macros with RustImprove business productivity by choosing the right libraries and frameworks for your applicationsBook Description Rust is a community-built language that solves pain points present in many other languages, thus improving performance and safety. In this book, you will explore the latest features of Rust by building robust applications across different domains and platforms. The book gets you up and running with high-quality open source libraries and frameworks available in the Rust ecosystem that can help you to develop efficient applications with Rust. You'll learn how to build projects in domains such as data access, RESTful web services, web applications, 2D games for web and desktop, interpreters and compilers, emulators, and Linux Kernel modules. For each of these application types, you'll use frameworks such as Actix, Tera, Yew, Quicksilver, ggez, and nom. This book will not only help you to build on your knowledge of Rust but also help you to choose an appropriate framework for building your project. By the end of this Rust book, you will have learned how to build fast and safe applications with Rust and have the real-world experience you need to advance in your career. What you will learnAccess TOML, JSON, and XML files and SQLite, PostgreSQL, and Redis databasesDevelop a RESTful web service using JSON payloadsCreate a web application using HTML templates and JavaScript and a frontend web application or web game using WebAssemblyBuild desktop 2D gamesDevelop an interpreter and a compiler for a programming languageCreate a machine language emulatorExtend the Linux Kernel with loadable modulesWho this book is for This Rust programming book is for developers who want to get hands-on experience with implementing their knowledge of Rust programming, and are looking for expert advice on which libraries and frameworks they can adopt to develop software that typically uses the Rust language.