DEV Community: hassaan-syed

do you know what exactly startup code does ?

hassaan-syed — Fri, 26 Jun 2026 17:03:21 +0000

let me explain what happens before the main()

Most C programmers believe that a program starts executing from the main() function. Surprisingly, that is not true. Before main() is ever called, another piece of code runs automatically. This hidden code is known as startup code.

Startup code is provided by the compiler and the C library(runtime). Although programmers never write it themselves, every C program depends on it. Its job is simple but essential—it prepares the program so that main() can execute correctly.

The first thing startup code does is initialize memory. It loads the values of initialized global and static variables into memory and clears the "_uninitialized variables by setting them to zero. _".This ensures that every global and static variable begins with the correct value.

Next, startup code prepares the execution environment. It sets up the stack, initializes the runtime library, and, in operating systems like Linux and Windows, prepares the command-line arguments (argc and argv) that are passed to the main() function.
like:

#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("Number of arguments = %d\n", argc);

    for (int i = 0; i < argc; i++)
    {
        printf("argv[%d] = %s\n", i, argv[i]);
    }

    return 0;
}

Once everything is ready, startup code transfers control to main(), where the programmer's code finally begins execution. When main() finishes, startup code performs the final cleanup by calling the necessary exit routines and returning the program's exit status(collects the value and check either succseed or failed) to the operating system.

The execution flow of a C program can be summarized as follows:

Program Starts
      ↓
Startup Code
      ↓
Initialize Memory
      ↓
Setup Runtime Environment
      ↓
Call main()
      ↓
Cleanup and Exit

Although startup code remains invisible to most programmers, it is one of the most important parts of a C program. Without it, the program would not have a properly initialized memory or execution environment, making reliable execution impossible. Understanding startup code gives us a clearer picture of what really happens before our own code begins to run.

Can We See the Source Code of Startup Code ?

Why Your Computer Reads Numbers Backwards: Byte Order

hassaan-syed — Sat, 16 May 2026 16:24:20 +0000

What is Byte Order?

Before understanding byte order, we need to understand one thing:

A byte = 8 bits

Many data types use multiple bytes.

For example:

Data Type   Size
char           1 byte
short          2 bytes
int            4 bytes
long long      8 bytes

When a number takes multiple bytes, the computer has to decide:

“In what order should I store these bytes in memory?”

That storage order is called:

Byte Order (Endianness)
1.little order endian
2.big order endian

Most people assume memory stores it like this:

12 34 56 78

But here comes the surprise…

On many computers, it is actually stored like this:

78 56 34 12

Wait… what?

Did the computer reverse the number?

No. Your computer is not confused — this behavior is called Byte Order, also known as Endianness.

In this article, we’ll understand byte order from scratch using diagrams, memory examples, and a practical C program.

*Understanding With an Example
*
Let’s take this hexadecimal number:

0x12345678

This number contains 4 bytes:

12 34 56 78

Now imagine memory locations like this:

Address → 1000 1001 1002 1003

The question is:

Which byte should be placed first?

This is where endianness comes in.

Type 1: Little Endian

In Little Endian, the smallest byte (Least Significant Byte) comes first.

Memory stores:


Address →   1000   1001   1002   1003
Data    →    78      56      34      12

Here:

78 is stored first
12 is stored last

This may look backward, but internally it helps processors perform arithmetic efficiently.

Why is it called “Little” Endian?

Because the little end (least significant byte) is stored first.

Type 2: Big Endian

In Big Endian, the largest byte (Most Significant Byte) comes first.

Memory stores:


Address →   1000   1001   1002   1003
Data    →    12      34      56      78

This looks more natural because humans usually read numbers from left to right.

Why is it called “Big” Endian?

Because the big end (most significant byte) comes first.

Visual Comparison
Number = 0x12345678


Little Endian
┌───────┬───────┬───────┬───────┐
│  78   │  56   │  34   │  12   │
└───────┴───────┴───────┴───────┘
 1000    1001    1002    1003


