DEV Community: joyeta jahan

The Blueprint Analogy: Why Your Variables Don't Actually Exist in Your Hard Drive

joyeta jahan — Mon, 06 Jul 2026 09:50:50 +0000

Notes

Variable: a small space in computer's RAM that is assigned to a single piece of data. But a variable can only hold a single type of data. It's like a packet that can contain one snicker or one mars chocolate or one Reese's peanut butter cup.
When we create a variable we take a specific chunk of RAM and name that chunk on the name of the variable. For example if there is a large container of chocolate, then we take one section, name it "Snickers" and now it can only contain snickers
The size of the chunk depends on what type of data is stored inside the variable. Therefore that memory space holds that data / that type of data unless we delete the variable / close our after which computer assigns the same space to a different variable since computer RAM is limited.
Data type / type is what type of data is stored inside a variable (is it a number, a character, a string aka words / sentences; string is called such because a word or a sentence is basically a string of characters)
Inside our RAM there are these black chips that contain the transistors (tiny switches that turn on or off by the computer itself and each switch stands for a single bit aka binary digit aka 0 which means off and 1 which means on). Computer groups these transistors in a group of 8 therefore 8 bits = 1 byte.
When we write a variable then it takes up the specific space for the data type we set it on like an int takes up 4 bytes aka 32 transistors.
Usually, even though the transistors might be neatly stacked in a grid inside the RAM, so to human eyes the computer memory might be shaped like a grid, for a computer it is a continuous horizontal line. Not a grid
When we run a program or give computer any command computer takes the binary of our source code (done in the assembling and linking process of compilation) or any command we give (like open a new tab in browser) and turns of the switches / transistors according to our code and executes it thereof THEN turns that into human language and shows us the result.
Floating point imprecision is when there is a imperfection in any floating point number represented by the computer. It happens due to the rounding rule (if we cut off after certain number of digits after a floating point and the next number is 5 or more we MUST add 1 to the last number). This happens becuase a float variable only can have a finite amount of space and if we do a math like 10 / 3 then the result is forever 3.33333…… so just like when we are writing in paper we need to cut it off at some point cause we have finite amount of pages, the computer has to cut off the digits after it takes up more space than 4 bytes of transistors because that is the space allocated to a float (decided many years ago by some humans)

Insight

Fun fact I found during my questions with AI session for today (15th June, 2026): Variables only ever exist in RAM. NEVER in Harddisk. When we write a program and write stuff like int a = 0; the computer does not allocate ANY space to it unless we actually run the program. A good analogy Gemini gave me was our source code is like the blueprint of a 10x10 house, it sits on our shelves but DOES not occupy any space in our land unless we build the house itself. And when the program running is over, the variable get rewritten aka the house is demolished and another house gets rebuild in the memory space (so THAT is why we get garbage values from!!! And also why we always keep saying that the memory is extremely finite even when we have 512 GB of SSD on laptops alone these days, the space doesn’t get allocated in the hard disk, ONLY in RAM!!!)

Questions

floating point imprecision
a string size depends on how my chars are inside it. But isn't that a memory issue? Plus if computer can't compare a char to another char and we can't perform conditionals on it then how come it knows how many characters are in a string aka how can it count that?
if a program has thousands of bools as a data type, isn't that a huge wastage of memory? Cause at the end of the day, 7 bits of it are wasted.
Even if there are lots of transistors in a RAM the amount of instructions we give to a computer per second is a lot, then does that mean the transistors are changing their on and off position every second?
Round 2
Okay floating point imprecision also happens in calculators no? Give me an example of a floating point imprecision in programming. And does my program automatically follow arithmetic rules for cutting out a number for example if the next number in the floating point is 5 or more then we have to add 1 to the last number we're cutting out from (is THAT why these imprecisions happen? Like if someone asks to cut the number after 2 digits after the floating point and someone asks for say 5 digits... then it will be different no?)
Okay let me rephrase my second question. A compiler at least a C compiler really can't compare a string then how does it actually count how many charachters are inside the string and what do you mean it crashes into other data? Shouldn't it crash beforehand? For example, if I write a program that takes name of a user and prints it... Then how does computer allocate any space for printf if it doesn't know how long my string is going to be? It is bound to crash in the first place no? Computers can't guess
You said variable lives in RAM, but our program itself lives in the hard disk if we don't run it, then at some point, doesn't variable sit in the hard disk too?
Okay what do we mean by variable "expiring" after C executes programs? They are not parmanent labels for a chunk of memory?
Round 3
Okay so we will get floating point imprecision everytime we or the computer has to cut of a floating point number and it happens because of rounding number rule. In that case, does it vary from editor to editor or machine to machine because every machine can be slightly different? Like does the same code produce slightly different result in a local VS Code setup and say... VS Code for CS50?
Okay will the string thing be cleared up in the later weeks of cs50 like memory? Cause right now I feel i am biting more than I can chew..
Fun fact I found during my questions with AI session for today: Variables only ever exist in RAM. NEVER in Harddisk. When we write a program and write stuff like int a = 0; the computer does not allocate ANY space to it unless we actually run the program. A good analogy Gemini gave me was our source code is like the blueprint of a 10x10 house, it sits on our shelves but DOES not occupy any space in our land unless we build the house itself. And when the program running is over, the variable get rewritten aka the house is demolished and another house gets rebuild in the memory space (so THAT is why we get garbage values from!!!)

