DEV Community: Bimsara

Programming foundation - data types at bit level

Bimsara — Sat, 07 Mar 2026 22:10:37 +0000

welcome to this sub article,in here I'm going to talk about data types for little deeper,

Okay,computers store data as 1 and 0 , we call them 'bit'.when we define data type as int,float etc. we define how much bits that value need,

int

this can be either 16 bits or 32 bits depending on the system meaning when we store a value as a int,memory will allocate 16 or 32 bits for that value

eg: int age=25

if we convert 25 into bits

Division	Quotient	Remainder
25 ÷ 2	12	1
12 ÷ 2	6	0
6 ÷ 2	3	0
3 ÷ 2	1	1
1 ÷ 2	0	1

Reading the remainders from bottom to top gives us 11001.

So 25 is stored as:

16-bit: 00000000 00011001
32-bit: 00000000 00000000 00000000 00011001

float

this is for storing decimal numbers and float data type will allocate 32 bits in memory
1 bit for sign bit
8 bits for exponent
23 bits for Mantissa

eg: float a= 20.5

let's represent this in bits
first the 20

Division	Quotient	Remainder
20 ÷ 2	10	0
10 ÷ 2	5	0
5 ÷ 2	2	1
2 ÷ 2	1	0
1 ÷ 2	0	1

20 => 10100

then .5

Multiplication	result	Integer
0.5 × 2	1.0	1

.5 => .1

so the binary representation of 20.5 will be

      10100.1

BUT,we can't store '.' in computer,WHY? computer store only 1 and 0s,computer don't now What The Fish is '.', so we need to normalize it

Normalization

if we want to find the origin of Normalization we have to looked at some scientific maths (don't worry it's not scary...)

Scientists work with extremely large or small values:

Distance to sun = 150,000,000,000 meters
Size of an atom = 0.000000000100 meters
Mass of electron = 0.000000000000000000000000000000911 kg

Soo, scientist determined to find a compact, error-free way to write numbers, and that is the normalization

in normalization, instead of writing the whole value, we write it like this:

Size of an atom = 1.0 × 10⁻¹⁰

This was called Normalized Scientific Notation . and they made a rule always exactly 1 non-zero digit before the dot

Then,The Computers arrived!!!

and computer have no idea about how to store a decimal number ,when it was given 20.5, and it stored 205.see the problem?why?because it doesn't know how to store a '.',computer only knows about 1s and 0s.

As a solution, scientist thought "let's do the same thing that we did on paper,let's use normalization for the computer" (idk they actually said that,just guessing).

let's see how does computer store 20.5 with help of the normalization

first,when we give 20.5 to computer,it take that number as two parts, integer part (20) and fraction part (.5). then convert them into binary

20 => 10100
5 => 1

after that,computer find the first 1 from left side in integer part which we define as left most bit . in here it is the first bit from left side.

10100.1 =>1.01001

then computer count how many bits are there after the left most bit . in here it is 4.

and that leading bit is hidden and not stored in memory,why? because we exactly now the leading bit is always 1 cannot be 0 or else because this method follow the rule always exactly 1 non-zero digit before the dot in normalization.since computer have only 1 and 0,the non-zero digit will always 1.so storing it will be waste of memory.

in normalization process we shifted 4 places,so the exponent is 4 , and Mantissa is 01001

then computer add bias 127 (IEEE 754 standard) to that exponent,so now exponent will be:

127+4=131=>10000011

after that, assemble the fraction part(1) with these,so the final result is:

0 10000011 01001000000000000000000

okay,that's how float data type works,but it has limitation,that is it can only store 32 bits values;

1 bit for sign bit
8 bits for exponent
24 (23 + hidden bit) bits for Mantissa

23 bits can generate 8,388,608 combinations (2²³),so it can only hold roughly 7 decimal digits of precision, what if we want to store a number with 8 or more precision, then we have to use double data type

double

this work as same as float data type but this provide 64 bits instead of 32

1 bit for sign bit
11 bits for exponent
52 bits for Mantissa

so it can generate roughly 9,007,199,254,740,991 combinations which mean it can hold up to 16 decimal digits of precision

Now you understand what's actually happening inside int, float, and double at the hardware level — and why choosing the right data type matters.

Thank you for reading this far — it genuinely means a lot. I'm still learning and growing as a writer, and your time and support make that journey worthwhile. I hope this gave you something useful to carry forward.Happy Coding 🖥️

Programming Foundation with C — Article 1: Variables, Data Types & Arrays

Bimsara — Fri, 06 Mar 2026 16:20:22 +0000

Welcome to the first article in my "Programming Foundation with C" series.
Before we start writing C code, there are three core concepts you need to understand. Master these and the rest of programming starts to make sense:

Variables
Data Types
Arrays

Let's get into it.

1. Variables

When you write a program, you almost always need to work with values — names, numbers, scores, ages, whatever. Those values need to live somewhere while your program is running. That somewhere is your computer's memory — the RAM.
A variable is just a named location in that memory. You give it a name so you can find it and use it later.

Here's the simplest example:

#include <stdio.h>

int main() {
    int age = 25;
    printf("%d", age);
    return 0;
}

This program stores the number 25 in memory, labels that location age, and prints it. That's it. Clean and simple.

Naming Rules (you must follow these)

Cannot start with a number → 1name ❌
Cannot contain spaces → my age ❌
Cannot be a reserved word → int, for, while ❌

Best Practices (you should follow these)

Use meaningful names → age is better than a
Use camelCase or snake_case → userName or user_name

2. Data Types

When you create a variable, you also have to tell the computer what kind of value you're storing. Is it a whole number? A decimal? A single character? That's what data types are for.
C is strict about this — you can't just throw any value into any variable. You have to declare the type upfront.

The Core Data Types

Type	What it stores	Example
int	Whole numbers	25, -7, 1000
float	Decimal numbers (single precision)	.14, -0.5
double	Decimal numbers (double precision)	.14,-0.5
char	A single character	'A', 'z', '3'

double - if we want to store values that can have more than 7 decimal points, we should use

int score = 100;
float temperature = 36.6;
char grade = 'A';

Quick summary: A variable has three things — a type, a name, and a value. Always define all three clearly.
click here if you want to go little bit deeper in data types

3. Arrays

So far we've stored one value per variable. But what if you need to store a list of values — like a full squad of operators?
That's where arrays come in.
An array is a collection of values grouped under one variable name. Each value has an index (its position in the list), starting from 0.

char team[] = {"Price", "Soap", "Gaz", "Ghost"};

(Yeah, if you know these guys — you're a real one. And yes, they ruined it.)

Accessing values by index:

team[0]  // "Price"
team[1]  // "Soap"
team[2]  // "Gaz"
team[3]  // "Ghost"

⚠️ Note: In most cases, arrays hold values of the same data type. A list of integers, a list of characters — not a mix.

Wrapping Up
You now know the three building blocks that almost every program is built from:

Variables — named locations in memory that hold values
Data Types — define what kind of value a variable holds
Arrays — group multiple values under one name

These aren't just C concepts — they exist in every programming language. Learning them in C means you're learning them properly, from the ground up.

Next article, we'll go deeper. Stay tuned.

If you found this helpful — or if I got something wrong — drop a comment. Whether you're a beginner or a veteran, I want to hear from you.
Happy coding. 🖥️