Learn Rust by Building Real Applications from Udemy

You have probably heard of the Rust Programming Language - a modern systems language that is blazingly fast, guarantees memory safety without the use of a garbage collector and most importantly is fun to write. It has a great community and excellent tooling. These are just some of the reasons why Rust was voted the most loved programming language for five years in a row. Rust is the proof that systems programmers can have nice things.

In this course you will learn the fundamentals of Rust. The format will be a bit different than most other courses. Instead of jumping between unrelated concepts in every video and showing examples that have nothing to do with the real world use of the language, we will learn entirely through practice.

Together we will build real Rust applications and introduce new concepts when we need them to solve actual problems.

To start there will be a short theoretical section on low level memory management.

Then to introduce the basics of Rust we will build a simple command line application. This will provide us with the necessary knowledge to tackle a much larger project.

For our big project we will build a working HTTP server from scratch. We will write our custom implementation of the HTTP protocol and we will build a functioning web server with it. This will let us introduce all of the fundamental and some advanced features of the Rust language.

What's inside

Learning objectives

The fundamentals of the rust programming language
Low level memory management

Rust’s unique approach to memory safety
How to troubleshoot common compiler errors

The fundamentals of the rust programming language
Low level memory management
Rust’s unique approach to memory safety
How to troubleshoot common compiler errors

Syllabus

Getting Started

Course Introduction

What is Rust

Installing Rust

Setting Up the Development Environment

Cargo

Learn how the memory works

Code for this section

Introduction

The Stack

The Heap

Smart Pointers

Explore the Memory Layout in GDB

Test your knowledge from this section

Learn the basics of Rust

Basic Data Types

Functions

Macros

Mutability

The Standard Library

Ownership

References and Borrowing

Explore the Ownership and Borrowing in GDB

Finishing Touches

Building a HTTP Server From Scratch

The HTTP Protocol and the Architecture of Our Server

Structs

Strings

Enums

The Option Enum

Organising Our Code into Modules

Listening for TCP Connections

The Result Enum

Loops

Tuples

The Match Expression

Arrays

Logging the Incoming Requests to the Console

Traits and Type Conversions

Custom Errors

Advanced Error Handling

Iterating Over Strings

Converting an Option into a Result

Parsing Values From Strings

The "If Let" Expression

Lifetimes - Part 1

Lifetimes - Part 2

Lifetimes

Silencing Compiler Warnings

Representing the Query String Using a Hash Map - Part 1

Representing the Query String Using a Hash Map - Part 2

The Derive Attribute

Modelling the HTTP Response

Copy and Clone Types

Writing Data to a TCP Stream

Dynamic vs Static Dispatch

Custom Traits

Implementing Getters

Routing Incoming Requests

Working with Environment Variables

Serving HTML Files

Serving Arbitrary Files Securely

Final Quiz

Next Steps

Good to know

Know what's good

, what to watch for

, and possible dealbreakers

Focuses on building a HTTP server from scratch, which provides practical experience in network programming and server-side development, highly sought after in the industry

Explores low-level memory management and Rust's approach to memory safety, which are critical for building robust and efficient systems software

Starts with the fundamentals of Rust, including basic data types, functions, and ownership, which builds a strong foundation for beginners

Teaches how to troubleshoot common compiler errors, which is an essential skill for any developer working with Rust due to its strictness

Requires familiarity with command-line tools and basic programming concepts, which may pose a challenge for individuals with limited prior experience

Uses GDB to explore memory layout and ownership, which requires learners to install and configure GDB, a command-line debugger

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Learn Rust by Building Real Applications with these activities:

Review Memory Management Concepts

Show steps

Reviewing memory management concepts will help you better understand Rust's ownership and borrowing system.

Browse courses on Memory Allocation

Show steps

Read articles or watch videos on stack and heap memory.
Practice allocating and deallocating memory in C or C++.
Review the concept of pointers and references.

Practice Rustlings Exercises

Show steps

Working through Rustlings exercises will reinforce your understanding of Rust syntax and concepts through hands-on practice.

Show steps

Install Rustlings following the instructions on the GitHub repository.
Work through the exercises in order, reading the hints when needed.
Focus on understanding the error messages and fixing the code.

Read 'The Rust Programming Language'

Show steps

Reading the official Rust book will provide a solid foundation for understanding the language and its features.

View The Rust Programming Language, 2nd Edition on Amazon

Show steps

Read the chapters relevant to the current course topics.
Try the examples and exercises in the book.
Refer to the book when you encounter difficulties in the course.

Four other activities

Expand to see all activities and additional details

Show all seven activities

Build a Simple CLI Tool

Show steps

Building a command-line tool will help you practice using Rust's basic syntax, data types, and standard library.

