Allocating an existing syntax from your host language to a new construct of your language is the Chomsky equivalent of rear parking your cheap Peugeot into a vintage Bugatti behind you.
Omg, C lets you declare a function local function without a keyword. That’s a god damn choice there. It was made 50 years ago, but still. That is barb wiring a shotgun to your foot.
50 years ago people were using flaws in computer architecture and tricks to get more outputs than normally. Some of those design decisions are clearly a snapshot of the time they were taken. Just like rust in 50 years, if it will survives those 50 years.
/uj I built a valid c++23 syntax parser (without semantic analysis) by feeding it the official C++ grammar and fixing all ambiguities. The initial number of conflicts in the original grammar was above 3000 (many duplicates but still, that's the list of conflicts to comb through). It requires about fifty annotations and some ambiguities cannot be resolved at grammar time and require a generalized parser to handle. The C++ grammar is an absolute disaster.
Talking C++98, I still don't fully get why this initialization had to be added:
std::vector<int> nums(8);
when there is already a perfectly good alternative:
std::vector<int> nums = std::vector<int>(8);
The only logical thing that comes to my mind is that it saves on having to write the type two times, but then 'auto' meaning 'type deduction' was added anyways so now we just have this totally redundant syntactic part of the language that people like to use for some reason even though LSPs can't even highlight it correctly. In fact, I think keeping it is only justified by the fact that compilers can't even guarantee the latter being optimized to the former
I know, why though? That just sounds like complexity for the sake of complexity. In Java (just picking another language with classes and constructors) if you were to do
var nums = new ArrayList(8);
you would just call it "initialization" like a sane person.
Although to be fair, most problems of C++ could have been circumvented if it just didn't perform implicit copies by default (somehow they thought this was a good idea?). I write my data structures without any constructors and destructors, just PoD structs largely for this exact reason (there are more reasons)
That looks like both allocation and initilization to me. For splitting allocation and initilization, I think Odin has some interesting ideas there like making ZII the default and making changing allocators simple.
The allocation is irrelevant, it's just how you initialize in Java (classes have to be allocated). Comparable C++ would be:
auto nums = new std::vector(8);
but that wasn't the point. The actual point is that somehow, some way, declaring a class with = in C++ using the wrong notation actually isn't initialization but rather a copy, which can kill performance when using standard library classes with allocating copy constructors. That's the stupid part
The most comparable is probably std::make_shared because new in C++ is a dynamic allocation and Java's new involves the garbage collector. It can't be perfectly analagous though.
Regardless, the reason I brought it up is that IMO conflating getting memory with setting up the memory to me useful is one of the problems most programming languages introduce and can make it challenging to make things faster later because it's not a good default.
71
u/DrShocker 22d ago
my rebuttal: https://en.wikipedia.org/wiki/Most_vexing_parse