Training Example: Rust Programming Language – Review the Data, Give Your Score & Compare to the Real AI Evaluation

[H3] Performance

Rust is blazingly fast and memory-efficient: with no runtime or
garbage collector, it can power performance-critical services, run on
embedded devices, and easily integrate with other languages.

[H3] Reliability

Rust’s rich type system and ownership model guarantee memory-safety
and thread-safety — enabling you to eliminate many classes of
bugs at compile-time.

[H3] Productivity

Rust has great documentation, a friendly compiler with useful error
messages, and top-notch tooling — an integrated package manager
and build tool, smart multi-editor support with auto-completion and
type inspections, an auto-formatter, and more.

In 2018, the Rust community decided to improve the programming experience
for a few distinct domains (see the 2018
roadmap). For these, you can find many high-quality crates and some
awesome guides on how to get started.

[IMG: terminal]

[H3]
Command Line
Whip up a CLI tool quickly with Rust’s robust ecosystem.
Rust helps you maintain your app with confidence and distribute it with ease.
Building Tools

[IMG: gear with puzzle piece elements]

[H3]
WebAssembly
Use Rust to supercharge your JavaScript, one module at a time.
Publish to npm, bundle with webpack, and you’re off to the races.
Writing Web Apps

[IMG: a cloud with nodes]

[H3]
Networking
Predictable performance. Tiny resource footprint. Rock-solid reliability.
Rust is great for network services.
Working On Servers

[IMG: an embedded device chip]

[H3]
Embedded
Targeting low-resource devices?
Need low-level control without giving up high-level conveniences?
Rust has you covered.
Starting With Embedded

Hundreds of companies around the world are using Rust in production
today for fast, low-resource, cross-platform solutions. From startups to large
corporations, from embedded devices to scalable web services, Rust is a great fit.

[H3] Read Rust
We love documentation! Take a look at the books available online, as well as key blog posts and user guides.
Read the book

[H3] Watch Rust
The Rust community has a dedicated YouTube channel collecting a huge range of presentations and
tutorials.
Watch the Videos

[H3] Contribute code

Rust is truly a community effort, and we welcome contribution from hobbyists and production users, from
newcomers and seasoned professionals. Come help us make the Rust experience even better!

Read Contribution Guide

Rust would not exist without the generous contributions of time, work, and resources from individuals and companies. We are very grateful for the support!

[H3] Individuals
Rust is a community project and is very thankful for the many community contributions it receives.
See individual contributors

[H3] Corporate sponsors
The Rust project receives support from companies through the Rust Foundation.
See Foundation members

Affectionately nicknamed “the book,” The Rust Programming Language will give you an overview of the language from first principles. You’ll build a few projects along the way, and by the end, you’ll have a solid grasp of the language.
Read the Book!

If reading multiple hundreds of pages about a language isn’t your style, then Rust By Example has you covered. While the book talks about code with a lot of words, RBE shows off a bunch of code, and keeps the talking to a minimum. It also includes exercises!
Check out Rust by Example!

Alternatively, Rustlings guides you through downloading and setting up the Rust toolchain, and teaches you the basics of reading and writing Rust syntax, on the command line. It's an alternative to Rust by Example that works with your own environment.
Do the Rustlings course!

[H3] Read the core documentation
All of this documentation is also available locally using the rustup doc command, which will open up these resources for you in your browser without requiring a network connection!

The standard library
Comprehensive guide to the Rust standard library APIs.

Edition Guide
Guide to the Rust editions.

Cargo Book
A book on Rust’s package manager and build system.

rustdoc Book
Learn how to make awesome documentation for your crate.

rustc Book
Familiarize yourself with the knobs available in the Rust compiler.

Compiler Error Index
In-depth explanations of the errors you may see from the Rust compiler.

[H3] Build your skills in an application domain

Command Line Book

Learn how to build effective command line applications in Rust.

Embedded Book

Become proficient with Rust for Microcontrollers and other embedded systems.

Curious about the darkest corners of the language? Here’s where you can get into the nitty-gritty:

[IMG: A bookshelf icon]

The Reference is not a formal spec, but is more detailed and comprehensive than the book.
Read the reference

[IMG: Two hands cradling fire]

The Rustonomicon is your guidebook to the dark arts of unsafe Rust. It’s also sometimes called “the ’nomicon.”

