Rust Adventure is an ever-growing collection of courses designed to help you put Rust into production through real-world projects.
Introducing Rust Adventure
Rust's mission statement is to be a language empowering everyone to build reliable and efficient software.
It achieves this by being a language approachable enough for JavaScript developers and performant enough for C developers.
If you're a web developer, Rust can introduce you to writing API servers.
Dig in to your preferred focus area, from writing your first Rust program to expertly applying new crates. Here's a sampling of what paths Rust Adventure offers.
Rust's focus on zero-cost abstraction mean that Serverless Functions boot and run faster, often in just milliseconds, while being as easy to use as JavaScript.
Write your first Serverless function without worrying about setting up infrastructure using Netlify Functions and PlanetScale MySQL.
Then level up and take advantage of hyperscalers with AWS CDK, Lambda, and DynamoDB using your first AWS account.
Learn how to use async/await for the first time and optionally delve into advanced concepts like Streams.
Use Rust to insert and query data from both SQL and NoSQL databases.
Rust excels at creating small, portable, and quick to run Command Line applications.
Parse flags from the CLI, config files, and the environment with Clap.
Learn how to integration test CLI tools by taking control over binaries, asserting against the filesystem, and even working with interactive programs.
Provide useful human feedback for errors and progress.
Experience the tracing crate for the first time, a recurring theme that builds into observability later.
Let's face it, the only thing that matters when learning something new is that you're still interested in it tomorrow. Building video games is a great way to level up your Rust knowledge while also being easy to show your friends and future employers.
Bevy's ECS based game engine allows us to build complex applications out of small building blocks. This means we can tackle more advanced concepts like implementing Traits in isolated pieces of our application.
Learn how to build your own structs take advantage of traits to imbue them with the functionality you need.
Games provide us with a rich tapestry of problems that we can use to advance our Rust skills such as:
I designed Rust Adventure to allow you to learn Rust through practical, fun projects.
Learning features of the Rust language in-context when we need to solve real problems helps them stick because you'll actually understand why lifetimes exist.
During Rust Adventure, you will build up a collection of real-world code you can show your friends *and* your future employers.
Helpful Resources
Recent crate releases, one-off Rust language feature deep dives, useful crate rundowns, and smaller tutorials.
#[tokio::main]
async fn main() -> Result<(), Error> {
let handler_fn = service_fn(handler);
lambda_runtime::run(handler_fn).await?;
Ok(())
}
async fn handler(
event: LambdaEvent<ApiGatewayV2httpRequest>,
) -> Result<ApiGatewayV2httpResponse, Error> {
let (_event, _context) = event.into_parts();
let response = format!(
"{}",
event.path_parameters
.get("pokemon")
.unwrap_or("world")
);
Ok(ApiGatewayV2httpResponse {
status_code: 200,
headers: HeaderMap::new(),
multi_value_headers: HeaderMap::new(),
body: Some(Body::Text(response)),
is_base64_encoded: Some(false),
cookies: vec![],
})
}
#[derive(StructOpt, Debug)]
#[structopt(name = "garden")]
struct Opt {
#[structopt(
parse(from_os_str),
short = 'p',
long,
env
)]
garden_path: Option<PathBuf>,
#[structopt(subcommand)]
cmd: Command,
}
#[derive(StructOpt, Debug)]
enum Command {
/// write something in your garden
///
/// This command will open your $EDITOR, wait for you
/// to write something, and then save the file to your
/// garden
Write {
/// Optionally set a title for what you are going to write about
#[structopt(short, long)]
title: Option<String>,
},
}
fn game_reset(
mut commands: Commands,
tiles: Query<Entity, With<Position>>,
mut game: ResMut<Game>,
) {
for entity in tiles.iter() {
commands.entity(entity).despawn_recursive();
}
game.score = 0;
}
