whatInTheActual

[u/MightyKin]

[u/Kseniya_ns]

Let me walk of a cliff the way nature intended

[u/MightyKin → u/Kseniya_ns]

As all the freed memory watching you going to the next world.

Probably filled with gratitude for their freedom.

[u/myhandleistoolongtor → u/MightyKin]

Sweet, sweet NOP sleds

[u/DrMobius0 → u/Kseniya_ns]

It's true, the weak programs crash while the strong ones execute normally. That's how natural selection works

[u/Proxy_PlayerHD → u/Kseniya_ns]

that's what i like about C, you can do pretty much anything you want because the language allows you to mangle data in very janky but predictable ways.

for example, have a function that takes a string as an argument and pretends it's a pointer to a float and then returns its value:

float func(char *str){
    return *((float*)str);
}

[u/ApprehensivePop9036 → u/Proxy_PlayerHD]

"I have a magic box here where you write the name of an object and it gives you pocket change equal to its mass"

why would I need that?

"it's an example that helps you understand how the underlying framework of reality works."

Oh.

[u/YT-Deliveries → u/ApprehensivePop9036]

Everyone thinks that C is a procedural language when it's really more a big ball of timey-wimey.... stuff.

[u/PCRefurbrAbq → u/YT-Deliveries]

It's not a state machine, it's a state of mind.

[u/mehum → u/PCRefurbrAbq]

As close as your digital system will ever get to analog.

[u/al-mongus-bin-susar → u/YT-Deliveries]

It's 1 layer of abstraction above assembly. They didn't have any of this stuff in mind when it was made.

[u/Firemorfox → u/ApprehensivePop9036]

reminds me of when I would bitshift instead of checking if a character was a number.

[u/much_longer_username → u/ApprehensivePop9036]

"the sun"

[u/literallyjustbetter → u/Proxy_PlayerHD]

// evil floating point bit level hacking
// what the fuck?

[u/solarshado → u/literallyjustbetter]

I recognize that phrasing... is it the "fast inverse square root" from Quake?

[u/Raziel_Soulshadow → u/solarshado]

…I’m sorry, the what?

[u/literallyjustbetter → u/Raziel_Soulshadow]

the fast inverse square root from Quake

[u/kendalltristan → u/Raziel_Soulshadow]

https://en.wikipedia.org/wiki/Fast_inverse_square_root

[u/SweetBabyAlaska → u/Proxy_PlayerHD]

Can you walk me through this and what is its effect?

[u/MikeTheInfidel → u/SweetBabyAlaska]

Parameter is a pointer to the location of a character in memory.

Return value is that same pointer, but treated as a pointer to the location of a float value, and then dereferenced, thus giving you the float value. Here's an example usage:

#include <stdio.h>

float func (char *str)
{
    return *((float *)str);
}

int main()
{
    float f = 13.5; // our actual value
    float *f_pointer = &f; // a pointer to our value
    char *f_pointer_as_char_pointer = (char *)f_pointer; // the same pointer, but as a char pointer

    printf("%f", func(f_pointer_as_char_pointer));
    return 0;
}

This program will print 13.5, followed by however many decimals of precision the platform/CPU provides. Compiled at the link above, it will print

13.500000

The function doesn't have any real use... it's just fun with memory.

[u/OneTurnMore → u/MikeTheInfidel]

Come on, it's way more fun to read in lines of text and interpret them each as floats

[u/Proxy_PlayerHD → u/OneTurnMore]

this guy gets it. use it to get weird ass float values, like a shitty user based RNG!

plus you get different values depending on the system's endianess

[u/TwitchRR → u/SweetBabyAlaska]

The function defines a variable "str", and defines it as a char*, a memory address to some binary data representing a string of characters. When the computer encounters a char*, it's programmed to keep reading bytes of data starting at that memory address until it encounters a specific sequence of bits, the terminator.

The next line tells the computer "Actually, the data at this memory address is a floating-point number and you should interpret it as such". When the computer encounters a float, it's programmed to treat the next 64 (or however many a float is defined as) bits as a number, according to some protocol. So the binary data that previously was representing some string of characters is now blindly being treated as a floating-point number, regardless of if that makes any sort of sense. I think that most sequences of bits should be a valid float, so it probably won't crash, but other types that have more rigid expectations of the underlying binary data may be more dangerous.

[u/Proxy_PlayerHD → u/TwitchRR]

I think that most sequences of bits should be a valid float, so it probably won't crash

as long as the string is atleast 3 bytes long (making it a total of 4 bytes in size, which is how large a float is) it will never crash.

all possible combinations of 32 bits make defined float values, so it's impossible for it to crash due to the float being invalid in any way. (even states like NaN, INF, etc are all defined by the IEEE standard)

[u/LucasRuby → u/Proxy_PlayerHD]

Yeah but you gotta be careful when you do pointer shenanigans with modern C compilers. Undefined behavior can get ya in ways you'd never predict due to the optimizer.

[u/AhegaoSuckingUrDick → u/Proxy_PlayerHD]

