book

Creative Projects for Rust Programmers

Name: Creative Projects for Rust Programmers
Author: Carlo Milanesi
ISBN: 9781789346220

by Carlo Milanesi

June 2020

Intermediate to advanced

404 pages

8h 46m

English

Packt Publishing

Read now

Unlock full access

Title Page
Copyright and Credits
Creative Projects for Rust Programmers
Dedication
About Packt
Why subscribe?
Contributors
About the authorAbout the reviewerPackt is searching for authors like you
Preface
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
Rust 2018: Productivity
Technical requirementsUnderstanding the different editions of RustThe projectsWorking through the examples in this bookExploring some utility cratesPseudo-random number generators – the rand crateLogging – the log crateInitializing static variables at runtime – the lazy_static crateParsing the command line – the structopt crateSummaryQuestions
Storing and Retrieving Data
Technical requirementsProject overviewReading a TOML fileUsing toml_dynamicUsing toml_staticReading and writing a JSON fileThe json_dynamic projectThe json_static projectReading an XML fileAccessing databasesAccessing a SQLite databaseImplementing the projectAccessing a PostgreSQL databaseImplementation of the projectStoring and retrieving data from a Redis storeImplementing the projectPutting it all togetherSummaryQuestions
Creating a REST Web Service
Technical requirementsThe REST architectureProject overviewEssential background theory and contextBuilding a stub of a REST web serviceRunning and testing the serviceGetting a resource using the GET methodSending a named resource to the server using the PUT methodSending a new resource to the server using the POST methodDeleting a resource using the DELETE methodSending an invalid commandExamining the codeBuilding a complete web serviceDownloading a fileUploading a string to a specified fileUploading a string to a new fileDeleting a fileExamining the codeBuilding a stateful serverHow to have a stateful serverThe API of this serviceTesting the serviceImplementing the databaseHandling queriesReturning JSON dataSummaryQuestionsFurther reading
Creating a Full Server-Side Web App
Technical requirementsDefinition of a web appUnderstanding the behavior of a web appProject overviewUsing the Tera template engineA simple list of personsThe templates folderThe other Rust handlersA CRUD applicationThe JavaScript codeThe HTML codeThe Rust codeThe db_access.rs changesThe main.rs changesHandling an application with authenticationThe implementationThe HTML codeThe JavaScript codeThe mock database codeThe main functionSummaryQuestionsFurther reading

Creating a Client-Side WebAssembly App Using Yew
Technical requirementsIntroducing WasmUnderstanding the MVC architectural patternImplementing two toy web appsWhat is the MVC pattern?The modelThe viewThe controllerView implementationController implementationUnderstanding the MVC architectureProject overviewGetting startedThe incr appThe adder appThe login appOrganization of the projectThe db_access.rs fileThe main.rs fileThe login.rs fileThe yauth appUnderstanding the behavior of the appOrganization of the projectThe persons_list.rs fileWhy an empty collection wouldn't be good for filtered_personsThe one_person.rs fileA web app accessing a RESTful serviceThe persons_db appThe yclient appThe imported cratesThe source filesThe changes to the modelsA typical client/server requestSummaryQuestionsFurther reading
Creating a WebAssembly Game Using Quicksilver
Technical requirementsProject overviewUnderstanding the animation loop architectureImplementing the ski projectUnderstanding the code behind thisImplementing the silent_slalom projectImplementing the assets_slalom projectAnalyzing the codeSummaryQuestionsFurther reading
Creating a Desktop Two-Dimensional Game Using ggez
Technical requirementsProject overviewUnderstanding linear algebraImplementing the gg_ski projectThe main functionPatterns of input handlingInput handling in the gg_ski projectOther differences with quicksilverName of the traitThe type of contextThe new methodThe angle's unit of measurementHow to specify the FPS rateHandling the ski steeringComputation of new position and speedDrawing the backgroundDrawing composite shapesEnding the draw methodImplementing the gg_silent_slalom projectImplementing the gg_assets_slalom projectImplementing the gg_whac projectThe assetsThe general structure of the application and eventsOther fields of the modelDefining a widgetSummaryQuestionsFurther reading
Using a Parser Combinator for Interpreting and Compiling
Technical requirementsProject overviewIntroducing CalcUnderstanding formal languages and their parsersRegular languagesContext-free languagesContext-dependent languagesUsing Nom to build parsersLearning about compiler-compilers and parser combinatorsLearning the basics of NomParsing an alternative of charactersParsing a sequence of charactersParsing a fixed stringMapping parsed items to other objectsCreating custom parsing resultsParsing a variable textRepeating a parserThe calc_parser projectUnderstanding the main.rs source fileLearning about the parser.rs source fileUnderstanding the types needed by the parserLooking at the parser codeThe calc_analyzer projectChecking the variables of the parsed programUnderstanding the main.rs fileLooking at the symbol_table.rs fileGlancing at the analyzer.rs fileThe calc_interpreter project Learning about the main.rs fileGlancing at the symbol_table.rs fileUnderstanding the executor.rs fileThe calc_compiler projectGlancing at the main.rs fileUnderstanding the compiler.rs fileSummaryQuestionsFurther reading
Creating a Computer Emulator Using Nom
Technical requirementsProject overviewIntroducing a very simple machine languageThe most important concepts relating to machine languageExtending our machine languageWriting a very simple programA more complex program – the sieve of EratosthenesDefining a byte-addressing machine languageCoping with the endianness issueThe nom_byte_machine projectUnderstanding the main.rs source fileUsing the Nom libraryThe emulator.rs source fileThe parsing_interpreter.rs source fileThe translator.rs source fileThe nom_disassembler projectRunning the projectExamining the source codeGenerating disassembly code that is useful for debuggingGenerating disassembly code that is useful for reassemblingSummaryQuestions
Creating a Linux Kernel Module
Technical requirementsProject overviewUnderstanding kernel modulesPreparing the environmentA boilerplate moduleBuilding and running the kernel moduleThe build commandsThe source code of the boilerplate moduleUsing global variablesAllocating memoryA character deviceBuilding the character deviceThe source code of the dots moduleThe global informationThe initialization callThe cleanup callThe reading functionSummaryQuestionsFurther reading
The Future of Rust
IDEs and interactive programmingCrate maturityAsynchronous programmingOptimizationThe const generics featureEmbedded systemsSummary
Assessments
Chapter 1Chapter 2Chapter 3Chapter 4Chapter 5Chapter 6Chapter 7Chapter 8Chapter 9Chapter 10
Other Books You May Enjoy
Leave a review - let other readers know what you think

Content preview from Creative Projects for Rust Programmers

Creating a Computer Emulator Using Nom

In the last chapter, we saw how to parse text files—in particular, how to program source files in a simple programming language. Text files aren't the only thing you could need to parse—several kinds of system software need to parse binary files (such as binary executables, multimedia files, and inter-process communication messages).

In this chapter, we will look at how to cope with the need for parsing binary files and how the nom library can be used to ease this task. First, we will look at how to parse and interpret a very simple machine language without using an external library, and then how the nom library can be used to ease this task.

To do this, we will cover the following topics:

Introducing ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781789346220

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Creative Projects for Rust Programmers

by Carlo Milanesi

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.