Big Endian
┌───────┬───────┬───────┬───────┐
│  12   │  34   │  56   │  78   │
└───────┴───────┴───────┴───────┘
 1000    1001    1002    1003

can I know why we want these endian orders ?

Why 0.1 + 0.2 != 0.3 in C? Understanding Floating Point Numbers

hassaan-syed — Sun, 05 Apr 2026 16:46:23 +0000

HISTORY:IEEE 754 was invented in 1985 to standardize floating-point arithmetic, ensuring consistent, reliable, and portable numerical results across different computer hardware.

#include <stdio.h>

int main() {
    float a = 0.1;
    float b = 0.2;

    if (a + b == 0.3)
        printf("Equal\n");
    else
        printf("Not Equal\n");

    return 0;
}

WHAT DO YOU EXPECT?
Eqaul or Not Equal,If Equal then your wrong because,
computer dont know the . as a decimal so for that we usedb IEEE754 standard for better uderstanding the real problem let us do by example.

Computers don’t understand numbers like we do.
We use decimal (base 10):
0.1 → one tenth

But computers use binary (base 2):
0s and 1s only

Now here’s the catch:
Some decimal numbers cannot be represented exactly in binary

Just like:
1/3 = 0.3333... (infinite in decimal)

Similarly:
0.1 in binary = 0.0001100110011... (infinite)

then,What is actaully stored in computer
like eg : float 0.1
it stores the nearest approx value
like : 0.10000000149011612 (in binary)

WE CAN PROVE BY CODING

#include <stdio.h>

int main() {
    float a = 0.1;
    float b = 0.2;

    printf("%.20f\n", a);
    printf("%.20f\n", b);
    printf("%.20f\n", a + b);

    return 0;
}

OUTPUT
0.10000000149011611938 0.20000000298023223877 0.30000001192092895508

NOW,lets understand how really its stores in binary so called "Format"
its is simple its stores in 4bytes
this bytes are divided into fixed paths we call as:
1.sign

2.exponent
3.mantisa

this are actaully important so keep in mind

Sign (S)
Decides whether the number is positive or negative
Uses 1 bit only
0 → Positive (+)
1 → Negative (−)

Example:
+5.2 → Sign = 0
-5.2 → Sign = 1

Exponent (E)
Controls the scale (magnitude) of the number
Think of it like moving the decimal point

“How big or how small is the number?”
Higher exponent → Bigger number

Lower exponent → Smaller number

Example idea:
1.23 × 10³ = 1230 (big)
1.23 × 10⁻³ = 0.00123 (small)

In binary, the exponent does the same job.

Fraction / Mantissa (F)
Stores the actual digits (precision) of the number
This is the main value part.

“What are the exact digits of the number?”
More fraction bits → More accuracy

Less fraction bits → Less accuracy

let me ask something?
do you know what is sign copy if yes comment please

THANK YOU FOR READING
"Take it from me that all knowledge is useless until it is connected with your life, because the purpose of knowledge is nothing but to show you the splendors of yourself!"

What’s Inside Your .o File? A Beginner-Friendly Guide to the Linux nm Command

hassaan-syed — Fri, 20 Feb 2026 05:51:13 +0000

What Is the nm Command?
nm is a Linux command that shows the symbols from symbol table of an object file or executable.

In simple words:
nm tells you what functions and variables exist inside a compiled file.

It is commonly used after compilation to inspect what got created inside the object file.

nm file.o

what is symbol?
A symbol is simply a name that represents something in your program.A symbol in C programming is simply the name of a function or global variable that the compiler records inside a compiled file so that the linker and other parts of the system can identify and connect different pieces of code together

That “something” is usually:

A function
A global variable

Symbol table

