Learn Ember, Mocha and Rust

In this course, Chris takes a README-driven approach to build out a Rust CLI that supports content authoring for a digital garden.

Specifically, you'll work through the first command for the CLI, writing files. You start by initializing a new Cargo binary crate through creating the `write` command that allows you to create files (and their contents) to the folder that you set. 

Step by step you'll learn about:
- Handling user input
- Error handling
- Rust Move semantics
- Rust Copy semantics
- Integration testing

...and more!

Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety.

rust

Creating a Digital Garden CLI with Rust

Rust is a modern language that is close to the metal. It's got the performance of C, but with a more friendly syntax and community.

It's also memory safe, and ensures your applications are bug free by catching errors at compile time instead of runtime.

These features make Rust a great choice for developing code for embedded systems, web servers, and CLI apps. You can even compile Rust into WebAssembly in order to run it in-browser!

But as the saying goes, "before you learn to run, you must learn to walk".

In this course, you will write your first Rust application.

Starting from “Hello World” you’ll quickly move on to learning about Rust’s types, configuration files, and the `cargo` package manager along with classics like functions, loops, and handling user input.

More Rust-specific concepts like macros and pattern matching will also be introduced.

Check out these [**community notes for this course on Github**](https://github.com/eggheadio-projects/write-your-first-program-with-the-rust-language).

Next Steps: [Basic Types in Rust](https://egghead.io/playlists/data-types-in-rust-ab72)

Write Your First Program with the Rust Language

[Rustlings](https://github.com/rust-lang/rustlings) is a set of exercises that serves as a great introduction to the Rust language. It covers many concepts from the [Rust book](https://doc.rust-lang.org/book/) by asking you to work through sets of exercises.

This collection walks you through Rustlings in a way that explains what's going on in each exercise. We cover everything from basic types to generics and threading.

Learning Rust by Working Through the Rustlings Exercises

This collection contains videos that explore the basic types in Rust, including **Fixed size Integer**, **Pointer sized Integer**, **Boolean**, **Strings**, **Characters**, **Arrays**, **Tuples** and more.

If you're just starting out learning Rust and [wrote your first program](https://egghead.io/courses/write-your-first-program-with-the-rust-language), this collection is the right place to get more familiar with the language!

Basic Types in Rust

Many languages work on a compilation story to WebAssembly, but Rust is already ready for primetime. Why?


- Rust is a stable language and great replacement for C and C++. 
- Due to the reference and borrowing concept, Rust doesn’t need a Garbage Collector and can be used for a production-ready WebAssembly project. 
- The Rust/Wasm team has built some sophisticated tooling for straightforward interoperability between Rust and JavaScript.

This course gives you the tools to compile to WebAssembly with Rust. Over 11 lessons, we’ll set up a project and explore various paths of communication and interoperability between Rust and JavaScript.

Using WebAssembly with Rust

Ember is a javascript framework that provides a rich set of tools for building modern web applications. Unlike many frameworks, Ember comes with opinions and a way of doing things so you aren't left with a ton of decisions to make about problems that have already been solved very well. Ember was designed from the start to deliver a productive and comfortable experience for you, the developer.

In this course you will learn what you need to know to get started building your own Ember we applications. From the absolute essentials like creating a new project with the Ember-CLI tools, templating, routing, and reusable components.



A JavaScript framework for creating ambitious web applications.

ember

Ember 2 Fundamentals

In this lesson you'll learn how to install Rust's toolchain.

Install Rust

This lesson takes an existing function with duplicated functionality and makes it more DRY by extracting core functionalities into another function.

Make your Rust code more DRY

In this lesson we’ll create a new Rust project using the `cargo new` command and take a look at some of the generated files.

Create a Rust package with the Cargo package manager

In this lesson we take a look at how `println!()` can be used to output multiple variables using formatter placeholders.

Output multiple variables using println!() in Rust

In this lesson we’ll create our first “Hello World” Rust program from scratch and will learn how to compile it using `rustc`.

Compile and run a Rust program from scratch

In this lesson we'll learn how to use the `cargo run` command to compile and run a Rust program.

Compile and run a Rust program using Cargo

In this lesson we'll learn how to initialise variables in Rust and how to make them mutable using the `mut` keyword so they can be changed throughout the program.

Variables and Mutability in Rust

In this lesson we'll create a new function that receives parameters and called inside our program's `main()` function.

Write and call a function in Rust

In this lesson we'll briefly discuss the concept of Ownership and Borrowing in Rust, and how expressions can be passed by value and by reference.

Understanding basic Ownership and Borrowing in Rust

In this lesson we'll learn how to read user input from stdin, using Rust's `std::io` module and its `Stdin` object.

Read user input from stdin in Rust

In this lesson we'll take a look at the simplest way of handling error in Rust using the `unwrap()` function.

Handle errors with unwrap() in Rust

This lesson discusses how to improve error handling by configuring custom error messages using the `expect()` function.

Handle errors in Rust using expect()

In this lesson we'll explore how to unwrap a `Result` type using a language feature called Pattern Matching.

Handle errors in Rust using Pattern Matching

In this lesson we'll learn how to exit a program using the `std::process` module in Rust and it's `exit()` method.

Exit a program using std::process in Rust

This lesson shows how to use a Rust `loop` to run a program infinitely.

Topics

Instructors

Content Type

Free or Pro