When you run Javascript code it's processed by a javascript engine. At a high level, the engine performs two key tasks:

-    **Manages Execution(Call Stack)**: it determines what piece of code to run and when
-    **Manages Memory(Memory Heap):** It allocates memory for variables and objects, and cleans up memory that is no longer needed.

## What is the Call Stack?

The **Call Stack** is a data structure where the JavaScript engine keeps track of where your code is during execution. Every time a function is called, it gets **pushed** onto the stack. Once a function finishes executing, it’s **popped** off the stack. When the stack is empty, it indicates that the engine has finished executing the script. You can think of the call stack like a stack of plates where you can only remove the plate on top (first in,last out). Newer function calls are placed on top, while older ones stay lower until they’re done. If functions keep calling each other endlessly (like a recursive function without an exit condition), a **"Stack Overflow"** error occurs because the stack grows too large for the engine to manage.

## How the Call Stack Works? (Example) 

```js
function secondFunction() {
  console.log('End of the stack');
}

function firstFunction() {
  secondFunction();
}

firstFunction();

```

## Execution step by step:

1.  firstFunction() is called → pushed onto the stack.
2.  Inside firstFunction, secondFunction() is called → pushed onto the stack.
3.  Inside secondFunction, console.log('End of the stack') is called → pushed onto the stack.
4.  console.log('End of the stack') executes and returns → popped off the stack.
5.  secondFunction() finishes → popped off the stack.
6.  sayHi() finishes → popped off the stack.

## What is the Memory Heap?

The **Memory Heap** is a large region of memory where objects, functions, and variables are stored. Whenever you create objects, arrays, or even functions, they are allocated in the memory heap (primitive constants are stored in the call stack or in the global execution context -ex: window in the browser-).

## Example of Memory Allocation:

```js

const person = {
  name: 'Marko',
  gender: 'male'
};
```

When this code runs:

- The object  **{name: 'Marko', gender: 'male'}** is stored in the heap.
- The variable **person** holds a reference (a pointer) to that location in memory.

## Example of Call Stack and Memory Heap usage:


```js

function createProfile(name, gender) {
  return {
    name: name,
    gender: gender
  };
}

const userProfile = createProfile('Marko', 'male');

console.log(userProfile);

```

## What happens:

- **createProfile('Marko', 'male')** is called → pushed onto the **call stack**.
- a new object is created in the **memory heap** (the function is still on the stack)
- **createProfile** returns a reference to the object -> poped of the **call stack**
- reference is stored in the **userProfile** variable
- **console.log(userProfile)**  logs the object, accessing it via the reference.


## How the Call Stack and Memory Heap Interact

- The **call stack** manages where you are in the code and what function is currently running (keeps track of function calls)
- The **memory** heap manages where your data lives in memory (stores actual data during function calls)


Call Stack and Memory Heap

How Javascript manages execution and memory, focusing on the call stack and memory heap.

Memory heap

Call Stack and Memory Heap