Just wrapped up another Rust project—Minigrep, a command-line file search tool! Feeling accomplished and excited for the next challenge!
😇 If you’re learning Rust, I highly recommend tackling this—it’s a great way to level up!
#RustLang #Coding #SystemsProgramming #LearningRust #Minigrep #DevJourney
🚀 Rust Under the Hood hardcover edition is now available! 📚
Dive deep into Rust internals through x86-64 assembly, exploring memory management, compiler optimizations, async state machines, and more.
Get your copy today: https://www.amazon.com/dp/B0DS9M8S13
🔧 Learn how enums, structs, Vtables, SIMD, and async executors work at any level. 🦀💻
#Rust #Programming #RustLang #SystemsProgramming #Books #LearningRust
That’s it, our short tour of my favorite resources for #LearningRust is finished… It’s now time to start your own project or pick up an open source project you like and contribute to it!
Stay tuned to the @hnsec blog for the third installment of our #OffensiveRust series, in which I’ll explore how to use #Rust for vulnerability research and present my humble contributions to @binarly_io idalib bindings, enabling the development in idiomatic Rust of standalone tools based on Hex-Rays’s IDA Pro.
As an intermediate-level #Rust developer, what you need are learning resources that can help bring your skills to the next level.
One such resource is “Zero to Production in Rust” by @algo_luca, an introduction to web API backend development that provides excellent coverage of the whole language and its patterns, using a realistic project as a practical example for #LearningRust.
Other intermediate-level learning resources that I recommend are “Effective Rust”, “Rust Design Patterns”, “Rust API Guidelines”, and the “Rust Cookbook”.
Happy new year!
If you have followed my previous advice while #LearningRust, you should be ready for one of my favorite learning resources.
“Learn Rust With Entirely Too Many Linked Lists” is a fun and entertaining read on the intricacies of #Rust (and linked lists) by the same author of the eldritch Rustonomicon. You’re welcome!
Now that you have learned the basics of the language and have set up your IDE, you’re ready to tackle some practical exercises as the next step in #LearningRust.
I especially recommend Rustlings, a collection of small exercises to get you used to reading and writing #Rust code.
https://github.com/rust-lang/rustlings/
If you need more, 100 Exercises To Learn Rust is another excellent resource for some additional guided practice. Then, you also have Exercism, Advent of Code, and similar challenges to further hone your skills.
Theory is important, but I’m a strong believer in getting your hands dirty (i.e., writing your own code) as soon as possible! To make this a pleasant experience when #LearningRust, you should pick up the IDE that is best for you.
After some experimentation, I settled with RustRover by @jetbrains. It offers a delightful user experience and it’s free for non-commercial use. You should check it out.
Another popular choice is Visual Studio Code equipped with rust-analyzer and other specialized extensions such as Even Better TOML and Prettier Rust.
If you aren’t familiar with how computers work under the hood, I recommend to start #LearningRust with Rust in Action, a perfect book for beginners.
It’s a hands-on guide that introduces the #Rust programming language by exploring systems programming concepts and techniques. It goes beyond language syntax to showcase what Rust has to offer in real-world use cases, such as dealing with persistent storage, memory, networking, CPU instructions, and more.
Let’s get our journey started with the best book for #LearningRust dedicated to beginners that I’ve found out there.
Programming Rust 2nd Edition is, in my opinion, even better than the official Rust Book. It covers all you need to know (and then some) to get familiar with the #Rust programming language, in a very readable style from start to finish.
https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/
2025 is just around the corner. If #LearningRust is among your New Year’s resolutions, I’ve got you.
Following my ongoing #Rust series on the @hnsec blog (https://security.humanativaspa.it/tag/rust/) and adding something along the way, in the next days I’ll recommend the learning resources that worked for me.
Stay tuned!
Understanding string slicing in #RustLang 🦀:
Remember: slices are based on bytes, not characters! Slicing an ASCII string is different from slicing a multibyte Unicode string. If you slice incorrectly, Rust will panic at runtime. ⚠️
let multibyte_string = "España";
let slice_multibyte = &multibyte_string[..5]; // This will panic! 🚫
Ensure your slices align with valid UTF-8 character boundaries.
#Programming #CodeTips #LearningRust #RustCommunity #Unicode
🚀 Exciting News: Learning Rust! 🦀
Hey everyone! 👋 Just wanted to share my latest adventure—I'm diving into the world of Rust! 🌐💻 Super stoked to explore this powerful systems programming language known for its performance, safety, and concurrency features. 🚀🔒 If you've got any tips, resources, or cool projects to recommend, I'm all ears! Let's embark on this coding journey together. 💡👨💻 #LearningRust #CodingAdventure #RustLangJourney
After a year since the last update, I returned to write some Rust to build a new feature for 235.
I documented my process of making it work and then extensively refactoring to make it nice.
https://hamatti.org/posts/learning-rust-10-added-new-feature-with-hashmap/
sigh, I'm going to need stronger drugz to walk my way through this "example":
----- snip -----
use std::fmt::Display;
fn longest_with_an_announcement<'a, T>(
x: &'a str,
y: &'a str,
ann: T,
) -> &'a str
where
T: Display,
{
println!("Announcement! {}", ann);
if x.len() > y.len() {
x
} else {
y
}
}
----- snip -----
#LearningRust
master of understatement:
"Most of the time, an error message suggesting the 'static lifetime results from attempting to create a dangling reference or a mismatch of the available lifetimes. In such cases, the solution is fixing those problems, not specifying the 'static lifetime."
translation: if you have to use a shotgun, then you are probably doing something wrong.
hmmmm, going to have to re-read "10.3. Validating References with Lifetimes" a few more times to grok it. in the first example set, the problem lifetimes is aimed at solving looks to me like an artifact of the language avoiding using an explicit return statement.
either I am missing something and later sections of this chapter will clarify, or this is really just a way to overcome a logical ambiguity problem which the language itself has introduced.
"Note that it isn’t possible to call the default implementation from an overriding implementation of that same method."
traits ain't interfaces, in the OOP sense... no calling "super"
hmmm, "traits" are pretty sweet... and subtly different than "interfaces"c
reading: "Traits: Defining Shared Behavior"
ugh, I understand why they re-used names in the example-set code and... ugh. Phil Karlton wuz right.
