Rust: Develop Programming Skills with Rust

This video will give you an overview about the course.

As RUST is a systems language, we need to know how to run RUST using console. In this video we‘ll get to know how RUST is compiled while running it using console.

• Learn some of the basics of Cargo

• Build a new project with RUST

• Build a console application which tells our robot to do something

To be able to do more coding in Rust we first need to learn basic Rust syntaxes that will help us in developing interesting applications. Let's do just that in this video.

• Learn what data types are

• Get to know loops and conditional statements

• Understand the difference between an expression and a statement

When we will build a real-life project that will contain a large amount of code for sure. To make that large amount of code readable and easily customizable we will need to modularize the code.

• Know about Rust's Module System

• Learn how to build modules

• Learn how to implement Modules

Building each and every function and module by writing raw code gets a little overwhelming for a developer. Developers can get help in this point by using Rust's Standard Library.

To make our robot more functional and capable to do many other things, we need to use functions and modules from standard library.

• Get an overview of Rust's Standard Library

• Loading modules from the standard library

• Use functions and module items

Rust's modules are managed, published, and retrieved by most important tool of rust tool chain – Cargo. To develop a more functional application, we have to add our additional libraries or local gits to this tool. Cargo tool is controlled by cargo.toml file. We need to know to how to add additional binaries, libraries and local gits with this file. Let's see how to do that in this video.

• Take an overview of the Rust Tool Chain and Ecosystem

• Explore ways to add additional binaries and libraries to the cargo.toml file

• Add local gits with the cargo.toml file

The crates that we have built may depend on other libraries from crates.io or from gits or from other folders of your pc. To ensure properly functional crates, you have to manage their dependencies properly with the cargo.

• Adopt knowledge of dependency in Cargo

• Specify dependencies from crates.io

• Specify dependencies from local path location

We need to make our robot more functional on specific tasks. To do this we need to use more crates. We can solve this problem by shopping on crates.io.

• Take an overview of crates.io

• Explore required crates on crates.io

• Add dependencies of the specific crates that we want to use from crates.io

It is very important for a developer to know whether he is writing code perfectly or not or is there a bug in the code. The same applies for Rust programming. To solve this problem Rust gives extra facility to test our code. Let's check that out.

• Know the testing process

• Know the test attributes

• Know the test directories

Keeping memory and reference different from each other in Rust is known as Borrow Checker. It also verifies concurrency safety. We should understand how rust does this job.

• Understand the magnificent type system of Rust.

• Get an overview of memory and reference and concurrency safety.

• Know how Borrow Checker ensures verification of memory and concurrency safety.

Rust concurrency or parallelism is normally understood by sending and syncing of data. Where data sent is safe by default, but sync is not safe.

Understanding how rust handles this safety is our main focus point for this video.

• Understand concurrency safety

• Understand Borrow Checker

• Know how safety is maintained though rust is a concurrent system

To control our army, we need to impose restriction on them. We can make this done by contracting which can be done by using Rust's trait system.

• Know Rust's Trait system

• Safe programming

• Contract building

In case of distributed simulation, there are network protocols for this simulation. Pattern matching could be a powerful tool when we are building such network protocol. Rust offers a smart pattern matching mechanism. Let's see this.

• Check out pattern matching

• Use pattern matching in protocol programming

Trait is a very important feature of Rust. We can use it for many complex tasks. To do that we have to go deep in the trait system.

• Take a look at the Trait System

• Take a look at Advanced trait

• Follow an example for better understanding

To make our system (robot) more functional, we need to communicate with it.

• Take a look at concurrency

• Learn about message passing (send message)

• Develop a message sending system using the Rust API

As messages are sent and received through some shared states by the channels there is no guarantee that no unexpected sharing of states will occur. At this point, to protect accidental sharing of states as well as protect messages from unwanted leaking we need to use a Rust API – Lock.

• Know why packing and unpacking is required

• Know what is Lock and why we need it

• Know functionality of Lock

One of the main and most important reasons for which the Rust invention project was initiated is to handle concurrency less painfully. And Rust as a programming language can handle this very smartly. Our target is now to know deeply the Rust's concurrency management system.

• Concurrency and Threads

• Learn Thread Safety and shared mutable states

• Channel based communication

