DEV Community: tanzimsafin

How Liquidity Pools Work — A Developer's Overview

tanzimsafin — Tue, 24 Mar 2026 15:51:45 +0000

If you've ever swapped tokens on Uniswap or PancakeSwap,
you've used a liquidity pool. But what's actually happening
under the hood?

This post gives you a solid mental model as a developer —
no heavy math, just the concepts you need to build on top of DeFi.

The Core Problem

Traditional exchanges use an order book — buyers and sellers
post orders, the exchange matches them.

On-chain this is painful:

Every order is a transaction (gas costs)
Thin markets mean no liquidity for small tokens
Slow block times create front-running opportunities

Liquidity pools solve this by removing the need for a
counterparty entirely.

What is a Liquidity Pool?

A liquidity pool is a smart contract holding two tokens
in reserve. Instead of matching a buyer with a seller,
you trade directly against the contract.

The price is determined automatically based on the ratio
of tokens in the pool. No order book. No matching engine.
Just a contract and a formula.

This model is called an Automated Market Maker (AMM).

Liquidity Providers

Anyone can deposit tokens into a pool and become a
Liquidity Provider (LP).

You deposit equal value of both tokens. In return:

You receive LP tokens representing your pool share
You earn a cut of every swap fee (typically 0.3%)
You can withdraw anytime by burning your LP tokens

The more trading volume the pool sees, the more LPs earn.

The Key Risk — Impermanent Loss

This is the most important concept for anyone building
with or investing in liquidity pools.

When token prices shift significantly after you deposit,
the pool auto-rebalances. You end up with more of the
token that dropped and less of the one that rose.

When you withdraw, you may have less value than if
you had simply held the tokens in your wallet.

That gap is impermanent loss.

It's called "impermanent" because if prices return to
original levels, the loss disappears. But if you withdraw
while prices are different — it's a realized loss.

Fee revenue can offset this — but for highly volatile
pairs, IL can outweigh what you earn.

Reading a Pool with ethers.js

Every Uniswap V2 pool exposes a getReserves() function.
Here's how to read live pool data:

import { ethers } from "ethers";

const PAIR_ABI = [
  "function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)",
];

const provider = new ethers.JsonRpcProvider(
  "https://mainnet.infura.io/v3/YOUR_KEY"
);

// ETH/USDC pair — Uniswap V2
const PAIR = "0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc";

const pool = new ethers.Contract(PAIR, PAIR_ABI, provider);

async function getPrice() {
  const [reserve0, reserve1] = await pool.getReserves();

  const usdc = Number(reserve0) / 1e6;   // USDC = 6 decimals
  const eth  = Number(reserve1) / 1e18;  // ETH  = 18 decimals

  console.log(`ETH price: $${(usdc / eth).toFixed(2)}`);
}

getPrice();

That's it — you're reading live on-chain price data
directly from the pool contract.

V2 vs V3 — What Changed

Uniswap V3 introduced concentrated liquidity —
instead of spreading liquidity across all possible prices,
LPs choose a specific price range to provide liquidity in.

The tradeoff:

Much more capital efficient within the range
Stops earning fees if price moves outside the range
Requires active management vs V2's set-and-forget

V3 positions are also NFTs — because each position
is unique (different price ranges), they can't be
fungible tokens like V2 LP tokens.

Key Terms Cheatsheet

Term	What it means
AMM	Smart contract that prices assets automatically
LP	Someone who deposits tokens to earn fees
LP Token	Your receipt/share of the pool
Impermanent Loss	Value difference vs just holding
Concentrated Liquidity	V3 feature — LPs pick a price range
Slippage	Price difference between quote and execution

What's Next

Next part: Building a real-time pool price monitor
with ethers.js — watching reserve changes live and
calculating price impact before a swap.

If anything here is unclear or wrong, drop it in
the comments. Always prefer a correction over bad
mental models spreading.

Reverse array in groups

tanzimsafin — Sun, 01 Mar 2026 06:08:15 +0000

Original Problem: Reverse an Array in Groups of Given Size

Using Chunking Technique (Reversal)

We want to reverse an array in groups of size k. Think of the array as being split into consecutive chunks (windows) of length k, and we reverse each chunk one by one.

Key Idea (Chunk-by-Chunk)

Start from index 0.
Take the next k elements as a chunk: array[i : i+k].
Reverse only that chunk.
Jump to the next chunk by moving i forward by k.

Algorithm Steps

Loop through the array in steps of k:
i = 0, k, 2k, 3k, ...
Reverse the current chunk:
Replace array[i : i+k] with its reversed version.
Handle the edge case (last chunk smaller than k):
If fewer than k elements remain, array[i : i+k] simply returns the remaining elements.
Reversing it still works, so no extra checks are needed.

