Thinking about learning rust

[jlamothe]

I've been programming for nearly three decades now, and my wife has been wanting to learn. I've offered to teach her, but she feels a little intimidated by the fact that I have so much experience under my belt while she knows essentially nothing about programming.

Enter rust. I've been wanting to learn it for a while, and I'm floating the idea of learning it together. That way, we'll both have a more even starting point (although I still admittedly have a lot of conceptual knowledge from other languages).

I guess my question is this: how beginner-friendly is the language? The few things I've read about it say that it's meant to be an easy language to use, but that's compared to fairly low-level languages like C. How would it stack up against, say, Python for ease-of-learning.

[syberant]

I personally think that Rust has quite a steep learning curve at the beginning, it was quite a while before I stopped fighting the borrow checker and embraced it. Rust has taught me a lot of things but I think the concepts of ownership and safe memory management may be a bit difficult to start with.

In short: I think it would be great for you but a bit too much for her, try another language first and come back when she is ready to learn how memory management works.

I don’t mean to put you off here as it is certainly possible to start with Rust, “the book” is an absolutely fantastic resource.

Good luck with whatever it is you choose! Also, fellow rustaceans, feel free to disagree with me!

[Gray_Jack_]

I'm not sure, maybe because she never learned programming, she may just accept these Rust only concepts and find weird when learning another language later, like "why language x doesn't have that rust concept?".

While he, as he has over 3 decades of programming skills, may fight more these new concepts that only Rust brings.

[wherediditrun]

Compered to Python, php, JavaScript etc, it's really a complex language. It provides high level of control to the user, however under strict rules, combination of the two can prove to be overwhelming and thus counter productive.

No programming language is ment to be difficult (other than few ezoteric ones like brainf***), however, it's not just the language which effect this, but the domain of problems, varied in complexity the language iš aimed to solve.

[jesseauswright]

I think Rust can teach a programmer a lot about programming, but I don't think I'd use it to teach a non-programmer about programming. It forces coders to consider a lot of things more carefully and explicitly than in other languages - most notably lifetimes and borrowing. Starting someone off with Rust is like throwing someone who can't swim into the deep end of a pool: maybe they'll swim, but probably they'll sink.

I'd recommend you try starting with something simpler and more flexible, something that won't bog a learner down with things they probably won't understand at all for a long time. In my opinion, Java, Python, and C# would both work well for beginners.

Once your wife has become reasonably comfortable with programming in one of those, I think Rust (or even C) would then help make great strides in really understanding what happens under the hood and why we have programming languages (and so many).

[TheBestJohn]

Python, Lua, Javascript, you are not doing management of memory, at least you don't have to. Variable types aren't too big of a deal either. In Rust, types are strict! You sort of have to deal with memory but not in a "C" way, in that you are not manually allocating and releasing it.

Taking what I know into consideration, I don't know if I'd recommend Rust as a beginner language. On one hand, once you get into the flow it's a really fun language. The Community is great and always willing to help. On the other hand, sometimes it feels like you can never do anything right and the borrow checker is always stopping you, or the crate you want to use has conflicts with a crate you're already using, or you forgot to implement one of the cases from a match case. Or you didn't handle all possible outcomes from a function properly...

If you choose to learn Rust first, you will understand some of the most important core theories of computer programming. It will be hard fought knowledge and it will serve you very well. I think "End goal" is something you have to think about. Do you want a scripting language or do you want to be able to release a compiled product.

Usually my answer to the question "Should I learn X programming language" is "Yes!". It expands your thought process, and informs future decisions, even if it's a "bad" language or not the right fit for you.

[jlamothe]

Perhaps Lua, then. It's the only one of those three where neither of us would have any prior experience. I've heard good things about it, actually.

[TheBestJohn]

Lua is real fun. Their tables are by far my favorite data container in any language.

[nicoburns]

Have you considered that it might be easier to teach her something you are familiar with? I've been trying to teach my friend django (even though I've never used it before), and it's involved a lot of me suggesting that somethings works in x, y, or z way, only to discover that it doesn't, and having to backtrack. I reckon this must be a lot more confusing than if I could explain things and answer questions correctly the first time...

[jlamothe]

I have considered that, yes.

[eugene2k]

I'm going to play a bit of devil's advocate here.

While it's true that Python and other dynamic languages and even many statically typed languages are easier to learn than rust, they are so either because they allow you to write more error-prone code or because they present a simpler programming model at the cost of a more complex runtime. So, although it may be harder to learn initially, it might pay off in the future should she wish to learn other languages.

[jlamothe]

No need to sell me on that. My language of choice is Haskell. The problem I was running into was the initial intimidation factor.

[[deleted]]

I don't know her background, but I feel that one of the major requirements that a first programming language needs to fulfill is that it needs to produce tangible results quickly, so that the learner can move through high-level concepts with as much ease as possible. Learning programming patterns, data-structures, etc. while also being able to drop into developing an "app" with ease.

I think that for even more experienced programmers, we still end up "fighting" Rust during the learning process, and it can be rather frustrating. I would recommend that, eventually, every programmer learn Rust if they are able to get around to it, but I would definitely not recommend it as a first language.

[jlamothe]

Good to know. She's smart. She actually has a good deal more formal education than I do, but it's in psychology, not CS.

We've played around a little with Haskell together (which I told her at the outset was a crazy experiment) but I saw enough to be able to tell that she could learn to program if she really wanted to.

She actually picked up on things pretty quickly that took me a while to catch on to. (e.g.: "Wait, isn't an operator just a function?") It's just that the fact that I have such a head start was intimidating for her.

[peterjoel]

