book

Practical System Programming for Rust Developers

by Prabhu Eshwarla

December 2020

Intermediate to advanced

388 pages

7h 52m

English

Packt Publishing

Read now

Unlock full access

Why subscribe?ContributorsAbout the authorAbout the reviewerPackt is searching for authors like you
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchReviews
Technical requirementsChoosing the right Rust configuration for your projectChoosing a Rust release channelSelecting a Rust project typeIntroducing Cargo and project structuresAutomating build management with CargoBuilding a basic binary crateConfiguring CargoBuilding a static library crateAutomating dependency managementSpecifying the location of a dependencyUsing dependent packages in source codeWriting and running automated testsWriting unit tests in RustWriting integration tests in RustControlling test executionRunning tests sequentially or in parallelDocumenting your projectWriting inline documentation comments within crateWriting documentation in markdown filesRunning documentation testsSummaryFurther reading
Technical requirementsAnalyzing the problem domainModeling the system behaviorBuilding the tokenizerTokenizer data structureTokenizer data processingBuilding the parserParser data structureParser methodsOperator precedenceBuilding the evaluatorDealing with errorsPutting it all togetherSummary
Technical requirementsThe Rust Standard Library and systems programmingExploring the Rust Standard LibraryComputation-oriented modulesSyscalls-oriented modulesBuilding a template engineTemplate syntax and designWriting the template engineExecuting the template engineSummaryFurther reading
Technical requirementsProject scope and design overviewWhat will we build? Technical designUsing the Rust Standard LibraryCoding the imagix libraryDeveloping the command-line application and testingDesigning the command-line interfaceCoding the command-line binary using structoptSummary
Technical requirementsThe basics of OS memory managementThe memory management lifecycleThe process memory layoutUnderstanding the memory layout of Rust programsRust program memory layoutThe characteristics of stack, heap, and static memoryThe Rust memory management lifecycleOverview of the Rust memory management lifecycleMemory allocationMemory use and manipulationMemory deallocationImplementing a dynamic data structureChanges to the design of the template engineCoding the dynamic data structureSummaryFurther reading
Technical requirementsUnderstanding Linux system calls for file operationsDoing file I/O in RustLearning directory and path operationsSetting hard links, symbolic links, and performing queriesWriting a shell command in Rust (project)Code overviewError handlingSource metric computationThe main() functionSummary

Technical requirementsIntroducing terminal I/O fundamentalsCharacteristics of terminalsThe Termion crateWhat will we build?Working with the terminal UI (size, color, styles) and cursorsWriting data structures and the main() functionInitializing the text viewer and getting the terminal sizeDisplaying a document and styling the terminal color, styles, and cursor positionExiting the text viewerProcessing keyboard inputs and scrollingListening to keystrokes from the userPositioning the terminal cursorEnabling scrolling on the terminalProcessing mouse inputs Summary
Technical requirementsUnderstanding Linux process concepts and syscallsHow does a program become a process?Delving into Linux process fundamentalsSpawning processes with RustSpawning new child processesTerminating processesChecking the status of a child process' executionHandling I/O and environment variablesHandling the I/O of child processesSetting the environment for the child processHandling panic, errors, and signalsAborting the current processSignal handlingWriting a shell program in Rust (project)Summary
Technical requirementsReviewing concurrency basicsConcurrency versus parallelismConcepts of multi-threadingSpawning and configuring threadsError handling in threadsMessage passing between threadsAchieving concurrency with shared stateDefining the program structureAggregating source file statistics in shared statePausing thread execution with timersSummary
Technical requirementsUnderstanding device I/O fundamentals in LinuxWhat are device drivers?Types of devicesDoing buffered reads and writesWorking with standard input and outputChaining and iterators over I/OHandling errors and returning valuesGetting details of connected USB devices (project)Designing the projectWriting data structures and utility functionsWriting the main() functionSummary
Technical requirementsReviewing networking basics in LinuxUnderstanding networking primitives in the Rust standard libraryProgramming with TCP and UDP in RustWriting a UDP server and clientWriting a TCP server and clientWriting a TCP reverse proxy (project)Writing the origin server – structs and methodsWriting the origin server – the main() functionWriting the reverse proxy serverSummary
Technical requirementsIntroducing unsafe RustHow do you distinguish between safe and unsafe Rust code?Operations in unsafe RustIntroducing FFIsReviewing guidelines for safe FFIsCalling Rust from C (project)Understanding the ABISummary
Leave a review - let other readers know what you think

Overview

Dive into the world of systems programming with Rust and create robust and secure utilities for Linux/Unix systems. This book takes you from the basics of Rust to advanced systems programming concepts, with practical examples and projects to solidify your understanding. By the end, you'll be confident in designing and developing efficient system tools and utilities with Rust.

What this Book will help me do

Learn to effectively manage system resources in a Linux/Unix environment using Rust.
Understand the Rust standard library and its application in systems programming.
Design practical system tools and utilities leveraging Rust's features.
Delve into Rust's unique memory management capabilities and principles.
Explore network programming and interoperability through Rust's ecosystem.

Author(s)

None Eshwarla is a developer and educator specializing in Rust and systems programming. With a passion for teaching and a wealth of experience in crafting reliable software, None brings clarity and practical insight to complex topics. They focus on providing readers with practical skills and understanding.

Who is it for?

This book is for programmers who already know the basics of Rust but seek to apply it to systems programming. Beginners in systems programming looking for a safer alternative to C/C++ will gain much from this. Professionals aiming to expand their skill set with Rust-specific tools for low-level programming will find it invaluable. Technical enthusiasts who enjoy learning about programming close to the metal are also well-suited for this resource.