What is garbage collector?

Garbage Collector (GC) in Ruby is an automated memory management mechanism. It frees up memory occupied by objects that are no longer used in the program. This allows developers not to manually manage memory (allocation and deallocation), reducing the likelihood of memory leaks and errors.

Main principles of Ruby GC:

Mark and Sweep:
- Marking: GC determines which objects are accessible from active parts of the program (e.g., from local or global variables). These objects are marked as "alive".
- Sweeping: After marking, GC traverses the entire heap (the memory area where objects are stored) and frees memory occupied by objects that were not marked as "alive".
Generational Collection:
- Objects are divided into "generations" based on their "age". New objects belong to the "young" generation, while old objects belong to the "old".
- It is assumed that young objects are more likely to become inaccessible than old ones.
- GC checks the young generations more frequently, which speeds up garbage collection and requires fewer resources.
Incremental Collection:
- Garbage collection occurs in small portions, interleaved with the execution of the main program.
- This helps avoid long pauses in program execution, which can be noticeable to users.

An example of a very simplified demonstration of how an object can become inaccessible to GC:

# Create an object referenced by a variable
obj = "Hello, Ruby!"

# Now, if the variable stops referencing this object...
obj = nil

# ...or if the variable goes out of scope (for example, at the end of a method),
# the "Hello, Ruby!" object becomes inaccessible to the program.
# During the next garbage collection cycle, if there are no other references to this object,
# it will be collected by GC, and memory will be freed.

GC operation is transparent to most developers, but understanding its principles is useful for optimizing performance and diagnosing memory-related issues.