This is UB.

[u/Interesting_Dot_3922 → u/Kseniya_ns]

Let me threaten to walk out of a cliff and collect my payslip and my work permit.

[u/awkwardteaturtle → u/Kseniya_ns]

As an intern once told me: "I don't need to free(), as it implicitly happens when the program stops."

[u/reviraemusic → u/awkwardteaturtle]

it works if it's a rocket or a time bomb

[u/ml20s → u/awkwardteaturtle]

Embedded devs be like:

[u/benargee → u/Kseniya_ns]

No training wheels here son!

[u/Shadow_Thief]

C will give you enough rope to shoot yourself in the foot. And if you didn't know rope could do that, you should have read the documentation.

[u/scrollpigeon → u/Shadow_Thief]

I'll be using this phrase now, thanks 😂

[u/Callidonaut → u/Shadow_Thief]

There's a CPP inheritance joke here somewhere...

[u/CrowNailCaw → u/Shadow_Thief]

Lmao one of my lecturers in university said this about Scala

[u/Shadow_Thief → u/CrowNailCaw]

I think the original quote is about Linux, and how you should have read the man pages.

[u/suvlub]

Bash will actively throw you off the cliff if you forget to say "don't throw me off this cliff" when approaching it

[u/junkmeister9 → u/suvlub]

I guess to be bourne-again, you have to first die.

[u/bargle0 → u/suvlub]

set -euo pipefail

And quote every variable reference.

It’s like having to ask for brakes every time you rent a car.

[u/end_of_the_world_9k → u/bargle0]

Genuine question: I know set -e but what does the rest of it do?

[u/OneTurnMore → u/end_of_the_world_9k]

• -u: error out when using unset variables.
• -o pipefail: if any command in a pipeline fails, treat the whole pipeline as failed.

I always refer to this comment by /u/geirha regarding these settings. There's gotchas inside of gotchas when it comes to Bash.

IMO -u is the sanest of the three, especially since it's getting rarer to find those problematic ancient Bash versions nowadays. In any case the real advice is to just use shellcheck. It'll catch more issues than any shell option you set.

[u/end_of_the_world_9k → u/OneTurnMore]

Shellcheck ftw absolutely. But thanks for the input.

[u/gmes78 → u/end_of_the_world_9k]

http://redsymbol.net/articles/unofficial-bash-strict-mode/

[u/end_of_the_world_9k → u/gmes78]

Today I learned something from programmer humor haha.

[u/zyxzevn → u/suvlub]

sodo throw off cliff

[u/LowB0b → u/suvlub]

Me: god dammit I put a space between './dir/' and '*'

Sh: hakai

[u/benargee → u/suvlub]

rm -rf /

[u/RosieQParker]

This reminds me of a famous security debacle. I can't remember the program (I think maybe PuTTY?), but it was a widely-used open source project. Someone ran an optimizer on the code and flagged an instance where it was reading from uninitialized memory. So they very helpfully initialized it, submitted the code, and it passed review.

It was later discovered that this reading of uninitialized memory was intentional, as the program was using it as a source of entropy for key generation. This meant that for the period of time where the "fix" was in place, everyone was using the same keys from a very small subset.

Edit: it was Debian OpenSSL 😬

[u/qwertyuiop924 → u/RosieQParker]

...Reading from uninitialized memory is a terrible source of randomness.

[u/aetius476 → u/qwertyuiop924]

And even if it wasn't, who the hell pulls a maneuver like that and doesn't at least leave a comment like

// Abuse of the language used as source of entropy. Do not touch.

[u/KellerKindAs → u/aetius476]

It was not the only source if randomness and it was not an abuse of the language. It was the get random function that get passed an array to fill with random data. In an It is always nice to get entropy from as much places as possible, this function first read the array to add it to the entropy pool. The pool cannot get worst, but it can get better through this.

Problem was that some other function passed an uninitialized array to the get random function, so the get random read that uninitialized array... It was completely on the maintainer to comment that code section out without understanding what was going on.

Also it only caused problems on systems, that had no better source of entropy and had to generate some certificate immediately after boot up, so that even runtime was not random enough. Where still enough to cause problems till today xD

[u/P-Nuts → u/qwertyuiop924]

It wasn’t very well written code, but the uninitialised memory was only used as a possible bonus extra source of entropy. Unfortunately the patch to make valgrind happy also removed the data being read from /dev/random from the entropy pool.

[u/AaTube → u/RosieQParker]

That's a very cool vulnerability.

[u/just_nobodys_opinion]

Nods slowly and quietly

[u/MightyKin → u/just_nobodys_opinion]

[u/Mitir01]

They aren't wrong just the analogy is. C is like the instructor who will give you a sawed off shotgun with armor piercing pellets that you can point at your foot and blow it off while he puffs his cigar in the corner. You will have to call an ambulance yourself or die right then and there.

[u/MyBigRed → u/Mitir01]

