Description
Memory leaks and dangling pointers are the main issues of manual memory management. You delete a parent node in a linked list, forgetting to delete all its children first - and your memory is leaking. You delete an object chain in the correct order - but suddenly your program crashes since you forgot about the second owner of this resource, which now tries to dereference a null-pointer.
To avoid these issues, most of the modern high-level programming languages implement automatic memory management. You allocate objects manually, however, don’t bother with their deallocation: a special program, garbage collector, knows how to automatically deallocate them correctly, and reclaim them for future reuse.
In the Garbage Collection Algorithms class, we study all different techniques and algorithms related to automatic memory management, which are used today in practice.
Who this class is for?
First of all, for compiler engineers.
In implementing your programming language, there is a very high chance you’ll need to implement a garbage collector. Even languages that initially were positioned as “memory-safe”, such as Rust, eventually implemented automatic reference counting (ARC) and other collectors.
To reiterate: in most of the modern high-level programming languages, a garbage collector module (or multiple GC modules, like in Java) is pretty much a requirement today.
What if I don't implement programming languages every day?
If you are not a compiler engineer, then the class can still be interesting for you. Implementing a garbage collector or a memory manager, in general, is a pretty advanced engineering task. It's a simple trick: you take some complex project (such as a garbage collector, compiler, interpreter, etc), and while building it, you learn all different data structures and algorithms. And then come back to "every-day programming", improved as a better engineer, with the transferable generic knowledge of complex systems.
Do I need C or C++ for this project?
Not really! Of course, C and C++ are probably the best languages for raw memory manipulations and fit well here, however, in the course we study generic design algorithms and focus mainly on theoretical aspects of garbage collectors and memory allocators. This means you can implement them in any language you want. For example, you can allocate an `ArrayBuffer` in JavaScript for a virtual heap, or a similar byte array in Python, Rust, etc.
Most of the algorithms in the course are described in generic pseudo-code, so you can port them to any language.
What's specific in this class?
The main things of these lectures are:
Concise and straight to the point. Each lecture is self-sufficient, concise, and describes information directly related to the topic, not distracting on unrelated materials or talks.
Animated presentation combined with live-editing notes. This makes an understanding of the topics easier and shows how (and when at the time) the object structures are connected. Static slides simply don’t work for complex content.
I hope you enjoy this class and make the topic of Automatic memory management more clear and easier in implementing your programming language!
Basic knowledge
Basic data structures and algorithms (trees, graphs, linked lists, etc)
Basic knowledge about computer memory (bytes, addresses, pointers)
