Introduction

In programming, programs create variables, objects, arrays, lists, strings, and many other data structures while they are running.

Some of this data is needed only for a short time. After the program no longer needs it, the memory used by that data should be released so that the memory can be reused.

Garbage Collection is an automatic memory management process that finds unused objects in memory and frees the memory occupied by them.

It helps programmers avoid manually releasing memory in many modern programming languages.

Easy Real-Life Example

Classroom Example:
Useful books and notes stay.
Waste papers are removed.
The room becomes clean again.

Programming Example:
Useful objects stay in memory.
Unused objects are removed.
Memory becomes available again.

Garbage collection works like an automatic cleaner for program memory.

What is Garbage Collection?

Garbage Collection, often called GC, is a process where the programming language runtime automatically identifies memory that is no longer needed and releases it.

The memory that is no longer needed is called garbage.

Object created
        ↓
Object used by program
        ↓
Object no longer needed
        ↓
Garbage collector identifies it
        ↓
Memory is released or reused

Why Do We Need Garbage Collection?

Programs have limited memory. If unused memory is not released, the program may become slow, unstable, or even crash.

Garbage collection helps manage memory automatically and reduces the burden on programmers.

What is Garbage in Programming?

In programming, garbage means memory occupied by data or objects that are no longer reachable or needed by the program.

If the program cannot access an object anymore, that object becomes useless for the program.

CREATE object A
USE object A

Later:
No variable points to object A

Object A is now unreachable.
It may become garbage.

Reachable and Unreachable Objects

Garbage collection is based on the idea of reachability.

An object is reachable if the program can still access it directly or indirectly. An object is unreachable if the program has no way to access it.

Example: Object Becomes Unreachable

/*
This example shows how an object can become unreachable.
*/

CLASS Student
    PROPERTY name
END CLASS

ENTRY POINT
    CREATE studentRef AS Student
    SET studentRef.name = "Aman"

    SET studentRef = null

    /*
    Now the Student object has no reference.
    It may become eligible for garbage collection.
    */
END ENTRY POINT

In this example, the student object was first reachable through studentRef. After studentRef is set to null, the object may become unreachable.

How Garbage Collection Works

Different languages and runtimes use different garbage collection techniques. But at a beginner level, the process can be understood in three main steps.

1. Find objects that are still being used.
2. Identify objects that are no longer reachable.
3. Release memory used by unreachable objects.

Mark Phase

In the mark phase, the garbage collector identifies objects that are still in use.

It starts from known active references and follows links to find all reachable objects.

Program variables:
userRef → User object
cartRef → Cart object

Garbage collector marks:
User object as reachable
Cart object as reachable

Marked objects are considered alive because the program may still use them.

Sweep Phase

In the sweep phase, the garbage collector finds unmarked objects and releases their memory.

Marked object:
User object → keep

Unmarked object:
Old temporary object → remove

The memory occupied by removed objects becomes available for future use.

Compaction

Some garbage collectors also perform compaction.

Compaction means moving remaining live objects closer together in memory so that free memory becomes more organized.

Before compaction:
[Object A] [Free] [Object B] [Free] [Object C]

After compaction:
[Object A] [Object B] [Object C] [Free Free]

This can help reduce memory fragmentation.

Garbage Collection and Heap Memory

Garbage collection mostly works with heap memory, because objects and dynamic data are commonly stored in heap memory.

Stack memory is usually cleaned automatically when function calls finish. Heap memory may need garbage collection or manual management depending on the language.

Example: Heap Object Cleanup Concept

/*
This example shows dynamic object creation.
*/

CLASS Product
    PROPERTY name
END CLASS

FUNCTION createProduct()
    CREATE p AS Product
    SET p.name = "Keyboard"
    RETURN p
END FUNCTION

ENTRY POINT
    DECLARE item = createProduct()

    DISPLAY item.name

    SET item = null

    /*
    Product object may now become unreachable.
    Garbage collector may clean it later.
    */
END ENTRY POINT

The object may exist in heap memory while it is reachable. After no reference points to it, it may become eligible for garbage collection.

Does Garbage Collection Run Immediately?

Garbage collection usually does not run immediately when an object becomes unreachable.

The runtime decides when garbage collection should happen.

Object becomes unreachable
        ↓
Object becomes eligible for garbage collection
        ↓
Garbage collector may run later
        ↓
Memory is reclaimed

Eligible for Garbage Collection

An object is eligible for garbage collection when it is no longer reachable by the program.

Common ways an object may become eligible include:

Example: Reassigning a Reference

CLASS User
    PROPERTY name
END CLASS

ENTRY POINT
    CREATE userRef AS User
    SET userRef.name = "Aman"

    CREATE anotherUser AS User
    SET anotherUser.name = "Riya"

    SET userRef = anotherUser

    /*
    The old object with name "Aman" may become unreachable
    if no other reference points to it.
    */
