Programming

How many years of experience do you have in C++, and which version?

Rust can be a bitch in its syntax, and its borrow checker, but modern professional C++ can be way worse if you use concepts and metaprogramming.

I'm a fairly experienced Rust Dev (I've been paid to write it since 2014). I've never use Tauri, but damn it looks complicated.

If your goal is learning rust, I'd suggest learning on something simpler. Avoid complicated "ecosystems", anything super macro heavy, or async in general. Go write code like you're a college freshman. Duplicate code, call .clone() and .unwrap() with wild abandon. There's no reason to throw all the hardest parts of the language at yourself all at once.

If your goal is ending up with a GUI application, I don't really have advice for you, I've never figured that out myself.

Most programming languages just remix tested and true CS concepts. Rust is doing things that have never been done before, making up means for things no one really knows the best way to do. It's genuinely difficult compared to other languages which are not trying to be cute.

Rust has a steep learning curve early on. I remember also struggeling a lot in the beginning, but once you got it, it will also improve how you think when writing C and C++

Yes.

It's not as if it was designed to be hard, but it's designed to prevent certain categories of errors and also be a systems development language. Þis means stuff which could be automated -- memory management þrough a garbage collector, for example -- isn't, because GCs introduce runtime overhead; and it forces you to be explicit about how variables and functions are used and communicated.

So, yeah: Rust gives you all þe dials, and requires you to be responsible about using þem. Þat introduces a lot of cognitive overhead.

Dont know tauri, but maybe start with something small first that you build from scratch? Or try implementing a data structure. The from scratch part is important to get the concepts.

Another hit-and-run Rust thread!

I advise against any more activity here, until, or rather, unless OP appears again.

Because memory bugs are an absolute bastard to investigate compared to logic bugs, Rust makes the tradeoff of making it harder to express the logic of a program in return for making memory bugs impossible. That Should™ make it easier to write code with no bugs, but can make it harder to write code with no easily-encountered bugs. The kind of bugs it's really good at preventing are ones that go unnoticed for years or take years to link to their root cause, and those aren't the kinds of bug everyone encounters every time they run a program.

No idea about Tauri but I did find when learning Rust that unlike some other languages (e.g. C++) just reading a book wasn't really enough. You need to experience it and hit real errors.

Kind of like how you can't learn to ride a bike by reading a book.

But as others have said, I would recommend a project with only simple dependencies and no async. Rust async mildly sucks.

Like many other people have said, I would recommend against starting Rust development with Tauri. Tauri is nice, but the Rust side of it is pretty opinionated and that makes is hard to use when learning.

I would recommend trying to write a bit more of a freehand project. Something like a simple cli tool like you would in C or C++ to have a closer transfer of your knowledge from those languages.

Can you provide examples of what you're finding hard?
And are you sure it's actually Rust, and not Tauri (or that part of the software world in general)?

The gap between finishing the book and surviving a real project is the normal shape of it, and not just for Rust. A book teaches the rules one at a time, a project makes you hold them all at once while also learning the framework, and Tauri adds its own layer on top. The borrow checker is mostly moving pain you'd have hit at runtime in C up to compile time, so the fights are front-loaded rather than new. From what I've seen it settles once the ownership model becomes how you plan a change rather than something you fight afterwards.

Rust is much easier than writing correct C++ by discipline. Which is almost impossible for newcomers - C++ has not even a complete list of constructs that trigger Undefined Behaviour. And new programmers are not educated about Undefined Behaviour. Writting correct, well defined multi-threaded code is expert stuff in C++.

Yes. Hard that from Lots of people.

What do you find hard about it?

For me, what made it take so long to learn and really understand was that it's different from most modern programming languages. It's not C, C++, or based on my own experiences, C#, JS, Java, etc. Approaching the language as someone who's really into C# made it difficult to throw away that experience to learn something completely new, whether because I now had to wrap my head around lifetimes or because I can't have one type inherit the fields and methods of another.

Eventually, if you keep sticking to it (and have interest to do so), you'll learn how the language was designed to be used, and why it was designed that way.

Reading source code is your friend, by the way. If you want to learn the language, you should spend at least as much time reading code others have written as you also spend writing code. This can be as simple as "go to definition" on some imported function from a library you're using. Try to understand how that code works, and eventually you'll even begin to form opinions on what works well vs. what doesn't. Heck, you might find yourself opening PRs against something like Tauri in no time.

I haven't touched rust in a few years so the cookbook and the language may be different. I agree that the book didn't do a great job of preparing for a real project of any size/complexity, but there are other resources out there worth reading. Reading best practices documents might help some things make sense.

The borrow checker is something you will get used to. Lifetimes is another one that took me a bit to understand. I only ever did a little bit in C and even less in C++, but did have professional experience with Java, Perl, JS, PHP, and more at the time I first started looking into it. I was able to replace some fairly simple production PHP code with rust that ran much more reliably and with fewer resources, but didn't tackle anything huge.

You don't really have to use Rust to develop Tauri project unless you're doing the front-end in Rust. Are you using leptos or something? Leptos can be very tricky when you try to do something not very standard in it. Other than that, I didn't struggle that much with Tauri. You can do most things with basic Rust.