I can confirm this applies to me. I know I'm not that good, but I "feel" like I am.

If your software is boring, you're in the top 10%

@@ScibbieGames Mine is boring, not because I'm in the top 10%

@@ScibbieGames exactly. The good thing about C is you can do anything with it, the problem with C is you can do anything with it. C programmers usually want to be "creative" and there's where they turn on the fan and grab the bag of sh*t. "Oh I'm so great in C look what I can do" yeah genius you're throwing sh*t at the fan now.

They're C programmers, hubris comes with the job description. :)

glow in the dark

​@@werren894 N

That actually made me spill tea through my nose. Well played sir.

Hardest question: "Is this n*****licious or is it divine intellect?"

and canonize Terry Davies as a saint

Both of them write logic bugs

There are two types of programmers: - One type knows they write memory bugs. The other thinks they don't write memory bugs. - n+1.

There are two types of programmers, those with the right tooling and ..

that, combined with the fact that sauron apparently wants it - makes me thing this isnt about garbage collection., but instead some other effects of those preffered languages. this is about control of something. it always is. i am familiar with whats going on at the hardware level and i am under no illusion that this is any better through the layers up to the programmer/user... any thoughts? this is an issue from the beginning. it starts at the chip-fab/systems-assembly.

a good programmer is so unfathomable to shit programmers

After spending some time thinking of how I'd try to explain the problems with the argument, I actually think this sums it up much more concisely and convincingly than any kind of logical analysis.

@@devinneal438 How is your comment from an hour ago but the one written by @Zguy1337 only 32 minutes old? I am confused.

@@catfan5618 Your youtube probably refreshed the comments at some point, adding any new comments without updating the time frame of old comments

Actually, it should have been "do not fall with scissors in a way you didn't intend to" ;-)

@@czakotmiszermawi *bumps into coworker mortally wounding them* "woops"

It's because you're programming defensively. The language should have a type called number and if it overflows it goes into bignums. Gawk does this. Erlang also let's programs crash. We are stuck on shit. But it's because of speed.

@@Khwerz I'd prefer to still split it into integers and decimals, but yes. Speed is king, which is why the languages let us make those decisions.

@GreyReBl describes the mental discomfort when the horizon of "unknown unknowns" grows rapidly as technical learning exposes more knowledge surface area.

Yup, I've been programming for living for 30 years, trying to learn every day how to be a better programmer.. and year by year it's become ever more painfully obvious how little we actually know and care about making good software. It's tribal warfare about which mistakes we should repeat. I hope we get more science in the "computer science" and the industry actually starts listening to it..

pure poetry

facts and logic

Chad

No one has a problem with that. It just doesn't belong in critical infrastructure or controls.

@@DanielJoyceI would call that a matter of opinion. It is less about the programming language used and more about best practices in design, implementation, and testing. Although, I do think there is a fair case about not using a language designed for systems programming to write ALL of your software.

o7!!!👍

Let's go Brandon. C for president 2024

Ah, fellow contrarian. Or does that even count.

White house is also recommending Go. Look like we have to write stuff in assembly now

Oh man, you're like soooo edgy!

"Well, now I'm not doing it" vibes!

Also this guy is being dishonest with his statisics in his quest to prove that he IS good enough to use C. "88% are below average contributors" while having obvious mega outliers. The median number of commits is three. The "average" contributor makes about 3 commits, and the 1 or 2 guys maintaining a project do a lot more work, sure. That doesn't make the rest "below average". What an insufferable author.

@@markogalevski6088 Absolutely agreed. Comparing skill with commit count is stupid.

looking forward to retirement, when I can do 100% solo projects. hell is other developers

​@@markogalevski6088By definition, about half or more of people im any given profession are below average in measurable skills, and given Pareto, the levels of contribution spread over a group are abysmal data to review.

@@blarghblarghyou're the problem

99% of Rust developers are front end boot camp developers that know absolutely nothing about system programming VS 99% C developers are well versed in system and probably embedded programming to some degree.