END ENTRY POINT

When userRef is reassigned, it no longer points to the first object.

Circular References and Garbage Collection

Sometimes two objects may refer to each other but still be unreachable from the main program.

Object A → Object B
Object B → Object A

But no active program variable points to Object A or Object B.

A good garbage collector can detect that these objects are unreachable from the running program and can clean them.

Circular Reference Example

CLASS Node
    PROPERTY next
END CLASS

ENTRY POINT
    CREATE nodeA AS Node
    CREATE nodeB AS Node

    SET nodeA.next = nodeB
    SET nodeB.next = nodeA

    SET nodeA = null
    SET nodeB = null

    /*
    The two nodes refer to each other,
    but the program no longer has access to them.
    They may become garbage.
    */
END ENTRY POINT

Garbage Collection Does Not Solve Everything

Garbage collection helps manage memory, but it does not solve every memory problem.

If a program still keeps references to objects that are no longer logically needed, the garbage collector may not remove them because they are still reachable.

unusedObjectsList = []

ADD oldObject TO unusedObjectsList

/*
Even if oldObject is no longer needed logically,
it is still reachable through unusedObjectsList.
Garbage collector may not remove it.
*/

Memory Leak in Garbage-Collected Languages

A memory leak can still happen in garbage-collected languages.

This happens when objects are no longer needed but the program still keeps references to them.

cache = []

FOR EACH request
    CREATE temporaryData
    ADD temporaryData TO cache

/*
If cache keeps growing and old data is never removed,
memory usage may keep increasing.
*/

The garbage collector cannot clean objects that are still reachable through cache.

Manual Memory Management vs Garbage Collection

Garbage Collection Pause

In some systems, garbage collection may temporarily pause program execution while it cleans memory.

This pause may be very small or noticeable depending on the runtime, program size, memory usage, and garbage collection strategy.

Generational Garbage Collection

Many modern garbage collectors use a generational approach.

The basic idea is that many objects are short-lived, while some objects live longer.

Young objects:
Created recently.
Often temporary.
Collected frequently.

Old objects:
Survived longer.
Collected less frequently.

This helps garbage collection focus more on recently created objects that are likely to become unused quickly.

Young Generation

The young generation usually stores newly created objects.

Many temporary objects are created and discarded quickly, so this area may be collected frequently.

Temporary objects:
- Temporary string values
- Short-lived list objects
- Method-level helper objects
- Request-level objects

Old Generation

The old generation usually stores objects that survived multiple garbage collection cycles.

These objects may be long-lived, such as application-level data, cached data, or objects used for a longer time.

Long-lived objects:
- Application configuration
- Shared service objects
- Long-running session data
- Important cached objects

Example: Short-Lived Object

FUNCTION calculateTotal()
    CREATE temporaryList AS LIST
    ADD values TO temporaryList
    RETURN SUM temporaryList
END FUNCTION

ENTRY POINT
    DISPLAY calculateTotal()
END ENTRY POINT

The temporary list may be used only during the function execution. After that, it may become eligible for garbage collection if no reference remains.

Example: Long-Lived Object

ENTRY POINT
    CREATE appSettings AS Configuration
    SET appSettings.theme = "Dark"
    SET appSettings.language = "English"

    RUN application using appSettings
END ENTRY POINT

The configuration object may remain reachable while the application is running, so it should not be collected.

Advantages of Garbage Collection

Limitations of Garbage Collection

Garbage Collection and External Resources

Garbage collection mainly manages memory.

Other resources such as files, database connections, network connections, sockets, streams, and locks may require explicit closing or cleanup depending on the programming language and framework.

Memory object:
May be cleaned by garbage collector.

File connection:
Should often be closed explicitly.

Database connection:
Should often be released back to connection pool.

Example: Resource Cleanup Idea

OPEN file

TRY
    READ data from file
FINALLY
    CLOSE file
END TRY

Even in garbage-collected languages, external resources should usually be closed when no longer needed.

Common Beginner Mistakes

Best Practices for Garbage Collection Awareness

Prerequisites Before Learning Garbage Collection

Students should understand the following topics before learning garbage collection deeply:

Trace Table Example: Garbage Collection Eligibility

CREATE user1
CREATE user2
SET user1 = user2

Practice Activity: Identify Garbage Collection Eligibility

Identify whether the object may become eligible for garbage collection.

1. An object has no variable pointing to it.
2. A list is still stored in a global variable.
3. A temporary object was created inside a function and no reference was returned.
4. Two objects refer to each other, but no active variable points to either of them.
5. A cache stores old objects forever.

Sample Answers

1. Eligible
2. Not eligible while reachable through global variable
3. Eligible after function ends, if no reference remains
4. Eligible if unreachable from active program references
5. Not eligible while still stored in cache

Mini Quiz

Interview Questions on Garbage Collection

Quick Summary