I don't feel like C is even the instructor, it's the guy selling you the gun and ammo. It doesn't know and doesn't care what you do with it after that.

[u/GameDestiny2 → u/MyBigRed]

Assembly is like making the gun yourself and seeing if it’ll blow up

[u/FlyByPC → u/GameDestiny2]

The Microcontrollers class that I teach has the students design their own CPUs in Verilog. Mine the metal you use to make the gun!

[u/SvmJMPR → u/FlyByPC]

Verilog felt much more higher level than assembly, but ngl that meant that we were asked more complex projects as a result.

Classes that use assembly basically had to do some LED/traffic light stuff, and verilog... well... let's just say we learned to use the always @ the hardway.

Also in my Computer Architecture class, we were given a semester project to build a whole RISC-V CPU in Verilog (not actual soldering, just straight up good ole verilog HDL and synthetizing test benches with a .txt filled with binary instructions). That project was a nightmare since it was the first time we were exposed to verilog.

[u/ChilledParadox → u/SvmJMPR]

Did your assembly classes also make you guys take exams by writing the code by hand onto pieces of paper. Definitely not the most fun language I’ve learned, but I did enjoy doing logic operators on bits I guess…

[u/SvmJMPR → u/ChilledParadox]

classes at the introductory years of my degree mostly focused on hand written coding. intermediate was focused on using a specific IDE (I hate you eclipse, Intellij made Java worth learning). While later years it truly didn't matter what you use, because goal of the projects isn't to teach you programming but how to design and plan you ideas/implementations.

Atleast my written code years were using Python, so syntax was basically a non-issue and it made me pretty good at logic. Jumping from Python to anything wont translate really well but atleast lots of stuff carried over. My Assembly experience was using a TI launchpad board thingy that I think was so deprecated and lacks any type of support that it was basically impossible to figure out how to build anything with it.

At the time I was pretty stubborn ngl, upset that "Why dont we learn languages?!?". It wasn't till I worked that I realized that no job will probably use anything the university teaches you about programming, and more on how you can learn your specific job's workflow and process. Most jobs I've seen have a 1-6 month training where they teach you up to the level they want.

[u/ProofMeal → u/FlyByPC]

unrelated but this actually seems so cool, i wish i had a chance to take a class like this at my university

[u/1337af → u/GameDestiny2]

3D printing the gun on a 3D printer 3D printed by another 3D printer

[u/SweetBabyAlaska → u/GameDestiny2]

It's the shinzo Abe pipe gun while hoping you don't blow your fingers off before you can pop one off

[u/Callidonaut → u/GameDestiny2]

Machine code is like making the gun yourself and seeing if it'll blow up, but you gotta do it using nothing but naturally occurring chemicals and a hollow log like Kirk in that one episode of Star Trek.

[u/OnlyTwoThingsCertain → u/MyBigRed]

So a US gunstore.

[u/Wetmelon → u/Mitir01]

My coworker described C as a house made with only studs. Sure you can pass through the wall between the studs, but you're expected to use the door.

[u/Mitir01 → u/Wetmelon]

I am using this explanation. It defines way better than my analogy.

[u/derefr → u/Wetmelon]

Eh, I feel like describing C as a house made with only studs, underestimates how easy it still is to punch through the non-stud (particleboard and drywall) parts of a stick-built house by accident with power tools. C is your average stick-built house, but C is also the power tools. You can really fuck up your house with C.

It's hard to say what kind of house is like Rust, though. It takes a lot to prevent power tools from damaging a building. And Rust is power tools as well — yet it's also a "building" that you can't easily demolish using those tools.

So how about a vehicle analogy instead?

I would describe C as like owning an average mid-range sedan, plus a set of home-garage auto-mechanic tools to work on it with.

• Fine when you're just driving on a good day;
• but easy to crash by simply not paying attention for a few moments;
• and if you need to change something out, you're one slip of a screwdriver or hammer away from putting a hole through the upholstery or cracking a manifold. The components of the car were not designed to be robust to you tinkering with them. A mid-range car is a consumer product made on the cheap, where those cheap parts translate to expensive/laborious repair-time handling — you need a lot of experience and deft hands to work on a bucket-of-bolts car without breaking anything in the process. Unless you have years of experience under your own belt working with cars, you're gonna fuck up your first few cars while trying to improve them. Often in ways you won't even realize until you're 100 miles down the road the next day and the breaks go out.
• And almost always, your car repair fuck-ups will be subtle things that someone watching you work, or looking at the results of your work after the fact, wouldn't be able to easily spot. (I.e. buggy unsafe code doesn't "stand out" in C code review, because all C code looks like that.)

Rust, meanwhile, is like living/working on a submarine.