@@jazzycoder hey jazz, I love C too, but you don't need to spam a copy paste reply

​@@jazzycoderWhy are you spamming this everywhere? Also this statistic is WILDLY untrue.

​@@VivekYadav-ds8ozMaybe not true but it paints a rough joke on what Rust means for the dev world. Just look at the cpp vs rust reddits, one has twice the other's active users while retaining the same sub count, meaning perhaps that people enjoy more talking about rust than coding in rust. Proof of this is that I can find 8 job posts in the Barcelona area relating to Rust (6 of them are the same remote position copy-pasted all across spain; C++ on the other hand...

@@jazzycoder A certain part of me finds you people endearing. Please continue to spam your pro-C comments to angry Rusties. They deserve it because they act like a cult.

I mean you can buffer overflow or use after free in safe rust without that much resistance, so the 0 days are probably staying.

@@UnidimensionalPropheticCatgirl No, you can't. Things like cve-rs are neat tricks you can play with the type system, but they aren't things that are just going to randomly pop up in your code "without that much resistance". While very interesting, they are very deliberate exploits that demonstrate hard to fix edge cases with the compiler.

The memory issues that Rust supposedly solves "because tooling" are also solved with C & C++ -- just use the tooling (general a flag or two). When people refuse to do that we can take bets about how many "Rust" devs will soon be in disabling "those annoying safety things..."

@@UnidimensionalPropheticCatgirlYou're talking about temporary compiler bugs that don't even apply to normal code vs fundamentally unsafe design. Do you think corporations like Microsoft, Google etc would go through the effort to switch to this complex language if there was no clearly measurable advantage?

@@infinitelinkAnd another "skill issue" person. Just use the tooling, just jump through all the hoops, just do everything perfectly because that's what people can be famously relied on.

Well NASA tries to avoid using anything but static memory altogether, which eliminates a huge chunk of the safety issues with C

@@research417 Also every method needs to take a time budget (often simplified to a counter) as one of its inputs, and abort early & cleanup if it can't finish within the time constraint. Cooperative multitasking where each task is just proven to finish in time is much more predictable than preemption

Automakers also have to use a C subset for their systems. Programming C with all those restrictions and rules sounds like a MISRAble experience.

​@@research417are no all memory a static memory?

​​@@InZiDes, no static memory is the memory which is allocated during compilation while dynamic is the one which could be created during runtime. uint8_t arr[1024] = {0} vs uint8_t *array = malloc(1024) for example

Find one major application written in C that doesn't have a CVE about an RCE vulnerability haha, the issue has nothing to do with skill like the author claims. I would even argue the author demonstrates their own lack of skill by demonstrating that they feel as if they require memory unsafety to write good code. There are a lot of issues with many of the author's points imo and they use a lot of logical fallacy.

@@Hexcede also, that 10x programmer also has to spend all his time fixing the other stuff written by the newbs that he won't get anything done at all. Rarely will you have a team of all 'aces'.

@@HexcedeseL4, probably, lol. But then again, I don't expect people who don't want to learn rust to learn even more complicated Isabelle.

Zig is a better C and even it's projects have segfault issues. Meanwhile the number of rust crashes involving safe code is basically 0.

Yeah this author didn't give a reason to not switch off of C, they just wanted to show off that they were knowledgeable about C best practices.

This. One of the best comments explaining this that I have seen so far.

exactomundo

💦

I was definitely suspicious of his "ace" claim after reading some of the code. In general he jumps through a lot of illegible hoops to do seemingly unsafe stuff that other languages abstract away.

Bro really just said "I *MAKE* Arch, btw" 😂

Not fully because the same C developers also write the compiler for the “safe” language so they are now introducing those bugs into a compiler which can proliferate into the codebase. Only when you then have the 10% developers then you will possibly have a safe language. The problem is that this does not happen.

@@Xamdify rust isnt written in c lmao, it was first written in ocaml and then rewritten in itself, how new r u to this?

@@yandere8888 Those are still developers. You know human beings that make the mistakes in C, when someone develops in a different language then they won't magically develop safe code...

