519
Redditors, how do you like Lemmy?
(beehaw.org)
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
this post was submitted on 12 Jun 2023
519 points (100.0% liked)
Technology
37716 readers
349 users here now
A nice place to discuss rumors, happenings, innovations, and challenges in the technology sphere. We also welcome discussions on the intersections of technology and society. If it’s technological news or discussion of technology, it probably belongs here.
Remember the overriding ethos on Beehaw: Be(e) Nice. Each user you encounter here is a person, and should be treated with kindness (even if they’re wrong, or use a Linux distro you don’t like). Personal attacks will not be tolerated.
Subcommunities on Beehaw:
This community's icon was made by Aaron Schneider, under the CC-BY-NC-SA 4.0 license.
founded 2 years ago
MODERATORS
It's looking great! I joined just 2 days ago and the communities I subscribed to are already looking much more lively today. Thanks, Reddit blackout!
Also written in Rust, btw :)
Weirdly enough the fact that it’s written in rust is why I am using it instead of kbin (PHP)
What makes rust so special?
God damn! Okay now I'm fully behind it
Fast because it's pointer-based like C, but better because it's memory safe, which means it won't crash, leak or mysteriously overwrite it's own data constantly.
I'd say that it's fast because it's compiled to machine code and doesn't use garbage collection. But I see what you mean with "pointer-based".
Is there anything with no garbage collection that doesn't work with pointers? If the compiler is handling all the memory allocation for you it might as well just collect garbage, so I figured they were kind of synonymous.
Since we're now going into details, Rust is neat because they figured out a way to keep track of the memory safety of pointers at compile time. That's hard to do, which is why it's a new language and not the old standard.
I would argue that on the one hand you could say that the references to objects in garbage collected languages are also pointers.
On the other hand, you could argue that such references are not pointers, but then you might as well argue that references in rust are not pointers.
I just feel like "a language with pointers" is a weird way to describe a language and it isn't really something that causes the language to become fast. Pointers are low level constructs that are used all the time, and whether or not they are abstracted away in the high level language doesn't automatically make it slow or fast.
Hmm. Alright, what word would you use to differentiate C or Rust from, say, Python? I haven't actually made anything with Rust, but it sounds like you can store a reference in another structure like you can in C, but you can't AFAIK in Python.
You can store references in another structure, but you probably don't want to do this most of the time, since it's a major headache to get ownership and lifetimes right. You shouldn't think of references as pointers, but you should think of them as "borrows": you are temporarily borrowing something from the owner, but you can only do so if the owner exists. So you need to statically guarantee that for as long as you borrow it, the owner must be alive, which gets tricky when you store that borrow somewhere in some data structure. In practice, references or borrows will be short-lived, and most operations on data will be done by the owner of that data.
Underneath, references are represented by pointers, but you shouldn't think of them as pointers, but rather as something you have borrowed, so in that sense it's different from C.
Also, Python does use references everywhere, it's just implicit, and depends on the type. Try storing a list in a class: you've just stored a reference to another structure. Most things (e.g. lists, objects) are passed and stored by reference, some types like integers are copied. In Rust, you can choose whether you want to pass by reference, copy or move ownership. At this point we're still at a high level of abstraction, we don't think so much about whether this will be pointers at the low level.
But my main point is that whether you use pointers, references, or whether it's implicit or explicit doesn't make a language slow or fast, it just defines how programs are written. Rust is very fast because it's compiled to machine code and doesn't do garbage collection or have any other overhead from a "runtime". Python is relatively slow because it's interpreted. You could argue that more manual control over references/pointers can make a language faster, but it's not the main contributing factor.
I guess I could just say "Rust isn't garbage collected" but I feel like that would be meaningless to someone who doesn't think about compilation. I gravitated to manual pointer/reference control because that's the part you can actually see in the code, and it's pretty closely connected to the lack of garbage collection.
While I have your ear, "who" exactly are the owners in Rust? So far I've come to understand it from the aliasing XOR mutability perspective.
When you create an instance of a struct and assign it to a variable or field of another struct, that variable becomes the owner of that value. When you assign it to some other variable or pass it to a function that takes ownership, ownership will move. Otherwise, you will borrow. But there will always only be one owner for each value. That way you know exactly when to free up memory: whenever the owner is dropped.
So then when you say "most operations on data will be done by the owner of that data", do you mean ownership-taking functions? In my head a variable is like a bin, so it's odd to think of it doing anything "operations" other than holding.
No, I phrased that poorly. What I meant is that if you have a struct that has some field (it owns that data), your operations on that data will be methods of that struct, and not some other struct that happens to have a reference to that struct. The latter is something people tend to do in OO languages like Java. In Rust, if a function accesses data, you usually "freshly" borrow from the owner of that data and pass it as argument to that function instead of relying on some "hidden" references somewhere in hidden in an object. Borrows will almost always be short-lived.
I don't know if any of this makes sense, I'm sorry for the bad explanation. It might make more sense if you play with Rust yourself.
Rust is a very good language but is relatively new on the scene so it has to compete against other languages that fit the same niche(primarily C++) that have been around a lot longer.
Rust has been very popular for hobby projects for a while but it's still pretty rare to see it for larger projects, and you still almost never see it for enterprise projects. So it's cool seeing an app that uses it blow up.
It should be noted that while Rust is rarely used, some very big players are pushing it. E.g. last year Microsoft Azure's CEO tweeted that "it's time to halt starting any new projects in C/C++ and use Rust for those scenarios where a non-GC language is required", Windows contains some Rust code now and the Linux kernel also supports Rust in addition to C since December.
There's a bit of a groundswell, where I've seen young devs try to push an organisation that they're working in towards Rust. This is usually a terrible mistake because it means you'll be forcing all the other devs to maintain your Rust code.
While I lean more towards Go, I have found that any Rust project that actually reaches maturity tends to be amazingly well built.
It might be a side-effect of Rustaceans on average being good programmers, or maybe the language itself just lends itself to robust, high performance software. Who knows.