Course Overview

Overview of history of the JavaScript language

History of JavaScript

Overview of the relationship between JavaScript and Java

JavaScript vs Java

Overview of how JavaScript is evolved as a programming language

How is it evolved?

Overview of how we can track upcoming features in the JavaScript language

How to track upcoming features?

Overview of how the ECMAScript is versioned

How is ECMAScript versioned?

Explanation of whether JavaScript is interpreted or a compiled language

Is it interpreted or compiled?

Explanation of how JavaScript is executed

How is it executed?

Execution Context

Explanation of what is a callstack and how it is used in JavaScript

Callstack

Overview of memory management in JavaScript

Memory

What is JavaScript

What is hoisting?

Explanation of common misconception about hoisting in JavaScript

Misconception about hoisting

Hoisting

What is scope?

Explanation of global scope in JavaScript

Global scope

Explanation of function scope in JavaScript

Function scope

Block scope

Explanation of module scope in JavaScript

Module scope

Scope chain

Scope

What is coercion?

Diving into inner details of  coercion in JavaScript

Deeper look at coercion

Explanation of what abstract operations are and common types of abstract operations in JavaScript

Abstract operations

Explanation of how abstract or loose equality works in JavaScript

Abstract equality operator

Explanation of how the addition operator works in JavaScript

Addition operator

Explanation of how relational operators work in JavaScript

Relational operators

Coercion exercise for testing and practicing the knowledge learned in this module

Coercion exercise

Coercion

What is a closure?

Explanation of a common misconception about closures in JavaScript

Misconception about closures

Explanation of the problem of closures inside loops and how to fix it

Closures inside loops

Explanation of closures can be used to hide data

Data hiding using closures

Closures

What is prototypal inheritance?

Prototype chain

__proto__ property

Explanation of how we can create objects with custom prototypes in JavaScript

Custom prototypes

Explanation of how prototype chain is set with ES6 classes

ES6 classes and prototypes

Prototypes

Explanation of this keyword in JavaScript

What is this?

Explanation of how "this" works inside arrow functions

Arrow functions and "this"

Explanation of how value of "this" can be set explicitly

Explicitly binding "this"

globalThis

Summarizing "this"

'this' keyword

What is a symbol?

Explanation of why symbols were added in JavaScript

Why symbols?

Symbols and privacy

Explanation of global symbols in JavaScript

Global symbols

Explanation of what well-known symbols are in JavaScript

Well-known symbols

Symbol

Overview of asynchronous behavior of JavaScript

Overview

Overview of how callbacks help us write asynchronous code in JavaScript

Callbacks

Event loop

Promise

Explanation of promise chaining in JavaScript

Promise chaining

Explanation of some static methods of promises and their use cases

Use cases for static Promise methods

Explanation of async-await syntax in JavaScript

async await

Explanation of microtasks, how they are processed, and how they are linked to promises

Microtasks

Explanation of common anti-patterns to avoid when using promises in JavaScript

Promise anti-patterns

Asynchronous JavaScript

Explanation of what is an iterator in JavaScript

Iterators

Explanation of what is a generator in JavaScript

Generators

Explanation of how we can create asynchronous iterators in JavaScript

Asynchronous iterators

Explanation of how we can create asynchronous generators in JavaScript

Asynchronous generators

Iterators and Generators

Overview of what is debugging and different ways to debug JavaScript

Debugging

Overview of using the "debugger" statement to debug JavaScript

Debugger statement

Overview of using the breakpoints in browser developers' tools to debug JavaScript

Breakpoints in browser

Overview of using the VS Code debugger to debug JavaScript

VS Code debugger

Debugging JavaScript

Final thoughts and advice regarding how to continue the exciting journey of learning JavaScript

Conclusion

Wrap up

Enter your name and email address below, then click the **"Send my free chapter"** button to get started

300+ page PDF

EPub

newline Access with Replits

All Code Samples

Discord Community Access

One-time price of $69

Become a confident JavaScript pro by unraveling the most challenging aspects of the language. With easy-to-understand explanations and code examples, you’ll gain a deeper and solid understanding of JavaScript's most complex features.

Advanced JavaScript Unleashed is for beginner and intermediate developers alike, who want to elevate their JavaScript skills and become senior engineers by gaining a deeper understanding of the core topics of the language.

Advanced JavaScript Unleashed

There are many resources on the internet that claim that primitives are allocated on the stack and objects are allocated on the heap, but the reality is not that simple.

The official ECMAScript specification doesn't state anything about how JavaScript engines should allocate memory for different types of values or how they should free up memory once it is no longer needed by the program. As a result, different JavaScript implementations are free to choose how they want to handle memory management in JavaScript.

So instead of simply believing that the primitive values are stored on the stack, and the objects are stored on the heap, we should understand that memory allocation in JavaScript is an implementation detail, and different JavaScript engines might handle memory differently because the language specification doesn't mandate how memory should be handled in JavaScript.

In the V8 engine, for example, almost everything is stored on the heap. The following quote from the 

 invalidates the common misconception regarding memory allocation in JavaScript.

