From c14aa1772185ed3f210219a262b867a2fabb86cf Mon Sep 17 00:00:00 2001 From: Vedansh Date: Tue, 24 Jun 2025 05:15:23 +0530 Subject: [PATCH] refactor(rust): cleanup roadmap content (#8813) * audit first 55 topics * audit next 38 topics * audit last 32 topics --- .../content/actix@3Y90v2ysoMcyjDL24H7mC.md | 4 ++- .../rust/content/arc@yYmV5qkldu0FkDhOhWOXs.md | 3 +- .../content/array@2DbdHCjFzGHwCUETakaGh.md | 2 +- .../async-std@_2uQInXPdOY-DpYTO1Prt.md | 3 +- ...onous-programming@yu0f5gALho0e8wzV10yow.md | 9 ++++- ...--memory-barriers@n1Epl_nBuoXW2OE0IKYVR.md | 5 +-- .../content/axum@duQ1RO1lqq793mfb5w31P.md | 3 +- .../content/bevy@uyrGki0jB7DXQ0HJe2-vY.md | 8 ++++- .../binary-heap@jdndHBzmdgI6uYql6bO4W.md | 2 ++ .../content/boolean@bjwJCGMx5ZfrH7vz3eLS7.md | 4 +-- ...rences-and-slices@-onH5vPffdcZFjjVcnEpk.md | 5 +-- .../content/btreemap@LWgaZWTJVWLDes3HzflRh.md | 2 +- .../content/btreeset@FsyLYRQP_rs4qL7IAj9Mo.md | 2 +- .../content/channels@3nXJg5Y4SUug_dEAj0eQm.md | 3 +- .../content/clap@AId80IokM7NvGBVutmuGC.md | 7 +++- .../cli-utilities@2Zyyf9q_CxmOW-z2pipL.md | 9 ++++- .../cli-utilities@2Zyyf9q_CxmOW-z2pipL8.md | 9 ++++- ...tion--namespacing@c_SdccEXEJyh4ymWzvCeX.md | 4 +-- ...ency--parallelism@pehYc_xLrs6BFUbcpPTiJ.md | 8 ++++- ...ow-and-constructs@u2wlnmE1uLaTqWw35UF0a.md | 3 +- ...variant-lifetimes@7yVvMnvCvLbFa51pESx0j.md | 7 +++- .../criterionrs@clQ26LFV_9AdQ4evnaxUK.md | 8 ++++- .../cryptography@Rv_Z-rbtELPZ1Nv0PZQmV.md | 7 +++- ...-types-and-traits@LwqOxYY9E9MUDgz2M40uV.md | 2 +- .../database-and-orm@_n7emeqzf5UTxVB5-385G.md | 7 +++- .../debugging@7YKWYxogJq6X35IAUwcZF.md | 9 ++++- ...-with-macro_rules@AXWXXsww7Xkl3BYgtThNe.md | 4 +-- ...ive-stack-vs-heap@UdXq0H8599cDTKXaIlPqt.md | 4 ++- ...gement-with-cargo@PkePVzV-b1pgFJP5xID5_.md | 4 +-- .../content/diesel@UAXpBK3lfnq0Q4RcBehZ1.md | 4 +-- ...ting-with-rustdoc@65nbahPj9qAb9y8dF8Jnd.md | 9 ++++- ...ic-languages-dsls@Kb7KF7JCMaWFz-GuaQmQV.md | 5 +-- ...edded-and-systems@RKXljexmLAceMYwg4D_uP.md | 8 ++++- .../embedded-hal@LzaO2cpDajXERqEYDjMl_.md | 7 +++- .../content/enums@FswpjWqqt8-BzUTsDDjel.md | 9 +++-- .../error-handling@X2gB0m-ZKSC4TJyIcwsMx.md | 7 +++- ...etime-annotations@R5HIVS-lyCp9b46aXqx2m.md | 7 +++- .../content/floats@rNHHp1GgmRnKIYlZayi59.md | 6 ++-- ...and-method-syntax@5hKJaMKpeFEUi3S1Hpiyk.md | 9 +++-- ...yncawait-paradigm@kVfBbsOHoixvqb4dYTG3Q.md | 5 +++ .../content/fyrox@x9bmK_cLYpX0ebwjZUn4R.md | 10 ++++-- .../game-development@uG-EmZVZ-jc3mswOT4-7l.md | 8 ++++- ...level-programming@_hxwo_iAdOwlWBltv7i6i.md | 5 +-- .../content/ggez@qquYnrrzUlyd8738jzj1D.md | 7 +++- .../content/gtk-rs@2Zp3m3Y7j6R1hK3DIVdkH.md | 7 +++- .../gui-development@T1LlJz5m5wnwBvKAEuGnP.md | 8 ++++- .../content/hashmap@JAgjrf5WDXiorZ6gFRzTc.md | 2 +- .../content/hashset@b1iYy4Hvkj47Q13V2HE4i.md | 4 +-- .../content/hyper@-MiN5ytI43EjgmWV55BhU.md | 5 +-- ...d-rust-toolchains@oyP1ZyOgDC4nYEQXHwdVQ.md | 11 +++++- .../impl-blocks@HzWHDQZjA9OgVZEWrmhKf.md | 4 ++- ...ng-rust-and-cargo@-IqA02ObYvXPW1ot6t_b9.md | 8 +++-- .../content/integers@FHZSxSiOZYNBEz6tu8wuF.md | 35 ++----------------- .../introduction@4U-HZQGH7kaWCB94Xy8Mh.md | 4 ++- .../json-rust@ZXMKY0f7mqqlsvyH9u-LM.md | 4 ++- .../language-basics@6E4pGifNfSAq6SbzfzFNT.md | 8 ++++- .../content/leptos@n5t3MUqmvrcr36VIIOw0u.md | 10 +++++- ...ime-elision-rules@qJI8GObmsxyc_tTtUEOAd.md | 7 +++- ...s--borrow-checker@UZ56NKloehcxUFNuSeO19.md | 2 ++ .../linkedlist@iR0ewc2yURqS7bfMWfoBi.md | 6 ++-- .../content/loco@GnSBtZoN9mAehRf5Eczng.md | 10 +++++- .../macroquad@EtKhe3lgK3NoiBOjXRb2O.md | 8 ++++- ...--metaprogramming@eTpZXd8E2jVBmk_aSLZYV.md | 9 ++++- ...rty-based-testing@HEqfA6An6ZeT3z4R610en.md | 3 +- .../modules--crates@Zpowr_NGd-E2DC3g-oW9h.md | 4 ++- .../content/mutex@GbbeV3r27IBEKHyiyLqs6.md | 6 ++-- .../networking@3pL0ARqk8uRNimopHSalW.md | 10 +++++- .../content/nrf-hal@ETYrk0s5Wn80XyntNG_t1.md | 8 ++++- ...sult-enumerations@wQHkBydWsiGEOZMdKmz40.md | 4 +-- ...es--memory-safety@2UQ3AuGkDbT0-54l0rOGM.md | 4 ++- ...ng--destructuring@yqp3UePmSlGyOYpxITis4.md | 8 +++-- ...nce-and-profiling@WduD9VIcYSs_JTnuMNyxk.md | 8 ++++- ...os--custom-derive@bkVM1OIbv4XUpY6FQb8x_.md | 3 +- ...ors-and--operator@pTC1ucmErVnMbNFnYLJK7.md | 3 +- ...shing-on-cratesio@Op0-bdMV3kE9Be6Ot1aC6.md | 3 +- .../content/queue@fq2NMV-QV9ayJl82ZWzov.md | 4 ++- .../content/quinn@qi1pmsY8bPk8nbHiBIGha.md | 4 ++- .../rust/content/rc@U9Bd-GO0QwYVLvESR4PTb.md | 5 +-- .../content/relm@QbdGnUoTLgMHO1NCQINIi.md | 10 ++++-- .../content/reqwest@TtajUXZpyNx9AmdUawm-8.md | 4 ++- .../content/ring@w8nxQDxmfoUHkFV66TKiq.md | 4 +-- .../content/rocket@ApjwY_70OGG_dNIC85oBD.md | 3 +- .../content/rppal@L01rVq2_H4rWzlKygW5kA.md | 8 ++++- .../content/rusqlite@a2MLN7f-FvsgdmvP9ixlv.md | 5 +-- .../rust-crypto@f68x7r-qzaQfrzXnjOI2q.md | 8 ++++- .../content/rust-gdb@UkHXsAolmbk-MsJFfqObC.md | 7 +++- .../rust-lldb@p1w1iljGABgHoJjIRJYLY.md | 6 ++++ ...l-rust-playground@eYCNYtwXBjZwcPUe7QYZ-.md | 7 ++++ .../content/rwlock@WzGl4DkANjUu7VC1AIWI-.md | 5 +-- .../content/serde@EHErECEYws05oi59OsZpC.md | 5 +-- ...--deserialization@gcmKSLWfBqx4aPZOmyQsg.md | 8 ++++- .../content/smol@3C9gCBAq3OQVb583S72D4.md | 4 ++- .../sodiumoxide@hzzRFb5cyXkgUdLZxaozB.md | 7 +++- .../content/sqlx@r2KembNZ2WIzLe87EB91K.md | 5 +-- .../content/stack@B-S1hE-ofNTutnkc2hJBf.md | 4 ++- .../content/string@Hu1jf46OpX44nam_UvYqc.md | 8 ++--- .../structopt@_43912wPdXgLL8v-IMHX_.md | 9 +++-- .../content/structs@Mi9mQ-8gyDPd8Mbu1zuHt.md | 11 ++---- .../content/tauri@Q71MnFDQBkZF1c2hj13pU.md | 8 +++-- .../content/termion@YS0igALDqSanGDWva_vls.md | 10 ++++-- .../content/testing@08qKtgnhJ3tlb5JKfTDf5.md | 5 +-- ...d-message-passing@pJN260pWQVO0gHxi1-_3U.md | 5 ++- .../content/tokio@H0mctp3Bj2OYfIGFDWGfz.md | 4 +-- ....md => toml-rust@LmFog_qXrS9e5ARhV6OD_.md} | 3 +- ...-associated-types@pRDgDtRIVpNM2CdhSOS3Q.md | 7 +++- ...--implementations@_EicstELZcdesHiXFWJGu.md | 3 +- .../traits--generics@zLKbYX0nnbfD5n3P_JRaS.md | 2 +- .../content/traits@SJMuIEuHp8X6nfLb0k0TU.md | 5 ++- .../content/tuple@81_J7CwtUUjYPvKV_prg3.md | 2 +- ...tegration-testing@w9coeW9-crDxu0KC-9gEU.md | 6 ++-- ...pes-and-constants@Gw5E21W5zis-RUIgNSEV2.md | 7 ++-- .../content/vector@PskCueCc9pSxfnSzfdX-u.md | 8 ++--- .../wasm-bindgen@SUtBBqqDeR_yAkr669ZvE.md | 8 ++++- .../wasm-pack@TSlj7mMUB5CDTy8uMFzKV.md | 9 ++++- .../content/wasmer@iyFHvZj_ntr_dX6WlL4E1.md | 12 +++++-- .../web-development@KomYBYxj0FTrJDYB3nU5B.md | 6 ++++ .../webassembly-wasm@fusu4ZHH4-cjoouLr4F9U.md | 10 +++++- .../content/wgpu-rs@6wGShK9WEnXiby_Jm8sTO.md | 6 ++++ .../what-is-rust@cMfsRtvzvDZZJ0TqeUOxm.md | 4 ++- .../why-use-rust@VhSEH_RoWFt1z2lial7xZ.md | 5 +++ src/data/roadmaps/rust/rust.md | 6 ++-- 121 files changed, 544 insertions(+), 207 deletions(-) rename src/data/roadmaps/rust/content/{quinn@LmFog_qXrS9e5ARhV6OD_.md => toml-rust@LmFog_qXrS9e5ARhV6OD_.md} (75%) diff --git a/src/data/roadmaps/rust/content/actix@3Y90v2ysoMcyjDL24H7mC.md b/src/data/roadmaps/rust/content/actix@3Y90v2ysoMcyjDL24H7mC.md index 18b5193d7..f66d1091e 100644 --- a/src/data/roadmaps/rust/content/actix@3Y90v2ysoMcyjDL24H7mC.md +++ b/src/data/roadmaps/rust/content/actix@3Y90v2ysoMcyjDL24H7mC.md @@ -4,4 +4,6 @@ Actix is a high-performance, pragmatic web framework for Rust built on the actor Visit the following resources to learn more: -- [@official@Actix](https://actix.rs/) +- [@official@Actix - Actor framework for Rust](https://actix.rs/) +- [@official@Actix Documentation](https://docs.rs/actix/latest/actix/) +- [@article@Building a Clean API in Rust with Actix Web](https://medium.com/@anto18671/building-a-clean-api-in-rust-with-actix-web-a-comprehensive-guide-d084e368a988) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/arc@yYmV5qkldu0FkDhOhWOXs.md b/src/data/roadmaps/rust/content/arc@yYmV5qkldu0FkDhOhWOXs.md index 5c23e180c..74f9bd7a0 100644 --- a/src/data/roadmaps/rust/content/arc@yYmV5qkldu0FkDhOhWOXs.md +++ b/src/data/roadmaps/rust/content/arc@yYmV5qkldu0FkDhOhWOXs.md @@ -4,4 +4,5 @@ Learn more from the following links: -- [@article@Arc](https://doc.rust-lang.org/rust-by-example/std/arc.html) \ No newline at end of file +- [@official@Arc in std::sync](https://doc.rust-lang.org/std/sync/struct.Arc.html) +- [@official@Arc in Rust Lang](https://doc.rust-lang.org/rust-by-example/std/arc.html) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/array@2DbdHCjFzGHwCUETakaGh.md b/src/data/roadmaps/rust/content/array@2DbdHCjFzGHwCUETakaGh.md index be67b7062..c69764945 100644 --- a/src/data/roadmaps/rust/content/array@2DbdHCjFzGHwCUETakaGh.md +++ b/src/data/roadmaps/rust/content/array@2DbdHCjFzGHwCUETakaGh.md @@ -4,7 +4,7 @@ Arrays are fixed-size collections of elements of the same type stored consecutiv Learn more from the following links: -- [@official@Rust - array](https://doc.rust-lang.org/std/primitive.array.html) +- [@official@Array](https://doc.rust-lang.org/std/primitive.array.html) - [@article@The Array Type](https://rust-book.cs.brown.edu/ch03-02-data-types.html#the-array-type) - [@article@Rust Array (With Examples)](https://www.programiz.com/rust/array) - [@video@Rust Tutorial - Arrays](https://www.youtube.com/watch?v=t047Hseyj_k&t=767s) diff --git a/src/data/roadmaps/rust/content/async-std@_2uQInXPdOY-DpYTO1Prt.md b/src/data/roadmaps/rust/content/async-std@_2uQInXPdOY-DpYTO1Prt.md index 9eeeeda75..6db2d1c08 100644 --- a/src/data/roadmaps/rust/content/async-std@_2uQInXPdOY-DpYTO1Prt.md +++ b/src/data/roadmaps/rust/content/async-std@_2uQInXPdOY-DpYTO1Prt.md @@ -4,4 +4,5 @@ Visit the following resources to learn more: -- [@article@Docs.rs: async-std](https://docs.rs/async-std/latest/async_std/) +- [@official@async-std](https://docs.rs/async-std/latest/async_std/) +- [@article@Rust Async Programming: Tokio & Async-std](https://medium.com/@AlexanderObregon/async-programming-in-rust-exploring-tokio-and-async-std-97d4b524cef0) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/asynchronous-programming@yu0f5gALho0e8wzV10yow.md b/src/data/roadmaps/rust/content/asynchronous-programming@yu0f5gALho0e8wzV10yow.md index b643f3704..ca6903c71 100644 --- a/src/data/roadmaps/rust/content/asynchronous-programming@yu0f5gALho0e8wzV10yow.md +++ b/src/data/roadmaps/rust/content/asynchronous-programming@yu0f5gALho0e8wzV10yow.md @@ -1,3 +1,10 @@ # Asynchronous Programming -Async programming in Rust allows executing tasks concurrently rather than sequentially, enabling efficient resource usage especially in IO-heavy applications. Rust provides `async` and `await` keywords: `async` marks functions that can return `Future` values, while `await` pauses and resumes async functions. Popular async runtimes like Tokio and async-std manage task execution efficiently. \ No newline at end of file +Async programming in Rust allows executing tasks concurrently rather than sequentially, enabling efficient resource usage especially in IO-heavy applications. Rust provides `async` and `await` keywords: `async` marks functions that can return `Future` values, while `await` pauses and resumes async functions. Popular async runtimes like Tokio and async-std manage task execution efficiently. + +Visit the following resources to learn more: + +- [@official@Fundamentals of Asynchronous Programming](https://doc.rust-lang.org/book/ch17-00-async-await.html) +- [@official@async-std](https://docs.rs/async-std/latest/async_std/) +- [@article@Demystifying Async Programming in Rust](https://medium.com/@trek007/demystifying-async-programming-in-rust-a-complete-guide-with-real-world-examples-147079950f8b) +- [@article@Rust Async Programming: Tokio & Async-std](https://medium.com/@AlexanderObregon/async-programming-in-rust-exploring-tokio-and-async-std-97d4b524cef0) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/atomic-operations--memory-barriers@n1Epl_nBuoXW2OE0IKYVR.md b/src/data/roadmaps/rust/content/atomic-operations--memory-barriers@n1Epl_nBuoXW2OE0IKYVR.md index d739e37ef..0eb607a0a 100644 --- a/src/data/roadmaps/rust/content/atomic-operations--memory-barriers@n1Epl_nBuoXW2OE0IKYVR.md +++ b/src/data/roadmaps/rust/content/atomic-operations--memory-barriers@n1Epl_nBuoXW2OE0IKYVR.md @@ -2,6 +2,7 @@ Atomic operations provide lock-free concurrency through uninterruptible operations like `load`, `store`, `swap`, and `compare_and_swap`. These low-level primitives enable thread-safe data sharing without locks, forming the foundation for higher-level concurrent abstractions and non-blocking data structures. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Rust Atomics and Locks - Low-Level Concurrency in Practice](https://marabos.nl/atomics/) +- [@official@fence in std::sync::atomic](https://doc.rust-lang.org/std/sync/atomic/fn.fence.html) +- [@article@Atomic Operations and Memory Barriers](https://medium.com/@murataslan1/atomic-operations-and-memory-barriers-43ee6f60ead5) diff --git a/src/data/roadmaps/rust/content/axum@duQ1RO1lqq793mfb5w31P.md b/src/data/roadmaps/rust/content/axum@duQ1RO1lqq793mfb5w31P.md index 7b66f3c6a..02f650b60 100644 --- a/src/data/roadmaps/rust/content/axum@duQ1RO1lqq793mfb5w31P.md +++ b/src/data/roadmaps/rust/content/axum@duQ1RO1lqq793mfb5w31P.md @@ -4,4 +4,5 @@ Axum is a modern, ergonomic web framework built on hyper and designed for async Visit the following resources to learn more: -[@official@Axum Documentation](https://docs.rs/axum/latest/axum/) +- [@official@Axum Documentation](https://docs.rs/axum/latest/axum/) +- [@article@Getting Started with Axum - Rust's Most Popular Web Framework](https://www.shuttle.dev/blog/2023/12/06/using-axum-rust) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/bevy@uyrGki0jB7DXQ0HJe2-vY.md b/src/data/roadmaps/rust/content/bevy@uyrGki0jB7DXQ0HJe2-vY.md index 5bf392ffc..d55fb156a 100644 --- a/src/data/roadmaps/rust/content/bevy@uyrGki0jB7DXQ0HJe2-vY.md +++ b/src/data/roadmaps/rust/content/bevy@uyrGki0jB7DXQ0HJe2-vY.md @@ -1,3 +1,9 @@ # bevy -Bevy is a modern, data-driven game engine built in Rust featuring an ECS (Entity Component System) architecture. It supports both 2D and 3D games with modular design, custom shaders, and high performance. Bevy emphasizes developer ergonomics and provides comprehensive tools for game development. \ No newline at end of file +Bevy is a modern, data-driven game engine built in Rust featuring an ECS (Entity Component System) architecture. It supports both 2D and 3D games with modular design, custom shaders, and high performance. Bevy emphasizes developer ergonomics and provides comprehensive tools for game development. + +Visit the following resources to learn more: + +- [@official@Bevy Engine](https://bevy.org/) +- [@official@Bevy Documentation](https://docs.rs/bevy/latest/bevy/) +- [@opensource@bevyengine/bevy](https://github.com/bevyengine/bevy) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/binary-heap@jdndHBzmdgI6uYql6bO4W.md b/src/data/roadmaps/rust/content/binary-heap@jdndHBzmdgI6uYql6bO4W.md index bf24c9514..4b6d15cd6 100644 --- a/src/data/roadmaps/rust/content/binary-heap@jdndHBzmdgI6uYql6bO4W.md +++ b/src/data/roadmaps/rust/content/binary-heap@jdndHBzmdgI6uYql6bO4W.md @@ -5,3 +5,5 @@ Learn more from the following links: - [@official@BinaryHeap](https://doc.rust-lang.org/std/collections/struct.BinaryHeap.html) +- [@article@The Rust Guide - BinaryHeap](https://rust-guide.com/en/documentation/collections/BinaryHeap) +- [@article@Comprehensive Guide to BinaryHeap in Rust](https://www.gyata.ai/rust/binaryheap) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/boolean@bjwJCGMx5ZfrH7vz3eLS7.md b/src/data/roadmaps/rust/content/boolean@bjwJCGMx5ZfrH7vz3eLS7.md index 43a08ec4d..68bf2c829 100644 --- a/src/data/roadmaps/rust/content/boolean@bjwJCGMx5ZfrH7vz3eLS7.md +++ b/src/data/roadmaps/rust/content/boolean@bjwJCGMx5ZfrH7vz3eLS7.md @@ -4,6 +4,6 @@ Rust's `bool` primitive type represents truth values with two possible states: ` Learn more from the following links: -- [@video@Rust Tutorial - Booleans](https://www.youtube.com/watch?v=t047Hseyj_k&t=388s) +- [@official@bool](https://doc.rust-lang.org/std/primitive.bool.html) - [@article@The Boolean Type](https://rust-book.cs.brown.edu/ch03-02-data-types.html#the-boolean-type) -- [@official@bool - Rust](https://doc.rust-lang.org/std/primitive.bool.html) +- [@video@Rust Tutorial - Booleans](https://www.youtube.com/watch?v=t047Hseyj_k&t=388s) diff --git a/src/data/roadmaps/rust/content/borrowing-references-and-slices@-onH5vPffdcZFjjVcnEpk.md b/src/data/roadmaps/rust/content/borrowing-references-and-slices@-onH5vPffdcZFjjVcnEpk.md index 47c793e39..7990866ec 100644 --- a/src/data/roadmaps/rust/content/borrowing-references-and-slices@-onH5vPffdcZFjjVcnEpk.md +++ b/src/data/roadmaps/rust/content/borrowing-references-and-slices@-onH5vPffdcZFjjVcnEpk.md @@ -4,5 +4,6 @@ Borrowing allows accessing data without taking ownership. Immutable borrows (`&T Learn more from the following links: -- [@article@References and Borrowing](https://rust-book.cs.brown.edu/ch04-02-references-and-borrowing.html) -- [@article@The Slice Type](https://rust-book.cs.brown.edu/ch04-04-slices.html) \ No newline at end of file +- [@official@References and Borrowing](https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html) +- [@article@The Slice Type](https://rust-book.cs.brown.edu/ch04-04-slices.html) +- [@article@Borrowing and References in Rust](https://codeforgeek.com/borrowing-and-references-in-rust/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/btreemap@LWgaZWTJVWLDes3HzflRh.md b/src/data/roadmaps/rust/content/btreemap@LWgaZWTJVWLDes3HzflRh.md index 883a0dc71..4889d3e44 100644 --- a/src/data/roadmaps/rust/content/btreemap@LWgaZWTJVWLDes3HzflRh.md +++ b/src/data/roadmaps/rust/content/btreemap@LWgaZWTJVWLDes3HzflRh.md @@ -4,5 +4,5 @@ Learn more from the following links: -- [@article@BTreeMap](https://doc.rust-lang.org/std/collections/struct.BTreeMap.html) +- [@official@BTreeMap](https://doc.rust-lang.org/std/collections/struct.BTreeMap.html) - [@article@BTreeMap](https://cglab.ca/~abeinges/blah/rust-btree-case/) diff --git a/src/data/roadmaps/rust/content/btreeset@FsyLYRQP_rs4qL7IAj9Mo.md b/src/data/roadmaps/rust/content/btreeset@FsyLYRQP_rs4qL7IAj9Mo.md index ecf5e8807..6b3346fa0 100644 --- a/src/data/roadmaps/rust/content/btreeset@FsyLYRQP_rs4qL7IAj9Mo.md +++ b/src/data/roadmaps/rust/content/btreeset@FsyLYRQP_rs4qL7IAj9Mo.md @@ -4,4 +4,4 @@ Learn more from the following links: -- [@article@Btree Set](https://doc.rust-lang.org/std/collections/struct.BTreeSet.html) \ No newline at end of file +- [@official@Btree Set](https://doc.rust-lang.org/std/collections/struct.BTreeSet.html) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/channels@3nXJg5Y4SUug_dEAj0eQm.md b/src/data/roadmaps/rust/content/channels@3nXJg5Y4SUug_dEAj0eQm.md index f8e47ed51..fad88f492 100644 --- a/src/data/roadmaps/rust/content/channels@3nXJg5Y4SUug_dEAj0eQm.md +++ b/src/data/roadmaps/rust/content/channels@3nXJg5Y4SUug_dEAj0eQm.md @@ -4,4 +4,5 @@ Channels enable thread communication via message passing from `std::sync::mpsc` Learn more from the following links: -- [@article@Channels](https://doc.rust-lang.org/rust-by-example/std_misc/channels.html) \ No newline at end of file +- [@official@Channels](https://doc.rust-lang.org/rust-by-example/std_misc/channels.html) +- [@article@Using Channels in Rust: Why and When?](https://howtorust.com/using-channels-in-rust-why-and-when/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/clap@AId80IokM7NvGBVutmuGC.md b/src/data/roadmaps/rust/content/clap@AId80IokM7NvGBVutmuGC.md index 4e537be26..4b3cc0bbb 100644 --- a/src/data/roadmaps/rust/content/clap@AId80IokM7NvGBVutmuGC.md +++ b/src/data/roadmaps/rust/content/clap@AId80IokM7NvGBVutmuGC.md @@ -1,3 +1,8 @@ # clap -`clap` is Rust's most popular command-line argument parser library. It provides declarative CLI definition with automatic help generation, subcommands, validation, and error handling. Supports both builder pattern and derive macros for easy CLI app development with comprehensive features. \ No newline at end of file +`clap` is Rust's most popular command-line argument parser library. It provides declarative CLI definition with automatic help generation, subcommands, validation, and error handling. Supports both builder pattern and derive macros for easy CLI app development with comprehensive features. + +Learn more from the following links: + +- [@official@clap](https://docs.rs/clap/latest/clap/) +- [@article@Using Clap in Rust for command line (CLI) Argument Parsing](https://blog.logrocket.com/using-clap-rust-command-line-argument-parsing/) diff --git a/src/data/roadmaps/rust/content/cli-utilities@2Zyyf9q_CxmOW-z2pipL.md b/src/data/roadmaps/rust/content/cli-utilities@2Zyyf9q_CxmOW-z2pipL.md index d15d3e202..0bbd3a904 100644 --- a/src/data/roadmaps/rust/content/cli-utilities@2Zyyf9q_CxmOW-z2pipL.md +++ b/src/data/roadmaps/rust/content/cli-utilities@2Zyyf9q_CxmOW-z2pipL.md @@ -1,3 +1,10 @@ # CLI Utilities -Rust excels at building fast, reliable command-line tools with memory safety and performance. Popular crates include `clap` for argument parsing, `structopt` for derives, and `termion` for terminal control. Rust's tooling ecosystem makes CLI development efficient and robust. \ No newline at end of file +Rust excels at building fast, reliable command-line tools with memory safety and performance. Popular crates include `clap` for argument parsing, `structopt` for derives, and `termion` for terminal control. Rust's tooling ecosystem makes CLI development efficient and robust. + +Learn more from the following links: + +- [@official@structopt](https://docs.rs/structopt/latest/structopt/) +- [@official@clap](https://docs.rs/clap/latest/clap/) +- [@official@Command-line Apps](https://www.rust-lang.org/what/cli/) +- [@article@Rust CLI Utilities - GitHub](https://github.com/baldwin-sudo/rusty-utils) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/cli-utilities@2Zyyf9q_CxmOW-z2pipL8.md b/src/data/roadmaps/rust/content/cli-utilities@2Zyyf9q_CxmOW-z2pipL8.md index 33483b156..7a603cd58 100644 --- a/src/data/roadmaps/rust/content/cli-utilities@2Zyyf9q_CxmOW-z2pipL8.md +++ b/src/data/roadmaps/rust/content/cli-utilities@2Zyyf9q_CxmOW-z2pipL8.md @@ -1,3 +1,10 @@ # CLI Utilities -CLI utilities are command-line tools that allow users to interact with their system through text commands. Rust is excellent for building fast, reliable CLI tools due to its memory safety and performance. Popular crates like clap and structopt help parse command-line arguments, handle input validation, and generate help messages, making CLI development efficient. \ No newline at end of file +CLI utilities are command-line tools that allow users to interact with their system through text commands. Rust is excellent for building fast, reliable CLI tools due to its memory safety and performance. Popular crates like clap and structopt help parse command-line arguments, handle input validation, and generate help messages, making CLI development efficient. + +Learn more from the following links: + +- [@official@structopt](https://docs.rs/structopt/latest/structopt/) +- [@official@clap](https://docs.rs/clap/latest/clap/) +- [@official@Command-line Apps](https://www.rust-lang.org/what/cli/) +- [@article@Rust CLI Utilities - GitHub](https://github.com/baldwin-sudo/rusty-utils) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/code-organization--namespacing@c_SdccEXEJyh4ymWzvCeX.md b/src/data/roadmaps/rust/content/code-organization--namespacing@c_SdccEXEJyh4ymWzvCeX.md index b0d19fc09..c1ea62ccb 100644 --- a/src/data/roadmaps/rust/content/code-organization--namespacing@c_SdccEXEJyh4ymWzvCeX.md +++ b/src/data/roadmaps/rust/content/code-organization--namespacing@c_SdccEXEJyh4ymWzvCeX.md @@ -4,6 +4,6 @@ Rust organizes code through modules (`mod`) for grouping related functionality a Visit the following resources to learn more: -- [@article@Rust by Example: Modules](https://doc.rust-lang.org/rust-by-example/mod.html) -- [@article@The Rust Reference: Namespaces](https://doc.rust-lang.org/reference/names/namespaces.html) +- [@official@Modules](https://doc.rust-lang.org/rust-by-example/mod.html) +- [@official@Namespaces](https://doc.rust-lang.org/reference/names/namespaces.html) - [@feed@Explore top posts about General Programming](https://app.daily.dev/tags/general-programming?ref=roadmapsh) diff --git a/src/data/roadmaps/rust/content/concurrency--parallelism@pehYc_xLrs6BFUbcpPTiJ.md b/src/data/roadmaps/rust/content/concurrency--parallelism@pehYc_xLrs6BFUbcpPTiJ.md index b85f954bf..6f3918d05 100644 --- a/src/data/roadmaps/rust/content/concurrency--parallelism@pehYc_xLrs6BFUbcpPTiJ.md +++ b/src/data/roadmaps/rust/content/concurrency--parallelism@pehYc_xLrs6BFUbcpPTiJ.md @@ -1,3 +1,9 @@ # Concurrency and Parallelism -Concurrency allows tasks to run in overlapping time periods (interleaved execution), while parallelism executes multiple tasks simultaneously on different cores. Rust provides safe concurrency primitives like channels, mutexes, and atomic operations without data races, enforced at compile time. \ No newline at end of file +Concurrency allows tasks to run in overlapping time periods (interleaved execution), while parallelism executes multiple tasks simultaneously on different cores. Rust provides safe concurrency primitives like channels, mutexes, and atomic operations without data races, enforced at compile time. + +Visit the following resources to learn more: + +- [@official@Fearless Concurrency](https://doc.rust-lang.org/book/ch16-00-concurrency.html) +- [@article@Rust Concurrency and Parallelism](https://rustlang.app/article/Rust_concurrency_and_parallelism.html) +- [@article@Concurrency and Parallelism in Rust](https://sterlingcobb.medium.com/concurrency-and-parallelism-in-rust-an-overview-and-examples-bd811f5a5afe) diff --git a/src/data/roadmaps/rust/content/control-flow-and-constructs@u2wlnmE1uLaTqWw35UF0a.md b/src/data/roadmaps/rust/content/control-flow-and-constructs@u2wlnmE1uLaTqWw35UF0a.md index bf80496b9..82e7d14a5 100644 --- a/src/data/roadmaps/rust/content/control-flow-and-constructs@u2wlnmE1uLaTqWw35UF0a.md +++ b/src/data/roadmaps/rust/content/control-flow-and-constructs@u2wlnmE1uLaTqWw35UF0a.md @@ -4,5 +4,6 @@ In Rust, control flow is managed through various structures, like `if`, `else`, Learn more from the following links: -- [@article@Control Flow](https://rust-book.cs.brown.edu/ch03-05-control-flow.html) +- [@official@Control Flow](https://doc.rust-lang.org/book/ch03-05-control-flow.html) - [@article@Concise Control Flow with `if let`](https://rust-book.cs.brown.edu/ch06-03-if-let.html) +- [@article@Mastering Control Flow in Rust](https://dev.to/iamdipankarpaul/mastering-control-flow-in-rust-36fd) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/covariant--contravariant-lifetimes@7yVvMnvCvLbFa51pESx0j.md b/src/data/roadmaps/rust/content/covariant--contravariant-lifetimes@7yVvMnvCvLbFa51pESx0j.md index c897d29f6..4c6171a48 100644 --- a/src/data/roadmaps/rust/content/covariant--contravariant-lifetimes@7yVvMnvCvLbFa51pESx0j.md +++ b/src/data/roadmaps/rust/content/covariant--contravariant-lifetimes@7yVvMnvCvLbFa51pESx0j.md @@ -1,3 +1,8 @@ # Covariant and Contravariant Lifetimes -Variance describes how subtyping relationships change when types are nested. Covariant types preserve ordering (`&'long T` is subtype of `&'short T`), contravariant reverses it, invariant requires exact matches. Affects how lifetimes work with references, boxes, and function parameters. \ No newline at end of file +Variance describes how subtyping relationships change when types are nested. Covariant types preserve ordering (`&'long T` is subtype of `&'short T`), contravariant reverses it, invariant requires exact matches. Affects how lifetimes work with references, boxes, and function parameters. + +Learn more from the following links: + +- [@official@Subtyping and Variance](https://doc.rust-lang.org/nomicon/subtyping.html) +- [@article@Demystifying Covariant and Contravariant Lifetimes in Rust](https://medium.com/@murataslan1/demystifying-covariant-and-contravariant-lifetimes-in-rust-76051484fe1c) diff --git a/src/data/roadmaps/rust/content/criterionrs@clQ26LFV_9AdQ4evnaxUK.md b/src/data/roadmaps/rust/content/criterionrs@clQ26LFV_9AdQ4evnaxUK.md index e688bcd98..d39841e79 100644 --- a/src/data/roadmaps/rust/content/criterionrs@clQ26LFV_9AdQ4evnaxUK.md +++ b/src/data/roadmaps/rust/content/criterionrs@clQ26LFV_9AdQ4evnaxUK.md @@ -1,3 +1,9 @@ # Criterion.rs -`Criterion.rs` is a statistics-driven microbenchmarking library for Rust that provides reliable performance analysis over time. It offers detailed feedback, automatic outlier detection, and statistical methods to compare algorithm performance and track regressions with actionable insights. \ No newline at end of file +`Criterion.rs` is a statistics-driven microbenchmarking library for Rust that provides reliable performance analysis over time. It offers detailed feedback, automatic outlier detection, and statistical methods to compare algorithm performance and track regressions with actionable insights. + +Learn more from the following links: + +- [@official@Criterion](https://docs.rs/criterion/latest/criterion/) +- [@article@Rust Benchmarking with Criterion.rs](https://www.rustfinity.com/blog/rust-benchmarking-with-criterion) +- [@article@Benchmarking Rust Functions Using Criterion](https://www.slingacademy.com/article/benchmarking-rust-functions-using-criterion/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/cryptography@Rv_Z-rbtELPZ1Nv0PZQmV.md b/src/data/roadmaps/rust/content/cryptography@Rv_Z-rbtELPZ1Nv0PZQmV.md index 81fa88cb7..876b8a639 100644 --- a/src/data/roadmaps/rust/content/cryptography@Rv_Z-rbtELPZ1Nv0PZQmV.md +++ b/src/data/roadmaps/rust/content/cryptography@Rv_Z-rbtELPZ1Nv0PZQmV.md @@ -1,3 +1,8 @@ # Cryptography -Cryptography involves securing data through encryption (making readable data unreadable) and decryption (reversing the process). Rust offers crypto libraries like `ring`, `sodiumoxide`, and `rust-crypto` for hashing, symmetric/asymmetric encryption, and digital signatures with memory-safe implementations. \ No newline at end of file +Cryptography involves securing data through encryption (making readable data unreadable) and decryption (reversing the process). Rust offers crypto libraries like `ring`, `sodiumoxide`, and `rust-crypto` for hashing, symmetric/asymmetric encryption, and digital signatures with memory-safe implementations. + +Learn more from the following links: + +- [@official@Cryptography — list of Rust libraries/crates](https://lib.rs/cryptography) +- [@article@Awesome Rust Cryptography](https://cryptography.rs/) diff --git a/src/data/roadmaps/rust/content/custom-error-types-and-traits@LwqOxYY9E9MUDgz2M40uV.md b/src/data/roadmaps/rust/content/custom-error-types-and-traits@LwqOxYY9E9MUDgz2M40uV.md index efaa0a9fd..4fbaf8e46 100644 --- a/src/data/roadmaps/rust/content/custom-error-types-and-traits@LwqOxYY9E9MUDgz2M40uV.md +++ b/src/data/roadmaps/rust/content/custom-error-types-and-traits@LwqOxYY9E9MUDgz2M40uV.md @@ -4,4 +4,4 @@ Custom error types use `enum` to define specific error variants with attached da Visit the following resources to learn more: -- [@article@Rust by Example: Defining an error type](https://doc.rust-lang.org/rust-by-example/error/multiple_error_types/define_error_type.html) +- [@official@Defining an Error Type](https://doc.rust-lang.org/rust-by-example/error/multiple_error_types/define_error_type.html) diff --git a/src/data/roadmaps/rust/content/database-and-orm@_n7emeqzf5UTxVB5-385G.md b/src/data/roadmaps/rust/content/database-and-orm@_n7emeqzf5UTxVB5-385G.md index 6e4061633..b6e20ea62 100644 --- a/src/data/roadmaps/rust/content/database-and-orm@_n7emeqzf5UTxVB5-385G.md +++ b/src/data/roadmaps/rust/content/database-and-orm@_n7emeqzf5UTxVB5-385G.md @@ -1,3 +1,8 @@ # Database and ORM -ORMs (Object-Relational Mapping) provide abstraction layers between Rust code and SQL databases. Popular Rust ORMs include Diesel (compile-time safety), SQLx (async with compile-time query checking), and Sea-ORM. They eliminate raw SQL writing while maintaining type safety and performance. \ No newline at end of file +ORMs (Object-Relational Mapping) provide abstraction layers between Rust code and SQL databases. Popular Rust ORMs include Diesel (compile-time safety), SQLx (async with compile-time query checking), and Sea-ORM. They eliminate raw SQL writing while maintaining type safety and performance. + +Visit the following resources to learn more: + +- [@official@Diesel is a Safe, Extensible ORM and Query Builder for Rust](https://diesel.rs/) +- [@article@Choosing the Right ORM for Rust: A Comparative Analysis](https://medium.com/@wiederinchristoph/rusts-ecosystem-offers-a-variety-of-object-relational-mapping-orm-libraries-and-database-ce4690a97a61) diff --git a/src/data/roadmaps/rust/content/debugging@7YKWYxogJq6X35IAUwcZF.md b/src/data/roadmaps/rust/content/debugging@7YKWYxogJq6X35IAUwcZF.md index 8761f1736..300c4a793 100644 --- a/src/data/roadmaps/rust/content/debugging@7YKWYxogJq6X35IAUwcZF.md +++ b/src/data/roadmaps/rust/content/debugging@7YKWYxogJq6X35IAUwcZF.md @@ -1,3 +1,10 @@ # Debugging -Rust provides excellent debugging support through `rust-gdb` and `rust-lldb` debuggers, along with built-in macros like `println!`, `dbg!`, and `debug!`. The strict compiler catches many bugs at compile-time, while runtime debugging is enhanced by panic backtraces and comprehensive error messages. \ No newline at end of file +Rust provides excellent debugging support through `rust-gdb` and `rust-lldb` debuggers, along with built-in macros like `println!`, `dbg!`, and `debug!`. The strict compiler catches many bugs at compile-time, while runtime debugging is enhanced by panic backtraces and comprehensive error messages. + +Visit the following resources to learn more: + +- [@article@Debugging Rust apps with GDB](https://blog.logrocket.com/debugging-rust-apps-with-gdb/) +- [@article@Rust Debugging: Easy Guide with Practical Examples](https://boxoflearn.com/rust-debugging-guide/) +- [@article@Testing and Debugging in Rust](https://rustmeup.com/testing-and-debugging-in-rust) +- [@article@Mastering Rust Debugging: Tips & Tools](https://medium.com/@AlexanderObregon/rust-debugging-strategies-tools-and-best-practices-b18b92e0a921) diff --git a/src/data/roadmaps/rust/content/declarative-macros-with-macro_rules@AXWXXsww7Xkl3BYgtThNe.md b/src/data/roadmaps/rust/content/declarative-macros-with-macro_rules@AXWXXsww7Xkl3BYgtThNe.md index 9faf703dc..2f8dec6e4 100644 --- a/src/data/roadmaps/rust/content/declarative-macros-with-macro_rules@AXWXXsww7Xkl3BYgtThNe.md +++ b/src/data/roadmaps/rust/content/declarative-macros-with-macro_rules@AXWXXsww7Xkl3BYgtThNe.md @@ -4,5 +4,5 @@ Declarative macros use `macro_rules!` for pattern-based code generation at compi Visit the following resources to learn more: -- [@article@Rust Book: Macros](https://doc.rust-lang.org/book/ch19-06-macros.html) -- [@article@Macros by Example](https://doc.rust-lang.org/reference/macros-by-example.html) +- [@official@Macros](https://doc.rust-lang.org/book/ch20-05-macros.html) +- [@article@Macros in Rust: A Tutorial with Examples](https://blog.logrocket.com/macros-in-rust-a-tutorial-with-examples/) diff --git a/src/data/roadmaps/rust/content/deep-dive-stack-vs-heap@UdXq0H8599cDTKXaIlPqt.md b/src/data/roadmaps/rust/content/deep-dive-stack-vs-heap@UdXq0H8599cDTKXaIlPqt.md index c4ce9f2ac..f2fb586e2 100644 --- a/src/data/roadmaps/rust/content/deep-dive-stack-vs-heap@UdXq0H8599cDTKXaIlPqt.md +++ b/src/data/roadmaps/rust/content/deep-dive-stack-vs-heap@UdXq0H8599cDTKXaIlPqt.md @@ -2,6 +2,8 @@ Stack memory stores fixed-size data with automatic allocation/deallocation following LIFO order - fast but limited. Heap memory stores dynamic-size data with manual management - slower but flexible. Rust's ownership system ensures memory safety across both, with stack being default and heap accessed via smart pointers. -Learn more from the following links: +Learn more from the following resources: +- [@official@Box, Stack and Heap](https://doc.rust-lang.org/rust-by-example/std/box.html) +- [@article@Memory Management in Rust: Stack vs. Heap](https://dev.to/iamdipankarpaul/memory-management-in-rust-stack-vs-heap-3m45) - [@article@The Stack and the Heap](https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/the-stack-and-the-heap.html) diff --git a/src/data/roadmaps/rust/content/dependency-management-with-cargo@PkePVzV-b1pgFJP5xID5_.md b/src/data/roadmaps/rust/content/dependency-management-with-cargo@PkePVzV-b1pgFJP5xID5_.md index 8c4143630..08b1b462a 100644 --- a/src/data/roadmaps/rust/content/dependency-management-with-cargo@PkePVzV-b1pgFJP5xID5_.md +++ b/src/data/roadmaps/rust/content/dependency-management-with-cargo@PkePVzV-b1pgFJP5xID5_.md @@ -4,5 +4,5 @@ Cargo manages Rust projects and dependencies through `Cargo.toml` files. Depende Visit the following resources to learn more: -- [@article@Rust Blog: Cargo](https://blog.rust-lang.org/2016/05/05/cargo-pillars.html) -- [@article@Rust by Example: Dependencies](https://doc.rust-lang.org/rust-by-example/cargo/deps.html) +- [@official@Dependencies](https://doc.rust-lang.org/rust-by-example/cargo/deps.html) +- [@official@Cargo](https://blog.rust-lang.org/2016/05/05/cargo-pillars.html) diff --git a/src/data/roadmaps/rust/content/diesel@UAXpBK3lfnq0Q4RcBehZ1.md b/src/data/roadmaps/rust/content/diesel@UAXpBK3lfnq0Q4RcBehZ1.md index 97a8bf30a..7251e4086 100644 --- a/src/data/roadmaps/rust/content/diesel@UAXpBK3lfnq0Q4RcBehZ1.md +++ b/src/data/roadmaps/rust/content/diesel@UAXpBK3lfnq0Q4RcBehZ1.md @@ -6,5 +6,5 @@ Visit the following resources to learn more: - [@official@Diesel](https://diesel.rs/) - [@opensource@Repository](https://github.com/diesel-rs/diesel) -- [@article@Docs.rs: Diesel](https://docs.rs/diesel/latest/diesel/) -- [@video@YouTube](https://www.youtube.com/watch?v=tRC4EIKhMzw) +- [@offiial@Docs.rs: Diesel](https://docs.rs/diesel/latest/diesel/) +- [@video@Rust & SQL Databases (With Diesel)](https://www.youtube.com/watch?v=tRC4EIKhMzw) diff --git a/src/data/roadmaps/rust/content/documenting-with-rustdoc@65nbahPj9qAb9y8dF8Jnd.md b/src/data/roadmaps/rust/content/documenting-with-rustdoc@65nbahPj9qAb9y8dF8Jnd.md index f751283cd..ec123f051 100644 --- a/src/data/roadmaps/rust/content/documenting-with-rustdoc@65nbahPj9qAb9y8dF8Jnd.md +++ b/src/data/roadmaps/rust/content/documenting-with-rustdoc@65nbahPj9qAb9y8dF8Jnd.md @@ -1 +1,8 @@ -# Documenting with `rustdoc` \ No newline at end of file +# Documenting with rustdoc + +RustDoc is an invaluable tool within the Rust ecosystem for generating comprehensive and user-friendly documentation directly from your source code. By leveraging special documentation comments (starting with `///` for regular comments and `//!` for crate-level comments), developers can embed Markdown-formatted text, code examples, and even doctests directly alongside their functions, modules, and types. RustDoc then processes these comments to produce static HTML pages, making it easy for others (and your future self) to understand how to use your libraries and applications. This integrated approach not only promotes good documentation habits but also ensures that the documentation remains in sync with the codebase. + +Visit the following resources to learn more: + +- [@official@How to Write Documentation](https://doc.rust-lang.org/rustdoc/how-to-write-documentation.html) +- [@article@Writing Rust Documentation](https://dev.to/gritmax/writing-rust-documentation-5hn5) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/domain-specific-languages-dsls@Kb7KF7JCMaWFz-GuaQmQV.md b/src/data/roadmaps/rust/content/domain-specific-languages-dsls@Kb7KF7JCMaWFz-GuaQmQV.md index 23c6a0b3d..8cb3ed5e7 100644 --- a/src/data/roadmaps/rust/content/domain-specific-languages-dsls@Kb7KF7JCMaWFz-GuaQmQV.md +++ b/src/data/roadmaps/rust/content/domain-specific-languages-dsls@Kb7KF7JCMaWFz-GuaQmQV.md @@ -1,7 +1,8 @@ -# Domain-Specific Languages (DSLs) in Rust +# Domain-Specific Languages (DSLs) DSLs are specialized programming languages for specific domains. Rust macros enable creating DSLs by manipulating syntax trees and defining custom syntax patterns. This allows extending Rust's language capabilities for specialized applications like game development, configuration, or domain-specific tasks. Visit the following resources to learn more: -- [@article@Rust by Example: Domain Specific Languages (DSLs)](https://doc.rust-lang.org/rust-by-example/macros/dsl.html) +- [@official@Domain Specific Languages (DSLs)](https://doc.rust-lang.org/rust-by-example/macros/dsl.html) +- [@article@Crafting Expressive Tools: Domain-Specific Languages (DSLs)](https://medium.com/@murataslan1/crafting-expressive-tools-domain-specific-languages-dsls-in-rust-94394debe12b) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/embedded-and-systems@RKXljexmLAceMYwg4D_uP.md b/src/data/roadmaps/rust/content/embedded-and-systems@RKXljexmLAceMYwg4D_uP.md index 410442ff8..b07dcba40 100644 --- a/src/data/roadmaps/rust/content/embedded-and-systems@RKXljexmLAceMYwg4D_uP.md +++ b/src/data/roadmaps/rust/content/embedded-and-systems@RKXljexmLAceMYwg4D_uP.md @@ -1,3 +1,9 @@ # Embedded and Systems -Rust excels in embedded systems programming for microcontrollers and real-time applications. Its zero-cost abstractions, memory safety, and low-level control make it ideal for resource-constrained environments. Popular for IoT devices, firmware, and system-level programming without garbage collection overhead. \ No newline at end of file +Rust excels in embedded systems programming for microcontrollers and real-time applications. Its zero-cost abstractions, memory safety, and low-level control make it ideal for resource-constrained environments. Popular for IoT devices, firmware, and system-level programming without garbage collection overhead. + +Visit the following resources to learn more: + +- [@official@Embedded Devices](https://www.rust-lang.org/what/embedded) +- [@article@Rust for Embedded Systems](https://medium.com/@enravishjeni411/rust-for-embedded-systems-a-beginner-friendly-guide-e8c171cfb359) +- [@article@Rust Embedded Systems: Beginner's Guide with Example](https://boxoflearn.com/rust-embedded-systems-guide/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/embedded-hal@LzaO2cpDajXERqEYDjMl_.md b/src/data/roadmaps/rust/content/embedded-hal@LzaO2cpDajXERqEYDjMl_.md index ed2f8226e..46385a4d0 100644 --- a/src/data/roadmaps/rust/content/embedded-hal@LzaO2cpDajXERqEYDjMl_.md +++ b/src/data/roadmaps/rust/content/embedded-hal@LzaO2cpDajXERqEYDjMl_.md @@ -1,3 +1,8 @@ # embedded-hal -`embedded-hal` (Hardware Abstraction Layer) provides generic traits for creating portable embedded drivers in Rust. Enables hardware-agnostic code by abstracting digital I/O, UART, I2C, SPI, and other communication protocols into a uniform API, promoting code reuse across different hardware platforms. \ No newline at end of file +`embedded-hal` (Hardware Abstraction Layer) provides generic traits for creating portable embedded drivers in Rust. Enables hardware-agnostic code by abstracting digital I/O, UART, I2C, SPI, and other communication protocols into a uniform API, promoting code reuse across different hardware platforms. + +Visit the following resources to learn more: + +- [@official@HALs - The Embedded Rust Book](https://doc.rust-lang.org/stable/embedded-book/design-patterns/hal/index.html) +- [@opensource@A Hardware Abstraction Layer (HAL) for Embedded Systems](https://github.com/rust-embedded/embedded-hal) diff --git a/src/data/roadmaps/rust/content/enums@FswpjWqqt8-BzUTsDDjel.md b/src/data/roadmaps/rust/content/enums@FswpjWqqt8-BzUTsDDjel.md index 46dad74e6..f0dfbb8b3 100644 --- a/src/data/roadmaps/rust/content/enums@FswpjWqqt8-BzUTsDDjel.md +++ b/src/data/roadmaps/rust/content/enums@FswpjWqqt8-BzUTsDDjel.md @@ -2,10 +2,9 @@ An enum, short for enumeration, is a custom data type that allows you to define a type by enumerating (listing out one-by-one) all of its possible variants. In Rust, if something is one of a given set of possibilities (e.g., `Rock` or `Paper` or `Scissors`), it's probably appropriate to represent that data with an enum, like so: `enum RpsChoice { Rock, Paper, Scissors }`. -An instance of an `enum` can be one and only one of the enum's declared variants at any given time. Unlike enumerations in some other languages, variants in Rust are not restricted to a singular data type. When you define an `enum`, you can decide for each of its possible variants whether or not that variant will hold additional embedded data; each variant of the enum is also allowed to hold data of completely different types and amounts. You can even embed structs and other enums in a variant, making enums incredibly versatile. +An instance of an `enum` can be one and only one of the enum's declared variants at any given time. Unlike enumerations in some other languages, variants in Rust are not restricted to a singular data type. When you define an `enum`, you can decide for each of its possible variants whether or not that variant will hold additional embedded data; each variant of the enum is also allowed to hold data of completely different types and amounts. -Enums in Rust are one way to enable simple pattern matching for a value, which allows you to compare the interior structure of a value to a series of patterns using a `match` block. For example, you can execute different branches of code based on whether an `RpsChoice` value is `Rock`, `Paper`, or `Scissors` without a verbose tree of `if`/`else` blocks. You can also handle whatever data might be embedded within that instance of the enum variant, as you will do frequently with Rust's standard `Option` and `Result` enums. +Learn more from the following resources: -Learn more from the following links: - -- [@article@Defining an Enum](https://rust-book.cs.brown.edu/ch06-01-defining-an-enum.html) +- [@official@Defining an Enum](https://doc.rust-lang.org/book/ch06-01-defining-an-enum.html) +- [@article@Understanding and Implementing Enums in Rust](https://towardsdev.com/understanding-and-implementing-enums-in-rust-6eae37b6b5e3) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/error-handling@X2gB0m-ZKSC4TJyIcwsMx.md b/src/data/roadmaps/rust/content/error-handling@X2gB0m-ZKSC4TJyIcwsMx.md index daab49e6a..d9e0ffd73 100644 --- a/src/data/roadmaps/rust/content/error-handling@X2gB0m-ZKSC4TJyIcwsMx.md +++ b/src/data/roadmaps/rust/content/error-handling@X2gB0m-ZKSC4TJyIcwsMx.md @@ -1,3 +1,8 @@ # Error Handling -Rust handles errors through `Result` for operations that may fail and `Option` for values that may be absent. `Result` has `Ok(T)` for success and `Err(E)` for errors, while `Option` has `Some(T)` and `None`. Pattern matching and the `?` operator enable elegant error handling and propagation. Rust doesn't use exceptions, eliminating many common error-handling problems. \ No newline at end of file +Rust handles errors through `Result` for operations that may fail and `Option` for values that may be absent. `Result` has `Ok(T)` for success and `Err(E)` for errors, while `Option` has `Some(T)` and `None`. Pattern matching and the `?` operator enable elegant error handling and propagation. Rust doesn't use exceptions, eliminating many common error-handling problems. + +Learn more from the following resources: + +- [@official@Error Handling](https://doc.rust-lang.org/book/ch09-00-error-handling.html) +- [@article@How to Handle Errors in Rust](https://dev.to/nathan20/how-to-handle-errors-in-rust-a-comprehensive-guide-1cco) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/explicit-lifetime-annotations@R5HIVS-lyCp9b46aXqx2m.md b/src/data/roadmaps/rust/content/explicit-lifetime-annotations@R5HIVS-lyCp9b46aXqx2m.md index 456bfbfdc..d3b12b856 100644 --- a/src/data/roadmaps/rust/content/explicit-lifetime-annotations@R5HIVS-lyCp9b46aXqx2m.md +++ b/src/data/roadmaps/rust/content/explicit-lifetime-annotations@R5HIVS-lyCp9b46aXqx2m.md @@ -1,3 +1,8 @@ # Explicit Lifetime Annotations -Explicit lifetime annotations use syntax like `'a` to specify relationships between reference lifetimes in function signatures. Required when the compiler can't infer lifetimes automatically. Example: `fn longest<'a>(x: &'a str, y: &'a str) -> &'a str` ensures all references live equally long. \ No newline at end of file +Explicit lifetime annotations use syntax like `'a` to specify relationships between reference lifetimes in function signatures. Required when the compiler can't infer lifetimes automatically. Example: `fn longest<'a>(x: &'a str, y: &'a str) -> &'a str` ensures all references live equally long. + +Learn more from the following resources: + +- [@official@Explicit Annotation](https://doc.rust-lang.org/rust-by-example/scope/lifetime/explicit.html) +- [@article@What are Lifetimes in Rust? Explained with Code Examples](https://www.freecodecamp.org/news/what-are-lifetimes-in-rust-explained-with-code-examples/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/floats@rNHHp1GgmRnKIYlZayi59.md b/src/data/roadmaps/rust/content/floats@rNHHp1GgmRnKIYlZayi59.md index e32a8048d..3f8340cb4 100644 --- a/src/data/roadmaps/rust/content/floats@rNHHp1GgmRnKIYlZayi59.md +++ b/src/data/roadmaps/rust/content/floats@rNHHp1GgmRnKIYlZayi59.md @@ -9,9 +9,9 @@ Rust supports two types of floating-point numbers: `f32` and `f64`. These are 32 Both `f32` and `f64` represent negative, zero and positive floating-point values. -Learn more from the following links: +Visit the following resources to learn more: -- [@video@Rust Tutorial - Floating-Points](https://www.youtube.com/watch?v=t047Hseyj_k&t=335s) -- [@official@f32 - Rust](https://doc.rust-lang.org/std/primitive.f32.html) +- [@official@f32](https://doc.rust-lang.org/std/primitive.f32.html) - [@article@IEEE-754 Standard](https://en.wikipedia.org/wiki/IEEE_754) - [@article@Floating-Point Types](https://rust-book.cs.brown.edu/ch03-02-data-types.html#floating-point-types) +- [@video@Rust Tutorial - Floating-Points](https://www.youtube.com/watch?v=t047Hseyj_k&t=335s) diff --git a/src/data/roadmaps/rust/content/functions-and-method-syntax@5hKJaMKpeFEUi3S1Hpiyk.md b/src/data/roadmaps/rust/content/functions-and-method-syntax@5hKJaMKpeFEUi3S1Hpiyk.md index a30719ae8..faa604648 100644 --- a/src/data/roadmaps/rust/content/functions-and-method-syntax@5hKJaMKpeFEUi3S1Hpiyk.md +++ b/src/data/roadmaps/rust/content/functions-and-method-syntax@5hKJaMKpeFEUi3S1Hpiyk.md @@ -1,9 +1,8 @@ # Functions and Method Syntax -In Rust, functions are declared using the `fn` keyword. Each function can take a set of input variables with their specified types, and may return data of a specified type. The body of a function is contained within curly braces `{}`. Unlike other languages, in Rust, you don't need to end the last statement in a block with a semicolon; omitting the last semicolon of a block in this way turns the last statement into an expression, and the result of this expression becomes the implicit return value of the block. In other words, if we want to return a value, we simply write the expression we want to return. +In Rust, functions are declared using the `fn` keyword. Each function can take a set of input variables with their specified types, and may return data of a specified type. The body of a function is contained within curly braces `{}`. Unlike other languages, in Rust, you don't need to end the last statement in a block with a semicolon; omitting the last semicolon of a block in this way turns the last statement into an expression, and the result of this expression becomes the implicit return value of the block. -An example of a function that returns implicitly in Rust is `fn add(one: i32, two: i32) -> i32 { one + two }`, where `one` and `two` are parameters of type `i32`. This function returns an integer of type `i32`, which is the result of `one + two`. Rust also has an explicit `return` keyword to exit a function with a given value, like so: `fn add(one: i32, two: i32) -> i32 { return one + two; }`. Using a `return` statement versus the implicit return syntax is mostly a matter of preference. +Visit the following resources to learn more: -Learn more from the following links: - -- [@article@Functions](https://rust-book.cs.brown.edu/ch03-03-how-functions-work.html) +- [@official@Functions](https://doc.rust-lang.org/book/ch03-03-how-functions-work.html) +- [@article@Rust Functions Explained with Examples](https://boxoflearn.com/rust-functions-complete-guide/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/futures-and-asyncawait-paradigm@kVfBbsOHoixvqb4dYTG3Q.md b/src/data/roadmaps/rust/content/futures-and-asyncawait-paradigm@kVfBbsOHoixvqb4dYTG3Q.md index 456b66a8d..98eed1575 100644 --- a/src/data/roadmaps/rust/content/futures-and-asyncawait-paradigm@kVfBbsOHoixvqb4dYTG3Q.md +++ b/src/data/roadmaps/rust/content/futures-and-asyncawait-paradigm@kVfBbsOHoixvqb4dYTG3Q.md @@ -1,3 +1,8 @@ # Futures and Async/Await Paradigm Futures represent asynchronous computations that produce values or errors eventually. The `async/await` syntax provides ergonomic programming over futures, allowing asynchronous code to look synchronous. Futures are lazy and must be polled to make progress, forming the foundation of Rust's async ecosystem. + +Visit the following resources to learn more: + +- [@official@Fundamentals of Asynchronous Programming](https://doc.rust-lang.org/book/ch17-00-async-await.html) +- [@article@Async/Await in Rust: A Beginner's Guide](https://leapcell.medium.com/async-await-in-rust-a-beginners-guide-8752d2c2abbf) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/fyrox@x9bmK_cLYpX0ebwjZUn4R.md b/src/data/roadmaps/rust/content/fyrox@x9bmK_cLYpX0ebwjZUn4R.md index 153bb6ba8..673509cfb 100644 --- a/src/data/roadmaps/rust/content/fyrox@x9bmK_cLYpX0ebwjZUn4R.md +++ b/src/data/roadmaps/rust/content/fyrox@x9bmK_cLYpX0ebwjZUn4R.md @@ -1,3 +1,9 @@ -# fyrox +# Fyrox -Fyrox is a modern, highly optimized 3D game engine designed specifically for Rust. Leverages Rust's safety and concurrency for high performance and reliability. Features advanced lighting, shadowing, support for common 3D formats, and low-level hardware control for performance-critical applications. \ No newline at end of file +Fyrox is a modern, highly optimized 3D game engine designed specifically for Rust. Leverages Rust's safety and concurrency for high performance and reliability. Features advanced lighting, shadowing, support for common 3D formats, and low-level hardware control for performance-critical applications. + +Visit the following resources to learn more: + +- [@official@Fyrox - A feature-rich game engine built in Rust](https://fyrox.rs/) +- [@opensource@FyroxEngine/Fyrox: 3D and 2D game engine written in Rust](https://github.com/FyroxEngine/Fyrox) +- [@article@Game Development with Fyrox and Rust](https://bocksdincoding.com/blog/game-development-with-fyrox-and-rust-pt-1) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/game-development@uG-EmZVZ-jc3mswOT4-7l.md b/src/data/roadmaps/rust/content/game-development@uG-EmZVZ-jc3mswOT4-7l.md index faf7b5f23..916bbb447 100644 --- a/src/data/roadmaps/rust/content/game-development@uG-EmZVZ-jc3mswOT4-7l.md +++ b/src/data/roadmaps/rust/content/game-development@uG-EmZVZ-jc3mswOT4-7l.md @@ -1,3 +1,9 @@ # Game Development -Rust's performance and memory safety make it excellent for game development. Popular engines and frameworks include Bevy (ECS-based), Macroquad, ggez, and Fyrox. Rust handles both 2D and 3D games efficiently, with growing ecosystem support for graphics, audio, and physics. \ No newline at end of file +Rust's performance and memory safety make it excellent for game development. Popular engines and frameworks include Bevy (ECS-based), Macroquad, ggez, and Fyrox. Rust handles both 2D and 3D games efficiently, with growing ecosystem support for graphics, audio, and physics. + +Visit the following resources to learn more: + +- [@official@Fyrox - A feature-rich game engine built in Rust](https://fyrox.rs/) +- [@article@5 Rust Game Engines to Consider for your Next Project](https://blog.logrocket.com/5-rust-game-engines-consider-next-project/) +- [@article@Game Development with Fyrox and Rust](https://bocksdincoding.com/blog/game-development-with-fyrox-and-rust-pt-1) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/generics--type-level-programming@_hxwo_iAdOwlWBltv7i6i.md b/src/data/roadmaps/rust/content/generics--type-level-programming@_hxwo_iAdOwlWBltv7i6i.md index eb591298f..e489c021f 100644 --- a/src/data/roadmaps/rust/content/generics--type-level-programming@_hxwo_iAdOwlWBltv7i6i.md +++ b/src/data/roadmaps/rust/content/generics--type-level-programming@_hxwo_iAdOwlWBltv7i6i.md @@ -4,5 +4,6 @@ Advanced generics in Rust include `where` clauses for complex bounds, `?Sized` f Visit the following resources to learn more: -- [@article@Book: Generics](https://doc.rust-lang.org/book/ch10-01-syntax.html) -- [@article@Rust by Example: Generics](https://doc.rust-lang.org/rust-by-example/generics.html) +- [@official@Generic Types, Traits, and Lifetimes](https://doc.rust-lang.org/book/ch10-00-generics.html) +- [@official@Generics](https://doc.rust-lang.org/rust-by-example/generics.html) +- [@official@Generics Data Type](https://doc.rust-lang.org/book/ch10-01-syntax.html) diff --git a/src/data/roadmaps/rust/content/ggez@qquYnrrzUlyd8738jzj1D.md b/src/data/roadmaps/rust/content/ggez@qquYnrrzUlyd8738jzj1D.md index 6c0db2e76..6c439f6fc 100644 --- a/src/data/roadmaps/rust/content/ggez@qquYnrrzUlyd8738jzj1D.md +++ b/src/data/roadmaps/rust/content/ggez@qquYnrrzUlyd8738jzj1D.md @@ -1,3 +1,8 @@ # ggez -`ggez` is a lightweight 2D game framework for Rust inspired by Love2D. Provides facilities for graphics rendering, input handling, audio manipulation, and game timing with an easy, Rusty interface. Enables developers to focus on game logic without worrying about low-level implementation details. \ No newline at end of file +`ggez` is a lightweight 2D game framework for Rust inspired by Love2D. Provides facilities for graphics rendering, input handling, audio manipulation, and game timing with an easy, Rusty interface. Enables developers to focus on game logic without worrying about low-level implementation details. + +Visit the following resources to learn more: + +- [@official@ggez: Rust Game Thing](https://ggez.rs/) +- [@article@2D Game Renderer in Rust](https://dev.to/trish_07/2d-game-renderer-in-rust-lets-make-a-mini-rpg-a9h) diff --git a/src/data/roadmaps/rust/content/gtk-rs@2Zp3m3Y7j6R1hK3DIVdkH.md b/src/data/roadmaps/rust/content/gtk-rs@2Zp3m3Y7j6R1hK3DIVdkH.md index ba2fc291a..cd81c66b4 100644 --- a/src/data/roadmaps/rust/content/gtk-rs@2Zp3m3Y7j6R1hK3DIVdkH.md +++ b/src/data/roadmaps/rust/content/gtk-rs@2Zp3m3Y7j6R1hK3DIVdkH.md @@ -1,3 +1,8 @@ # gtk-rs -`gtk-rs` provides Rust bindings for GTK+3 and related libraries (GObject, Glib, Cairo, Pango) enabling cross-platform GUI application development. These open-source libraries offer a Rust-friendly interface for GTK components, allowing developers to create graphical applications using Rust with native GTK functionality. \ No newline at end of file +`gtk-rs` provides Rust bindings for GTK+3 and related libraries (GObject, Glib, Cairo, Pango) enabling cross-platform GUI application development. These open-source libraries offer a Rust-friendly interface for GTK components, allowing developers to create graphical applications using Rust with native GTK functionality. + +Visit the following resources to learn more: + +- [@official@Unlocking the GNOME stack for Rust](https://gtk-rs.org/) +- [@opensource@gtk-rs/gtk4-rs: Rust Bindings of GTK 4](https://github.com/gtk-rs/gtk4-rs) diff --git a/src/data/roadmaps/rust/content/gui-development@T1LlJz5m5wnwBvKAEuGnP.md b/src/data/roadmaps/rust/content/gui-development@T1LlJz5m5wnwBvKAEuGnP.md index 63839b7b9..e6983d2ef 100644 --- a/src/data/roadmaps/rust/content/gui-development@T1LlJz5m5wnwBvKAEuGnP.md +++ b/src/data/roadmaps/rust/content/gui-development@T1LlJz5m5wnwBvKAEuGnP.md @@ -1,3 +1,9 @@ # GUI Development -Rust offers several GUI frameworks for desktop applications including Tauri (web-based), Iced (inspired by Elm), Druid, GTK-rs, and Egui. These provide cross-platform support for creating native desktop applications with modern UI patterns and performance benefits of Rust. \ No newline at end of file +Rust offers several GUI frameworks for desktop applications including Tauri (web-based), Iced (inspired by Elm), Druid, GTK-rs, and Egui. These provide cross-platform support for creating native desktop applications with modern UI patterns and performance benefits of Rust. + +Visit the following resources to learn more: + +- [@article@Rust and GUI Development - Comprehensive Guide](https://rustmeup.com/rust-and-gui-development) +- [@article@The state of Rust GUI libraries](https://blog.logrocket.com/state-rust-gui-libraries/) +- [@article@Building Beautiful and Intuitive GUIs with Rust and egui](https://triophore.com/blogs/content/rust-egui-gui-development/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/hashmap@JAgjrf5WDXiorZ6gFRzTc.md b/src/data/roadmaps/rust/content/hashmap@JAgjrf5WDXiorZ6gFRzTc.md index 1a4899621..aeb440b26 100644 --- a/src/data/roadmaps/rust/content/hashmap@JAgjrf5WDXiorZ6gFRzTc.md +++ b/src/data/roadmaps/rust/content/hashmap@JAgjrf5WDXiorZ6gFRzTc.md @@ -4,7 +4,7 @@ Learn more from the following links: -- [@official@HashMap in std::collections - Rust](https://doc.rust-lang.org/std/collections/struct.HashMap.html) +- [@official@HashMap in std::collections](https://doc.rust-lang.org/std/collections/struct.HashMap.html) - [@official@Storing Keys With Associated Values In Hash Maps](https://doc.rust-lang.org/book/ch08-03-hash-maps.html?highlight=hashmap#storing-keys-with-associated-values-in-hash-maps) - [@article@Hash Table](https://en.wikipedia.org/wiki/Hash_table) - [@video@HashMaps: key-value stores in Rust](https://www.youtube.com/watch?v=BfmSYuDdg8Q) diff --git a/src/data/roadmaps/rust/content/hashset@b1iYy4Hvkj47Q13V2HE4i.md b/src/data/roadmaps/rust/content/hashset@b1iYy4Hvkj47Q13V2HE4i.md index 6886a6633..2cbbd964f 100644 --- a/src/data/roadmaps/rust/content/hashset@b1iYy4Hvkj47Q13V2HE4i.md +++ b/src/data/roadmaps/rust/content/hashset@b1iYy4Hvkj47Q13V2HE4i.md @@ -4,6 +4,6 @@ Learn more from the following links: -- [@official@HashSet in std::collections - Rust](https://doc.rust-lang.org/std/collections/struct.HashSet.html) -- [@article@Hashset](https://doc.rust-lang.org/rust-by-example/std/hash/hashset.html) +- [@official@HashSet in std::collections](https://doc.rust-lang.org/std/collections/struct.HashSet.html) +- [@official@Hashset](https://doc.rust-lang.org/rust-by-example/std/hash/hashset.html) - [@video@Rust HashSet Collection Type](https://www.youtube.com/watch?v=KYw3Lnf0nSY&t=1440s) diff --git a/src/data/roadmaps/rust/content/hyper@-MiN5ytI43EjgmWV55BhU.md b/src/data/roadmaps/rust/content/hyper@-MiN5ytI43EjgmWV55BhU.md index 286ba0029..79321f368 100644 --- a/src/data/roadmaps/rust/content/hyper@-MiN5ytI43EjgmWV55BhU.md +++ b/src/data/roadmaps/rust/content/hyper@-MiN5ytI43EjgmWV55BhU.md @@ -4,5 +4,6 @@ Hyper is a fast, safe HTTP client/server library for Rust built on Tokio for asy Visit the following resources to learn more: -- [@official@Official Website](https://hyper.rs/) -- [@article@Docs.rs: Hyper](https://docs.rs/hyper/latest/hyper/) +- [@official@Hyper.rs](https://hyper.rs/) +- [@article@Hyper Documentation](https://docs.rs/hyper/latest/hyper/) +- [@article@Creating a Basic HTTP Server in Rust using Hyper](https://medium.com/@ajay.bhatia/creating-a-basic-http-server-in-rust-using-hyper-a-step-by-step-tutorial-459b48d61151) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/ides-and-rust-toolchains@oyP1ZyOgDC4nYEQXHwdVQ.md b/src/data/roadmaps/rust/content/ides-and-rust-toolchains@oyP1ZyOgDC4nYEQXHwdVQ.md index 6cc06235b..8fb5e704a 100644 --- a/src/data/roadmaps/rust/content/ides-and-rust-toolchains@oyP1ZyOgDC4nYEQXHwdVQ.md +++ b/src/data/roadmaps/rust/content/ides-and-rust-toolchains@oyP1ZyOgDC4nYEQXHwdVQ.md @@ -1,3 +1,12 @@ # IDEs and Rust Toolchains -For the Rust Programming Language, several Integrated Development Environments (IDEs) and editors provide great support. [Visual Studio Code](https://code.visualstudio.com) is highly preferred among Rust developers due to its support for Rust via the "Rust Language Server" or "rust-analyzer" plugins. Another popular choice is [RustRover](https://www.jetbrains.com/rust/), a dedicated IDE for Rust development by JetBrains. Additionally, [Sublime Text](https://www.sublimetext.com) and [Atom](https://atom.io) with respective Rust-enhancement plugins are also used. For a more terminal-centric approach, [Vim](https://www.vim.org) and [Emacs](https://www.gnu.org/software/emacs/) are equipped with Rust modes. These IDEs and editors offer various features like auto-completion, syntax highlighting, and debugging tools which prove useful for Rust programming. +For the Rust Programming Language, several Integrated Development Environments (IDEs) and editors provide great support. Visual Studio Code is highly preferred among Rust developers due to its support for Rust via the "Rust Language Server" or "rust-analyzer" plugins. Another popular choice is RustRover, a dedicated IDE for Rust development by JetBrains. Additionally, Sublime Text and Atom with respective Rust-enhancement plugins are also used. For a more terminal-centric approach, Vim and Emacs are equipped with Rust modes. These IDEs and editors offer various features like auto-completion, syntax highlighting, and debugging tools which prove useful for Rust programming. + +Visit the following resources to learn more: + +- [@official@Visual Studio Code](https://code.visualstudio.com) +- [@official@RustRover](https://www.jetbrains.com/rust/) +- [@official@Vim](https://www.vim.org) +- [@official@Emacs](https://www.gnu.org/software/emacs/) +- [@official@Atom](https://atom.io) +- [@official@Sublime Text](https://www.sublimetext.com) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/impl-blocks@HzWHDQZjA9OgVZEWrmhKf.md b/src/data/roadmaps/rust/content/impl-blocks@HzWHDQZjA9OgVZEWrmhKf.md index 047eeb000..65ccda78d 100644 --- a/src/data/roadmaps/rust/content/impl-blocks@HzWHDQZjA9OgVZEWrmhKf.md +++ b/src/data/roadmaps/rust/content/impl-blocks@HzWHDQZjA9OgVZEWrmhKf.md @@ -4,6 +4,8 @@ Impl blocks use the `impl` keyword, and are used to **implement** behavior in th Note that `self` and `Self` have different meanings in the context of an `impl` block's functions. `self` represents the specific value in your program that's calling the method and passing itself as an argument, while `Self` is syntax sugar for the `impl` block's data type, which is commonly used in constructor methods that return a new instance of the type. -Learn more from the following links: +Visit the following resources to learn more: +- [@official@Keyword impl](https://doc.rust-lang.org/std/keyword.impl.html) - [@article@Method Syntax](https://rust-book.cs.brown.edu/ch05-03-method-syntax.html) +- [@article@Rust: Understanding Structs and impl Blocks with 10 Examples](https://medium.com/@TechSavvyScribe/rust-understanding-structs-and-impl-blocks-with-10-examples-20371f90b1ed) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/installing-rust-and-cargo@-IqA02ObYvXPW1ot6t_b9.md b/src/data/roadmaps/rust/content/installing-rust-and-cargo@-IqA02ObYvXPW1ot6t_b9.md index 415bd2118..ed03c7a92 100644 --- a/src/data/roadmaps/rust/content/installing-rust-and-cargo@-IqA02ObYvXPW1ot6t_b9.md +++ b/src/data/roadmaps/rust/content/installing-rust-and-cargo@-IqA02ObYvXPW1ot6t_b9.md @@ -1,7 +1,9 @@ # Installing Rust and Cargo -To install Rust, navigate to the official website at [https://www.rust-lang.org](https://www.rust-lang.org) and download the appropriate installation file (or run the appropriate terminal command) for your operating system. You'll be installing `rustup`, which is the preferred tool for installing, updating, and managing your core Rust tooling. For UNIX systems like Linux and MacOS, installation is as easy as running a single command in the terminal. For Windows, you'll be provided with an '.exe' installer which you need to execute. Further instructions can be found on the download page of the website. +To install Rust, navigate to the rust official website and download the appropriate installation file (or run the appropriate terminal command) for your operating system. You'll be installing `rustup`, which is the preferred tool for installing, updating, and managing your core Rust tooling. For UNIX systems like Linux and MacOS, installation is as easy as running a single command in the terminal. For Windows, you'll be provided with an '.exe' installer which you need to execute. Further instructions can be found on the download page of the website. -Keep in mind that for the compiler to create executables, you'll also need a linker on your operating system, such as 'GCC'. Otherwise, you'll encounter errors when you try to run `rustc` or `cargo`. This is one necessary thing that `rustup` doesn't install for you. Such linker components are part of the C standard library, so they may or may not be partially or fully preinstalled on your system. For example, a common error when running `rustc` for the first time in a 64-bit Linux environment is that your system is missing 32-bit support for GCC, which can be solved by installing `gcc-multilib`. +Visit the following resources to learn more: -You can update your Rust version at any time by running `rustup update` in the terminal. +- [@official@Rust Programming Language](https://www.rust-lang.org) +- [@official@Install Rust](https://www.rust-lang.org/tools/install) +- [@official@Installation - The Rust Programming Language](https://doc.rust-lang.org/book/ch01-01-installation.html) diff --git a/src/data/roadmaps/rust/content/integers@FHZSxSiOZYNBEz6tu8wuF.md b/src/data/roadmaps/rust/content/integers@FHZSxSiOZYNBEz6tu8wuF.md index 83a8de6b3..69a65e27c 100644 --- a/src/data/roadmaps/rust/content/integers@FHZSxSiOZYNBEz6tu8wuF.md +++ b/src/data/roadmaps/rust/content/integers@FHZSxSiOZYNBEz6tu8wuF.md @@ -5,38 +5,9 @@ In Rust, integers are a primitive data type that hold whole number values, both - Signed integers, denoted by "i", are those that can hold negative, zero, and positive values. - Unsigned integers, denoted by "u", only hold zero and positive values. -Each denotation is followed by a number which represents the number of bits they occupy in memory. The available integer types are: - -|Type|Minimum|Maximum| -|---|---|---| -|i8|-(2^7)|(2^7)-1| -|i16|-(2^15)|(2^15)-1| -|i32|-(2^31)|(2^31)-1| -|i64|-(2^63)|(2^63)-1| -|i128|-(2^127)|(2^127)-1) -|isize|-(2^31) or -(2^63)|(2^31)-1 or (2^63)-1| - -The unsigned integer types consist of: - -|Type|Minimum|Maximum| -|---|---|---| -|u8|0|(2^8)-1| -|u16|0|(2^16)-1| -|u32|0|(2^32)-1| -|u64|0|(2^64)-1| -|u128|0|(2^128)-1| -|usize|0|(2^32)-1 or (2^64)-1| - -In these types, the number after "i" or "u" denotes the size of the integer type in bits. - -There's also the `isize` and `usize` integer types. The sizes of these primitive are taken from the computer architecture (32/64 bits). When one of these types is declared, the compiler calculates, so to speak, how many bytes it takes to reference any location in memory. For example, on a 32-bit target, this is 4 bytes, and on a 64-bit target, this is 8 bytes. - -- [@article@Integer Data Type in Rust](https://doc.rust-lang.org/book/ch03-02-data-types.html#integer-types) +Visit the following resources to learn more: +- [@official@Integer Data Type in Rust](https://doc.rust-lang.org/book/ch03-02-data-types.html#integer-types) +- [@official@Machine-dependent Integer Types](https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types) - [@article@Rust Data Types (With Examples)](https://www.programiz.com/rust/data-types#integer-type) - -- [@article@Machine-dependent Integer Types](https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types) - -Learn more from the following links: - - [@article@Integer Types](https://rust-book.cs.brown.edu/ch03-02-data-types.html#integer-types) diff --git a/src/data/roadmaps/rust/content/introduction@4U-HZQGH7kaWCB94Xy8Mh.md b/src/data/roadmaps/rust/content/introduction@4U-HZQGH7kaWCB94Xy8Mh.md index a81e06136..12807813d 100644 --- a/src/data/roadmaps/rust/content/introduction@4U-HZQGH7kaWCB94Xy8Mh.md +++ b/src/data/roadmaps/rust/content/introduction@4U-HZQGH7kaWCB94Xy8Mh.md @@ -2,7 +2,9 @@ Rust is a modern system programming language focused on performance, safety, and concurrency. It accomplishes these goals without having a garbage collector, making it a useful language for a number of use cases other languages aren’t good at. Its syntax is similar to C++, but Rust offers better memory safety while maintaining high performance. +Visit the following resources to learn more: + +- [@official@Rust Programming Language](https://www.rust-lang.org/) - [@official@Rust by Example](https://doc.rust-lang.org/stable/rust-by-example/index.html) -- [@official@Official Website](https://www.rust-lang.org/) - [@opensource@Rust Book](https://edu.anarcho-copy.org/Programming%20Languages/Rust/rust-programming-language-steve-klabnik.pdf) - [@opensource@Rust Book Interactive](https://rust-book.cs.brown.edu/experiment-intro.html) diff --git a/src/data/roadmaps/rust/content/json-rust@ZXMKY0f7mqqlsvyH9u-LM.md b/src/data/roadmaps/rust/content/json-rust@ZXMKY0f7mqqlsvyH9u-LM.md index ec721d73e..bcfae52fd 100644 --- a/src/data/roadmaps/rust/content/json-rust@ZXMKY0f7mqqlsvyH9u-LM.md +++ b/src/data/roadmaps/rust/content/json-rust@ZXMKY0f7mqqlsvyH9u-LM.md @@ -4,5 +4,7 @@ JSON handling in Rust primarily uses `serde` and `serde_json` libraries for high Visit the following resources to learn more: +- [@official@Serde](https://serde.rs/) - [@article@Docs.rs: JSON](https://docs.rs/json/latest/json/) -- [@feed@Explore top posts about Rust](https://app.daily.dev/tags/rust?ref=roadmapsh) +- [@opensource@serde-rs/serde: Serialization framework for Rust](https://github.com/serde-rs/serde) +- [@feed@Explore top posts about Rust](https://app.daily.dev/tags/rust?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/language-basics@6E4pGifNfSAq6SbzfzFNT.md b/src/data/roadmaps/rust/content/language-basics@6E4pGifNfSAq6SbzfzFNT.md index 0c6ae75bd..5d755cda0 100644 --- a/src/data/roadmaps/rust/content/language-basics@6E4pGifNfSAq6SbzfzFNT.md +++ b/src/data/roadmaps/rust/content/language-basics@6E4pGifNfSAq6SbzfzFNT.md @@ -1,3 +1,9 @@ # Language Basics -Rust language basics cover fundamental programming concepts including syntax and semantics, variables and data types, control flow (loops and conditionals), and functions. These elements form the foundation for writing effective Rust code and understanding how to structure and reuse code segments. \ No newline at end of file +Rust language basics cover fundamental programming concepts including syntax and semantics, variables and data types, control flow (loops and conditionals), and functions. These elements form the foundation for writing effective Rust code and understanding how to structure and reuse code segments. + +Visit the following resources to learn more: + +- [@official@Introduction - Rust By Example](https://doc.rust-lang.org/stable/rust-by-example/) +- [@article@How to Learn Rust in 2025: A Complete Beginner's Guide](https://blog.jetbrains.com/rust/2024/09/20/how-to-learn-rust/) +- [@feed@Explore top posts about Rust](https://app.daily.dev/tags/rust?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/leptos@n5t3MUqmvrcr36VIIOw0u.md b/src/data/roadmaps/rust/content/leptos@n5t3MUqmvrcr36VIIOw0u.md index b18a7f8f6..12e2c7e18 100644 --- a/src/data/roadmaps/rust/content/leptos@n5t3MUqmvrcr36VIIOw0u.md +++ b/src/data/roadmaps/rust/content/leptos@n5t3MUqmvrcr36VIIOw0u.md @@ -1 +1,9 @@ -# Leptos \ No newline at end of file +# Leptos + +Leptos is a rust based web framework that lets you build reactive UIs with Rust and WebAssembly. It supports SSR and CSR, fine-grained reactivity, and a rich ecosystem of libraries and tools. Leptos lets you build web applications with client-side rendering, server-side rendering, or hydration. + +Visit the following resources to learn more: + +- [@official@Home - Leptos](https://www.leptos.dev/) +- [@official@Introduction - Leptos Documentation](https://book.leptos.dev/) +- [@opensource@leptos-rs/leptos: Build fast web applications with Rust](https://github.com/leptos-rs/leptos) diff --git a/src/data/roadmaps/rust/content/lifetime-elision-rules@qJI8GObmsxyc_tTtUEOAd.md b/src/data/roadmaps/rust/content/lifetime-elision-rules@qJI8GObmsxyc_tTtUEOAd.md index d08f4cf11..29beb6a27 100644 --- a/src/data/roadmaps/rust/content/lifetime-elision-rules@qJI8GObmsxyc_tTtUEOAd.md +++ b/src/data/roadmaps/rust/content/lifetime-elision-rules@qJI8GObmsxyc_tTtUEOAd.md @@ -1,3 +1,8 @@ # Lifetime Elision Rules -Lifetime elision allows the compiler to infer lifetimes in common patterns, reducing explicit annotations. Rules: each reference parameter gets its own lifetime, single input lifetime applies to all outputs, methods with `&self` propagate its lifetime to outputs. Simplifies code while maintaining safety. \ No newline at end of file +Lifetime elision allows the compiler to infer lifetimes in common patterns, reducing explicit annotations. Rules: each reference parameter gets its own lifetime, single input lifetime applies to all outputs, methods with `&self` propagate its lifetime to outputs. Simplifies code while maintaining safety. + +Visit the following resources to learn more: + +- [@official@Lifetime Elision](https://doc.rust-lang.org/reference/lifetime-elision.html) +- [@article@Understanding Lifetime Elision in Rust](https://masteringbackend.com/posts/understanding-lifetime-elision-in-rust) diff --git a/src/data/roadmaps/rust/content/lifetimes--borrow-checker@UZ56NKloehcxUFNuSeO19.md b/src/data/roadmaps/rust/content/lifetimes--borrow-checker@UZ56NKloehcxUFNuSeO19.md index f913379ca..7b0f21ccf 100644 --- a/src/data/roadmaps/rust/content/lifetimes--borrow-checker@UZ56NKloehcxUFNuSeO19.md +++ b/src/data/roadmaps/rust/content/lifetimes--borrow-checker@UZ56NKloehcxUFNuSeO19.md @@ -4,4 +4,6 @@ Lifetimes define how long references remain valid, preventing dangling reference Visit the following resources to learn more: +- [@official@Lifetimes](https://doc.rust-lang.org/rust-by-example/scope/lifetime.html) +- [@article@Mastering Lifetimes in Rust: Memory Safety and Borrow Checking](https://leapcell.medium.com/mastering-lifetimes-in-rust-memory-safety-and-borrow-checking-4a8c082a54ee) - [@video@Crust of Rust: Lifetime Annotations](https://youtu.be/rAl-9HwD858) diff --git a/src/data/roadmaps/rust/content/linkedlist@iR0ewc2yURqS7bfMWfoBi.md b/src/data/roadmaps/rust/content/linkedlist@iR0ewc2yURqS7bfMWfoBi.md index 1715f7cf7..79dabe525 100644 --- a/src/data/roadmaps/rust/content/linkedlist@iR0ewc2yURqS7bfMWfoBi.md +++ b/src/data/roadmaps/rust/content/linkedlist@iR0ewc2yURqS7bfMWfoBi.md @@ -2,7 +2,7 @@ `LinkedList` is a doubly-linked list where each node contains a value and pointers to both next and previous nodes. Provides O(1) insertion/removal at both ends but O(n) indexing. Generally slower than `Vec` and rarely needed; `VecDeque` is usually preferred for queue operations. -Learn more from the following links: +Visit the following resources to learn more: -- [@official@LinkedList in std::collections - Rust](https://doc.rust-lang.org/std/collections/struct.LinkedList.html) -- [@opensource@Too Many Linked Lists](https://rust-unofficial.github.io/too-many-lists/) +- [@official@LinkedList in std::collections](https://doc.rust-lang.org/std/collections/struct.LinkedList.html) +- [@article@Too Many Linked Lists](https://rust-unofficial.github.io/too-many-lists/) diff --git a/src/data/roadmaps/rust/content/loco@GnSBtZoN9mAehRf5Eczng.md b/src/data/roadmaps/rust/content/loco@GnSBtZoN9mAehRf5Eczng.md index d822deac1..87c6d80e7 100644 --- a/src/data/roadmaps/rust/content/loco@GnSBtZoN9mAehRf5Eczng.md +++ b/src/data/roadmaps/rust/content/loco@GnSBtZoN9mAehRf5Eczng.md @@ -1 +1,9 @@ -# Loco \ No newline at end of file +# Loco + +Loco is a web framework for Rust that is inspired by Ruby on Rails, designed to help developers build MVC-style applications easily. It emphasizes simplicity, rapid development, and integrates features like ORM, background jobs, and templating engines for a productive coding experience. + +Visit the following resources to learn more: + +- [@official@Loco.rs - Productivity-first Rust Fullstack Web Framework](https://loco.rs/) +- [@official@The Loco Guide - Loco.rs](https://loco.rs/docs/getting-started/guide/) +- [@article@Getting Started with Loco in Rust](https://www.shuttle.dev/blog/2023/12/28/using-loco-rust-rails) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/macroquad@EtKhe3lgK3NoiBOjXRb2O.md b/src/data/roadmaps/rust/content/macroquad@EtKhe3lgK3NoiBOjXRb2O.md index f00e62981..f9398f39c 100644 --- a/src/data/roadmaps/rust/content/macroquad@EtKhe3lgK3NoiBOjXRb2O.md +++ b/src/data/roadmaps/rust/content/macroquad@EtKhe3lgK3NoiBOjXRb2O.md @@ -1,3 +1,9 @@ # macroquad -Macroquad is a simple, cross-platform 2D game engine for Rust focusing on rapid prototyping and development. Features efficient rendering via miniquad, input handling, coroutine-based async programming, and sound support. Portable across Windows, macOS, Linux, WebAssembly, Android, and iOS. \ No newline at end of file +Macroquad is a simple, cross-platform 2D game engine for Rust focusing on rapid prototyping and development. Features efficient rendering via miniquad, input handling, coroutine-based async programming, and sound support. Portable across Windows, macOS, Linux, WebAssembly, Android, and iOS. + +Visit the following resources to learn more: + +- [@official@Macroquad](https://macroquad.rs/) +- [@official@Macroquad Documentation](https://macroquad.rs/docs/) +- [@article@Rust: Create A Clicker Game With Macroquad](https://dev.to/flavius_the_0th/rust-create-a-clicker-game-with-macroquad-1820) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/macros--metaprogramming@eTpZXd8E2jVBmk_aSLZYV.md b/src/data/roadmaps/rust/content/macros--metaprogramming@eTpZXd8E2jVBmk_aSLZYV.md index 7888abd15..fa581d5e7 100644 --- a/src/data/roadmaps/rust/content/macros--metaprogramming@eTpZXd8E2jVBmk_aSLZYV.md +++ b/src/data/roadmaps/rust/content/macros--metaprogramming@eTpZXd8E2jVBmk_aSLZYV.md @@ -1,3 +1,10 @@ # Macros and Metaprogramming -Macros are code that writes code, enabling metaprogramming in Rust. Declarative macros use `macro_rules!` for pattern-based code generation, while procedural macros provide custom derives and function-like macros. They're expanded at compile time, offering zero-cost abstractions. \ No newline at end of file +Macros are code that writes code, enabling metaprogramming in Rust. Declarative macros use `macro_rules!` for pattern-based code generation, while procedural macros provide custom derives and function-like macros. They're expanded at compile time, offering zero-cost abstractions. + +Visit the following resources to learn more: + +- [@official@Macros](https://doc.rust-lang.org/book/ch20-05-macros.html) +- [@official@macro_rules\!](https://doc.rust-lang.org/rust-by-example/macros.html) +- [@article@Macros in Rust: A Tutorial with Examples](https://blog.logrocket.com/macros-in-rust-a-tutorial-with-examples/) +- [@article@Metaprogramming Magic in Rust: The Complete Guide](https://elitedev.in/rust/metaprogramming-magic-in-rust-the-complete-guide-/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/mocking--property-based-testing@HEqfA6An6ZeT3z4R610en.md b/src/data/roadmaps/rust/content/mocking--property-based-testing@HEqfA6An6ZeT3z4R610en.md index 1a6476926..de3116920 100644 --- a/src/data/roadmaps/rust/content/mocking--property-based-testing@HEqfA6An6ZeT3z4R610en.md +++ b/src/data/roadmaps/rust/content/mocking--property-based-testing@HEqfA6An6ZeT3z4R610en.md @@ -7,4 +7,5 @@ Visit the following resources to learn more: - [@article@Docs.rs: mockito](https://docs.rs/mockito/latest/mockito/) - [@article@Docs.rs: mockall](https://docs.rs/mockall/latest/mockall/) - [@article@Docs.rs: mockall\_double](https://docs.rs/mockall_double/latest/mockall_double/) -- [@feed@Explore top posts about Testing](https://app.daily.dev/tags/testing?ref=roadmapsh) +- [@article@Mocking in Rust: Mockall and alternatives](https://blog.logrocket.com/mocking-rust-mockall-alternatives/) +- [@feed@Explore top posts about Testing](https://app.daily.dev/tags/testing?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/modules--crates@Zpowr_NGd-E2DC3g-oW9h.md b/src/data/roadmaps/rust/content/modules--crates@Zpowr_NGd-E2DC3g-oW9h.md index 52646796f..0a6f7502b 100644 --- a/src/data/roadmaps/rust/content/modules--crates@Zpowr_NGd-E2DC3g-oW9h.md +++ b/src/data/roadmaps/rust/content/modules--crates@Zpowr_NGd-E2DC3g-oW9h.md @@ -4,4 +4,6 @@ Modules provide namespacing and encapsulation within a crate, organizing code wi Visit the following resources to learn more: -- [@article@Rust Book: Managing Growing Projects with Packages, Crates, and Modules](https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-crates-and-modules.html) +- [@official@Crates](https://doc.rust-lang.org/rust-by-example/crates.html) +- [@official@Managing Growing Projects with Packages, Crates, and Modules](https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-crates-and-modules.html) +- [@article@How It Works: Rust's Module System Finally Explained](https://confidence.sh/blog/rust-module-system-explained/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/mutex@GbbeV3r27IBEKHyiyLqs6.md b/src/data/roadmaps/rust/content/mutex@GbbeV3r27IBEKHyiyLqs6.md index 51c24ed0f..03ff0edaa 100644 --- a/src/data/roadmaps/rust/content/mutex@GbbeV3r27IBEKHyiyLqs6.md +++ b/src/data/roadmaps/rust/content/mutex@GbbeV3r27IBEKHyiyLqs6.md @@ -2,6 +2,8 @@ `Mutex` (Mutual Exclusion) protects shared data from concurrent access by multiple threads. Only one thread can access the protected data at a time through `lock()`. Rust automatically unlocks mutexes when they go out of scope and handles panics to prevent deadlocks. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Mutex](https://doc.rust-lang.org/std/sync/struct.Mutex.html) \ No newline at end of file +- [@official@Mutex](https://doc.rust-lang.org/std/sync/struct.Mutex.html) +- [@article@Rust Mutex: From Basics to Advanced Techniques](https://medium.com/@TechSavvyScribe/rust-mutex-from-basics-to-advanced-techniques-56e1f1389d9b) +- [@article@Rust Concurrency Made Easy: A Guide to Arc and Mutex](https://www.ruststepbystep.com/rust-concurrency-made-easy-a-guide-to-arc-and-mutex/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/networking@3pL0ARqk8uRNimopHSalW.md b/src/data/roadmaps/rust/content/networking@3pL0ARqk8uRNimopHSalW.md index 060cdccc8..829362876 100644 --- a/src/data/roadmaps/rust/content/networking@3pL0ARqk8uRNimopHSalW.md +++ b/src/data/roadmaps/rust/content/networking@3pL0ARqk8uRNimopHSalW.md @@ -1,3 +1,11 @@ # Networking -Rust's `std::net` module provides networking primitives including `TcpStream`, `TcpListener`, `UdpSocket`, and address types. Built on BSD sockets, it offers low-level network operations for building networking applications. Higher-level crates like Tokio provide async networking capabilities. \ No newline at end of file +Rust's `std::net` module provides networking primitives including `TcpStream`, `TcpListener`, `UdpSocket`, and address types. Built on BSD sockets, it offers low-level network operations for building networking applications. Higher-level crates like Tokio provide async networking capabilities. + +Visit the following resources to learn more: + +- [@official@std\:\:net](https://doc.rust-lang.org/std/net/) +- [@official@TcpListener](https://doc.rust-lang.org/std/net/struct.TcpListener.html) +- [@official@UdpSocket](https://doc.rust-lang.org/std/net/struct.UdpSocket.html) +- [@official@TcpStream](https://doc.rust-lang.org/std/net/struct.TcpStream.html) +- [@article@Networking Fundamentals in Rust](https://medium.com/@murataslan1/networking-fundamentals-in-rust-525dcfbd5058) diff --git a/src/data/roadmaps/rust/content/nrf-hal@ETYrk0s5Wn80XyntNG_t1.md b/src/data/roadmaps/rust/content/nrf-hal@ETYrk0s5Wn80XyntNG_t1.md index 8e34b1b2f..bd62efe86 100644 --- a/src/data/roadmaps/rust/content/nrf-hal@ETYrk0s5Wn80XyntNG_t1.md +++ b/src/data/roadmaps/rust/content/nrf-hal@ETYrk0s5Wn80XyntNG_t1.md @@ -1,3 +1,9 @@ # nrf-hal -`nrf-hal` is a Rust Peripheral Access Crate for Nordic Semiconductor nRF52 and nRF91 series chips. Provides high-level, semantic interfaces for GPIO, timers, RNG, RTC, I2C/SPI, temperature sensors, and delay routines. Open-source Apache licensed library abstracting direct register access. \ No newline at end of file +`nrf-hal` is a Rust Peripheral Access Crate for Nordic Semiconductor nRF52 and nRF91 series chips. Provides high-level, semantic interfaces for GPIO, timers, RNG, RTC, I2C/SPI, temperature sensors, and delay routines. Open-source Apache licensed library abstracting direct register access. + +Visit the following resources to learn more: + +- [@official@nRF-HAL — embedded dev in Rust](https://lib.rs/crates/nrf-hal) +- [@opensource@nrf-rs/nrf-hal](https://github.com/nrf-rs/nrf-hal) +- [@article@What the HAL? The Quest for Finding a Suitable Embedded Rust HAL](https://dev.to/theembeddedrustacean/what-the-hal-the-quest-for-finding-a-suitable-embedded-rust-hal-2i02) diff --git a/src/data/roadmaps/rust/content/option-and-result-enumerations@wQHkBydWsiGEOZMdKmz40.md b/src/data/roadmaps/rust/content/option-and-result-enumerations@wQHkBydWsiGEOZMdKmz40.md index 5a0d36a39..c3a5b8db1 100644 --- a/src/data/roadmaps/rust/content/option-and-result-enumerations@wQHkBydWsiGEOZMdKmz40.md +++ b/src/data/roadmaps/rust/content/option-and-result-enumerations@wQHkBydWsiGEOZMdKmz40.md @@ -4,5 +4,5 @@ Visit the following resources to learn more: -- [@article@Rust by Example: Option & unwrap](https://doc.rust-lang.org/rust-by-example/error/option_unwrap.html) -- [@article@Rust by Example: Result](https://doc.rust-lang.org/rust-by-example/error/result.html) +- [@official@Option & unwrap](https://doc.rust-lang.org/rust-by-example/error/option_unwrap.html) +- [@official@Result](https://doc.rust-lang.org/rust-by-example/error/result.html) diff --git a/src/data/roadmaps/rust/content/ownsership-rules--memory-safety@2UQ3AuGkDbT0-54l0rOGM.md b/src/data/roadmaps/rust/content/ownsership-rules--memory-safety@2UQ3AuGkDbT0-54l0rOGM.md index d039c0e17..713d30bd8 100644 --- a/src/data/roadmaps/rust/content/ownsership-rules--memory-safety@2UQ3AuGkDbT0-54l0rOGM.md +++ b/src/data/roadmaps/rust/content/ownsership-rules--memory-safety@2UQ3AuGkDbT0-54l0rOGM.md @@ -2,6 +2,8 @@ Rust's ownership has three key rules: each value has exactly one owner, only one owner exists at a time, and values are dropped when owners go out of scope. This prevents data races, ensures memory safety without garbage collection, and eliminates common bugs like use-after-free and memory leaks. -Learn more from the following links: +Visit the following resources to learn more: +- [@official@What is Ownership?](https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html) +- [@article@Rust Ownership & Borrowing - Memory Safety Without Garbage](https://webreference.com/rust/ownership/) - [@article@What Is Ownership?](https://rust-book.cs.brown.edu/ch04-01-what-is-ownership.html) diff --git a/src/data/roadmaps/rust/content/pattern-matching--destructuring@yqp3UePmSlGyOYpxITis4.md b/src/data/roadmaps/rust/content/pattern-matching--destructuring@yqp3UePmSlGyOYpxITis4.md index 55a2d2a15..2a4cb48a0 100644 --- a/src/data/roadmaps/rust/content/pattern-matching--destructuring@yqp3UePmSlGyOYpxITis4.md +++ b/src/data/roadmaps/rust/content/pattern-matching--destructuring@yqp3UePmSlGyOYpxITis4.md @@ -2,7 +2,9 @@ In Rust, "pattern matching" is a robust tool that allows you to destructure data types and perform conditional checks in a succinct and clear way. The main structures used for pattern matching are `match` and `if let`. The `match` keyword can be used to compare a value against a series of patterns and then execute code based on which pattern matches. Patterns can be made up of literal values, variable names, wildcards, and many other things. The `if let` structure allows you to combine `if` and `let` into a less verbose way of handling values that match one specific pattern, rather than a series of patterns. It's basically a nice syntax sugar over a `match` statement. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@The match Control Flow Construct](https://rust-book.cs.brown.edu/ch06-02-match.html) -- [@article@Concise Control Flow with if let](https://rust-book.cs.brown.edu/ch06-03-if-let.html) +- [@official@Patterns and Matching](https://doc.rust-lang.org/book/ch19-00-patterns.html) +- [@official@Destructuring](https://doc.rust-lang.org/rust-by-example/flow_control/match/destructuring.html) +- [@official@Matching](https://doc.rust-lang.org/rust-by-example/flow_control/match.html) +- [@article@Control Flow with if let](https://rust-book.cs.brown.edu/ch06-03-if-let.html) diff --git a/src/data/roadmaps/rust/content/performance-and-profiling@WduD9VIcYSs_JTnuMNyxk.md b/src/data/roadmaps/rust/content/performance-and-profiling@WduD9VIcYSs_JTnuMNyxk.md index f1023becc..e3b5bc66e 100644 --- a/src/data/roadmaps/rust/content/performance-and-profiling@WduD9VIcYSs_JTnuMNyxk.md +++ b/src/data/roadmaps/rust/content/performance-and-profiling@WduD9VIcYSs_JTnuMNyxk.md @@ -1,3 +1,9 @@ # Performance and Profiling -Performance profiling in Rust identifies bottlenecks using tools like `perf`, `cargo bench`, `criterion`, and `flamegraph`. These tools collect statistical data about runtime performance, helping developers optimize code efficiently by targeting actual problem areas rather than guessing. \ No newline at end of file +Performance profiling in Rust identifies bottlenecks using tools like `perf`, `cargo bench`, `criterion`, and `flamegraph`. These tools collect statistical data about runtime performance, helping developers optimize code efficiently by targeting actual problem areas rather than guessing. + +Visit the following resources to learn more: + +- [@article@Profiling - The Rust Performance Book](https://nnethercote.github.io/perf-book/profiling.html) +- [@article@How to benchmark Rust code with Criterion](https://bencher.dev/learn/benchmarking/rust/criterion/) +- [@article@Optimizing Rust Application Performance with Profiling](https://hemaks.org/posts/optimizing-rust-application-performance-with-profiling/) diff --git a/src/data/roadmaps/rust/content/procedural-macros--custom-derive@bkVM1OIbv4XUpY6FQb8x_.md b/src/data/roadmaps/rust/content/procedural-macros--custom-derive@bkVM1OIbv4XUpY6FQb8x_.md index d6538bc81..999f1cfc1 100644 --- a/src/data/roadmaps/rust/content/procedural-macros--custom-derive@bkVM1OIbv4XUpY6FQb8x_.md +++ b/src/data/roadmaps/rust/content/procedural-macros--custom-derive@bkVM1OIbv4XUpY6FQb8x_.md @@ -4,4 +4,5 @@ Procedural macros operate on token streams at compile time, generating new code. Visit the following resources to learn more: -- [@article@Procedural Macros](https://doc.rust-lang.org/reference/procedural-macros.html) +- [@official@Procedural Macros](https://doc.rust-lang.org/reference/procedural-macros.html) +- [@article@Understanding Procedural Macros and Custom Derive](https://www.gyata.ai/rust/procedural-macros-and-custom-derive) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/propagating-errors-and--operator@pTC1ucmErVnMbNFnYLJK7.md b/src/data/roadmaps/rust/content/propagating-errors-and--operator@pTC1ucmErVnMbNFnYLJK7.md index 25e4eb2f4..2c9283191 100644 --- a/src/data/roadmaps/rust/content/propagating-errors-and--operator@pTC1ucmErVnMbNFnYLJK7.md +++ b/src/data/roadmaps/rust/content/propagating-errors-and--operator@pTC1ucmErVnMbNFnYLJK7.md @@ -4,4 +4,5 @@ The `?` operator provides concise error propagation in functions returning `Resu Visit the following resources to learn more: -- [@article@Rust Book: Recoverable Errors with Result](https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html) +- [@official@Recoverable Errors with Result](https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html) +- [@article@Understanding Result, Option, and '?' Operators in Rust](https://howtorust.com/understanding-result-option-and-operators-in-rust/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/publishing-on-cratesio@Op0-bdMV3kE9Be6Ot1aC6.md b/src/data/roadmaps/rust/content/publishing-on-cratesio@Op0-bdMV3kE9Be6Ot1aC6.md index 42bee78a2..6989400ca 100644 --- a/src/data/roadmaps/rust/content/publishing-on-cratesio@Op0-bdMV3kE9Be6Ot1aC6.md +++ b/src/data/roadmaps/rust/content/publishing-on-cratesio@Op0-bdMV3kE9Be6Ot1aC6.md @@ -4,4 +4,5 @@ Publishing Rust crates involves creating an account on crates.io, preparing prop Visit the following resources to learn more: -- [@article@The Cargo Book: Publishing on crates.io](https://doc.rust-lang.org/cargo/reference/publishing.html) +- [@official@The Cargo Book: Publishing](https://doc.rust-lang.org/cargo/reference/publishing.html) +- [@article@From Zero to Hero: Your First Rust Crate](https://medium.com/rust-programming-language/from-zero-to-hero-your-first-rust-crate-6f2c084df464) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/queue@fq2NMV-QV9ayJl82ZWzov.md b/src/data/roadmaps/rust/content/queue@fq2NMV-QV9ayJl82ZWzov.md index 7213f4c8d..f8b8d5ca8 100644 --- a/src/data/roadmaps/rust/content/queue@fq2NMV-QV9ayJl82ZWzov.md +++ b/src/data/roadmaps/rust/content/queue@fq2NMV-QV9ayJl82ZWzov.md @@ -2,6 +2,8 @@ Queue follows FIFO (First-In-First-Out) ordering where elements are added at one end and removed from the other. Rust doesn't have a built-in queue, but `VecDeque` provides queue functionality with `push_back()` for adding and `pop_front()` for removing elements efficiently. -Learn more from the following links: +Visit the following resources to learn more: +- [@official@VecDeque in std::collections](https://doc.rust-lang.org/std/collections/struct.VecDeque.html) +- [@article@Working with Queues in Rust](https://basillica.medium.com/working-with-queues-in-rust-5a5afe82da46) - [@official@Queues](https://docs.rs/queues/latest/queues/) diff --git a/src/data/roadmaps/rust/content/quinn@qi1pmsY8bPk8nbHiBIGha.md b/src/data/roadmaps/rust/content/quinn@qi1pmsY8bPk8nbHiBIGha.md index 053fbe6b6..c9b62102d 100644 --- a/src/data/roadmaps/rust/content/quinn@qi1pmsY8bPk8nbHiBIGha.md +++ b/src/data/roadmaps/rust/content/quinn@qi1pmsY8bPk8nbHiBIGha.md @@ -4,4 +4,6 @@ Visit the following resources to learn more: -- [@article@Docs.rs: quinn](https://docs.rs/quinn/latest/quinn/) +- [@opensource@quinn-rs/quinn: Async-friendly QUIC implementation in Rust](https://github.com/quinn-rs/quinn) +- [@official@Quinn — Rust Network Library](https://lib.rs/crates/quinn) +- [@article@Quinn](https://docs.rs/quinn/latest/quinn/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/rc@U9Bd-GO0QwYVLvESR4PTb.md b/src/data/roadmaps/rust/content/rc@U9Bd-GO0QwYVLvESR4PTb.md index 435179193..ad3497fcb 100644 --- a/src/data/roadmaps/rust/content/rc@U9Bd-GO0QwYVLvESR4PTb.md +++ b/src/data/roadmaps/rust/content/rc@U9Bd-GO0QwYVLvESR4PTb.md @@ -2,6 +2,7 @@ `Rc` (Reference Counting) enables multiple owners of the same heap-allocated data in single-threaded contexts. It tracks the number of references and automatically deallocates data when the count reaches zero. Use `Rc::clone()` to create additional references without deep copying data. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@rct - The Reference Counted Smart Pointer](https://doc.rust-lang.org/book/ch15-04-rc.html#rct-the-reference-counted-smart-pointer) \ No newline at end of file +- [@official@Rc\ in std::rc](https://doc.rust-lang.org/std/rc/struct.Rc.html) +- [@official@rct - The Reference Counted Smart Pointer](https://doc.rust-lang.org/book/ch15-04-rc.html#rct-the-reference-counted-smart-pointer) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/relm@QbdGnUoTLgMHO1NCQINIi.md b/src/data/roadmaps/rust/content/relm@QbdGnUoTLgMHO1NCQINIi.md index b851b5414..9a80eb892 100644 --- a/src/data/roadmaps/rust/content/relm@QbdGnUoTLgMHO1NCQINIi.md +++ b/src/data/roadmaps/rust/content/relm@QbdGnUoTLgMHO1NCQINIi.md @@ -1,3 +1,9 @@ -# relm +# Relm -`relm` is a declarative, event-driven GUI framework for Rust built on `gtk-rs` and GTK+3. Uses Model-View-Update architecture with async Futures for complex UI interactions. Features widget identification by name, seamless inter-widget communication, and leverages Rust's safe concurrency for dynamic desktop applications. \ No newline at end of file +`relm` is a declarative, event-driven GUI framework for Rust built on `gtk-rs` and GTK+3. Uses Model-View-Update architecture with async Futures for complex UI interactions. Features widget identification by name, seamless inter-widget communication, and leverages Rust's safe concurrency for dynamic desktop applications. + +Visit the following resources to learn more: + +- [@official@Relm](https://relm4.org/) +- [@official@Relm Documentation](https://relm4.org/book/stable/) +- [@article@Relm, a GUI library, based on GTK+ and futures, written in Rust](https://relm.antoyo.xyz/relm-intro/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/reqwest@TtajUXZpyNx9AmdUawm-8.md b/src/data/roadmaps/rust/content/reqwest@TtajUXZpyNx9AmdUawm-8.md index a2151ba6f..1470dc653 100644 --- a/src/data/roadmaps/rust/content/reqwest@TtajUXZpyNx9AmdUawm-8.md +++ b/src/data/roadmaps/rust/content/reqwest@TtajUXZpyNx9AmdUawm-8.md @@ -4,4 +4,6 @@ Visit the following resources to learn more: -- [@article@Docs.rs: Reqwest](https://docs.rs/reqwest/latest/reqwest/) +- [@article@Making HTTP requests in Rust with Reqwest](https://blog.logrocket.com/making-http-requests-rust-reqwest/) +- [@article@Exploring Reqwest in Rust](https://medium.com/@chetanreddyk394/exploring-reqwest-in-rust-b91c548e69af) +- [@article@Reqwest Documentation](https://docs.rs/reqwest/latest/reqwest/) diff --git a/src/data/roadmaps/rust/content/ring@w8nxQDxmfoUHkFV66TKiq.md b/src/data/roadmaps/rust/content/ring@w8nxQDxmfoUHkFV66TKiq.md index ca95b680a..c41c6d909 100644 --- a/src/data/roadmaps/rust/content/ring@w8nxQDxmfoUHkFV66TKiq.md +++ b/src/data/roadmaps/rust/content/ring@w8nxQDxmfoUHkFV66TKiq.md @@ -4,5 +4,5 @@ Visit the following resources to learn more: -- [@opensource@ring](https://github.com/briansmith/ring) -- [@article@Docs.rs: ring](https://docs.rs/ring/latest/ring/) +- [@opensource@briansmith/ring](https://github.com/briansmith/ring) +- [@article@Ring](https://docs.rs/ring/latest/ring/) diff --git a/src/data/roadmaps/rust/content/rocket@ApjwY_70OGG_dNIC85oBD.md b/src/data/roadmaps/rust/content/rocket@ApjwY_70OGG_dNIC85oBD.md index dbfa3c17b..319c2ce36 100644 --- a/src/data/roadmaps/rust/content/rocket@ApjwY_70OGG_dNIC85oBD.md +++ b/src/data/roadmaps/rust/content/rocket@ApjwY_70OGG_dNIC85oBD.md @@ -4,4 +4,5 @@ Rocket is a web framework for Rust emphasizing ease of use, expressiveness, and Visit the following resources to learn more: -- [@official@Rocket](https://rocket.rs/) +- [@official@Rocket - Simple, Fast, Type-Safe Web Framework for Rust](https://rocket.rs/) +- [@article@Getting Started with Rocket in Rust](https://www.shuttle.dev/blog/2023/12/13/using-rocket-rust) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/rppal@L01rVq2_H4rWzlKygW5kA.md b/src/data/roadmaps/rust/content/rppal@L01rVq2_H4rWzlKygW5kA.md index e8d8e9dc5..0d779ebc1 100644 --- a/src/data/roadmaps/rust/content/rppal@L01rVq2_H4rWzlKygW5kA.md +++ b/src/data/roadmaps/rust/content/rppal@L01rVq2_H4rWzlKygW5kA.md @@ -1,3 +1,9 @@ # rppal -`RPPAL` (Raspberry Pi Peripheral Access Library) provides Rust access to Raspberry Pi GPIO, I2C, PWM, SPI, and UART peripherals. Features comprehensive interrupt handling, software-based PWM, and I2C/SPI buses. Supports all Raspberry Pi models running Raspbian/Debian Stretch or newer. \ No newline at end of file +`RPPAL` (Raspberry Pi Peripheral Access Library) provides Rust access to Raspberry Pi GPIO, I2C, PWM, SPI, and UART peripherals. Features comprehensive interrupt handling, software-based PWM, and I2C/SPI buses. Supports all Raspberry Pi models running Raspbian/Debian Stretch or newer. + +Visit the following resources to learn more: + +- [@official@RPPAL Documentation](https://docs.golemparts.com/rppal/0.11.1/rppal/) +- [@opensource@golemparts/rppal](https://github.com/golemparts/rppal) +- [@article@RPPAL — Embedded dev in Rust](https://lib.rs/crates/rppal) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/rusqlite@a2MLN7f-FvsgdmvP9ixlv.md b/src/data/roadmaps/rust/content/rusqlite@a2MLN7f-FvsgdmvP9ixlv.md index 2685cca59..51b62d038 100644 --- a/src/data/roadmaps/rust/content/rusqlite@a2MLN7f-FvsgdmvP9ixlv.md +++ b/src/data/roadmaps/rust/content/rusqlite@a2MLN7f-FvsgdmvP9ixlv.md @@ -4,5 +4,6 @@ Visit the following resources to learn more: -- [@opensource@Repository](https://github.com/rusqlite/rusqlite) -- [@article@Docs.rs: rusqlite](https://docs.rs/rusqlite/latest/rusqlite/) +- [@article@Rusqlite](https://docs.rs/rusqlite/latest/rusqlite/) +- [@opensource@rusqlite/rusqlite](https://github.com/rusqlite/rusqlite) +- [@article@Rust | Sqlite Database](https://medium.com/@mikecode/rust-sqlite-database-rusqlite-162bad63fb5d) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/rust-crypto@f68x7r-qzaQfrzXnjOI2q.md b/src/data/roadmaps/rust/content/rust-crypto@f68x7r-qzaQfrzXnjOI2q.md index 9af6b59b7..d1093234e 100644 --- a/src/data/roadmaps/rust/content/rust-crypto@f68x7r-qzaQfrzXnjOI2q.md +++ b/src/data/roadmaps/rust/content/rust-crypto@f68x7r-qzaQfrzXnjOI2q.md @@ -1,3 +1,9 @@ # rust-crypto -`rust-crypto` is a collection of cryptographic algorithms implemented in pure Rust including AES, DES ciphers, SHA, MD5 hash functions, and RSA digital signatures. Known for speed and low memory usage, making it suitable for resource-constrained systems requiring cryptographic functionality. \ No newline at end of file +`rust-crypto` is a collection of cryptographic algorithms implemented in pure Rust including AES, DES ciphers, SHA, MD5 hash functions, and RSA digital signatures. Known for speed and low memory usage, making it suitable for resource-constrained systems requiring cryptographic functionality. + +Visit the following resources to learn more: + +- [@article@Awesome Rust Cryptography](https://cryptography.rs/) +- [@article@rust-crypto](https://docs.rs/rust-crypto/latest/crypto/) +- [@article@Rust | Sqlite Database](https://medium.com/@mikecode/rust-sqlite-database-rusqlite-162bad63fb5d) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/rust-gdb@UkHXsAolmbk-MsJFfqObC.md b/src/data/roadmaps/rust/content/rust-gdb@UkHXsAolmbk-MsJFfqObC.md index 2b3b6794e..695dcbdfb 100644 --- a/src/data/roadmaps/rust/content/rust-gdb@UkHXsAolmbk-MsJFfqObC.md +++ b/src/data/roadmaps/rust/content/rust-gdb@UkHXsAolmbk-MsJFfqObC.md @@ -1,3 +1,8 @@ # rust-gdb -`rust-gdb` is GDB (GNU Project debugger) enhanced for Rust debugging. It provides low-level debugging capabilities including breakpoints, execution tracing, runtime modification, and memory inspection. Designed for command-line debugging with deep system integration for comprehensive Rust application analysis. \ No newline at end of file +`rust-gdb` is GDB (GNU Project debugger) enhanced for Rust debugging. It provides low-level debugging capabilities including breakpoints, execution tracing, runtime modification, and memory inspection. Designed for command-line debugging with deep system integration for comprehensive Rust application analysis. + +Visit the following resources to learn more: + +- [@official@Use rust-gdb and rust-lldb for Improved Debugging](https://users.rust-lang.org/t/use-rust-gdb-and-rust-lldb-for-improved-debugging-you-already-have-them/756) +- [@article@Debugging Rust apps with GDB](https://blog.logrocket.com/debugging-rust-apps-with-gdb/) diff --git a/src/data/roadmaps/rust/content/rust-lldb@p1w1iljGABgHoJjIRJYLY.md b/src/data/roadmaps/rust/content/rust-lldb@p1w1iljGABgHoJjIRJYLY.md index e55e5bd54..bc517d999 100644 --- a/src/data/roadmaps/rust/content/rust-lldb@p1w1iljGABgHoJjIRJYLY.md +++ b/src/data/roadmaps/rust/content/rust-lldb@p1w1iljGABgHoJjIRJYLY.md @@ -1,3 +1,9 @@ # rust-lldb `rust-lldb` is LLDB debugger enhanced with Rust-specific modifications for understanding Rust data structures and concepts. It includes pretty-printers for standard library types and comes bundled with the Rust compiler, providing better debugging experience for Rust applications. + +Visit the following resources to learn more: + +- [@official@Using rust-lldb for Improved Debugging](https://users.rust-lang.org/t/use-rust-gdb-and-rust-lldb-for-improved-debugging-you-already-have-them/756) +- [@article@Debugging Rust apps with GDB](https://blog.logrocket.com/debugging-rust-apps-with-gdb/) +- [@article@Debugging Rust with rust-lldb](https://dev.to/bmatcuk/debugging-rust-with-rust-lldb-j1f) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/rust-repl-rust-playground@eYCNYtwXBjZwcPUe7QYZ-.md b/src/data/roadmaps/rust/content/rust-repl-rust-playground@eYCNYtwXBjZwcPUe7QYZ-.md index ed7288df5..b92a0a31b 100644 --- a/src/data/roadmaps/rust/content/rust-repl-rust-playground@eYCNYtwXBjZwcPUe7QYZ-.md +++ b/src/data/roadmaps/rust/content/rust-repl-rust-playground@eYCNYtwXBjZwcPUe7QYZ-.md @@ -1,3 +1,10 @@ # Rust REPL (Rust Playground) `Rust REPL` (Read-Eval-Print-Loop) is an interactive shell in which you can write and test Rust snippets in real-time. Unlike running a program normally in Rust where you have to manually compile and then run the program, REPL automatically evaluates your inputs, and the result is returned immediately after execution. This is helpful when experimenting with Rust code, learning the language, and debugging. REPL isn't built into Rust directly, but is available via third-party tools such as `evcxr_repl`. + +Visit the following resources to learn more: + +- [@official@Rust Playground](https://play.rust-lang.org/) +- [@article@Debugging Rust apps with GDB](https://blog.logrocket.com/debugging-rust-apps-with-gdb/) +- [@article@Debugging Rust with rust-lldb](https://dev.to/bmatcuk/debugging-rust-with-rust-lldb-j1f) +- [@article@Interactive Rust in a REPL and Jupyter Notebook](https://depth-first.com/articles/2020/09/21/interactive-rust-in-a-repl-and-jupyter-notebook-with-evcxr/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/rwlock@WzGl4DkANjUu7VC1AIWI-.md b/src/data/roadmaps/rust/content/rwlock@WzGl4DkANjUu7VC1AIWI-.md index bbcfd9622..e52ae0d0f 100644 --- a/src/data/roadmaps/rust/content/rwlock@WzGl4DkANjUu7VC1AIWI-.md +++ b/src/data/roadmaps/rust/content/rwlock@WzGl4DkANjUu7VC1AIWI-.md @@ -2,6 +2,7 @@ `RwLock` (Read-Write Lock) allows multiple concurrent readers OR one exclusive writer, unlike Mutex which allows only one accessor. Use `read()` for shared access and `write()` for exclusive access. Ideal for read-heavy workloads where data is frequently read but rarely modified. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@RwLock](https://doc.rust-lang.org/std/sync/struct.RwLock.html) \ No newline at end of file +- [@official@RwLock](https://doc.rust-lang.org/std/sync/struct.RwLock.html) +- [@article@Rust Read-Write Locks: Managing Concurrent Read and Write Access](https://medium.com/@TechSavvyScribe/rust-read-write-locks-managing-concurrent-read-and-write-access-a6ab689bbed3) diff --git a/src/data/roadmaps/rust/content/serde@EHErECEYws05oi59OsZpC.md b/src/data/roadmaps/rust/content/serde@EHErECEYws05oi59OsZpC.md index a356a2d8c..7dd784017 100644 --- a/src/data/roadmaps/rust/content/serde@EHErECEYws05oi59OsZpC.md +++ b/src/data/roadmaps/rust/content/serde@EHErECEYws05oi59OsZpC.md @@ -4,5 +4,6 @@ Serde is Rust's most popular serialization framework for converting data structu Visit the following resources to learn more: -- [@official@Official Website](https://serde.rs/) -- [@article@Docs.rs: Serde](https://docs.rs/serde/latest/serde/) +- [@official@Serde](https://serde.rs/) +- [@article@Serde Documentation](https://docs.rs/serde/latest/serde/) +- [@article@Serialization in Rust with Serde](https://rustmeup.com/serialization-in-rust-with-serde) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/serialization--deserialization@gcmKSLWfBqx4aPZOmyQsg.md b/src/data/roadmaps/rust/content/serialization--deserialization@gcmKSLWfBqx4aPZOmyQsg.md index 404cf5ac9..3c00a14cb 100644 --- a/src/data/roadmaps/rust/content/serialization--deserialization@gcmKSLWfBqx4aPZOmyQsg.md +++ b/src/data/roadmaps/rust/content/serialization--deserialization@gcmKSLWfBqx4aPZOmyQsg.md @@ -1,3 +1,9 @@ # Serialization/Deserialization -Serialization converts Rust data structures into bytes for storage or transmission, while deserialization reverses the process. Serde is the standard framework with support for JSON, YAML, TOML, Binary, and more formats. Provides efficient, type-safe data conversion. \ No newline at end of file +Serialization converts Rust data structures into bytes for storage or transmission, while deserialization reverses the process. *Serde* is the standard framework with support for JSON, YAML, TOML, Binary, and more formats. Provides efficient, type-safe data conversion. + +Visit the following resources to learn more: + +- [@article@Serde Documentation](https://docs.rs/serde/latest/serde/) +- [@article@Serialization and Deserialization in Rust: A Comprehensive Guide](https://rustmeup.com/serialization-in-rust-with-serde) +- [@article@Rust Serialization: Easy Beginner's Guide with Examples](https://boxoflearn.com/rust-serialization-guide/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/smol@3C9gCBAq3OQVb583S72D4.md b/src/data/roadmaps/rust/content/smol@3C9gCBAq3OQVb583S72D4.md index 80117bda6..f410eb272 100644 --- a/src/data/roadmaps/rust/content/smol@3C9gCBAq3OQVb583S72D4.md +++ b/src/data/roadmaps/rust/content/smol@3C9gCBAq3OQVb583S72D4.md @@ -4,4 +4,6 @@ Visit the following resources to learn more: -- [@article@Docs.rs: smol](https://docs.rs/smol/latest/smol/) +- [@official@Smol - Gist of Rust](https://book.gist.rs/rust/r1/smol.html) +- [@article@Smol Documentation](https://docs.rs/smol/latest/smol/) +- [@opensource@smol-rs/smol: A small and fast async runtime for Rust](https://github.com/smol-rs/smol) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/sodiumoxide@hzzRFb5cyXkgUdLZxaozB.md b/src/data/roadmaps/rust/content/sodiumoxide@hzzRFb5cyXkgUdLZxaozB.md index 14003187b..43294fda9 100644 --- a/src/data/roadmaps/rust/content/sodiumoxide@hzzRFb5cyXkgUdLZxaozB.md +++ b/src/data/roadmaps/rust/content/sodiumoxide@hzzRFb5cyXkgUdLZxaozB.md @@ -1,3 +1,8 @@ # sodiumoxide -`sodiumoxide` is a Rust binding to libsodium cryptography library, designed for easy use and misuse prevention. Provides safe, high-level, idiomatic Rust wrappers for cryptographic primitives with automatic error handling. Follows NaCl design principles for simplicity while offering libsodium performance benefits. \ No newline at end of file +`sodiumoxide` is a Rust binding to libsodium cryptography library, designed for easy use and misuse prevention. Provides safe, high-level, idiomatic Rust wrappers for cryptographic primitives with automatic error handling. Follows NaCl design principles for simplicity while offering libsodium performance benefits. + +Visit the following resources to learn more: + +- [@article@Rust Password Hashing with Argon2id and the Sodiumoxide](https://blue42.net/code/rust/examples/sodiumoxide-password-hashing/post/) +- [@article@sodiumoxide/sodiumoxide](https://deepwiki.com/sodiumoxide/sodiumoxide) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/sqlx@r2KembNZ2WIzLe87EB91K.md b/src/data/roadmaps/rust/content/sqlx@r2KembNZ2WIzLe87EB91K.md index f3c338371..01c513637 100644 --- a/src/data/roadmaps/rust/content/sqlx@r2KembNZ2WIzLe87EB91K.md +++ b/src/data/roadmaps/rust/content/sqlx@r2KembNZ2WIzLe87EB91K.md @@ -4,5 +4,6 @@ SQLx is an async, pure-Rust SQL toolkit providing compile-time query checking fo Visit the following resources to learn more: -- [@opensource@Repository](https://github.com/launchbadge/sqlx) -- [@article@Docs.rs: sqlx](https://docs.rs/sqlx/latest/sqlx/) +- [@opensource@launchbadge/sqlx](https://github.com/launchbadge/sqlx) +- [@article@sqlx Documentation](https://docs.rs/sqlx/latest/sqlx/) +- [@article@Getting Started with SQLx and SQLite in Rust](https://medium.com/rustaceans/getting-started-with-sqlx-and-sqlite-in-rust-895ae7fc01ae) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/stack@B-S1hE-ofNTutnkc2hJBf.md b/src/data/roadmaps/rust/content/stack@B-S1hE-ofNTutnkc2hJBf.md index 1f0d7a7ff..d3a1b3011 100644 --- a/src/data/roadmaps/rust/content/stack@B-S1hE-ofNTutnkc2hJBf.md +++ b/src/data/roadmaps/rust/content/stack@B-S1hE-ofNTutnkc2hJBf.md @@ -2,6 +2,8 @@ Stack is a LIFO (Last-In-First-Out) data structure where elements are added and removed from the same end. In Rust, the call stack manages function calls, with each call pushing a frame and returns popping it. Stack memory is fast but limited in size, with stack overflow occurring when exceeded. -Learn more from the following links: +Visit the following resources to learn more: - [@official@Box, Stack and Heap](https://doc.rust-lang.org/rust-by-example/std/box.html) +- [@official@std::collections](https://doc.rust-lang.org/std/collections/index.html) +- [@article@Getting Started with SQLx and SQLite in Rust](https://medium.com/rustaceans/getting-started-with-sqlx-and-sqlite-in-rust-895ae7fc01ae) diff --git a/src/data/roadmaps/rust/content/string@Hu1jf46OpX44nam_UvYqc.md b/src/data/roadmaps/rust/content/string@Hu1jf46OpX44nam_UvYqc.md index 14d78802f..d3178f562 100644 --- a/src/data/roadmaps/rust/content/string@Hu1jf46OpX44nam_UvYqc.md +++ b/src/data/roadmaps/rust/content/string@Hu1jf46OpX44nam_UvYqc.md @@ -2,10 +2,10 @@ Rust's `String` is a growable, mutable, UTF-8 encoded string type stored on the heap. Unlike string slices (`&str`), `String` owns its data and can be modified. Create with `String::from("text")` or `"text".to_string()`. Common operations include `push_str()`, `push()`, and concatenation with `+` or `format!()` macro. -Learn more from the following links: +Visit the following resources to learn more: -- [@official@String in std::string - Rust](https://doc.rust-lang.org/std/string/struct.String.html) -- [@official@str - Rust](https://doc.rust-lang.org/std/primitive.str.html) -- [@official@What Is a String?](https://doc.rust-lang.org/book/ch08-02-strings.html?highlight=String#what-is-a-string) +- [@official@String](https://doc.rust-lang.org/std/string/struct.String.html) +- [@official@str](https://doc.rust-lang.org/std/primitive.str.html) +- [@official@What as a String?](https://doc.rust-lang.org/book/ch08-02-strings.html?highlight=String#what-is-a-string) - [@article@Rust String (With Examples)](https://www.programiz.com/rust/string) - [@video@All Rust string types explained](https://www.youtube.com/watch?v=CpvzeyzgQdw&pp=ygUOc3RyaW5nIGluIHJ1c3Q%3D) diff --git a/src/data/roadmaps/rust/content/structopt@_43912wPdXgLL8v-IMHX_.md b/src/data/roadmaps/rust/content/structopt@_43912wPdXgLL8v-IMHX_.md index ae358aace..14b27ca04 100644 --- a/src/data/roadmaps/rust/content/structopt@_43912wPdXgLL8v-IMHX_.md +++ b/src/data/roadmaps/rust/content/structopt@_43912wPdXgLL8v-IMHX_.md @@ -1,3 +1,8 @@ -# structopt +# StructOpt -`StructOpt` is a library for parsing command-line arguments by defining structs where fields represent flags, options, and arguments. Combines `clap`'s parsing power with Rust's type system for declarative CLI definition with automatic help generation, strong typing, and validation. \ No newline at end of file +`StructOpt` is a library for parsing command-line arguments by defining structs where fields represent flags, options, and arguments. Combines `clap`'s parsing power with Rust's type system for declarative CLI definition with automatic help generation, strong typing, and validation. + +Visit the following resources to learn more: + +- [@official@Defining and Instantiating Structs](https://doc.rust-lang.org/book/ch05-01-defining-structs.html) +- [@article@Parsing Command Line Args with StructOpt](https://www.tenderisthebyte.com/blog/2019/05/08/parsing-cli-args-with-structopt/) diff --git a/src/data/roadmaps/rust/content/structs@Mi9mQ-8gyDPd8Mbu1zuHt.md b/src/data/roadmaps/rust/content/structs@Mi9mQ-8gyDPd8Mbu1zuHt.md index b6f047044..56036d244 100644 --- a/src/data/roadmaps/rust/content/structs@Mi9mQ-8gyDPd8Mbu1zuHt.md +++ b/src/data/roadmaps/rust/content/structs@Mi9mQ-8gyDPd8Mbu1zuHt.md @@ -2,12 +2,7 @@ In Rust, a struct is a custom data type used for grouping related values together into one entity. Structs are similar to classes in other programming languages. Essentially, each `struct` creates a new type that we can use to streamline complex data handling. -There are three types of `struct` in Rust: classic 'C' structs, tuple structs, and unit structs. +Visit the following resources to learn more: -- **Classic 'C' structs** are named-field structs and are the most commonly used. -- **Tuple structs**, while not being common, are useful when you want to couple together just a few data points that don't need field names. -- **Unit structs** are useful in situations where you want to implement a **trait** on some type, but don't have any data that you want to store in the type itself. - -Learn more from the following links: - -- [@article@Defining and Instantiating Structs](https://rust-book.cs.brown.edu/ch05-01-defining-structs.html) +- [@official@Defining and Instantiating Structs](https://doc.rust-lang.org/book/ch05-01-defining-structs.html) +- [@article@Understanding Structs in Rust: A Complete Guide with Examples](https://medium.com/@er.pwndhull07/understanding-structs-in-rust-a-complete-guide-with-examples-621bf9753b88) diff --git a/src/data/roadmaps/rust/content/tauri@Q71MnFDQBkZF1c2hj13pU.md b/src/data/roadmaps/rust/content/tauri@Q71MnFDQBkZF1c2hj13pU.md index 320a954bc..cbfbaa606 100644 --- a/src/data/roadmaps/rust/content/tauri@Q71MnFDQBkZF1c2hj13pU.md +++ b/src/data/roadmaps/rust/content/tauri@Q71MnFDQBkZF1c2hj13pU.md @@ -1,7 +1,9 @@ -# tauri +# Tauri Tauri is a framework for building lightweight, secure desktop applications using web technologies (HTML, CSS, JS) with a Rust backend. It offers smaller bundle sizes than Electron, enhanced security, and cross-platform support for Windows, macOS, and Linux with native system integration. -Learn more from the following resources: +Visit the following resources to learn more: -- [@official@Tauri Website](https://tauri.app) \ No newline at end of file +- [@official@Tauri](https://tauri.app) +- [@official@Tauri Guides](https://v1.tauri.app/v1/guides/) +- [@article@How to Build Cross-Platform GUI Applications with Rust & Tauri](https://codezup.com/cross-platform-gui-apps-rust-tauri-guide/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/termion@YS0igALDqSanGDWva_vls.md b/src/data/roadmaps/rust/content/termion@YS0igALDqSanGDWva_vls.md index 049eeb251..7c4e9417a 100644 --- a/src/data/roadmaps/rust/content/termion@YS0igALDqSanGDWva_vls.md +++ b/src/data/roadmaps/rust/content/termion@YS0igALDqSanGDWva_vls.md @@ -1,3 +1,9 @@ -# termion +# Termion -`termion` is a pure Rust, zero-dependency library for low-level terminal manipulation and information handling. Provides cross-terminal compatibility with features like color support, input handling, and terminal-specific capabilities. Ideal for building cross-platform CLI applications without external bindings. \ No newline at end of file +`termion` is a pure Rust, zero-dependency library for low-level terminal manipulation and information handling. Provides cross-terminal compatibility with features like color support, input handling, and terminal-specific capabilities. Ideal for building cross-platform CLI applications without external bindings. + +Visit the following resources to learn more: + +- [@official@Termion Documentation](https://docs.rs/termion/latest/termion/) +- [@article@Implementing Terminal I/O in Rust | by Packt](https://packt.medium.com/implementing-terminal-i-o-in-rust-4a44652b0f11) +- [@article@Making Terminal Applications in Rust with Termion](https://ticki.github.io/blog/making-terminal-applications-in-rust-with-termion/) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/testing@08qKtgnhJ3tlb5JKfTDf5.md b/src/data/roadmaps/rust/content/testing@08qKtgnhJ3tlb5JKfTDf5.md index e9beb72ab..17678c9f5 100644 --- a/src/data/roadmaps/rust/content/testing@08qKtgnhJ3tlb5JKfTDf5.md +++ b/src/data/roadmaps/rust/content/testing@08qKtgnhJ3tlb5JKfTDf5.md @@ -4,6 +4,7 @@ Rust has built-in testing support through `cargo test` and the `#[test]` attribu Visit the following resources to learn more: -- [@article@Rust Book: Writing Automated Tests](https://doc.rust-lang.org/book/ch11-00-testing.html) -- [@video@YouTube](https://www.youtube.com/watch?v=8XaVlL3lObQ) +- [@official@Writing Automated Tests](https://doc.rust-lang.org/book/ch11-01-writing-tests.html) +- [@article@Testing in Rust: A Quick Guide to Unit Tests](https://dev.to/tramposo/testing-in-rust-a-quick-guide-to-unit-tests-integration-tests-and-benchmarks-2bah) +- [@video@Mocking and Testing Rust](https://www.youtube.com/watch?v=8XaVlL3lObQ) - [@feed@Explore top posts about Testing](https://app.daily.dev/tags/testing?ref=roadmapsh) diff --git a/src/data/roadmaps/rust/content/threads-channels-and-message-passing@pJN260pWQVO0gHxi1-_3U.md b/src/data/roadmaps/rust/content/threads-channels-and-message-passing@pJN260pWQVO0gHxi1-_3U.md index 03be01239..5de9d54cf 100644 --- a/src/data/roadmaps/rust/content/threads-channels-and-message-passing@pJN260pWQVO0gHxi1-_3U.md +++ b/src/data/roadmaps/rust/content/threads-channels-and-message-passing@pJN260pWQVO0gHxi1-_3U.md @@ -2,6 +2,9 @@ Rust provides native threading with `std::thread::spawn()` and `join()` for 1:1 OS thread mapping. Channels enable safe message passing between threads, avoiding shared state issues. This model promotes concurrent programming without data races through Rust's ownership system. -Learn more from the following links: +Visit the following resources to learn more: +- [@official@std::thread](https://doc.rust-lang.org/std/thread/) +- [@official@Using Message Passing to Transfer Data Between Threads](https://doc.rust-lang.org/book/ch16-02-message-passing.html) +- [@article@Understanding Threads in Rust: A Comprehensive Guide](https://blog.stackademic.com/understanding-threads-in-rust-a-comprehensive-guide-7e2d23fb85b0) - [@article@Rust Atomics and Locks - Low-Level Concurrency in Practice](https://marabos.nl/atomics/) diff --git a/src/data/roadmaps/rust/content/tokio@H0mctp3Bj2OYfIGFDWGfz.md b/src/data/roadmaps/rust/content/tokio@H0mctp3Bj2OYfIGFDWGfz.md index 5ad4c927d..e968ecd61 100644 --- a/src/data/roadmaps/rust/content/tokio@H0mctp3Bj2OYfIGFDWGfz.md +++ b/src/data/roadmaps/rust/content/tokio@H0mctp3Bj2OYfIGFDWGfz.md @@ -4,5 +4,5 @@ Tokio is Rust's most popular async runtime for building fast, reliable network a Visit the following resources to learn more: -- [@official@Official Website](https://tokio.rs/) -- [@article@Docs.rs: Tokio](https://docs.rs/tokio/latest/tokio/) +- [@official@Tokio](https://tokio.rs/) +- [@article@Tokio Docs](https://docs.rs/tokio/latest/tokio/) diff --git a/src/data/roadmaps/rust/content/quinn@LmFog_qXrS9e5ARhV6OD_.md b/src/data/roadmaps/rust/content/toml-rust@LmFog_qXrS9e5ARhV6OD_.md similarity index 75% rename from src/data/roadmaps/rust/content/quinn@LmFog_qXrS9e5ARhV6OD_.md rename to src/data/roadmaps/rust/content/toml-rust@LmFog_qXrS9e5ARhV6OD_.md index 7ca183820..fd0eda1d5 100644 --- a/src/data/roadmaps/rust/content/quinn@LmFog_qXrS9e5ARhV6OD_.md +++ b/src/data/roadmaps/rust/content/toml-rust@LmFog_qXrS9e5ARhV6OD_.md @@ -4,4 +4,5 @@ Visit the following resources to learn more: -- [@article@Docs.rs: TOML](https://docs.rs/toml/latest/toml/) +- [@official@TOML](https://docs.rs/toml/latest/toml/) +- [@opensourcetoml-rs/toml-rs](https://github.com/toml-rs/toml-rs) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/trait-bounds-and-associated-types@pRDgDtRIVpNM2CdhSOS3Q.md b/src/data/roadmaps/rust/content/trait-bounds-and-associated-types@pRDgDtRIVpNM2CdhSOS3Q.md index af495265e..e0336f2f6 100644 --- a/src/data/roadmaps/rust/content/trait-bounds-and-associated-types@pRDgDtRIVpNM2CdhSOS3Q.md +++ b/src/data/roadmaps/rust/content/trait-bounds-and-associated-types@pRDgDtRIVpNM2CdhSOS3Q.md @@ -1,3 +1,8 @@ # Trait Bounds and Associated Types -Trait bounds constrain generics by requiring types to implement specific traits (`T: Display`). Associated types define type placeholders within traits that implementors must specify. Together, they enable flexible generic programming with type safety and improved API design patterns. \ No newline at end of file +Trait bounds constrain generics by requiring types to implement specific traits (`T: Display`). Associated types define type placeholders within traits that implementors must specify. Together, they enable flexible generic programming with type safety and improved API design patterns. + +Visit the following resources to learn more: + +- [@official@Trait and Lifetime Bounds](https://doc.rust-lang.org/reference/trait-bounds.html) +- [@article@Understanding Traits and Trait Bounds in Rust](https://leapcell.medium.com/understanding-traits-and-trait-bounds-in-rust-d575f19dd649) diff --git a/src/data/roadmaps/rust/content/trait-definitions--implementations@_EicstELZcdesHiXFWJGu.md b/src/data/roadmaps/rust/content/trait-definitions--implementations@_EicstELZcdesHiXFWJGu.md index 5eaef880e..dd4e19b18 100644 --- a/src/data/roadmaps/rust/content/trait-definitions--implementations@_EicstELZcdesHiXFWJGu.md +++ b/src/data/roadmaps/rust/content/trait-definitions--implementations@_EicstELZcdesHiXFWJGu.md @@ -4,4 +4,5 @@ Traits define shared behavior as a set of method signatures that types can imple Visit the following resources to learn more: -- [@article@Rust by Example: Traits](https://doc.rust-lang.org/rust-by-example/trait.html) +- [@official@Traits](https://doc.rust-lang.org/rust-by-example/trait.html) +- [@article@Understanding Traits and Trait Bounds in Rust](https://leapcell.medium.com/understanding-traits-and-trait-bounds-in-rust-d575f19dd649) diff --git a/src/data/roadmaps/rust/content/traits--generics@zLKbYX0nnbfD5n3P_JRaS.md b/src/data/roadmaps/rust/content/traits--generics@zLKbYX0nnbfD5n3P_JRaS.md index 6ca06497a..1f4102116 100644 --- a/src/data/roadmaps/rust/content/traits--generics@zLKbYX0nnbfD5n3P_JRaS.md +++ b/src/data/roadmaps/rust/content/traits--generics@zLKbYX0nnbfD5n3P_JRaS.md @@ -4,4 +4,4 @@ Traits define shared behavior that types can implement, while generics enable co Visit the following resources to learn more: -- [@article@Book: Generic Types, Traits, and Lifetimes](https://doc.rust-lang.org/book/ch10-00-generics.html) +- [@official@Generic Types, Traits, and Lifetimes](https://doc.rust-lang.org/book/ch10-00-generics.html) diff --git a/src/data/roadmaps/rust/content/traits@SJMuIEuHp8X6nfLb0k0TU.md b/src/data/roadmaps/rust/content/traits@SJMuIEuHp8X6nfLb0k0TU.md index 75f806edb..41bc7cd47 100644 --- a/src/data/roadmaps/rust/content/traits@SJMuIEuHp8X6nfLb0k0TU.md +++ b/src/data/roadmaps/rust/content/traits@SJMuIEuHp8X6nfLb0k0TU.md @@ -4,8 +4,7 @@ Traits in Rust define behaviors that are shared among different data types. Impl Traits are abstract; it's not possible to create instances of traits. However, we can define pointers of trait types, and these can hold any data type that implements the `trait`. A `trait` is **implemented** for something else with the syntax `impl TraitAbc for Xyz {...}`, which can be a concrete type or another trait. -You should read carefully about traits in Rust and understand how some common traits, like `Copy`, are already implemented for various primitive types and how this could affect your program. - -Learn more from the following links: +Visit the following resources to learn more: - [@article@Traits: Defining Shared Behaviour](https://doc.rust-lang.org/book/ch10-02-traits.html) +- [@article@Understanding Traits and Trait Bounds in Rust](https://leapcell.medium.com/understanding-traits-and-trait-bounds-in-rust-d575f19dd649) diff --git a/src/data/roadmaps/rust/content/tuple@81_J7CwtUUjYPvKV_prg3.md b/src/data/roadmaps/rust/content/tuple@81_J7CwtUUjYPvKV_prg3.md index 104d3a22d..fbba809eb 100644 --- a/src/data/roadmaps/rust/content/tuple@81_J7CwtUUjYPvKV_prg3.md +++ b/src/data/roadmaps/rust/content/tuple@81_J7CwtUUjYPvKV_prg3.md @@ -4,6 +4,6 @@ Tuples are fixed-size collections that can hold elements of different types. Acc Learn more from the following links: -- [@official@Tuple - Rust](https://doc.rust-lang.org/std/primitive.tuple.html) +- [@official@Tuple](https://doc.rust-lang.org/std/primitive.tuple.html) - [@article@The Tuple Type](https://rust-book.cs.brown.edu/ch03-02-data-types.html#the-tuple-type) - [@video@Rust Tutorial - Tuples](https://www.youtube.com/watch?v=t047Hseyj_k&t=506s) diff --git a/src/data/roadmaps/rust/content/unit--integration-testing@w9coeW9-crDxu0KC-9gEU.md b/src/data/roadmaps/rust/content/unit--integration-testing@w9coeW9-crDxu0KC-9gEU.md index 3b640583c..046453965 100644 --- a/src/data/roadmaps/rust/content/unit--integration-testing@w9coeW9-crDxu0KC-9gEU.md +++ b/src/data/roadmaps/rust/content/unit--integration-testing@w9coeW9-crDxu0KC-9gEU.md @@ -4,5 +4,7 @@ Unit tests verify individual functions using `#[test]` and live alongside code. Visit the following resources to learn more: -- [@article@Rust Book: How to Write Tests](https://doc.rust-lang.org/book/ch11-01-writing-tests.html) -- [@article@Rust by Example: Unit testing](https://doc.rust-lang.org/rust-by-example/testing/unit_testing.html) +- [@official@Unit Testing](https://doc.rust-lang.org/rust-by-example/testing/unit_testing.html) +- [@official@How to Write Tests](https://doc.rust-lang.org/book/ch11-01-writing-tests.html) +- [@article@Testing in Rust: A Quick Guide to Unit Tests](https://dev.to/tramposo/testing-in-rust-a-quick-guide-to-unit-tests-integration-tests-and-benchmarks-2bah) +- [@video@Mocking and Testing Rust](https://www.youtube.com/watch?v=8XaVlL3lObQ) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/variables-datatypes-and-constants@Gw5E21W5zis-RUIgNSEV2.md b/src/data/roadmaps/rust/content/variables-datatypes-and-constants@Gw5E21W5zis-RUIgNSEV2.md index 7f1b0cc34..a25816d6f 100644 --- a/src/data/roadmaps/rust/content/variables-datatypes-and-constants@Gw5E21W5zis-RUIgNSEV2.md +++ b/src/data/roadmaps/rust/content/variables-datatypes-and-constants@Gw5E21W5zis-RUIgNSEV2.md @@ -2,7 +2,8 @@ In Rust, variables are declared using the `let` keyword. All variables are immutable by default, which means once a value is bound to a variable, it cannot be changed. If you want to make a variable mutable, the `mut` keyword is used. So, if you wanted to declare a mutable variable `x` and assign it the value `5`, you would write `let mut x = 5;`. Variables can also be patterned. By default in Rust, variables are block-scoped. Rust also supports several types of variable attributes. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Variables and Mutability](https://rust-book.cs.brown.edu/ch03-01-variables-and-mutability.html) -- [@article@Data Types](https://rust-book.cs.brown.edu/ch03-02-data-types.html) +- [@official@Variables and Mutability](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html) +- [@official@Data Types](https://doc.rust-lang.org/book/ch03-02-data-types.html) +- [@official@Constants](https://doc.rust-lang.org/rust-by-example/custom_types/constants.html) diff --git a/src/data/roadmaps/rust/content/vector@PskCueCc9pSxfnSzfdX-u.md b/src/data/roadmaps/rust/content/vector@PskCueCc9pSxfnSzfdX-u.md index b25d8962d..6a0f74a2a 100644 --- a/src/data/roadmaps/rust/content/vector@PskCueCc9pSxfnSzfdX-u.md +++ b/src/data/roadmaps/rust/content/vector@PskCueCc9pSxfnSzfdX-u.md @@ -2,10 +2,10 @@ `Vec` is Rust's growable, heap-allocated array that stores elements of the same type contiguously. Unlike arrays, vectors can resize at runtime. Key methods include `push()` to add elements, `pop()` to remove the last element, and `len()` for size. Example: `let mut v = vec![1, 2, 3];` -Learn more from the following links: +Visit the following resources to learn more: -- [@official@Vec in std::vec - Rust](https://doc.rust-lang.org/std/vec/struct.Vec.html) -- [@article@Storing Lists of Values with Vectors](https://doc.rust-lang.org/book/ch08-01-vectors.html?highlight=vector#storing-lists-of-values-with-vectors) +- [@official@Vector](https://doc.rust-lang.org/std/vec/struct.Vec.html) +- [@official@Storing Lists of Values with Vectors](https://doc.rust-lang.org/book/ch08-01-vectors.html?highlight=vector#storing-lists-of-values-with-vectors) - [@article@Rust Vector (With Examples)](https://www.programiz.com/rust/vector) -- [@video@Rust: Vectors](https://www.youtube.com/watch?v=nOKOFYzvvHo&t=97s&pp=ygUMcnVzdCB2ZWN0b3Jz) +- [@video@Rust Vectors](https://www.youtube.com/watch?v=nOKOFYzvvHo&t=97s&pp=ygUMcnVzdCB2ZWN0b3Jz) - [@video@Common Collections in Rust](https://www.youtube.com/watch?v=Zs-pS-egQSs&t=39s&pp=ygUMcnVzdCB2ZWN0b3Jz) diff --git a/src/data/roadmaps/rust/content/wasm-bindgen@SUtBBqqDeR_yAkr669ZvE.md b/src/data/roadmaps/rust/content/wasm-bindgen@SUtBBqqDeR_yAkr669ZvE.md index 425750349..6d12e1d7b 100644 --- a/src/data/roadmaps/rust/content/wasm-bindgen@SUtBBqqDeR_yAkr669ZvE.md +++ b/src/data/roadmaps/rust/content/wasm-bindgen@SUtBBqqDeR_yAkr669ZvE.md @@ -1,3 +1,9 @@ # wasm-bindgen -`wasm-bindgen` facilitates high-level interactions between Rust and JavaScript in WebAssembly. It generates bindings allowing seamless communication, JavaScript API calls from Rust, and vice versa. Handles memory representations and call semantics for complex data types like strings and objects. \ No newline at end of file +`wasm-bindgen` facilitates high-level interactions between Rust and JavaScript in WebAssembly. It generates bindings allowing seamless communication, JavaScript API calls from Rust, and vice versa. Handles memory representations and call semantics for complex data types like strings and objects. + +Visit the following resources to learn more: + +- [@official@wasm-bindgen](https://docs.rs/wasm-bindgen/latest/wasm_bindgen/) +- [@opensource@rustwasm/wasm-bindgen](https://github.com/rustwasm/wasm-bindgen) +- [@article@Compiling from Rust to WebAssembly](https://developer.mozilla.org/en-US/docs/WebAssembly/Guides/Rust_to_Wasm) diff --git a/src/data/roadmaps/rust/content/wasm-pack@TSlj7mMUB5CDTy8uMFzKV.md b/src/data/roadmaps/rust/content/wasm-pack@TSlj7mMUB5CDTy8uMFzKV.md index 0f193723c..51eb9420e 100644 --- a/src/data/roadmaps/rust/content/wasm-pack@TSlj7mMUB5CDTy8uMFzKV.md +++ b/src/data/roadmaps/rust/content/wasm-pack@TSlj7mMUB5CDTy8uMFzKV.md @@ -1,3 +1,10 @@ # wasm-pack -`wasm-pack` is a command-line tool for assembling and packaging Rust crates targeting WebAssembly. It bridges Rust/WASM and JavaScript, generating necessary files for npm publishing. Ensures proper Rust-to-WASM compilation setup with focus on ergonomics, performance, and correctness. \ No newline at end of file +`wasm-pack` is a command-line tool for assembling and packaging Rust crates targeting WebAssembly. It bridges Rust/WASM and JavaScript, generating necessary files for npm publishing. Ensures proper Rust-to-WASM compilation setup with focus on ergonomics, performance, and correctness. + +Visit the following resources to learn more: + +- [@official@wasm-pack](https://lib.rs/crates/wasm-pack) +- [@article@Writing & Compiling WASM in Rust](https://www.shuttle.dev/blog/2024/03/06/writing-wasm-rust) +- [@opensource@rustwasm/wasm-pack](https://github.com/rustwasm/wasm-pack) +- [@article@Compiling from Rust to WebAssembly](https://developer.mozilla.org/en-US/docs/WebAssembly/Guides/Rust_to_Wasm) diff --git a/src/data/roadmaps/rust/content/wasmer@iyFHvZj_ntr_dX6WlL4E1.md b/src/data/roadmaps/rust/content/wasmer@iyFHvZj_ntr_dX6WlL4E1.md index 57f9a9a0b..84ddb2405 100644 --- a/src/data/roadmaps/rust/content/wasmer@iyFHvZj_ntr_dX6WlL4E1.md +++ b/src/data/roadmaps/rust/content/wasmer@iyFHvZj_ntr_dX6WlL4E1.md @@ -1,3 +1,11 @@ -# wasmer +# Wasmer -Wasmer is a standalone WebAssembly runtime designed to run WASM files on any platform quickly and efficiently. Features a pluggable system with different compiling strategies, friendly CLI, and embedding APIs for calling WASM functions directly from various programming languages. Lightweight and modular. \ No newline at end of file +Wasmer is a standalone WebAssembly runtime designed to run WASM files on any platform quickly and efficiently. Features a pluggable system with different compiling strategies, friendly CLI, and embedding APIs for calling WASM functions directly from various programming languages. Lightweight and modular. + +Visit the following resources to learn more: + +- [@official@Embedding WebAssembly in your Rust Application](https://blog.wasmer.io/executing-webassembly-in-your-rust-application-d5cd32e8ce46) +- [@article@Wasmer — WebAssembly in Rust](https://lib.rs/crates/wasmer) +- [@article@Writing & Compiling WASM in Rust](https://www.shuttle.dev/blog/2024/03/06/writing-wasm-rust) +- [@opensource@wasmerio/wasmer](https://github.com/wasmerio/wasmer) +- [@article@Compiling from Rust to WebAssembly](https://developer.mozilla.org/en-US/docs/WebAssembly/Guides/Rust_to_Wasm) diff --git a/src/data/roadmaps/rust/content/web-development@KomYBYxj0FTrJDYB3nU5B.md b/src/data/roadmaps/rust/content/web-development@KomYBYxj0FTrJDYB3nU5B.md index 33a2c4d1e..7a6515757 100644 --- a/src/data/roadmaps/rust/content/web-development@KomYBYxj0FTrJDYB3nU5B.md +++ b/src/data/roadmaps/rust/content/web-development@KomYBYxj0FTrJDYB3nU5B.md @@ -1,3 +1,9 @@ # Web Development Rust offers excellent web development capabilities with frameworks like Actix, Rocket, Axum, and Warp. These provide HTTP handling, routing, middleware, and database integration. Rust's performance and safety make it ideal for high-performance web services, APIs, and microservices. + +Visit the following resources to learn more: + +- [@official@Rocket - Simple, Fast, Type-Safe Web Framework for Rust](https://rocket.rs/) +- [@article@Rust for Web Development: A Beginner's Guide](https://medium.com/@enravishjeni411/rust-for-web-development-a-beginners-guide-fcc994e5c090) +- [@article@How to Write Your First Rust Web App with Rocket and RustRover](https://blog.jetbrains.com/rust/2024/02/28/how-to-write-your-first-rust-web-app-with-rocket-and-rustrover/) diff --git a/src/data/roadmaps/rust/content/webassembly-wasm@fusu4ZHH4-cjoouLr4F9U.md b/src/data/roadmaps/rust/content/webassembly-wasm@fusu4ZHH4-cjoouLr4F9U.md index 3c9a75112..c67a4e3a1 100644 --- a/src/data/roadmaps/rust/content/webassembly-wasm@fusu4ZHH4-cjoouLr4F9U.md +++ b/src/data/roadmaps/rust/content/webassembly-wasm@fusu4ZHH4-cjoouLr4F9U.md @@ -1,3 +1,11 @@ # WebAssembly (WASM) -WebAssembly is a binary instruction format that runs at near-native speed in web browsers and other environments. Rust compiles excellently to WASM with tools like `wasm-pack` and `wasm-bindgen`, enabling high-performance web applications and cross-platform deployment. \ No newline at end of file +WebAssembly is a binary instruction format that runs at near-native speed in web browsers and other environments. Rust compiles excellently to WASM with tools like `wasm-pack` and `wasm-bindgen`, enabling high-performance web applications and cross-platform deployment. + +Visit the following resources to learn more: + +- [@official@Embedding WebAssembly in your Rust Application](https://blog.wasmer.io/executing-webassembly-in-your-rust-application-d5cd32e8ce46) +- [@article@Writing & Compiling WASM in Rust](https://www.shuttle.dev/blog/2024/03/06/writing-wasm-rust) +- [@article@Compiling from Rust to WebAssembly](https://developer.mozilla.org/en-US/docs/WebAssembly/Guides/Rust_to_Wasm) +- [@official@wasm-pack](https://lib.rs/crates/wasm-pack) +- [@official@wasm-bindgen](https://docs.rs/wasm-bindgen/latest/wasm_bindgen/) diff --git a/src/data/roadmaps/rust/content/wgpu-rs@6wGShK9WEnXiby_Jm8sTO.md b/src/data/roadmaps/rust/content/wgpu-rs@6wGShK9WEnXiby_Jm8sTO.md index f6441967c..edf17b903 100644 --- a/src/data/roadmaps/rust/content/wgpu-rs@6wGShK9WEnXiby_Jm8sTO.md +++ b/src/data/roadmaps/rust/content/wgpu-rs@6wGShK9WEnXiby_Jm8sTO.md @@ -1,3 +1,9 @@ # wgpu-rs `wgpu-rs` provides safe, idiomatic Rust graphics programming by abstracting over wgpu-core. Offers high-level convenience with low-level control options. Provides unified access to graphics and compute functionality across Vulkan, Metal, DirectX, and WebGPU backends for cross-platform compatibility. + +Visit the following resources to learn more: + +- [@official@wgpu: portable graphics library for Rust](https://wgpu.rs/) +- [@article@wpgu docs](hhttps://docs.rs/wgpu/latest/wgpu/) +- [@opensource@gfx-rs/wgpu](https://github.com/gfx-rs/wgpu) \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/what-is-rust@cMfsRtvzvDZZJ0TqeUOxm.md b/src/data/roadmaps/rust/content/what-is-rust@cMfsRtvzvDZZJ0TqeUOxm.md index 6abbe953f..42a6bffa1 100644 --- a/src/data/roadmaps/rust/content/what-is-rust@cMfsRtvzvDZZJ0TqeUOxm.md +++ b/src/data/roadmaps/rust/content/what-is-rust@cMfsRtvzvDZZJ0TqeUOxm.md @@ -4,6 +4,8 @@ Rust is a modern system programming language focused on performance, safety, and Visit the following resources to learn more: +- [@official@Rust? What is it?](https://doc.rust-lang.org/stable/rust-by-example/index.html) +- [@official@Rust Programming Language](https://www.rust-lang.org/) +- [@article@What is Rust and why is it so popular?](https://stackoverflow.blog/2020/01/20/what-is-rust-and-why-is-it-so-popular/) - [@video@What is Rust?](https://www.youtube.com/watch?v=R33h77nrMqc) - [@feed@Explore top posts about Rust](https://app.daily.dev/tags/rust?ref=roadmapsh) -- [@official@Rust by example](https://doc.rust-lang.org/stable/rust-by-example/index.html) diff --git a/src/data/roadmaps/rust/content/why-use-rust@VhSEH_RoWFt1z2lial7xZ.md b/src/data/roadmaps/rust/content/why-use-rust@VhSEH_RoWFt1z2lial7xZ.md index 98ef1041c..0c0c8f8c5 100644 --- a/src/data/roadmaps/rust/content/why-use-rust@VhSEH_RoWFt1z2lial7xZ.md +++ b/src/data/roadmaps/rust/content/why-use-rust@VhSEH_RoWFt1z2lial7xZ.md @@ -2,6 +2,11 @@ Rust is a system programming language that aims to provide memory safety, concurrency, and performance with a focus on zero cost abstractions. It was originally created by Graydon Hoare at Mozilla Research, with contributions from Brendan Eich, the creator of JavaScript. Rust is appreciated for the solutions it provides to common programming language issues. Its emphasis on safety, speed, and support for concurrent programming, as well as its robust type system, are just a few reasons why developers choose Rust. +Visit the following resources to learn more: + +- [@official@Rust? What is it?](https://doc.rust-lang.org/stable/rust-by-example/index.html) +- [@official@Rust Programming Language](https://www.rust-lang.org/) +- [@video@What is Rust?](https://www.youtube.com/watch?v=R33h77nrMqc) - [@video@Convince your boss to use Rust](https://www.youtube.com/playlist?list=PLZaoyhMXgBzqkaLKR8HHWZaASMvW4gRtZ) - [@video@Rust in 100 seconds](https://www.youtube.com/watch?v=5C_HPTJg5ek\&pp=ygUNcnVzdCBmaXJlYmFzZQ%3D%3D) - [@feed@Explore top posts about Rust](https://app.daily.dev/tags/rust?ref=roadmapsh) diff --git a/src/data/roadmaps/rust/rust.md b/src/data/roadmaps/rust/rust.md index 5ba77d7ce..8534852d7 100644 --- a/src/data/roadmaps/rust/rust.md +++ b/src/data/roadmaps/rust/rust.md @@ -19,13 +19,16 @@ schema: datePublished: '2023-11-14' dateModified: '2023-11-14' seo: - title: 'Learn to become a Rust developer' + title: 'Learn to become a Rust developer - roadmap.sh' description: 'Community driven, articles, resources, guides, interview questions, quizzes for Rust development. Learn to become a modern Rust developer by following the steps, skills, resources and guides listed in this roadmap.' keywords: - 'guide to becoming a rust developer' - 'rust developer' - 'guide to rust' - 'rust roadmap' + - 'rust roadmap 2024' + - 'rust roadmap 2025' + - 'rustlang roadmap' - 'rust skills' - 'rust skills test' - 'skills for rust' @@ -37,7 +40,6 @@ relatedRoadmaps: - 'backend' - 'devops' - 'golang' - - 'java' - 'nodejs' sitemap: priority: 1