@@Xamdify wut r u even trying to say with this? that rust wont magically make all code work all the time? wow really? do u know that c doesnt do any bounds checking by default? it also forces u to do memory allocation manually aka freeing everything u created thats just BAD language design, its not a necessity to not have those features, its a bad decision

​@@yandere8888 I never said that they make code that works all the time, I said *SAFE* code. In literally every language it is possible to easily write unsafe code... Also C was developed in the 1970s so there were no other options which where memory safe and the hardware didn't have the capacity to use automatic memory management.

I personally use it for joy and its simple syntax.

Exactly right. Good structure, indentation, careful attention to matching brackets. Avoid huge functions as much as possible; don't do everything in main(). Once you get a good function, you can re-use that function in many places. Check the boundary conditions. Never ever assume that a string ends properly. I do some tricky things with unions where a particular memory address is simultaneously a byte, an int, or a string (or other things). This will sometimes be useful in the case of receiving data over the ethernet when you don't know for sure what exactly it is. Same with a chunk of data from a database. There's no telling what exactly it is sitting there in the buffer.

git gud*

Your mental gymnastics on that analogy are more insane than a tightrope over corpses

@@greg77389Sorry, I couldn't hear you over all of the screams about undefined behaviors and buffer overruns.

@@MrKlarthums Skill issue

​@@greg77389Yes, I'm aware of your skill issue in evaluating languages that weren't good 20 years ago and still aren't good now.

Bjarne Stroustrup (inventor of C++) argued exactly this point in order to convince people to use arrays/std::vector instead of linked lists.

It works that way at any level, not only CPU caches Locality is the best way to make use of paging mechanisms.

I think the author fears that he will be forced to use/ learn something else, when he feels like he is competent enough in C to not fall into the pitfalls.

Yes, this was my takeaway too. The author just basically argued against their own statement. If anything I would argue that if you rely on an unsafe language like C to write fast code than you are the one with the real skill issue.

revenge of the blub programmer. don't claw us back into your filthy pit, pot of crabs. we want to break free!

I mean his point was the White House argues ALL programs should move away from C, which he demonstrates isn't the case. Because there is a higher ceiling in C than in Rust, simply with how it let's you do more. It's not an outright denial of the White Houses claim, he agrees most people should be using Rust, it is literally one of his first statements, his critique is very specifically that it shouldn't be said that all code bases should now ignore C. The article makes it pretty clear what part of the White Houses statement he is arguing against, how do you misconstrue that as arguing against ALL of the statement? Especially when he outlines what part he does agree in the introduction.

The author has made so many logical errors in his article I can’t handle it

nowadays, the mid guy is a js dev

@@Daniel_Zhu_a6f ahahaahaa its so funny but so sad, well played sir

​@@natemaia9237 maybe if capitalists knew a thing or two about technologies they invest in, we wouldn't be in this stupid and sad js situation.

an arena allocator?

yes, void* in C is the most generic type possible, the only downside is that the compiler won't help me if I screw up(and a possible indirection for small size types that could normally fit in a register)

​@@TsvetanDimitrov1976I'm an embedded systems programmer, using void* on the daily together with about 20 to 30 people working in the same repo. I can't remember a single time this has caused a bug.

@@mananasi_ananas The only and only gamer found.

This right there. It doesn't matter if you're the top 1 car driver, you put a seat belt.

don't tell me what to do u fluffy react developer, I am superior

You put a seat belt on because OTHER people have skill issues. I don't have the same problem on my C programming team.

Better analogy is a car 5 - 8k thats a metal box but cheap and light. Or a 50K - 80K+ car that has all every feature, etc. Sometimes you just want something thats simple that gets the job done

@@7th_CAV_Trooper This is not even remotely true

absolutely. 100%

IIUC, the pattern is used by std::make_shared, etc. to allocate the ref count (or other data) with the object type, avoiding an additional allocation.

