Rust

Redpill a C programmer for Rust, why is this shit so special?

Beware Cat Shirt $21.68

Rise, Grind, Banana Find Shirt $21.68

Beware Cat Shirt $21.68

  1. 4 weeks ago
    Anonymous

    stick to C and learn Zig

  2. 4 weeks ago
    Anonymous

    The syntax allows you to express strong guarantees about behavior at compile time. Certain bugs can't exist in rust.

    • 4 weeks ago
      Anonymous

      >the syntax
      the type system*
      the syntax has nothing to do with it.

  3. 4 weeks ago
    Anonymous

    The goal was thread safety in Firefox
    That expanded to preventing mutation of non-atomic, non-synchronized types
    Now the compiler is haunted by a scary borrow checker that terrorizes innocent programmers who just want to mutate their void pointers in peace without worrying if something counts as undefined behavior

    • 4 weeks ago
      Anonymous

      >The goal was thread safety in Firefox
      then firefox died and everyone uses c++ chromium

      • 4 weeks ago
        Anonymous

        You know damn well Firefox was on its way to the grave before Rust hit 1.0

        • 4 weeks ago
          Anonymous

          because the devs wasted time on reinventing c++ with yet another syntax

    • 4 weeks ago
      Anonymous

      >Now the compiler is haunted by a scary borrow checker that terrorizes innocent programmers who just want to mutate their void pointers in peace without worrying if something counts as undefined behavior
      If you write it correctly this won't happen though.

      • 4 weeks ago
        Anonymous

        if you write C correctly you dont need rust in the first place tho

        • 4 weeks ago
          Anonymous

          Yes, but you can write C incorrectly by accident, which is what rust is trying to solve here.

          • 4 weeks ago
            Anonymous

            you can also write Rust incorrectly by accident, specially unsafe Rust which you'll eventually need to interact with.

          • 4 weeks ago
            Anonymous

            But is it not much more difficult to do so?

          • 4 weeks ago
            Anonymous

            depends on industry, anon.

            some webshit or user space development? Sure, std and a few libraries is all you need. You'll likely never have to see or write unsafe Rust yourself.

            embedded or kernel development? Not really, with how often you'll need to interact with raw pointers to physical memory and/or some memory mapped hardware registers. You might end up finding unsafe Rust more often than not, so what's the point?

          • 4 weeks ago
            Anonymous

            Depends on what kind of embedded you do as well. If you are doing bare metal then it's given, but I've been using Rust for ESP using IDF and don't have a single unsafe in my code. There is a good chance an embedded-hal implementation is all you need.

          • 4 weeks ago
            Anonymous

            It's easy to fill up the flash with esp-rs. Last I checked you have to use unsafe to store things in flash (nvs). They could make my life easier. Peripherals::take shouldn't have changed from Option to Result (MonadFail trait), and the espidf_time64 logic is coded in their project generator instead of being computed from the esp-idf version number available elsewhere.

          • 4 weeks ago
            Anonymous

            this happens in rust too.
            youre missing one key element here:
            the majority of C "memory managment" errors are actuallly... algorythmic mistakes.

            yes, you will be kinda removing some errors but not really (not really bc ppl use unsafe to go fast anyways)
            but you wont eliminate the source of the problem.
            industry-wide shortcomings in algorythmics skill.

            lo and behold! rust wasnt the silver bullet everyone hoped it would be
            https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=rust

  4. 4 weeks ago
    Anonymous

    Great Package Manager out of the box
    Great Tooling out of the box
    Great Error Handling out of the box
    Enums as sum types (algebraic data types)
    Iterators as streams (as opposed to C++ cursors)
    Targeting other architectures & OSes is piss easy
    Actually usable for the cloud & the web although i assume that is the least of your concerns
    Rayon & Tokio make concurrency and parallelism trivial

    The usual arguments regarding memory satefy and prevention of data races doesn't matter as much to me as the features above

    • 4 weeks ago
      Anonymous

      package manager thing is cool i wish C had something usable

      tooling - i have my own libs i wrote over the years so i don't need special tools

      error handling is good enough in C as well, also you should be building your code to have no errors therefore you will have very little to no error handling

      targeting other arch and os is easy, so is in C

      don't care about web sadly

      Rayon & Tokio make concurrency and parallelism trivial - KEK

      Here's my rust experience.

      >install rustup
      >cargo new rng_generator
      >cargo add random
      >write a tiny arse random number generator
      >cargo run
      >cargo builld --release

      project folder is 1.6gb

      >sudo rm -rf rng_generator
      >uninstall rustup

      C is literally all you need and any argument on the contrary is a israeli trick to sell more hard drives and turn you into a transgender freak.

      LMAO

      wait what do you need 1.6GB for? That seems like a broken programming language, perhaps you did something wrong anon?

      The goal was thread safety in Firefox
      That expanded to preventing mutation of non-atomic, non-synchronized types
      Now the compiler is haunted by a scary borrow checker that terrorizes innocent programmers who just want to mutate their void pointers in peace without worrying if something counts as undefined behavior

      I see this safety argument literally everywhere but every code example that isn't hello world I look at has unsafe { } in it which i assume is opposite of the main feature advertised in this language

      • 4 weeks ago
        Anonymous

        It's like C++ but they fixed as many bad decisions as they could and they guarantee no UB by making the type system smart about lifetimes and mutability and thread safety.
        Do you have an opinion about C++? If so then that'll help explain what Rust is like and whether you should expect to like it.

        >you should be building your code to have no errors therefore you will have very little to no error handling
        What does this look like when most syscalls can fail?

        • 4 weeks ago
          Anonymous

          >What does this look like when most syscalls can fail?
          then you have a broken system, fix the system then run your code,
          joke aside ofc you can get an error but you usually wont get any errors if you write clean code that has no reason to fail, at least I never have these issues.

          >opinion about C++?
          yeah, I don't like it, weird syntax compared to C, slow to compile, If you ever did simple game dev in it you must know the feel of compilation in C++. But C++ sometimes has cool and exclusive libs but usually have a support for C as well so i get by..

          • 4 weeks ago
            Anonymous

            >you usually wont get any errors if you write clean code that has no reason to fail, at least I never have these issues.
            So do you ignore errors or abort on error or what? Like, if a write returns -1, what does your code do?
            >weird syntax compared to C, slow to compile
            Rust has those issues so I guess it's a matter of the other stuff outweighing it or not.

            >guarantee no UB
            Complete nonsense.
            https://doc.rust-lang.org/reference/behavior-considered-undefined.html

            All Rust type concepts have a C++ equivalent. E.g. variants, optionals.

            Yeah, that was the half-sentence summary. More precisely they guarantee no UB without an unsafe block, and you can go a very long way without using one of those.
            >All Rust type concepts have a C++ equivalent. E.g. variants, optionals.
            Lifetimes don't. Sync/Send don't. Those are the big ones Rust uses for its guarantees.
            Traits don't have a 1:1 equivalent.

          • 4 weeks ago
            Anonymous

            >Lifetimes don't. Sync/Send don't. Those are the big ones Rust uses for its guarantees.
            >Traits don't have a 1:1 equivalent.
            Hopefully we get all that in C++30.

          • 4 weeks ago
            Anonymous

            Send and Sync cannot be retrofitted onto C++ without first having a borrow checker, getting uninitialized memory under control, and modifying the entire stdlib and all existing C++ code to work with the new rules
            Good luck with that

          • 4 weeks ago
            Anonymous

            Yes, that is why it is for cpp30 not cpp27.

        • 4 weeks ago
          Anonymous

          >guarantee no UB
          Complete nonsense.
          https://doc.rust-lang.org/reference/behavior-considered-undefined.html

          All Rust type concepts have a C++ equivalent. E.g. variants, optionals.

          • 4 weeks ago
            Anonymous

            >All Rust type concepts have a C++ equivalent
            enums as algebraic data types?
            stream based iterators (non-cursors)?

          • 4 weeks ago
            Anonymous

            >enums as algebraic data types?
            I literally just told you. They are called variants in c++.

            >stream based iterators (non-cursors)?
            Are you trolling? Those are ranges in c++.

      • 4 weeks ago
        Anonymous

        Responding to the last part - no.
        Is a race car invalidated because it has breaks?

        • 4 weeks ago
          Anonymous

          A competent driver would not need brakes, air bags, bumpers, or even a seat belt, because he woSegmentation fault (core dumped)

      • 4 weeks ago
        Anonymous

        >every code example that isn't hello world I look at has unsafe { } in it which i assume is opposite of the main feature advertised in this language
        Unsafe blocks do not turn of all guarantees.
        The presence of an unsafe block does not mean the rest of the code has no guarantees.
        Unsafe blocks need to be used very rarely.

      • 4 weeks ago
        Anonymous

        >unsafe { } in it which i assume is opposite of the main feature advertised
        The keyword has a shitty name. You're actually promising the compiler that the contents of the block ARE safe, just like you're implicitly doing for every single line of C (at least using GNU's maliciously moronic interpretation of what UB means).

        • 4 weeks ago
          Anonymous

          >You're actually promising the compiler that the contents of the block ARE safe
          No you are telling other devs if something goes wrong here is where to look. The name "unsafw" isnt directed towards thw compiler for all thw compiler cares it could be called poopstain

    • 4 weeks ago
      Anonymous

      >Rayon & Tokio make concurrency and parallelism trivial
      Rust's async/await is absolutely horrendous garbage and the fact that the solutions you named come with a runtime, makes you question why you're using a native image in the first place. If you're already running Tokyo, you could just as well write your application in C# or Java or Golang.

    • 4 weeks ago
      Anonymous

      >Great Package Manager out of the box
      npm syndrome, get 1000 dependencies for a small program
      also doesnt handle native dependencies anyway, which is the actual problem
      >Great Tooling out of the box
      wtf? theres not a single production level IDE or debugger available. so thats just a lie
      >Great Error Handling out of the box
      wtf? its literally just "check return value" kinda of error handling lmao
      >Enums as sum types (algebraic data types)
      actually pretty cool
      >Iterators as streams (as opposed to C++ cursors)
      wtf? iterators are just that, you can use them as whatever no matter the language. its just a pointer to something that knows how to get the next one. even C can do that
      >Targeting other architectures & OSes is piss easy
      agree, download toolchain and it works. pretty cool.
      >cloud and tokio
      lmao, no. the cloud? what does that even mean moron.
      and you never worked with tokio beyond an hello world if you think its trivial.

      >The usual arguments regarding memory satefy and prevention of data races doesn't matter as much to me as the features above
      you never used rust in production. you are a fizzbuzzer praising a tool you have no idea how it works.

      • 4 weeks ago
        Anonymous

        >get 1000 dependencies for a small program
        >also doesnt handle native dependencies anyway, which is the actual problem
        If your small project have 1000 dependencies then it's your fault, not the package manager.

        >wtf? theres not a single production level IDE or debugger available. so thats just a lie
        IDEs are not part of language tools.
        RustRover is "production level" and the debugger just works.

        >wtf? its literally just "check return value" kinda of error handling lmao
        It's the best way to handle errors. Especially when you combine it with monadic pattern, like Rust does.

        >wtf? iterators are just that, you can use them as whatever no matter the language. its just a pointer to something that knows how to get the next one. even C can do that
        That's not the same thing. Rust iterators are lazily evaluated and can be composed easily. Doing the same with C would be very hard, and possibly slow since you'd have to pass function pointers everywhere.

        >you never used rust in production. you are a fizzbuzzer praising a tool you have no idea how it works.
        NTA, but I'm using Rust for internal tools at my company.

      • 4 weeks ago
        Anonymous

        >also doesnt handle native dependencies anyway, which is the actual problem
        C and C++ programmers run into plenty of trouble with the other kind, to the point of avoiding dependencies altogether
        >production level IDE
        How is RustRover?
        >wtf? its literally just "check return value" kinda of error handling lmao
        The combination of explicit error propagation + reasonable ergonomics is much rarer than it perhaps should be
        >wtf? iterators are just that, you can use them as whatever no matter the language. its just a pointer to something that knows how to get the next one. even C can do that
        That's what an iterator is in C++ but not in Rust and not in a lot of other languages for that matter. Rust follows the model where an iterator is a repeated function call that eventually signals the end of the sequence. You don't have a pointer to the current item, instead you can take ownership of the next item.
        This gives fewer ways to consume an iterator (you e.g. can't sort one) but more ways to produce one. AIUI C++ iterators can't be by-value, where a container gradually provides ownership of its items, which is a pattern I love using in Rust. (But maybe that's covered by some other language feature.)
        For Rust they're working on generator functions, which I love using in languages that have them.

      • 4 weeks ago
        Anonymous

        >wtf? its literally just "check return value" kinda of error handling lmao
        Nope
        You have error bubbling up with a single character
        The actual return is tied together with the possible error in a sum type, and you cannot access it non-lexigraphically, ie the value is only available in a new (possibly impicit) scope. The condition to enter that scope is handling of the error. So you cannot not handle the errors, you HAVE to explicitly choose what to do on error, if you wish to access the return val

      • 4 weeks ago
        bruce3434

        >npm syndrome, get 1000 dependencies for a small program
        It's called the unix philosophy. Do one thing and one thing good.

    • 4 weeks ago
      Anonymous

      >Targeting other architectures & OSes is piss easy
      It's not though. Try writing a Rust compiler.

  5. 4 weeks ago
    Anonymous

    Here's my rust experience.

    >install rustup
    >cargo new rng_generator
    >cargo add random
    >write a tiny arse random number generator
    >cargo run
    >cargo builld --release

    project folder is 1.6gb

    >sudo rm -rf rng_generator
    >uninstall rustup

    C is literally all you need and any argument on the contrary is a israeli trick to sell more hard drives and turn you into a transgender freak.

    • 4 weeks ago
      Anonymous

      >rng_generator
      Yeah stick with c moron

    • 4 weeks ago
      Anonymous

      package manager thing is cool i wish C had something usable

      tooling - i have my own libs i wrote over the years so i don't need special tools

      error handling is good enough in C as well, also you should be building your code to have no errors therefore you will have very little to no error handling

      targeting other arch and os is easy, so is in C

      don't care about web sadly

      Rayon & Tokio make concurrency and parallelism trivial - KEK

      [...]
      LMAO

      wait what do you need 1.6GB for? That seems like a broken programming language, perhaps you did something wrong anon?

      [...]
      I see this safety argument literally everywhere but every code example that isn't hello world I look at has unsafe { } in it which i assume is opposite of the main feature advertised in this language

      >rng_generator
      Yeah stick with c moron

      Unlike Rust trannies I am willing to admit when I have made a mistake(like cutting off my penis).

      It wasn't a random number generator that created the >1gb project it was a gtk4 example which is an unacceptable amount of bloat. GTK4 and it's deps are less than 100mb on Linux.

      Some troony will come along with muh deps, muh debug, muh release builds. literally do not give a frick. Your language is a bloated piece of shit with horrific syntax.

      • 4 weeks ago
        Anonymous

        that's pretty crazy but how big is a release binary of your example?

        • 4 weeks ago
          Anonymous

          He already told you he won't respond to such pedantry

          • 4 weeks ago
            Anonymous

            that's pretty dishonest of him to not show us the whole picture because we won't be able to make a rational informed opinion on the subject

          • 4 weeks ago
            Anonymous

            It's okay for C and C++ shills to be dishonest about the drawbacks of using Rust

        • 4 weeks ago
          Anonymous

          picrel

          He already told you he won't respond to such pedantry

          that's pretty dishonest of him to not show us the whole picture because we won't be able to make a rational informed opinion on the subject

          Nice straw man. I gain nothing by you not using Rust.

          • 4 weeks ago
            Anonymous

            131M is still a pretty large release binary for such a small project

          • 4 weeks ago
            Anonymous

            Isn't 4.3MB gtk4-example the binary? Build should be a folder used for intermediates.

          • 4 weeks ago
            Anonymous

            I have no idea, if it's 4.3M then it's fairly reasonable.

          • 4 weeks ago
            Anonymous

            Generally, binaries have the same name as project name in Rust, unless specified otherwise.

      • 4 weeks ago
        Anonymous

        The rust API is so much nicer than the raw GTK4 one. Is there any real reason to ever use C anymore?
        t. published multiple GTK GUI tools in flathub.

      • 4 weeks ago
        bruce3434

        That's because Linux ships GTK libraries and you are using them. On windows you have to install mingw packages which also take up a lot of space. GTK is not a minimal UI library either. And its far from just a simple random number generator.

      • 4 weeks ago
        Anonymous

        >Gets BTFO
        >REEEEE IM STILL RIGHT SOMEHOW REEEEEEEE
        Just Cniles things.

    • 4 weeks ago
      Anonymous

      [...]
      [...]
      Unlike Rust trannies I am willing to admit when I have made a mistake(like cutting off my penis).

      It wasn't a random number generator that created the >1gb project it was a gtk4 example which is an unacceptable amount of bloat. GTK4 and it's deps are less than 100mb on Linux.

      Some troony will come along with muh deps, muh debug, muh release builds. literally do not give a frick. Your language is a bloated piece of shit with horrific syntax.

      Why are you morons measuring the size of the project folder and not the size of the binary itself? You know you're basically counting all of the build artifacts in there, right? That's not what you ship to your users.

      • 4 weeks ago
        Anonymous

        From the start I said project folder. I don't care if the final binary is a single byte, who ships binaries?

        All I did was
        >cargo new gtk4-example
        >cargo add gtk4
        >copied the example
        >cargo run
        >cargo build --release

        That should not create 1.3GB of poo on my drive.

        • 4 weeks ago
          Anonymous

          >who ships binaries?
          Everyone.

        • 4 weeks ago
          bruce3434

          >who ships binaries?
          Who doesn't ship binaries?

          • 4 weeks ago
            Anonymous

            how are they going to see the elegance of your fizzbuzz if you just ship a binary? for all they know you could've hardcoded the values!

        • 4 weeks ago
          Anonymous
      • 4 weeks ago
        Anonymous

        because i don't have infinite hard disk space, moron. hello world shouldn't take up half of my drive

      • 4 weeks ago
        Anonymous

        Anon do you realize how much source code or compiled external lib code is 1.6GB?

        • 4 weeks ago
          Anonymous

          You might want to consider checking what files are contributing most to that bloated directory size.

    • 4 weeks ago
      Anonymous

      C and C++ have a similar amount of build junk, it's just in your /usr directory causing dependency conflicts with other things you're trying to build. C and C++ were created back when dependency conflicts weren't as big a problem as hard drive space. Now the opposite is true, so modern languages use a little more disk space to solve the much more painful dependency problem.

      • 4 weeks ago
        Anonymous

        C/C++ can be compiled on machines with a few MB of memory

        • 4 weeks ago
          Anonymous

          And Rust can compile multiple things with conflicting dependency versions without having to jump through any hoops, which is something you might actually have to do in current year.

          • 4 weeks ago
            Anonymous

            No

        • 4 weeks ago
          bruce3434

          >machines with a few MB of memory
          Nobody is compiling code in machines with few MB of memory.

          • 4 weeks ago
            Anonymous

            >who ships binaries?
            Who doesn't ship binaries?

            That's because Linux ships GTK libraries and you are using them. On windows you have to install mingw packages which also take up a lot of space. GTK is not a minimal UI library either. And its far from just a simple random number generator.

            I like rust but I still believe that you should have a nice day bruce.

          • 4 weeks ago
            bruce3434

            I'm just asking questions.

          • 4 weeks ago
            Anonymous

            Technically, only one of the three posts being quoted contains a question, and that question was clearly rhetorical.

          • 4 weeks ago
            Anonymous

            Don't listen to him Bruce, I like you even though you act moronic sometimes

    • 4 weeks ago
      Anonymous

      >Rayon & Tokio make concurrency and parallelism trivial
      Rust's async/await is absolutely horrendous garbage and the fact that the solutions you named come with a runtime, makes you question why you're using a native image in the first place. If you're already running Tokyo, you could just as well write your application in C# or Java or Golang.

      these haters along with this reddit post https://www.reddit.com/r/rust/comments/12b7p2p/the_rust_programming_language_absolutely/
      and the syntax section of the wikipedia page have won me over
      I am officially never learning rust
      my intuition is just steering me away for whatever reason, maybe it truly is troony shit for amateurs

      >muh safety
      frick off I dont need your hand holding dragging me down

      • 4 weeks ago
        Anonymous

        That safety is also pretty useless for embedded development when you're not doing dynamic allocations anyways. I don't think you'll regret skipping it.

        • 4 weeks ago
          Anonymous

          except it's literally not. the safety and type system lets you do a lot of useful things in embedded. static guarantees at compile time
          https://docs.rust-embedded.org/book/static-guarantees/design-contracts.html

          • 4 weeks ago
            Anonymous

            Just use Ada.

        • 4 weeks ago
          Anonymous

          That is only one part of embedded development though. Much of embedded nowadays is on Linux systems.

          But yes, if you don't have dynamic allocations you can not have bugs caused by dynamic allocations.

        • 4 weeks ago
          Anonymous

          >That safety is also pretty useless for embedded development when you're not doing dynamic allocations anyways.
          The only thing relevant to safety when doing dynamic allocating is RAII and it's not unique to Rust.
          Rust safety guarantees go way beyond that. Also not every embedded environment doesn't support dynamic allocation. It's pretty common nowadays everywhere.

      • 4 weeks ago
        Anonymous

        wtf, rust is that bad that even java seems a good language?

      • 4 weeks ago
        Anonymous

        >https://www.reddit.com/r/rust/comments/12b7p2p/the_rust_programming_language_absolutely/
        kek because it's true

      • 4 weeks ago
        Anonymous

        but everyone was so nice to him and helpful in that thread... how could you not like rustaceans?

        • 4 weeks ago
          Anonymous

          nobody addressed his problem and everybody had some gay snarky delusional attitude like
          >"maybe you shouldnt be doing that [task assigned by higher ups]"
          >"maybe you should spend more time learning :)" (when hes working on a deadline and has already read the rust manual cover to cover)
          >"clearly this is a management problem, have you tried telling your boss you cant do the job he assigned?"
          > "Im really sorry to hear youre having problems! ...[unhelpful bullshit written in baby talk]... hope this helps!"

          even the dev of the library hes using confirms that he cant do what hes trying to do even though that task would be trivial in c++ or java

          these people do not live in reality

          • 4 weeks ago
            Anonymous

            >even the dev of the library hes using confirms that he cant do what hes trying to do even though that task would be trivial in c++ or java
            trivial use after free lmao, always the lies

          • 4 weeks ago
            Anonymous

            Never thought I'd die fighting side-by-side with a Java programmer.

          • 4 weeks ago
            Anonymous

            >Wow, you can devine
            moron alert

          • 4 weeks ago
            Anonymous

            wew lad, a typo
            you're as anal as a rust compiler

          • 4 weeks ago
            Anonymous

            >They have a chapter on Traits and how to use them in an object oriented way. And they have tons written on async and await. Yeah, only an idiot would assume you could put both features together. Silly me.
            Joke's on you - there are plenty of other features that don't work properly if you use them with async/await. Unfortunately, everyone keeps talking about async non-stop even though it's almost never a good idea to use it.

            Killing libgreen was a huge mistake.

          • 4 weeks ago
            Anonymous

            Why are we even doing async/await still? It always seems to introduce problems no matter what language it's implemented in, every single time it ends up enshittifying the language.

            Also, why are we still trying to share pointers and references between threads? That just seems moronic, and then you need "muh thread safe" language to lock your way into making it synchronize again. How about this, don't share pointers between threads, just share (by copy) atomic values instead and most of your thread safety problems disappear.

          • 4 weeks ago
            Anonymous

            >Why are we even doing async/await still?
            Because the other ways of solving the same problems also leave a lot to be desired.
            >Also, why are we still trying to share pointers and references between threads? That just seems moronic, and then you need "muh thread safe" language to lock your way into making it synchronize again. How about this, don't share pointers between threads, just share (by copy) atomic values instead and most of your thread safety problems disappear.
            Some languages take this approach. Nim does it. JS added web workers, Python is adding subinterpreters, Ruby ractors. Go wants you to do it but doesn't force you in any way. Erlang takes it all the way. Hare says you should spawn an entire new process for parallelism. Etcetera.
            Problem is that you might have to sacrifice a ton of efficiency, and Rust is for writing highly efficient programs. Also it has to interoperate with classically threaded C and C++.

          • 4 weeks ago
            Anonymous

            >sacrifice a ton of efficiency, and Rust is for writing highly efficient programs
            Sometimes you have to sacrifice something to end up with a good, well designed system. Just look at all the pointer stuff from C and C++ that Rust had to sacrifice to get a well designed memory safe system. I'm certain that with more help from the compiler and a change in people's way of writing threaded code, just like the one required for memory safe code, you could make the copy approach more efficient but this would require time and effort to find the exact correct approach.

            Rust instead went with the lazy approach and tried to shoehorn JS/C#-like async/await into a language that is not supposed to have a runtime, while forgetting that the reason why those other languages can make it work is because of their heavier runtime. Now you have an awful, hard to use version of async/await with Tokio and others (the heavier runtime) needed to make it even bearable to use. How is needing an inefficient async runtime more efficient than the previous option?

            >Also it has to interoperate with classically threaded C and C++.
            How is it a good idea to introduce an awful async model just to have one thread be in Rust and another thread be in C or C++, that's just moronic system design right there. No one is expecting C# async threads (the thing they're likely trying to emulate) to interop with C and C++ native threads, so why the frick are they expecting Rust async to work with them?

          • 4 weeks ago
            Anonymous

            Rust already had threading before it had async. Threading is the one that must be interoperable.
            Rust is designed to be able to validate that shared data is only accessed in a properly synchronized way.
            You absolutely need to be able to have shared data because that's How The Computer Works, for better or worse. The hardware knows about atomics, the kernel knows about futexes. And if you have actors and channels then those use shared memory under the hood.
            Rust has to be a language that can implement language runtimes and channels and other primitives. It has to support this, for that reason and other reasons, and so they tried to make it as safe as possible.
            If you do want to share no mutable data then Rust actually makes that easy enough, it'll tell you if you mess up. You can use your channels and no mutexes whatsoever. You can even keep sharing your risk-free immutable data, it'll make sure it's truly immutable.

          • 4 weeks ago
            Anonymous

            >Why are we even doing async/await still? It always seems to introduce problems no matter what language it's implemented in, every single time it ends up enshittifying the language.
            Sync/await in JS works without any issue. In rust it's complicated, but if you know what you are doing it really be useful.

            >Also, why are we still trying to share pointers and references between threads? That just seems moronic, and then you need "muh thread safe" language to lock your way into making it synchronize again. How about this, don't share pointers between threads, just share (by copy) atomic values instead and most of your thread safety problems disappear.
            You've reinvented channels. That's how does it work in Go. Rust allows channels as well.

            Also async/await does not mean multi threading. Many languages with async/await are single threaded, and vice versa. In rust you can choose multi threaded or single threaded runtime, depending on what you need.

          • 4 weeks ago
            Anonymous

            >You've reinvented channels. That's how does it work in Go.
            Unironically a much better design than whatever Rust is trying to accomplish with async. Golang has a much better model, so why is Rust no investing into making it more efficient?

          • 4 weeks ago
            Anonymous

            Rust already has channels.

          • 4 weeks ago
            Anonymous

            But is Rust focusing on them? Seems like they're focusing more on async, anon.

          • 4 weeks ago
            Anonymous

            If you look at examples of multi threading in Rust they often use channels. When I was doing multi threading with it, that's what I also used because they are just very convenient.

            However keep in mind that not everything can be done with channels and channels themselves are not zero cost. That's why mutexes and other synchronization methods exist. Not every multi threading problem can be split into isolated threads that just take some data and split out result after some time. Info you are not just doing large number crunching but a more complex programs where threads do different things, they will mostly likely need to do more complicated synchronization that channels offer.

          • 4 weeks ago
            Anonymous

            Maybe something built on top of channels could work? I know that they're not zero cost, threading in general is hardly going to be zero cost no matter the method used, but I'll always prefer something that doesn't involve sharing pointers and references directly, as in sending them to another thread.

            Have you ever seen the absolute bloat needed to implement a memory allocator that supports allocating on one thread and freeing on another thread? You go from less than a thousand lines of a very efficient thread local allocator, to several thousand lines of added bloat that is there just to support freeing on a different thread, and now your entire program pays the cost of a much less efficient allocator just so you can share a few pointers around.

            I'd prefer looking for ways of making channels and close alternatives more efficient, than bogging down my entire program with inefficient allocators and async runtimes. Sharing pointers between threads IS the inefficient solution when you consider the kind of code needed to support it.

          • 4 weeks ago
            Anonymous

            nta but you dont make sense.
            your threads just share a memory. something something child processes
            and if threading makes your memory management code go from a couple hundos to thousands youre doing something very wrong on multiple levels

          • 4 weeks ago
            Anonymous

            NTA but I can believe it. I just looked at two channel implementations I wrote recently. The one for sending messages between two fibers/coroutines on the same OS thread (meaning cooperative scheduling, no need for locks or atomics) is 300 lines. The one for sending messages between fibers on different threads is 1500 lines.

          • 4 weeks ago
            Anonymous

            yeah but it doesnt have much to do with memory mangment.
            programs just get more complex with threading
            for starters you have a signalling system grafted on top of existing code. and you have to diverge then merge the data again bc you dont want to be relying on messaging or mutexes every time you do a write.

            memory managment shouldnt increase much. its the same routines, just applied to multiple threads. there may be a little massaging to be done bc threads, and each one has their scopes, but thats it
            you would need to do a conscious effort to go from hundreds to thousands on memory managment "bc threads". or youre doing something wrong. on a couple levels. the formatting must be weird, and you would have to not use loops or something to that effect

          • 4 weeks ago
            Anonymous

            >nta but you dont make sense.
            Ever had to implement a memory allocator that supports multiple threads, anon? It's not as easy to make it efficient as you think it is, it's not just a matter to adding a few locks or mutexes here and there.

            >if threading makes your memory management code go from a couple hundos to thousands youre doing something very wrong on multiple levels
            Oh you thought the memory allocator wouldn't be affected by threading? Go look at the source code for jemalloc, mimalloc and snmalloc, they are all at around or more than 10 thousand lines, and these are meant to be the state of the art in allocator design today. That's the amount of bloat you need to support sharing pointers between threads.

            By the way, jemalloc is more than 30 thousand lines of C code, anon.

          • 4 weeks ago
            Anonymous

            if youre talking about the syscalls, thats kindof not my problem doe.
            if youre advocating for me to take on part of the effort that goes into making an os through having coding principles bleed into my projects im gonna give you a hard stop.

            its not my fricking problem.
            malloc is god knows how many klocs (half of them are guarded by defines btw)
            EXACTLY so that my experience is "pointer goes bip boop ad the data happens"

          • 4 weeks ago
            Anonymous

            >if youre talking about the syscalls
            >anon thinks malloc is a system call
            No it's not you moron, malloc is a user space function and is often not even the one libc implements. Rust used jemalloc for quite some time if I recall correctly.

            >advocating for me to take on part of the effort that goes into making an os
            MALLOC. IS. NOT. A. SYSCALL. Hope you learned something new today, anon.

            Fricking hell, people should learn C first before diving into Rust and thinking they are some low level hacker without even knowing where their allocator comes from.

          • 4 weeks ago
            Anonymous

            i dont even fricking code in rust and love C bc i con focus on the fun part of programming without any care about the fricking tedium you seem sexually aroused by

          • 4 weeks ago
            Anonymous

            >Anon codes in C and doesn't even know where his allocator comes from
            >Confidently says that it's a system call
            >Tries to tell me how an allocator works
            Anon, please stop embarrassing yourself.

            also yes, i know malloc is not a syscall, thank you
            its how you interact with the os, in case youre having trouble following the discussion

            >Tries to say he knew all along it wasn't a syscall
            >Says malloc is how you interact with the OS
            Anon, just stop. You don't interact with the OS with malloc, it sometimes make a few mmap calls in there. Aside from that there's no more interactions with the OS, it all happens in user space and in your process's own virtual address space.

          • 4 weeks ago
            Anonymous

            Not them and I think malloc is worth understanding and caring about but it's not unreasonable to consider your libc part of the OS
            If I mean kernel I say kernel, not OS

          • 4 weeks ago
            Anonymous

            One of the problems with this argument is that often you'll see production systems not using libc malloc, but some other malloc. If libc malloc was the only available implementation then sure you could consider malloc strictly as part of the OS or kernel.

            But Rust used jemalloc for quite some time for example, and you can implement it yourself and end up with a much more efficient implementation for your own needs, than the extremely generalized libc malloc implementation.

            The only memory management function the kernel itself gives you is the one to allocate virtual memory, usually mmap on Unix or VirtualAlloc on Windows.

          • 4 weeks ago
            Anonymous

            >If libc malloc was the only available implementation then sure you could consider malloc strictly as part of the OS or kernel.
            youre kinda retaded, arent you?

            which version of malloc comes with you os?
            the one that you wrote yourself maybe?

          • 4 weeks ago
            Anonymous

            You certainly can and often should use a different allocator but the fact remains that if you're publishing a general purpose OS you'll include a malloc so it's not, like, ridiculous
            What I'm really saying is that jumping from a casual reference to the allocator as part of the OS to accusing somebody of thinking it's a syscall is unreasonable and not healthy for the discussion

          • 4 weeks ago
            Anonymous

            >monomania
            >lack of understanding of subtelty
            that anon has hard autism.
            he just needs to learn not to be an butthole about it.

          • 4 weeks ago
            Anonymous

            >he just needs to learn not to be an butthole about it.
            esl moment.
            i dont imply autism is something superior
            i mean autists also have ego
            and while most people are braindead, a smart bulldozes the autist in intellectual work bc of puridisciplinary knowledge and flexibility of thought/thought procedure

          • 4 weeks ago
            Anonymous

            >Confidently says that it's a system call
            ur seeing things. i understand subtelty is not your cup of tea, but cmon

            also yes, i know malloc is not a syscall, thank you
            its how you interact with the os, in case youre having trouble following the discussion

            >You don't interact with the OS with malloc
            now youre being moronic on purpose. i kinda doubt everything you said until now, now.

            im not gonna dive into the ins and outs of os memory management because i dont care, anon
            i just dont care about learning lowest level nerd autismo shit, which i dont need in my day to day operations.
            especially theres morons like you who focus all their time and energy on servicing code infrastructure.

            'that your kink? go nuts. dont bother me doe
            i just dont give a frick, see
            your concerns of minimizing the size of an executable by a couple kilobytes or shaving off a 0.1 ms off each allocation are completely moot in 99.9% of contexts.

          • 4 weeks ago
            Anonymous

            >because i dont care, anon
            >i just dont care about learning lowest level nerd autismo shit
            Then don't try to tell us how memory management works, you moron.

            We were talking about how support for multi-threading requires a larger memory allocator implementation, you're the one who got here trying to tell everyone how shit works and refuses to accept any explanations from people who actually know from it works.

            If it's not your problem and you don't care enough to understand it, then why would you argue about it as if you knew how it works? You're a perfect example of the Dunning–Kruger effect. Fricking annoying.

          • 4 weeks ago
            Anonymous

            >you moron.
            careful.
            youre the (only) one who gets all riled up about what amounts to 0.1% of runtime. (and is boring as frick to be honest)

            the fact that you memorized useless shit nobody cares about is just that- you memorized useless shit nobody cares about.
            except os engineers, and turbo autists (read morons) who just cant do anything else

          • 4 weeks ago
            Anonymous

            also yes, i know malloc is not a syscall, thank you
            its how you interact with the os, in case youre having trouble following the discussion

          • 4 weeks ago
            Anonymous

            I think you're the one who's lost track of the discussion. Your original claim was

            nta but you dont make sense.
            your threads just share a memory. something something child processes
            and if threading makes your memory management code go from a couple hundos to thousands youre doing something very wrong on multiple levels

            >if threading makes your memory management code go from a couple hundos to thousands youre doing something very wrong on multiple levels
            We're talking about multithreaded malloc implementations specifically. You seem to agree that

            yeah but it doesnt have much to do with memory mangment.
            programs just get more complex with threading
            for starters you have a signalling system grafted on top of existing code. and you have to diverge then merge the data again bc you dont want to be relying on messaging or mutexes every time you do a write.

            memory managment shouldnt increase much. its the same routines, just applied to multiple threads. there may be a little massaging to be done bc threads, and each one has their scopes, but thats it
            you would need to do a conscious effort to go from hundreds to thousands on memory managment "bc threads". or youre doing something wrong. on a couple levels. the formatting must be weird, and you would have to not use loops or something to that effect

            >programs just get more complex with threading
            and the same applies to malloc implementations: ones that support threading (and, in particular, the other anon's example of allocating some memory on thread 1 and freeing it on thread 2) are more complex than ones that don't support threading.

            Looking at your original post again, I wonder if when you say "memory management" you aren't confusing "application code that uses malloc" with "the implementation of malloc itself". The overall conversation is about the latter.

          • 4 weeks ago
            Anonymous

            and btw
            mem allocation is not really a problem in many situations because the most time efficient approach regardless of your allocatior' complexity is to allocate chunks of memory and assign pointers to it internally.

          • 4 weeks ago
            Anonymous

            (clarif.)
            chunks of memory as opposed to allocating individual objects
            another advantage in doing so is that if you compartimentalize your bulk allocations based on your program flow it makes memory management trivial.
            quit a certain context? just free the associated chunk. jobs a goodn, lets go drink

          • 4 weeks ago
            Anonymous

            >Why are we even doing async/await still?
            Because it's still the most reliable way to solve the C10K problem.
            If you have something better, there's an entire industry waiting for it.

            >How about this, don't share pointers between threads, just share (by copy) atomic values instead and most of your thread safety problems disappear.
            >just duplicate your entire database 64 times bro

          • 4 weeks ago
            Anonymous

            >thinking you'd need to copy the entire database into all 64 threads, instead of requesting (and then copying) just the value that is required from it.
            LMAO people can't write efficient code anymore. This is why you learn C first instead of Rust.

          • 4 weeks ago
            Anonymous

            >instead of requesting (and then copying) just the value that is required from it.
            And how do you implement a multi-threaded DBMS without sharing any references or pointers?

          • 4 weeks ago
            Anonymous

            >Why are we even doing async/await still?
            Because people keep talking about it. It's a huge meme. Users see devs talking about it and think it must be this killer feature that will make their lives so much easier. Devs see users talking about it and think the feature in high demand and they should put ever more effort into it. In reality, if they had decided "Rust's approach to async is to bring back libgreen", they would have been done already and everyone would be happy, except maybe people who are literally trying to implement nginx (and honestly, if you're really writing something like nginx, I suspect you might want to roll your own state machines instead of letting the compiler do it for you).

            >Why are we even doing async/await still?
            Because it's still the most reliable way to solve the C10K problem.
            If you have something better, there's an entire industry waiting for it.

            >How about this, don't share pointers between threads, just share (by copy) atomic values instead and most of your thread safety problems disappear.
            >just duplicate your entire database 64 times bro

            C10k is trivial in the current year, partly because hardware now is much faster than it was in 1999, and partly people put a lot of effort into making Apache's thread-per-connection model go fast back when LAMP was a thing

          • 4 weeks ago
            Anonymous

            >except maybe people who are literally trying to implement nginx (and honestly, if you're really writing something like nginx, I suspect you might want to roll your own state machines instead of letting the compiler do it for you).
            Cloudflare just did reimplement nginx in Rust (Pingora). They seemed pretty happy about it, considering they got zero software crashes in production, except for a kernel bug. Seems pretty successful to me.

            >C10k is trivial in the current year, partly because hardware now is much faster than it was in 1999,
            If your solution to C10K is "lel just spawn threads, we fast now", you completely missed the point.

      • 4 weeks ago
        Anonymous

        >I've been programming for 30 years so I should be able to understand and write perfect Rust instantly
        that post is like the archetypal programming moron, entitled boomer idiot subspecies. not surprised people here cling to it as affirmation of their beliefs when it's a flawed premise from the start

    • 4 weeks ago
      Anonymous

      >rng_generator

  6. 4 weeks ago
    Anonymous

    Imagine C/C++ but
    1. The compiler enforced good practices (unless you ask it not to) and didn't speak in pure jargon
    2. Tooling wasn't stuck in the 20th century

    • 4 weeks ago
      Anonymous

      yeah tooling is shit in C by default

      gcc is the troonix type of a compiler, it has the basics and the most minimal code to get it working lmao but that is why C will always be the fastest programming language out there, aside of course, the native assembly.

      But the problem i have with rust is that syntax, my god did you see it? It's like C++ (that I absolutely hate) but somehow even worse.

    • 4 weeks ago
      Anonymous

      >didn't speak in pure jargon
      what are you talking about you fricking moron. every single piece of text even remotely related to rust is literally undecipherable unless you have vast experience with c++ or rust itself

    • 4 weeks ago
      Anonymous

      >Tooling wasn't stuck in the 20th century
      What the frick does that even mean, I bet you're a troony.

      • 4 weeks ago
        Anonymous

        I've noticed webshits love to talk about "the tooling"

      • 4 weeks ago
        bruce3434

        I've noticed webshits love to talk about "the tooling"

        What makes the word "tooling" so indecipherable to you?

        • 4 weeks ago
          Anonymous

          What makes you think Rust "tooling" is better than what C++ offers?

          • 4 weeks ago
            bruce3434

            Sure, there is no answer to cargo in the C++ world to start with.

          • 4 weeks ago
            Anonymous

            >cmake
            >vcpkg
            >meson
            >conan
            all trash

          • 4 weeks ago
            Anonymous

            You'll learn that you're wrong when you start a project more complicated than FizzBuzz. good luck with that RIIR CLI program you're building. Maybe you can replicate 41% of the functionality of the C equivalent!

          • 4 weeks ago
            Anonymous

            concession accepted

          • 4 weeks ago
            bruce3434

            What is wrong with the CLI? Are you implying that CLIs are easy?

          • 4 weeks ago
            Anonymous

            The only reason you should be using make over a shell script to begin with is if your project is large enough to warrant needing to only compile what's been changed. There is absolutely zero reason to use any of that other dogshit.
            >muh windows
            There are a billion make interpreters that run on windows. Don't even fricking start.

          • 4 weeks ago
            Anonymous

            I wrote a substantial cross-platform C++ program and I don't know how you can even ask that. It takes a non-trivial engineering effort just to let the compiler know where the dependencies are, and you run into a lot of trouble if another program you're building requires an incompatible version of a dependency. Those are just not even an issue in rust.

  7. 4 weeks ago
    Anonymous

    What a stupid name for a programming language

  8. 4 weeks ago
    Anonymous

    I thought the whole appeal of Rust was the subsidized gender affirmation surgeries.

  9. 4 weeks ago
    Anonymous

    It has clippy

  10. 4 weeks ago
    Anonymous

    It has a terrific ecosystem full of very nice people that are sure to tell you which non-binary sexuality they subscribe to. And lots of tooling to keep you from using problematic identifiers in your code.

    > t. Likes Rust, but sheesh, can’t we get away from the culture wars?

    • 4 weeks ago
      bruce3434

      >And lots of tooling to keep you from using problematic identifiers in your code.
      Such as?

      • 4 weeks ago
        Anonymous

        https://github.com/rust-lang/rust/blob/master/src/tools/tidy/src/style.rs#L66

        Hint, convert to hex. Can you believe some moron committed that? I’d be embarrassed.

        • 4 weeks ago
          Anonymous

          former linux maintainer

        • 4 weeks ago
          bruce3434

          Strange, why did it not identify these problematic identifiers?

          • 4 weeks ago
            Anonymous

            To their credit, it’s just for tidy. It’ll still build.

          • 4 weeks ago
            bruce3434

            Hmm, I used the tidy and it still did not detect any problem in identifiers? Is this a psy-op, anon? Redpill me in this.

          • 4 weeks ago
            Anonymous

            >windows
            >vscode
            >light theme

          • 4 weeks ago
            bruce3434

            Yes.
            Yes.
            Yes.

          • 4 weeks ago
            Anonymous

            Light themes are superior and better for the eyes.

          • 4 weeks ago
            Anonymous

            he's a moronic schizo spammer.

        • 4 weeks ago
          Anonymous

          To their credit, it’s just for tidy. It’ll still build.

          It's just for that repo because they don't want 0xCAFEBABE in the examples in the official stdlib docs. You cannot run this check on your own code at all

          • 4 weeks ago
            Anonymous

            No Java class parsers in the standard library, then. And anyone can use Tidy. Still stupid.

          • 4 weeks ago
            Anonymous

            >No Java class parsers in the standard library, then.
            If you need it then you just add an exception to tidy in the same commit.
            >anyone can use Tidy
            You really can't, it's hardcoded for the language repo's directory structure and doesn't ship with the toolchain. You have been lied to.

          • 4 weeks ago
            Anonymous

            Why would you need Java class parsers in the rust standard library?

  11. 4 weeks ago
    Anonymous

    another shit lang to add to the pile

  12. 4 weeks ago
    Anonymous

    >why is this shit so special?

    The official selling point:
    >Easier to write high performance parallel applications without data races
    >Much less likely to have memory bugs due to segregation of safe and unsafe code
    The reason why C and C++ programmers actually end up liking Rust:
    >Cargo
    >Sum types, pattern matching, and the stdlib (Option/Result as very fricking nice)
    >Rust libraries that can leverage the much, much better macro system
    The reason why non C and C++ programmers end up using Rust:
    >Fast as C++, but without the footguns
    >An absurd amount of webdev tooling despite not being designed for webdev
    Why you, as a C programmer, should use Rust:
    >Cargo

    • 4 weeks ago
      Anonymous

      imho cargo/crate.io should be the main selling point because it's pretty good, especially compared to the C/C++ ecosystem
      I would add that rust support in editors is also excellent

      without either of those, it would be a language much more worse than C/C++, regardless of all the other selling points

      • 4 weeks ago
        Anonymous

        Eh, I wouldn't consider Rust significantly worse than C and C++, but I do still think Cargo is the strongest selling point. It's so good I even wish some of my Python projects could be done in Rust because of all the minor annoyances of Pip and Conda.

        • 4 weeks ago
          Anonymous

          https://python-poetry.org/
          check poetry I'm sure you will like it

          • 4 weeks ago
            Anonymous

            not her, but every single python package management "solution" is dogshit. they all suck and every few months/years, it's "dude try out my package manager it totally works and fixes the problems every other one has trust me"

          • 4 weeks ago
            Anonymous

            I find poetry to be pretty similar to cargo. You track your dependencies in a pyproject.toml file and it will manage your virtual envs for you.
            if you like cargo you will probably like poetry.

          • 4 weeks ago
            Anonymous

            i like cargo. i don't like poetry, virtual-envs, and whatever other non-solutions the python space uses. i switched from python to rust years ago to get away from that mess

          • 4 weeks ago
            Anonymous

            yeah if you don't like python you will not like poetry more I give you that

          • 4 weeks ago
            Anonymous

            the state of python deployment and package management doesn't really seem any better than back in 2017-2018

  13. 4 weeks ago
    Anonymous
  14. 4 weeks ago
    Anonymous

    Wonder why there are so many people that flat out lie about Rust especially on IQfy. Seems concerted and bot-like, always the same posts. Makes me wonder who's behind it

    • 4 weeks ago
      Anonymous

      Misc refugees (nocoders).

    • 4 weeks ago
      Anonymous

      People who don't want a fricking data center to be a requirement for programing?

      How long until hello world becomes a terabyte?

      • 4 weeks ago
        Anonymous

        Good, it filters the poors and third worlders who should not have access to computers.

        • 4 weeks ago
          Anonymous

          That's funny cause rust is trying to solve problems that were created by third world poors.

          • 4 weeks ago
            Anonymous

            I thought the C bugs were created all by le ebin white males?

  15. 4 weeks ago
    Anonymous

    It's C but it needs dilation.

  16. 4 weeks ago
    Anonymous

    Because this shit formalized the behaviour of references and lifted them and their lifetimes to the level of the type system.

    The result is that we are closer to the ideal of mathematics (or Haskell) which are both immutable and could be evaluated by substitution with a pen and paper.

    Other nice things, like local reasoning, non-leaking abstractions, cinposability of traits and extension methods come as a consequence

    Rust is by far the best imperative language. Period

    https://lngnmn2.github.io/articles/unrestanding-rust/

    • 4 weeks ago
      Anonymous

      That article is unreadable. The overuse of in the first run-along paragraph emphasis is nauseating.

  17. 4 weeks ago
    Anonymous

    > any substantial c code uses * so youre better off writing every single instruction in pure binary
    this is what the morons who criticize the 'unsafe' keyword sound like.

  18. 4 weeks ago
    Anonymous

    is it worth learning or not this is a huge investment in time

    • 4 weeks ago
      Anonymous

      are you already familiar with C++?

      • 4 weeks ago
        Anonymous

        Not every nook and crannies but enough to write plugins for stuff

        • 4 weeks ago
          Anonymous

          Then it shouldn't really be a big time investment

    • 4 weeks ago
      Anonymous

      yes, it's worth it

    • 4 weeks ago
      Anonymous

      Worth it and I learned it without prior experience in C++.

    • 4 weeks ago
      Anonymous

      Only if you want to transition

      • 4 weeks ago
        Anonymous

        uwu

      • 4 weeks ago
        Anonymous

        Transition to a better language, that is

  19. 4 weeks ago
    bruce3434
  20. 4 weeks ago
    Anonymous

    It’s probably the greatest yak shaving platform modern devs have produced. Years of productivity wasted.

  21. 4 weeks ago
    Anonymous

    depends on what you use C for.

  22. 4 weeks ago
    Anonymous

    It's not. Remember how Ruby was supposed to be the future? This is just another iteration of that.

    • 4 weeks ago
      Anonymous

      >Remember how Ruby was supposed to be the future?
      No

      • 4 weeks ago
        Anonymous

        Literally everyone shilling Rust used to be shilling Ruby, they switched as soon as they got done running some Ruby code and realized it was too slow for systems programming
        This took 15 years because Ruby is just that slow

        • 4 weeks ago
          Anonymous

          >Literally everyone shilling Rust used to be shilling Ruby, they switched as soon as they got done running some Ruby code and realized it was too slow for systems programming
          >This took 15 years because Ruby is just that slow
          Factually incorrect.
          Rust is systems programmer language, it has literally nothing to do with managed languages like Ruby.
          I'm C++ programmer that moved to Rust. I never in my life even considered using Ruby. I also never see any Ruby discussion in Rust threads, both on IQfy and other places.

          Do you have anything to support your claim?

  23. 4 weeks ago
    Anonymous

    >compile everything with debug symbols
    >NOOOOOO WHY IS MY PROJECT SO HUGE????

  24. 4 weeks ago
    Anonymous

    Rust matters because humans are empirically incapable of writing non-trivial programs in C or C++ by hand. If you're already using formal methods then feel free to ignore Rust, but otherwise a quick glance at the latest CVEs tells you all you need to know. If you're still not convinced, consider SQLite. SQLite is written by highly skilled programmers, and is tested/fuzzed/static analyzed to a level far beyond the majority of programs, and it still has occasional memory safety bugs. Rust is special because it gives you memory safety without having to sacrifice any performance or compatibility with other code. Not even Ada gives you this (although it comes close).

    Do not confuse Rust the language with Rust programming culture. You shouldn't be surprised that Rust programming culture is as bad as every modern language's culture. The default assumption is that everything has Internet access. People are trying their best to reinvent the NPM disaster with Cargo. Very few people care about the theoretical performance benefits of Rust. Bloat is standard. Many people are there mostly to push their political views. You can ignore all that. The language itself isn't perfect, but it's the best we have.

    • 4 weeks ago
      Anonymous

      You're saying that Rust is for brainlets?

      • 4 weeks ago
        Anonymous

        brainlets are the ones that believe they're infallible

        Why does Rust exist when Ada exists?
        [...]
        No thanks, Ada is dead

        >Why does Rust exist when Ada exists?
        serves different purposes. Ada is not a general purpose programming language that can do the same things rust can. it's much more limited even with SPARK and typically uses GC

        • 4 weeks ago
          Anonymous

          >and typically uses GC
          It typically doesn't

          • 4 weeks ago
            Anonymous

            we're talking about use as a general programming language. if it doesn't use a GC then it's not using dynamic memory and knows how much it'll be working with for the life of the program. this is not how general purpose programming languages are used

          • 4 weeks ago
            Anonymous

            I don't know the details but they can do (limited?) dynamic memory allocation without GC. Something about a second stack? GNAT doesn't have a garbage collector and that's the implementation people use to do basically general-purpose stuff.

            I thought it did RAII?

            It does, but just like C++ there are holes. The most common accidental one is to create a cycle of reference-counted smart pointers. So Rust doesn't make a hard guarantee about leaks.

          • 4 weeks ago
            Anonymous

            they use arenas

          • 4 weeks ago
            Anonymous

            Ada can put things with a defined hardcap on the # of instances on the heap, but really that's not dynamic memory, that's a static fixed-size array, but put on the heap instead of in .data

        • 4 weeks ago
          Anonymous

          Ada is a state-of-the art programming language that development teams worldwide are using for critical software: from microkernels and small-footprint, real-time embedded systems to large-scale enterprise applications, and everything in between.

          Ada is general purpose programming language and has been around since 1984. The popularity of Rust is a byproduct of a successful marketing campaign.

          • 4 weeks ago
            Anonymous

            >1980s
            >state of the art
            >object oriented
            lol no

          • 4 weeks ago
            Anonymous

            >The popularity of Rust is a byproduct of a successful marketing campaign
            It's not even that popular, it's only popular between nocoders and trannies.

          • 4 weeks ago
            Anonymous

            Nocoders shill C.

        • 4 weeks ago
          Anonymous

          >and typically uses GC
          Where did you get this idea? Maybe there are JVM implementations that implicitly use GC but arguably the most common one, GNAT, doesn't. Implementations *may* implement a GC but are not required to (see 4.8 of the ARM).

          we're talking about use as a general programming language. if it doesn't use a GC then it's not using dynamic memory and knows how much it'll be working with for the life of the program. this is not how general purpose programming languages are used

          > if it doesn't use a GC then it's not using dynamic memory and knows how much it'll be working with for the life of the program.
          You can allocate types with runtime-known length on the stack or heap. It works exactly the same as malloc/free pairs in C except you use new/Unchecked_Deallocation. I don't know where you got this idea either. Have you actually used Ada or you just shitpost about it?

      • 4 weeks ago
        Anonymous

        All humans are brainlets.

    • 4 weeks ago
      Anonymous

      Why does Rust exist when Ada exists?

      Just use Ada.

      No thanks, Ada is dead

    • 4 weeks ago
      Anonymous

      >Rust matters because humans are empirically incapable of writing non-trivial programs in C or C++ by hand
      [White] Men went to the moon by hand-writing assembly. This is, for the most part, a jeet problem.
      Rust isn't popular in India, which is why you think your language is safe. When jeets pick up on it (and they will), you'll see that Rust isn't any safer than C++.

      • 4 weeks ago
        Anonymous

        >>Rust matters because humans are empirically incapable of writing non-trivial programs in C or C++ by hand
        >[White] Men went to the moon by hand-writing assembly. This is, for the most part, a jeet problem.
        You can write safe programs in assembly but you can't write safe programs in C.

        • 4 weeks ago
          Anonymous

          They are the same thing at runtime

          • 4 weeks ago
            Anonymous

            What the frick does that even mean you stupid frick? That's true of any language without a runtime.

    • 4 weeks ago
      Anonymous

      Only SPARK ada gives you some memory safety, but it's pretty much unusable for general purpose programming.

      >NPM disaster with Cargo.
      And what precisely is that disaster?

      >Very few people care about the theoretical performance benefits of Rust. Bloat is standard
      What bloat?

  25. 4 weeks ago
    Anonymous

    no use after free or double free or memory leak

    • 4 weeks ago
      Anonymous

      Safe Rust prevents use after free and double free. It does not prevent memory leaks.

      • 4 weeks ago
        Anonymous

        I thought it did RAII?

        • 4 weeks ago
          Anonymous

          RAII only prevents memory leaks in trivial data structures.

  26. 4 weeks ago
    Anonymous

    >illegible syntax to make people use python/js forever
    >trannies in administration, you can't even go through the rust tutorial without some troony shit
    >0xB00B135 and the like are forbidden, see: https://github.com/rust-lang/rust/blob/11f32b73e0dc9287e305b5b9980d24aecdc8c17f/src/tools/tidy/src/style.rs#L66
    Yup, it's rustroony time

    • 4 weeks ago
      Anonymous

      >0xB00B135 and the like are forbidden
      Doesn't seem like it. See

      Strange, why did it not identify these problematic identifiers?

      • 4 weeks ago
        Anonymous

        It's in the style guide. What that anon just did is non-idiomatic code.
        Were it for me, the compiler would instantly report him to the authorities.

        • 4 weeks ago
          Anonymous

          >It's in the style guide
          Where? You didn't link it, just some code which checks it

          • 4 weeks ago
            Anonymous

            >you just linked a file called "style.rs" which belongs to "tidy", Rust's official code style tool.
            >where is the source though???
            you understand you'll never be a woman, right?

          • 4 weeks ago
            Anonymous

            >Rust's official code style tool
            It isn't though, it's just a quick and dirty internal linter for the first-party codebase
            It only even works with the rust-lang/rust repo, look: https://github.com/rust-lang/rust/blob/11f32b73e0dc9287e305b5b9980d24aecdc8c17f/src/tools/tidy/src/main.rs#L33

          • 4 weeks ago
            Anonymous

            I see, so it's just the style tool used officially.

          • 4 weeks ago
            Anonymous

            You said it was in the style guide, link the guide
            >>you just linked a file called "style.rs" which belongs to "tidy", Rust's official code style tool.
            I do not doubt that, but if you take a look "official code style tool" and "style guide" are different words

          • 4 weeks ago
            Anonymous

            >the styling the devs use has NOTHING to do with the language's style!!!
            I don't get it, why are you rustrannies like this? Although it kinda makes sense, it's just another delusion you live under.

          • 4 weeks ago
            Anonymous

            who are you quoting?
            If you can't link me the style guide that's fine, do you know how do I run this "tidy" on my rust projects?

    • 4 weeks ago
      Anonymous

      The irony of your pic
      you're the guy on the left, moron

    • 4 weeks ago
      Anonymous

      This is a Rust thread, people came here to discuss Rust. You are the one who comes here trying to disturb the conversation.

      • 4 weeks ago
        Anonymous

        >This is a Rust thread, people came here to discuss Rust.
        >which, of course, doesn't include negative opinions of Rust!!
        Do you know what "discuss" means? outside your echo chambers, rust is despised. If you wanna have a "discussion" where everyone jerks each other's female penis, go to rust's official discord.

        • 4 weeks ago
          Anonymous

          You are still being the guy on the left.

          • 4 weeks ago
            Anonymous

            Why are you so attached to a random pic, anon?
            It doesn't change the fact that rust has more evangelists than coders. It seems to be a language exclusively composed of twitter posters and that one linux commit that Linus approved to piss off Bjarne.

          • 4 weeks ago
            Anonymous
    • 4 weeks ago
      Anonymous

      >guy on left is moisturized and unbothered, staying in his lane.

  27. 4 weeks ago
    Anonymous

    I don't see any reason to hate trannies.

  28. 4 weeks ago
    Anonymous

    I love C, Rust sucks for embedded and osdev but for anything above the OS layer it's annoying having to reimplement everything or dealing with memory management. GC is terrible though. C++ is also bloated and the syntax is dogshit. So what do you do? You pick the trans girl language. I despise the community around it but it's a joy to work with for things like CLI tools or writing a wayland compositor. Basically anything above OS layer, you want to use Rust. Or Go if you can't find a specific library for Rust.

  29. 4 weeks ago
    Anonymous

    Everything about Rust, the design of the language, the paradigms, the concepts, the syntax, makes me want to projectile vomit. It's a language that forces you to think more about the language than your problem. Hard pass.

    • 4 weeks ago
      Anonymous

      >It's a language that forces you to think more about the language than your problem.
      That's C

      • 4 weeks ago
        Anonymous

        nta, also lurking bc im genuinely interested in the discussion
        but thats the opposite of C.
        in theory you could get there with any language, but C has a very limited set of symbols.
        and may i remind you that the body of knowledge needed grows with the square of the count of symbolsn because you need to learn how they interact with eachother

        and this is why every C afficionado is so anal about formatting. its all about removing cognitive overhead

        • 4 weeks ago
          Anonymous

          >its all about removing cognitive overhead
          Rust gave up on all that and accepts high cognitive load as an inescapable fact of life.

          • 4 weeks ago
            Anonymous

            fundamentally its a good idea if your workforce is of varied competence levels
            .
            they traded working memory (modelization) skills for dead memory (by-heart). (im esl, sorry if i use the wrong terms)
            so in a way, the maturation of a C-like programmer is offset into a bigger effort to learn the rust language. maturation which usually happened on the job. (im not pointing fingers, just saying whats the rationale behind rust. i think)

            doesnt excuse the lack of effort to streamline the syntax. some symbol choices are wholesale bad bc of a lack of distinction in the code, and this is 100% objective. (you wouldnt want to paint your stop sign in camo colors). and im not sure about the whole borrow checker things and such, but i cant really discuss the subject; i think theres better solutions but i couldnt clearly demonstrate that. 'didnt give a possible alternative much thought to be honest

          • 4 weeks ago
            Anonymous

            >bigger effort to learn the rust language.
            and operate that language
            >maturation of a C-like programmer
            understanding/appropriating how data flows. this is replaced by procedure that can be by-hearted in rust. instead of controlling the locality and lifetimes of the data, theres a borrow checker and structures i mean

        • 4 weeks ago
          Anonymous

          No it's not.
          The simplest things in C require high effort. Compare parsing a CSV in C vs. python. Your C code is gonna be a hundred lines at least and is probably gonna crash on a malformed row. That's the opposite of focusing on the problem you're trying to solve.

          • 4 weeks ago
            Anonymous

            python is written in C doe.

          • 4 weeks ago
            Anonymous

            And?
            Show me your two liner to read a CSV in C with pandas. It should be easy, Python is written in C after all, right sweatie?

          • 4 weeks ago
            Anonymous

            kek.
            open your ide and look at how your wrote it in "python"

          • 4 weeks ago
            Anonymous

            What are you even trying to say, troony?

          • 4 weeks ago
            Anonymous

            Why are you comparing C to Phyton? Parsing a CSV better be easier in Python than it is in C. Otherwise, what's the point?

          • 4 weeks ago
            Anonymous

            parsing a CSV is incredibly simple in any language, you just check for custom separator then read "[value][separator]" till EOF. The logic is identical for pretty much every language, including our purely functional friend Haskell.
            I guess that anon is a rustroony, so he'd spend a week fighting the compiler to get this simple code to work.

        • 4 weeks ago
          Anonymous

          Managed languages are the ones that remove cognitive overhead. Rust goes the opposite way, it forces you to be aware of everything and demands you to write code in a way that ensures correctness. On the other hand, C only appears to be simple on the surface. But in reality, everything you'd struggle with in Rust, is just as relevant in C. The only difference is that C doesn't check any of that at compile time, and your mistakes will result in hard to debug runtime errors.

          • 4 weeks ago
            Anonymous

            >Managed languages are the ones that remove cognitive overhead.
            were talking about stuff that you cannot do with managed languages tho
            well, you could, for a part of low level stuff were talking about, but C-like and rust operate on a level youre deliberately kept from in managed languages.
            its like, managed languages are from the point of view of car making
            and rust/c are a discussion about industrial car making machines

          • 4 weeks ago
            Anonymous

            I honestly can't decipher what your post is trying to say.

          • 4 weeks ago
            Anonymous

            managed languages remove cognitive overhead. (sometimes they dont but lets not talk about failures)
            but there a tradeoff: you lose fine control of your computer.
            and theres another computing cost tax in the form of generalist solutions.

            and when you need to do something very fast or deal with a great amount of data it become impractical or even impossible to solve the problem in a managed language environment.

            theres also the problem that managed languages leverage the functionalities of an os.
            but if you write the os itself, what do?

            and this is why managed languages are a whole different league and the comparison doesnt really make sense

          • 4 weeks ago
            Anonymous

            Yeah, that's the point.
            And it does make sense to compare them. You literally did just that in your post.
            Managed languages take away some of the cognitive load in exchange for suboptimal performance. That's the point, that's what they do. They offer higher level abstractions that are easier to wrap your head around but also introduce additional performance cost.

          • 4 weeks ago
            Anonymous

            >And it does make sense to compare them. You literally did just that in your post.
            its like if you compared a ship engine to what sits in a toyota and say "but the toyota has more rpm!"
            it can be done. doesnt mean it makes sense if you do so.

            yeah, one goes into a toyota, the other gets installed into a ship. congrats, its what it says on the tin.

        • 4 weeks ago
          Anonymous

          You're thinking more about the language than the problem, because C has very few ways to compartmentalize and reuse solutions.
          Fewer symbols don't reduce cognitive load, abstraction does.

          • 4 weeks ago
            Anonymous

            >You're thinking more about the language than the problem, because C has very few ways to compartmentalize and reuse solutions.
            you dont really need anything more than pointers and pointer arithmetic doe.
            >compartimentalization
            yeah, skill issue. rather wrong training. in my (limited, but existent) experience oop is a matter of style. theres really no discernible advantage to either fp or oop. its just that instead of a dot you put an underscore (snakecase. if youre rational in your naming, thats the practical difference between oop and fp)

          • 4 weeks ago
            Anonymous

            >theres really no discernible advantage to either fp or oop
            fp is a whole different beast, don't think it's just those pythonic "map(f, iterable)" calls.

          • 4 weeks ago
            Anonymous

            >whole different beast
            not to my eyes.
            t. coded in php, js, c#, but mainly python when i started, and since 5 years i code only in c

            i never worked in a corporate setting doe
            so obviously if your manager is a tyrant about "le clean code" then oop is very different indeed.
            but corporate is fricking moronic and they should be ignored wherever possible

          • 4 weeks ago
            Anonymous

            >t. coded in php, js, c#, but mainly python when i started, and since 5 years i code only in c
            but anon... none of these are functional.
            Have you tried Haskell yet?

          • 4 weeks ago
            Anonymous

            >fp, haskell
            i stand corrected
            its alien hieroglyphics
            i think i meant procedural then

          • 4 weeks ago
            Anonymous

            >you dont really need anything more than pointers and pointer arithmetic doe
            Literally the most BASIC shit like differentiating arrays from pointers is missing
            >int**
            is this a pointer to an array of pointers, or a pointer to a pointer to an array, a pointer to an array of pointers to arrays? You don't know, you can't know, unless you read a comment that (HOPEFULLY) someone left.

            You need pointers? I'll do you one better, you don't need them. Just make int always address-sized. Is this int a number or an address of a number? Or an address of something else? Who the frick knows! That's how assembly does it.

            Thanks to this moronic minimalism wanking, even POSIX, the holy cnile grail of muh standards and muh portability, has different interfaces on different platforms. Precisely the ** problem I described.

            >limited
            you don't say
            >its just that instead of a dot you put an underscore (snakecase. if youre rational in your naming, thats the practical difference between oop and fp)
            what the frick are you talking about moron, stop guessing what shit you don't know is

            >whole different beast
            not to my eyes.
            t. coded in php, js, c#, but mainly python when i started, and since 5 years i code only in c

            i never worked in a corporate setting doe
            so obviously if your manager is a tyrant about "le clean code" then oop is very different indeed.
            but corporate is fricking moronic and they should be ignored wherever possible

            >i never worked
            stop having opinions

          • 4 weeks ago
            Anonymous

            holy venom
            who touched you and when?

            >nuh work
            i still get residuals from 100 lines of code i wrote almost a decade ago now.
            nmp + dilate, wageslave.

            on second thought i think i know where the venom comes from, now

          • 4 weeks ago
            Anonymous

            The venom comes from having to deal with someone "genuinely interested in the discussion" that keeps spouting his uninformed opinion as fact and using terms they don't understand. All while they're unemployed and too fricking broke for a keyboard with a working shift key.

          • 4 weeks ago
            Anonymous

            youre the one spouting nonsense tho.
            'guess being employed doesnt mean that much

          • 4 weeks ago
            Anonymous

            >differentiating arrays from pointers
            They are the same thing at runtime

          • 4 weeks ago
            Anonymous

            So is literally everything else

    • 4 weeks ago
      Anonymous

      woman behavior. none of that is logical

      • 4 weeks ago
        Anonymous

        Rust makes simple things complicated. That's the simplest way I can put it. If that's not logical enough for you, then I'm sorry.

        • 4 weeks ago
          Anonymous

          Safe and performant systems programming is not simple by any means.
          That's the impression of newbie programmer that think good programmers just don't make mistakes.

          • 4 weeks ago
            Anonymous

            If it's not simple you did it wrong. That's the fundamental problem. We through out simplicity and created a monster. Now we're trying to tame the beast with another beast. The whole thing is getting worse.
            But if you don't agree, another way to put it is Rust makes complicated things even more complicated and opaque.

          • 4 weeks ago
            Anonymous

            >If it's not simple you did it wrong.
            Tell that to OpenSSL programmers. Or Windows programmers. Or Linux programmers. Or literally any larger project.

            Your ignorance is a perfect example of dunning–kruger effect.

          • 4 weeks ago
            Anonymous

            And this is the perfect example of the Rust mentality: give up, the war on complexity was lost.

    • 4 weeks ago
      Anonymous

      reminds me of this

      • 4 weeks ago
        Anonymous

        Lol, where is this from and was it debated seriously (likely by autists)?

        • 4 weeks ago
          Anonymous

          autism is a crippling handicap tho
          stopped reading the second i understood the guy is making a link between aspergers and intellectual performance

        • 4 weeks ago
          Anonymous

          Slashdot
          They really hate Rust

      • 4 weeks ago
        Anonymous

        >Even the supposedly stable Rust 1.x release branch has seen 19 minor releases!
        kek they're up to at least 73 now. The real issue isn't autism, it's that they can't slow down to write a spec (or at least a set of guidelines for what the frick the language should look like) and instead blaze ahead with no concern for where they end up

        autism is a crippling handicap tho
        stopped reading the second i understood the guy is making a link between aspergers and intellectual performance

        Aspergers is like +5 INT -6 CHR -3 WIS. Nothing specifically prevents a sperg from being smart and sociable but it is much more difficult than for someone that rolled normal stats

        • 4 weeks ago
          Anonymous

          no.
          autism is you get panic attacks when you see new people and play with legos aged 34
          oh, and you like rocking. as you sit and rock back and forth like a mong.

        • 4 weeks ago
          Anonymous

          They do a new release every six weeks no matter what. Some releases don't have anything interesting. If anything that means they don't have to rush language design, because there are no heavy deadlines—in C++ if you don't get something into the next standard you'll have to wait three whole years but in Rust it just adds six weeks, no big deal.
          Getting a feature into Rust is a long process. For something major you're looking at pre-RFC -> RFC -> implementation -> code review -> unstable public testing phase -> various changes -> discussion about whether the design is good enough (+ bikeshedding over names) -> stabilization -> beta release -> full release.
          They're careful and they have a good idea about where they want to end up and they now want to create a full spec that covers everything not covered by the existing docs and reference: https://rust-lang.github.io/rfcs/3355-rust-spec.html

    • 4 weeks ago
      Anonymous

      Go lang was made specifically for people like you.

    • 4 weeks ago
      Anonymous

      >muh aesthetics
      damn, troon, I guess you are a woman after all

  30. 4 weeks ago
    Anonymous

    Here's Rust in a nutshell
    >I don't have a job and my personality makes me borderline unemployable even though people say I'm smart
    >I've rewritten a common piece of software in a much more complex language demonstrating I'm so smart you need to look past my personality issues
    >Hire me

    • 4 weeks ago
      Anonymous

      >>I don't have a job and my personality makes me borderline unemployable even though people say I'm smart
      >>I've rewritten a common piece of software in a much more complex language demonstrating I'm so smart you need to look past my personality issues
      >>Hire me
      Perfect description of an average cnile in this board. No wonder they yell at employed web devs while flipping burgers.

      • 4 weeks ago
        Anonymous

        I have a C job. We ship code that works. Flipping burgers is more dignifying than cutting your nuts off and screaming at people trying to get shit done to satisfy your own pathology.

      • 4 weeks ago
        Anonymous

        Every C dev I've ever met was a cool dude, idk where you've been hanging.

  31. 4 weeks ago
    Anonymous

    It's not.

  32. 4 weeks ago
    Anonymous

    Pros:
    >borrow checker prevents most memory errors
    >send/sync make it easier to avoid race conditions in multi-threaded programs (note that you can still have race conditions in 100% safe Rust)
    >types are more powerful than C and much cleaner than C++
    >rust enums are much nicer to work with than tagged unions or std::variant (puke)
    >traits are superior to classes in most cases (except for UI design)
    >benefits you even if you return to C or C++, by forcing you to learn how proper memory management works
    >easy to use dependencies
    Cons:
    >you MUST completely restructure your program logic to work with the borrow checker (no splitting borrows, no circular references)
    >fundamentally impossible to write a good UI library in Rust
    >async is poorly designed (no way to yield to another task)
    >fragmentation hell (expect to pull in hundreds of dependencies for a trivial program)
    >ugly syntax
    >radioactive community
    I really want to like Rust, but I just can't.

    • 4 weeks ago
      Anonymous

      >you MUST completely restructure your program logic to work with the borrow checker (no splitting borrows, no circular references)
      If your program needs a data structure that deals with circular references, you can use unsafe with things like Option<NonNull<T>>. But otherwise yes, you do have to write things different. Lots of programming languages have a philosophy of design, and Rust is no different. When you get used to Rust's philosophy, it isn't that difficult to write in.
      >fragmentation hell (expect to pull in hundreds of dependencies for a trivial program)
      This is the case with a lot of modern programming languages. But the alternative with C and C++ is that dependency management across multiple platforms is a herculean task that makes most people just write everything from scratch.

    • 4 weeks ago
      Anonymous

      impossible to write a good UI library in Rust
      how so?

      • 4 weeks ago
        Anonymous

        The needs of UI are contrary to Rust's memory model. UI requires mutable aliasing, which Rust has no first-class support for.

        • 4 weeks ago
          Anonymous

          Couldn't Arc<T> be used for that purpose?

        • 4 weeks ago
          Anonymous

          >UI requires mutable aliasing
          Retained UI does, in the common case where you want your event callbacks to be able to mutate other parts of the UI. Immediate-mode UI works fine with Rust's model. Unfortunately as far as I know it's still in the state where there are 9999 half-baked prototypes and no stable/usable implementations.

          • 4 weeks ago
            Anonymous

            The needs of UI are contrary to Rust's memory model. UI requires mutable aliasing, which Rust has no first-class support for.

            Pros:
            >borrow checker prevents most memory errors
            >send/sync make it easier to avoid race conditions in multi-threaded programs (note that you can still have race conditions in 100% safe Rust)
            >types are more powerful than C and much cleaner than C++
            >rust enums are much nicer to work with than tagged unions or std::variant (puke)
            >traits are superior to classes in most cases (except for UI design)
            >benefits you even if you return to C or C++, by forcing you to learn how proper memory management works
            >easy to use dependencies
            Cons:
            >you MUST completely restructure your program logic to work with the borrow checker (no splitting borrows, no circular references)
            >fundamentally impossible to write a good UI library in Rust
            >async is poorly designed (no way to yield to another task)
            >fragmentation hell (expect to pull in hundreds of dependencies for a trivial program)
            >ugly syntax
            >radioactive community
            I really want to like Rust, but I just can't.

            egui just werks.

          • 4 weeks ago
            Anonymous

            >9999 half-baked prototypes
            Where are the rewrite everything in Rust people when you need them? This would be a good reason to rewrite some UI libraries to Rust.

          • 4 weeks ago
            Anonymous

            Half-baked prototypes are what rewrite everything in rust people produce.

          • 4 weeks ago
            Anonymous

            Egui is heavily inspired by imgui.

          • 4 weeks ago
            Anonymous

            You mean DearImgui?

  33. 4 weeks ago
    Anonymous

    so, check this out IQfyuys – bosses barged in today, legit chanting "rust! rust! rust!" like, what? it's not the usual office vibe, more like they've joined a cult, going nuts over this programming language. and get this – product managers, bosses, everyone's sippin' the rust kool-aid. feels like a software uprising, but with a rebellious twist. they're on a mission to rust-ify everything, swear it's the code savior. meetings? now rust sermons. office? buzzing with keyboards converting to the rust side. the whole place caught this coding fever, and i'm just here, trying to roll with the weird "rust! rust! rust!" soundtrack in the background coding in my trusty C.

    i feel like my days are numbered IQfyuys.

  34. 4 weeks ago
    Anonymous

    it's not, Go and Zig pretty much cover all use cases.
    Hell, Go is very easy to use and can be absurdly fast.
    Without any fiddling it'll beat or match Zig/Rust (yes, I'm talking about release builds).
    You can definitely beat go, but the code starts becoming unreadable most of the time.
    Not to mention, lots of stuff will have IO being the bottleneck. For example, you're reading a huge file (in chunks), running some stuff over the chunks. Most of the time will be spent reading the chunks, as Go and all the others will probably do the processing ops very fast.
    Go does make concurrency ridiculously easy.

    • 4 weeks ago
      Anonymous

      >Without any fiddling it'll beat or match Zig/Rust (yes, I'm talking about release builds).
      doesn't Go lose to even Haskell at that one benchmark test?

  35. 4 weeks ago
    Anonymous

    Every Rust release announcement I see has like 20 new features. And they want to cram this into every piece of critical software they can get their hands on.

    • 4 weeks ago
      Anonymous

      You have to understand, the troony's purpose in life is to shove itself in places where no one wants them. As every creation mirrors its creator, it became rust's purpose as well.

  36. 4 weeks ago
    Anonymous

    What I wanted
    >ML dialect with pointers and no garbage collection, self-compiling and bootstrappable from ANSI-C
    What I got
    >The worst parts of C++ grafted onto a mangled ML dialect afflicted with babbies first substructural type system and an absolutely autistic stdlib scoping scheme, compiled by LLVM and made so bloated that there is zero chance in hell of ever having another FOSS compiler in its miserable lifespan

    • 4 weeks ago
      Anonymous

      Myr/Myrddin was closer to what you wanted but I think it's dead
      The compiler backend was used to make Hare

      • 4 weeks ago
        Anonymous

        Oh I know Ori. He hangs out with the 9front people. Last I heard (circa 2022) it wasn't dead.

  37. 4 weeks ago
    Anonymous

    It has allowed corporations to trick autists into rewriting GPL code into MIT code, thus increasing productivity.

    • 4 weeks ago
      Anonymous

      GPL is already dead, with or without Rust.

    • 4 weeks ago
      Anonymous

      Microsoft already did that with Copilot. You can now recycle whatever GPL'd code their glorified autocomplete decides to output for you.

  38. 4 weeks ago
    Anonymous

    The clippy in-line warning/error extension in vscode is really nice and I want it for every language.

  39. 4 weeks ago
    Anonymous

    All the b***hing is relegated to compile time. It’s like being able to lock your wife in a cellar for most of the day.

  40. 4 weeks ago
    Anonymous

    What a high quality thread this has been!
    Good bye

    • 4 weeks ago
      Anonymous

      nobody asked. especially not me.
      if you want me to care maybe dont act like a fricking brat

      • 4 weeks ago
        Anonymous

        I'm not even whoever the frick you were talking to but carry on

        • 4 weeks ago
          Anonymous

          yoiure telling me you were unironical?
          i find it hard to believe

          • 4 weeks ago
            Anonymous

            I'm saying you spent the whole thread replying to someone else and I popped in every couple hours to watch this shitshow unfold like a three hundred car pileup during a tsunami
            I salute both of you!

          • 4 weeks ago
            Anonymous

            i might have hooked you, but otherwise im replying to (you)'s tho

          • 4 weeks ago
            Anonymous

            anyhoo
            you seem like somene positive
            i salute you too!

Your email address will not be published. Required fields are marked *