Read the ’nomicon

[IMG: A hand sharing sparkles]

The Unstable Book has documentation for unstable features that you can only use with nightly Rust.
Read the unstable book

You can try Rust online in the Rust Playground without installing anything on your computer.
Try Rust without installing
[H3] Rustup: the Rust installer and version management tool
The primary way that folks install Rust is through a tool called Rustup, which is a Rust installer and version management tool.

It looks like you’re running macOS, Linux, or another Unix-like OS. To download Rustup and install Rust, run the following in your terminal, then follow the on-screen instructions. See "Other Installation Methods" if you are on Windows.
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Copy

It looks like you’re running Windows. To start using Rust, download the installer, then run the program and follow the onscreen instructions. You may need to install the Visual Studio C++ Build tools when prompted to do so. If you are not on Windows see "Other Installation Methods".

Download rustup-init.exe (32-bit)

Download rustup-init.exe (x64)

Download rustup-init.exe (ARM64)

[H3] Windows Subsystem for Linux
If you’re a Windows Subsystem for Linux user run the following in your terminal, then follow the on-screen instructions to install Rust.
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Copy

To install Rust, if you are running a Unix such as WSL, Linux or macOS, run the following in your terminal, then follow the on-screen instructions.

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Copy

If you are running Windows,download and run rustup‑init.exe then follow the on-screen instructions.

[H3] Is Rust up to date?
Rust updates very frequently. If you have installed Rustup some time ago, chances are your Rust version is out of date. Get the latest version of Rust by running rustup update.
Learn more about installation
[H3] Cargo: the Rust build tool and package manager
When you install Rustup you’ll also get the latest stable version of the Rust build tool and package manager, also known as Cargo. Cargo does lots of things:
build your project with cargo build
run your project with cargo run
test your project with cargo test
build documentation for your project with cargo doc
publish a library to crates.io with cargo publish
To test that you have Rust and Cargo installed, you can run this in your terminal of choice:
cargo --version
Read the cargo book
[H3] Other tools
Rust support is available in many editors:

VS Code

Vim/Neovim

RustRover

Helix

Emacs

Sublime Text

Visual Studio

Zed

Let’s write a small application with our new Rust development environment. To start, we’ll use Cargo to make a new project for us. In your terminal of choice run:
cargo new hello-rust
This will generate a new directory called hello-rust with the following files:
hello-rust
|- Cargo.toml
|- src
|- main.rs
Cargo.toml is the manifest file for Rust. It’s where you keep metadata for your project, as well as dependencies.
src/main.rs is where we’ll write our application code.
The cargo new step generated a "Hello, world!" project for us! We can run this program by moving into the new directory that we made and running this in our terminal:
cargo run
You should see this in your terminal:
$ cargo run
Compiling hello-rust v0.1.0 (/Users/ag_dubs/rust/hello-rust)
Finished dev [unoptimized + debuginfo] target(s) in 1.34s
Running `target/debug/hello-rust`
Hello, world!

Let’s add a dependency to our application. You can find all sorts of libraries on crates.io, the package registry for Rust. In Rust, we often refer to packages as “crates.”
In this project, we’ll use a crate called ferris-says.
In our Cargo.toml file we’ll add this information (that we got from the crate page):
[dependencies]
ferris-says = "0.3.1"
We can also do this by running cargo add ferris-says.
Now we can run:
cargo build
...and Cargo will install our dependency for us.
You’ll see that running this command created a new file for us, Cargo.lock. This file is a log of the exact versions of the dependencies we are using locally.
To use this dependency, we can open main.rs, remove everything that’s in there (it’s just another example), and add this line to it:
use ferris_says::say;
This line means that we can now use the say function that the ferris-says crate exports for us.