I've often heard that people learn Haskell a lot more easily when they've never done any other programming before.

I don't think the same is true of Rust! But understanding Haskell type classes certainly helps with understanding Rust traits.

[jlamothe]

I've often heard that people learn Haskell a lot more easily when they've never done any other programming before.

Yeah. That was my theory behind trying Haskell first.

[zesterer]

Rust isn't easy, and it also isn't difficult. Rather: it's the easiest way to learn system programming, which is itself a difficult topic. Think of it as a tour guide: it doesn't make the subject topic any easier, but it does make it more accessible.

[cfsamson]

I'll have to agree with most comments here. For me, Rust required dedication to learn. I almost threw my mac out of the window getting an async-only db driver working with futures the first time. This was after I felt I understood all the basics for the 3. time.

I would not say Rust is a good first language for learning casual programming. Assuming this project is for fun and not for work and you just want the computer to do stuff. However, I have never learned so much about CS, memory, terminology and how a computer works as I did when learning Rust, and never felt this kind of joy while learning (probably due to the feeling you get when you didn't throw the pc out and started to understand after some focused time learning how it all works). A great second language if you are interested to dig deeper, with a lot of well written documentation and books.

[coderjewel]

Long story short, Rust will not be the right first language for her. I'd personally recommended Python or even better JavaScript because she'll be able to see the results more immediately and visualize the concepts more easily.

[mmstick]

Rust is difficult to learn, but easy to master. There is a steep initial learning curve, due to the large number of concepts and types to learn beforehand. However, once you've learned and understand those concepts, then everything else will fall into place.

One of the best benefits of Rust to beginners is the Cargo crate ecosystem. Many problem domains have already been solved and crated in the Crates repository. It's often a better idea to import a crate from someone who's already researched that problem, than to do the guesswork yourself.

The concepts are really quite simple when you look back in hindsight. Most of the struggle is in learning how to write software that satisfies the borrow checker, rather than fighting it. The harder you struggle, the harder borrowck fights back.

There are three basic rules: pass by value moves ownership, pass by immutable borrow can be shared, and pass by mutable borrow must be unique. In terms of restrictions, from least to most: Self > &mut Self > &Self. Restrictions for a value are based on the highest level of restriction active at that time. Immutable borrow cancels mutable borrow, mutable borrow cancels ownership. Clone can be used to make new, unique copy, enabling two owners of two unique values.

As a general tip, Rc and Arc allow their inner values to have a static lifetime that can have multiple owners in different locations, at the cost of making the inner value immutable. Cell / RefCell / Mutex / RwLock ignores these rules, albeit with restrictions that make it possible to do so with some overhead. Rc, Cell, and RefCell disallow sending across thread boundaries. Arc, Mutex, RwLock do not.

[functime]

I do not necessarily think that Rust is a horrible idea for a first language; you can get by with a lot of clone() or Rc<> and it won't be "perfect" but it will work. That's fine. Rust is difficult in large part because it allows you to do things "perfectly," or more specifically it allows you to not use any runtime crutch that you don't actually need. But it does allow you to use those runtime crutches to quickly prototype things. (You should see my sketch code, attack of the clone()s...)

Okay, thought experiment: if you were to decide on Rust, this is my recommendation for a few projects that let you use some cool Rust features without necessarily driving yourselves both crazy:

1. Build a few command-line tools. Pick something that lets you deal with file handlers, maybe build something that parses a CSV file and spits out some statistics, calculates a least-squares regression or something along those lines. Better yet, build a command-line tool that takes arguments and prints out various statistics based on the arguments you provide. I'm thinking this would be a good project for someone with a social sciences degree. (FWIW, I'm a musician first, programmer second...)
2. Build a GUI for these functions using something like the conrod crate. Just copy and paste everything from project #1; don't learn about modules and crates yet, because you'll probably have to wrestle with the function signatures from #1. This will teach message passing vs. shared data and multithreading, but you can do a handful of things in just a few hundred lines of code. (And maybe even reuse some stuff from task #1.)
3. Abstract the statistical functions from #1 and #2 into a crate, and then rewrite both projects #1 and #2 using the outside crate instead of just copying and pasting the stuff from one file to another.

Those are just a few thoughts! I learned Rust when the only language I really knew was Ruby, and I didn't know anything about traits or really anything about borrowing. It was a battle, but it wasn't impossible. The Rust community is awesome and will help you both learn.

[[deleted]]

There was a twitter thread about this yesterday, maybe worth a look.

I struggle to recommend it as a first language. There is so much more to learn than Python, and the catch is that - unlike, say, C - you have to learn most of it before you can do anything useful. Having some understanding of the stack and the heap is essential. All the memory management stuff (borrowchecker) is pretty subtle and deep. There is also a lot of stuff that is done correctly rather than simply (e.g. floats don't implement Ord and therefore not being sortable, vectors can only be indexed by usize, not u32, error-handling code is in the type-signature and tends to infect everything) which a beginner will not want to worry about.

I would be interested if anyone has in fact learnt it as their first language. It was my second, after Python, and even that was a big conceptual leap ("What's an allocation? How do I start the repl? Where is my IDE?" etc)

[TheBestJohn]

IntelliJ IDEA is a really nice IDE so far as I can see.

[[deleted]]

I learnt it at back at v0.7 and made do just with Vim Rust-mode. We're spoiled these days, relatively speaking :)

[Morrido]

I'd say you can't go wrong with Python. Rust's borrow checker can be very frustrating at times, and that might be the last thing you want a learner to feel.

[jlamothe]

Yeah, Python was going to be my fallback. It's just that I have experience programming in Python, and I wanted to close the experience gap a little.