Show steps

Choose a simple task for your CLI tool (e.g., a calculator, a to-do list).
Plan the structure and functionality of the tool.
Implement the tool using Rust, focusing on error handling and user input.
Test the tool thoroughly and fix any bugs.

Read 'Programming Rust'

Show steps

Reading 'Programming Rust' will provide a deeper understanding of the language and its advanced features.

View Programming Rust: Fast, Safe Systems Development on Amazon

Show steps

Read the chapters relevant to the course topics.
Try the examples and exercises in the book.
Use the book as a reference for advanced topics.

Write a Blog Post on Rust Ownership

Show steps

Explaining Rust's ownership system in a blog post will solidify your understanding and help others learn.

Show steps

Research and understand the different aspects of Rust's ownership system.
Write a clear and concise explanation of ownership, borrowing, and lifetimes.
Include examples and diagrams to illustrate the concepts.
Edit and proofread your blog post before publishing.

Contribute to a Rust Project

Show steps

Contributing to an open-source Rust project will give you real-world experience and expose you to different coding styles and project structures.

Show steps

Find a Rust project on GitHub that interests you.
Read the project's documentation and contribution guidelines.
Find a small bug or feature to work on.
Submit a pull request with your changes.

Career center

Learners who complete Learn Rust by Building Real Applications will develop knowledge and skills that may be useful to these careers:

Systems Programmer

A systems programmer works on the core components of an operating system or other low-level software. This role is all about performance and resource management, and this course, with its focus on memory management and low-level programming in Rust, directly aligns with the demands of systems programming. You’ll learn to build a functional HTTP server from scratch, giving you a deep understanding of how applications interact with the system. This hands-on approach is essential for a prospective systems programmer, as it emphasizes troubleshooting common compiler errors and utilizing the language’s unique approach to memory safety.

See salaries and explore the career path for Systems Programmer

Software Engineer

A software engineer is responsible for the design, development, and implementation of software systems across many different contexts. The course's approach of learning through the building a server application provides practical skills in software design, and implementation. Working through the syllabus will help you to gain expertise in fundamental concepts and advanced concepts. The building of this server application also mirrors the real-world requirements of many software engineering tasks, making this an excellent choice to build an appropriate skill set.

See salaries and explore the career path for Software Engineer

Embedded Systems Engineer

An embedded systems engineer designs and develops software for devices that are not general-purpose computers, such as industrial controls or automotive systems. Rust's focus on memory safety and performance is ideal for embedded systems development, where reliability and deterministic behavior are essential. This course helps build a relevant skill set by focusing on the fundamentals of Rust, including the low-level memory management techniques, and allows you to gain hands-on experience by exploring advanced error handling. This approach is critical for prospective embedded systems engineers, as it covers aspects such as working with custom traits and implementing getters.

See salaries and explore the career path for Embedded Systems Engineer

Network Programmer

A network programmer is responsible for writing software that enables communication between computers over a network. This course, focusing on building a HTTP server, provides foundational knowledge for anyone looking to become a network programmer. Specifically, this course covers aspects such as listening for TCP connections, writing data to a TCP stream, and error handling during these operations. The hands-on building of an HTTP server provides the perfect practical experience for network programming. You’ll be exposed to the many ways that data can be sent in a network, and how to manage these operations efficiently.

See salaries and explore the career path for Network Programmer

Backend Developer

A backend developer works on the server-side of applications, focusing on databases, APIs, and server logic. This course's emphasis on building an HTTP server from scratch using Rust is a huge benefit for anyone aiming to become a backend developer. The ability to write custom implementation of the HTTP protocol will serve as a strong foundation for building robust and efficient server applications. The course also covers aspects useful to a backend developer, such as implementing routing, working with environment variables, and serving files securely, giving you a real-world feel for backend development.

See salaries and explore the career path for Backend Developer

Security Engineer

A security engineer works to develop and implement security policies and safeguards in software. Rust's memory safety guarantees and its focus on performance make it an asset in writing secure software. Building a server with a custom implementation of the HTTP protocol provides direct insight into how security vulnerabilities can occur and how to prevent them. You will gain a deep understanding of how applications work and how they could be attacked. Specifically, this course discusses serving arbitrary files securely, which is incredibly important in the context of security engineering.

See salaries and explore the career path for Security Engineer

Game Developer

Game developers create the software that powers video games. This course's focus on performance and memory management using Rust directly addresses challenges encountered when creating games. While this course does not directly address game development, the exercises included can directly translate to the creation of high-performance game engines. The emphasis on low-level control over memory and other resources makes Rust ideally suited for game development. This gives those who want to write efficient and fast code a distinct competitive advantage.