| Symbol | Meaning       | Simple Explanation            |
| ------ | ------------- | ----------------------------- |
| T      | Text (global) | Global function               |
| t      | Text (local)  | Static function               |
| D      | Data (global) | Global initialized variable   |
| d      | Data (local)  | Static initialized variable   |
| B      | BSS (global)  | Global uninitialized variable |
| b      | BSS (local)   | Static uninitialized variable |
| U      | Undefined     | Used but defined elsewhere    |

each section meaning

Text (.text) → Stores functions (code)
*Data *(.data) → Stores initialized variables
*BSS *(.bss) → Stores uninitialized variables
*Undefined *(U) → Function exists, but defined somewhere else

Memory Layout :

lets under stand by example

#include <stdio.h>

// Global variable
int global_var = 10;

// Static global variable
static int static_var = 20;

// Global function
void global_function() {
    printf("Inside global function\n");
}

// Static function
static void static_function() {
    printf("Inside static function\n");
}

int main() {
    global_function();
    static_function();
    return 0;
}

compilation stages:
step 1 "compile into object file"
gcc -c file.c
~This file.o is created

step 2 "nm command"
nm file.o
~you can might see someting like this

OUTPUT:
0000000000000000 T global_function 0000000000000000 T main 0000000000000000 t static_function 0000000000000000 D global_var 0000000000000000 d static_var U printf

Important Note for Beginners
✔️ Global variables → become symbols
✔️ Functions → become symbols
❌ Local variables inside functions → usually NOT symbols
ex:
void func() { int x = 10; // Not a symbol (local) }
x is temporary and does not appear in nm.

why local variable are not in output?

Local variables are not shown in nm because they are not needed for linking. The purpose of the symbol table (the one nm shows) is to help the linker connect different files together, and local variables do not participate in that process.Its exists only inside its function, lives temporarily on the stack segment

Understanding strlen() Internally by Writing It From Scratch in C

hassaan-syed — Fri, 06 Feb 2026 07:04:42 +0000

Let us understand the internal concept of strlen().

strlen() is a predefined function which is used to know the length of a given string.

Syntax of strlen:
strlen(variable_name);

Example:
char str[6] = "hello"; // here length = 5

char str[6] = "hello";
strlen(str);   // Output: 5

strlen(str);

Firstly, what is a string?

In C, a string is not a data type.
A string is a collection of characters which always ends with a special character '\0', also known as the null character.

This null character indicates the end of the string.
It does not mean “nothing in memory”, but it tells functions where the string stops.

Header file information:
There are some library files which include many function declarations to perform different tasks.
Here, we are learning about the strlen() function, which comes under the <string.h> header file.

Let us start from scratch — how strlen() works internally.

Prototype of strlen:

int my_strlen(const char *str);

Explanation:
int → return type (returns length of string)
my_strlen → function name
const char *str →

char * is a character pointer which stores the base address of the string
const is used so that the value of the string cannot be modified inside the function (this helps avoid bugs)
str is the variable name (kept meaningful and relatable)

code:

int my_strlen(const char *str)
{
    int cnt = 0;
    while (str[cnt] != '\0')
    {
        cnt++;
    }
    return cnt;
}

We use a pointer to traverse the string from one character to another while counting.

How this works step by step:

When we pass the argument:
my_strlen(str);
-The base address of the string is passed to the function.

Counter initialization:
-Here, cnt is an integer variable used to count the number of characters in the string.

While loop condition:
-We know that every string ends with the null character '\0'.
So the loop runs until '\0' is encountered.
-Although we are using str[cnt], internally this works using pointer arithmetic.

Incrementing the counter:
-Each increment moves to the next character of the string and increases the count.

Memory Representation:

Loop termination:
When str[cnt] becomes '\0':

The condition becomes false
The while loop terminates
The function returns the value of cnt

THIS IS MY MY_STRING.H(project)
Full code on GitHub: my_string.h

Why does it return the length of the string?

Because:

Every character is counted
The null character '\0' is not counted
Counting stops exactly at the end of the string

Final understanding:

By writing strlen() from scratch, I understood:

How strings are stored in memory
Why the null character is important
How string traversal works internally in C