Aside from some exceptions, human species have collectively moved on from consuming their own excrement into much more palatable and sanitary foods.

Aside from some exceptions, human species have collectively moved on from consuming their own excrement into much more palatable and sanitary foods. We don't look back at our ancestors ways and reminisce about the old days where consuming clean cooked food wasn't in the grasp of the imagination. Yet, the sentiment among the older folk in academia seem to agree that we should go back to our old ways and learn C programming before moving on to much more versatile and easier to use programming languages. These new programming languages, which mostly abstract away the memory management and commonly used algorithms into simple function calls, seems to be most logical choice if you actually want to be productive and not the make the next person who was unfortunate enough to be tasked to read your code fill with rage. What gives?

Shopping Cart Returner Shirt $21.68

The Kind of Tired That Sleep Won’t Fix Shirt $21.68

Shopping Cart Returner Shirt $21.68

  1. 1 month ago
    Anonymous

    People don't like to admit that they're wrong and/or wasted a bunch of time, simple as
    It's not just exclusive to programming

  2. 1 month ago
    Anonymous

    Still the fastest. You can write slow code if you want, I guess

    • 1 month ago
      Anonymous

      >still the fastest, if you ignore compilers that produce better code

      • 1 month ago
        Anonymous

        >part of the toolchain
        when are you going back to your troonycord?

        • 1 month ago
          Anonymous

          >part of the toolchain
          written in the better language than C because C is worthless

      • 1 month ago
        Anonymous

        >MUH COMPILERS!!!
        Another moronic claim from the moronic blog post that trannies believed about C.

        All good compilers employ the same types of optimizations. C is generally faster than other languages at any level of optimization including optimizations off. The reasons for this are actually quite simple to anyone who actually grasped EE, though it eludes those who either never studied it or got through it by cheating.

        • 1 month ago
          Anonymous

          C is "fast" because it has more complicated compilers.

          http://justine.lol/endian.html
          >Now you might be looking at the code above and be thinking, surely that's the slowest thing imaginable. Here's a israeliteel from the TensorFlow codebase expressing that sentiment:

          // Fall back on a non-optimized implementation on other big-endian targets.
          // This code swaps one byte at a time and is probably an order of magnitude
          // slower.
          #define BYTE_SWAP_64(x)
          ~~*(x)&0x00000000000000ffUL) << 56) | ~~*x)&0x000000000000ff00UL) << 40) |
          ~~*x)&0x0000000000ff0000UL) << 24) | ~~*x)&0x00000000ff000000UL) << 8) |
          ~~*x)&0x000000ff00000000UL) >> 8) | ~~*x)&0x0000ff0000000000UL) >> 24) |
          ~~*x)&0x00ff000000000000UL) >> 40) | ~~*x)&0xff00000000000000UL) >> 56))

          >That might have been true with old compilers, but it's not true today. The more verbosely well-defined your code is, then with a good modern compiler, the smaller the generated code will be. Here's what we get if we run it through clang.godbolt.org:

          • 1 month ago
            Anonymous

            >turn optimizations off
            >C still faster
            >"dude it's the compiler"
            Frick off moron.

          • 1 month ago
            Anonymous

            [...]
            I posted your friend's site because C programmers don't listen to people unless they worship C and Unix.
            http://justine.lol/sizetricks/
            >I like the UNIX philosphy of having lots of small programs. I like it so much, that the Cosmopolitan repository builds hundreds of them.
            That means you will believe what he says about C compilers being the reason C is fast. If I quoted someone who said C is bad, you would ignore the post and say it doesn't count.

            >MUH NARROW CASE!
            >WHAT ABOUT MUH NARROW CASE???
            It doesn't even prove what you claim it proves. Compiler changes have altered the best approach but that's not even remotely the same as
            >hurr it's always fast only because muh compiler
            Narrow case aside: his recommendation of "Mask, and then shift" is something C is good at that higher level languages often put behind indirection making them slower. You ironically provided an example of why C is often faster, not that C is only fast due to compilers. (Rust would probably be as fast, but in a lot of languages manipulating bytes and bits in a memory block or string always invokes a function and/or additional pointer indirection, making it slower.)

            Take a set of algorithms from LeetCode or HackerRank and implement them in various languages including C. C is often faster with the same exact solution. It can be orders of magnitude faster with a C optimal solution. When it's faster, it's faster even if you turn optimizations off or use an older compiler. This is not always true, sometimes another language is faster or just as fast. But it's generally true and recognized in studies of performance and energy use.
            https://thenewstack.io/which-programming-languages-use-the-least-electricity/

            Your stupid blog post on "muh pdp-11 muh C" is false top to bottom, written by someone who never grasped EE. Every point he made is easily disproven, including the false claim "it's just the compiler bro!" And someone versed in logic yet completely ignorant about computers could figure out that the compiler claim is false. How?
            >if it's just the compiler then why don't other languages implement the same optimization tricks for the same performance?
            It's either not just the compiler, or everyone working on compilers for other languages is a fricking idiot.

            Now frick off with your dumb shit. Why are you even obsessed with C? Did you fail a class?

          • 1 month ago
            Anonymous

            >Narrow case aside: his recommendation of "Mask, and then shift" is something C is good at that higher level languages often put behind indirection making them slower.
            It's not "mask, and then shift" it's big/little endian. C forces you to write "mask, and then shift" because it has no way to express "reverse the bytes." The C compiler has to figure out what that specific case of "mask, and then shift" means and optimize it.

            >>if it's just the compiler then why don't other languages implement the same optimization tricks for the same performance?
            Because they don't need the tricks.

          • 1 month ago
            Anonymous

            >It's not "mask, and then shift" it's big/little endian.
            You didn't even read the article you damn moron. picrel

            >C forces you to write "mask, and then shift" because it has no way to express "reverse the bytes."
            >WHY DOESN'T C GIVE ME A MAGIC BLACK BOX???
            As expected, you go and prove that you are completely ignorant about computers and EE. Your magic function in MemeLanguage is doing one of two things under the hood:
            - Telling the CPU what endianness to use when loading values as many CPUs are bi-endian. Or...
            - Using a similar algorithm to reverse the bytes. Probably the exact same algorithm in C since C was used to implement MemeLanguage's runtime.
            You remind me of someone who once told me their solution was O(n) when they had to call a sort function for it to work. To them the language sort function was magic and literally sorted the array in a single step.

            >The C compiler has to figure out what that specific case of "mask, and then shift" means and optimize it.
            No, it just optimizes masks and shifts in all cases. It does not have code specifically looking for and optimizing byte reversal. Holy shit.

            >runs slower, sometimes many times slower
            >"Because they don't need the tricks."
            LMFAO. You are completely ignorant about all of this. Both the CPU and the functions you use in MemeLanguage are little black magic boxes to you. Stop posting and go learn something. You are literally at the level of "but sort is one function call, it's one step!" You have so much to learn.

          • 1 month ago
            Anonymous

            the rustroony is too moronic to understand half of what you wrote
            but i sure did enjoy the exposition
            same with that one

            [...]
            >MUH NARROW CASE!
            >WHAT ABOUT MUH NARROW CASE???
            It doesn't even prove what you claim it proves. Compiler changes have altered the best approach but that's not even remotely the same as
            >hurr it's always fast only because muh compiler
            Narrow case aside: his recommendation of "Mask, and then shift" is something C is good at that higher level languages often put behind indirection making them slower. You ironically provided an example of why C is often faster, not that C is only fast due to compilers. (Rust would probably be as fast, but in a lot of languages manipulating bytes and bits in a memory block or string always invokes a function and/or additional pointer indirection, making it slower.)

            Take a set of algorithms from LeetCode or HackerRank and implement them in various languages including C. C is often faster with the same exact solution. It can be orders of magnitude faster with a C optimal solution. When it's faster, it's faster even if you turn optimizations off or use an older compiler. This is not always true, sometimes another language is faster or just as fast. But it's generally true and recognized in studies of performance and energy use.
            https://thenewstack.io/which-programming-languages-use-the-least-electricity/

            Your stupid blog post on "muh pdp-11 muh C" is false top to bottom, written by someone who never grasped EE. Every point he made is easily disproven, including the false claim "it's just the compiler bro!" And someone versed in logic yet completely ignorant about computers could figure out that the compiler claim is false. How?
            >if it's just the compiler then why don't other languages implement the same optimization tricks for the same performance?
            It's either not just the compiler, or everyone working on compilers for other languages is a fricking idiot.

            Now frick off with your dumb shit. Why are you even obsessed with C? Did you fail a class?

            >consider the electrical efficiency of a language to objectively benchmark its computing efficiency
            jeenius.

          • 1 month ago
            Anonymous

            >You didn't even read the article you damn moron. picrel
            Yes I did, but you did not.

            >As expected, you go and prove that you are completely ignorant about computers and EE.
            It has a byte swap instruction called bswap. The CPU has a bswap instruction, but C forces you to "mask, and then shift" like it doesn't have it. Then it needs a complicated compiler that has to figure out what that means and work backwards.

            >Your magic function in MemeLanguage is doing one of two things under the hood:
            Are you saying x86 assembly is a "magic function in MemeLanguage?"

            >No, it just optimizes masks and shifts in all cases.
            It can't turn "masks and shifts in all cases" into a bswap instruction. It can only turn byte reversal into a bswap instruction.

            >It does not have code specifically looking for and optimizing byte reversal. Holy shit.
            Actually it does. Holy shit is right. C is too moronic for you to imagine.

            >Both the CPU and the functions you use in MemeLanguage are little black magic boxes to you. Stop posting and go learn something.
            It's not a "little black magic box," it's a CPU instruction called bswap.

            >You are literally at the level of "but sort is one function call, it's one step!" You have so much to learn.
            You C programmers are always projecting.

            http://justine.lol/endian.html
            > That might have been true with old compilers, but it's not true today. The more verbosely well-defined your code is, then with a good modern compiler, the smaller the generated code will be. Here's what we get if we run it through clang.godbolt.org:

            read32le(char*):
            mov (%rdi),%eax
            ret
            byte_swap_64(unsigned long):
            mov %rdi,%rax
            bswap %rax
            ret
            read32be(char*):
            mov (%rdi),%eax
            bswap %eax
            ret

          • 1 month ago
            Anonymous

            >CPU instruction called bswap
            not portable

          • 1 month ago
            Anonymous

            nta but all you wrote boils down to:
            >the compiler turns explicit byte swaps into bswap
            >here look at the asm bswaps right there!
            its not only the edgiest of edge cases
            but you said... nothing.
            same with the article

            did you actually read that disjointed fricking ranting?

          • 1 month ago
            Anonymous

            >Yes I did, but you did not.
            No, it was conclusively shown that you did not. Just like it can be conclusively shown that you are not a woman.

            >The CPU has a bswap instruction
            The blog post is about writing a correct, portable solution. Not relying on a particular CPU instruction. That a compiler is able to recognize when a combination of operations can be reduced to a single instruction on a particular architecture is great, but does not support any of your points.

            >but C forces you to "mask, and then shift" like it doesn't have it.
            It doesn't "have it" because some of the ISAs targeted by C do not have it or a direct equivalent. Most C compilers let you include assembly. Which higher level languages let you do that? If the blog post had been about byte swapping only on x86, it would have been much shorter.

            >Are you saying x86 assembly is a "magic function in MemeLanguage?"
            >Are you saying straw man?
            Typical.

            >Actually it does.
            No, it does not. It probably recognizes hundreds of code combinations that can reduce to one or two opcodes, including the use of bswap in places where you would not expect it. It is a generic optimization however much you wish to pretend that it is not.

            >> That might have been true with old compilers, but it's not true today. The more verbosely well-defined your code is, then with a good modern compiler, the smaller the generated code will be.
            This is a general statement, so I'm at a loss as to how you think it proves any of your points.

            Let's implement a byte swap algorithm in C and something like Python WITHOUT relying on any functions which map to an opcode under the hood. Let's make the language do it. Want to try that? Which do you think will be faster? Hmmm...

            Here's another homework assignment for you: implement a dozen LeetCode or HackerRank solutions in C, Java, and Python. Same algorithm each time. Tell us which is faster.

          • 1 month ago
            Anonymous

            >Which higher level languages let you do that?
            Enjoying your rant, hate to butt in, but C++ does. If you don't consider C++ higher level than C then ignore this post.

          • 1 month ago
            Anonymous

            >Enjoying your rant, hate to butt in, but C++ does.
            Of course it does. I didn't say that no other language lets you do that. But most do not.

            Of course we don't have the opportunity to debate C vs a specific language because the troony won't pick a specific language so that we can actually test and show things like performance differences and compiler optimizations. He knows he will get his ass beat if he does, so he wants to maintain language fluidity like he maintains gender fluidity.

          • 1 month ago
            Anonymous

            >No, it was conclusively shown that you did not.
            The article says you write this:
            #define READ16LE(S) ((255 & (S)[1]) << 8 | (255 & (S)[0]))
            #define READ16BE(S) ((255 & (S)[0]) << 8 | (255 & (S)[1]))
            #define READ32LE(S)
            ((uint32_t)(255 & (S)[3]) << 030 | (uint32_t)(255 & (S)[2]) << 020 |
            (uint32_t)(255 & (S)[1]) << 010 | (uint32_t)(255 & (S)[0]) << 000)
            #define READ32BE(S)
            ((uint32_t)(255 & (S)[0]) << 030 | (uint32_t)(255 & (S)[1]) << 020 |
            (uint32_t)(255 & (S)[2]) << 010 | (uint32_t)(255 & (S)[3]) << 000)
            #define READ64LE(S)
            ((uint64_t)(255 & (S)[7]) << 070 | (uint64_t)(255 & (S)[6]) << 060 |
            (uint64_t)(255 & (S)[5]) << 050 | (uint64_t)(255 & (S)[4]) << 040 |
            (uint64_t)(255 & (S)[3]) << 030 | (uint64_t)(255 & (S)[2]) << 020 |
            (uint64_t)(255 & (S)[1]) << 010 | (uint64_t)(255 & (S)[0]) << 000)
            #define READ64BE(S)
            ((uint64_t)(255 & (S)[0]) << 070 | (uint64_t)(255 & (S)[1]) << 060 |
            (uint64_t)(255 & (S)[2]) << 050 | (uint64_t)(255 & (S)[3]) << 040 |
            (uint64_t)(255 & (S)[4]) << 030 | (uint64_t)(255 & (S)[5]) << 020 |
            (uint64_t)(255 & (S)[6]) << 010 | (uint64_t)(255 & (S)[7]) << 000)

            And the compiler turns it into this:
            read32le(char*):
            mov (%rdi),%eax
            ret
            byte_swap_64(unsigned long):
            mov %rdi,%rax
            bswap %rax
            ret
            read32be(char*):
            mov (%rdi),%eax
            bswap %eax
            ret
            C needs MORE code than assembly.

            >Just like it can be conclusively shown that you are not a woman.
            At least you got one thing in your post right. I am not and will never be a woman.

            >This is a general statement, so I'm at a loss as to how you think it proves any of your points.
            It proves that C compilers have code like this because C does not let you express what you want to do directly.

          • 1 month ago
            Anonymous

            disjointed rant.
            >It proves that C compilers have code like this because C does not let you express what you want to do directly.
            nobody fricking cares

          • 1 month ago
            Anonymous

            I don't get it why not just
            static inline uint32_t read32(const char* src) {
            uint32_t ret = {0};
            memcpy(src, &ret, 4);
            return ret;
            }

          • 1 month ago
            Anonymous

            Because it's reading it in the opposite endian of the CPU. You have to reverse the bytes.

          • 1 month ago
            Anonymous

            Only for the be version. And then it would be clearer to do something like
            static inline uint32_t read32be(const char* src) {
            union {
            char chars[4];
            uint32_t integer;
            } ret = {0};
            for (int i=0; i < 4; ++i ){
            ret.chars[4 - i] = src[i];
            }
            return ret.integer;
            }

            But it is my opinion that if your code depends on endianness in the first place, you're doing something shitty.

          • 1 month ago
            Anonymous

            you can use the bswap function if you want, no?

          • 1 month ago
            Anonymous

            >C needs MORE code than assembly.
            Because

            >CPU instruction called bswap
            not portable

            code always needs less code than a portable version, unless you're using a higher-level language that purposefully abstracts that away from you.

            C naturally needs more code to express the different instructions that are CPU instructions provided by the hardware vendor for convenience.
            An AVR does not have a division instruction, but you can use a division just the same in C/++ code, the compiler restructures that part of the code into smaller AVR ASM instructions to effectively achieve the same thing that x86 has as an instruction.

            EE and C go hand-in-hand, Rust is a modern abomination in this regard, and you don't understand why and don't care to understand why either.

            The truth of the matter is, anyone who's intrinsically butthurt about C isn't using programming languages as tools like everything else, but has an irrational sentimentality attached to them.
            And Rustgays are almost always more guilty of this, it's inherent in the nature of the subject.

            *puff*
            *sip*

            There's nothing more to say, least to say, I needn't hear any more.

          • 1 month ago
            Anonymous

            >An AVR does not have a division instruction, but you can use a division just the same in C/++ code, the compiler restructures that part of the code into smaller AVR ASM instructions to effectively achieve the same thing that x86 has as an instruction.
            I mean, that was actually a counter-example as to when C needs less code, but the fact of the matter is, you either convolute the standard adding byte-swap and what-not into C (which you could otherwise express as primitve instructions), but then it will become a mess like C++ with time.

            So, yes, sometimes C can be a pain in the ass, but I understand why it has to be that way.

            The White House is butthurt all that useful software written in C can just be recompiled to work on different architectures, so they want you to use Rust, so when they cut off non-compliant states from hardware, they would also be cut off from software.

            homosexuals.

          • 1 month ago
            Anonymous

            And
            >homosexuals
            are being used by the very same entity to push their message, because who could refuse what a perfect little fairy homosexual has to tell them, you aren't one of those backwards primitive Slavoids or Muzzies, are you, Anon?

            Jeez, why is all of this so opaque to that particular subset of people often proclaiming to be 'progressive' when they fall for the oldest ticks in the book?

          • 1 month ago
            Anonymous

            >slavoids
            theyre actually the best coders in the world.
            youre allowed to go leave, slightly asshurt

          • 1 month ago
            Anonymous

            JFC.

          • 1 month ago
            Anonymous

            >EE and C go hand-in-hand
            No they do not. EE doesn't have anything to do with C. C was made by people who never designed a computer architecture or CPU. You can design a CPU that can't run C.

            >The truth of the matter is, anyone who's intrinsically butthurt about C isn't using programming languages as tools like everything else, but has an irrational sentimentality attached to them.
            You have an irrational sentimentality attached to C which is why you can't stand even the slightest criticism of C. You are projecting again. You always accuse other people of what you are doing.

            >when tools are judged on their technical merits
            and thats the exact reason C still remained once the shilling stopped.
            and even found new forms like openCL and cuda.

            funny how they picked C as basis for the languages they use for platforms that have no architectural lineage in common with pdp.

            >and thats the exact reason C still remained once the shilling stopped.
            The C shilling never stopped. It's still going on right now in this thread.

          • 1 month ago
            Anonymous

            >EE doesn't have anything to do with C
            Primitive CPU instructions do.
            Or wiewing memory addresses inherently as neither safe nor unsafe, they just exist (or don't).
            It's just 'too simple' for you to understand.

          • 1 month ago
            Anonymous

            >Primitive CPU instructions do.
            No they do not. CPUs have a lot more instructions than C has that are also primitive, like rotate, bswap, and add/subtract with carry. The PDP-11 had those instructions too. C doesn't even expose all the instructions the PDP-11 can do.
            https://pdos.csail.mit.edu/6.828/2005/readings/pdp11-40.pdf
            >ROR(B) rotate right
            >ROL(B) rotate left
            >SWAB swap bytes
            >ADC(B) add carry
            >SBC(B) subtract carry
            >Or wiewing memory addresses inherently as neither safe nor unsafe, they just exist (or don't).
            This is not how C works. Read the C standard. C "pointers" do not have to have anything to do with actual memory or hardware. See WASM.
            >It's just 'too simple' for you to understand.
            C is an extremely complex language, especially considering the low number of features in C.

          • 1 month ago
            Anonymous

            It's like you didn't read anything I wrote and took some out of my sentences out of context and cherrypicked a few bits of "evidence" and "proof" against that, and now expect me to honor your request to continue this pointless charade that would only end for you with me saying "I'm a dumb idiot for using C, you're teh master 1337 programmer proving me teh wrongz," objective reality be damned.

            Sorry, I do not take part in the sexual fetishes of random internet strangers, thank you.

          • 1 month ago
            Anonymous

            Trannies
            >why doesn't C include every x86 instruction as a primitive?
            Also trannies
            >OMG WHY ISN'T IT PORTABLE???

          • 1 month ago
            Anonymous

            No, every single C thread goes like this:
            > C is very fast since it's very close to the hardware. Rust trannies hide raw memory behind 10 layers of abstraction, just like they do with their gender
            > actually C is a high level language, it doesn't have anything to do with the processor
            > no it isn't homosexual, the processor literally runs C, troony troony troony troony troony troony confused gay man>;-(
            > some anon gives literal proof that C abstracts the hardware away and that the compiler does a poor job at utilizing it because C lacks the means of proper abstraction
            > troony troony troony troony

          • 1 month ago
            Anonymous

            ok troony

          • 1 month ago
            Anonymous

            I like c because its simple not because its fast
            I dont care if rust or cpp is 10% faster, its not worth the complexity

          • 1 month ago
            Anonymous

            C is a little like roads, it doesnt really matter if its the best or not its what we have and like roads we already laid out everywhere we have c everywhere and we cant go around and change everything all at once like switching to trains overnight
            If anything could work its something like zig which works nicely with c
            Rust might replace cpp, could be nice but will take 10 years i guess

            You say C isn't beginner friendly and then spew shit like this, just pick your fricking mind

          • 1 month ago
            Anonymous

            >The C shilling never stopped. It's still going on right now in this thread.

            >insult people
            >people insult right back
            >OMAGAD, WHY ARE YOU SO VULGAR
            yeah, you aint gaining any sympathy here, rustroon

          • 1 month ago
            Anonymous

            >c shilling
            in fact
            with the likes of you around, i wouldnt even need to shill C if that was my goal

            your personality is the best advocate as to why the rust community is a cancerous pit of misery and should be avoided if possible

          • 1 month ago
            Anonymous

            Based.

            >An AVR does not have a division instruction, but you can use a division just the same in C/++ code, the compiler restructures that part of the code into smaller AVR ASM instructions to effectively achieve the same thing that x86 has as an instruction.
            I mean, that was actually a counter-example as to when C needs less code, but the fact of the matter is, you either convolute the standard adding byte-swap and what-not into C (which you could otherwise express as primitve instructions), but then it will become a mess like C++ with time.

            So, yes, sometimes C can be a pain in the ass, but I understand why it has to be that way.

            The White House is butthurt all that useful software written in C can just be recompiled to work on different architectures, so they want you to use Rust, so when they cut off non-compliant states from hardware, they would also be cut off from software.

            homosexuals.

            Exceptionally based.

            >C IS ONLY FAST BECAUSE THE COMPILER IS GOOD
            This is partly correct, but the compiler can be so good because C is such a simple, good language.
            Rustc will never be as good as clang, even though they're both LLVM

            I might of jumped on this but you said "partly." In some cases C lets you easily write solutions that just are faster. But yes, in other cases the compiler can just optimize more because it's C. It's the combination.

            The troony still can't answer
            >if it's just the compiler
            >then why don't other languages have similar quality compilers?

          • 1 month ago
            Anonymous

            >I might of
            I might have*

          • 1 month ago
            Anonymous

            >troony literally doesn't understand portability
            Let me explain it this way...

            The code at the top is gender fluid. It runs on any gender. The compiler is a surgeon. When the code will only run as one gender forever, the surgeon trans-compiles the code into gender specific code.

            Now do you understand?

            >C doesn't let you express this!
            bswap is not common to all instruction set architectures you fricking moron. If you only run on x86, the bottom pic is a clue as to what you can type in C.

            you can use the bswap function if you want, no?

            The troony can't admit this without demolishing his dumb edge case argument and seething.

      • 1 month ago
        Anonymous

        If that's the case, why is clang still faster than rustc? Both target LLVM, so both could also output the same code.

    • 1 month ago
      Anonymous

      this is the easiest ways to detect neets
      doesn't how fast the software runs, it matters how fast it is to build the software in the first place

      • 1 month ago
        Anonymous

        >doesn't how fast the software runs, it matters how fast it is to build the software in the first place
        this isn't true in every domain, anon
        maybe always true for web development

        • 1 month ago
          Anonymous

          its true for 99.999% of cases
          build the initial product, then iterate and improve it. Trying to build the most optimal program from the get go is a one way ticket to bankruptcy
          exceptions are onboard controllers/systems on planes or similar fields which is a very small portion of the entire software market

          • 1 month ago
            Anonymous

            >Trying to build the most optimal program from the get go
            i didn't say this at all
            nobody can do this unless the program is trivial
            do you think domains like trading platforms and video games are a "small portion" of the market?
            what about other things like drivers for gpus?
            are you writing that in python?

      • 1 month ago
        Anonymous

        Exactly, people complain about Python but it gets the job done in 99% of cases where modern hardware offsets the performance hit, while probably having the highest dev velocity of any popular language.

        It also makes me laugh when people insist on C/C++ for shit that's inherently IO bound (aka most things that aren't simulations or embedded systems), as you say NEETs. I used to use C and a bit of C++ (the features were shit and/or not needed, tried it for a project and it showed its ugly head), but unless your job understands the environment, you got 5 layers of managers telling you to get shit done by yesterday as marketing just promised a bunch of shit, you aren't choosing a low velocity language for that (nor should you for sanity alone), you're gonna use Python and use some dodgy packages, BS some unit tests, and serve them the shit sandwich they ordered.

        >doesn't how fast the software runs, it matters how fast it is to build the software in the first place
        this isn't true in every domain, anon
        maybe always true for web development

        >nnnn but C is a subset of C++
        yes. youre still writing C.

        [...]
        webshitter take.
        your whole infrastructure is build on C and the likes because performance translates into real life money if you need an n times larger infra bc of your moronic code

        [...]
        all leveraging high performance low level languages.
        webshittery should be a bannable offence

        [...]
        lol. what an illiterate

        Send me your CVs, I prefer to be constructive with communities and getting you NEETs jobs so you can understand would partly uplift this place. I can tell you're NEETs because like juniors, you know the facts that it isn't every case, but you lack the wisdom to know it's definitely over 80% of cases

        its true for 99.999% of cases
        build the initial product, then iterate and improve it. Trying to build the most optimal program from the get go is a one way ticket to bankruptcy
        exceptions are onboard controllers/systems on planes or similar fields which is a very small portion of the entire software market

        I've always compared it to building a house, you could decorate the kitchen but if you need to change the pipework (which you're manager will insist on), you need to pull up the floorboards, remove the table and chairs, furnishings etc. That's the problem with an optimal solution, I just build stuff that's modular TDD since I can change it, test it, or remove it if it's not needed anymore, frick optimised shit, that's the work of autists and academics, it's not my product.

        >your entire application must be one language
        just write cuda parts in C and the rest of the application in a real language like C#

        It's unironically why Python is probably one of the better languages, easy language, check, need something fast, cook up a C API for it then it's both readable and fast. Imagine if data scientists or ML engineers had to use C/C++, code war crimes galore

        • 1 month ago
          Anonymous

          >lack the wisdom to know it's definitely over 80% of cases
          that was pretty dumb.

          lets talk maths and proportions.

          we could divide computers, embedded or not, into broadly two categories:
          those that use an os to function
          those that dont.

          and you know what?
          both run high performance low level code.

          its just how it is.
          it doesnt matter how much webspaghetti you produce, its never gonna run on bare metal.

          it runs on infrastructure built with, repeat it with me-
          high performance low level languages.

          i would gladly take up a job offer if i werent in the process of building a company.
          sadly, im kinda locked in previous engagements.

          • 1 month ago
            Anonymous

            The thing you have to realise is that high level languages/code is based on low level ones, and the reason why there's inefficiencies in the high level code is because you're applying an API of a low level language (effectively), the tradeoff is better velocity.

            The reason we don't run everyone on C is because, informally, we agree that the tradeoff for ease and velocity, is worth more than the cost of efficiency. This is also massively due to the improvements to hardware.

            Take electron for instance, basically webdev for applications programming, the reason it's so popular is because it's not the fastest, but has much much better dev velocity, sure in the 00s and 90s, doing so would be absolutely insane to run a program via a copy of the browser, but today it's okay for industry.

            As for the "backend" side, yeah, write that low level, you want a good base for your pyramid of software, but it has its place at the base, not the tip.

            The other situation you (well I did) present is embedded, that's because most embedded stuff is on-par with the 90s-00s if not before, therefore it isn't only the base of the pyramid but the entire thing. A lot of my arduino projects I do simply wouldn't work if I use higher level languages, but nor would they work on the VIAO laptop I had in the 00s.

            The idea of all of this is that if you can get away with higher dev velocity, industry will value that over raw performance, personal projects are different though so raw performance might be better due to the lack of apathy.

            As for the company, best of luck to it my dude.

          • 1 month ago
            Anonymous

            >Take electron for instance, basically webdev for applications programming, the reason it's so popular is because it's not the fastest, but has much much better dev velocity, sure in the 00s and 90s, doing so would be absolutely insane to run a program via a copy of the browser, but today it's okay for industry.
            Electron has worse velocity than many languages/frameworks for writing desktop apps, even cross platform ones. But it lets boomer managers tap into a pool of web script kiddies. That's why we have to deal with that piece of shit.

            Understand that software engineering does not have the respect of any other engineering discipline. There are no real requirements or licensing, and it's a spooky black box to the average manager. Therefore in their mind with the right magic tools they can substitute anyone for an educated engineer expecting a living wage and it won't affect their product quality or bottom line. "Muh productivity!!! MUH VELOCITY!!!" is a meme cooked up in their brains because it feeds what they want to believe: that someday they can hire people at below minimum wage to produce their crap yet still sell it for billions. They hate, hate, HATE that anyone can still earn a middle class existence via SwE. The end goal is that everyone but them are serfs and beggers.

            AI delusions are the ultimate expression of this. But part of me actually wishes AI could takeover SwE. What the boomers don't understand is that at that point every piece of software in the world will have a higher quality FOSS equivalent and all the software companies can go out of business. Even Microsoft. Maybe that would be for the best after all.

          • 1 month ago
            Anonymous

            thank you for the patient response
            and i appreciate the exposition. but i already kinda know that...

            my point is that theres tons of applications where performance is a serious concern.
            one could say velocity vs performance is a spectrum.
            from the economical point of view it would be dev costs vc compute costs

            in frontend webdev you more leeway bc you can run scripts on the user's machine
            but with osdev, for instance, the balance is entirely different.
            same with the browsers that will run said web scripts. or codecs. or drivers.

            i mainly wanted to point out that your vision of 80% of code being velocity-dependent might be a little skewed
            because theres tons of stuff that is leveraged to allow for webdev to begin with
            and webdev isnt the only context to programming either
            you got gaymes
            you got media players,
            you of course have embedded, but theres literal tons of it
            theres os utilities
            i mean
            i think pure velocity-dependent programs make up at most 50% of the code that is produced... maybe less

            idk, maybe you have stats on that, the figure i gave is based on the speed of a fart multiplied by the circumference of my eye, but that figure would make sense for me.
            routers run low level code
            servers run tons of low level code
            the endpoints/browsers run on low level code

            it seems like pure velocity-dependent programs are just like you described them- the tip of the pyramid

        • 1 month ago
          Anonymous

          >Exactly, people complain about Python but it gets the job done in 99% of cases where modern hardware offsets the performance hit
          People like you are why so much code is bloated, slow shit even on systems capable of billions of operations per second.

          >BUT MUH PRODUCTIVITY!!!
          A boomer manager myth. Language is dead last in terms of factors in productivity.

          >muh language velocity
          >boomer manager still saying you needed it done yesterday
          The problem is never the language.

        • 1 month ago
          Anonymous

          >you lack the wisdom to know it's definitely over 80% of cases
          You can't afford me, anon. I know because you have been arguing this made-up argument about writing optimal code from the get-go, so you're incapable of even thinking straight, which implies you're in some kind of dead-end code shack.

  3. 1 month ago
    Anonymous

    >human species have collectively moved on from consuming their own excrement into much more palatable and sanitary foods
    C programmers are the kind of people who brag about consuming their own excrement. They don't want to eat palatable and sanitary food. It's the whole Worse is Better mentality that C shills convinced morons was "more macho" than normal languages.

    • 1 month ago
      Anonymous

      It's the hecking let's move fast and break things mentality but from the 70's. Basically a bunch of mentally children adults who keep trying to fit a square into a circle until it breaks, and, would you look at that, it fits.

  4. 1 month ago
    Anonymous

    thats an awful lot of text to say youre a midwit
    you could have just written "nnn c is LE bad bc its OLD!!!!111"

    picrel was also new in its time
    today its the symbol of human stupidity and the reminder that hype can be a dangerous thing

    • 1 month ago
      Anonymous

      >you could have just written "nnn c is LE bad bc its OLD!!!!111"
      C was bad when it was new too. C programmers were the ones saying OLD BAD NEW GOOD when C was taking over. The whole reason for pushing C was OLD BAD. You had to replace older languages like Pascal, BASIC, FORTRAN, COBOL, and Lisp with C because OLD BAD.

      • 1 month ago
        Anonymous

        you dont change a winning team, rustroon.
        come back when you have a standard

        • 1 month ago
          Anonymous

          That picture describes C in the 80s. C had no standard and was defined by compiler source code.
          >SOMEONE IS USING ANOTHER LANGUAGE!!!!
          >WHY AREN'T THEY USING C????
          >BASE YOUR BILLION DOLLAR PROJECTS ON IT
          That's literally what Bell Labs shills were saying in the 80s. There's actually a song called "Write in C" that says this exact thing.

          >you dont change a winning team
          Then why are C shills doing it?

          >come back when you have a standard
          All the languages I mentioned had standards before C did. C was the language with no standard and made by people who said OLD BAD and STANDARDS BAD.

          >you see anon, i am a professional obnoxious sperg because 50 years ago a lot of people used to be spergs just like me
          And you people claim to be more than 18 yo?

          >>you see anon, i am a professional obnoxious sperg because 50 years ago a lot of people used to be spergs just like me
          Why are you posting your Twitter bio?

          • 1 month ago
            Anonymous

            >That picture describes C in the 80s.
            >living in the past
            were in 2024, moron

            >part of the toolchain
            written in the better language than C because C is worthless

            *looks at the code*
            *raw pointers everywhere*
            nice c++ you got there, pal

          • 1 month ago
            Anonymous

            Yes, pointers are part of C++, what's the problem troony? Feeling culturally appropriated yet?

          • 1 month ago
            Anonymous

            >Feeling culturally appropriated yet?
            lmfao
            go back

          • 1 month ago
            Anonymous

            >g-go b-ACK!

          • 1 month ago
            Anonymous

            >Why are you posting your Twitter bio?
            nice projection

          • 1 month ago
            Anonymous

            >That picture describes C in the 80s. C had no standard
            C has always had a double standard, which is why it's okay for C shills to act like this but not okay for anyone else to do it

          • 1 month ago
            Anonymous

            >C shills to act like this but not okay for anyone else to do it
            so youre saying that shilling is a ok, just what bothers you is that C-ultists call you out?
            ok, id say duly noted, but i already knew that.

            also:
            44 years and counting
            still rent free

          • 1 month ago
            Anonymous

            Nah, I prefer when tools are judged on their technical merits
            For that reason, it's fricking annoying to see anyone shilling anything based only on promises of Hopes and Dreams™
            I don't want to see anyone doing it for languages that aren't C
            I also don't want to see cniles doing it
            I especially don't want to see cniles do this exact thing, pat themselves on the back for being Close To The Metal™, and turn right around and attack other languages over allegations of technical inadequacy while flatly asserting that C alone (with C++ as an optional guest star) is immune to those very same attacks, when in fact they're bigger problems with C (and/or C++) than with literally any other language with a community that isn't 99% zombies and 1% trained dogs

          • 1 month ago
            Anonymous

            >when tools are judged on their technical merits
            and thats the exact reason C still remained once the shilling stopped.
            and even found new forms like openCL and cuda.

            funny how they picked C as basis for the languages they use for platforms that have no architectural lineage in common with pdp.

          • 1 month ago
            Anonymous

            Nah

          • 1 month ago
            Anonymous

            yeah.
            like it or not heres how "cuda c++" looks like:
            ...
            cublasLtMatrixTransformDesc_t transformDesc = NULL;
            int8_t *Atransform = NULL, *Btransform = NULL;
            int32_t *Ctransform = NULL;
            cublasLtMatrixLayout_t AtransformDesc = NULL, BtransformDesc = NULL, CtransformDesc = NULL;
            float transformAlpha = 1.0f, transformBeta = 0.0f;
            cublasLtOrder_t order_COL32 = CUBLASLT_ORDER_COL32;
            cublasLtOrder_t order_COL4_4R2_8C = CUBLASLT_ORDER_COL4_4R2_8C;

            int ldatransform = 32 * m;
            int ldbtransform = 32 * roundoff(n, 8);
            int ldctransform = 32 * m;

            checkCudaStatus(cudaMalloc(reinterpret_cast<void**>(&Atransform), sizeof(int8_t) * roundoff(k, 32) / 32 * ldatransform));
            checkCudaStatus(cudaMalloc(reinterpret_cast<void**>(&Btransform), sizeof(int8_t) * roundoff(k, 32) / 32 * ldbtransform));
            checkCudaStatus(cudaMalloc(reinterpret_cast<void**>(&Ctransform), sizeof(int32_t) * roundoff(n, 32) / 32 * ldctransform));

            checkCublasStatus(cublasLtMatrixTransformDescCreate(&transformDesc, CUDA_R_32F));

            checkCublasStatus(cublasLtMatmulDescCreate(&matmulDesc, CUBLAS_COMPUTE_32I, CUDA_R_32I));
            // tensor op igemm kernels only support NT gemm
            checkCublasStatus(cublasLtMatmulDescSetAttribute(matmulDesc, CUBLASLT_MATMUL_DESC_TRANSB, &opTranspose, sizeof(opTranspose*~~;
            ...

            not so many templates and iterators, eh?
            https://github.com/NVIDIA/CUDALibrarySamples/tree/master

          • 1 month ago
            Anonymous

            Yikes, no reason none of that couldn't have been written in C, which honestly seems to fit the subject matter more.
            Seems more like inertia nVidiot decided to use C++ for CUDA in the first place.
            I mean, that was ages ago. Wasn't it first shipped the same time they did PhysX? Some time in mid-to-late 2000s?
            That was fresh out of the late 90s, when C++'s OOP was being hyped like today's Rust, and look where that has led us.

          • 1 month ago
            Anonymous

            cuda also interfaces with C. but ive seen a couple kernels declared as templates.
            you wont find any fancy abstractions within the kernel itself doe.
            and this code in particular could totally be written in C. theres even casts to raw pointers bc C++ principles get in the way.
            >and look where that has led us.
            pain. and theres only more pain ahead.

            I was maintaining my position that C did not win on technical merits alone
            Its simplicity and mechanical sympathy are illusory
            Compilers have to bend over backwards to make it reliably fast and their methods blow up in your face if you don't anticipate their every move and write code in a state of advanced paranoia
            There were simpler languages before C that did not have these problems, and they were chased away by the cult

            As for CUDA:
            Does it work? Yeah, often enough for what people are doing today
            Is it the best possible tool for what it does? Absolutely not
            Something better would already exist and be in widespread use if not for the C/C++ stranglehold on developer mindshare
            You're a fine example of the psychosis at work
            Occasionally your intelligence peeks through, but then you drown it in beer and waffles and forget whatever conversation we had
            Anyway bye

            >Compilers have to bend over backwards to make it reliably fast
            admittedly, a black box for me. and thats whats so awesome about the toolchain. i dont need to know how the compiler does its magic.

            >and their methods blow up in your face if you don't anticipate their every move
            no, just dont write UB and youre good.
            or you do like me and write UB in c standard but defined elsewhere.
            like packed pointers. the standard can go frick itself on that one. i write for a target so portability flies out of the window (ntm i posit that C is not portable to begin with. the appearance thereof is achieved with duplicate code guarded with defines. thats not portability in the slightest)

            >and write code in a state of advanced paranoia
            if you master your programs execution and have a concept of dataflow, what you write is what the compiler expects.
            yes, when you write C you have to use your brain. if you dont like it, you have rust.

            >There were simpler languages before C that did not have these problems, and they were chased away by the cult
            examples?

            >Is it the best possible tool for what it does? Absolutely not
            you could write asm for your gpu. we have glsl, we have vulkan, there are alternatives.
            but opencl and cuda are the best for the job.
            cuda is clunky but opencl is pretty fricking comfy

            >Something better would already exist and be in widespread use if not for the C/C++ stranglehold on developer mindshare
            "something better" has been tried over and again. zig, jim or jit, nim, rust, of course, c++. yeah, that one was supposed to replace C.
            its not a matter of mindshare. its a matter of C just being that good

          • 1 month ago
            Anonymous

            cuda also interfaces with C. but ive seen a couple kernels declared as templates.
            you wont find any fancy abstractions within the kernel itself doe.
            and this code in particular could totally be written in C. theres even casts to raw pointers bc C++ principles get in the way.
            >and look where that has led us.
            pain. and theres only more pain ahead.

            [...]
            >Compilers have to bend over backwards to make it reliably fast
            admittedly, a black box for me. and thats whats so awesome about the toolchain. i dont need to know how the compiler does its magic.

            >and their methods blow up in your face if you don't anticipate their every move
            no, just dont write UB and youre good.
            or you do like me and write UB in c standard but defined elsewhere.
            like packed pointers. the standard can go frick itself on that one. i write for a target so portability flies out of the window (ntm i posit that C is not portable to begin with. the appearance thereof is achieved with duplicate code guarded with defines. thats not portability in the slightest)

            >and write code in a state of advanced paranoia
            if you master your programs execution and have a concept of dataflow, what you write is what the compiler expects.
            yes, when you write C you have to use your brain. if you dont like it, you have rust.

            >There were simpler languages before C that did not have these problems, and they were chased away by the cult
            examples?

            >Is it the best possible tool for what it does? Absolutely not
            you could write asm for your gpu. we have glsl, we have vulkan, there are alternatives.
            but opencl and cuda are the best for the job.
            cuda is clunky but opencl is pretty fricking comfy

            >Something better would already exist and be in widespread use if not for the C/C++ stranglehold on developer mindshare
            "something better" has been tried over and again. zig, jim or jit, nim, rust, of course, c++. yeah, that one was supposed to replace C.
            its not a matter of mindshare. its a matter of C just being that good

            Now that I think about it, yeah, PhysX was the original thing for CUDA, to be used for physical effects simulation coding in games, which were largely (still many; but lots of standardized game engines nowadays) C++ OOP software, so keeping CUDA in C++ was not a wrong decision.

            It's use as a general multi-scalar programming tool merits using C, though, but maybe this is a more recent afterthought in its history.

          • 1 month ago
            Anonymous

            i am not familiar with the ins and outs of cuda history
            heck, im not even competent in cuda, its just that i looked at it in preparation for when i will buy ngreedia hardware (i do opencl)
            so i can only offer further speculation
            but
            since cuda is a hardware interface, it stands to reason raw pointers were seen as natural interfacing method.
            as such CUDA would already be firmly seated within the C framework
            but since CUDA is compiled by a C/C++ compiler, there shouldnt be much problems with implementing a couple features from C++ into it
            like templates.

            given that said templates are part of the CUDA standard, and that C++ is a superset of C, i find it logical to then say that CUDA is based on C++, despite it looking like C, and only having a couple features from C++ added to it.
            i dont think CUDA was built with game devs in mind tho.
            i think what spurred the creation of CUDA was the introduction of opengl glsl in 2004. or rather what non-gamedevs did with said shader language.

            the industry realized the power of gpgpu computing, and given that glsl didnt have actual provision for gpgpu compute a niche was created for tools and interfaces that are actually designed for the task
            what makes me think that gamedevs werent the target users for cuda is the fact that opengl had to mature until 2014 before it got extended with compute shaders

          • 1 month ago
            Anonymous

            I was maintaining my position that C did not win on technical merits alone
            Its simplicity and mechanical sympathy are illusory
            Compilers have to bend over backwards to make it reliably fast and their methods blow up in your face if you don't anticipate their every move and write code in a state of advanced paranoia
            There were simpler languages before C that did not have these problems, and they were chased away by the cult

            As for CUDA:
            Does it work? Yeah, often enough for what people are doing today
            Is it the best possible tool for what it does? Absolutely not
            Something better would already exist and be in widespread use if not for the C/C++ stranglehold on developer mindshare
            You're a fine example of the psychosis at work
            Occasionally your intelligence peeks through, but then you drown it in beer and waffles and forget whatever conversation we had
            Anyway bye

          • 1 month ago
            Anonymous

            >they were chased away by the cult
            Ah yes, the C-lonialists are at fault other languages aren't as developed as they are today.
            Thank God we now live in an age where we've abolished the use of 'slave/master' in programming.
            >people unironically believe this

          • 1 month ago
            Anonymous

            >You're a fine example of the psychosis at work
            >ad homonem
            of course. you just couldnt do otherwise

            >Anyway bye
            tactical retreat.

          • 1 month ago
            Anonymous

            >I was maintaining my position that C did not win on technical merits alone
            >Its simplicity and mechanical sympathy are illusory
            >Compilers have to bend over backwards to make it reliably fast
            All not only false, but proven false in this thread. Your example would be an irrelevant edge case if it was honest, but it is dishonest which is why you ignore portability.

            >There were simpler languages before C that did not have these problems, and they were chased away by the cult
            More false and unsubstantiated claims, just like your claim to be a woman.

            >Something better would already exist and be in widespread use if not for the C/C++ stranglehold on developer mindshare
            >REEEEEEEE IT'S C'S FAULT!!!
            Which class did you fail? Did it cost you an EE or CS degree? God I hope so, I don't want you in this industry.

          • 1 month ago
            Anonymous

            What were the alternatives in the 80s, Black person?

            ...
            das rite, they didnt listen and now banks have to scramble looking for fortran programmers

          • 1 month ago
            Anonymous

            >banks have to scramble looking for fortran programmers
            COBOL, you airheaded moron, not Fortran.

          • 1 month ago
            Anonymous

            Same thing

        • 1 month ago
          Anonymous

          Lmao what movie is this?

          • 1 month ago
            Anonymous

            Basket Case

      • 1 month ago
        Anonymous

        >you see anon, i am a professional obnoxious sperg because 50 years ago a lot of people used to be spergs just like me
        And you people claim to be more than 18 yo?

      • 1 month ago
        Anonymous

        >things that never happened
        I'm an old gay and was a kid into computers when C and C++ started to dominate classic Macintosh and old Windows development. It took over for various reasons not the least of which were UNIX, FOSS, and in the case of C++ the OOP features. Nobody ever argued that Pascal was bad. That's not why Pascal lost the race.

        >pascal
        Slow to adopt OOP across the ecosystem.
        >BASIC
        Old BASIC was pretty bad and slow. There are good examples of BASIC syntax (VB.NET, Xojo) but they were very late to the game.
        >FORTRAN
        >COBOL
        C just has a better syntax on top of the other reasons.
        >Lisp
        Performance issues in the old days. Less of an issue today but it just never caught on.

  5. 1 month ago
    Anonymous

    >Aside from some exceptions, human species have collectively moved on from consuming their own excrement into much more palatable and sanitary foods. We don't look back at our ancestors ways and reminisce about the old days where consuming clean cooked food wasn't in the grasp of the imagination. Yet, the sentiment among the older folk in academia seem to agree that we should go back to our old ways and learn C programming before moving on to much more versatile and easier to use programming languages. These new programming languages, which mostly abstract away the memory management and commonly used algorithms into simple function calls, seems to be most logical choice if you actually want to be productive and not the make the next person who was unfortunate enough to be tasked to read your code fill with rage. What gives?
    Nobody gives a frick.

    Grug will bash your head with stick, because stick is convenient and cheap and gets the job done.

    • 1 month ago
      Anonymous

      Good luck explaining to your boss why your "convenient and cheap" C program takes 10x longer and is 8x harder to debug than the simple python/JS/c# script your coworker came up with in 5 minutes
      "B-but it runs faster" won't cut it

      • 1 month ago
        Anonymous

        good luck writing for gpus in C#, rustBlack person

        • 1 month ago
          Anonymous

          I have never used rust because none of the my projects required it, the same goes for CUDA
          A lot of people are under the illusion that one language is the best for everything, but that's like eating soup with a fork. Real programmers (aka people who actually have a job) understand this, you do not. I feel bad for you.

          • 1 month ago
            Anonymous

            >none of the my
            Meant to say "none of my" but was too busy thinking about "none of the projects I've worked on"
            Ah well, you get my point. Or maybe you won't, it doesn't matter to me

          • 1 month ago
            Anonymous

            >understand this, you do not
            ad homonem + how can you say this?

            given the level of your discourse you must be a rustroony in disguise

          • 1 month ago
            Anonymous

            >"everyone who disagrees with me is [label]"
            >"nooo why would I simply admit that I'm wrong, this is the internet, I NEED to stand my ground"
            If you say so

          • 1 month ago
            Anonymous

            yeah that train has sailed long ago, or howerever the saying goes.
            next time try not to start with ad homonems like a kindergartner

            >g-go b-ACK!

            no
            >go back

          • 1 month ago
            Anonymous

            >"REEE RUSTtroony YOU'RE A troony"
            "You do not understand how software development works"
            >"AAAAH HE ATTACKED ME, AD HOMINEM, AD HOMINEEEEEEEM HEEEEEEEEEELP"

          • 1 month ago
            Anonymous

            you are a rustroony doe.
            its not a homonem unlike saying that i dont know how to code.

        • 1 month ago
          Anonymous

          >your entire application must be one language
          just write cuda parts in C and the rest of the application in a real language like C#

          • 1 month ago
            Anonymous

            you only say that because of the excellent c/c++ interop microsoft did for c#, it's not necessarily easy for every language

          • 1 month ago
            Anonymous

            I mainly use Elixir and its also just as easy. all good langs have excellent C interop for exactly this purpose

          • 1 month ago
            Anonymous

            numbers confirm
            note that the underlying idea here is that C is still king for any serious work, and needs to be abstracted away from or interfaced with from other languages if you can't stand C's raw power

        • 1 month ago
          Anonymous

          i work on medical devices. the ui is written in c# while the code that moves the motors and the other low-level stuff are done by the c team. why the frick would you write everything in c?

          • 1 month ago
            Anonymous

            that was a reply to this:
            >Good luck explaining to your boss why your "convenient and cheap" C program takes 10x longer and is 8x harder to debug than the simple python/JS/c# script your coworker came up with in 5 minutes
            and the key part:
            >"B-but it runs faster" won't cut it

            which you probably read too since its the post just above it.
            in many cases "b-but it runs faster" is mission critical.

          • 1 month ago
            Anonymous

            The fact that C/C++ devs never actually tested code as standard until higher level languages did it then C/C++ retrofitted it, really shows the shenanigans they were pulling.

            C is more proper and gets shit done properly, but C++ is the embodiment of that college student who thinks he is a coding genius because he could build some project from github that forgot to include build instructions.

            Seriously, the testing thing, the STL is a shitshow, CMake files, the fact it genuinely believes a modern standard needs to be backwards compatible to a 50 year old version. Let alone until only recently, the language genuinely believed making people manage their own memory was a good idea (sure, you, the 10x dev could do it, but do you genuinely trust your team, or the juniors to do the same?).

            Language is a shitshow, Bjarne Stroustrup deserves a prolonged execution, and as gay and troony harbouring as Rust is, I'm glad it's showing how shit C++ is when you actually have competition (even if Rust is also a PoS language for other reasons, primarily community and fundamental principles that it tried to guess that weren't "let's avoid the shit C++ did and failed to fix"), can't wait for the next language that ran because Rust walked

          • 1 month ago
            Anonymous

            >(sure, you, the 10x dev could do it, but do you genuinely trust your team, or the juniors to do the same?).
            No, but they shouldn't be writing libraries or infrastructure critical software to begin with (unless you have a very promising candidate).
            The libs should be in C, the application implementation sold to clients can be C++ and coded by jeets, frick do I care, I ain't the one buying it.

            Exactly, people complain about Python but it gets the job done in 99% of cases where modern hardware offsets the performance hit, while probably having the highest dev velocity of any popular language.

            It also makes me laugh when people insist on C/C++ for shit that's inherently IO bound (aka most things that aren't simulations or embedded systems), as you say NEETs. I used to use C and a bit of C++ (the features were shit and/or not needed, tried it for a project and it showed its ugly head), but unless your job understands the environment, you got 5 layers of managers telling you to get shit done by yesterday as marketing just promised a bunch of shit, you aren't choosing a low velocity language for that (nor should you for sanity alone), you're gonna use Python and use some dodgy packages, BS some unit tests, and serve them the shit sandwich they ordered.

            [...]
            [...]
            Send me your CVs, I prefer to be constructive with communities and getting you NEETs jobs so you can understand would partly uplift this place. I can tell you're NEETs because like juniors, you know the facts that it isn't every case, but you lack the wisdom to know it's definitely over 80% of cases

            [...]
            I've always compared it to building a house, you could decorate the kitchen but if you need to change the pipework (which you're manager will insist on), you need to pull up the floorboards, remove the table and chairs, furnishings etc. That's the problem with an optimal solution, I just build stuff that's modular TDD since I can change it, test it, or remove it if it's not needed anymore, frick optimised shit, that's the work of autists and academics, it's not my product.

            [...]
            It's unironically why Python is probably one of the better languages, easy language, check, need something fast, cook up a C API for it then it's both readable and fast. Imagine if data scientists or ML engineers had to use C/C++, code war crimes galore

            >it's definitely over 80% of cases
            It really depends on your branch, obviously you don't work in embedded.

          • 1 month ago
            Anonymous

            >The fact that C/C++ devs never actually tested code as standard until higher level languages did it
            im gonna ask you for a source on that. this sounds too enormous to be true.

            >the fact it genuinely believes a modern standard needs to be backwards compatible to a 50 year old version.
            100% agree this is pretty asswards.
            especially we have version flags with our compilers

            but
            this
            >believed making people manage their own memory was a good idea (sure, you, the 10x dev could do it, but do you genuinely trust your team, or the juniors to do the same?).
            i firmly believe it is a matter of proper training.
            people are taught to use idiomatic c which tries to instill a high level approach to the language, through a heavy use of the libc.
            but it destroys code ownership and a high level approach doesnt train dataflow visualization.

            once the trainees have to do memory management, they just arent used to it.
            from my point of view, memory management in c can be done properly just by being boringly systematical in following the lifetimes of your objects, and if people fail at it, it is because they werent trained to do it properly.

            if i were to work with a team of various skill levels and backgrounds, id just extend the language and/or provide them with libraries.
            admittedly its a little cheeky, but the simplicity of c makes code analysis and generation if not trivial, then very doable.

            but admittedly, i dont work in a corporate setting, i am mounting my own company. when i will do the hiring i will hire a core team of decently skilled and highly motivated people i already worked with.
            but i understand the need for more standard, high level tools too.
            if i were to work in an organization i aint gonna take upon me the retraining of the whole workforce to work with my standards.
            im gonna go with whats standard in the industry for the task at hand.

            (1/2)

          • 1 month ago
            Anonymous

            (2/2)

            >and as gay and troony harbouring as Rust is, I'm glad it's showing how shit C++
            completely agree
            i always told crabs that their actual target is C++, not C.
            a big part of the the appeal of C is its *lack of abstractions.
            you cant compete with a product whose prominent feature is a lack of abstractions with a language whose key selling point is a lot of them.

            >can't wait for the next language that ran because Rust walked
            same here. im all for progress in computing methods, safer code and more efficient development.
            and rust is a step in the right direction.
            its just that... its undercooked. unrefined. and theres too little attention paid to ease of use.
            hopefully the next new low level language will have learned from rusts mistakes.

            but im affraid the bad side of rust is actually a feature.
            call me paranoid, but the cognitive overhead of rust might be desired to force people into increasingly larger teams, to facilitate the monopolization of innovation by big corpo.
            the difficulty of use of rust creates issues with the workforce. its lack of standard promises rewrites in the future.
            it makes no economical sense to push for rust as it is now.
            yet, major companies, and even the us government are pushing for it. there must be another reason. and monopolization of innovation fits the bill, and would even be profitable in the long run.

          • 1 month ago
            Anonymous

            >call me paranoid, but the cognitive overhead of C might be desired to force people into increasingly larger teams, to facilitate the monopolization of innovation by big corpo.
            >the difficulty of use of C creates issues with the workforce. its lack of standard promises rewrites in the future.
            >it makes no economical sense to push for C as it is now.
            >yet, major companies, and even the us government are pushing for it. there must be another reason. and monopolization of innovation fits the bill, and would even be profitable in the long run.
            C already did this. The lack of productivity of C made it so only the biggest companies can get anything done.

          • 1 month ago
            Anonymous

            >lack of productivity of c
            now i know for sure this is bait

      • 1 month ago
        Anonymous

        >*autistic screeching*
        >makes 100 other threads seething about this specifical language because you can hold a knife from the sharp side

      • 1 month ago
        Anonymous

        >C
        >slower than python
        So OP wasn't even sincere, he's just posting bait?
        >NOOOO MUH PRONOUNS ARE SHE/HER REEEEEEEEE

  6. 1 month ago
    Anonymous

    After browsing this shithole board for quite a while I've come to the conclusion that 90% of threads in IQfy are made by morons that got filtered by something and come here to hate on it to cope with the fact that they are midwits.

    • 1 month ago
      Anonymous

      >90%
      100%
      If the thread starts off on a normal discussion, it will quickly devolve into shit flinging. Honestly starting the thread with shit flinging is the most honest thing a rust supporter can do, because they were going to do it anyway no matter what.

  7. 1 month ago
    Anonymous

    >new thing good
    >old thing bad
    Grow up.

    >inb4 old thing good, new thing bad
    have a nice day as well, evaluate things on its metrics, not age.

    • 1 month ago
      Anonymous

      I evaluated C++ on its metrics and I scratch my head when I see "people" say that C is somehow better in any regard.

      • 1 month ago
        Anonymous

        an idiot admires complexity...

        • 1 month ago
          Anonymous

          ...while a genius abstracts it away?

          • 1 month ago
            Anonymous

            its all fine and dandy until you realize your abstractions also have to interact with eachother.
            you'll understand once you properly learn coding

          • 1 month ago
            Anonymous

            Sorry I never learned this "coding" thing separately, I'm more into programming, it's basically like coding, but also involves using my brain at the same time.

          • 1 month ago
            Anonymous

            these are synonyms doe
            make a detour through english first

          • 1 month ago
            Anonymous

            Sorry I wasn't notified of when they became same thing, was it around the time when men became women in this special English language of yours that I'm totally going to take seriously now that some IQfytard amerimutt told me to?

          • 1 month ago
            Anonymous

            too much venom.
            who touched you and why was it your father?

          • 1 month ago
            Anonymous

            That's what open source is for homosexual. 99.99% of the time customer and users just to click a button and everything to magically work.

            C, rust and Go abstract away the bullshit so you can just printf() without giving a frick about streams and buffers

          • 1 month ago
            Anonymous

            im talking about syntactical abstractions you dweeb

          • 1 month ago
            Anonymous

            Same shit homosexual

        • 1 month ago
          Anonymous

          That explains C. Most of the complexity in C makes it worse for the person using it. Normally features in a language have a purpose by making programs simpler, so the overall complexity of the system (language+program) is smaller than if the feature was not part of the language. C does the opposite where the complexity in C adds even more complexity to the programs. The complexity is not even considered to be features in C. C programmers use the word "footgun" to describe them. Normal languages have features. C has "footguns."

          • 1 month ago
            Anonymous

            No, you don't understand, C not having any tools to make simple interfaces makes programming in C simple. It totally doesn't bleed inherent complexity into the codebase.

          • 1 month ago
            Anonymous

            >Most of the complexity in C makes it worse for the person using it.
            its less complex doe

            or are you saying that you have no control over your code bc you have no idea whats going on behind the abstractions?

          • 1 month ago
            Anonymous

            >more complexity is less complex

          • 1 month ago
            Anonymous

            *less complexity bc you will write the exact same, only everything is explicit.
            please stay away from code, we have enough CVEs as is

          • 1 month ago
            Anonymous

            >its less complex doe
            C is a very complex language. It just doesn't do anything with all the complexity. It's all because of bad design.

            >or are you saying that you have no control over your code bc you have no idea whats going on behind the abstractions?
            That's false. I wrote my own language and compiler so I have more control over my code than any C programmers on earth do.

          • 1 month ago
            Anonymous

            >It's all because of bad design.
            yeah the design is so bad that we still base our languages concepts and syntax on it 50 years later.

          • 1 month ago
            Anonymous

            What is so complex about C exactly?

          • 1 month ago
            Anonymous

            It filters morons with pointers. Which is actually its best fricking feature.

          • 1 month ago
            Anonymous

            C is a hammer, nails, hand saw, measuring tape and pencil.
            Libraries are hand drills, lathes, laser levels, tablesaws, and nail guns.
            But modern programmers want to build ikea furniture with rust and python and call themselves carpenters

          • 1 month ago
            Anonymous

            >C is a hammer, nails, hand saw, measuring tape and pencil.
            And all of them are the lowest quality crap that failed quality control.

          • 1 month ago
            Anonymous

            >C is low quality
            >C still in use after 52 years

          • 1 month ago
            Anonymous

            >muh rhetoric
            >WHAT ABOUT MUH RHETORIC!
            Nobody cares.

          • 1 month ago
            Anonymous

            >What is so complex about C exactly?
            Read it for yourself. It's "only" 756 pages.
            https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3047.pdf

          • 1 month ago
            Anonymous

            Now compare it against the standards doc of your favourite language.

          • 1 month ago
            Anonymous

            it doesn't have one

          • 1 month ago
            Anonymous

            Disingenuous homosexual.

          • 1 month ago
            Anonymous

            1. there's no reason for that function to be static
            2. you've written C not C++

          • 1 month ago
            Anonymous

            C is a subset of C++. Valid C code is valid C++ code. There's no reason for it to be static in the image either but I didn't want a semantics Black person like you to say OMFG YOU DIDN'T MAKE IT STATIC WTF. Also
            >Stop being a Black person.

          • 1 month ago
            Anonymous

            >nnnn but C is a subset of C++
            yes. youre still writing C.

            this is the easiest ways to detect neets
            doesn't how fast the software runs, it matters how fast it is to build the software in the first place

            webshitter take.
            your whole infrastructure is build on C and the likes because performance translates into real life money if you need an n times larger infra bc of your moronic code

            its true for 99.999% of cases
            build the initial product, then iterate and improve it. Trying to build the most optimal program from the get go is a one way ticket to bankruptcy
            exceptions are onboard controllers/systems on planes or similar fields which is a very small portion of the entire software market

            all leveraging high performance low level languages.
            webshittery should be a bannable offence

            Same shit homosexual

            lol. what an illiterate

          • 1 month ago
            Anonymous

            disingenuous and a moron

          • 1 month ago
            Anonymous

            >floors your float
            heh, nothing personal kid

          • 1 month ago
            Anonymous

            You only require such a generic if you're using classes and overloading operators, none of which is valid C.
            If you want a function to work on floats, you need to define. Just like you need for unsigned and signed, sometimes. And the different data widths of it. It's part of the deal. It's more verbose this way, yes, but you'll avoid the work you'd have to exert using templates, because that, by design, strives to be generic, meaning you have to consider more edge cases everytime you use them.

            Nanananana... nanananana.... hey, hey, heeey, gooohoodbye.

          • 1 month ago
            Anonymous

            unsigned int add(unsigned int a, unsigned int b) {return a + b;}

            Is COMPLETELY BUG-FREE AND ABSOLUTELY DEFINED and will return a valid mapping of a U32 value to any arbitrary input U32 pairs.
            As soon as you add signed, it's broken.
            Now C++ even adds generics!
            moronic homosexuals, moronic homosexuals everywhere!

          • 1 month ago
            Anonymous

            >compares static int function to template
            ngmi

  8. 1 month ago
    Anonymous

    Of course a shitty reddit meme spamming underage homosexual who has never written an useful C program knows a lot about simplciity.

    • 1 month ago
      Anonymous

      >no you
      thats more telling about you than me tho.
      somehow you care about 5 chars after a timestamp.

      • 1 month ago
        Anonymous

        it's okay fizzbuzzer, you don't have to be mad that everyone can see through you being a nocodeshitter

        • 1 month ago
          Anonymous

          >t. filetred by void *
          lol

          • 1 month ago
            Anonymous

            >void*
            is that how you represent your penis in C?

          • 1 month ago
            Anonymous

            >is that how you represent your penis in C?
            how old are you?

          • 1 month ago
            Anonymous

            old enough to have grown up before troony pedogroomers who stole your penis showed up because void* represents the void between your legs perfectly, and to add insult to the injury, the pointer is dangling and UB to dereference.

          • 1 month ago
            Anonymous

            the question was purely rhetorical you mong autismo

  9. 1 month ago
    Anonymous

    modern food is hyper-palatable to the point that it's unhealthy and causes heart failure
    besides, c is not a low level language

  10. 1 month ago
    Anonymous

    BURN THE HERUSTIC
    KILL THE CRAB
    PURGE THE TROON

    • 1 month ago
      Anonymous

      >Tau is Python
      >Eldar is LISP

      What is the Orkz?

      • 1 month ago
        Anonymous

        it must surely be some flavour of the 'fun' scripting languages like lua

  11. 1 month ago
    Anonymous

    Rust and Go are unusable.

  12. 1 month ago
    Anonymous

    My father raped me when I was a kid.

  13. 1 month ago
    Anonymous

    I will learn C Puss Puss only to piss off Cniles and Rust trannies, lol.

  14. 1 month ago
    Anonymous

    >moronic emotional exaggerated rhetoric
    >no actual logic or examples or even a point beyond "muh c bad"
    If you need attention you can just post pictures of yourself in your programming socks on reddit. You don't have to shit up IQfy.

  15. 1 month ago
    Anonymous

    [...]

    I posted your friend's site because C programmers don't listen to people unless they worship C and Unix.
    http://justine.lol/sizetricks/
    >I like the UNIX philosphy of having lots of small programs. I like it so much, that the Cosmopolitan repository builds hundreds of them.
    That means you will believe what he says about C compilers being the reason C is fast. If I quoted someone who said C is bad, you would ignore the post and say it doesn't count.

    • 1 month ago
      Anonymous

      beyond page 184 its all libraries
      do rust now homosexual

      • 1 month ago
        Anonymous

        >do rust now
        can't
        it has no standard and only one compiler (that's a good thing though don't ask why you wouldn't understand)

        • 1 month ago
          Anonymous

          >no standard
          >good thing
          lmfao

  16. 1 month ago
    Anonymous

    Why are you guys fighting with each other? Every problem on this earth is because of Joos. Do 110 on them and everything will be fixed.

  17. 1 month ago
    Anonymous

    It's more fun to cook with fire and eat without utensils.

  18. 1 month ago
    Anonymous

    >We don't look back at our ancestors ways and reminisce about the old days where consuming clean cooked food wasn't in the grasp of the imagination
    speak for yourself homosexual, my grandma's 'dirty cooked food' tastes a lot better than the 'clean cooked food' they serve at restaurants. I'll emulate my ancestors and reject modernity.

    • 1 month ago
      Anonymous

      op is a mongoloid

  19. 1 month ago
    Anonymous

    C is not a programming language. The C interfaces are built in into every computing system today, they're the lowest layer of abstraction bar compiled machine code. Zig is the evolved way to write for C APIs though

  20. 1 month ago
    Anonymous

    >C IS ONLY FAST BECAUSE THE COMPILER IS GOOD
    This is partly correct, but the compiler can be so good because C is such a simple, good language.
    Rustc will never be as good as clang, even though they're both LLVM

  21. 1 month ago
    Anonymous

    If you can't understand C pointers, you will never be able to program.
    It's a filter.

  22. 1 month ago
    Anonymous

    >try to learn C
    >can't understand pointers
    It's over.

    • 1 month ago
      Anonymous

      What the hell is so difficult to understand

      • 1 month ago
        Anonymous

        order of dereferencing can be tricky
        like when you have an array of structs, which contain other structs, which contain arrays etc
        but the principles are pretty straightforward

        some just need the right example for pointers to click in their heads

      • 1 month ago
        Anonymous
    • 1 month ago
      Anonymous

      p = make_shared()
      *p
      What's so hard?

      • 1 month ago
        Anonymous

        >make_shared
        anon please

  23. 1 month ago
    Anonymous

    If industry would have gone with Pascal instead of C, we would not be in this mess. Thanks, Unixtards! Thanks, academia! You've hobbled computing as a whole!

    • 1 month ago
      Anonymous

      stop spamming this moronic shit in every C thread, rustroon
      at least be inventive or something

      its the 4th time i see your moronic discourse
      your next step is a winded rant about how it all boils down to c being made for pdp 11

      and then you getting btfod with
      >c is the one of the most, if not the most ported language in the world
      >it would make negative sense if it wasnt a flexible, adaptable language

      get new material, crabs
      its gonna be 2 days youre running the same show, it gets boring

      • 1 month ago
        Anonymous

        >its the 4th time i see your moronic discourse
        First time I've posted it. Nice to see that there are more people that think similarly on it.

        • 1 month ago
          Anonymous

          [x]doubt
          https://desuarchive.org/g/search/text/pascal

          >call me paranoid, but the cognitive overhead of C might be desired to force people into increasingly larger teams, to facilitate the monopolization of innovation by big corpo.
          >the difficulty of use of C creates issues with the workforce. its lack of standard promises rewrites in the future.
          >it makes no economical sense to push for C as it is now.
          >yet, major companies, and even the us government are pushing for it. there must be another reason. and monopolization of innovation fits the bill, and would even be profitable in the long run.
          C already did this. The lack of productivity of C made it so only the biggest companies can get anything done.

          thats bullshit.
          or you wouldnt have gnu loonix. especially the gnu part

          • 1 month ago
            Anonymous

            >https://desuarchive.org/g/search/text/pascal
            Goddamn dude, you have way too much time on your hands.

          • 1 month ago
            Anonymous

            it took 15 seconds you fricking dweeb

          • 1 month ago
            Anonymous

            Its not the time it took, its the fact that you are this petty on an anonymous image board. You need pussy.

          • 1 month ago
            Anonymous

            kek.
            youre malding that you cant manipulate the weak minded autists from this board like before

            youre psycho doe
            you dont have compassion towards others, dont expect it for yourself

          • 1 month ago
            Anonymous

            btw
            >petty
            its all organic.

            your bunch acted like total asswipes for a loooong time
            with alooooot of people
            and now everyone gives back what you have been shoving down their throats during all this time.
            dont cry, bully.
            who lives by the banter, dies by the banter
            yoiu should have been a nicer person

  24. 1 month ago
    Anonymous

    Hardware hasn't changed moron.

  25. 1 month ago
    Anonymous

    LMAO, OP is a gay who got filtered by memory management.

  26. 1 month ago
    Anonymous

    C is a little like roads, it doesnt really matter if its the best or not its what we have and like roads we already laid out everywhere we have c everywhere and we cant go around and change everything all at once like switching to trains overnight
    If anything could work its something like zig which works nicely with c
    Rust might replace cpp, could be nice but will take 10 years i guess

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