Why do all the Rust killers kill themselves? >Nim

Why do all the Rust killers kill themselves?
>Nim
GC, after all these years their major accomplishment is a web framework that has no websites or API reference.
>Crystal
Can't figure out what GC they are going to use, last I checked they wanted to port Scala's Immix GC
>cpp2/cppfront
Pipe dream of some C++ boomer that has and will gain no traction. Literal definition of putting lipstick on a pig
>Odin
Who
>Carbon
Yet another entry of killedbygoogle.com

Homeless People Are Sexy Shirt $21.68

Tip Your Landlord Shirt $21.68

Homeless People Are Sexy Shirt $21.68

  1. 4 weeks ago
    Anonymous

    Zig is alive.

    • 4 weeks ago
      Anonymous

      >permanently pre v1.0

    • 4 weeks ago
      Anonymous

      >worse aliasing bugs than a COMPSCI 101 student project
      >alive
      Lol

      • 4 weeks ago
        Anonymous

        >@andrewrk - since this issue is a high priority, it might be worth having a one-time compiler / language design meeting to discuss how to solve it? Whatever we decide will have spec implications.
        >andrewrk modified the milestones: 0.12.0, 0.13.0 7 hours ago

        • 4 weeks ago
          Anonymous

          >they'll fix it eventually
          Don't care, to make such a mistake in the first place is unacceptable, and it going unnoticed for months is proof that there's no actual development being done in Zig.

    • 4 weeks ago
      Anonymous

      >No ownership rules and/or borrow checker
      >No memory safety at all aside from a few runtime checks
      >No RAII at all not even a limited version for just pointers
      >Must pass an allocator on every function that allocates
      >Async cancer is present in the language
      >Zig is alive
      Is it? Or is it just an experiment on bad language design decisions?

      • 4 weeks ago
        Anonymous

        Part of the goal of Zig is to prove that using static analysis to enforce memory safety is unnecessary and burdensome to the prograSegmentation fault (core dumped)

      • 4 weeks ago
        Anonymous

        Rust wants to be C++
        Zig wants to be C

        • 4 weeks ago
          Anonymous

          >randomly decay by-value objects into mutable pointer https://github.com/ziglang/zig/issues/19011
          >using by-reference parameter copies the entire object https://github.com/ziglang/zig/issues/16343
          yes it might have surpassed C lmao

          • 4 weeks ago
            Anonymous

            >might have surpassed C lmao
            In moronic language design decisions, yes.

  2. 4 weeks ago
    Anonymous

    I personally would prefer Crystal to succeed.

  3. 4 weeks ago
    Anonymous

    Carbon hasn't been properly released and Go has been surprisingly successful. But Carbon will probably be trash anyways.

    • 4 weeks ago
      Anonymous

      But Go isn't designed to compete with Rust. It's designed to compete with Python.

    • 4 weeks ago
      Anonymous

      Go is shit, also this:

      But Go isn't designed to compete with Rust. It's designed to compete with Python.

  4. 4 weeks ago
    Anonymous

    GC is optional in Nim, also is no longer the default for the current stable version, which uses ref counting

    • 4 weeks ago
      Anonymous

      >GC is optional in Nim
      >uses ref counting
      Reference counting is a form of automatic garbage collection. It's not a tracing GC but a form of garbage collection nonetheless. Definitely not manual memory management then, right?

      • 4 weeks ago
        Anonymous

        https://nim-lang.org/docs/mm.html
        Nim's ARC is basically C++'s smart pointers. ORC, the current default, is ARC with cycle detection. If you want manual memory management, use --mm:arc or --mm:none. The latter does not free anything allocated when using the standard library or builtin string/seq types. So there's plenty of options if manual memory management is absolutely necessary.

        • 4 weeks ago
          Anonymous

          >--mm:none. Allocated memory is simply never freed. You should use --mm:arc instead.
          >Reference cycles are handled by a cycle collection mechanism based on "trial deletion".
          So let me get this straight, your options are: some full GC, reference counting but with a tracing GC for cycle collection, or just never freeing any memory?

          This is not a systems programming language at all, it's at best just another GC'd language that will compete with Golang. You can't compete with the likes of C, C++ and Rust when your language requires garbage collection.

          • 4 weeks ago
            Anonymous

            You can still free memory with --mm:none, the compiler just doesn't do it for you (just like C). I don't have experience using this mode but I imagine you would have to call GC_unref manually on any string or seqs you use when done with them.

            So your options are GC, reference counting with or without a tracing GC, or no management whatsoever. What else do you want?

          • 4 weeks ago
            Anonymous

            >You can still free memory with --mm:none
            That's clearly not what the website says, it also seems to discourage its use.

            >I imagine you would have to call GC_unref manually
            So there's no first-class native alloc APIs, you have manually call GC functions? Please stop pretending that Nim isn't a garbage collected, after reading the link it's painfully obvious that it was not designed for manual memory management.

            >What else do you want?
            Manual memory management built-in with first-class language support, not as an afterthought or an awkward alternative to the default GC usage. I can also call malloc and free in unsafe C#, but it's fricking awkward without first-class support for it.

          • 4 weeks ago
            Anonymous

            >That's clearly not what the website says, it also seems to discourage its use.
            The website says memory is allocated but never freed, it does not say you cannot free memory yourself, ie, creating a ref object will result in an allocation, but it will never be freed unless you do so yourself. --mm:none is discouraged because you would only use it in very niche cases. ARC/ORC is suitable for most applications imo.

            >So there's no first-class native alloc APIs, you have manually call GC functions?
            There are functions for allocating and deallocating memory in system module, the GC_* functions are typically used for interfacing with C, not sure if you're supposed to use them in that case.

            Nim with ARC/ORC isn't a GC language, that would be like saying using smart pointers in C++ is GC. The runtime cost is simply not the same as a full fledged GC.

            >Manual memory management built-in with first-class language support
            What like C++'s new/delete? A type-safe version of malloc+free? It's not hard to make something like that in Nim with its macro system.

  5. 4 weeks ago
    Anonymous

    They have severely underestimated the difficulty of doing what Rust is trying to do, and they don't have enough literal geniuses like Niko Matsakis to carry out their plans

  6. 4 weeks ago
    Anonymous

    >incapable of criticizing Odin
    >avoids bringing up Zig entirely
    kek. pretty solid advertisement.

    • 4 weeks ago
      Anonymous

      I will criticize Odin
      It's a shitty Jai clone made by a guy who apes Blowjon's ludicrous confidence but doesn't have the technical chops to put his money where his loud stupid mouth is
      Ask him about ownership some time
      Or don't bother and just wait for Jai to come out and fricking destroy Odin

      • 4 weeks ago
        Anonymous

        >Ask him about ownership some time
        i'll ask you first. what about ownership?

        • 4 weeks ago
          Anonymous

          Ownership semantics originated as a mental model that programmers can use to analyze the lifetimes of any objects reachable from the stack frames of the functions in their call graph
          Ginger Bill does not understand the difference between a mental model and codified language features, so when someone mentions it he jumps down their throat while chanting "Odin doesn't have that" over and over until they shut up

          • 4 weeks ago
            Anonymous

            i'll keep that in mind anon

      • 4 weeks ago
        Anonymous

        >Jai
        literally vaporware

      • 4 weeks ago
        Anonymous

        Jai is never coming out and exists solely to farm cult coins

    • 4 weeks ago
      Anonymous

      Drew is getting smart

  7. 4 weeks ago
    Anonymous

    there is no such a thing as Rust
    its compiler and crates are made of C/C++

    • 4 weeks ago
      Anonymous

      Works on my machine

    • 4 weeks ago
      Anonymous

      Gross. They need to be rewritten in memory-safe Rust asap

      • 4 weeks ago
        Anonymous

        >They need to be rewritten
        Good luck rewriting the LLVM backend with over 2 million lines of C++ into "memory-safe Rust".

        • 4 weeks ago
          Anonymous

          Yeah, that's so much fricking code it's ridiculous to even suggest someone would even try
          Anyway they named it Cranelift

          • 4 weeks ago
            Anonymous

            Ah yes, rustlet disinfo. Cranelift is NOT a rewrite of LLVM from C++ into Rust.

            >Planned uses
            >Cranelift is designed to be a code generator for WebAssembly
            It doesn't even meant to be a replacement for LLVM. LMAO.

            >The speed of Cranelift's generated code is ~2% slower than that of V8 (TurboFan), and ~14% slower than WAVM (LLVM).
            The generated code is ~14% slower than LLVM and that's when using LLVM as a JIT compiler, not when all the slowest and best optimization passes are applied to the code. Try again, rustlet.

          • 4 weeks ago
            Anonymous

            You will get replies arguing with you and trying to tell you it's literally usable now as an LLVM alternative in the official Rust compiler, but that's not what brings me here
            I just think it's mind-boggling to even think about competing with LLVM or any similarly huge project
            QBE is another example (but I didn't mention it before because it's written in C)

          • 4 weeks ago
            Anonymous

            ESL

  8. 4 weeks ago
    Anonymous

    >inventing an entire language because morons exist who can't valgrind
    no thanks, not using it, not even once, rust is for morons

    • 4 weeks ago
      Anonymous

      >valgrind
      I prefer catching errors in compile time. Cry harder cnile.

  9. 4 weeks ago
    Anonymous

    do you guys think hare's planned addition of linear types will get somewhere? also do you think no generics is a good idea? (i do, i think it's smart to avoid adding metaprogramming to the core language because it makes analysis much easier)

    • 4 weeks ago
      Anonymous

      >do you think no generics is a good idea?
      NO! Generics are not metaprogramming, it's a way to create reusable components. Have fun writing a hash table library without generics, I'm guessing Drew thinks that working with other people's types is unnecessary.

      • 4 weeks ago
        Anonymous

        having one generic routine compile to various type-specific codepaths depending on code context is very much a form of metaprogramming
        you don't even seem to know exactly what generics are if you think you won't work with other people's types without them
        all no generics means is that you won't be writing libraries that consume arbitrary types, which is a good thing because feature-rich generic libraries are bloat that have lots of cruft you're not going to need for your usecase, so it's better to just write data structures that are tailor-made to your usecase anyway

    • 4 weeks ago
      Anonymous

      >hare
      Lol
      >no generics
      >...and that's why it's a good thing!
      Lmao, even.

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