JohnHammerSkyIs Rust supposed to be that hard?
slacktoidIts more of what do you want out of a compiler.
manning.com/…/learn-rust-in-a-month-of-lunches
A great analogy for Rust is that of a critical but helpful spouse.
And I kinda agree with that. Maybe a little excessive but when you’re done you have a much more likely to not hit a segfault
How many years of 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.
TheTechnician27I’d also add that the borrow checker, to me, has a grossly overexaggerated difficulty/annoyance. It follows a simple set of a few easily learned rules, and in my experience, if you break one, it’ll tell you which and where. I feel like the type of C/C++ programmers complaining about it are mostly the ones that have mountains of hidden memory etc. bugs in their C/C++ code that Rust actually makes them clean up.
Edit: Another class I find are those who kind of just feel out the borrow checker blindly without sitting down for 20 minutes to learn how ownership works.
It depends what you’re trying to do. Some data structures inherently do not work comfortably with a single-mutable-ownership model, and while they’re not exactly ubiquitous, they’re common enough. (My exposure to rust is through advent of code where they’re more common than in the real world).
Rust doesn’t make it impossible, but you need to convert everything to Rc Refcell and there’s a load of annoying crusty boilerplate, so it is more difficult. And yes, the guards in those calls can prevent or expose nasty errors, but a lot of the time - in a simple app you’re writing to learn the language - the logic that keeps everything safe is so simple that an experienced programmer doesn’t even think about it, and then it’s confusing because it’s not clear what you’re being protected from :)
Do you really need that much Rc? That is, do you really need multiple ownership for a piece of data in a single thread? It is rarely the case, many times you can get away by just borrowing that data.
ARc is harder to avoid, since across threads you often really need the multiple ownership.
Next is, do you need RefCell? Or would a simple Cell in some of the struct fields be enough?
I recently picked up embedded in Rust and I often stumble upon the pattern of taking buffer references into structures, and I would want to pack the buffer and the struct that uses it together, but I don’t want to do self referential magic, so for now I keep buffers passed around everywhere
Yeah. That’s a huge issue rust has. However, it can’t be solved with Rc.
You either do it in safe rust, by “cheating” the borrow checker and storing a size offset of the buffer instead of a reference. Or just use unsafe rust and store a raw pointer alongside the buffer.
No I’m not professional, maybe I’m mistaken. I just know C++ and made a few simple things, and then I tried to do a few simple things in Rust but it’s almost killing me. I’m asking myself if it’s worth it.
Lucy :3If your code touches sensitive stuff (eg. public networking) and needs to be low level, probably Rust (or another compiled memory safe language). Otherwise, just use C++.
But then what’s the point of Tauri? I mean there are plenty general use projects in Tauri, why’d they chose Rust?
Once you’ve learned it, Rust is just a very nice compiled language to work with.
You get higher level constructs than in C++, a language without a billion weird edge cases, a modern package manager, and much more. In my experience, my code written in Rust is more likely to work as intended, both because of the stricter compile-time checks, but also because language features like sum types make it easier to check the core logic at compile time.
I work in both C++ and Rust, among other languages, but these days I never reach for C++ for a new project
Tauri is for using webtech with rust irc.
So if you want to use rust in combination with JS frameworks like reakt you use tauri.
Do you really need tauri?
Tauri is for web devs that want to make GUIs with web tech in rust. You can do GUIs without web tech.
If you really want to make a GUI with rust, you can use iced.
If you just want a GUI with web tech, do it in JavaScript+html.
If you want a GUI without web tech and don’t care the language, use a GUI toolkit for your preferred language.
Learning a GUI toolkit is hard. Learning a language is hard. Learning both at the same time is even harder than the sum.
Tauri provides native system plugins cross platform, that’s what I want, paired with the fact it doesn’t bundle Chromium, apps are lightway and fast.
You can use Tauri with Iced too, it doesn’t require web tech, the strong point of Tauri is the native system modules.
I thought about using native tools only but I’m planning on supporting Linux and Windows at the same time, so that’s the appealing for me.
I don’t know what kind of a GUI you’re building, but there are simpler options than Tauri out there. Slint comes to mind.
The GUI isn’t important to be honest, just anything that doesn’t look too outdated. I’m more interested on cross-platform native plugins, so I don’t need to write all by hand. Slint seems to be less libre than Tauri, there are pricing on their website, even tho I understand it’s free, still, I prefer to keep it away from strongly backed by individual company, especially if I don’t know it well.
“plugins” is not a feature. What plugin specifically do you need? Most probably you can accomplish whatever you need with a library and iced. Plugin is just a fancy word for library.
Plugin are a feature when it provides cross platform abstraction for Windows, Linux, Mac, Android and iOS.
Doing it natively means I need to make a few thousands of extra ifs and maintain all different ifs for each platform, while Tauri provides it out of the box. Such as notifications, filesystem access, file opener, auto start, window management and etc…
There are plenty of cross-platform libraries in rust. In fact, most of them are. Since Rust is cross-platform at its core.
You probably mean general purpose libraries, when it comes to libraries that need to interact with OS native APIs Tauri does the heavy lifting by implementing for alç platforms including Android and iOS.
I mean every language is cross-platform at its core, even Node, but for more complex calls things get really tricky.
Go to crates.io, search for whatever you need. Most probably it will be multiplatform.
MikinaI think that is kind of the main point of Rust, though.
It’s pretty easy to make something in C++. But it will very probably have a lot of hidden issues with memory, undefined behaviors and the like. Rust doesn’t let you make those mistakes that much, and forces you to do it correctly and securely the first time, which is why it is harder to get into.
They are mostly harmless and may never cause problems for you, but that’s how you get critical RCEs that are 8 years old in a software that’s now widely used.
If you don’t need this kind “ease traded for security”, in my personal opinion I’d go with Zig instead.
It’s worth it because it’s not C++. If I could, I would get a job writing Rust. Or Zig as that other guy said. My shitty opinion:
- Zig <-> C
- Rust <-> C++
x74sysWhat 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.
thingsiplayMaybe the problem is, that you try to learn and use everything at once. Rust is not easy and it has lot of stuff to learn and get good at. And compared to many languages, Rust has a few set of core features that makes it more complicated to understand and also you need to learn the basics before getting started. So just doing the exercises is not enough. My advice is to write simple programs with a focus of specific set of language features and what you want to accomplish, before doing the more advanced stuff.
The difference to languages like C++ is, that Rust forces you to do the homework before running the program, not after. That is the reason why it looks to be “harder”, but I think this is one of the reasons why its so misunderstood. In example if you MUST think about all possible states, variables and errors in a program before it runs, then you have to put so much work for this. In the end, you did all the work and the program should theoretically better than if you did not have. Compare this to other languages, where you can run the program simply by ignoring errors, all states a program can be in and be done in short amount of time. That looks easy. But in reality you didn’t do all the work.
This is actually an interesting answer. I am in the process of reading the main book as of now and I can already feel it won’t be enough. I did find out recently about rustlings and that is actually quite nice to have a feel on the language. I do think however more is needed, and as you mentioned, doing small programs should help. Problem is: where to even start? I find incredibly hard to have ideas on things to do on the smaller scale that are good for learning opportunities.
Also another thing I am equating to do is to actually just read existing working code of some Foss project. I still didn’t find one that is good to already see patterns and other nuances, but if someone knows that would be very helpful.
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.
Yeah, for folks with previous programming experience, I generally recommend the Rust CLI book, particularly the first chapter
It makes you build a small, usable program and shows you concrete ways to handle some intermediate topics, like error handling, unit tests, bundling etc…
AnyOldName3Because 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.
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.
azdleI’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.
Ŝan • 𐑖ƨɤ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.
Thank you for the comment, it was very helpful to me. Why do you use that symbol for “th” in your comment? Just curious.
clifYou’re one of today’s lucky 10,000!
… Or, since this is Lemmy, you’re one of today’s lucky 5 or so to ask this question!
It’s a Lemmy rite of passage, congrats.
I know that symbol means “th” I was just curious why the user is choosing to use it since most people don’t know that’s what it means, and I don’t know why it would add anything useful.
I can’t answer for OP here, but the explanation I often see on Lemmy is “poisoning/messing with the AI web crawlers”
This makes a lot of sense, thank you.
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.
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.
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.
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.
Another hit-and-run Rust thread!
I advise against any more activity here, until, or rather, unless OP appears again.
It’s not limited to Rust but you’re right. OP asks a question, provides no info, does not answer, and disappears. It’s weird.
What about C#?
Can it be used to develop for Linux?
I mean, I got Linux running on a literal toaster. So imma go ahead and give you an affirmative.
MoonRaven
nek0d3r