My Journey Learning Rust | Part 1 | It Begins

[FivelFox]

Heyo everyone!

It appears to be up for debate how easy it is to learn Rust as a beginner programmer. So I thought I would try to help by cataloging my experience since I only started programming this year, and my only experience is messing around with Lua tables.

A Note: Keep in mind, everyone is different and mileage will vary- what might make sense to me may confuse someone else and vise-versa. But, I hope this can provide some insight into how it can be for a beginner to learn Rust.

I'm currently on chapter 6 in the book.

Setup

Everything from Rustup to Cargo was super easy to setup and learn, and they are excellent. Fortunately I had already learned Git, but Cargo wouldn't have made it any more complicated I think. The Getting Started chapter is also well written, and overall everything was smooth.

Ownership

Aside from the things I already knew (variables, functions, and loops mostly) , ownership was by far the easiest concept to understand. It's super straightforward and it's one of the few things in programming that just makes sense to me.

Cross-compiling

Since I use Ubuntu and I wanted to send a programmer friend that uses Windows a program I had made, I looked into cross-compiling. It was fairly straightforward once I figured it out, and wasn't a hassle really. I've heard it's harder to cross-compile to Mac though.

Types

I kept hearing stuff about Rust having a type system and traits somehow had to do with it, but I just didn't grasp it. Were they related to normal data types? I couldn't tell.

Finally, I got tired of the ambiguity and looked into it. The Wikipedia articles on Type Systems and Data Types broke it open and made me realize they are in fact very related.

Note: I think the confusion came from people talking about generic types and "normal" types separately- it seemed like they were unrelated. For me, there needed to be more clarity that concrete types and generic types function similarly.

Of course, I know they have important differences, but this was worth noting I think.

Data Structures

So far tuples, structs, and arrays have been not super hard to learn, not super easy either- just in that middle spot. I still have more to learn about them, but I'm getting there. Enums are definitely harder to grasp how to use them in a practical way, but they're not terrible.

Conclusion

Overall, Rust seems pretty awesome! The book is very helpful, as well.

Honestly, from what I've gathered, I don't really think it's harder to learn than say, C or C++ would be. it may even be easier- but I can't really say, since I don't know those languages. I will say though, it seems like all the problems I've ran into so far have to do more with statically typed languages than Rust itself.

I hope this will be insightful! Let me know if you have any questions, I'd be happy to answer them! : )
Again, mileage may vary

[blonk]

@FivelFox

Aside from the things I already knew (variables, functions, and loops mostly) , ownership was by far the easiest concept to understand. It's super straightforward and it's one of the few things in programming that just makes sense to me.

This is fascinating to read. To me, as a long-time programmer, I knew what the borrow-checker was trying to do and while I did appreciate it, it was definitely making my life harder.

I imagined that I would never have been able to appreciate the borrow-checker without that initial struggle, but reading your take on it I realize that the initial struggle isn't really necessary -- it was just my brain having a difficult time letting go of the C/C++ "do whatever you want [but we'll implicitly sprinkle in a few foot guns here and there]" philosophy.

[VorfeedCanal]

That's something that I had no way to verify (for the lack of newbies willing to learn Rust before other, “more traditional” languages), but suspected for years now: it's structured programming all over again.

I.e.: ownership and borrow system is not intrinsically harder to learn and use than loops, ifs and functions… except today people are using loops, functions and ifs naturally in most existing languages while ownership-and-borrow system is Rust exclusive thing.

This leads to what was observed when structural programming was initially introduced:

Us converts waved this interesting bit of news under the noses of the unreconstructed assembly-language programmers who kept trotting forth twisty bits of logic and saying, 'I betcha can't structure this.' Neither the proof by Böhm and Jacopini nor our repeated successes at writing structured code brought them around one day sooner than they were ready to convince themselves.

P.S. I only hope Rust would get more newbie-firendly sibling like outlined in these articles: first, second. Because ownership and borrow system is easy to use and logical yet some things in Rust (especially around async) are quite complicated and while, maybe, are Ok and justified for low-level close-to-metal programming languages they are not bringing much to the application-level programming.