, we need to look at a very fundamental concept in how programs work: memory access.
When you run a program, a certain amount of system memory is allocated for its use. Within this allocation, the program runs its instructions and processes data, constantly swapping values in and out of specific, physical locations in the system's memory reserve. In older languages like C and C++, these memory addresses can be directly accessed from within the program itself without having to ask for permission .
The problem is that even if memory has an ironclad electrical logic built into it, the programmers who are manipulating it are humans, and humans make mistakes like forgetting to give memory allocations back to the OS when they are done with them or attempting to access parts of system memory for which they do not actually have permission.
Older languages will compile these errors into the program and run it without safeguards, leading to program crashes when an operating system denies a program's attempts to access forbidden memory. Or even worse, bad programming can leave sensitive data behind in memory after the program is done with it, making it accessible to malware and viruses.In order to prevent these issues, newer languages have guardrails in place that periodically clears out the memory that is no longer being used.
Generally, computers are so fast now that the processing delays created by these guardrails aren't always noticeable to the end user, but at a system level, the delays are substantial, and when these programs are scaled up to the level of cloud computing data centers like those used by Amazon, Google, and Microsoft, the seemingly insignificant inefficiencies in newer languages scale up along with them.