While I mostly agree, anyone liking npm should really question if they were dropped as a child. Assuming by npm you mean node package manager. I think even the original author tries to distance themself from that dogshit.
This is why C remains one of my favorites even if I barely use it these days. As nice as Rust can be, with it's type system and whatever else, those same features just get in the way. Yes I want to access raw memory and cast it to whatever. I (think I) know what I am doing. If I make a mistake nobody's going to blame the compiler. When a program borks your computer or business nobody blames the language it was written in, they blame the authors of the program.
i will never understand why garbage collectors piss retards off so much
you can at least learn it yourself! just use a package manager of your choice to install a lisp or scheme implementation and start playing in the repl today
probably because html+css-based ui seems a lot more accessible and runs on more platforms than major c/c++ widget toolkits
i think a bit of the scheme still rubbed off on javascript and that may be part of why you can never escape it these days
rustniggers&co. don't realize exactly how based c is: it's partially designed to be used as an IR for other languages
If you wish to learn it SICP is excellent introduction into scheme(LISP/1) and into programming in general.
If you have ever used a minecraft server with the gui activated, you will see something like to this image:
Transmute?
memory usage graphs looking like that is how a garbage collected runtime is supposed to lookIf you have ever used a minecraft server with the gui activated, you will see something like to this image:
This is the Garbage Collector manifest. The performance characteristics may be acceptable in the absolute measure, but conceptually they are offensive— memory usage increases at a ridiculous rate, then the program must spend a large amount of time (compared to normal operation) clearing the garbage.
casting is when you tell c to treat some piece of data as a different type than what it was marked as
Nobody claimed otherwise. By the way, I agree that Garbage Collection is good, I am just presenting the common argument against it.
I hope this isn't directed at me. It's simply a fun example that happens to be demonstrative.
"Transmute" is one of two Rust things similar to c(++) casting.
More specifically, the fancy trick is treating the 32-bit float as an int, subtracting from a magic number, and casting back to float.
float Q_rsqrt( float number )
{
long i;
float x2, y;
const float threehalfs = 1.5F;
x2 = number * 0.5F;
y = number;
i = * ( long * ) &y; // evil floating point bit level hacking
i = 0x5f3759df - ( i >> 1 ); // what the fuck?
y = * ( float * ) &i;
y = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration
// y = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed
#ifndef Q3_VM
#ifdef __linux__
assert( !isnan(y) ); // bk010122 - FPE?
#endif
#endif
return y;
}sqrt(2^127) (01011111 00110111 01011001 11011111). Using it in the way described above results in an approximation of the inverse square root, which is then made more accurate using Newton's method.
better arguments would be to point out the requirement to bundle a gc, or the potential issues of a 3ms gc freeze when your industrial control software needs to do something in 2ms or people die, or the weird issues (and security vulnerabilities!) you can end up having with finalization
it's directed at whoever thinks a sawtooth-shaped memory usage graph is proof that gc is inefficient, which i hope doesn't include you either
of course rustroglodytes have to call it something slightly different for absolutely no reason
This is the less common (not retarded) argument.
The aforementioned retards.
"explicit type conversion (casting) [in rust] follow C conventions generally, except in cases where C has undefined behavior." REF
The average retard thinks that malloc/free is in some sense foundational and therefore every other memory management scheme must necessarily be bloat on top of malloc/free. Never mind that it's one of many schemes and that there are all sorts of variations and tradeoffs even between different mallocs. It doesn't help that most people's exposure to performance issues is video games, which have unusually latency-focused performance requirements that clash with many common GC designs. Meanwhile, latency borders on irrelevant for most programs unless you do something really stupid.
say "compacting collector" and "bump allocator" and maybe "free list" and get a funny confused stare from these memory management experts
note: most of the games they bring up have horrible issues that would make them chug even without a gc
I am not familiar with that part of Rust. To be fair I was exaggerating with my C comment, as I tend to not need to do those things myself.
GC is good, for the most part. Provided you know about what it will be doing. The problem with it is a wider one: lot's of people have learnt not to give a fuck about memory and end up writing awful code.
People loved to blame the performance on Java and GC back in the day, but as far as I know the actual issue was the renderer, which used the ancient OpenGL 1 and did ridiculous shit like issuing a draw call for every block or so. Once the overhaul of the renderer landed (around 1.8?), performance got noticeably better. I'm not sure how you'd run specifically into GC issues in Minecraft either to be honest, outside of Java pointer soup being taxing in general.
Was this Python and its awful reference counting GC? Most GCs are very good at cleaning up lots of short-lived garbage quickly. Not that I'm defending concatenate loops, those are always wasteful.
True, but then Mojang started using immutable data-object classes for their basic Vector3f, BlockPos, Quaternion, etc. math structures, which were allocated en masse every single frame for every single mathematical calculation. I forget exactly which version this happened in, but I do remember it being a problem.
Ah that's interesting. I thought it was a lot of construction and destruction of objects but that doesn't track now that I think about it.
I thought java was getting struts or some lightweight data types in a more recent version? I've given up paying attention to Valhalla.