@@msclrhd Not quite. With make_shared, the object and the ref count can be allocated together in the same block of memory, saving one indirection. But it's not technically an intrusive pattern. An example of the intrusive pattern is boost::intrusive_ptr, where you put the reference count in your class, making it usable by that smart pointer. But boost:: intrusive_ptr is pretty much useless now. Like I said, with C++ templates, it's pretty rare that you really need an intrusive pattern because you can most often just store the "T" object by value within whatever node you have and get the same performance, which is what std::make_shared does.

@@mike200017Ah, thanks! That makes sense.

In C++ it is less common for stupid reasons. Code managing links in link based data structures like lists or red-black trees is type-agnostic. You shouldn't have a different type-annotated instantiation of it for each "template instantiation" when the outputted assembly's the same. But the subsequent casting (container_of in the Llinux kernel) to the right container type should be done inline and in a contained fashion.

"Are we supposed to keep letting developers write bad and unsafe code so 10% of them can become amazing at an unsafe language?" There is no WE. Unless you are the boss and not a developer yourself and looking to UKposts commenters to answer this question. "Will there always be someone around with your skill level?" Sure; a few thousand miles away perhaps. I come from an era of mainframe assembly language. How "unsafe" is THAT? But when it works, you KNOW it works, no hidden library bugs.

Sounds like you suffer from skill issue. Recommended medication is a high dose of getting good

That's not what a cougar is, so this isn't really landing. Cougars are mature women who play the field of young men, generally 40-50. The pejorative for an unattractive cougar is "cradle robber" but objective beauty is not real etc. and the term doesn't generally apply to functional narcissism, but rather the subtext described above. Almost clever, but perhaps too surface

@@BeamMonsterZeus no, you just missed it. The joke landed fine.

​@@7th_CAV_Trooperthis is peak Internet conversation

Wouldn't it be dawning-cougar effect? When you wake up the next morning next to the cougar I guess.

if you think rust is going to save you from all that, then you're definitely not a sniper

​@@blarghblarghRust definitely saves from the most of it, as was already demonstrated by google. But I guess they are not snipers either.

​@blarghblarghA sniper knowing how to not shoot himself with a foot gun does not make the gun any less of a footgun.

@@blarghblargh That is exactly the point. I'm definitely a "non-sniper". Most of all software ever written and ever going to be written are by "non-snipers". Unlike for example civil engineering, software engineering has no way of preventing "non-snipers" from doing "sniper" work. The goal therefore is somehow make sure the code that gets written meets at least certain level of quality. I do agree Rust does not solve all issues. However, if a language makes by default memory errors into compiler errors, that is still a massive win for "non-snipers". Also, how many C coders or C projects you know of which actually use -Werror -Wall -Wextra -pedantic? In my experience, pretty much none. Most C and C++ coders in my experience will just fight you if you enable them. Either because dependencies, too much work to fix or "compiler is wrong".

@@AM-yk5yd Google made stadia and wave. Checkmate, atheists.

Because the author severely overestimates their skill with C… The condescension is incredible…

To be pedantic, In C23 standard "typeof" is an operator.

He doesn't need to, it's from the Linux kernel, ergo gcc extensions and -fno-strict-aliasing. Also, what compiler would you even remotely want to port to, MSVC?

@@paulie-g clang? musl and not glibc?

@@Comeydclang supports all, or nearly all, gcc extensions, and is actually in front in some respects (clang had a guaranteed tail call optimisation func attribute first for example). This has nowt to do with libc. The only valid point in 2024, now that even icc is dead, is proprietary compilers for embedded systems like Keil, but you're going to have much bigger fish to fry when porting to that. Rust is not an alternative to C, it's an alternative to C++ for general purpose development. C use case in the modern era is essentially as a portable assembler that gives you semi-competent insn scheduling for free most of the time. It is perfectly reasonable to use it as such. Being able to compile your code with exotic legacy implementations like MSVC is not a requirement, and if it is one, that's a strong indication you're using the wrong tool for the job.

Still not using Rust.

Heck, even C# a language with a GC has the 'unsafe' feature and has for years too.

