Week 26

This week everything started to come together in a way that finally made sense to me. We covered several topics related to how memory works behind the scenes, and it felt like I was slowly uncovering how the operating system really manages the world that programs think they live in. The main ideas were virtual address spaces, how C handles memory with malloc and free, and the different techniques the OS uses to translate a virtual address into a physical one. We started with base and bounds, then moved into segmentation, and this naturally prepared the ground for paging.

Virtual address spaces were the first thing that clicked for me. Understanding that every process thinks it has its own clean and simple memory layout made it easier to visualize how code, heap, and stack live inside that space. Seeing that this space is actually “fake” and that the real data is stored somewhere else in RAM made me realize how much work the operating system is constantly doing behind the curtain.

The C memory API was another eye opener. Using malloc and free looks simple on the surface, but when you think about how memory can leak if you forget to free something, or how both the heap and stack interact during a function call, everything becomes more delicate. It made me appreciate why memory bugs can be so dangerous and why languages with automatic garbage collection exist in the first place.

The hardest topics for me this week were base and bounds and segmentation. Not the idea itself, but applying it mentally. With base and bounds, the translation formula is easy, but the part that confused me was thinking in terms of “is this address even valid?” before doing anything else. Segmentation added even more mental juggling because now the virtual address has to be decoded into a segment number and an offset. I had to stop a few times and redraw the diagrams just to keep everything straight. Still, it helped me understand why internal fragmentation becomes a problem and why segmentation was invented to improve memory efficiency.

My “aha” moment came when segmentation finally made sense. Realizing that the OS can place the code, heap, and stack in totally different areas of physical memory made me see how much flexibility this gives compared to the single contiguous space used in base and bounds. It felt like the picture zoomed out and I could understand why this approach reduces wasted space.

Something I keep wondering is how paging will solve the remaining issues. I know it gets rid of external fragmentation and allows very flexible placement of memory, but I want to see how the translation works in practice and how the TLB fits into the picture. It feels like the next step will combine everything we learned into a system that is both efficient and practical.

Overall, these topics connect to things I learned before in computer architecture, especially the stack frame, the heap, and how pointers work. But now everything feels more concrete. I can finally see how the OS enforces protection, how it keeps different processes separate, and how memory is treated as a shared but carefully controlled resource. This week was challenging, but it also made everything feel more real.