Repository: NLeSC/guide
Pull request #436: first iteration of the Rust chapter
Author: login: rvhonorato
Created: 2025-04-17T14:51:22Z | Merged: 2025-04-24T15:14:32Z

# Changes in this PR
<!--
Give a brief description of the PR, mainly: why & what.
Link relevant issues as well.
-->

This PR adds a first iteration of a chapter about Rust to the guide. For now it just contains a very basic explanation of the main concepts of the language, a section on how to get started with the first project and some links to learning resources. I plan to add more content such as relevant projects for research and more specific topics about the language itself - but these can go in other PRs. 

Please let me know if this is in line with the guidelines.

# Checklist
<!--
Use the checklist below to make sure you followed the [CONTRIBUTING guidelines](https://guide.esciencecenter.nl/#/CONTRIBUTING).
Feel free to remove what is not applicable.
-->

## SIGNIFICANT changes / additions, e.g. new chapters
- [x] I checked whether the contribution fits in [The Turing Way](https://github.com/the-turing-way/the-turing-way) before considering contributing to this Guide.
- [x] I discussed my contribution in an issue and took into account feedback.
    - https://github.com/NLeSC/guide/issues/388

## ALL contributions
- [x] I previewed my changes locally using e.g. `python3 -m http.server 4000` and confirmed they work correctly.
- [x] I checked for broken links, e.g. using the link checker GitHub Action workflow, or locally by using ``docker run --init -it -v `pwd`:/docs lycheeverse/lychee /docs --config=docs/lychee.toml``, at least for the files I changed.
- [x] My name was added to the `CITATION.cff` file.



Diff:
diff --git a/CITATION.cff b/CITATION.cff
index 5b89bb8..7a8859b 100644
--- a/CITATION.cff
+++ b/CITATION.cff
@@ -168,3 +168,7 @@ authors:
     family-names: Kasalica
     given-names: Vedran
     orcid: "https://orcid.org/0000-0002-0097-1056"
+  - affiliation: "Utrecht University"
+    family-names: Vargas Honorato
+    given-names: Rodrigo
+    orcid: "https://orcid.org/0000-0001-5267-3002"
diff --git a/_sidebar.md b/_sidebar.md
index f203f39..dfba962 100644
--- a/_sidebar.md
+++ b/_sidebar.md
@@ -7,6 +7,7 @@
   - [R](/language_guides/r.md)
   - [C and C++](/language_guides/ccpp.md)
   - [Fortran](/language_guides/fortran.md)
+  - [Rust](/language_guides/rust.md)
 - [Technology Guides](/technology/technology_overview.md)
   - [GPU programming](/technology/gpu.md)
   - [UX - User Experience](/technology/user_experience.md)
diff --git a/index.html b/index.html
index 9bf90b8..c696000 100644
--- a/index.html
+++ b/index.html
@@ -40,6 +40,7 @@
     <script src="https://cdn.jsdelivr.net/npm/docsify/lib/plugins/external-script.min.js"></script>
     <script src="https://cdn.jsdelivr.net/npm/docsify/lib/plugins/search.min.js"></script>
     <script src="https://cdn.jsdelivr.net/npm/prismjs/components/prism-bash.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/prismjs/components/prism-rust.min.js"></script>
     <!-- custom version of Matomo plugin, modified from https://github.com/docsifyjs/docsify/blob/develop/src/plugins/matomo.js -->
     <script>
       function appendScript(options) {
diff --git a/language_guides/rust.md b/language_guides/rust.md
new file mode 100644
index 0000000..a62cf64
--- /dev/null
+++ b/language_guides/rust.md
@@ -0,0 +1,134 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern programming language designed to provide both high
+performance while enforcing memory safety through its unique ownership system
+and borrow checker. Developed by Mozilla and first released in 2015,
+Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years its ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+Rust is increasingly adopted in **research software** for its unique blend of
+speed, safety, and modern tooling. It powers everything from
+high-throughput DNA sequencing pipelines to climate simulations, where even
+minor memory errors could invalidate results. By eliminating entire classes
+of bugs (e.g., null pointers, race conditions, type mismatches), Rust lets
+researchers focus on science, not on debugging.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about allocating or freeing
+memory as the interpreter takes care of it, making the code slower but much
+easier to program. In a **low-level** language you need to manage it yourself.
+Because Rust runs "closer to the metal", it achieves blazing-fast performance -
+similar to [C/C++](./ccpp.md) while avoiding common memory-safety and
+concurrency bugs.
+
+Here are some of Rust's key characteristics:
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
+  time, eliminating crashes from null pointers, dangling references, or leaks.
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), [crates.io](https://crates.io) (libraries)
+  and [rustdoc](https://doc.rust-lang.org/stable/rustdoc/) (documentation)
+  streamline development.
+
+```rust
+// Ownership in action: the compiler tracks who "owns" data.
+fn main() {
+    // Lets declare a string, here `s` owns it
+    let s = String::from("hello");
+
+    // Borrow `s` as a read-only reference (no ownership transference)
+    let len = calculate_length(&s);
+
+    // `s` still owns the data and we can use it
+    println!("'{}' has length {}", s, len);
+}
+
+fn calculate_length(s: &str) -> usize {
+    s.len()
+}
+```
+
+## Getting started
+
+To get started you will first need to install Rust, this can be done via [`rustup`](https://rustup.rs)
+which is a command line tool for managing Rust versions and tools.
+
+On Linux/MacOs:
+
+```bash
+curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
+```
+
+On Windows, [see the instructions here](https://forge.rust-lang.org/infra/other-installation-methods.html#other-ways-to-install-rustup).
+
+Cargo is Rust's build system and package manager and is installed by `rustup`.
+You can use it to create a project:
+
+```bash
+cargo new rust_project
+```
+
+This will create the project folder structure, add a `Cargo.toml` and a `src/main.rs`
+which contains a placeholder "Hello world", so you can already build this
+`rust_project`
+
+```bash
+cd rust_project
+cargo build --release # using --release will build the optimized binary
+./target/release/rust_project # execute the binary
+```
+
+## Learning
+
+Its unique approach to memory management (ownership, borrowing and lifetimes) and
+the strict compiler can feel daunting at fist - especially if you are accustomed
+to high-level languages like [python](./python.md) or [javascript](./javascript.md).
+Learning Rust can be challenging as some new concepts, such as the borrow checker
+, may take time to be internalized.
+
+> Keep in mind that in the long run all the effort pays off. The code produced
+> will be faster while having _fewer bugs_ (thanks to the opinionated compiler),
+> you will learn _transferable skills_ that will make you a better programmer
+> in other languages. The general mindset should be **start small and embrace
+> the compiler**.
+
+To learn it, you only need:
+
+- [The Rust Book](https://doc.rust-lang.org/book/): This
+  is the official book and it is very well written and easy to follow. It contains
+  all the information you need to gain a deep understanding of Rust. It contains
+  a fully guided tutorial on how to write a Guessing game as your first project.
+- [Rust by Example](https://doc.rust-lang.org/rust-by-example/): This contains
+  smaller examples of how to use the language, and it is a good complement to
+  the book or when you need to quickly look up how to do something.
+- [Rustlings](https://rustlings.cool): Fully interactive exercises
+  that will help you get used to the syntax and the concepts of the language -
+  it is paired with the book, so you should be doing the exercises as you go
+  through the book.
+- [Rust Playground](https://play.rust-lang.org/): Lets you experiment with Rust
+  online in your browser
+
+🦀


Reviews:
user: login: stijnh
body: The text is looking good. Overall, I think it is a great introduction to Rust. Great work! Maybe we could also link to some research software written in Rust to give concrete examples of where it is used.

I left some comments to provide feedback, they are only minor issues in the text.

For a future version of this page, we could also discuss PyO3. I have seen several cases where people rewrite parts of their Python code in Rust and then use PyO3 to make the Rust functions callable from Python.
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-04-22T12:57:42Z
user: login: rvhonorato
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-22T14:05:15Z
user: login: egpbos
body: Please apply the typos and then this looks good to merge to me! Thanks a lot for this great work! Let's do the additions mentioned (research software examples, PyO3) in a follow-up PR.
state: APPROVED
author_association: COLLABORATOR
submitted_at: 2025-04-23T08:26:58Z

Review comments:
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
path: language_guides/rust.md
user: login: stijnh
body: it's -> its
created_at: 2025-04-22T12:19:43Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
path: language_guides/rust.md
user: login: stijnh
body: "modern," -> "modern"
created_at: 2025-04-22T12:20:03Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
path: language_guides/rust.md
user: login: stijnh
body: Not sure if "robust" is really the right word here. Maybe "..designed to provide high performance while enforcing memory safety". 
created_at: 2025-04-22T12:23:59Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
path: language_guides/rust.md
user: login: stijnh
body: Not sure if "cleaning variables" is really the best way to describe it. Perhapse "in Python, you don't ever need to think about allocating or freeing memory as the interpreter takes care of it, making code slower but much easier to program."
created_at: 2025-04-22T12:27:24Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
path: language_guides/rust.md
user: login: stijnh
body: I would put this one at the top, as it is the really the main feature of Rust and the key advantage over other low-level langauges
created_at: 2025-04-22T12:28:35Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
+  time, eliminating crashes from null pointers, dangling references, or leaks.
+
+```rust
+// Ownership in action: the compiler tracks who "owns" data.
+fn main() {
+    // Lets declare a string, here `s` owns it
+    let s = String::from("hello");
+
+    // Borrow `s` as a read-only reference (no ownership transference)
+    let len = calculate_length(&s);
+
+    // `s` still owns the data and we can use it
+    println!("'{}' has length {}", s, len);
+}
+
+fn calculate_length(s: &String) -> usize {
path: language_guides/rust.md
user: login: stijnh
body: The idiomatic signature would be "s: &str". 

Although, for this example I would understand that explaining the difference between `String` and `str` might be too much information
created_at: 2025-04-22T12:30:24Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
+  time, eliminating crashes from null pointers, dangling references, or leaks.
+
+```rust
+// Ownership in action: the compiler tracks who "owns" data.
+fn main() {
+    // Lets declare a string, here `s` owns it
+    let s = String::from("hello");
+
+    // Borrow `s` as a read-only reference (no ownership transference)
+    let len = calculate_length(&s);
+
+    // `s` still owns the data and we can use it
+    println!("'{}' has length {}", s, len);
+}
+
+fn calculate_length(s: &String) -> usize {
+    s.len()
+}
+```
+
+Rust is increasingly adopted in **research software** for its unique blend of
path: language_guides/rust.md
user: login: stijnh
body: This is a great paragraph! I would move it to the top (after the first paragraph)
created_at: 2025-04-22T12:31:00Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
+  time, eliminating crashes from null pointers, dangling references, or leaks.
+
+```rust
+// Ownership in action: the compiler tracks who "owns" data.
+fn main() {
+    // Lets declare a string, here `s` owns it
+    let s = String::from("hello");
+
+    // Borrow `s` as a read-only reference (no ownership transference)
+    let len = calculate_length(&s);
+
+    // `s` still owns the data and we can use it
+    println!("'{}' has length {}", s, len);
+}
+
+fn calculate_length(s: &String) -> usize {
+    s.len()
+}
+```
+
+Rust is increasingly adopted in **research software** for its unique blend of
+speed, safety, and modern tooling. It powers everything from
+high-throughput DNA sequencing pipelines to climate simulations, where even
+minor memory errors could invalidate results. By eliminating entire classes
+of bugs (e.g., null pointers, race conditions, type mismatches), Rust lets
+researchers focus on science, not on debugging.
+
+## Getting started
+
+To get started you will first need to install Rust, this can be done via [`rustup`](https://rustup.rs)
+which is a command line tool for managing Rust versions and tools.
+
+On Linux/MacOs:
+
+```bash
+curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
+```
+
+On Windows, [see the instructions here](https://rust-book.cs.brown.edu/ch01-01-installation.html#installing-rustup-on-windows).
+
+Cargo is Rust's build system and package manager and is installed by `rustup`.
+You can use it to create a project:
+
+```bash
+cargo new rust_project
+```
+
+This will create the project folder structure, add a `Cargo.toml` and a `src/main.rs`
+which contains a placeholder "Hello world", so you can already build this
+`rust_project`
+
+```bash
+cd rust_project
+cargo build --release # using --release will build the optimized binary
+./target/release/rust_project # execute the binary
+```
+
+## Learning
+
+It's unique approach to memory management (ownership, borrowing and lifetimes) and
+the strict compiler can feel daunting at fist - especially if you are accustomed
+to high-level languages like [python](./python.md) or [javascript](./javascript.md).
+You **will** wrestle with the borrow checker and some concepts may take time to be
+internalized.
+
+> Keep in mind that in the long run all the effort pays off. The code produced
+> will have _fewer bugs_ (thanks to the opinionated compiler), you will learn
path: language_guides/rust.md
user: login: stijnh
body: Maybe also mention that the code is fast. Maybe something like "The code produced will be faster while having fewer bugs than a high-level language"
created_at: 2025-04-22T12:35:38Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
+  time, eliminating crashes from null pointers, dangling references, or leaks.
+
+```rust
+// Ownership in action: the compiler tracks who "owns" data.
+fn main() {
+    // Lets declare a string, here `s` owns it
+    let s = String::from("hello");
+
+    // Borrow `s` as a read-only reference (no ownership transference)
+    let len = calculate_length(&s);
+
+    // `s` still owns the data and we can use it
+    println!("'{}' has length {}", s, len);
+}
+
+fn calculate_length(s: &String) -> usize {
+    s.len()
+}
+```
+
+Rust is increasingly adopted in **research software** for its unique blend of
+speed, safety, and modern tooling. It powers everything from
+high-throughput DNA sequencing pipelines to climate simulations, where even
+minor memory errors could invalidate results. By eliminating entire classes
+of bugs (e.g., null pointers, race conditions, type mismatches), Rust lets
+researchers focus on science, not on debugging.
+
+## Getting started
+
+To get started you will first need to install Rust, this can be done via [`rustup`](https://rustup.rs)
+which is a command line tool for managing Rust versions and tools.
+
+On Linux/MacOs:
+
+```bash
+curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
+```
+
+On Windows, [see the instructions here](https://rust-book.cs.brown.edu/ch01-01-installation.html#installing-rustup-on-windows).
+
+Cargo is Rust's build system and package manager and is installed by `rustup`.
+You can use it to create a project:
+
+```bash
+cargo new rust_project
+```
+
+This will create the project folder structure, add a `Cargo.toml` and a `src/main.rs`
+which contains a placeholder "Hello world", so you can already build this
+`rust_project`
+
+```bash
+cd rust_project
+cargo build --release # using --release will build the optimized binary
+./target/release/rust_project # execute the binary
+```
+
+## Learning
+
+It's unique approach to memory management (ownership, borrowing and lifetimes) and
+the strict compiler can feel daunting at fist - especially if you are accustomed
+to high-level languages like [python](./python.md) or [javascript](./javascript.md).
+You **will** wrestle with the borrow checker and some concepts may take time to be
+internalized.
+
+> Keep in mind that in the long run all the effort pays off. The code produced
+> will have _fewer bugs_ (thanks to the opinionated compiler), you will learn
+> _transferable skills_ that will make you a better programmer in other
+> languages. The general mindset should be **start small and embrace the compiler**.
+
+To learn it, you only need:
+
+- [The Rust Book](https://rust-book.cs.brown.edu/ch00-00-introduction.html): This
+  is the official book and it is very well written and easy to follow. It contains
+  all the information you need to gain a deep understanding of Rust. It contains
+  a fully guided tutorial on how to write a Guessing game as your first project.
+- [Rust by Example](https://doc.rust-lang.org/rust-by-example/): This contains
+  smaller examples of how to use the language, and it is a good complement to
+  the book or when you need to quickly look up how to do something.
+- [Rustlings](https://rustlings.cool): Fully interactive exercises
+  that will help you get used to the syntax and the concepts of the language -
+  it is paired with the book, so you should be doing the exercises as you go
+  through the book.
+
+🦀
path: language_guides/rust.md
user: login: stijnh
body: 🦀!
created_at: 2025-04-22T12:35:48Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
+  time, eliminating crashes from null pointers, dangling references, or leaks.
+
+```rust
+// Ownership in action: the compiler tracks who "owns" data.
+fn main() {
+    // Lets declare a string, here `s` owns it
+    let s = String::from("hello");
+
+    // Borrow `s` as a read-only reference (no ownership transference)
+    let len = calculate_length(&s);
+
+    // `s` still owns the data and we can use it
+    println!("'{}' has length {}", s, len);
+}
+
+fn calculate_length(s: &String) -> usize {
+    s.len()
+}
+```
+
+Rust is increasingly adopted in **research software** for its unique blend of
+speed, safety, and modern tooling. It powers everything from
+high-throughput DNA sequencing pipelines to climate simulations, where even
+minor memory errors could invalidate results. By eliminating entire classes
+of bugs (e.g., null pointers, race conditions, type mismatches), Rust lets
+researchers focus on science, not on debugging.
+
+## Getting started
+
+To get started you will first need to install Rust, this can be done via [`rustup`](https://rustup.rs)
+which is a command line tool for managing Rust versions and tools.
+
+On Linux/MacOs:
+
+```bash
+curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
+```
+
+On Windows, [see the instructions here](https://rust-book.cs.brown.edu/ch01-01-installation.html#installing-rustup-on-windows).
+
+Cargo is Rust's build system and package manager and is installed by `rustup`.
+You can use it to create a project:
+
+```bash
+cargo new rust_project
+```
+
+This will create the project folder structure, add a `Cargo.toml` and a `src/main.rs`
+which contains a placeholder "Hello world", so you can already build this
+`rust_project`
+
+```bash
+cd rust_project
+cargo build --release # using --release will build the optimized binary
+./target/release/rust_project # execute the binary
+```
+
+## Learning
+
+It's unique approach to memory management (ownership, borrowing and lifetimes) and
+the strict compiler can feel daunting at fist - especially if you are accustomed
+to high-level languages like [python](./python.md) or [javascript](./javascript.md).
+You **will** wrestle with the borrow checker and some concepts may take time to be
path: language_guides/rust.md
user: login: stijnh
body: This is the first time that the "borrow checker" is mentioned. Ideally, it should also be explained somewhere in the first paragraph.
created_at: 2025-04-22T12:37:43Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
+  time, eliminating crashes from null pointers, dangling references, or leaks.
+
+```rust
+// Ownership in action: the compiler tracks who "owns" data.
+fn main() {
+    // Lets declare a string, here `s` owns it
+    let s = String::from("hello");
+
+    // Borrow `s` as a read-only reference (no ownership transference)
+    let len = calculate_length(&s);
+
+    // `s` still owns the data and we can use it
+    println!("'{}' has length {}", s, len);
+}
+
+fn calculate_length(s: &String) -> usize {
+    s.len()
+}
+```
+
+Rust is increasingly adopted in **research software** for its unique blend of
+speed, safety, and modern tooling. It powers everything from
+high-throughput DNA sequencing pipelines to climate simulations, where even
+minor memory errors could invalidate results. By eliminating entire classes
+of bugs (e.g., null pointers, race conditions, type mismatches), Rust lets
+researchers focus on science, not on debugging.
+
+## Getting started
+
+To get started you will first need to install Rust, this can be done via [`rustup`](https://rustup.rs)
+which is a command line tool for managing Rust versions and tools.
+
+On Linux/MacOs:
+
+```bash
+curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
+```
+
+On Windows, [see the instructions here](https://rust-book.cs.brown.edu/ch01-01-installation.html#installing-rustup-on-windows).
+
+Cargo is Rust's build system and package manager and is installed by `rustup`.
+You can use it to create a project:
+
+```bash
+cargo new rust_project
+```
+
+This will create the project folder structure, add a `Cargo.toml` and a `src/main.rs`
+which contains a placeholder "Hello world", so you can already build this
+`rust_project`
+
+```bash
+cd rust_project
+cargo build --release # using --release will build the optimized binary
+./target/release/rust_project # execute the binary
+```
+
+## Learning
+
+It's unique approach to memory management (ownership, borrowing and lifetimes) and
+the strict compiler can feel daunting at fist - especially if you are accustomed
+to high-level languages like [python](./python.md) or [javascript](./javascript.md).
+You **will** wrestle with the borrow checker and some concepts may take time to be
path: language_guides/rust.md
user: login: stijnh
body: I think "you will wrestle" sound a bit harsh and demotivating. Maybe, "Learning Rust can be challenging as some new concepts, such as the borrow checker, may take time to be internalized." 
created_at: 2025-04-22T12:41:31Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
+  time, eliminating crashes from null pointers, dangling references, or leaks.
+
+```rust
+// Ownership in action: the compiler tracks who "owns" data.
+fn main() {
+    // Lets declare a string, here `s` owns it
+    let s = String::from("hello");
+
+    // Borrow `s` as a read-only reference (no ownership transference)
+    let len = calculate_length(&s);
+
+    // `s` still owns the data and we can use it
+    println!("'{}' has length {}", s, len);
+}
+
+fn calculate_length(s: &String) -> usize {
+    s.len()
+}
+```
+
+Rust is increasingly adopted in **research software** for its unique blend of
+speed, safety, and modern tooling. It powers everything from
+high-throughput DNA sequencing pipelines to climate simulations, where even
+minor memory errors could invalidate results. By eliminating entire classes
+of bugs (e.g., null pointers, race conditions, type mismatches), Rust lets
+researchers focus on science, not on debugging.
+
+## Getting started
+
+To get started you will first need to install Rust, this can be done via [`rustup`](https://rustup.rs)
+which is a command line tool for managing Rust versions and tools.
+
+On Linux/MacOs:
+
+```bash
+curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
+```
+
+On Windows, [see the instructions here](https://rust-book.cs.brown.edu/ch01-01-installation.html#installing-rustup-on-windows).
path: language_guides/rust.md
user: login: stijnh
body: This is not an official link. A better option might be: https://forge.rust-lang.org/infra/other-installation-methods.html
created_at: 2025-04-22T12:42:32Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
+  time, eliminating crashes from null pointers, dangling references, or leaks.
+
+```rust
+// Ownership in action: the compiler tracks who "owns" data.
+fn main() {
+    // Lets declare a string, here `s` owns it
+    let s = String::from("hello");
+
+    // Borrow `s` as a read-only reference (no ownership transference)
+    let len = calculate_length(&s);
+
+    // `s` still owns the data and we can use it
+    println!("'{}' has length {}", s, len);
+}
+
+fn calculate_length(s: &String) -> usize {
+    s.len()
+}
+```
+
+Rust is increasingly adopted in **research software** for its unique blend of
+speed, safety, and modern tooling. It powers everything from
+high-throughput DNA sequencing pipelines to climate simulations, where even
+minor memory errors could invalidate results. By eliminating entire classes
+of bugs (e.g., null pointers, race conditions, type mismatches), Rust lets
+researchers focus on science, not on debugging.
+
+## Getting started
+
+To get started you will first need to install Rust, this can be done via [`rustup`](https://rustup.rs)
+which is a command line tool for managing Rust versions and tools.
+
+On Linux/MacOs:
+
+```bash
+curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
+```
+
+On Windows, [see the instructions here](https://rust-book.cs.brown.edu/ch01-01-installation.html#installing-rustup-on-windows).
+
+Cargo is Rust's build system and package manager and is installed by `rustup`.
+You can use it to create a project:
+
+```bash
+cargo new rust_project
+```
+
+This will create the project folder structure, add a `Cargo.toml` and a `src/main.rs`
+which contains a placeholder "Hello world", so you can already build this
+`rust_project`
+
+```bash
+cd rust_project
+cargo build --release # using --release will build the optimized binary
+./target/release/rust_project # execute the binary
+```
+
+## Learning
+
+It's unique approach to memory management (ownership, borrowing and lifetimes) and
+the strict compiler can feel daunting at fist - especially if you are accustomed
+to high-level languages like [python](./python.md) or [javascript](./javascript.md).
+You **will** wrestle with the borrow checker and some concepts may take time to be
+internalized.
+
+> Keep in mind that in the long run all the effort pays off. The code produced
+> will have _fewer bugs_ (thanks to the opinionated compiler), you will learn
+> _transferable skills_ that will make you a better programmer in other
+> languages. The general mindset should be **start small and embrace the compiler**.
+
+To learn it, you only need:
+
+- [The Rust Book](https://rust-book.cs.brown.edu/ch00-00-introduction.html): This
path: language_guides/rust.md
user: login: stijnh
body: This is not the official link, instead we should link to: https://doc.rust-lang.org/book/
created_at: 2025-04-22T12:43:33Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
path: language_guides/rust.md
user: login: stijnh
body: Maybe we could add here rustdoc (documentation): https://doc.rust-lang.org/rustdoc
created_at: 2025-04-22T12:45:15Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
path: language_guides/rust.md
user: login: stijnh
body: Maybe a sentence like "similar to [C/C++] while avoiding common memory-safety and concurrency bugs"
created_at: 2025-04-22T12:48:00Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
+  time, eliminating crashes from null pointers, dangling references, or leaks.
+
+```rust
+// Ownership in action: the compiler tracks who "owns" data.
+fn main() {
+    // Lets declare a string, here `s` owns it
+    let s = String::from("hello");
+
+    // Borrow `s` as a read-only reference (no ownership transference)
+    let len = calculate_length(&s);
+
+    // `s` still owns the data and we can use it
+    println!("'{}' has length {}", s, len);
+}
+
+fn calculate_length(s: &String) -> usize {
+    s.len()
+}
+```
+
+Rust is increasingly adopted in **research software** for its unique blend of
+speed, safety, and modern tooling. It powers everything from
+high-throughput DNA sequencing pipelines to climate simulations, where even
+minor memory errors could invalidate results. By eliminating entire classes
+of bugs (e.g., null pointers, race conditions, type mismatches), Rust lets
+researchers focus on science, not on debugging.
+
+## Getting started
+
+To get started you will first need to install Rust, this can be done via [`rustup`](https://rustup.rs)
+which is a command line tool for managing Rust versions and tools.
+
+On Linux/MacOs:
+
+```bash
+curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
+```
+
+On Windows, [see the instructions here](https://rust-book.cs.brown.edu/ch01-01-installation.html#installing-rustup-on-windows).
+
+Cargo is Rust's build system and package manager and is installed by `rustup`.
+You can use it to create a project:
+
+```bash
+cargo new rust_project
+```
+
+This will create the project folder structure, add a `Cargo.toml` and a `src/main.rs`
+which contains a placeholder "Hello world", so you can already build this
+`rust_project`
+
+```bash
+cd rust_project
+cargo build --release # using --release will build the optimized binary
+./target/release/rust_project # execute the binary
+```
+
+## Learning
+
+It's unique approach to memory management (ownership, borrowing and lifetimes) and
+the strict compiler can feel daunting at fist - especially if you are accustomed
+to high-level languages like [python](./python.md) or [javascript](./javascript.md).
+You **will** wrestle with the borrow checker and some concepts may take time to be
+internalized.
+
+> Keep in mind that in the long run all the effort pays off. The code produced
+> will have _fewer bugs_ (thanks to the opinionated compiler), you will learn
+> _transferable skills_ that will make you a better programmer in other
+> languages. The general mindset should be **start small and embrace the compiler**.
+
+To learn it, you only need:
+
+- [The Rust Book](https://rust-book.cs.brown.edu/ch00-00-introduction.html): This
+  is the official book and it is very well written and easy to follow. It contains
+  all the information you need to gain a deep understanding of Rust. It contains
+  a fully guided tutorial on how to write a Guessing game as your first project.
+- [Rust by Example](https://doc.rust-lang.org/rust-by-example/): This contains
+  smaller examples of how to use the language, and it is a good complement to
+  the book or when you need to quickly look up how to do something.
+- [Rustlings](https://rustlings.cool): Fully interactive exercises
+  that will help you get used to the syntax and the concepts of the language -
+  it is paired with the book, so you should be doing the exercises as you go
+  through the book.
path: language_guides/rust.md
user: login: stijnh
body: We could add: [Rust Playground](https://play.rust-lang.org/): Let's you experiment with Rust online in your browser.
created_at: 2025-04-22T12:50:36Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,125 @@
+# Rust
+
+_Page maintainer: [Rodrigo V. Honorato](https://github.com/rvhonorato)_
+
+Rust is a modern, programming language designed to provide both high
+performance and robust memory safety. Developed by Mozilla and first released in
+2015, Rust has rapidly gained popularity for its ability to prevent common
+programming errors at compile time. It is commonly categorized as a systems
+programming language but over the last few years it's ecosystem has grown
+considerably and Rust is being adopted as a general programming language.
+
+It is however a **low-level** language, which gives you direct control over
+hardware and memory (like [C/C++](./ccpp.md)). For comparison, [Python](./python.md)
+is a **high-level** language that prioritizes readability by abstracting these
+details - in Python you don't ever need to think about cleaning variables from memory,
+but in a **low-level** language you need to manage it yourself. Because Rust
+runs "closer to the metal", it achieves blazing-fast performance - similar to [C/C++](./ccpp.md).
+
+Here are some of Rust's key characteristics:
+
+- **Type Safety**: Strict compile-time checks ensure variables, data types,
+  and operations are error-free, so there will be no surprises at runtime.
+
+- **Zero-Cost Abstractions**: High-level syntax (e.g., iterators, traits) compiles
+  to machine code as efficiently as hand-written low-level code.
+
+- **Fearless Concurrency**: Built-in rules prevent data races, letting you
+  write safe, parallel code without runtime crashes.
+
+- **Expressive Enums & Pattern Matching**: Enums can hold data, and match
+  ensures all cases are handled—no forgotten edge cases.
+
+- **Traits for Polymorphism**: Define shared behavior across types without
+  runtime overhead.
+
+- **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
+  (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
+  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
+
+- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
+  time, eliminating crashes from null pointers, dangling references, or leaks.
+
+```rust
+// Ownership in action: the compiler tracks who "owns" data.
+fn main() {
+    // Lets declare a string, here `s` owns it
+    let s = String::from("hello");
+
+    // Borrow `s` as a read-only reference (no ownership transference)
+    let len = calculate_length(&s);
+
+    // `s` still owns the data and we can use it
+    println!("'{}' has length {}", s, len);
+}
+
+fn calculate_length(s: &String) -> usize {
path: language_guides/rust.md
user: login: rvhonorato
body: that was my idea, but maybe better indeed to have the proper signature
created_at: 2025-04-22T14:05:15Z
author_association: CONTRIBUTOR
diff_hunk: @@ -35,10 +48,7 @@ Here are some of Rust's key characteristics:
 
 - **Rich Ecosystem**: Tools like [Cargo](https://doc.rust-lang.org/cargo/)
   (package manager), [Clippy](https://doc.rust-lang.org/stable/clippy/usage.html)
-  (linting), and [crates.io](https://crates.io) (libraries) streamline development.
-
-- **Memory Safety**: Rust's unique ownership system guarantees memory safety at compile
-  time, eliminating crashes from null pointers, dangling references, or leaks.
+  (linting), [crates.io](https://crates.io) (libraries) streamline development and [rustdoc](https://doc.rust-lang.org/stable/rustdoc/) (documentation).
path: language_guides/rust.md
user: login: egpbos
body: ```suggestion
  (linting), [crates.io](https://crates.io) (libraries) and [rustdoc](https://doc.rust-lang.org/stable/rustdoc/) (documentation) streamline development.
```
created_at: 2025-04-23T08:24:23Z
author_association: COLLABORATOR
diff_hunk: @@ -100,17 +103,16 @@ cargo build --release # using --release will build the optimized binary
 It's unique approach to memory management (ownership, borrowing and lifetimes) and
path: language_guides/rust.md
user: login: egpbos
body: ```suggestion
Its unique approach to memory management (ownership, borrowing and lifetimes) and
```
created_at: 2025-04-23T08:25:09Z
author_association: COLLABORATOR
diff_hunk: @@ -121,5 +123,6 @@ To learn it, you only need:
   that will help you get used to the syntax and the concepts of the language -
   it is paired with the book, so you should be doing the exercises as you go
   through the book.
+- [Rust Playground](https://play.rust-lang.org/): Let's you experiment with Rust online in your browser
path: language_guides/rust.md
user: login: egpbos
body: ```suggestion
- [Rust Playground](https://play.rust-lang.org/): Lets you experiment with Rust online in your browser
```
created_at: 2025-04-23T08:25:56Z
author_association: COLLABORATOR

PR comments:
user: login: netlify[bot]
created_at: 2025-04-17T14:51:41Z
body: ### <span aria-hidden="true">✅</span> Deploy Preview for *nlesc-guide-testing* ready!


|  Name | Link |
|:-:|------------------------|
|<span aria-hidden="true">🔨</span> Latest commit | 8ec13169f0919ed9e426a821bf8e227a93c4d538 |
|<span aria-hidden="true">🔍</span> Latest deploy log | https://app.netlify.com/sites/nlesc-guide-testing/deploys/680a2f02e881450008b97f25 |
|<span aria-hidden="true">😎</span> Deploy Preview | [https://deploy-preview-436--nlesc-guide-testing.netlify.app](https://deploy-preview-436--nlesc-guide-testing.netlify.app) |
|<span aria-hidden="true">📱</span> Preview on mobile | <details><summary> Toggle QR Code... </summary><br /><br />![QR Code](https://app.netlify.com/qr-code/eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1cmwiOiJodHRwczovL2RlcGxveS1wcmV2aWV3LTQzNi0tbmxlc2MtZ3VpZGUtdGVzdGluZy5uZXRsaWZ5LmFwcCJ9._vxE6g7FZfEnBFDoIUOMYxEz-cNBI71Y8G1Aqb-PEPM)<br /><br />_Use your smartphone camera to open QR code link._</details> |
---
<!-- [nlesc-guide-testing Preview](https://deploy-preview-436--nlesc-guide-testing.netlify.app) -->
_To edit notification comments on pull requests, go to your [Netlify site configuration](https://app.netlify.com/sites/nlesc-guide-testing/configuration/notifications#deploy-webhooks)._
author_association: NONE
user: login: egpbos
created_at: 2025-04-22T10:58:07Z
body: I really like this content so far!

It's a bit opinionated and rather explicit, but in this case I think that may be warranted for now. For example, the "key characteristics" list could probably also be left out (it's probably out there somewhere on the web where we can link to), same for the "Getting started" section which is very explicit (the commands can probably be found on the rustup page for instance and then we don't have to maintain it...). However, since Rust is still pretty new to many people, it may be good to keep this in for now.

The paragraph "Rust is increasingly adopted in research software..." I would move to the top (make it the second paragraph), because this is of course of critical importance for this particular Guide :)

There's a few typos (it's instead of its), but other than that this looks very good to me :)

It would be good if someone with a bit more Rust background could have a peek, @stijnh maybe?
author_association: COLLABORATOR
user: login: rvhonorato
created_at: 2025-04-22T14:16:29Z
body: Thanks for the feedback @egpbos! 

Indeed this "key characteristics" is the first thing that comes up when you search anything about rust. My idea here was to have a quick "at a glance" overview of the feature for people that are curious, but if its too basic (or redundant) it can also be removed - same with the "Getting started" section.

I shifted things around also following the feedback from @stijnh, thanks! Lot's of valid comments that I have incorporated into the text.


author_association: CONTRIBUTOR
user: login: rvhonorato
created_at: 2025-04-22T14:18:59Z
body: As for more content; having some links to research software written in rust and a section about pyo3 would be great additions. Would you rather merge this PR here as a first iteration and then add these content in subsequent PRs?
author_association: CONTRIBUTOR
user: login: stijnh
created_at: 2025-04-23T09:00:40Z
body: > As for more content; having some links to research software written in rust and a section about pyo3 would be great additions. Would you rather merge this PR here as a first iteration and then add these content in subsequent PRs?

Sounds like a good plan to me! More stuff can always be added in later revisions of the page.
author_association: MEMBER
user: login: egpbos
created_at: 2025-04-24T07:08:03Z
body: @rvhonorato If you could fix the three small typos I indicated above, we can merge this :) If you don't have time right now, I can also do it for you, let me know.
author_association: COLLABORATOR
user: login: rvhonorato
created_at: 2025-04-24T12:32:13Z
body: done! thanks for your time to have a look at this. When I have some more time I'll make another PR adding more content 🦀
author_association: CONTRIBUTOR
user: login: egpbos
created_at: 2025-04-24T15:14:55Z
body: Looking forward to your next PRs!
author_association: COLLABORATOR