5 ms·

Is Rust really high level?

by stolen_biscuit 6y ago

pasquinelli 6y ago
to me a language is low level if variables are memory addresses and flow is controlled with jumps.
sfkdjf9j3j 6y ago
I think you could make that argument, although it might involve using Arc<T> for everything
- TylerE 6y ago
  I wouldn't. Rust is WAY too much ceremony to qualify as high level.
amalcon 6y ago
Once upon a time, "high level" unambiguously meant higher than assembly language. A smallish fraction of the population still uses it that way.
eximius 6y ago
I would qualify a language as high level if you're not expected to deal with pointers in 'normal' use. Yes, Rust has pointers, but using them is NOT normal. C/C++/C#/D, etc are not high level by this criteria. There are also of course degrees to all this. Rust is lower level than a lot of languages by virtue of having native pointer uses, even if it's frowned on. There's also something to be said for language features, but I can't quite put my finger on it.
- catblast 6y ago
  The difference between pointers and references can easily become muddled. If you have a language with pointers that are non-nullable, type- and memory-safe, is that not high-level? I think a good real-world example that exposes the problem in your definition is Go. Go has pointers, using them is normal. However, go does not pointer arithmetic and outside of unsafe (like Rust) they are memory safe. I consider golang to be higher level than C/C++ for this reason, and many others (GC, channels, defer, etc, etc) -- I'd also consider it lower-level because of its non-answer/cop-out to error-handling. But what is special about pointers compared to references? If you have a language with pointers that are type-safe and memory-safe how is this distinctive?
  - eximius 6y ago
    I mean, even Python has references to variables. You can't escape references (as opposed to values). The difference is one of model. Pointers are an exposure of the underlying computer architecture. Whereas references are more of a property of common language design. In theory, you could not have pointers but still have references.
    - catblast 6y ago
      > Pointers are an exposure of the underlying computer architecture. Whereas references are more of a property of common language design. Sorry, I just don't follow. How are the pointers in Go more exposing of the underlying architecture than a reference? (I'm using Go as an example to make it concrete, but any language with similar properties will do). The syntax and some of the semantics of assignment and rebinding are different between say go pointers and python references, but that's the point I'm contesting, I don't see how one is necessarily higher level than the other. If you put automatic memory management, null pointer checks, removal of any "undefined behavior", pointers aren't necessarily low-level. It wasn't the pointer, it was the memory safety. I personally think that once you tease it out that it becomes a semantics argument that unfortunately doesn't shed much light on what is "high-level".
  - nyanpasu64 6y ago
    I feel that defer is lower-level than C++ RAII which happens automatically in destructors without manually specifying. C has compiler-specific defers, and you can emulate defer using C++ RAII (though clunky).
- mwindow 6y ago
  I disagree. Rust still requires thinking about low-level details like lifetimes, aliasing, whether/when to use `Box` or `Rc` etc., Even when these are not explicitly spelled-out sometimes (like in lifetime elision), the programmer still has to be aware of these. Plus, modern C++ also abstracts away raw pointers by your definition, and has `unique_ptr` and `shared_ptr` which are the same as `Box` and `Rc` respectively. Bare pointers are frowned upon in modern C++ too. Furthermore, the OP talks about languages high-level enough to be used by biologists, while maintaining an acceptable performance.
  - xyhopguy 6y ago
    Problems like the benchmark in the post are actually really simple to write in rust. They're all essentially streaming algorithms with some simple parsing. Fwiw rust has completely replaces cpp for high performant bioinfx code in my workflows. Sooo much easier to write than cpp!
- AndrewGaspar 6y ago
  Dealing with pointers in C# is not normal.
ginko 6y ago
Even C is a high level language.
Measter 6y ago
It can really depend how you write it. In some instances you can just throw things together and it can look a fair bit like you might write it in what many would consider high level languages. On the other hand, there are times when you really need to get into the nitty gritty of things for performance reasons, and it ends up feeling quite low level. For example, here's a Rust program which does the same as fqcnt_py1_4l.py: https://gist.github.com/Measter/d31abe88b5e318ba98856bf6f047ef19 https://gist.github.com/Measter/d31abe88b5e318ba98856bf6f047... It's longer than the Python version[0], I'm going out of my way to not allocate for every string. But, and maybe I'm biased here, it doesn't really feel like it's low-level code. [0] https://github.com/lh3/biofast/blob/master/fqcnt/fqcnt_py1_4l.py https://github.com/lh3/biofast/blob/master/fqcnt/fqcnt_py1_4...