P.S. Honest confession - I don't know if I have mentioned this in my notes but the blueprint analogy is actually given to my by the AI. It was NOT made up by me. There is a small chance that I came up with this but I can't remember so thought it should be mentioned.

Why the Hell Are There So Many Layers? Breaking Down the 4 Steps of C Compilation

joyeta jahan — Mon, 06 Jul 2026 09:38:02 +0000

Notes:

Prototype : a line that promises to a compiler that a certain function exists somewhere in the server or harddisk or files so it doesn't throw an error. In C, it is done with copying the declaration line of a function and adding a semicolon at the end of it.
When we download / setup a specific programming language we download:
- the specific version of the language's compiler for your operating system and CPU
- the version of machine code of standard functions that the creator of the language has written that is fine tuned for our operating system and CPU
- the header files that has Only the prototype of the standard functions (aka functions like printf that are created by the creator of C)
We need these in the compilation process:
- Pre-processing: compiler changing the header files calling line (#include line) with actual prototypes that are inside the header files and creates a temporary file with .i extension (temporary cause it gets deleted in the next step) that contains the prototype at the very top instead of #include line and your source code below
- compilation: compiler changes the entire contents of the .I file into assembly code (code written in assembly language). Here is why the specific version of compiler is important because every CPU has specific assembly language commands that are unique to it. Therefore when we setup a language we download specific assembly instructions for our own operating system and it comes handy in this step. Syntax check also happens in this step and the .I file also gets deleted. Now there comes a a.out file that we can actually see listed in our file explorer (but we only see the a.out file after the very end of compilation process but it does exist by this stage)
- Assembling: compiler changes assembly code (a.out file) to machine code (aka 0's and 1's).
- linking: compiler links your machine code and the machine code FOR the standard functions (because till now it ONLY has the prototypes of the function written in Binary, not the actual binary code for function itself, those are the downloaded files hidden deep inside the system)
- This complication process is detailed but specific to C. Other languages might have slightly different compilation process / interpreted languages have completely different process.

Insights

Fun fact: if we have multiple source code files then we don't get multiple a.out files. The compiler just rewrites the current a.out file. So if we have two files (let’s say fileA.c and fileB.c, we run compiler once for fileA then we get an a.out file. But when we compile fileB we don’t get a new a.out file or anything, just the current ones contents changes)

Questions I asked my AI to learn these

Decided to add a "Questions I asked my AI" to get some feedback on if these are the type of questions I should ask my AI. And yes I really do ask these long questions, I copied and pasted my Gemini chats questions here

David J. Malan said that that header files contain prototypes of the functions, but then where do the acutal functions live?
Prototype of a function = it is just the naming line of the function copy pasted so that the compiler knows there is a function with this name that exists (but that is for C, cause it works from top to bottom. But how is it for other languages)
Compiling = Preprocessing + Compilling + Assembling + Linking (It isn’t just translate source code to machine code)
Preprocessing = Computer chaging the header files line in your source code and replacing them with the prototype of the functions you use from that header file (for example, if I include “stdio.h” in my code and use the function printf the compiler actually goes into the server / hard drive wherever that header file is, then copies the prototype line for printf function into my source code. So now your source code will have the code you have written and at the very top it will have protoype of all the functions you have used aka a promise to the compiler that the functions you have used actually exists so to not stop execution) But then…. why don’t we see the change in my source code file? Also every compiler has a different assembly instruction for the CPU according to David, so basically we download different softwares and stuff for different programming languages so that the compiler understands the assembly version of my code?
Also every compiler has a different assembly instruction for the CPU according to David, so basically we download different softwares and stuff for different programming languages so that the compiler understands the assembly version of my code?
Compiling: Actually what compiling really means is turning your source code into assembly code (code written in assembly language). This step also pushes out a file named a.out mentioned previously cause it just stands for assembly output.
Assembling: Turning the assembly code into machine code (aka binary code aka 0’s and 1’s)
Linking: In the same harddisk / server or a different server stays a file that is completely machine code and it ACTUALLY contains the functions code you used (for example printf, the header file only has the prototype, NOT the actual code). So in the last step, the compiler links your source code’s machine code and links any other external machine code it needs (for example if you have used printf then it is an external command cause you haven’t actually written it, the creators of C did) and links all these 0’s and 1’s to finally execute your code. (Why are these files that actually contain the code for a function written in machine code, and not the programming language itself, why is there no source file? Computer can just turn them into 0’s and 1’s along with mine. Where do these actual source code file live? In the linking process does the compiler link ONLY the function I need or the whole file and only the parts I need gets executed?)
Computer can just turn the external functions into 0’s and 1’s along with mine. Where do these actual source code file live? In the linking process does the compiler link ONLY the function I need or the whole file and only the parts I need gets executed?)
In which step does the sytax check happens?
In languages that are interpreted rather than compiled is the syntax checking or compiling process any different cause an interpreter actually reads a line, executes it, then reads another line then executes it, unlike compiler that does all of it in one go?
Why the hell are there SO MANY LAYERS????

