oh god how did this get here i am not good with computer

 


 

Background music:
Click here because I can't put an audio widget in the profile

 

The scenes with the shark are usually very intense and disturbing.

 

I use Arch BTW

 

Fun fact: Neo-Nazi dipshit cartoonist Stonetoss is in fact Hans Kristian Graebener of Spring, Texas


MxSelfDestruct
@MxSelfDestruct

a lot of Rust's features honestly seem really nice in comparison to C(++) but to be frank, the language feels massively unapproachable. you think the C++ STL is weird and bloated? Rust is way fucking worse. from a newcomer like me's perspective it really feels like you have to chain together half a dozen cryptically abbreviated standard library functions, methods, and macros to get just about anything done.

is this really the case? I don't know, but the Rust Book sure makes it seem like it. so I'll be sticking with C(++) for a while, it looks like.


DecayWTF
@DecayWTF

This is my major issues with Rust, it's built along lines specifically to accommodate some of the worst antipatterns of modern programming; it's Java but worse. core+std is somehow bloated and incomplete at the same time so while you can't do anything remotely useful without invoking cargo (and there's no useful way to manage crates without using cargo, meaning you're automatically and permanently tied to Rust's package repo system so a left-pad issue is inevitable) the cognitive load of std is way more than it should be for something so functionally incomplete! Beyond that, so much functionality is pushed into attributes because the language itself is poorly designed, and attributes explicitly exist to escape the language strictures, meaning that every single program is full of adhockery that needs to be learned beyond, separate from and often against the core language.

Rust exhibits every design badness of Java coupled with the notational badness of modern C++. Add to that that the only thing the Rust community seems to think is important in a language is memory safety, no matter how B&D and unmanageable the implementation, and you're left with something I do not want to use. And that's a shame because as you say there is a lot worthy there! Rust could have been a good language, I was very excited when it was new!


You must log in to comment.

in reply to @MxSelfDestruct's post:

Replying in a comment, instead of Quote Replying, since I mean this to be helpful, and not a dunk in any way!

