RicardoLuis0

bjarne/hsutter and their whole "club" have been (from my admittedly outsider perspective) using the "founding principles" in bad faith in the c++ comittee for a while now, see the strong-arming of safety profiles into the standard while they are in no way workable or anything more than a half-useless solution to anything they claim to solve https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p34... / https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p34... / https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p36...

smoking tobacco is bad, but smoking cigarettes is much, much worse because of all the extra shit that's added in to make them even more addictive (and more carcinogenic) https://en.wikipedia.org/wiki/List_of_additives_in_cigarette...

> Measuring productivity with LoCs is like measuring output with cash burn.

companies are doing that as well lol (re: tokenmaxxing)

more that, most C++ developers aren't "C++ people", the ones that are are a very vocal, but very small minority, though they're disruptive enough that some projects (re: the aforementioned linux kernel) elect to abandon C++ entirely just to avoid them

> I wonder what starting point and success criteria do you assume for that 2 year timeline. About a year ago I wrote a deferred renderer with dynamic lights, and shadow mapping, and few post effects in about a month of free time (Less than a week of full time work).

i'd assume it means fully understanding what you're building, if you already know 3d graphics or are just copying example code around, sure you can build something quick, but to fully understand the concepts from a background without previous graphics knowledge takes time and dedication

just because someone writes or wrote C++ doesn't make them a "C++ person", and "C++ people" are very much against rust

while SEO has made search worse, i don't think it's the core reason why things are impossible to find, i think it's simply the fact that, over time, google has been butchering the ability to search for exact terms in favour of "natural language" searching, which makes simple things like "how do i make an orange cake" or whatever return useful results, but makes any actually technical query return a lot of pure garbage

yeah, but those are using conventional explosives, only countries like the US and Russia have enough nukes to do the same with nuclear explosives, a country like japan would need a sophisticated missile instead

that's exactly the point, the _lack of_ humans during its evolution is what it has to do with us, a mushroom may be poisonous to the species that it evolved around, while at the same time not being poisonous to humans

consumer cards don't share dies with datacenter cards, but they do share dies with workstation cards (the formerly quadro line), ex. the GB202 die is used by both the RTX PRO 5000/6000 Blackwell and the RTX 5090

it's worth noting as well that the windows API has been a thing since 1985, _before_ C was standardized, such old versions of C were incredibly untyped

or possibly the malware has spread to multiple of their devices?

that's the altered part -- those more restrictive terms of the VVVVVV license only apply to the _assets_, and the license for the source code itself is far more liberal:

https://github.com/analgesicproductions/Even-The-Ocean-Open-...

if your data's sequential, creating an iterator in C++ is as simple as returning a begin and end pointer, and will be optimized away by any level other than O0

https://godbolt.org/z/WEjzEr5j4

> So why aren't we doing this?

isn't IPv6 is basically that? just restricted to internet addresses

and it's not like SRAM isn't used in modern computers -- it's baked directly into the silicon of your CPU to serve as register banks and cache

> the case of a run-away string

that, i'd guess, is one of the reasons why most languages don't allow multi-line strings without special syntax

it seems to be on github, but the commit history doesn't go beyond 2017: https://github.com/beejjorgensen/bgc

that one in particular was not really caused by goto, but rather by braceless if statements, it'd be a vulnerability all the same if the line was a "fail" function that was called instead of a goto.

just about any electronics here in brazil are ~2x the price, be it phones, computers, computer parts (CPUs, GPUs, MOBOs, etc), or anything else (not just apple, any brand)

it's not guaranteed atomic, and if you ARE using volatiles, "maybe" doesn't really cut it, so now you need to do `++*v` the proper way (ex. `lock cmpxchg` / `__atomic_compare_exchange`), or explicitly write it out the long way (`*v = *v + 1`) and risk the small chance of the value changing under you between read/write

that's still wrong, the integer data model is defined by the target, which is not specified in the quiz, not solely by the compiler, ex. clang uses 32-bit longs when compiling for windows, and 64-bit longs when compiling for linux:

* windows - https://godbolt.org/z/WWWzarEsK

* linux - https://godbolt.org/z/57WK45o6e

same for gcc on linux/windows (mingw)

there's a minecraft-style 4d sandbox game, with a playable demo: https://store.steampowered.com/app/1941640/4D_Miner/

"survived to update the file" implies that the one to add it to the list must be the one to have landed there

> Also i think that the reason C has -> is because in C pointer de-reference is a prefix whereas in Pascal is a suffix so without it you'd either have to write (*ptr).foo. Pascal avoids that by having both be suffix operators.

That distinction comes from early C (pre-ANSI / K & R C), where structures were really definitions of offsets (and said offsets were global, you couldn't have different 'offsets' for a member with the same name in different structs).

Say you had a struct 'struct mystruct {int a;int b;int c};':

You could do '200.b' to access the value at the 'b' offset of the memory location '200' ( '*(int*)( 200 + offsetof(struct mystruct,b) )' or '((struct mystruct*)200)->b' )

And '200->b' would access offset 'b' of the memory pointed to by memory location '200' ( '*(int*)( *(intptr_t*)200 + offsetof(struct mystruct,b) )' or '(*(struct mystruct**)200)->b' )

> The HTML and JS specs are absurdly complex to the point where there's basically no hope of anyone implementing them from 0

That's actually being done in the Serenity OS project! HTML renderer, JS interpreter, and Web Browser, from scratch:

https://github.com/SerenityOS/serenity

https://www.youtube.com/playlist?list=PLMOpZvQB55beChggmvk-s...

https://www.youtube.com/playlist?list=PLMOpZvQB55be0Nfytz9q2...

have you considered using C11's _Generic feature? It allows you to maunally implement function overloading: https://godbolt.org/z/jxjvnMTPT

I've been using a free tool by voidtools tool called "Everything" for years, it provides almost-instant search on windows NTFS volumes: https://www.voidtools.com/support/everything/

while the word 'master' can indeed be used in the sense of "master and slave", its use in git is more akin to the use of 'master' in "master record", and doesn't refer to 'ownership' in any way

the windows 7 start button still "pops" out of the taskbar if you're using the taskbar in small mode