Memory management is the process of allocating a program's working memory when it's actually needed and freeing that memory again once it's not, and a memory leak, memory that's no longer actually needed by the program but never gets freed, doesn't crash anything immediately. It just quietly accumulates over time, until the computer eventually runs out of available memory altogether, sometimes hours or even days after the specific bug that originally caused the leak.
Manual allocation gives direct control, garbage collection trades that control for built-in safety
Manual memory management, explicit allocate and free calls, gives a programmer direct control over exactly when memory is claimed and released, but makes forgetting to free memory, or accidentally freeing the same memory twice, a genuinely common source of real bugs. Automatic garbage collection instead periodically identifies memory the program can no longer actually reach and frees it automatically, trading away some of that direct manual control in exchange for built-in protection against that entire specific class of bug.
A leak's delayed, distant symptom is exactly why it's such a distinctively hard bug to catch
A memory leak itself produces no immediate visible symptom, the program keeps running correctly, appearing completely normal, for a genuinely long time after the leak begins. The eventual failure, running out of available memory, can occur far away in time, and even in a completely different part of the program, from wherever the actual leak first originated, which makes tracing the connection between root cause and eventual symptom a genuinely difficult debugging problem compared with a bug that fails immediately and visibly at the exact point it occurs.
What we're still unsure about
That manual memory management and automatic garbage collection trade direct control against built-in safety, and that memory leaks produce delayed, distant symptoms, are well established, uncontroversial facts of software engineering. What's genuinely worth flagging is that garbage collection removes an entire class of manual memory bugs but doesn't eliminate memory leaks entirely, a reference to an object that's technically still reachable but that the program will actually never use again can still leak memory even under full automatic garbage collection, and catching that specific kind of leak still requires real, deliberate profiling rather than something the garbage collector alone can guarantee to prevent.
This sits inside Memory Management, one of eight topics in Programming, one of seven domains in Computer Science, one of seventeen subjects the app can quiz you on.