Why wasn't D to C what C was to B?

Why wasn't D to C what C was to B?

Attached: D.png (220x167, 24K)

too little too late

because it's actually ++(c++)

D is actually --C++

This. C was good enough and here now when D was still being implemented.

Too much GC to replace C.

2C++
0

GC made it useless in bare metal, which is where C shined the most and continues to shine. Now it's competing with Go and Rust, which are both more modern though Rust goes a lot further into the cutting edge.

what's GC?

GC = Garbage collection
The term implies automatic memory management. This can be achieved with either reference counting, or tracing garbage collection. Tracing garbage colection is often just called garbage collection.
In case you have no idea what it is, in languages like Java and C# you write things like something x = new something and never worry about deleting it from memory. Garbage collection has an overhead compare to manual memory mangement, where you explicitly delete things after use.

Ah yea I know what that is, thanks.
Although I'm unsure as to why it would bad on bare metal?

>why it would bad on bare metal?
I'm not even sure what user meant by that, but perhaps he meant embedded and other low powered devices. The overhead of garbage collection there would be completely unacceptable

the problem is that it's very computationally heavy, and can behave unpredictably. Your programs run slower when they're garbage coillected, which is fine in some applications but there are cases where every clock cycle counts.

If you need a system that provides some service in an extremely predictable (and/or fast) amount of time, a garbage collector can make that almost impossible because it could arbitrarily jump in and start taking up CPU cycles while your application is trying to respond to some kind of service request.

There are a lot of applications where the heap is avoided entirely- not even manual memory management is used. This is generally the case on resource-starved systems that don't have a lot of RAM. Without a lot of RAM, constant allocation/reallocation/deallocation can lead to heap fragmentation, which can cause a system to lock up if it can't find a sufficient continuous space in memory to allocate something.

>can behave unpredictably
D's GC is deterministic

>>CAN behave unpredictably
>D's GC is deterministic

>0

Attached: 1519264861280.png (645x729, 62K)

Still not faster then java

wait shit yea I'm retarded fuck
I do physics as well oh fuck

>Now it's competing with Go
No it doesn't.

It was a piece of shit

Its just a shittier version of C++, it made all the same mistakes