See salaries and explore the career path for Game Developer

High Performance Computing Developer

High performance computing developers focus on writing software for computationally intensive applications, often in scientific or engineering contexts. Rust's memory safety and performance features make it a great fit for this type of work. This course’s emphasis on low level memory management and performance optimization, specifically error handling, custom traits, and performance tuning, is extremely beneficial. The skills learned in the course provide a foundation for building efficient systems in a high performance environment. This course may be useful for those wanting to work in this field.

See salaries and explore the career path for High Performance Computing Developer

DevOps Engineer

A DevOps engineer is responsible for the set of practices that combines software development and IT operations. This course provides the fundamental knowledge for writing efficient infrastructure tools, because of the server implementation that is built as part of the course. The practical experience gained through building a robust server will give you a unique understanding of the tools that DevOps engineers use. The course’s emphasis on error handling and networking also translates well to the kinds of problems handled by a DevOps engineer. This course may be useful to someone wanting to work in this field.

See salaries and explore the career path for DevOps Engineer

Blockchain Developer

A blockchain developer works on creating software for decentralized systems and applications. Rust’s performance and memory safety features make it a compelling language for blockchain. This course’s focus on low-level aspects of memory management and building a server provides a foundation for creating complex and secure distributed systems. The hands-on approach of building applications from scratch also develops intuition on how different components interact, which is essential for blockchain development. This may be useful for those wanting to work in this field.

See salaries and explore the career path for Blockchain Developer

Operating Systems Developer

An operating systems developer works on the core software that manages a computer's hardware and software resources, and this course which covers low-level memory management gives practical insight on the kind of work expected in this field. Rust’s performance and robust system programming features make it potentially relevant in this domain. The focus on building applications from first principles translates well to the challenges faced in operating systems development. Also, the course explicitly covers topics such as the stack, the heap, and smart pointers, which are all important concepts in operating system design. This course may be useful to those wanting to work in this field.

See salaries and explore the career path for Operating Systems Developer

Robotics Software Engineer

A robotics software engineer is responsible for creating software for robotic systems, and this role often demands high performance and real-time processing. Rust’s memory safety and performance features make it a good fit for robotics development where determinism is critical. The focus on low-level memory management and building custom functionality will be relevant. By learning how to build an HTTP server, a learner begins to understand the challenges involved in real-time response and data management.

See salaries and explore the career path for Robotics Software Engineer

Compiler Engineer

A compiler engineer works on creating and updating compilers for programming languages. Rust's advanced features and unique approach to memory safety, which are covered in this course, make it a great case study for compiler design. The building of custom functionality such as the server, also gives insight into the design choices behind compilers. The debugging skills gained from troubleshooting compiler errors encountered throughout the course are also beneficial. This course may be helpful for those who want to work in this field.

See salaries and explore the career path for Compiler Engineer

Database Engineer

A database engineer designs, develops, and maintains the systems that store and organize data. The low-level memory management concepts covered here, provide a theoretical basis for understanding how database systems work at a lower level. The building of an HTTP server provides insight into data management, including error handling and networking. The course will also help develop a deeper intuitive understanding of these concepts, and make a prospective database engineer more well-rounded. This course may be useful to those wanting to work in this field.

See salaries and explore the career path for Database Engineer

Data Scientist

A data scientist analyzes large data sets to identify patterns and insights. This language is not commonly used in data science, where languages like Python are commonly used. This course's direct usefulness to the data science field is low. Despite this, given Rust's performance characteristics, it may be useful to a data scientist who has to perform computationally intensive tasks. The course may give a data scientist a more complete picture of computer science, which is usually a secondary skill for this role. This course may be useful to those wanting to work in this field.

See salaries and explore the career path for Data Scientist

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Learn Rust by Building Real Applications.

The Rust Programming Language, 2nd Edition

Save

This book, often referred to as 'the book', is the official guide to Rust. It covers all aspects of the language, from basic syntax to advanced topics like concurrency and macros. It's a valuable resource for understanding the core concepts and best practices of Rust programming. is commonly used as a textbook at academic institutions.

The Rust Programming Language, 2nd Edition

Paperback

The Rust Programming Language, 2nd Edition

Kindle Edition

Programming Rust

Save

Provides a comprehensive guide to Rust, covering both the language itself and its ecosystem. It delves into advanced topics like concurrency, macros, and unsafe Rust. It's a valuable resource for experienced programmers who want to master Rust. This book is commonly used as a textbook at academic institutions.

Programming Rust: Fast, Safe Systems Development

Kindle Edition

Learn Rust by Building Real Applications

What's inside

Learning objectives

Syllabus

Good to know

Save this course

Activities

Career center

Reading list

Share

Similar courses