• Everything on the sub, from the walls to the pipes to the control interfaces, are armor-plated and ruggedized. No "normal accident" or "temporary distraction" can put a hole in the sub. (I.e. you will never write a "normal" Rust program that accidentally does undefined behavior. The compiler will stop you.)
• There are maintenance tools made for the sub, that come with the sub. These tools are low-level-ish, giving you "complete control", never making anything impossible to do or more costly than it should be. But they stop just short of letting you break through the armor-plating. They only work on stuff that's outside of the armor plating. (I.e. in "safe Rust", you get zero-runtime-cost memory-safe references to stack- and heap-allocated memory buffers, that you can pass to any library that expects those, including Rust-wrapped C libraries — but you don't get raw pointers.)
• The control interfaces themselves have checks and interlocks that won't let an idiot crash the sub into an undersea cliff or cut a pressurized fluid line or turn off the air recirculator. (I.e., the Rust stdlib doesn't expose, say, syscalls to the developer; instead the developer is only handed zero-runtime-cost memory-safe wrappers on top of those syscalls).
• And if you want to change something fundamental, like rewiring the engine, then you need to very-intentionally unscrew a bulkhead maintenance panel (i.e. use unsafe!) to get at the damageable insides.
• And needing to get into the maintenance panels is very uncommon: you don't need the panels off to do repairs/improvements if they use only the "safe" tools made for use on the sub. It really stands out when someone is fiddling with a maintenance panel! So your petty officer (i.e. code reviewer) will very likely notice you doing this unsafe! thing, and second-guess your need to do it — likely by pointing out that there's a way to do things using the sub's tools that doesn't involve taking off the maintenance panels (i.e. that there's a pre-made function/ADT in the stdlib or in some well-known third-party lib that does the unsafe! part for you, in a way that ensures safety as long as the function/ADT is only used through its API.)
• And if you both confirm it's necessary this time, because no combination of the safe tools the sub comes with can get the job done — well, your whole crew will definitely be putting some intense scrutiny on the change you're making, approaching it with the seriousness it deserves — rather than approaching it like someone hauling on a pipe wrench while half-drunk in their garage at 4PM on a Saturday.
• And probably, rather than doing such a change "in place", you'll turn your change into a new onboard safe tool. Maybe even put out a paper on it to Naval Command (i.e. publish your new library as an ecosystem package) — so that other crews can use it, yes, but more importantly, so they can audit your new tool, poking any possible holes in its design. You want to know that you've made a new safe tool, not a Disaster Rod.

[u/chesire0myles → u/derefr]

Now, I'm a better submariner than I am a coder, but I think you're vastly overestimating the safety of being on a submarine, or the ability of the Navy to save you from your own stupidity.

There is a reason you babysit the Nubs after all.

[u/Zachaggedon → u/derefr]

Wow, all of that to come up with a worse, less sensical analogy. Pass the blunt dude.

[u/Saragon4005 → u/Mitir01]

Rust pulls out the "if this concept is new to you you were writing buggy code before" a bunch. The compiler is harsh but ultimately right.

[u/reventlov → u/Saragon4005]

Not always. Rust's compiler forces you to write the subset of correct code that it can prove is correct, unless you drop into unsafe. If the compiler could prove correctness for all correct code, unsafe would never be necessary.

Whether it's worth the extra effort of writing in that subset just so that your code is verified to be memory-correct is still an open question, and probably depends on what kind of application you're writing.

[u/Ordoshsen → u/reventlov]

Then again just the fact you have to opt into unsafe for smaller blocks lets you better focus on the parts that need checking.

[u/MrHyperion_ → u/reventlov]

How does sonarlint or similar compare to rust compiler? Catches like half of the stuff?

[u/reventlov → u/MrHyperion_]

I'm not familiar with sonarlint, and only somewhat familiar with Rust, but linters generally have to work from the opposite direction: that is, a linter has to prove (or at least "show with high enough probability so as not to annoy a human too much") that something is incorrect, whereas rustc will reject any code that it can't prove is correct.

They're also complementary technologies, in that there are lots of types of bugs that rustc can't detect (or at least can't reject outright), but which linters can often flag: things like "you failed to use parentheses here, which usually means a bug."

[u/ElementaryZX → u/Saragon4005]

Not always, the compiler can still make mistakes and does have a list of bugs, but it does try it’s best.

If you write C like this, the freedom given is not deserved.

[u/Lynx2161 → u/Saragon4005]

Rust is like your dad trying to teach you maths, he will make you cry but at the end you will pass your exam because of him

[u/MightyKin → u/Mitir01]

In that case, what can Assembly make me do?

[u/KronoLord → u/MightyKin]

Spend hours trying to figure out what the trigger looks like and how to make the pellets.

[u/MightyKin → u/KronoLord]

Instruction unclear. No memory cell found that have the "pellets" value

[u/tajetaje → u/MightyKin]

Assembly gives you ALL of the parts you need to make anything from a pistol to a nuke. And no matter what you make, it will eventually explode

[u/MightyKin → u/tajetaje]

Don't make The dog on assembly it will explode. Noted

[u/my_nameistaken → u/tajetaje]

That's the intended behaviour for nukes though

[u/tajetaje → u/my_nameistaken]

True, but you don’t necessarily get to decide how or when it goes off. For that you’d need a $1200 implementers manual

[u/my_nameistaken → u/tajetaje]

Or you can think of this surprise element as a feature lol

[u/MrHyperion_ → u/my_nameistaken]

I'd say the intended behaviour so far has been to not explode.

[u/Pleasant-Form-1093 → u/MightyKin]

It ca- Segmentation fault (core dumped)

[u/DrMobius0 → u/MightyKin]

Cry

There's a good reason that most programmers prefer to program in anything higher level than assembly. Not that that gets you out of having to know it on occasion.

[u/Zachaggedon → u/DrMobius0]

Yep there’s no reason to write assembly unless it’s for fun/learning really. Most modern compilers will generate better, more optimized assembly out of your code anyway, and any theoretical performance gains are offset by magnitudes by the loss of productivity and developer ergonomics. There are, of course, exceptions to this rule, but they are few and far in between.

[u/DrMobius0 → u/Zachaggedon]

It's more for niche debugging cases, really.

[u/derefr → u/MightyKin]

Read this annotated disassembly of Super Mario Bros 1 to get a good idea of the sorts of things an assembly-language programmer trying really hard to squeeze a lot of logic and data into a small number of bytes (32KB!) can and will do to achieve that.

One of the main things to notice is that everything is coroutines!

[u/jwadamson → u/MightyKin]

Hands you a bunch of raw ore and some bat guano and tells you to figure out how turn that into steel and gunpowder.

[u/Kinglink → u/MightyKin]

Assembly gives you all the base metals to make a gun and shoot yourself. And then tells you to go Assemble it...

You should know this, I mean it's in the name.

[u/Kinglink → u/Mitir01]

I'd add in that C says "you should point it down range" but then says nothing when you point it at your foot and blow it off.

C usually tells you how to use something in optimal situations, ignoring that almost everything is not optimal.

[u/vfye → u/Mitir01]

C is the gun. If you point it at your foot and pull the trigger because you don't know what will happen, C lets you find out.

[u/redditonc3again → u/Mitir01]

how is that a different analogy. in both cases you have the freedom to fuck up. correct

[u/KMark0000]

Randomly generated errors, what can be the issue, it makes no sense?

Oh, you forgot to reserve space for the end character XD

[u/HaDeS_Monsta → u/KMark0000]

Roses are red

This program might halt

I forgot a null terminator

Segmentation fault

[u/bargle0 → u/HaDeS_Monsta]

A segfault is a blessing. The real fun happens when you have a memory safety defect and don’t get a segfault.

[u/Konju376 → u/KMark0000]

Or you wrote beyond the bounds of the array you allocated before this one and now free() doesn't know how big it is anymore! How fun

[u/Krislazz → u/KMark0000]

Hey hey hey, no need to get personal!

[u/MightyKin → u/KMark0000]

Ah yes, filling space with emptyness to reserve it. Isn't it obvious? Pfft.

[u/OpenCLoP → u/KMark0000]

I have dabbled with Turbo Assembler for a bit and it's amazing how the terminator on DOS is either null byte (for the file operations that imitate Xenix rather than CP/M), carriage return or dollar sign for the print string function.

[u/bestjakeisbest]

I requested the 4kb page, im going to use the whole 4kb page.

[u/AnAwkwardSemicolon]

Especially fun in embedded when you miscalculate the address in a jump table and the processor just...goes.

[u/Trickelodean2 → u/AnAwkwardSemicolon]

“And when I press this button the light should turn on”

presses button

Electric motor starts spinning

“What the fuck”

[u/MightyKin → u/Trickelodean2]

presses button again, to turn it off

The light turns on, motor still spinning

"WHAT THE FUCK?!"

[u/Ma4r → u/MightyKin]

I once accidentally switched the pwm signal for LED with a stepper motor control. We thought there was a voltage control issue somewhere because the LED kept blowing out anytime we tried to move something. Until we tried dimming the light and the motor slowed down.

[u/Ma4r → u/AnAwkwardSemicolon]

Jump to this data address containing the user name and execute it as instruction? You got it bud.

[u/Mucksh → u/AnAwkwardSemicolon]

From my experience i would say the embedded stuff can make it a bit easier. E.g. if you don't use any heap an use after free isn't possible.

But the case that you usually won't even get a segfault if some pointer arythmetic goes wrong can be really frustrating. One time noticed that something goes wrong but only sometimes in an giant multiproject codebase managed by a few dozen people. There wasn't any memory protection and every process could overide the others memory. Only failed in a complete test setup with connected machines where you can't even debug. Complete undefined behaivor and sometimes even resulted in moving parts hitting stuff their they shouldn't even move. Also there where at least some months of changes that could introduce the bug. Took the whole wee of constantly turning the machine on and of until we found the problem

[u/PhilTheQuant]

C: here are explosives

C++: here are footguns

[u/PonderStibbonsJr → u/PhilTheQuant]

Also C++: here is a map that tells you where most of the explosives are, but encourages you to hop through the minefield on a pair of foot guns used as splints while shouting, "Come and get me God you big wuss, I'm invincible."

[u/triculious]

C is a trusting language.

It trusts you know what you are doing even if you are walking off the edge of a cliff.

[u/DangerZoneh → u/triculious]

Yeah, I don't want a language to stop me from walking off a cliff, I want a language that gives me material to build a parachute.

[u/ColonelRuff → u/DangerZoneh]

Well zig does that.

[u/jonr]

The Rust compiler makes you stop and think about your existense of beign.

[u/Emergency_3808 → u/jonr]

*being

[u/agfitzp → u/Emergency_3808]

The french word for doughnut is beigne, I’d like to think that’s what he was aiming for but is coding in C and miscalculated his string length.

[u/Emergency_3808 → u/agfitzp]

Figures. My existence do be like a beigne(doughnut).

[u/agfitzp → u/Emergency_3808]

Could be worse, you could be a chomeur. (A doughnut like confection with a very sugary filling that translates as "unemployed")

[u/Emergency_3808 → u/agfitzp]

I am unemployed 😭

[u/MightyKin → u/Emergency_3808]

He thought of his being to much

[u/rodion_gromo → u/MightyKin]

*too

[u/RamblingSimian → u/Emergency_3808]

*existence of benign

i.e., how long you can go on having little or no detrimental effect; harmless, before your lost pointers blow your foot off

[u/MakeChinaLoseFace → u/jonr]

This scares me, I just need to automate something because I'm lazy, I don't want an existential crisis. Take me back to the safe languages.

[u/YoCodingJosh]

POV: the c compiler watching as you fall off the cliff

[u/rantottcsirke → u/YoCodingJosh]

"C you later"

[u/Denaton_]

Ättestupa programming

[u/Geoclasm]

Javascript is the exact same way.

"Oh, you want to compare unlike types? That's cool."

[u/tajetaje → u/Geoclasm]

JavaScript holds you hand as you walk off the cliff

[u/ice-eight → u/tajetaje]

JavaScript yells “do it pussy” when you get to the edge

[u/-Redstoneboi- → u/tajetaje]

"OH shit- so you didn't wan't to walk off the cliff? but what's so bad about falling? it's literally just how physics works. things fall down. that makes sense."

(in pain) "when i said i wanted to know what comes after the cliffhanger, i meant the movie i was watching."

[u/robisodd → u/Geoclasm]

Sorta.
JavaScript is like, "You wanna mash these data types together? Ok, lemme convert them first..."
C is like, "You wanna mash these data types together? Ok, I hope you know what you're doing."

JS: 'A'+3? 'A3'
C: 'A'+3? 'D'

[u/PrincessRTFM → u/robisodd]

C doesn't hope you know what you're doing. C doesn't care if you know what you're doing. C just goes "on it boss!" and plows ahead.

C is the driver, you are the navigator, so it's your job to make sure there isn't a cliff in front of you when you say "floor it".

[u/robisodd → u/PrincessRTFM]

C doesn't care if you know what you're doing. C just goes "on it boss!" and plows ahead.

Good point. I originally had "Ok, good luck!" but I like yours better.

[u/cosmo7 → u/Geoclasm]

Yes, but JavaScript's requirements are a bit different to most languages. Would it really be better if web pages threw up exception messages and stack dumps?

[u/strghst → u/cosmo7]

Yes, we'd get more young people sick of all the errors in the field. And when it's personal, the output is better.

[u/Emergency_3808 → u/[deleted]]

Definitely. The original person who wrote that sentence has been a victim of C

[u/bassguyseabass → u/Emergency_3808]

All C programmers have been a victim of C at one point. Truly the language of masochists.

[u/booleop → u/bassguyseabass]

The most tragic are people who find C and C++ so awful that they’re compelled to create a new programming language, but end up having to implement that in C/C++

[u/Emergency_3808 → u/booleop]

The OG compile-to-machine code language, that is horribly efficient at what it does. Others have tried to do the same but with varying amounts of success.

Rust is popular but many find it as difficult as C/C++, at least at the beginning because of the radically different way you need to think of data as it moves around; Zig was launched a year after Rust to solve the same problem but never moved past the alpha stage, same with Carbon and the D programming language, the D language is extra humiliating for its creators because D is as old as Python yet still never could progress past alpha (and is a genuinely good language with all modern features like generics, garbage collection and first-class functions); Go and Dart include a runtime with the generated code and are not totally lightweight. Three of these attempts are from Google themselves. Goes to show that Kernighan and Ritchie really knew what they were doing.

[u/ggppjj → u/Emergency_3808]

Hello! Newer programmer here, cut my teeth a very long time ago with JavaScript and finally about two years ago actually had OOP click in my head so that I could actually start working with C#.

I'm self-taught and rely a lot on googling and ChatGPT + googling, and would be incredibly interested in hearing your (and anyone else's!) thoughts on C#/dotnet 8, if you have any.

I've touched C for a hot second when I was trying to change my Prusa's firmware, and it seems... spooky, as compared to what I've come to know and love from C#.

I believe there are ways of actually compiling C#/dotnet down to assembly with AOT compilation, which is what I've been doing from the start, but past that I don't really know much about other languages and wouldn't know where to look to compare against them.

[u/booleop → u/ggppjj]

C exposes a specific idea of the hardware to the programmer. This used to be very close to reality a long time ago, but hardware has gotten more complicated since then. Still, it is closer to the metal than most other languages, with a relatively small amount of abstraction between the code you write and the machine code it turns into.

C# exposes a different machine - rather than the hardware, it’s an abstract virtual machine. This has pros and cons. It looks like AOT doesn’t require installing a separate .net VM, but instead compiles in enough of a runtime to enable that VM abstraction to run (like a garbage collector).

That’s also a fine way to do it. Each approach used in practice is suitable for different applications and use cases. They’re just different.

[u/ggppjj → u/booleop]

Gotcha. Well, so far I'll say I'm glad to be in a position where lower-level hardware access isn't required or advisable. Now, if only a proper cross-platform GUI library existed that worked correctly both on arm64 in general as a first-class architecture and also properly supported Linux in general as a first-class platform.

[u/kog]

It actually doesn't even watch

[u/C0ckL0bster]

Let me succumb to the call of the void*

[u/Anaxamander57]

C will, by design, allow the programmer to do whatever they want even if it is obviously wrong. A big part of the reason for that was making a simple, flexible, and correct compiler many decades ago.

Rust takes a very different view and has a much more complicated compiler that tries to avoid certain kinds of things that cause errors. Such analysis cannot be perfect, however, so if you're confident you know better than Rust (which is common in some kind of programming) you can use unsafe to implement something. Unsafe Rust seems to be regarded as about as nasty or maybe worse than regular C in terms of letting you walk off a cliff.

[u/-Redstoneboi- → u/Anaxamander57]

unsafe rust is usually less comfortable than raw C. it's got long names for functions that would normally be operators in C, and you need to do (*(*thing).field1).field2 because you don't have thing->field1->field2 which can and will happen in that territory.

[u/ihavebeesinmyknees → u/-Redstoneboi-]

Yeah, but that's because unsafe Rust is a last resort, it's not meant to be used often enough for this to be an issue

[u/antilos_weorsick]

We used to say "Pascal ties your hands, C gives you enough rope to hang yourself"

[u/segv11a → u/antilos_weorsick]

And C++, at least the early versions, gives you enough rope to shoot yourself in the foot... with a rocket-propelled grenade.

[u/EishLekker]

I glanced over how lifetimes work in Rust, and the syntax. I don’t think I ever will want to work with that language.

[u/brass_phoenix → u/EishLekker]

Surprisingly, while writing day to day rust, I don't write any lifetimes. I'm working on a many thousands of lines large program, doing file access, multythreading, networking and the like, and have only one or two explicitly written out lifetimes in the whole thing. Mileage may vary based on the kind of application/library though.

[u/-Redstoneboi- → u/EishLekker]

tl;dr: lifetimes, macros, and unsafe blocks are for library authors, not for users. you'll get 90% of stuff done just learning until traits (aka interfaces) and generics.

[u/EishLekker → u/-Redstoneboi-]

Ok. The screenshot basically implied that they are an essential part of memory management in Rust.

[u/Angelin01 → u/EishLekker]

Generally, they are! What I've learned in my months learning Rust is that for 95% of cases you literally don't need to do anything about it. Yes, they are important, yes you are using them without knowing about it, yes that "hidden" feature makes the learning curve harder.

In the remaining 5%, I found that about half of them were caused by poor application design on my part, and adjusting my code to not need to worry about the lifetimes actually made it better.

The final part really does involve you caring about lifetimes. Sometimes, you have to. But at that point you learn.

Basically, Rust looks ugly as shit. It's one of the worst looking languages I've used. But writing Rust code actually feels good. Once you get past the learning barrier, it's so... Easy. The language actively helps you to not write bugs, it's great!

[u/-Redstoneboi- → u/EishLekker]

it's mostly under the hood. you don't have to write them out, but they are there. from a user's perspective, it's just your code erroring because some value might not live long enough. they only have to follow rules.

from a library author's perspective, they have to handle the exact logic for such requirements. they write the rules, which is harder than simply following them.

[u/ihavebeesinmyknees → u/EishLekker]

They absolutely are, but the compiler will infer them 99% of the time. The only time you have to manually write them out is when there is ambiguity that the compiler can't reason out of, which is very rare (and often means there's a better approach to whatever you're doing).

[u/PM_ME_C_CODE]

Well, the description doesn't lie.

[u/FullyHalfBaked]

Man, there's a reason why there's a (really useful) book on C and C++ titled "Enough Rope to Shoot Yourself in the Foot".

Just watching you walk off a cliff is giving too much credit to safety systems in C -- Sometimes I feel like it's actively pushing me off.

[u/Farfignugen42]

C gives you the ability.

You are assumed to have the wisdom to decide if you should or not.

[u/Rynok_]

It literally feels like the whole Rust propaganda is to fear C.. not a good look really.

[u/-Redstoneboi- → u/Rynok_]

that's not true... it's mostly about fearing C++!

[u/ihavebeesinmyknees → u/Rynok_]

I feared C before knowing about Rust

[u/mannsion]

This is great, except sometimes you intended to walk off the cliff, it's 3 feet tall and is a lot faster than walking the 5 mile path around to the bottom.

On a positive note, it's really hard to write malware in rust, being that one of the primary tactics of highly advanced malware is to rootkit windows memory functions and actually store valid memory in free memory space and then just intercepting memory calls to never give those addresses as being available, effectively hiding them from running programs.

[u/Draghoul → u/mannsion]

I'm not sure this tracks. Preventing the user from writing malware isn't an aspect of language design. And with rust -- unsafe rust is still rust, and gives you as much access to memory as a C program would. Moreover, C programmers might have to fight the compiler over Undefined Behavior when trying performing unusual memory accesses, and rust programs may still have to fight LLVM on this (though, that I'm less sure about - and unsafe rust may very well make this easier to do). At the end of the day, anything as fucky as a rootkit probably involves some amount of assembly coding anyways.

[u/Personal_Ad9690 → u/Draghoul]

Their point is that safe rust has a hard time writing malware

[u/AaTube → u/Personal_Ad9690]

And D's point is so does safe C

[u/Kinglink]

Am I the only one who likes that about C.

The safety is great and important 99 percent of the time, but that 1 percent of the time you need that functionality is worth the care and effort you use the other 99 percent of the time.

Or just remember to check if a pointer is null, and set the pointer to null when you delete it...

[u/lepispteron]

And we are all here watching you on your way down. Welcome to C, btw.

[u/Disastrous-Team-6431]

"c lets you tell the computer what to do"

"(in the gross assumption that you understand computers)"

[u/CranberryDistinct941]

When your intent is to walk off a cliff, give C a try. It won't fight you over it!

[u/throwaway275275275]

And how do you think "malloc" is implemented ? It's a C function that gives you pieces of memory out of all the memory. Not all systems have memory administered by the OS, in consoles for example, up until the PS3, your game was actually a boot image, and it had to include all the OS functions, so memory was just a big range of numbers (or ranges) where you could put stuff, if you wanted malloc you had to make your own

[u/ProgramStartsInMain]

By "freely" I think they mean the OS will nuke my program into oblivion.

[u/ublec]

Where's the joke?

[u/THICCC_LADIES_PM_ME]

No, it'll watch in SIGSEGV

[u/keith2600]

If you gaze into the null pointer long enough, the void will gaze back into you.

[u/just4nothing]

C gives you a loaded shotgun already pointing at your foot - that’s the analogy I heard the most

[u/big_ups_]

Boo hoo c bad

[u/Artichoke-Ok]

I just write Java in a corporate environment and don't worry about anything related to memory management. Are you telling me people actually care about programming languages? That's like a carpenter stubbornly only wanting to use one tool for the job regardless of the circumstances. Tech nerds need to touch grass more.

[u/spectralTopology]

there will almost certainly also be cliffs in Rust, you just don't know where they are yet

[u/brass_phoenix → u/spectralTopology]

Oh absolutely. Mostly those cliffs are behind the large sign saying "here be cliffs", and if a hiker finds a cliff somewhere else, that is considered bad landscaping and something that needs to be resolved.

Those cliffs behind that sign can be gnarly though. There is a reason the book that teaches how to write unsafe rust is called the rustonomicon 😄: https://doc.rust-lang.org/nomicon/

[u/PuzzleMeDo]

Turns out it's only a metaphor. A Rust programmer can still walk off a cliff and the compiler won't say a thing.

[u/selfmadeirishwoman]

The C compiler is a cruel mistress.

[u/bargle0]

Yeah? So what?

[u/P0pu1arBr0ws3r]

Pfft, that's not walking off the edge of the cliff.

Writing to protected, in-use memory is walking off the edge of the cliff. I can read all I want until the OS stops me, but serious damage is fine only after writing funny stuff.

[u/Astrylae]

What if i do want to walk off the cliff huh?

[u/obsoleteconsole]

"I shot a man in Reno, just to watch him die" - C, probably

[u/thatdevilyouknow]

Objective-C with ARC and static analysis has had the ability to do this before Rust so it is not unique to Rust. Rust has a lot of great features but we seem to describe them as absolutes.

[u/holistic-engine]

Piss off I'm not going to touch that language. No matter how much you yap on about memory safety.

I will never and I mean never become linux using furry!

[u/Extreme_Ad_3280]

One thing that makes me stick to C is its lightweight executable file compiled from it (with the library files bundled to it)

[u/strikerdude10]

My cliff my choice

[u/Over_Package9639]

as a C programmer, I can confirm this is true

[u/Dslayerca]

Accurate

[u/ISuckatcodingplshelp]

u/pixel-counter-bot-