Rust programs can definitely still consume a lot of memory. Not using a garbage collector certainly helps with memory usage, but it’s not going to change it from gigabytes to kilobytes. That requires completely rethinking how things are done.
That said I’m very much in favour of everyone learning Rust, as it’s a great language - but for other reasons than memory usage :)
Or just use rust for everything with Dioxus. At least, that’s what Dioxus is going for.
This is the way with modern software engineering, especially in the industry. It comes from the basic fact that:
Basically they want to eat their cake and have it too. This applies to all modern package managers for modern languages that make it easy to distribute your own code and consume free online code.
I doubt the industry will ever mature to a point where this will stop, as the tradeoff of getting free code with no work is just too good for most companies, especially the smaller ones.
Have you tried the Rust book? I learned via that and it’s great.
I think that’s quite harsh. As I said, I know it’s not what OP asked and it was just a suggestion. I’m just adding it as an option. Perhaps someone else reading the thread will find it useful, if not OP (who I don’t think you should speak for).
OP mentioned they want native speed and were struggling with badly documented libraries. I feel like it was appropriate to at least mention Rust, considering those two things. Since when is widening a discussion slightly considered bad? You don’t have to reply to my comment either, if my comment does not seem interesting to you. Let alone downvote it. You can just leave it alone, it doesn’t hurt anyone.
Not that cool maybe but I once played a lot of Pathfinder (1st edition). I made a website with a detailed database of all the items in Pathfinder with very specific filters and also including a random item generator. You can try it out here:
I know it’s not really what you’re asking, but have you considered learning Rust? In many ways, Rust is more similar to C than C++ and is just as capable. There are quite a few very well documented (as is common in the Rust ecosystem) Rust libraries for GUIs, including efficient native ones or immediate mode ones and such. Just a suggestion.
I think you’re misunderstanding the never type. The never type is not a hack at all. It’s a very natural part of the type system. Just as you have the unit type (), which is the canonical type with only 1 value, you also have the never type, the canonical type with 0 values.
This is extremely useful in generic code. See my other comment in this thread.
This is an unfortunate wart to appease a desire to those that want to be able to write code like they do in legacy languages
What do you mean with this? I can’t really decipher it. What alternative to the never type would you want?
shouldn’t Rust enforce returning from function
This is impossible. How would you enforce that? What prevents a function from panicking, aborting the whole process or just going into an infinite loop? All these things correspond to the never type.
I think you’re misunderstanding what the never type is. It’s not equivalent to None at all. It’s a type that doesn’t have any values. This is useful in situations with generic code where for example an error type can be chosen as the never type. Then you could destructure or unwrap a Result without handling the error, cause the type system guarantees the error never occurs.
I think you should read up on the never type a bit more. It’s a perfectly natural part of the type system. In fact you can make your own very easily: enum Never {}
Can’t wait for the never type to be stable :D
Anyone got experience with every.org compared to Liberapay? Been pretty happy with liberapay myself, just curious.
Eh rust still has issues in some domains, e.g., when cyclic data is appropriate
This might be but then again I’ve been writing Rust for several years and have yet to actually run into this problem. The borrow checker definitely places certain restrictions on what kind of stuff you can do (for good reasons!). Once you know how it works, your brain starts writing the code in advance to fit how the borrow checker likes it and it becomes second nature and a total non issue.
Of course this is part of the reason Rust has a bit of a learning curve, which is fair. But any good sophisticated tool meant for professionals requires proper training and knowledge.
Eh, as funny as this is, I can’t agree that programming peaked with Java. In fact, much of this is just a rant about JavaScript, not about much else.
VSCode can easily do cross-file renames if you write Rust. Rust is kind of peak programming if you ask me, and it’s modern and still new. I don’t feel programming has peaked yet tbh.
I like the idea of using block labels, but I don’t like the ^ symbol. There’s already precedent for using keywords before blocks, like with async. There’s also already super let in nightly I believe.
I would say depends but generally I would think not? I mean say you clone a string because you move it in one place and also need to borrow it in another place. So you clone to avoid the borrow checker erroring out on that. As far as I know, there will be two different strings created with separate allocations and all (but I could be wrong).
Really not a fan of this approach. Makes the order of operations extremely weird. I would much prefer having super blocks that are explicitly inserted in the above scope. I.e. this:
tokio::task::spawn(async move {
do_something_else_with(
super { self.some_a.clone() },
super { self.some_a.clone() },
super { self.some_a.clone() },
)
});
Would desugar to:
tokio::task::spawn({
let first_block = { self.some_a.clone() };
let second_block = { self.some_a.clone() };
let third_block = { self.some_a.clone() };
async move {
do_something_else_with(
first_block,
second_block,
third_block,
)
}
});
Only problem is if the clone is inside another block… but perhaps you could do super super { ... }? But that sort of gets crazy and makes it very hard to read again.
My somewhat hot take is that design patterns and SOLID are just tools created to overcome the shortcomings of bad OOP languages.
When I use Rust, I don’t really think about design patterns or SOLID or anything like that. Sure, Rust has certain idiomatic patterns that are common in the ecosystem. But most of these patterns are very Rust-specific and come down to syntax rather than semantics. For instance the builder pattern, which is tbh also another tool to overcome one of Rust’s shortcomings (inability to create big structs easily and flexibly).
I think you’re completely correct that these things are dogma (or “circlejerking” if you prefer that term). Just be flexible and open minded in how you approach problems and try to go for the simplest solution that works. KISS and YAGNI are honestly much better principles to go by than SOLID or OOP design patterns.
Why do you say Leptos is more popular? Dioxus has more stars on GitHub.
I want a way to clearly express durations in terms of days
The argument here is that expressing durations in terms of days is a bad idea because “day” does not really convey a very precise duration, as it is not always 24 hours.
Maybe you won’t be confused by Duration::from_days right now, but maybe a junior dev before they get their coffee, or even the senior dev on code review might miss stuff like that.
I haven’t tried it myself but I’ve read the tutorials and it looks very React-inspired. It looks quite easy to pick up. It is still based on HTML and CSS but you can use one code base for all platforms.