More importantly, in Rust only small, specified parts are unsafe, as opposed to the whole thing. Which is easier to audit: twenty lines, or ten thousand?

If you're writing "unsafe" then why use Rust at all?

@@greg77389 Because the vast majority of the codebase isn't unsafe, only the small portions that need it.

​@@greg77389Because in general, it is easier to audit a small line of and make a prove of soundness than to have to audit multiple files. For example, Everytime you make an unsafe block in rust, you will conventionally, have to provide a reason why the unsafe block wouldn't cause UB. (Like writing down that the memory in the pointer in this function are confirmed to always point to a valid address.

My thoughts exactly. One doesn't need to go through the mental gymnastics of evaluating who's the real C programmer. Results speak for themselves and they're damning.

The "no true scotsman" fallacy force is strong in that person.

And, to elaborate, the extra context is there because function pointers do not work as closures, so would have to rely on global objects for any additional context if it wasn't passed in. And you obviously need that context to do anything else than simple in-place mutation.

you pretty much just described how LLMs work

I cannot understand how C, which historically is the reference language that nearly everything else is defined against or must be written to interact with... a language that can be learned in about 20 (or maybe 30) pages from the K&R book (the language, not stdlib etc), is something in which that so many "professionals" cannot write Even basic programs. It's literally about 20-30 pages with examples, reasoning, explanations of the examples to be able to write some seriously useful C programs. But supposedly nobody can use it?

@@infinitelink that's because really it's kind of shit

@@isodoubIet Maybe youre just shit at programming.

@@infinitelink it's because the language really doesn't give you enough abstractions so you resort to all sorts of ceremony and boilerplate. One example is the 'container_of' macro mentioned in the article, all it does is, you give it a pointer to some struct member and it gives you back a pointer of the whole struct. Reading and understanding the macro implementation is quite opaque for a beginner. Zig in contrast just gives you a built-in function to do the same thing called @fieldParentPtr. The way C is written/read today isn't really comparable to what is in that book, because a lot is going to be convention and some of it is quite obscure.

I like the version of C++ thats super bare bones like C, and is super simple yk. I hate memorizing stuff. I like to write my C++ code how I write my Roblox code, since I learnt to code on Roblox lmfao. Abstractions are really retarded sometimes cus they just make certain stuff more complicated than it ever should be. I shouldn't need to put time learning how to do the same thing but in a slightly different way. Everythign in Roblox is so simple and just works. I litterally model all my irl code to work like how it would on Roblox lmfao.

Yeah flipping between languages a lot I find that this is a much safer approach as the not equivalency table is too hard to remember across many languages.

He's right though. I wish I had a dollar for every time I saw a redditor saying "Dunning-Kruger effect" in response to losing an argument.

But if you studied statistics you would know that "Graph! Sniper riffle! Another graph! Most people who say they know DK don't know DK! You thought it was DK! Gottem! It was the mount stupid, stupid, haha,ha, look at me, I'm so smart and we haven't even started talking about C" is something to be impressed! Probably.

I love it. Thanks! Do you know what this topic is called? I would like to read about it.