Since we are building a simulation, we'll also want a high degree of randomness to allow us to exercise the probability of gambits winning or losing.

• Understand Rust Rand function and its functionality

• Include rand package with our system

• Implement Rand to our robot army

To make our system truly extensible, not only will our robots be separate implementations of traits, they'll live in separate modules. In order to advertise our army's capabilities, we'll have to document them thoroughly and make the documentation available online.

• What is Commenting and its necessity

• What is documenting and its necessity

• How make documentation

In order to make the simulation easy to read, let's add a little color with a special rust crate.

• Know the colored package

• Know how to add up this with our project

• Color up our project with colored package

We have already built a Robot army simulation system using Rust, but still this is bound in our consoles. Let's make it a Real-time simulation system which will help the clients to communicate through the web.

• Learn about Rust's IO systems

• Find the constraints of our previously used IO system

• Find the solution with a different IO system

To make our simulation application a real time one, the first and most important challenge is to develop a system that will have a non-blocking IO system. Mio framework is the first step to this problem.

• We will learn the basics of Mio Framework

• We will develop an echo application with TCP communication which will be a non-blocking one

• We will see how the application works through the network along with the OS

To make our army simulation application a real time live application we have do something awesome with the Mio and Hyper framework of Rust.

Earlier, we have learnt about Mio. Now its turn to Hyper.

• We will know about Hyper

• Features and syntaxes of Hyper

• We will develop a website with Hyper

Fundamental operations and functions of Hyper are our next field of study.

• We will learn about Hyper frameworks more deeply

• Learn Hyper's Modules

• Learn Hyper's Macros and Structs

So far, we have worked in the root level with very raw coding now we should cover those so that it looks well structured.

• Prepare Handler

• Make Handler Synchronized

• Prepare a Request Response Pair

To make our server connected with the user we have to develop a protocol which can establish a connection to the user through TCP connection.

• We will learn about Websocket

• Understand TCP communication

• Plugin websocket with our Hyper server

We have already developed a simulation application and on the other hand we have developed a High-performance networking system with Hyper Server which can establish HTTP communication. Now it's time to adapt the outputs of our existing simulation system with our HTTP server through websockets.

• Connect simulator with websockets

• Configure websockets to the server

• Run the final simulation

This video gives an overview of the entire course.

In this video, we will look at the different layers of a network model and understand each one in detail.

We have seen why it is important to identify hosts and networks uniquely to be able to deliver packets reliably. Depending on the scale, there are three major ways of doing this; we will discuss each of those in this video.

• Learn about Ethernet address and IP address

It is not possible for anyone to remember the IP address of each and every service. We have a protocol for that fortunately, DNS.

• Look at how DNS works

For two hosts to communicate via a network, they will need to send messages to each other. There are two models of exchanging messages, and each has specific use cases where they work best.

• Learn about connection-oriented service

• Understand connectionless service

In this video, we will get started with the basics of Rust.

• Put Cargo's bin directory to our PATH

• Set up a Rust project and run it

The most important aspect of Rust is the ownership and borrowing model. Based on the strict enforcing of borrowing rules, the compiler can guarantee memory safety without an external garbage collector.

• Declare variables using let keyword

• Clone the resource named mystr using .clone()

• Use the Rust compiler directly to compile our code

Rust supports writing generic code that is later bound with more concrete types, either during compile time or during runtime. We also introduce some new constructs which we haven't discussed before, which we will explain as we proceed.

• Look at a naive implementation

• Put the trait bound in the sum function

• Define a generic trait of type T

One of Rust's major goals is enabling the developer to write robust software. An essential component of this is advanced error handling. In this video, we will take a deeper look at how Rust does error handling.

• Return a special enum that carries the result

• Expand on the standard error type and implement custom errors

• Write our divide function

Rust supports a macro system that has evolved quite a lot over the years. A distinctive feature of Rust macros are that they are guaranteed to not refer to identifiers outside their scope by accident.

• Look at syntactic macros

• Look at procedural macros

Rust has rich support for functional programming both in the language and in the standard library. In this video, we will look at some of these.

• Look at higher-order functions

• Implement iterators

One of the promises of Rust is to enable fearless concurrency. Quite naturally, Rust has support for writing concurrent code through a number of mechanisms. In this video, we will discuss a few of these.