The Secret Life of Garbage Values, Docker Containers, and a.out

joyeta jahan — Mon, 06 Jul 2026 09:24:41 +0000

Notes

Notes and insights from lecture Array in CS50

Garbage variable: the default value of a variable before we initialize it (aka manually set a value to our declared variable). It gets the default value from previous variable that was stored in the same places (aka same bits) in the computer RAM your variable stays now. So for example, if I declare a variable called X, don’t initialize it then computer gives it a default value but that value comes from a previous variable (let’s say Y) that occupied the same space in the memory as your variable now (much like if we rent a house and there are some stuff leftover by the previous tenant, when we enter we clean it, throw everything out).
Break point: A point we add in our code literally when we use cs50 debugger. In technical term, it is a point where debugger actually stops the CPU from executing a line of code
local variables: the variables that are only available and exist within a limited scope of a program (for example in C, it is the variables inside the curly braces of a function so if we declare a variable in a function but then call the same variable in a different function the compiler will throw an error)
open source: the code that is written by somebody else but is open to use for other programmers and developers without any cost and even allowed to update it in our own computer and make our sort of custom made software (though we need the creators permission called a pull request if we need to make change in THEIR code and want everyone who downloads it afterwards has your custom made version)
command line: aka the terminal aka the text based interface where we write commands (don’t know the under the hood or technical definition of it)
command: the commands we write to make the computer do something (text equivalanet of clicking on a button)
command line argument: the extra inputs we write with the commands

Insight

Something interesting about garbage values. If you declare a variable then it gets the value of the previous variable that occupied the same memory space as a different variable. However, while doing CS50 I noticed that if we declare a variable and wait for user input in a variable called “h”, it has a default value sure, then the user assigns it a number, but if we close the program and run it again, it does not show the user variable as default value, it shows another large random number. Here is why, in a local setting (while developing a program locally), the computer memory gets reallocated again and again so if there is even a milisecond difference between the first time I run my program and the second time I run it then the space has already been allocated to some other program or software running in the background and when I run it again I see another garbage value. Also modern operating systems do something called ASLR or something which means my variable does not get allocated the same space in the memory twice, so it always has a default garbage value before my program actually initializes it manually. Interesting! But because CS50 cloud is ran in an controlled environment the same garbage value can reappeare again and again since everything in running on something called docker container which contains…. everything of your program I think.
If I click on step into for a line that is calling a function then it goes to the actual function aka debug the function itself but if I click on step into for a line of code that is NOT calling a funciton then it is just going to act like “step over” aka execute and go to next line in CS50 Debugger
If I have a breakpoint in the code but don’t use the debugger, just run it as it is then the compiler won’t throw an error
CS50 Debugging list to use in order: printf, speaking to an actual rubber duck, debug50 and finally cs50 rubber duck AI
When I use clang hello.c command in the terminal of vscode cs50 then it creates a file a.out. However I thought since I had two files (hello and buggy) then what happens if I compile the other file buggy.c? Cause David said clang only creates the execution file named a.out. So if I compile two files then does it create 2 .out files? Turns out, no. It doesn’t. It just changes the contents of the a.out aka where before it had the machine code for my hello.c file now it had the machine code version of buggy file. There were never two a.out files.

