the BSS (uninitialized data) segment
/ B-S-S /
Suppose your recipe needs three empty mixing bowls. You do not write down what is in them, because they start empty; you just need to know to set aside three bowls. The BSS segment is the part of a process's memory reserved for global and static variables that start out as zero. The program does not need to store any values for them in the executable, only the knowledge of how much space to reserve and zero out at startup.
The name BSS is an old assembler term ('block started by symbol') and the meaning has drifted, so treat it just as a label for the uninitialized-data region. When the OS loads the program, it reserves a block of memory for the BSS and fills it with zeros before the program runs. Because the values are all zero, nothing has to be saved on disk for them, which is why a program declaring a huge zero-filled array does not produce a huge executable file. The BSS is read-write, like the data segment, and the program can change these variables freely as it runs.
Understanding the BSS clears up a frequent surprise: why a program with a giant global array compiles to a small file. The array lives in the BSS, stored as 'reserve N bytes, set to zero', not as N bytes of actual data. In languages like C, this is also why uninitialized globals are guaranteed to start at zero (the OS zeroes the BSS), whereas uninitialized local variables on the stack are not zeroed and hold whatever garbage was there before.
Declaring 'static char buffer[1000000];' adds a megabyte to the BSS (reserved and zeroed at startup) but adds almost nothing to the executable file, because no values are stored, only the size.
Zero-filled space costs file size nothing; only its size is recorded.
Only globals and statics get zeroed via the BSS. Uninitialized local variables on the stack are not zeroed and contain leftover garbage, a frequent source of bugs.