It's not hard to "give good reasons for C". (1) where there is need for portability, supposed replacements with complex compilers or toolchains (e.g. Rust) don't work--C can be learned in about 20 pages (not a joke), it's that simple. That also means implementing a compiler on a new machine is always reasonable and quick. (2) Where portability is needed, a language *must* have "undefined" behaviors where defining the language would cause it to be machine-specific. (3) Where need for to solve difficult problems in spaces that are unknown: you aren't going to solve an ambiguous world-class problem in Rust if you're fighting to get Rust to work or let you compile: by definition to explore a space you need LOW friction from the tool. Most software projects fail... friction geometrically (at least) increases likelihood of that probable failure. (4) Where need raw control exists--from portability to need to implement your own structures as close to metal as possible... That's before getting into the fact it's an API for machines now, not really a language the way you think, into psychological considerations where at times there is need for COMPACT expression, value in the capability to override anything... That's a tremendous set of considerations where you begin to think through wanting to solve something with software and only C will really do--not even Zig will do (so bounding etc is great until you need that flexibility!). From writing another language to having assurances the language and its tools some modify names behind the scenes...I recently wanted to check out Nim for a project then discovered in horror that besides choices like case insensitivity--aka failing to deal with the world as it is--it then seeks to work around such bad choices by modifying names under the covers!!!!! 🫠 Not acceptable when you need assurances and control. A BIIIIIG reason for C almost never stated is this: simple compilers and simple languages enable you to write sophisticated tooling to aid your efforts. C devs that did the prior reading tend to be able to write their own **** analysis tools in ways nobody else can... many of the supposed shortcomings of C are there for reasons as mentioned above but *due to valid reasons the authors had in considering implementing C & Unit*: I know because they specify many of them in the early books about that things that they wrote. Many supposed faults in C are things people today think were missing "because it's old" that were present already in older langs (PL/1, Pascal, Algol (take your pick)...), and the C authors EXPLAINED WHY THESE HAD TO BE LEFT OUT OF A LANG LIKE C!!!! Your problem isn't that you've "never heard" this it that to convince you but that you apparently never read into the history behind these things.

I did know about the portability of c, I've also heard it's simplicity lauded, and it's consistency over time. I don't know why the phrase "never heard" is in quotation marks. I didn't say that. I was responding to the article specifically and said the arguments were weak. Which they are even if their conclusion happens to be correct. I don't care to take sides between Rust and C. I don't know enough about either language.

I did not at all interpret it as "rewrite everything in rust/zig/go/etc." Secondly taking something as low level as the Linux kernel and taking Rust code from that and treating it like average Rust code is super silly. "The Linux kernel does memory unsafe stuff and operates directly with hardware? Woaah, that's crazy"

@@Hexcede I think that was precisely OP's point - there's a lot of low lvl stuff for which C is simply better(or at least less cumbersome)

@@TsvetanDimitrov1976 Yes and no, but this is a super specific example where unsafe code will obviously be used heavily. You are taking "this code has a lot of unsafe blocks" as "C is unsafe and is therefore better because most of this code is unsafe" but this is a flawed conclusion/assumption, which was part of my point kinda, but also that this example is just bad. Nobody said "no more C, C bad, never use C," the focus is simply on the prioritization of memory safe language. The additional benefits of Rust's memory safety are kind of being ignored too because they still apply to unsafe blocks. Having a lot of unsafe blocks is still safer than being fully unsafe. You are relying on a lot of safe rust code inside the unsafe blocks that uses a lot of memory safe principles and you still get a lot of safety gaurantees. You are able to make some gaurantees that your unsafe code is safer than it might otherwise be, and when it is compartmentalized you are able to much more effectively debug and identify issues, find where bugs may be, etc in addition to being able to then utilize that unsafe code under its promise that it is a safe implementation. Safe Rust doesn't enclose all safe, valid programs, that is what unsafe blocks are for. But it encloses a huge majority of safe programs. And much of your code can rely on code containing unsafe blocks and maintain safety as long as you have made the guarantee that your unsafe block is implemented safely. You have greatly lessened the burden of identifying problems and gauranteeing safety by explicitly demonstrating where issues may be and in doing so you are able to make greater, stronger assertions about the safety of your program even with the use of lots of unsafe blocks.

It's still a linked list though, and if it's all about performance, usually you'll actually just want an array or a tree or a hash-map.

@@Sindrijo True, but that should be obvious. Linked lists are almost never the correct answer, but every once in a while they are what you need. I think the best approach is to always go with the simplest thing (arrays) which is also usually good for performance.

I don't even think a C "grandmaster" could write a perfect C program.

The goal of the code snippt was to show how fundamentally different an ace programmer would code from a base programmer but in an article defending c from its unsafety that is really funny.

Also funny is proposed "solution" of using static variable. if do_stuff uses john as a scratch buffer and sets `age=-25` in the process, it's not issue in "incorrect" example. But with static... In rust John would be const to begin with and ownership would be tracked.