Is Rust really high level?

pasquinelli 6y ago

to me a language is low level if variables are memory addresses and flow is controlled with jumps.

sfkdjf9j3j 6y ago

I think you could make that argument, although it might involve using Arc<T> for everything

TylerE 6y ago
I wouldn't. Rust is WAY too much ceremony to qualify as high level.

amalcon 6y ago

Once upon a time, "high level" unambiguously meant higher than assembly language. A smallish fraction of the population still uses it that way.

eximius 6y ago

I would qualify a language as high level if you're not expected to deal with pointers in 'normal' use. Yes, Rust has pointers, but using them is NOT normal. C/C++/C#/D, etc are not high level by this criteria. There are also of course degrees to all this. Rust is lower level than a lot of languages by virtue of having native pointer uses, even if it's frowned on. There's also something to be said for language features, but I can't quite put my finger on it.

catblast 6y ago
The difference between pointers and references can easily become muddled. If you have a language with pointers that are non-nullable, type- and memory-safe, is that not high-level? I think a good real-world example that exposes the problem in your definition is Go. Go has pointers, using them is normal. However, go does not pointer arithmetic and outside of unsafe (like Rust) they are memory safe. I consider golang to be higher level than C/C++ for this reason, and many others (GC, channels, defer, etc, etc) -- I'd also consider it lower-level because of its non-answer/cop-out to error-handling. But what is special about pointers compared to references? If you have a language with pointers that are type-safe and memory-safe how is this distinctive?
- eximius 6y ago
  I mean, even Python has references to variables. You can't escape references (as opposed to values). The difference is one of model. Pointers are an exposure of the underlying computer architecture. Whereas references are more of a property of common language design. In theory, you could not have pointers but still have references.
  - catblast 6y ago
    > Pointers are an exposure of the underlying computer architecture. Whereas references are more of a property of common language design. Sorry, I just don't follow. How are the pointers in Go more exposing of the underlying architecture than a reference? (I'm using Go as an example to make it concrete, but any language with similar properties will do). The syntax and some of the semantics of assignment and rebinding are different between say go pointers and python references, but that's the point I'm contesting, I don't see how one is necessarily higher level than the other. If you put automatic memory management, null pointer checks, removal of any "undefined behavior", pointers aren't necessarily low-level. It wasn't the pointer, it was the memory safety. I personally think that once you tease it out that it becomes a semantics argument that unfortunately doesn't shed much light on what is "high-level".
- nyanpasu64 6y ago
  I feel that defer is lower-level than C++ RAII which happens automatically in destructors without manually specifying. C has compiler-specific defers, and you can emulate defer using C++ RAII (though clunky).
mwindow 6y ago
I disagree. Rust still requires thinking about low-level details like lifetimes, aliasing, whether/when to use `Box` or `Rc` etc., Even when these are not explicitly spelled-out sometimes (like in lifetime elision), the programmer still has to be aware of these. Plus, modern C++ also abstracts away raw pointers by your definition, and has `unique_ptr` and `shared_ptr` which are the same as `Box` and `Rc` respectively. Bare pointers are frowned upon in modern C++ too. Furthermore, the OP talks about languages high-level enough to be used by biologists, while maintaining an acceptable performance.
- xyhopguy 6y ago
  Problems like the benchmark in the post are actually really simple to write in rust. They're all essentially streaming algorithms with some simple parsing. Fwiw rust has completely replaces cpp for high performant bioinfx code in my workflows. Sooo much easier to write than cpp!
AndrewGaspar 6y ago
Dealing with pointers in C# is not normal.

ginko 6y ago

Even C is a high level language.

Measter 6y ago

It can really depend how you write it. In some instances you can just throw things together and it can look a fair bit like you might write it in what many would consider high level languages. On the other hand, there are times when you really need to get into the nitty gritty of things for performance reasons, and it ends up feeling quite low level. For example, here's a Rust program which does the same as fqcnt_py1_4l.py: https://gist.github.com/Measter/d31abe88b5e318ba98856bf6f047ef19 https://gist.github.com/Measter/d31abe88b5e318ba98856bf6f047... It's longer than the Python version[0], I'm going out of my way to not allocate for every string. But, and maybe I'm biased here, it doesn't really feel like it's low-level code. [0] https://github.com/lh3/biofast/blob/master/fqcnt/fqcnt_py1_4l.py https://github.com/lh3/biofast/blob/master/fqcnt/fqcnt_py1_4...