--- title: 'Stack vs Heap Memory - Simple Explanation' source: 'https://youtube.com/watch?v=5OJRqkYbK-4' video_id: '5OJRqkYbK-4' date: 2026-08-02 duration_sec: 327 --- # Stack vs Heap Memory - Simple Explanation > Source: [Stack vs Heap Memory - Simple Explanation](https://youtube.com/watch?v=5OJRqkYbK-4) ## Summary This video provides a clear and concise explanation of stack and heap memory in programming, focusing on how they store data and why different variables have different scopes. It covers the stack data structure, the call stack's role, the heap's flexibility, and the differences between value and reference types, including the role of the garbage collector. ### Key Points - **Machine Code and Stack Data Structure** [00:15] — Machine code is converted into instructions the computer understands. The stack is a data structure where items are added and removed only from the top, like a stack of books. - **Call Stack Responsibilities** [01:02] — The call stack tracks the return address after a method finishes and keeps track of local variables within a method. - **Heap Allows Arbitrary Order** [01:16] — Unlike the stack, the heap allows storing items in any order, but this flexibility comes with higher overhead. - **Heap Usage for Cross-Method Data** [01:45] — The heap is used for data that needs to be accessed across different methods, such as reference types. - **Value vs Reference Types** [02:01] — Value types (like int) store the value directly, while reference types have a pointer to a memory location on the heap. - **Value Types on Stack or Heap** [02:16] — Value types are stored on the stack if declared locally in a method, but on the heap if they are part of a class or static. - **Garbage Collector** [03:15] — The garbage collector cleans up heap memory that is no longer referenced, such as reference types declared in a method after it finishes. - **Anonymous Functions and Closures** [03:57] — Anonymous functions (like lambdas in C#) can capture variables from the enclosing method, forcing those variables to be stored on the heap temporarily. - **Asynchronous Methods and Threads** [04:42] — Asynchronous methods run on different threads, each with its own call stack. Results are stored on the heap so the original thread can access them later. ### Conclusion Understanding stack and heap memory is crucial for grasping variable scope and performance. The stack is fast and ordered, while the heap is flexible but slower, with garbage collection managing cleanup. ## Transcript Today we're going to have a quick look at stack and heap memory when your application is running. memory can be really helpful to work out why things have different scopes. The first part is machine code. is converted into instructions that your computer can understand. Now to understand the stack, you need to understand the stack data structure. so you imagine you've got a book stacked like this. and you can put things on the top of the stack, So we can't take anything for the middle, we can't take it to the bottom. All we can do is just add stuff to the top, take it off, in that order. Now the call stack has a couple of responsibilities. returned to after the current method is finished executing. that's going to get added to the call stack and each subsequent Now the second thing that the call stack is responsible for is for keeping track of the local variables in your method. Now the heap, unlike the stack, allows you to store items in memory in any order. Now, with this added ability, and therefore adding items to the heap has a higher overheads Now generally the heap is used whenever you have data So if you have a variable that needs to be accessed across different methods then that is going to live on the heap. where your variables are stored in memory. Now value types just store the value. So generally data types such as this, such as INT will be stored to a value. So we have two parts to a reference type. We have a pointer which is generally just an address to a location in memory. For value types, it really depends on where you declare it. we know that we can't access that variable from outside the method. that is because that local variable is going to get stored on the call So soon as execution is finished, that block on the call isn't going to be available anymore. Now, if we were to declare a reference type variable inside your method, The value for your reference type variable will be on the heap, once the method execution is finished. It really depends on where you declare it in your code. because you need to be able to access it from different areas in your code. And for example, if you create a class and then have variables inside your class, is also going to live on the heap and so the variables inside it. Now because our reference types only have a pointer to a location in memory, what happens to that block of memory after your method is finished executing? Now, as the name suggests, the garbage collector goes around collecting garbage. It goes around and looks at the heap and finds things aren't being used anymore So this is how when a reference type thats declared in a method is no longer the garbage collector comes, it cleans it up. Value types are either on the stack or the heap, depending on where there declared. Static variables, for example, will always be on the heap Now, in some languages such as C#, we have what we call anonymous functions. but they can be created and called from inside another method. that you declared in the method that called it. those variables need to at least temporarily be stored on the heap, Of course, as soon as you call that anonymous and therefore not have access to anything that is on the previous level down. we're going to have a bunch of data that's just going to be dangling around Now, the other exception is asynchronous methods. anything asynchronously, it's going to get run on a different thread. it has multiple threads and each thread has its own call stack. is independent of one another, they can finish independently as well and therefore be able to access the results of your asynchronous methods. so when you call your asynchronous method, Your current thread is going to continue And all of those results are just going to get stored If you like this video, please make sure you like and subscribe and you might want to check out this one on Bitwise Operators and why we use them. Thank you for watching. I'll see you in the next video.