@@leonardschungel2689 The thing that comes to mind is "know your audience" an "acE" (cringe) programmer may be able to write and rapidly understand the code, but if he's the lead of a team of 4 or 5 who are mid or worse, it's actually shows that he's not infact act. Fully agree with prime on the point of making what you are writing deliberate and not being too cute.... even if future you is as smart enough to understand your tricks, is future other members of the team? and if they touch that area of code are they likely to cause issues? If yes then the developer is just enjoying their own farts.

As long as you debug your code I think C is fine. Some things demand speed without it things can go wrong.

@@computernerd8157 C is not objectively fast, you can write Rust code with identical or better performance to perfectly optimized C code, so this argument, although valid in some specific contexts, barely applies. Taken to its logical conclusion, this argument on its own pretty much just leads to hand written assembly being better than C.

C should absolutely be used in medical applications. Imagine getting 50x the dose of X-Rays because the garbage collector kicked in.

@@josephmellor7641C is not the only language without a GC.

@@josephmellor7641 you don't need a garbage collector to be safer than C.

defer is more like a comefrom.

defer will still call the code if you return from the function early. goto will not.

0 *known* defects. A dedicated professional examining the code or the executable with modern tooling, concolic analysis, fuzzing, etc could very likely find an exploitable vulnerability in most reasonably sized software, particularly from that era because of a lack of mitigations and particularly something like a driver.

@@leodlerThat's nonsensical. You don't even know what the driver was for, how would you even know there was an attack vector to begin with?

experience and evidence. You show me a program with no bugs (what the OP is claiming) and I'll show you a unicorn. Good luck.

​@@rameynoodles152#include int main() {std::cout

No classes

He's a giga chad alpha wolf mega sniper who thinks "only bad engineers make bugs" and they cope with "C's just as safe as Rust, you just need to be good at it. It's easy, look, let me just run valgrind, absan, ubsan, clang-tidy, a formatter, and my tests written in a third party test suite." And then they call you back in 30 min because their make script was broken.

No they don't exist, at least not in C xD

hay if he's so good at C, then just use unsafe rust, but he won't because doing that would make obvious how many uncessery risks you are taking to do little anything

The author is fundamentally right - the only problem is the "average doesn't exist" point. They do exist because there's not only extremes. There's people that think they are good in C, and are bad. There are people that think they're good and they're mediocre. And there's people that really are good. Commits != good commits or good code.

@@markogalevski6088 so the point you're making is even bad engineers know bad engineers make bugs? Hmm

This analogy would work it rust was supetset of C

Except thats not even slightly the same thing? Lmao

@@avarise5607 It's a functional superset of C. it's not a literal superset of C. Neither is C++ nor Carbon nor Zig. If you like C, that's fine, I like C too. But don't pretend like Rust doesn't have advantages and disadvantages over it that make it much more desirable for mission critical software, you'd just have your head up your **s.

​@@alfiegordon9013both TS and Rust were created to eliminate certain runtime errors. The similarities are there, you're just being obtuse.

it's all a superset of gates. don't be the um actually guy, comment repliers

I still use intrinsics, even when doing 90% of my stuff in Rust. Sometimes you just need a good extra bit of speed.

I'm with you old man. Nothing wrong with assembler. In fact I think all programmers should have at least some understanding and proficiency in assembler. "Unsafe"? No problem, we are aces right!. In fact I would claim that it is easier to write safe, UB free code in assembler than C++.

Don't tell Google Gemini.

hell yeah@@Heater-v1.0.0

lol@@user-us3hu4jh7j

Honestly, he doesn't seem nearly as smart as he (seems to) thinks he is. Yeah, there are skill issues, but there are also a lot of easy mistakes made even by very good developers that are less probable with even C++, let alone languages with saner defaults. C has some restrictions that bring down the developer experience, and some allowances that improve it, but also introduce safety issues.

See I'd like to use if(!boo) but most of my team struggle with if(boo == False) and couldn't even with the fist option so all it gives me is more work