The Illusion of Erasure: What \b, \r, and \n Actually Do to Your Screen

joyeta jahan — Mon, 06 Jul 2026 09:09:30 +0000

Notes

Notes and insights I found from playing around with \b, \r and \n for a small timer I was trying to build by myself (without AI help, unless searching syntax counts)

Compile: Translate source code (the code written in the programming language) to machine code (0’s and 1’s aka binary aka the only language a computer actually understands)
Runtime: From the point we open a program to the point of it closing / doing everything it’s suppossed to do
\n means move the cursor to the next line. \r is move the cursor to the very first space of the current line. \b is move the cursor back by one space. NONE of it ever actually deletes, pulls or moves the text written on the screen. Once it’s there it is TOTALLY there. If we write a code like:

#include <stdio.h>

int main (void)
{
    printf ("Hello Alexa\b\n");
}

The result is something like this:

Hello Alexa

The program prints out Hello, Alexa; then the cursor sits on top of “a” (\b means go back a space) but when you give the command \n it doesn’t move the “a” to the next line, only the cursor goes to next line. It CAN NOT drag a with it to the new line. The printed lines are kinda stuck on the screen. Same happens if we type \r. It doesn’t erase ANYTHING. It moves the cursor to “H” and when \n comes it just moves the CURSOR to the next line, “H” stays in the same place.

The only way we can give an illusion of erasure is if we do something called “Overwrite it”. For example:

#include <stdio.h>

int main (void)
{
    printf ("Hello World\r");
    printf ("B");
}

The result will be:

Bello World // The cursor moves to "H" and then overwrites it aka write a "B" over the H
// The computer has no more memory of the "H" there on the screen. It is deleted.

If we do the same with \b instead of \r then we’ll see the result “Hello WorlB”.

However the compiler can read the spaces between the words you wanna type and the backslash commands. For example if you type:

#include <stdio.h>

int main (void)
{
    printf ("Hello World \b");
    printf ("B");
}

The result will be:

Hello WorldB

Because first we

print out Hello World (with a space).
when there is a \b the cursor comes right beside the letter “d”
it prints the letter “B”

Compiler can even read the spaces between two backslash commands for example if you type \r space \n, then the compiler will act accordingly. Even your spaces matter when using these.

Decoding Compiler Confusion: Why the error messages of C are so confusing

joyeta jahan — Mon, 06 Jul 2026 08:48:29 +0000

Note: These notes, insights and questions are from my CS50 journey (lecture 2: Array)

Notes:

Syntax: Rules specific to a programming language that we need to follow if we want to write code in that programming language (aka give the computer instructions)
Bugs: Mistakes in code
Syntax error: The message compiler (the software that turns programming instructions into machine code aka 0’s and 1’s) throws if the coder has broken any syntax rules of the programming language
Error: The message compiler throws when something is wrong with the syntax
Logical error: An error (techincally bug) where the program runs (aka the compiler doesn’t throw an error) however it still does not behave the way it should.

Questions and Insights:

What happens if I add cs50 get_string function taking a string input from a user to an int variable? - throws an error (incompatiable pointer type)
If I have only stdio file as header file but call a function from a different file then the compiler throws a weird error. It looks for the most similar looking function (according to the name of the called function) in the header file mentioned (stdio) and says maybe you meant this…? In that case the compiler will not tell you straightforward what mistake you made cause it does not know if you meant to call another function from another file. It doesn’t know the other function even exists. So it looks for the closest looking functino however still throws the unindentifier error. That should be a tell.

To sum up, C errors are confusing because it never really tells you what you did wrong, it only tells what it is missing in order to execute a line of code and that can seem cryptic sometimes

Letter 0: Who is this blog for?

joyeta jahan — Wed, 28 Jan 2026 13:23:33 +0000

Dear Reader,

This blog is not for anyone who has experience with programming. I am just starting out on my journey to that destination. So this is more like a record of what I am learning. You’ll see me posting about things I have learned or discovered in my coding journey, however big or small.

My posts are by no means a finished polished source of information teaching someone how to code. I wouldn't even call it a source of information at this stage. It's more like me thinking out loud on the digital paper of my blog.
Therefore due to this and since I am a novice myself, please do not take my posts as a reliable source of information if you’re starting your coding journey and use other sources. On the contrary, if you’re someone with experience I invite you to offer any feedback if you see any loopholes in my logic. Thank you in advance for any feedback.

I might also share about other skills I learned besides programming. I am not a content creator by any means hence excuse me for not regularly posting on this blog.

Everyday Programmer