@allison I swear, I'm gonna make a language, it's gonna just be C without this bullshit, I'll call it "G" (a "C" wearing a moustache as a flimsy disguise).
@animeirl No, C allows people to write C code, Rust makes people turn Github issues into 300-reply hellthreads.
Rust isn't a programming language, it's a diversionary tactic. People are talking about programming languages that aren't rust and some Rust whiner shows up and either demands everyone use Rust or complains about Rust persecution. It is the neo-Nazism of programming languages. It's a perfect parallel: neo-Nazis spend nearly no time actually living out their ideals, they just whine that nobody lets them and that they're being persecuted by the Jews (C programmers) and that they are superior.
Know why I learned C? Know why I learned any of the languages I know? Do you know why people learn a programming language? None of these reasons apply to Rust: it's useless.
@p@animeirl Not how many of the supposed "Rust replacements" for common utilities like those from coreutils are shipped with some cuck license instead of GPL.
@animeirl C is unavoidable not because it has been around so long--Fortran and Lisp have been around longer--but because it is useful for so many tasks.
Rust is a shit language and I will not use it and the more people whine, the less I will be inclined. Rust is like Nazism: even if you assume that they are correct about everything, the main effect it has is turning people into intolerable whiners that cannot help injecting mentions of their single issue into every thread they see, whether it's germane or not.
@animeirl Tell you what: I'll avoid interacting with any software that was written in Rust, you can avoid interacting with any software that was written in C.
@animeirl Rust is a shit language, but that's why we have so many languages: people that do not like how C works can fuck off to Rust, and people that have sophisticated enough taste to prefer C are able to ignore Rust entirely.
@animeirl@sysrq Rust programmers don't write code in Rust, they just fine Github issues and HN threads to whine about better languages and demand everyone use Rust. Why would I use Rust if even Rust programmers spend more time demanding other people use it than they spend using it themselves?
@animeirl@nishi Lisp has been memory-safe since forty years before Rust existed, and is a much better language. Tcl is memory-safe. APL's memory-safe. OCaml's memory-safe. Lua's memory-safe. awk is memory-safe. Go is memory-safe. Ruby is memory-safe. JavaScript is memory-safe. Erlang is memory-safe. Brainfuck is memory-safe. Haskell is memory-safe. Python is memory-safe. Prolog is memory-safe.
Perl is memory-safe. PHP is memory-safe. Java is memory-safe.
@p@animeirl for real. also i am sure they do not know what debuggers are for. "wehhhh segfault wtf did i do weong !?!?!? this is why rust is better n!!!!" i hate these rustnigs
segfaults aren't really the problem. it's when they dont happen that is but it's still better for potential issues to come up at compile time than during runtime when possible
@allison@nishi@animeirl Almost all debuggers suck, but they can all be convinced to give you a stack trace when a program crashes with a minimum amount of hassle, which is the main use for any of them.
@mint@animeirl That is another good point. I'm sure this has nothing to do with the tech companies hating the GPL and wanting to move as much code as they can into a license that lets them exploit open source harder than they already do.
@animeirl@p@nishi honestly I feel like rust as it currently exists is something of a half measure, it doesn't go far enough on safety measures and it lulls the programmer into a false sense of security for writing "systems" code meanwhile gc'd languages are better for 99.9% of stuff anyway. I'm keeping my eye on austral for this reason and one or two others
@animeirl@nishi Yes, that is my point. Rust isn't a language, it's a cult. People that aren't complete assholes don't show up to Do Advocacy at people. It's as bad as assholes that go to parties just to "network" with unsuspecting people that just want to have a fun time with friends. It's as bad as salesmen and panhandlers that exploit the natural tendency to be polite instead of telling people to fuck off.
This thread had nothing to do with Rust, and some asshole showed up to Do Advocacy. "These people are talking about programming. This is a situation I can exploit for selfish ends."
@animeirl@nishi I use several of them. The narrow-minded Rust programmer cannot comprehend the continuing utility of C and Forth and even Fortran and assembly and all the languages that scare you from your safe home in the Rust Suburbs.
C is ofc still useful if you're looking for a job or projects to contribute to I just find it incredibly tedious in addition to the aforementioned security problems (which cause more tedium since you have to write more bullshit to guard against them)
@animeirl@teratology The solution to this was offered when you decided to show up in a thread that wasn't about Rust and shit out your sleazy salesman Rust Advocacy bullshit.
@animeirl@p I’ve been reading up more on this topic but the tl;dr is that linux’s kernel isn’t audited and most of the kernel has been the same so isa mess, I didn’t know they’re re-writing in Rust as well. All the more reason for me to pick it up but C isn’t going away anytime soon especially if you work with embedded systems. @realjoebiden is a C fanboy lol
happening in linux too. memory leaks aren't really the issue (also happen in rust) but the lack of bounds checking in C/C++ has basically been a plague on computer security since its inception
@animeirl@sysrq@nishi I'm saying I use it every day and it's a delight and I came to this conclusion without tedious fucking assholes Doing Advocacy at me.
The opinion of a Rust programmer means as much to me as the opinion of a Nazi or a furry. It's like a Mac user telling me my UI looks ugly. It's like a vegan criticizing my eating habits. Showing up to inject Rust into a non-Rust-related discussion on the internet is the equivalent of the Jehovah's Witness banging on my door and then offering opinions when told to fuck off with their Jehovah's Witness bullshit. It's like a telemarketer offering an opinion on my call quality. hellallyourfamily.jpg
@animeirl@sysrq@nishi In response to the first two words, yes. I'm about as sick of Rust as I am of Nazis and they have a very similar flavor. It'd be a toss-up if I could eliminate one or the other from the internet.
@hachi@sysrq@p@animeirl I'm sure you frequently use software that wasn't written by pedophiles, but you don't sound very thankful to them. Rope yourself at the earliest convenience.
> (a) the code is easier to reason about in the first damn place and
C is easy to reason about: you can basically do the compilation with pencil and paper. There are a handful of warts around things like casting or bitfields, but it's easier to reason about the behavior of something simple than something complex. Languages that surprise you are the ones that are hard to reason about.
> (b) they don't skimp on tooling.
I think there are two approaches to this, I mean, there are languages that are all tooling (Java has a lot of tooling because it's verbose and it's missing a lot of facilities that you expect from a language that lives on a VM), and there are languages that tooling would only get in the way of. The former effectively mean that your interface to the language includes the tools, but in the latter the interface to the language is just the language. It's usually better to make the tooling unnecessary than to add the tooling, some languages manage to be both concise and expressive, or integrated well enough with the environment that generic tools work for diagnostics. You don't really need a source-level debugger for awk, your awk programs don't get long enough for that to be helpful: the problem doesn't exist so no tool needs to be made to solve it. Most application programming languages can't segfault (or at least not because of a bug in your code): the bug has been avoided so you don't need a tool to handle it. Or they've integrated a stack trace, you don't need a separate tool for that.
Like, Nethack. Reading Nethack's source code is a component of playing Nethack. It is a little unique in that sense, most games don't work that way. You push the button, Mario jumps, your interface to a Mario game is all in the controller. Maybe for some games the interface is the controller plus a guide. Not that Java is terrible because of that, just that the interface to Java isn't Java source code files, it's Java source code files and the IDE and whatnot, and XCode seems to work more or less the same way.
As kind of a personal preference or a matter of taste, I like the languages that are usable without the tooling.
@allison@idiot@animeirl@nishi I don't think it's like that, I think some tools are not very useful. You can see what a process did or you can understand how the program works. This is the reason "the code doesn't resemble the compiler's output" is horrifying: you can't understand how the program works by reading the code if the compiler editorializes. So you bash stuff in at one end, the compiler does something completely different (e.g., the stuff in the top post in the thread), then at the other end you can use a debugger: this is a worse method of programming than thinking about the problem, writing code to express an algorithm, and then fixing your understanding if you fucked up the first step or fixing the code if you fucked up the second step.
@p@nishi@animeirl@idiot Oh without a doubt, I'm just saying that in addition to that, the tools themselves are needlessly baroque and thus there's no reason to use them unless you're forced to. What human being living on this earth has the time to actually *know* gdb? Much the same for any of the C debuggers shipped by any of the big names. acid is fine more or less because it doesn't do much and what it does it does well. Other languages and ecosystems don't suffer from this problem nearly as much because (a) the code is easier to reason about in the first damn place and (b) they don't skimp on tooling.
@idiot@p@nishi@animeirl pretty common among unix users I think, the tools are crap bc nobody really cares about them so the solution is judicious use of printf + being a better gorilla
@allison@p@nishi@animeirl To this day, I haven't figured out how to use GDB et. al. Like I know how it works and what's going on, I just never know when the best time to use it is and I bash my skull against the wall doing things the ghetto way instead.
@allison@amerika@animeirl@idiot@nishi There's always Forth. The standard way to start a Forth project is to write a Forth interpreter, making it completely impossible to have your experience with Forth ruined by unaccountable strangers.
> just because you can ship broken software with rust doesn't mean you're more likely or equally likely to ship broken software with rust as you are with c
Address the post I was replying to, then. All I did was take the premise as it was presented and reply.
A narrow focus on a single class of bug does not really say *anything* about the relative merits of the language.
@p@sysrq@animeirl >So does Rust I really shouldn't have to say this because it's middle school level logic, but just because you can ship broken software with rust doesn't mean you're more likely or equally likely to ship broken software with rust as you are with c
@hachi@Zerglingman@animeirl@sysrq What do you have to say about the nature of "undefined behavior" and the positions taken by compiler writers and the standards body on the proper behavior for the language, hachi?
> We all know open source doesn’t mean it’s more secure.
No, but "not Microsoft" does mean "more secure". You'd be foolish not to be suspicious of software produced by a company that has such a close relationship with the government of a major power, but most especially this company and this government. I do not know if you are old enough to remember watching what shook out in the 90s in this industry, but you are surely old enough to remember Microsoft on all of the PRISM slides if not but if you cannot build the project yourself from source you have downloaded, and the binaries come from Microsoft, you are owned. DRM, DMCA, TPM, TCI, all of these things were pushed by Microsoft.
@p@animeirl true but memes aside don’t you specialize in security? We all know open source doesn’t mean it’s more secure. I’m saying this as a void user.
@p@Zerglingman@sysrq@animeirl I'm a front-end web dev so the only undefined behavior I deal with are NaNs. I don't mess with compilers because I never use compiled languages. Though, I would like to learn Assembly because I'm getting into ROM hacking.
@xianc78@animeirl@sysrq@p@hachi Would you rather he goes on ruining the web with his shitty javascript? You don't have to play his hacks, they're not government-mandated.
> I mention void because I don’t run a systemd based distro for security reasons and minimalism
Yeah, I'm in the same camp, but talking about a distro isn't relevant, it's security-as-product rather than security-as-process.
> I’m not saying I’m not suspicious of microsoft, but they have people paid to audit and constantly patch known CVEs
If the software is a trojan, and they fix unintentional problems in that trojan, it's still a trojan. This is the company that, in terms of languages adopted, picked C++. They pushed out VB and VB has been a punchline for as long as I can remember because it's one hole after another even before VBA and email servers still get offered .xls files on a regular basis. I don't think it is wise to take any cues from a company with that kind of track record, let alone a malware vendor. Their endorsement is a negative thing.
@p@animeirl I mention void because I don’t run a systemd based distro for security reasons and minimalism
I’m not saying I’m not suspicious of microsoft, but they have people paid to audit and constantly patch known CVEs while with open source projects we rely on each other to catch these things. It creates a bystander effect that’s as misguided as corporations making millions off of open source projects.
@hachi@Zerglingman@animeirl@sysrq It is mainly a thread about the differing interpretations of "undefined behavior" between C programmers, C compilers, the C standards body, and the change over time; compilers are becoming hostile. (The behavior of NaNs is well-defined, just annoying to run into them.)
@p@nishi@animeirl isnt k&r outdated as fuck? its the only reason im not reading as its only talking about language c whereas sicp is about timeless concepts. im going through sicp too lmfao.
Anyway, the language hasn't really changed. A little extension for the sake of convenience, but C is C. Even code from v7 (which predates ANSI-C, which is what the second edition of K&R uses) still compiles and runs for the most part, so the book is current. Even the stdlib functions described are the same. The stuff that's changed fits on half a page: you wanna use strncmp() instead of strcmp(), the "register" and "inline" keywords are sometimes ignored in $current_year compilers, etc.
> its the only reason im not reading as its only talking about language c whereas sicp is about timeless concepts.
No, there's a reason people still read both K&R and SICP. K&R does describe the language, but the examples are all great stuff, and it's heavy on code. qsort() and binary search and parsing and how memory allocation works.
@iron_bug Yeah, I run into more portability issues with different compiler versions than I run into on different architectures. LP64 versus LLP64, endianness issues, these are fine, they don't cause problems if you pay attention to what you're doing. The difference is if I make a mistake with something like endianness, I feel foolish, but if the compiler rewrites my code, my program is broken because of someone else's mistake, this is frustrating.
> I write in C for over 30 years and I don't remember such problems in debugging.
Yeah, it's a new problem, the compilers are kind of going off the rails now. I expect optimization to move things around, I don't expect it to decide to call different functions. the_compiler_has_gone_mad.png
@p I build my system myself, from sources and I'm really afraid of updating a compiler because I cannot predict what monkey shit they could add to the next version that can ruin normal working software and introduce new bugs and quirks, or add new tons of annoying useless output. I seriously begin to think that I possibly need to patch gcc to remove all that litter from output because it drives me mad.
@iron_bug I don't know, it's a mess; usually this kind of thing happens after a personnel change. I'm not sure what version it was but a long time back I was debugging something, I put a `printf("About to do the thing before the bug happens\n");` and gcc silently translated it to puts(), so I set a breakpoint on printf and the program never stopped, my breakpoint didn't happen (and mangled the constant in the binary).
@p this usually doesn't happen if you don't use optimization, etc. I write in C for over 30 years and I don't remember such problems in debugging. -g (-ggdb3) -O0 and that's it.
@p what happened? I use gcc for ages (couple decades, at least) and it's fine. well, it went messy with useless warnings and paranoid output instead of just pointing to the file and line where the error is, but it's not so crucial.