DEV Community: Hossein Naseri

How Does File Compression Work?

Hossein Naseri — Sun, 14 Jun 2026 13:26:08 +0000

How Does File Compression Work?

Compression is a way to reduce a file's size.

To understand it, imagine you're asked to count the cars in a parking lot.

You could report:

a BMW

a BENZ

a BMW

a FORD

a BMW

a FORD

Or, if you wanted to send the shortest report possible, you could simply say:

3 BMW

2 BENZ

2 FORD

It's the same information, but it takes less space.

That's the basic idea behind many compression techniques: find repeating patterns and store them more efficiently.

Every file on your phone or computer is ultimately stored as a long sequence of tiny ON and OFF states, usually represented as 0s and 1s.
For example:

000000111111111010100000100000010010000001010111111111

Instead of storing every digit individually, the computer can look for repeated patterns.

For example:

becomes

5 zeros

and

becomes

5 ones

So our data could be represented like this:

(6 zeros)(8 ones)0101(5 zeros)1(6 zeros)1001(6 zeros)1010(8 ones)

Or, if we represented those 0s and 1s visually, it might look something like this:

Rather than storing every individual digit, the computer stores a shorter description of repeating patterns.

This is one of the simplest forms of compression.

The goal is simple:

Store the same information using less space.

Smaller files take up less storage, travel across the internet faster, and use less bandwidth.

Real compression algorithms are much smarter than this example, but they all follow the same basic idea:

Don't store repetition. Store a shorter description of it instead.

What are Typed Arrays in JavaScript?

Hossein Naseri — Wed, 03 Jun 2026 13:13:53 +0000

An array in JavaScript is like a big, messy room or warehouse where you can store anything: tables, random-sized boxes, bags, etc.
Or technically: strings, numbers, objects, or even other arrays.

This flexibility is awesome, but it comes with a cost:
the array can become slow and inefficient when it gets large.🐌

Imagine trying to find one specific box in a chaotic room full of different-sized items. You have to search through everything.
Now imagine you have a separate, well-organized room where every box is the same size and contains only one type of item.
You can go straight to the exact spot and grab what you need super fast!🏎️

This is the main idea behind Typed Arrays.

Typed arrays are special arrays where:

Every element must be a number of a fixed size (8-bit, 16-bit, 32-bit, etc.).
The size and type of each element is decided when you create the array.
They are designed for high performance and working with binary data (raw bytes).

Why do we use Typed Arrays?

Computers love perfectly organized data! Typed Arrays give them exactly that with:

Super Speed: Because the computer knows exactly what kind of data is inside and how much space each item takes, it can read, write, and process the data much faster. This is very important for games, video, audio, graphics, and large data processing.⚡
Memory Efficiency: Regular JavaScript arrays waste memory. Typed Arrays use the smallest possible amount of memory by storing raw binary data directly.📦
Direct access to binary data: They are perfect for working with files, images, audio, 3D models, WebGL, WebSockets, and more.🌐

Common Types of Typed Arrays:

Here are the most commonly used Typed Arrays:

Typed Array	Stores	Size per element	Common Use Cases
`Uint8Array`	Whole numbers 0 to 255	8 bits (1 byte)	Images, colors, binary files
`Int8Array`	Numbers from -128 to 127	8 bits	Small signed values
`Uint16Array`	Whole numbers 0 to 65,535	16 bits	Audio samples, larger values
`Int16Array`	Numbers from -32,768 to 32,767	16 bits	Audio, sensor data
`Uint32Array`	Whole numbers 0 to 4.29 billion	32 bits	Large counters, graphics
`Int32Array`	Numbers from -2.1B to 2.1B	32 bits	General math, coordinates
`Float32Array`	Decimal numbers (e.g., 3.14159)	32 bits	3D positions, physics, graphics
`Float64Array`	High-precision decimal numbers	64 bits	Scientific calculations

Uint8Array is the most commonly used, especially when starting.

Quick Example📝

// Regular array (flexible but slower for big data)
const normal = [1, "hello", true, 3.14];

// Typed Array - only numbers 0-255
const pixels = new Uint8Array([255, 128, 0, 255]); 

console.log(pixels[0]);     // 255
pixels[1] = 200;            // works
// pixels[1] = "hello";     // Won't work! Converts to 0 because it only allows numbers.

Key Points to Remember:

Typed Arrays have a fixed size once created.🎯
They can only store numbers of one specific type.
They are significantly faster and more memory-efficient than regular arrays when working with large amounts of data.
In Node.js, Buffer is commonly used and is built on top of Uint8Array. -💡 Bonus Tip (Under the Hood): Typed Arrays don't actually hold the data themselves. They are just a "view" looking inside a raw chunk of memory called an ArrayBuffer.

