Don’t forget to check needrestart or similar afterwards if you have no idea what has happened.

300€ is already a lot people won’t be willing to pay for just one part of a computer.

You may. You seem to not have seen the potatoes people are using. ;)

Skill issue. /j

Shouldn’t it be “KopenSuse”?

I use it as a format for, e.g., config files or for serializing data in a human readable format. Mainly from C++, sometimes from Python or C#.

Never in these years did I stumble over stringify.

‘/j’ marks a joke

I have worked with JSON very often and do not know, what ‘Stringify’ is. Reading it for the first time. Does it… convert anything to strings?

Looked it up:

The JSON.stringify() Method

The JSON.stringify() method converts a JavaScript value into JSON text.

https://www.w3schools.com/js/js_json_stringify.asp

Okay JavaScript. Never worked with JS before.

Also, didn’t knew web devs are considered ‘software engineers’ now. /j

Decades worth of windoofs hate. Finally did the full switch a few months ago. I have been using windoofs for gaming only anyway and professionally I already had plenty of Linux experience.

Linux isn’t great either though and can be a real pain in the ass. Recently had to fix few lines of code in the kernel, because I had no audio. But the fact that one can do it in principle is already a huge win over windoofs. And although some games stubbornly won’t run (stable), a lot do without having to tinker much, thanks to Wine, Proton, and a couple of startup parameters.

Professionally I mainly use Ubuntu, for gaming I did so at first as well but switched to CachyOS recently.

Tesla? Legendary? For trapping people and burning them alive? Already done multiple times throughout history.

People should stop being condescending at all and regardless what it’s about.

That is so ridiculously accurate. And sad. And infuriating. And then funny again because I am reuglarly going mad with those fucking drivers since I have to work with them on Linux professionally. I hate it. It is funny and tragic. Just like life.

What always triggers feelings of cosmic horror is the question: “Whom is this reported to?”

Contributing is such a wonderful way to give back to the community. And isn’t it heartwarming to know that a contribution you have made, regardless how small, is then being integrated into something that is used by dozens, hundreds, maybe even thousands of people?

That’s a little way to leave a mark on this planet, and possibly improve the life of people.

but enough for that answer to be valid

Highly arguable. Especially without specifications on the lamp. It could be a rather dim and small one. Then, you either need special equipment or supersenses.

Here you can test how identifiable you are:

https://coveryourtracks.eff.org/

https://amiunique.org/

gnew?

The more experience I gain over the years, the more this feels relatable. I had to pull myself together to keep my comments regarding kaputt Nvidia APIs civil in my code and commit messages.

Ah Nvidia. Always a fucking PITA (not the bread kind). I wonder how they have managed to become the most valuable chip manufacturer worldwide.

Good question! I have read a bit more about it and this does indeed heavily depend on the respective compiler implementation. Depending on the compiler, it may prefer default if-else ladders for few cases. For more, dense cases, LUTs may play a larger role. For less dense cases binary search might be chosen.

I inspected the generated assembler code of your (slightly extended) example via https://godbolt.org/

The code I used:

void check_uv();
void check_holograph();
void check_stripe();
void check_watermark();

void switch_test(int banknoteValue) {

    switch (banknoteValue) {
        case 5000:
            check_uv();
            check_holograph();
        case 2000:
            check_stripe();
        case 1000:
            check_watermark();
    }

}

Using x86-64 gcc 15.2 this leads to a couple of cmp followed by je instructions, so “compare” and “jump to label if equal” which basically is a typical if-else ladder. I get the same for x64 msvc v19.43.
Changing the cases to 1, 2 and 3 instead of 5000, 2000 and 1000 does not change the outcome.

Increasing to 23 different but incrementally increasing cases (cases 1 to 23) does not change the outcome as well for gcc. But here msvc has introduced a performance optimization: it decreased the input value by one to get a range of 0 to 22 and then created a jump table, so a LUT with execution addresses. (I am not going to detail the assembler commands logic here, but you can use the C++ code below and take a look yourself. :) )

So even in this simple example we can already see how different compilers may implement switch cases differently depending on its structure. Even though gcc chose the apparently less efficient solution here, usually one may trust on the compiler choosing the most efficient switch implementation. ;)

As far as I know, we would not even get the chance of similar optimizations if choosing if-else ladders directly instead of a switch-case structure. It would be interesting to put this to a test though and see whether some compilers translate if-else ladders equivalently with the performance benefits that can currently come with switch structures.

The inflated code:

void check_uv();
void check_holograph();
void check_stripe();
void check_watermark();

void switch_test(int banknoteValue) {

    switch (banknoteValue) {
        case 1:
            check_uv();
            check_holograph();
        case 2:
            check_stripe();
        case 3:
            check_watermark();
        case 4:
            check_watermark();
        case 5:
            check_watermark();
        case 6:
            check_watermark();
        case 7:
            check_watermark();
        case 8:
            check_watermark();
        case 9:
            check_watermark();
        case 10:
            check_watermark();
        case 11:
            check_watermark();
        case 12:
            check_watermark();
        case 13:
            check_watermark();
        case 14:
            check_watermark();
        case 15:
            check_watermark();
        case 16:
            check_watermark();
        case 17:
            check_watermark();
        case 18:
            check_watermark();
        case 19:
            check_watermark();
        case 20:
            check_watermark();
        case 21:
            check_watermark();
        case 22:
            check_watermark();
        case 23:
            check_watermark();
    }

}

That falls into the “very desparate” part. As long as there are companies that have better recruitement processes it will help if most people prefer those over others. If all of these companies reject an applicant then this applicant might become “desparate” and turn towards worse companies. So it’s more the mass of people that influence the market and can therefore improve its conditions.