Learn Rust by Building Real Applications

Learn Rust by Building Real Applications, available at $84.99, has an average rating of 4.64, with 61 lectures, 4 quizzes, based on 4153 reviews, and has 22893 subscribers.

You will learn about The fundamentals of the Rust Programming Language Low level memory management Rust’s unique approach to memory safety How to troubleshoot common compiler errors This course is ideal for individuals who are Developers interested in a safe systems programming language It is particularly useful for Developers interested in a safe systems programming language.

Enroll now: Learn Rust by Building Real Applications

Summary

Title: Learn Rust by Building Real Applications

Price: $84.99

Average Rating: 4.64

Number of Lectures: 61

Number of Quizzes: 4

Number of Published Lectures: 61

Number of Published Quizzes: 4

Number of Curriculum Items: 65

Number of Published Curriculum Objects: 65

Original Price: $89.99

Quality Status: approved

Status: Live

What You Will Learn

The fundamentals of the Rust Programming Language

Low level memory management

Rust’s unique approach to memory safety

How to troubleshoot common compiler errors

Who Should Attend

Developers interested in a safe systems programming language

Target Audiences

Developers interested in a safe systems programming language

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.

Course Curriculum

Chapter 1: Getting Started

Lecture 1: Course Introduction

Lecture 2: What is Rust

Lecture 3: Installing Rust

Lecture 4: Setting Up the Development Environment

Lecture 5: Cargo

Chapter 2: Manual Memory Management

Lecture 1: Code for this section

Lecture 2: Introduction

Lecture 3: The Stack

Lecture 4: The Heap

Lecture 5: Smart Pointers

Lecture 6: Explore the Memory Layout in GDB

Chapter 3: Building a Command Line Application

Lecture 1: Code for this section

Lecture 2: Introduction

Lecture 3: Basic Data Types

Lecture 4: Functions

Lecture 5: Macros

Lecture 6: Mutability

Lecture 7: The Standard Library

Lecture 8: Ownership

Lecture 9: References and Borrowing

Lecture 10: Explore the Ownership and Borrowing in GDB

Lecture 11: Finishing Touches

Chapter 4: Building a HTTP Server From Scratch

Lecture 1: Code for this section

Lecture 2: Introduction

Lecture 3: The HTTP Protocol and the Architecture of Our Server

Lecture 4: Structs

Lecture 5: Strings

Lecture 6: Enums

Lecture 7: The Option Enum

Lecture 8: Organising Our Code into Modules

Lecture 9: Listening for TCP Connections

Lecture 10: The Result Enum

Lecture 11: Loops

Lecture 12: Tuples

Lecture 13: The Match Expression

Lecture 14: Arrays

Lecture 15: Logging the Incoming Requests to the Console

Lecture 16: Traits and Type Conversions

Lecture 17: Custom Errors

Lecture 18: Advanced Error Handling

Lecture 19: Iterating Over Strings

Lecture 20: Converting an Option into a Result

Lecture 21: Parsing Values From Strings

Lecture 22: The If Let Expression

Lecture 23: Lifetimes – Part 1

Lecture 24: Lifetimes – Part 2

Lecture 25: Silencing Compiler Warnings

Lecture 26: Representing the Query String Using a Hash Map – Part 1

Lecture 27: Representing the Query String Using a Hash Map – Part 2

Lecture 28: The Derive Attribute

Lecture 29: Modelling the HTTP Response

Lecture 30: Copy and Clone Types

Lecture 31: Writing Data to a TCP Stream

Lecture 32: Dynamic vs Static Dispatch

Lecture 33: Custom Traits

Lecture 34: Implementing Getters

Lecture 35: Routing Incoming Requests

Lecture 36: Working with Environment Variables

Lecture 37: Serving HTML Files

Lecture 38: Serving Arbitrary Files Securely

Lecture 39: Next Steps

Instructors

Lyubomir Gavadinov
Senior Software Engineer

Rating Distribution

1 stars: 23 votes

2 stars: 55 votes

3 stars: 273 votes

4 stars: 1397 votes

5 stars: 2405 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!