Implementation

def reverse_in_groups(arr, k):
    n = len(arr)
    for i in range(0, n, k):
        # Reverse the sub-array from i to i+k
        arr[i:i+k] = reversed(arr[i:i+k])
    return arr

Time Complexity

Total time is $O (n)$ because each element is visited at most twice (once during iteration and once during reversal).

Example Walkthrough

Array: [1, 2, 4, 5, 7]
k = 3

Chunk 1: [1, 2, 4] → [4, 2, 1]
Chunk 2 (edge case): [5, 7] → [7, 5]

Result: [4, 2, 1, 7, 5]

DBMS Basics

tanzimsafin — Sat, 24 Jan 2026 09:53:43 +0000

Understanding DBMS: From Data to Database Architecture

What's the Difference Between Data and Information?

Think of it this way: Data is raw, unprocessed facts, while Information is data that has been given meaning.

Simple Example:

Data: 10
Information: Age: 10 years

The number alone is just data, but when we add context (that it represents someone's age), it becomes useful information.

What is a Database?

A database is simply a collection of related data that's connected in meaningful ways. Think of it like an organized filing cabinet where everything is labeled and linked together.

Why Use Databases Instead of File Systems?

You might wonder, "Can't I just save files on my computer?" Well, you could, but here's why that's problematic:

Problems with File Systems:

Data Redundancy (Duplication)

The same information gets saved in multiple places
Wastes storage space

Data Inconsistency

If you update information in one file but forget to update it in another copy
Different files show different information about the same thing

Poor Memory Management

No efficient way to organize and retrieve data
Everything becomes messy and slow

Weak Security

Hard to control who can access what
No built-in protection mechanisms

What is RDBMS (Relational Database)?

RDBMS organizes data in a simple table format with rows and columns - just like an Excel spreadsheet, but much more powerful!

Where is RDBMS Used?

Schools and colleges (student records, grades)
Banks (account information, transactions)
Software companies (user data, products)
Almost any business that needs to store data!

Popular Database Types:

SQL databases (like MySQL, PostgreSQL)
NoSQL databases (like MongoDB)
Object-oriented databases
In-memory databases
Blockchain databases

Most Popular: SQL and NoSQL dominate the software industry.

Why RDBMS is Better

Advantages:

Data Integrity

Has a "schema" (like a blueprint) that enforces rules
Only allows valid data to be stored
Example: Age field won't accept text like "abc"

Data Abstraction

You don't need to know how data is physically stored
Just write simple queries to get what you need
Like driving a car without knowing how the engine works!

Better Scalability

Easier to grow and handle more data

No Redundancy or Inconsistency

Data is stored once and used everywhere
Updates happen everywhere automatically

Disadvantages:

Can Be Expensive

Needs more storage space because data is organized and formatted
Requires powerful servers

Scalability Challenges

If you design a table for 20 rows and suddenly need 1,000 rows
Performance can slow down significantly
Need to plan capacity carefully

The Three Levels of DBMS

Think of these as different floors in a building:

1. Physical Level (The Basement)

This is where actual data sits in computer memory (RAM, hard drive)
Deals with how bits and bytes are stored
Uses special techniques like Hashing and B+ Trees for efficiency

2. Logical Level (The Main Floor)

This is where you work with the database
Write queries and interact with data
Don't need to worry about physical storage
Like using an app without knowing the code behind it

3. View Level (The Penthouse)

What users actually see and interact with
Customized views for different users
Example: Students see grades, teachers see grades + edit options

What is a Schema?

A schema is like a blueprint or rulebook for your database. It strictly defines:

What tables exist
What columns are in each table
What type of data goes in each column (numbers, text, dates, etc.)
What the column names are
What rules must be followed (constraints)

Two Types of Schema:

Physical Schema

Describes how data is actually stored in memory
Uses efficient techniques like:
- Hashing (quick lookups)
- B+ Trees (organized searching)

Logical Schema

Defines the structure users interact with
Sets data type rules (age must be a number, email must have @, etc.)
Creates relationships between tables

Instance: A snapshot of what your database looks like at any moment in time.

DBMS Architecture Types

1-Tier Architecture (All-in-One)

Everything on a single computer
Simple but limited
Example: Microsoft Access on your laptop

2-Tier Architecture (Client-Server)

Your Computer (Client): Where you interact with the database
Server: Where the database actually lives
Example: Your banking app connecting to bank servers

3-Tier Architecture (Enterprise Level)

Presentation Layer: What you see (website, app interface)
Application Layer: Business logic and processing (server)
Database Layer: Where data is stored
Example: Amazon - you see the website, servers process orders, databases store everything