Yeah, I don't know anyone who doesn't write silly code from time to time. Even the best engineers I know make bugs. And you know what? They usually laugh about it, it happens. And the best thing is, they're also humble enough to know they'll screw up at some point. They put systems in place, unit tests, running the program themselves, canary releases, ... -- dealing with (temporary) skill issues of humans is just natural. In (commercial) aviation, there's two pilots for a reason. Every pilot in a cockpit of a 737 or A320 can start and land the plane on their own. They can make all the fuel calculations, and handle most emergencies. So, why have the 2nd person? To catch skill issues. They have a pilot flying, and pilot monitoring. They have regular checks, and checklists. They have lots of manouvers they'd like to do, that would be more efficient, but that they don't do -- because skill issues. But when it comes to writing code professionally, especially critical kernel-level code, suddenly all the huamns are perfect. And there's a bob with the most perfect skills, that never makes a mistake. Sure, Bob, sure. You never make a mistake.

he already did learn Zig (somewhat)

@@VivekYadav-ds8oz there's always more to learn with zig

I support rust adoption because it makes all the bad-at-coding mentally unwell people who aren't even sure whether they're man or woman migrate away from C.

That's not a good reason.

@@svenyboyyt2304 How long have *you* been programming, building up a massive knowledge and code base, along with methodologies and practices that prevent unstable code, eliminating the need to run to new languages to solve problems brought on due to lack of mindfulness and discipline, huh?

Well of course it's memory safe, it doesn't do anything unsafe. I don't really understand your comment... If you actively tell Rust to leak memory it's going to leak memory. But that's true of literally every language regardless of memory safety. Rust has basically no memory leaks when compared to other languages because you need to use a specific kind of reference that implies the behaviour in the first place, and if you don't use those specific kinds of references (which aren't common in pretty much any code except in specific performance sensitive code and are therefore easy to track down) you're not going to run into memory leaks.

​@@Hexcede Rust has many ways to let you "safely" write leaks you should not be able to do according to their marketing and days worse by the day. C & C++ can also be compiled with flags that refuse to let them compile upon detecting memory leaks... and C being so simple, the compilers really can detect just about every leak! Issue: few people know about our use those flags--likely because fixing them costs companies money. Rust will be no different: users will turn the safety off or learn how to work around it while pretending things are better.

​@@Hexcede "Well of course it's memory safe, it doesn't do anything unsafe." Safe, like a forkbomb ;) The only reason Rusters consider leaks "safe" is because there's nothing in their language that can prevent them, so they moved the goalposts. The leakpocalypse thing was never fixed btw so it's not even safe in their own sense.

so your only issues are entirely cosmetic and easily completely forgotten after using it for a week. sounds pretty good :D

app_window_new (). Globals should be used sparsely, If you need them, hide them behind a function call. (Singelton) I find the simplicity of C very appealing. I can follow calls down the stack and know what is happening. That does not happen with stuff like C++ or Rust. And don't get me started on language specific "package managers"... That should be illegal. It's abhorrent.

Or a namespace

The hierarchical filesystem *is* the namespace... that's what it's for!

@@PixelThornI never understood this. Why is modulename_funcname worse than modulename::funcname?

@@attilatorok5767 because if I'm writing a function in modulename I can type just funcname instead of the whole thing. Lots of problems with how it was implemented in C++, but it's a good idea overall.

the macro perhaps, inlining generally takes care of it nowadays, but the examples do showcase efficiency improvements, and some simplification too

Thats how I feel about React, Angular ect vs Html5 and Css3 and Javascript. All these tools have their place and do certain things better.

The linked list example would be obviated by writing in C++ instead, which is what he _should_ have done, but it's not just overcomplicated for no benefit. It's a generic data structure, which is very useful.

And how many jr segfault C devs think they have become C gurus when they actually are not and have convinced them selves they can write safe code, they also convince each other that they can do it no problemo.

No he/she can't. I never met one and I am 20 years in the business. And those in the business older than me also never met one.

compiles faster. done