# Getting Rust (Trying to learn Rust. Without AI) Last update: 07.16.2026 · #rust #programming ## Intro I've been spending some time trying to learn this amount. This consisted of reading through the excellent book put out by the Rust Foundation. It provides a very solid foundation to build upon. For me the difficulty is coming more so from working in statically type languages with garbage collectors that abstract a lot of memory management away from the developer. So with this being my first foray into a systems level language, Rust has proven to be pretty difficult. Not impossible, but difficult. What I'm aiming to do with this article is provide an overview that beginners like myself and others can come back to to get a brief understanding of Rust from a noob perspective. Because that's what this is a noob perspective. I do some top level stuff here, and then I'm sure that I'll have some more writings in the near future as I identify a project that I think would be fun to do in Rust. ## The Gewd Stuff ### Borrowing (Like stingy kids but worst) For me, it was no surprise, the the hardest thing up front was memory management and the borrowing principle. To simplify this, the book goes over the idea of the Rust compiler being much more optimized from the C compiler. Well, Rust as a language being much more optimized in terms of memory management. And C, the compiler doesn't stop you from doing certain things in regards to memory management. So if you forget to deallocate a variable and it's called upon later, you get a runtime error instead of a compiler error that Rust tries to avoid by having a very optimized compiler with very friendly error messaging before you even before you ever get to compiling or runtime. The borrow principle operates on the scope level. So anytime you see open close brackets, you'll you see a scope. If a variable is defined within that scope, at the end of that scope, it will be de-allocated. Unless it's given to another function within which at the end of that function, if it's given it and not referenced, then that variable will also be de-allocated at the end of that scope. To clear this up, let me give a bit of a simple example. ### Structs not Classes (More Struct-ture) I'm so you my background is in dot net, C sharp, and Java. So I'm very used to using classes as the main operating object. Rust kind of threw a wrench in that, not a rusty wrench, but just a wrench. Instead of classes, you use structs. What I found is that they're a lot more flexible than classes. Even though C sharp does have structs for value type objects, very small objects, so that you are optimizing your memory usage. Rust uses structs as the overarching object. The reason I say structs are flexible is because they can be shaped into many many of the abstractions that we see in C sharp, for example. Struct has properties, as you can see in the example below. you can provide implementations for functions upon structs. structs can also inherit traits which can be considered interfaces from my understanding. So if you want your struct to have a certain functionality, that's common among other structs, you have an inherent a trait or implement a trait function. a good example of this is the copy or the debug traits that allow you to print entire objects based on that trait. I'll talk more about traits in another section, but structs as they are are highly flexible objects are in the predominant object within Rust. ### Enums (You're not my type. Wait, yes you are.) Enums are a fun one in Rust. They provide much more functionality than what I've seen traditionally in other statically type languages. Enums are another very flexible object within Rust that allow you to Provide Mutually Exclusive Types within one object type. So we all know Enums as objects that allow us to declare mutually exclusive properties for an overarching type type, for example, in the example below. We have animal types. So that you in essence have a union type with exhaustive values that you can match on. So if you want to have a response for each type within an enum, you can have data within that enum type, and you know you've covered all code branches for that enum. ### Traits (We can all relate with the right traits) Traits in terms of other statically type languages are just interfaces. They allow you to extend the functionality of a struct in addition to providing generics that can be applicable to different types and implement it within different structs. They're also the superpower to sidestep hierarchical inheritance within Rust. Because structs can't be inherited from other structs. This is how we provide common functionality between different code within our code base. An example is here. Okay. That was a high level overview of some of the biggest parts that I've started working through and looking at. I'll go more in depth as I continue to explore the language. And I come up with any good ideas of what I can do with this language. I hope to try to implement it. So far what I found interesting is that crates, containers, project organization is a little bit different than what I'm used to. So navigating and reading new code has been invigorating to see, but also difficult to follow. but I feel like I'm off to a good start, and I think this is a great language to know. Especially for optimizing something that you may have already built. Toodaloo for now.