Now let’s write a small application with our new dependency. In our main.rs, add the following code:
use ferris_says::say; // from the previous step
use std::io::{stdout, BufWriter};
fn main() {
let stdout = stdout();
let message = String::from("Hello fellow Rustaceans!");
let width = message.chars().count();
let mut writer = BufWriter::new(stdout.lock());
say(&message, width, &mut writer).unwrap();
}
Once we save that, we can run our application by typing:
cargo run
Assuming everything went well, you should see your application print this to the screen:
__________________________
< Hello fellow Rustaceans! >
--------------------------
\
\
_~^~^~_
\) / o o \ (/
'_ - _'
/ '-----' \

You’re a Rustacean now! Welcome! We’re so glad to have you. When you’re ready, hop over to our Learn page, where you can find lots of books that will help you to continue on your Rust adventure.
learn more!

Ferris is the unofficial mascot of the Rust Community. Many Rust programmers call themselves “Rustaceans,” a play on the word “crustacean.” We refer to Ferris with any pronouns “she,” “he,” “they,” “it,” etc.
Ferris is a name playing off of the adjective, “ferrous,” meaning of or pertaining to iron. Since Rust often forms on iron, it seemed like a fun origin for our mascot’s name!
You can find more images of Ferris on rustacean.net.

[IMG: a gif of ferris scurrying side to side]

We are committed to providing a friendly, safe and welcoming environment for all, regardless of level of experience, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, nationality, or other similar characteristic.
Please avoid using overtly sexual aliases or other nicknames that might detract from a friendly, safe and welcoming environment for all.
Please be kind and courteous. There’s no need to be mean or rude.
Respect that people have differences of opinion and that every design or implementation choice carries a trade-off and numerous costs. There is seldom a right answer.
Please keep unstructured critique to a minimum. If you have solid ideas you want to experiment with, make a fork and see how it works.
We will exclude you from interaction if you insult, demean or harass anyone. That is not welcome behavior. We interpret the term “harassment” as including the definition in the Citizen Code of Conduct; if you have any lack of clarity about what might be included in that concept, please read their definition. In particular, we don’t tolerate behavior that excludes people in socially marginalized groups.
Private harassment is also unacceptable. No matter who you are, if you feel you have been or are being harassed or made uncomfortable by a community member, please contact one of the channel ops or any of the Rust moderation team
immediately. Whether you’re a regular contributor or a newcomer, we care about making this community a safe place for you and we’ve got your back.
Likewise any spamming, trolling, flaming, baiting or other attention-stealing behavior is not welcome.
Email The Moderation Team

These are the policies for upholding our community’s standards of conduct. If you feel that a thread needs moderation, please contact the Rust moderation team.
Remarks that violate the Rust standards of conduct, including hateful, hurtful, oppressive, or exclusionary remarks, are not allowed. (Cursing is allowed, but never targeting another user, and never in a hateful manner.)
Remarks that moderators find inappropriate, whether listed in the code of conduct or not, are also not allowed.
Moderators will first respond to such remarks with a warning.
If the warning is unheeded, the user will be “kicked,” i.e., kicked out of the communication channel to cool off.
If the user comes back and continues to make trouble, they will be banned, i.e., indefinitely excluded.
Moderators may choose at their discretion to un-ban the user if it was a first offense and they offer the offended party a genuine apology.
If a moderator bans someone and you think it was unjustified, please take it up with that moderator, or with a different moderator, in private. Complaints about bans in-channel are not allowed.
Moderators are held to a higher standard than other community members. If a moderator creates an inappropriate situation, they should expect less leeway than others.
In the Rust community we strive to go the extra step to look out for each other. Don’t just aim to be technically unimpeachable, try to be your best self. In particular, avoid flirting with offensive or sensitive issues, particularly if they’re off-topic; this all too often leads to unnecessary fights, hurt feelings, and damaged trust; worse, it can drive people away from the community entirely.
And if someone takes issue with something you said or did, resist the urge to be defensive. Just stop doing what it was they complained about and apologize. Even if you feel you were misinterpreted or unfairly accused, chances are good there was something you could’ve communicated better — remember that it’s your responsibility to make your fellow Rustaceans comfortable. Everyone wants to get along and we are all here first and foremost because we want to talk about cool technology. You will find that people will be eager to assume good intent and forgive as long as you earn their trust.
The enforcement policies listed above apply to all official Rust venues; including Zulip channels (https://rust-lang.zulipchat.com/); GitHub repositories under rust-lang, rust-lang-nursery, and rust-lang-deprecated; and all forums under rust-lang.org (users.rust-lang.org, internals.rust-lang.org). For other projects adopting the Rust Code of Conduct, please contact the maintainers of those projects for enforcement. If you wish to use this code of conduct for your own project, consider explicitly mentioning your moderation policy or making a copy with your own moderation policy so as to avoid confusion.
Adapted from the Node.js Policy on Trolling as well as the Contributor Covenant v1.3.0.