JavaScript values in V8 are represented as objects and allocated on the V8 heap, no matter if they are objects, arrays, numbers, or strings. This allows us to represent any value as a pointer to an object.

This doesn't mean that we should assume that everything is allocated on the heap. JavaScript engines may allocate 

 values on the heap but could use the stack for optimization and store temporary values that might not last longer than a function call.

JavaScript engines are complicated softwares that are heavily optimized. It is unreasonable to assume that they all just follow the simple rule of 

primitives go on the stack and objects on the heap

The most important point you should take away from this lesson is that different JavaScript engines may handle memory differently, and "primitives in javaScript simply go on the stack" is a 

Unlike other languages like C, where the programmer is responsible for freeing up the memory when it is no longer needed, JavaScript makes the job of the programmer easier by automatically handling the memory.

Memory that is no longer needed is automatically freed by the JavaScript engine, and this process is known as 

. Modern JavaScript engines include a garbage collector that is responsible for determining which parts of the memory are no longer needed and can be freed. Once such blocks of memory have been determined, those blocks are freed by the garbage collector.

Different algorithms are used to determine which blocks of memory are no longer needed and are eligible for garbage collection. Currently, modern JavaScript engines use a 

This algorithm determines which blocks of memory are "unreachable"; such blocks of memory are considered eligible for garbage collection. This algorithm is an improvement over the 

The Java language also has the mechanism of automatic garbage collection, but in Java, programmers can manually trigger the garbage collection process, whereas JavaScript programmers don't have this level of control over garbage collection. Some might see this as a limitation, but there is no doubt that automatic garbage collection is really helpful for programmers to avoid memory leaks that are often encountered in languages that don't handle this automatically.

---
title: Memory
description: Overview of memory management in JavaScript
isPublicLesson: false
---

There are many resources on the internet that claim that primitives are allocated on the stack and objects are allocated on the heap, but the reality is not that simple.

The official ECMAScript specification doesn't state anything about how JavaScript engines should allocate memory for different types of values or how they should free up memory once it is no longer needed by the program. As a result, different JavaScript implementations are free to choose how they want to handle memory management in JavaScript.

So instead of simply believing that the primitive values are stored on the stack, and the objects are stored on the heap, we should understand that memory allocation in JavaScript is an implementation detail, and different JavaScript engines might handle memory differently because the language specification doesn't mandate how memory should be handled in JavaScript.

In the V8 engine, for example, almost everything is stored on the heap. The following quote from the [official V8 blog](https://v8.dev/blog/pointer-compression#value-tagging-in-v8) invalidates the common misconception regarding memory allocation in JavaScript.

> JavaScript values in V8 are represented as objects and allocated on the V8 heap, no matter if they are objects, arrays, numbers, or strings. This allows us to represent any value as a pointer to an object.

This doesn't mean that we should assume that everything is allocated on the heap. JavaScript engines may allocate _most_ values on the heap but could use the stack for optimization and store temporary values that might not last longer than a function call.

JavaScript engines are complicated softwares that are heavily optimized. It is unreasonable to assume that they all just follow the simple rule of _primitives go on the stack and objects on the heap_.

The most important point you should take away from this lesson is that different JavaScript engines may handle memory differently, and "primitives in javaScript simply go on the stack" is a **misconception**.

#### Further reading

-   [JavaScript memory model demystified - (blog)](https://www.zhenghao.io/posts/javascript-memory)
-   [What are JavaScript variables made of - (blog)](https://www.zhenghao.io/posts/javascript-variables)
-   [Where does Javascript allocate memory for the result of a function call? Stack or heap? - (stackoverflow post)](https://stackoverflow.com/questions/67356107/where-does-javascript-allocate-memory-for-the-result-of-a-function-call-stack-o)

## Automatic garbage collection

Unlike other languages like C, where the programmer is responsible for freeing up the memory when it is no longer needed, JavaScript makes the job of the programmer easier by automatically handling the memory.

Memory that is no longer needed is automatically freed by the JavaScript engine, and this process is known as **garbage collection**. Modern JavaScript engines include a garbage collector that is responsible for determining which parts of the memory are no longer needed and can be freed. Once such blocks of memory have been determined, those blocks are freed by the garbage collector.

Different algorithms are used to determine which blocks of memory are no longer needed and are eligible for garbage collection. Currently, modern JavaScript engines use a [Mark-and-sweep algorithm](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Management#mark-and-sweep_algorithm).

This algorithm determines which blocks of memory are "unreachable"; such blocks of memory are considered eligible for garbage collection. This algorithm is an improvement over the [reference counting algorithm](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Management#reference-counting_garbage_collection), which has its limitations.

The Java language also has the mechanism of automatic garbage collection, but in Java, programmers can manually trigger the garbage collection process, whereas JavaScript programmers don't have this level of control over garbage collection. Some might see this as a limitation, but there is no doubt that automatic garbage collection is really helpful for programmers to avoid memory leaks that are often encountered in languages that don't handle this automatically.
