Check out a free preview of the full Rust for TypeScript Developers course

The "Wrapping Up" Lesson is part of the full, Rust for TypeScript Developers course featured in this preview video. Here's what you'd learn in this lesson:

ThePrimeagen summarizes what was covered throughout the course and shares additional topics recommended for diving deeper into Rust. Resources and ideas for example applications to build in Rust are also discussed. Live long and VIM.


Transcript from the "Wrapping Up" Lesson

>> There's a lot more to learn. And we learned a lot of things, okay? We learned about just like your basic enums. You at least know what enums are. You kind of know how they're defined. You can now know they have subtypes, they can be generic, they can implement traits, they can implement their own methods and their own behaviors.

You have a vague idea of what the borrow checker does. You know about value, versus reference, versus mutable reference. You know about how options try to solve the undefined problem. You know how about results try to resolve the old throw problem that we have, Because you don't even know what functions throw in JavaScript.

You saw the basics of Rust, and hopefully that makes you excited about learning more. The problem about trying to learn something like Rust is, like I said, there's a big skill gap to it. In other words, you can just keep on learning for quite some time. There's a lot of room to just keep getting better at the language.

It's like C++, just without all the C++, [SOUND] right? You don't even have to deal with the C++ part of it, but it has that level of deepness to it. So there is something just really personally, I think magical about a language where you can keep on getting better at it.

Whereas TypeScript, if you've been programming it long enough, you don't necessarily feel like you're getting better at TypeScript. You just feel like you're getting better at trying to align things to work well enough. And for me, it's like I I don't even have new tools I can learn to get dramatically better.

I just feel like I'm kind of only, okay, I generally know what I'm doing. It just doesn't feel as enriching for me. So that's something I've just really liked about Rust. So hopefully this kind of builds the curiosity for you all that you want to learn a bit more about it.

We didn't even cover really errors, how to create errors, the error trait. We didn't cover WASM and UIs. We didn't cover async, smart pointers, interior mutability, lifetimes, macros, both proc macros and declarative macros. They're truly amazing, I can't even believe they exist. It's just really hard to fit all the things you could possibly fit into this course.

And so this was just me trying to give you at least traits and enums, so that you have a super strong foundation to be able to move from there. For me, those were the strangest differences coming from TypeScript into this. Because they were just unusual for me. And so hopefully that excites you, hopefully it makes you really excited about learning more about this.

I think it's tons of fun to do it. I just love the skill gap of all of it. Some good resources I think is the Rust book. You can just look it up, The Rust Book, it's fantastic. It goes over everything fairly in depth, and at the same time it's really simple.

There's also some variations of The Rust Book, like Too Many Damn Lists, the Async Rust Book, The Cargo Rust Book. And you can kind of go over each one of the topics, and learn about how the build tool works, how async works, and just how Rust works in general.

And then there's also Jonhoo's YouTube. If you haven't watched Jonhoo, he's like a super smart Rust guy. Okay, so when I told you, remember when I said how do you measure yourself with the language? One being, you can kind of write it. Two, you're writing libraries for it.

Three, you could give back to the language, like you know it really, well. Jonhoo's on the three side of Rust, so he really, really, does know it. Also,'s blog. He's very very good, he writes some super cool stuff. He has this really cool way in which he solves advent of code problems.

And he did some super cool default trait implementations along with changing how, say, the range works from 0 to 10. He actually changed how the methods would work on it, and made it so it solves problems, really cool. So cool stuff you can go read on, and how you can do stuff.

Things you, if you want to build, if you want to try it out. CLI applications are always a great start. Pick something that you like. Try doing LS, try doing anything, any basic command line utility, just learn how to use and write rust. I think WebSocket servers are great to just learn about async Rust.

See if you can just do a little chat program with WebSocket servers. Normally this is where I'd scream Tokyo, I'm not going to do it. If you want to learn about WASM, Leptos is an awesome framework. It's just like solid.js. It feels just like it, except for it implements a couple of things that make it super simple to use within Rust.

It implements the clone trait, or both the clone and copy trait, which means that you can just pass it around, and it'll automatically clone just the outside, whereas you keep the same signal. So you can just spread one signal throughout your whole application without worrying who's borrowing it and all that.

It just makes UI really, really simple to do, good times. And so my hope for you is that you don't leave with everything, but you leave enough to Google your way out of a problem. I hope you enjoyed this. I tried to get as much as I possibly could in such a small period of time.

That's all I can really give you in one day, I hope you enjoyed it. That's really it, Thank you.
>> Thank you, Twitch.
>> This is the first time I got a clap at Front End Masters.

Learn Straight from the Experts Who Shape the Modern Web

  • In-depth Courses
  • Industry Leading Experts
  • Learning Paths
  • Live Interactive Workshops
Get Unlimited Access Now