• Look at how Rust enables writing multithreaded applications

• Import the threading library

• Create a variable and a pointer

Rust treats testing as a first-class construct; all tools in the ecosystem supports testing. The compiler provides a built-in configuration attribute that designates a module for testing.

• Run cargo test

• Add a test to make sure factorial actually works

• Add some doctest for our factorial macro

In this video we will see how a simple multithreaded TCP client and server looks like in Rust.

• Write basic echo server

• Create a new TcpListener

• Declare a dependency on the rand crate

In this video, we will see how a simple multithreaded UDP client and server looks like in Rust.

• Bind the local address on a given port

• Write a simple UDP client

• Look at how multicasting works

In this video, we will look at number of functionalities in std::net.

• Construct an IpAddr from a string and check it

• Construct a globally routable IPv6 address from individual octet

• Construct a SocketAddr from a string an assert that the underlying

Serde provides a few macros that can be implemented on user defined data types, making them (de)serializable. Serde uses mechanism to provide two custom derives, named serialize and deserialize, that can be implemented for user-defined data types. In this video, we will uses procedural macros for deriving serialize and deserialize.

• Declare all our dependencies as extern crates

• Setup a TCP server and a client

• Computes the distance and sends back the result

In the Rust ecosystem, there are a few distinct ways of implementing PEGs, and each of those have their own strengths and weaknesses. The first way is using macros to define a domain-specific language for parsing.

• Parse a simple string

• Implement parser combinations

• Parse an example HTTP request

In this video, we will how nom can be used to parse binary data. In our toy example, we will write a parser for the IPv6 header.

• Declare a struct for the IPv6 fixed header

• Define a function using the do_parse! macro

One of the most popular RPC implementations is gRPC. gRPC offers high performance RPC over internet scale networks and is widely used in a number of projects, including Kubernetes.0020 For our gRPC example, we will build a service that is a lot like Uber. It has a central server where clients (cabs) can record their names and locations.

• Use the protoc-rust-grpc crate

• Define all associated protobuf messages for each of the requests and responses

• To process the responses, all the record_cab_location and get_cabs methods over RPC

Internet email uses a protocol called Simple Mail Transfer Protocol (SMTP), which is an IETF standard. Much like HTTP, it is a simple text protocol over TCP, using port 25 by default. In this video, we will look at a small example of using lettre for sending emails.

• Send crash reports for a server

• Create an instance of our CrashReport

Another common application layer protocol is the File Transfer Protocol (FTP). This is a text-based protocol, where the server and clients exchange text commands to upload and download files.

• Interact with FTP servers using crate called rust-ftp

• Connect to the server on port 21

• Look at TFTP server using the crate called tftp_server

Hyper is arguably the most stable and well-known of Rust-based HTTP frameworks. It has two distinct components, one for writing HTTP servers and one for writing clients. In this video, our Http instance will be passed to multiple threads. Thus, we need to wrap it in an Automatically Reference Counting (ARC) pointer.

• Write a small HTTP server in Hyper

• Interact with the server with curl

• Write a server that uses multi-threading

Rocket can only run on nightly, because it uses a bunch of features that are not stable yet.

• Write an API server using Rocket

• Set up our database using diesel CLI

• Define errors for our API

In this video, we will discuss the reqwest crate and look at how to use it; this borrows heavily from the requests library in Python.

• Use Serde to serialize and deserialize our data to JSON

• Deserialize the response to a list of Post objects

• Add asynchronous programming support using Tokio

The backbone of Rust's asynchronous programming story is the futures crate. This crate provides a construct called a future. We will learn more about it in this video

• Add some libraries in our Cargo config

• Simulate slowness

• Work with streams and sinks

The Tokio ecosystem is an implementation of a network stack in Rust. It has all the major functionality of the standard library. We will learn more about it in this video.

• Multiplex incoming connections in Tokio

• Write streaming protocols

• Look at some commonly used libraries

it is necessary to add some form of security between parties using HTTP to communicate. We will learn to add them.

• Learn about basic scheme of things

• Use OpenSSL library using Rust

A commonly used crate for cryptography is called ring. This crate supports a number of lower-level crypto primitives. We will learn to use it in this video.

• Learn how protocol works

• Create an example directory and place the two files

• Handle each client in a new thread