I decided to adventure myself in Tauri development for a personal project, I read the entire Rust official book and followed the exercises. When I first started developing it was like if nothing I learned helped for real life projects.
Now after getting betting up every single time I touch my project, it seems I’m catching things slowly.
But I’ve never seen such a hard modern language, I used C and C++ before and it’s incomparable.
What about C#?
Can it be used to develop for Linux?
Yes. Dotnet is multiplatform and has been for many years now.
I mean, I got Linux running on a literal toaster. So imma go ahead and give you an affirmative.
Another hit-and-run Rust thread!
I advise against any more activity here, until, or rather, unless OP appears again.
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.
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.
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.
avoid async
Lots of networking libs are bases on tokio. I found it super annoying.
There are more async runtimes, and imo many crates support other runtimes. it’s worth getting some experience with it, anyway
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.
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’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.
I mean, I don’t think that is a big issue, most of the time you don’t need self reference, and when you absolutely need there is a way even if not very simple one
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.
I 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++
if it’s a hobby project you might check out zig, it has a lot of safety like rust but much simpler. just be aware major changes can happen as it’s not a 1.0.0 release yet but from my experience their change guide is really thoughtful and lists any breaking changes and how to upgrade.
If 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?
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 lightweight 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.
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.
A fake sense of security by pretending that simple apps that don’t expose low level interfaces and use wrapping libraries for all parts of networking need to be implemented by-design memory language, or for people who just like rust.
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.
You’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.
You answered for OP here.
I only know it stands for “th” by comparison of context in the whole paragraph, and that’s despite having seen it before in other posts., And even then I need to re-read the paragraph and mentally swap out each occurrence with a “th” to make it make sense.
Maybe 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.
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.
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…
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.
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)?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++
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.