For context, I've been doing Rust for 7 or so years, and professionally taught rust for 3-4 years. Here's a couple of thoughts, happy to explain/expand any of them.

  • Rust does have a decently large set of APIs in its stdlib, but I would contend that the stdlib is:
    • Consistent, e.g. you will start to see patterns (in naming, function signatures, and types used)
    • Very well documented, e.g. you can browse or search the stdlib docs, and find a lot of information and usage examples
    • Low in "quirks", e.g. "oh if you use this wrong, it will bite you in the ass", or "oh no one ever uses X anymore, use Y" (in the few cases where there are deprecations, it's documented and points you to replacements)
    • Viable to learn incrementally: "what you don't know (yet) won't hurt you". You can avoid using huge parts of the stdlib for a very long time, if you don't actually need them.
  • As Rust is very strongly typed, you can lean on the signatures of functions very heavily to figure out what is or isn't possible to get from one thing to another. Again, it takes a little experience to find the kinds of types you'll want to reach for when solving different problems, but since the language is consistent, information is likely to be generalizable. Again: skimming the docs of a type, just looking at the return type of methods, helps a LOT.
  • As a sort of "living representation" of docs, I highly recommend using rust-analyzer with your editor of choice. Being able to press . on a value, and see what methods are available, again helps discovery.
  • IMO: When learning Rust, you are much more likely to see success if you use it consistently for a while (days/weeks), until the patterns sort of start to make sense. If you just sort of try to memorize "surface information" like function signatures and names and stuff, it's too easy for that to "fall out of brain cache" once you don't use it.
  • IMO: The best way to learn Rust is to find a problem you're familiar with/interested in solving, learn "enough" of the language via the book, rust by example, etc., then focus on solving the problem in a "good enough" way, rather than worrying about making it perfect.

I really like Rust, but it's just another tool. I think it pays dividends to learn, but there's definitely a cost to learning any new tool, and Rust (for better or worse) is very strict about getting certain things right.

I'd probably disagree with the characterization of "weird and bloated", but I'm also looking at it from a way different perspective than you are at the moment, and I can't really argue with an opinion/perspective.

Anyway, like I said, happy to expand on any of the points I made, or answering any "what the fuck is this even, rust?" questions.

in reply to @DecayWTF's post:

this is an old post but i got linked to it from here: https://cohost.org/SArpnt/post/1468225-the-kind-of-stuff-pe#comment-81ac1ae9-1298-47c0-95fb-fd87c7222d57

what antipatterns is rust accommodating? all the antipatterns i can think of in java or c++ rust specifically doesn't allow. i hate java, i could probably go many pages complaining about it, but almost none of those issues i can think of are in rust.

what notational badness of c++ are you talking about? i can think of quite a bit of confusing syntax in c++ but most of it isn't in rust, all i can think of is angle bracket generics, and that's not much.

i'm not sure what the line on "bloated" and "incomplete" is, what would you even consider to be the correct amount of stuff? i haven't really thought about it that much, i'm not sure if more or less stuff would even be better. only thing i wouldve liked to be different is to remove LinkedList and maybe replace it with something better since the one in std sucks

something similar to npm seemed inevitable, it makes sense to design the language with that in mind, the only language i know that doesn't work like that is c and c++ and managing dependencies with those suck. you aren't forced to put packages on crates.io or use ones from there, you can easily use any git repository or files with cargo. the left pad incident could either refer to people using a dumb dependency, which can't be fixed, that's a developer issue, or it could be referring to the package being deleted, which people can't do on crates.io. maybe some dmca thing could happen but c and c++ dependencies could be taken off the internet too. i'm not sure there's any good fix for this kind of issue that isn't just the responsibility of developers

i don't understand what you mean by attributes, i don't even know how to respond to any of it.

memory safety is cool and all, but honestly the main reason i use rust is because the type system and standard library actually make sense. java and c# have duplicate types, every object oriented language has inheritance issues, c barely even has types, null is horrible, and every dynamic language might as well be a static language with no type annotations and a trillion undefined behavior nulls

Antipatterns: The language, due to its memory management approach and the severe complexity of just passing things around, encourages the use of singletons. Hell, they're a recommended pattern in the Embedded Rust book. Having now written some lighting control software in Rust, using global god objects is the only reasonable way to handle eg holding a serial port. This is incredibly backward.

Notational badness: It's ugly and simultaneously overly terse and overly complex. It does the same thing as C++ and Java by having a ton of syntax and still simultaneously overloading operators; the most obvious one is the numerous different meanings of the :: operator. It's a path! It's a static method operator! It's a trait prefix! There's other examples, like ! for macros so that we can't ever replace a macro with a function (or vice versa) without touching all the code that calls it, which seems really fucking bad for a language that's under constant development and regularly introduces new features that might well tastefully support rewriting macros into normal functions!

Library fuckery: Why is there a ton of OS-specific stuff in std that could and should be external, but I have to go to crates.io to write a macro of any complexity?

Package management: Making it extremely hard to work with crates outside of cargo (and thus to integrate with other build systems or manage your own dependencies to avoid left-pad problems) is self-evidently bad, especially for a language that is purportedly intended to be able to build into existing C/C++ codebases gradually. I don't see any reason I should have to justify that.

Attributes: I did use the wrong language here, I meant attributes. This is another badness inherited (deliberately or otherwise) from Java; in Java, they're called annotations which is why the wrong name. Attaching arbitrary metadata (and so arbitrary evaluation) to any function, module, etc etc is also obviously bad by creating all sorts of non-local dependencies. I see a # and I know that I can't trust that the code does what it says it does.

And this last paragraph is just, every problem I have with the Rust community as a whole. The utter contempt and insistence that every language that isn't Rust is Bad and everyone who doesn't agree is stupid, I have no fucking time for.