What Exactly Encription is?

Hossein Naseri — Wed, 27 May 2026 21:09:32 +0000

When you open messaging apps like WhatsApp, you probably see alerts like:

Your messages are end-to-end encrypted.

But what does encryption actually mean?

What really happens technically when you send a message?

Imagine This Scenario

Suppose I want to send a secret message to my friend.

Before sending anything, I secretly tell my friend:

To understand my messages, move every letter one step backward in the alphabet.

So if my friend sees:

They know it actually means:

Because:

A → B
B → C
C → D

Every letter is shifted by one.

Now suppose my real message is:

HELLO

Before sending it, I transform every letter using the same rule:

H → I
E → F
L → M
L → M
O → P

So the encrypted message becomes:

IFMMP

Now I give YOU the paper containing:

IFMMP

and ask you:

Take this to my friend.

If someone steals the paper while you are carrying it, they will only see:

IFMMP

which looks meaningless unless they know the secret rule.

My friend, however, already knows the rule:

Move every letter one step backward.

So they can decode the message:

I → H
F → E
M → L
M → L
P → O

and recover:

HELLO

That secret rule is basically the key.

This Is Basically Encryption

Encryption means:

Transforming readable information into another form using a secret rule or key.

The original readable message is called:

Plain Text
And the transformed unreadable version is called:

Cipher Text
So in our example:

HELLO  → Plain Text
IFMMP  → Cipher Text
But Computers Do Not Understand Letters

Computers do not actually understand:

H
E
L
O

Computers only understand:

bits
0s
1s

As we explained in the previous article, every character inside a computer becomes a number.

For example:

H = 72
E = 69
L = 76
O = 79

And those numbers themselves become binary:

72 = 01001000
69 = 01000101

So inside a computer, your messages are really just numbers and bits.

Encryption Inside Computers

So inside a computer, your messages are really just numbers and bits.

Encryption at the computer level is basically taking those numbers and transforming them into other numbers using a reversible mathematical rule.

In simple words:

The computer changes the original numbers into different numbers in a way that can later be reversed using the correct key or formula.

For example, imagine we have a number like:

In binary, that becomes:

00000001

Now, suppose the computer applies a secret rule like:

add 5

So:

1 + 5 = 6

And now the stored value becomes:

00000110

Someone looking at the encrypted value only sees:

not the original:

To recover the original value, the receiver uses the reverse operation:

6 - 5 = 1

and the original data comes back again.

Modern encryption systems are much more advanced than simple addition and subtraction, but the core idea is still similar:

- take original data
- transform it using mathematics
- Use a secret key
- and make it unreadable without the correct way to reverse it

That transformed unreadable data is what we call:
Encrypted Data

What Are Buffers, Really?

Hossein Naseri — Sat, 23 May 2026 11:47:56 +0000

Buffers are temporary memory spaces used to hold data while it is being moved from one place to another.

Think of it like eating rice.

You cannot move the entire plate of rice into your stomach at once.
So you use a spoon.

The spoon temporarily holds a small piece of rice,
moves it,
Then it gets filled again.

In computers, buffers work similarly.

Instead of moving huge amounts of data all at once, computers usually move data in smaller chunks.

A buffer temporarily stores those chunks while data is being:

copied
read
written
uploaded
downloaded
streamed

For example:

while reading a file
while streaming a video
while receiving internet packets
while copying data between memory and disk

Buffers help data move smoothly and efficiently.

What Is a Buffer Technically?

<Buffer 4C A1 33 00 00 ...>

A buffer is a block of raw binary data stored in memory.

You can think of it as a list of very small memory units called bytes.

Each item inside a buffer:

has exactly 8 bits (1 byte)
stores a small piece of data
can be read, changed, copied, or written

For example:

4C A1 33 00
Each pair represents one byte of data written in **hexadecimal **format.

Why and What Is Hexadecimal?

We will learn more about hexadecimal later, but for now, here is the basic idea.
Computers internally work with binary numbers:

01001100 01001100 01001100 01001100
But binary is difficult for humans to read and understand quickly.

Imagine looking at thousands of bytes written only with 0s and 1s.
It becomes confusing very fast.

So programmers use hexadecimal instead.

Hexadecimal is simply a shorter and cleaner way to represent binary data.

For example, instead of writing:

01001100
we can write:

4C
Both represent the same data.

Simple Mental Model

Think of a buffer like this:

[ byte ][ byte ][ byte ][ byte ]
Each box:

contains 8 bits
stores a tiny piece of data
together forms larger information

That is the core idea behind buffers.