DEV Community: Saiful Islam

SDLC-2

Saiful Islam — Sun, 07 Jun 2026 19:36:18 +0000

সফটওয়্যার ডেপ্লয়মেন্ট: লোকাল মেশিন থেকে লাইভ সার্ভার পর্যন্ত

একটি সম্পূর্ণ বাংলা গাইড

এই গাইডটি পড়লে আপনি শিখবেন: কীভাবে আপনার নিজের কম্পিউটারে লেখা কোড, গিটহাবের মাধ্যমে, একটি ক্লাউড সার্ভারে স্বয়ংক্রিয়ভাবে ডেপ্লয় হয় — যাতে লক্ষো ব্যবহারকারী একসাথে সেটি ব্যবহার করতে পারে।
এই গাইডটি "সফটওয়্যার ডেভেলপমেন্ট সেশন টু" লাইভ ক্লাসের বিষয়বস্তু অবলম্বনে রচিত।

সূচিপত্র

১. ভূমিকা: আমরা কী শিখব এবং কেন?
২. ডেপ্লয়মেন্ট কী? — মূল ধারণা
৩. তিনটি মেশিনের পরিবেশ — The Three-Machine Model
৪. পোর্ট: দুই কম্পিউটারের কথোপকথনের দরজা
৫. গিট ও গিটহাব — কোডের গুগল ড্রাইভ
৬. ক্লাউড সার্ভার — আপনার অনলাইন কম্পিউটার
৭. SSH Key — ডিজিটাল চাবির সিস্টেম
৮. ডিজিটাল ওশান থেকে সার্ভার কেনা (ধাপে ধাপে)
৯. লোকাল মেশিন থেকে সার্ভারে SSH সংযোগ
১০. গিট ইনস্টল ও সার্ভারে গিটহাব সেটআপ
১১. GitHub Actions — স্বয়ংক্রিয় ডেপ্লয়মেন্ট পাইপলাইন
১২. YAML ওয়ার্কফ্লো ফাইল — পাইপলাইনের হৃদয়
১৩. Secrets ও Environment Variables — গোপন তথ্য সুরক্ষা
১৪. PM2 — Node.js সার্ভার ব্যাকগ্রাউন্ডে চালানো
১৫. সম্পূর্ণ ওয়ার্কফ্লো: শুরু থেকে শেষ পর্যন্ত
১৬. বাস্তব দলে ডেপ্লয়মেন্ট কীভাবে হয়?
১৭. AI/NLP কোডিং — ভবিষ্যতের কোডিং পদ্ধতি
১৮. পরবর্তী পদক্ষেপ ও রিসোর্স

অধ্যায় ১: ভূমিকা — আমরা কী শিখব এবং কেন?

আপনি হয়তো অনেক কোড লিখেছেন। একটি পোর্টফোলিও ওয়েবসাইট, একটি ই-কমার্স সাইট, অথবা একটি ছোট ওয়েব অ্যাপ। কোডটি আপনার নিজের কম্পিউটারে দিব্যি চলছে। কিন্তু প্রশ্ন হলো — এই কোড হাজার হাজার মানুষ কীভাবে ব্যবহার করবে?

এই প্রশ্নের উত্তরই হলো সফটওয়্যার ডেপ্লয়মেন্ট।

এই গাইডে আমরা শিখব:

লোকাল মেশিন থেকে গিটহাবে কোড কীভাবে পুশ করতে হয়
একটি ক্লাউড সার্ভার কীভাবে কিনতে ও সেটআপ করতে হয়
SSH Key দিয়ে সার্ভারে নিরাপদ সংযোগ কীভাবে করতে হয়
GitHub Actions দিয়ে স্বয়ংক্রিয় CI/CD পাইপলাইন কীভাবে তৈরি করতে হয়
PM2 দিয়ে সার্ভারে Node.js অ্যাপ কীভাবে চালু রাখতে হয়

এই বিষয়গুলো কেন জরুরি?

আপনি যে প্ল্যাটফর্মেই কাজ করুন না কেন — AWS, DigitalOcean, Azure, GCP — মূল নীতিগুলো সবজায়গায় একই। একবার এই ফান্ডামেন্টাল বুঝলে যেকোনো সার্ভারে কাজ করতে পারবেন।

অধ্যায় ২: ডেপ্লয়মেন্ট কী? — মূল ধারণা

ডেপ্লয়মেন্ট মানে হলো — আপনার লেখা সফটওয়্যার এমনভাবে একটি সার্ভারে স্থাপন করা, যাতে ইন্টারনেটের যেকোনো জায়গা থেকে যেকোনো মানুষ সেটি ব্যবহার করতে পারে।

চিন্তা করুন আপনি facebook.com ভিজিট করছেন। এই facebook.com আসলে কী? এটি ফেসবুকের একটি কম্পিউটারে (সার্ভারে) রাখা একটি সফটওয়্যার। আপনার ব্রাউজার সেই সার্ভারে একটি অনুরোধ পাঠায়, সার্ভার উত্তর দেয়, আর আপনার স্ক্রিনে ওয়েবসাইট দেখা যায়।

ডেভেলপার হিসেবে আপনার কাজ তিনটি স্তরে হয়:

[আপনার ল্যাপটপ] → [গিটহাব] → [ক্লাউড সার্ভার] → [কোটি ইউজার]

এই পুরো প্রক্রিয়াটিকেই বলা হয় Software Development Lifecycle (SDLC)। এর সবচেয়ে শেষ ধাপ হলো ডেপ্লয়মেন্ট — যখন আপনার কোড ইন্টারনেটে "লাইভ" হয়।

ডেপ্লয়মেন্টে কী কী শেখা যায়?

এই একটি বিষয় শিখতে গেলে আপনি পাশাপাশি শিখে ফেলবেন:

CI/CD (Continuous Integration / Continuous Deployment) — কোড পরিবর্তনের সাথে সাথে স্বয়ংক্রিয়ভাবে ডেপ্লয় হওয়া
DevOps মানসিকতা — ডেভেলপমেন্ট এবং অপারেশন একসাথে
Cloud Computing — ডিজিটাল ওশান, AWS, Azure ইত্যাদি
Linux / Ubuntu — সার্ভার অপারেটিং সিস্টেম
Bash Scripting — কমান্ড লাইনে স্বয়ংক্রিয় কাজ

অধ্যায় ৩: তিনটি মেশিনের পরিবেশ

একজন ডেভেলপার হিসেবে আপনাকে কমপক্ষে তিনটি আলাদা মেশিনের (পরিবেশের) কথা মাথায় রাখতে হবে:

┌─────────────────────────────────────────────────────────┐
│  মেশিন ১          মেশিন ২          মেশিন ৩             │
│  ──────────       ──────────       ──────────           │
│  আপনার           গিটহাব           ক্লাউড               │
│  ল্যাপটপ         সার্ভার          সার্ভার              │
│  (Dev Machine)   (Code Repo)      (Deploy Machine)     │
│                                                         │
│  কোড লেখা  ──→  কোড সংরক্ষণ ──→  কোড চালানো          │
└─────────────────────────────────────────────────────────┘

মেশিন ১: আপনার লোকাল মেশিন (Development Environment)

এটি হলো আপনার নিজের ল্যাপটপ বা ডেস্কটপ। এখানে আপনি:

কোড এডিটর (VS Code, IntelliJ, ইত্যাদি) দিয়ে কোড লেখেন
localhost এ সফটওয়্যার টেস্ট করেন
গিট দিয়ে কোড ট্র্যাক করেন

এই মেশিনে একটি মনিটর আছে, কীবোর্ড আছে — পুরো ডেস্কটপ পরিবেশ আছে।

মেশিন ২: গিটহাব সার্ভার (Code Repository)

এটি হলো Microsoft-এর পরিচালিত একটি সার্ভার, যেখানে github.com এর মাধ্যমে আপনি কোড সংরক্ষণ করেন।

গিটহাবকে আপনি কোডের গুগল ড্রাইভ হিসেবে ভাবতে পারেন। গুগল ড্রাইভে যেমন আপনার ফাইল অনলাইনে সংরক্ষিত থাকে, গিটহাবে তেমনি আপনার কোড সংরক্ষিত থাকে।

পার্থক্য হলো: গিটহাব শুধু স্টোরেজ না — এটি কোডের ইতিহাস রাখে, টিম কোলাবোরেশন সাপোর্ট করে, এবং GitHub Actions দিয়ে স্বয়ংক্রিয় কাজও করতে পারে।

মেশিন ৩: ক্লাউড ডেপ্লয়মেন্ট সার্ভার (Production Server)

এটি হলো DigitalOcean, AWS, Azure বা GCP-এর মতো কোম্পানির সার্ভার, যেটি আপনি মাসিক ভাড়া দিয়ে ব্যবহার করেন।

এই মেশিনে কোনো মনিটর নেই, কীবোর্ড নেই। এটি শুধু ইন্টারনেটের সাথে সংযুক্ত একটি কম্পিউটার। এই মেশিনটিকে আপনি টার্মিনাল/কনসোল দিয়ে দূর থেকে নিয়ন্ত্রণ করেন।

এই মেশিনে আপনার সফটওয়্যার চলে, এবং ইন্টারনেটের যেকোনো মানুষ সেটি ব্যবহার করতে পারে।

কেন আলাদা মেশিন দরকার?

এই তিনটি মেশিন তিনটি আলাদা হার্ডওয়্যার এবং আলাদা নেটওয়ার্কে থাকে। এরা এমনিতে একে অপরের সাথে কথা বলতে পারে না — ইন্টারনেট সংযোগ থাকলেই কেবল পারে।

একজন ডেভেলপার হিসেবে আপনার কাজ হলো: কোড মেশিন-১ থেকে মেশিন-২ হয়ে মেশিন-৩ পর্যন্ত নিয়ে যাওয়ার প্রক্রিয়াটি সহজ ও স্বয়ংক্রিয় করা।

অধ্যায় ৪: পোর্ট — দুই কম্পিউটারের কথোপকথনের দরজা

দুটি কম্পিউটার একে অপরের সাথে কথা বলার জন্য পোর্ট ব্যবহার করে।

পোর্ট কী? পোর্ট হলো কম্পিউটারের মধ্যে চলমান একটি প্রোগ্রাম, যেটি বাইরে থেকে আসা যোগাযোগের অনুরোধ গ্রহণ করতে পারে। সহজ ভাষায়: পোর্ট হলো একটি দরজা, যেটি খোলা থাকলে বাইরে থেকে ঢোকা যায়।

গুরুত্বপূর্ণ পোর্ট নম্বরগুলো:

পোর্ট নম্বর	প্রোটোকল	ব্যবহার
80	HTTP	সাধারণ ওয়েবসাইট দেখা (যেমন `http://example.com`)
443	HTTPS	নিরাপদ ওয়েবসাইট দেখা (যেমন `https://example.com`)
22	SSH	এক সার্ভার থেকে আরেক সার্ভারে টার্মিনাল সংযোগ
3000	Custom	Node.js অ্যাপ সাধারণত এই পোর্টে চলে

পোর্ট 80 এবং 443 কীভাবে কাজ করে?

যখন আপনি ব্রাউজারে http://facebook.com লেখেন, তখন আপনার কম্পিউটার ফেসবুকের সার্ভারের পোর্ট 80-তে একটি অনুরোধ পাঠায়। সার্ভার সেটি গ্রহণ করে উত্তর দেয়।

যদি https:// হয়, তাহলে পোর্ট 443 ব্যবহার হয়। HTTPS মানে যোগাযোগটি এনক্রিপ্টেড — মাঝপথে কেউ দেখতে পাবে না।

পোর্ট 22 কেন বিশেষ?

পোর্ট 22 হলো SSH (Secure Shell) প্রোটোকলের জন্য। এই পোর্ট দিয়ে আপনি একটি কম্পিউটার থেকে আরেকটি কম্পিউটারের টার্মিনালে সরাসরি ঢুকতে পারেন — যেন আপনি সেই কম্পিউটারের সামনে বসে কাজ করছেন।

উদাহরণ: আপনি ঢাকায় বসে DigitalOcean-এর সিঙ্গাপুরের সার্ভারে কমান্ড দিচ্ছেন — এটি পোর্ট 22 এর মাধ্যমে হয়।

গুরুত্বপূর্ণ: আপনার সার্ভারে পোর্ট 22 বন্ধ থাকলে কেউ SSH করে ঢুকতে পারবে না। ফায়ারওয়াল দিয়ে এই পোর্ট নিয়ন্ত্রণ করা হয়।

অধ্যায় ৫: গিট ও গিটহাব — কোডের গুগল ড্রাইভ

ডেপ্লয়মেন্ট বুঝতে হলে আগে গিট ও গিটহাব বুঝতে হবে।

গিট (Git) কী?

গিট হলো আপনার লোকাল কম্পিউটারে ইনস্টল করা একটি সফটওয়্যার, যেটি আপনার কোডের পরিবর্তনগুলো ট্র্যাক করে। এটি যেকোনো অপারেটিং সিস্টেমে ইনস্টল করা যায়।

টার্মিনালে git লিখলে যদি গিটের সাহায্য দেখা যায়, তার মানে গিট ইনস্টল আছে।

গিটহাব (GitHub) কী?

গিটহাব হলো Microsoft-এর একটি ক্লাউড সার্ভিস, যেখানে আপনি আপনার গিট রিপোজিটরি অনলাইনে সংরক্ষণ করতে পারেন।

সম্পর্কটা এরকম:

গিট = আপনার লোকাল মেশিনে চলা সফটওয়্যার
গিটহাব = অনলাইনে কোড রাখার জায়গা

মূল গিট কমান্ডগুলো:

# নতুন গিট রিপো শুরু করা
git init

# কোন কোন ফাইল পরিবর্তন হয়েছে দেখা
git status

# সব পরিবর্তন "স্টেজ" করা (আপলোডের জন্য প্রস্তুত করা)
git add .

# পরিবর্তনগুলো একটি "কমিট" হিসেবে সংরক্ষণ করা
git commit -m "আমার পরিবর্তনের বিবরণ"

# গিটহাবে কোড পাঠানো
git push origin main

# গিটহাব থেকে সর্বশেষ কোড আনা
git pull origin main

গিটহাবে রিপোজিটরি তৈরি করা:

১. github.com এ লগইন করুন
২. "New Repository" বাটনে ক্লিক করুন
৩. রিপোজিটরির নাম দিন (যেমন: session-two)
৪. Public বা Private বেছে নিন
৫. "Create Repository" ক্লিক করুন

গিটহাব তখন কিছু কমান্ড দেখাবে। এই কমান্ডগুলো আপনার লোকাল প্রজেক্টকে গিটহাবের সাথে যুক্ত করে।

লোকাল প্রজেক্টকে গিটহাবে লিংক করা:

# গিটহাব কোন রিপোতে কোড পাঠাব সেটা বলা
git remote add origin https://github.com/আপনার-নাম/session-two.git

# প্রথমবার পুশ করা
git push -u origin main

এরপর থেকে git push করলেই কোড গিটহাবে চলে যাবে।

অধ্যায় ৬: ক্লাউড সার্ভার — আপনার অনলাইন কম্পিউটার

ক্লাউড সার্ভার হলো ইন্টারনেটে থাকা একটি কম্পিউটার, যেটি আপনি মাসিক ভাড়া দিয়ে ব্যবহার করতে পারেন।

ক্লাউড সার্ভার এবং সাধারণ ল্যাপটপের পার্থক্য:

বিষয়	আপনার ল্যাপটপ	ক্লাউড সার্ভার
মনিটর	আছে	নেই
কীবোর্ড	আছে	নেই
এক্সেস পদ্ধতি	সরাসরি ব্যবহার	SSH টার্মিনাল দিয়ে
চলার সময়	আপনি চালু রাখলে	২৪/৭ চালু থাকে
ইন্টারনেট IP	পরিবর্তনশীল	স্থায়ী (Fixed IP)
মূল্য	একবার কিনতে হয়	মাসিক ভাড়া

ক্লাউড সার্ভারের অপারেটিং সিস্টেম:

সার্ভার কেনার সময় আপনাকে অপারেটিং সিস্টেম বেছে নিতে হয়। Ubuntu (Linux-ভিত্তিক) সবচেয়ে বেশি ব্যবহৃত:

Ubuntu 20.04 LTS: স্থিতিশীল, বেশি সাপোর্টেড — সাধারণ কাজের জন্য প্রস্তাবিত
Ubuntu 22.04 LTS: সর্বশেষ স্থিতিশীল সংস্করণ
LTS মানে "Long Term Support" — দীর্ঘদিন আপডেট পাবেন

অধ্যায় ৭: SSH Key — ডিজিটাল চাবির সিস্টেম

এটি সবচেয়ে গুরুত্বপূর্ণ অধ্যায়। SSH Key না বুঝলে সার্ভারে সংযোগ করা কঠিন হবে।

SSH Key কী?

SSH Key হলো একজোড়া ডিজিটাল চাবি। একটি তালা (Public Key) এবং একটি চাবি (Private Key)।

┌─────────────────────────────────────────────────┐
│  কি-পেয়ার (Key Pair)                           │
│  ─────────────────                              │
│  Private Key (id_rsa)     → আপনার কাছে থাকে   │
│  Public Key (id_rsa.pub)  → সার্ভারে রাখা হয়  │
└─────────────────────────────────────────────────┘

নিয়মটা মনে রাখুন:

যে মেশিন থেকে এক্সেস করবেন → সেখানে Private Key রাখুন
যে মেশিনকে এক্সেস করতে চান → সেখানে Public Key রাখুন

কেন পাসওয়ার্ডের বদলে SSH Key?

পাসওয়ার্ড দিয়েও সার্ভারে ঢোকা যায়, কিন্তু:

পাসওয়ার্ড চুরি হওয়ার ঝুঁকি বেশি
SSH Key গণিতগতভাবে অনেক বেশি সুরক্ষিত
একবার সেটআপ করলে বারবার পাসওয়ার্ড দিতে হয় না
প্রফেশনাল পরিবেশে এটিই স্ট্যান্ডার্ড

SSH Key কীভাবে তৈরি করবেন?

যেকোনো কম্পিউটারের টার্মিনালে এই কমান্ড দিন:

ssh-keygen -t rsa -b 4096 -C "আপনার-ইমেইল@example.com"

কমান্ড দেওয়ার পর:

ফাইলের নাম জিজ্ঞেস করবে: Enter দিলে ডিফল্ট নাম (id_rsa) নেবে। আলাদা নাম দিতে চাইলে টাইপ করুন।
Passphrase জিজ্ঞেস করবে: Enter দিয়ে ফাঁকা রেখে দিন (এখন সহজের জন্য)।

⚠️ গুরুত্বপূর্ণ: GitHub Actions-এর সাথে SSH ব্যবহারের সময় Passphrase ফাঁকা রাখুন, নইলে অটোমেশনে সমস্যা হবে।

তৈরি হওয়া Key ফাইলগুলো কোথায় থাকে?

Mac/Linux এ:

~/.ssh/id_rsa          ← Private Key (কখনো কাউকে দেবেন না!)
~/.ssh/id_rsa.pub      ← Public Key (সার্ভারে দেওয়া যায়)

এই ফাইলগুলো দেখতে:

# .ssh ফোল্ডারে যাওয়া
cd ~/.ssh

# সব ফাইল দেখা (hidden ফাইলসহ)
ls -lah

# Public Key এর ভেতরে কী আছে দেখা
cat id_rsa.pub

# Private Key এর ভেতরে কী আছে দেখা (এটি কখনো শেয়ার করবেন না)
cat id_rsa

Public Key কেমন দেখায়?

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDKGr9n...দীর্ঘ স্ট্রিং... আপনার-ইমেইল@example.com

এই পুরো লাইনটি আপনার Public Key।

একাধিক Key তৈরি করা কি যায়?

হ্যাঁ! আপনি চাইলে ভিন্ন ভিন্ন উদ্দেশ্যে ভিন্ন ভিন্ন Key তৈরি করতে পারেন:

# GitHub-এর জন্য আলাদা key
ssh-keygen -t rsa -b 4096 -C "github-actions-key" -f ~/.ssh/github_actions_key

# নিজের সার্ভার এক্সেসের জন্য আলাদা key
ssh-keygen -t rsa -b 4096 -C "my-server-key" -f ~/.ssh/my_server_key

এটি best practice — কারণ একটি key কম্প্রোমাইজ হলে অন্যগুলো নিরাপদ থাকে।

অধ্যায় ৮: DigitalOcean থেকে সার্ভার কেনা (ধাপে ধাপে)

DigitalOcean-এ একটি সার্ভার (তারা বলে "Droplet") তৈরি করার ধাপগুলো:

ধাপ ১: একাউন্ট তৈরি ও লগইন

digitalocean.com এ গিয়ে একাউন্ট খুলুন। ক্রেডিট কার্ড দিয়ে ভেরিফাই করতে হবে।

বিকল্প: বাংলাদেশের লোকাল সার্ভার প্রোভাইডার থেকেও Linux সার্ভার কিনতে পারেন। প্রক্রিয়া একই।

ধাপ ২: Droplets মেনু খুলুন

বাম পাশের মেনুতে "Droplets" ক্লিক করুন। Droplets মানে ছোট ছোট ক্লাউড কম্পিউটার।

ধাপ ৩: "Create Droplet" বাটনে ক্লিক করুন

ধাপ ৪: Region (অবস্থান) বেছে নিন

বাংলাদেশ থেকে সবচেয়ে কাছের সার্ভার:

Singapore — সবচেয়ে ভালো (কম latency)
Bangalore — দ্বিতীয় বিকল্প

ধাপ ৫: Operating System বেছে নিন

Ubuntu → 20.04 LTS বা 22.04 LTS বেছে নিন।

ধাপ ৬: Plan (দাম) বেছে নিন

শেখার জন্য সবচেয়ে সস্তা প্ল্যান নিন:

$4/মাস — 1 GB RAM, 1 CPU, 25 GB SSD — শুরুর জন্য যথেষ্ট

ধাপ ৭: Authentication Method বেছে নিন

এখানে দুটি অপশন আছে:

SSH Keys ← এটি বেছে নিন (বেশি নিরাপদ)
Password ← শেখার জন্য ব্যবহার করা যায়

SSH Key অপশনে ক্লিক করুন এবং আপনার Public Key পেস্ট করুন:

# আপনার Public Key কপি করুন:
cat ~/.ssh/id_rsa.pub
# উপরের আউটপুট কপি করে DigitalOcean-এর বক্সে পেস্ট করুন

ধাপ ৮: সার্ভারের নাম দিন

যেমন: my-deployment-server

ধাপ ৯: "Create Droplet" ক্লিক করুন

কিছুক্ষণের মধ্যে আপনার সার্ভার তৈরি হয়ে যাবে। সার্ভারটি একটি IP Address পাবে — যেমন 209.71.xx.xx।

এই IP Address মনে রাখুন বা কপি করে রাখুন।

অধ্যায় ৯: লোকাল মেশিন থেকে সার্ভারে SSH সংযোগ

এখন আমরা আমাদের ল্যাপটপ থেকে সার্ভারে সংযোগ করব।

SSH কানেক্ট করার কমান্ড:

ssh root@209.71.xx.xx

এখানে:

root = সার্ভারের অ্যাডমিন ইউজার নাম
209.71.xx.xx = আপনার সার্ভারের IP Address

প্রথমবার সংযোগে কী হবে?

The authenticity of host '209.71.xx.xx' can't be established.
RSA key fingerprint is SHA256:...
Are you sure you want to continue connecting (yes/no)?

yes টাইপ করুন। এরপর সার্ভারে ঢুকে যাবেন।

সফল সংযোগের চিহ্ন:

root@my-deployment-server:~#

এই প্রম্পট দেখলে বুঝবেন আপনি এখন সার্ভারের ভেতরে। আপনার টার্মিনাল এখন সেই দূরের সার্ভারে কমান্ড পাঠাচ্ছে।

এটা একটি অদ্ভুত মুহূর্ত: আপনি ঢাকায় বসে সিঙ্গাপুরের সার্ভারে কমান্ড দিচ্ছেন!

সার্ভার থেকে বেরিয়ে আসা:

exit

অথবা Ctrl+D।

অধ্যায় ১০: গিট ইনস্টল ও সার্ভারে গিটহাব সেটআপ

এখন সার্ভারে গিট ইনস্টল করব, যাতে সার্ভার গিটহাব থেকে কোড নামাতে পারে।

সার্ভারে গিট ইনস্টল করা:

SSH দিয়ে সার্ভারে ঢুকুন, তারপর:

# প্যাকেজ লিস্ট আপডেট করা
apt update

# গিট ইনস্টল করা
apt install git -y

# গিট ঠিকমতো ইনস্টল হয়েছে কিনা চেক করা
git --version

সার্ভারে গিটহাব কনফিগার করা:

git config --global user.name "আপনার নাম"
git config --global user.email "আপনার-ইমেইল@example.com"

গিটহাব রিপো ক্লোন করা:

# গিটহাব থেকে প্রজেক্ট কপি করা
git clone https://github.com/আপনার-নাম/session-two.git

# প্রজেক্ট ফোল্ডারে যাওয়া
cd session-two

# ফোল্ডারের ভেতরে কী আছে দেখা
ls -lah

এরপর থেকে নতুন কোড পেতে:

git pull origin main

অধ্যায় ১১: GitHub Actions — স্বয়ংক্রিয় ডেপ্লয়মেন্ট পাইপলাইন

এতক্ষণ আমরা দেখলাম সব কাজ ম্যানুয়ালি। কিন্তু প্রতিবার কোড পরিবর্তন করলে কি সার্ভারে ঢুকে git pull করতে হবে?

না! এখানেই আসে GitHub Actions।

GitHub Actions কী?

GitHub Actions হলো GitHub-এর একটি ফিচার, যেটি দিয়ে আপনি নির্দিষ্ট ঘটনায় (Event) স্বয়ংক্রিয় কাজ চালাতে পারেন।

উদাহরণ:

"যখনই main branch-এ কোড push হবে" → "সার্ভারে স্বয়ংক্রিয়ভাবে git pull করো"

এটাই CI/CD পাইপলাইনের মূল ধারণা।

GitHub Actions-এর মূল উপাদান:

┌─────────────────────────────────────────────────────────┐
│  GitHub Actions আর্কিটেকচার                            │
│  ─────────────────────────                              │
│                                                         │
│  Event (ঘটনা)      → কোড push হলো                     │
│       ↓                                                 │
│  Workflow (ওয়ার্কফ্লো) → .yml ফাইলে লেখা নির্দেশ     │
│       ↓                                                 │
│  Runner (রানার)    → ছোট্ট শর্ট-লাইভিং সার্ভার         │
│       ↓                                                 │
│  Jobs (কাজ)        → একটি বা একাধিক কাজ               │
│       ↓                                                 │
│  Steps (ধাপ)       → প্রতিটি কাজের ভেতরের ধাপগুলো     │
└─────────────────────────────────────────────────────────┘

GitHub Runner কী?

Runner হলো GitHub-এর দেওয়া একটি ছোট, সাময়িক কম্পিউটার। যখন আপনি কোড push করেন, GitHub একটি Runner চালু করে, সেটি আপনার .yml ফাইলের নির্দেশ মেনে কাজ করে, তারপর বন্ধ হয়ে যায়।

মূল পয়েন্টগুলো:

এটি সাময়িক (Ephemeral) — কাজ শেষ হলে বন্ধ
এটি GitHub-এর মধ্যে চলে — আপনার DigitalOcean সার্ভার নয়
এটি একটি ছোট Ubuntu মেশিন
এই Runner থেকেই আপনার DigitalOcean সার্ভারে SSH করা হয়

Events (ঘটনা) কী কী হতে পারে?

on:
  push:                    # কোড push হলে
    branches: [main]
  pull_request:            # PR তৈরি হলে
    branches: [main]
  workflow_dispatch:       # ম্যানুয়ালি চালানো
  schedule:                # নির্দিষ্ট সময়ে
    - cron: '0 0 * * *'    # প্রতিদিন রাত ১২টায়

অধ্যায় ১২: YAML ওয়ার্কফ্লো ফাইল — পাইপলাইনের হৃদয়

GitHub Actions-এর সব নির্দেশ একটি YAML ফাইলে লেখা হয়।

YAML ফাইল কোথায় রাখতে হয়?

আপনার প্রজেক্টে এই ফোল্ডার স্ট্রাকচার তৈরি করুন:

আপনার-প্রজেক্ট/
├── .github/
│   └── workflows/
│       └── deploy.yml     ← এখানে রাখুন
├── index.html
├── server.js
└── package.json

সহজ পরীক্ষামূলক Workflow:

শুরুতে এই সহজ .yml ফাইল দিয়ে দেখুন GitHub Actions কাজ করছে কিনা:

# .github/workflows/deploy.yml

name: Deploy to DigitalOcean

# কখন এই Workflow চলবে?
on:
  push:
    branches: [main]   # main branch-এ push হলে

# কী কাজ হবে?
jobs:
  echo-message:
    runs-on: ubuntu-latest   # Runner কোন OS ব্যবহার করবে

    steps:
      # ধাপ ১: রিপোজিটরি চেক করা
      - name: Checkout Repository
        uses: actions/checkout@v3

      # ধাপ ২: একটি বার্তা প্রিন্ট করা
      - name: Echo Push Event
        run: echo "A push has happened on the main branch!"

এই ফাইলটি আপনার প্রজেক্টে যোগ করুন এবং push করুন।

Workflow চলছে কিনা দেখবেন কীভাবে?

১. GitHub-এ আপনার রিপোতে যান
২. "Actions" ট্যাবে ক্লিক করুন
৩. নতুন একটি Workflow Run দেখা যাবে
৪. সবুজ হলে সফল, লাল হলে ব্যর্থ

সার্ভারে ডেপ্লয় করার Workflow:

এখন আসল কাজ — সার্ভারে স্বয়ংক্রিয় ডেপ্লয়:

name: Deploy to DigitalOcean

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      # ধাপ ১: কোড চেক করা
      - name: Checkout Repository
        uses: actions/checkout@v3

      # ধাপ ২: SSH সেটআপ এবং সার্ভারে কানেক্ট
      - name: Deploy to Server
        run: |
          # SSH ফোল্ডার তৈরি করা
          mkdir -p ~/.ssh

          # Private Key সেভ করা (GitHub Secret থেকে আসবে)
          echo "${{ secrets.DO_SSH_KEY }}" > ~/.ssh/id_rsa
          chmod 600 ~/.ssh/id_rsa

          # সার্ভার IP known hosts-এ যোগ করা
          ssh-keyscan -H ${{ secrets.DO_HOST }} >> ~/.ssh/known_hosts

          # সার্ভারে ঢুকে git pull করা
          ssh root@${{ secrets.DO_HOST }} "
            cd /root/session-two &&
            git pull origin main &&
            pm2 restart server
          "

অধ্যায় ১৩: Secrets ও Environment Variables — গোপন তথ্য সুরক্ষা

লক্ষ্য করুন, Workflow ফাইলে সার্ভারের IP সরাসরি লেখা নেই। বরং লেখা আছে ${{ secrets.DO_HOST }}।

এর কারণ: আপনার সার্ভারের IP বা SSH Key সরাসরি কোডে রাখা নিরাপদ নয় — যে কেউ গিটহাবে দেখে ফেলতে পারবে।

GitHub Secrets কীভাবে সেট করবেন?

১. আপনার রিপোতে যান
২. Settings ট্যাবে ক্লিক করুন
৩. বাম পাশে "Secrets and variables" → "Actions" ক্লিক করুন
৪. "New repository secret" বাটনে ক্লিক করুন

যে Secrets যোগ করতে হবে:

Secret নাম	মান কী হবে
`DO_HOST`	আপনার DigitalOcean সার্ভারের IP (যেমন: `209.71.xx.xx`)
`DO_SSH_KEY`	আপনার Private Key-এর পুরো কন্টেন্ট

Private Key কপি করবেন কীভাবে?

# Private Key দেখুন:
cat ~/.ssh/id_rsa

# এই পুরো আউটপুট কপি করুন (-----BEGIN RSA PRIVATE KEY----- থেকে -----END RSA PRIVATE KEY----- পর্যন্ত)

এই পুরো কন্টেন্ট GitHub Secret DO_SSH_KEY-তে পেস্ট করুন।

কোন Key সার্ভারে রাখা থাকবে?

আপনি যে Key pair (id_rsa এবং id_rsa.pub) তৈরি করেছেন, সেই Public Key (id_rsa.pub) আপনার সার্ভারে থাকা দরকার।

DigitalOcean-এ Droplet তৈরির সময় যদি SSH Key দিয়ে থাকেন, তাহলে ওই Public Key সার্ভারে /root/.ssh/authorized_keys ফাইলে সংরক্ষিত আছে।

যদি পরে নতুন Key যোগ করতে চান:

# সার্ভারে ঢুকুন
ssh root@সার্ভার-আইপি

# authorized_keys ফাইলে নতুন Public Key যোগ করুন
echo "এখানে-public-key-পেস্ট-করুন" >> ~/.ssh/authorized_keys

# ফাইলের পারমিশন ঠিক করুন
chmod 600 ~/.ssh/authorized_keys

Secrets কেন আলাদা Key ব্যবহার করা উচিত?

Best Practice হলো: আপনার নিজের সার্ভার এক্সেসের Key এবং GitHub Actions-এর জন্য আলাদা Key তৈরি করুন।

কারণ:

GitHub Actions-এর Key হারিয়ে গেলে শুধু সেই Key বাতিল করলেই হবে
আপনার মূল Key নিরাপদ থাকবে
নিরাপত্তার স্তর বাড়ে

# GitHub Actions-এর জন্য আলাদা Key তৈরি:
ssh-keygen -t rsa -b 4096 -C "github-actions" -f ~/.ssh/github_actions_key

# এই নতুন Public Key সার্ভারে যোগ করুন:
# (সার্ভারে ঢুকে)
echo "$(cat ~/.ssh/github_actions_key.pub)" >> ~/.ssh/authorized_keys

# নতুন Private Key GitHub Secret-এ দিন:
cat ~/.ssh/github_actions_key
# এই আউটপুট DO_SSH_KEY secret-এ পেস্ট করুন

অধ্যায় ১৪: PM2 — Node.js সার্ভার ব্যাকগ্রাউন্ডে চালানো

সমস্যাটা কী?

সার্ভারে Node.js অ্যাপ চালাতে সাধারণত:

node server.js

কিন্তু এই কমান্ড দিলে:

SSH session বন্ধ করলে অ্যাপও বন্ধ হয়ে যায়
সার্ভার রিস্টার্ট হলে অ্যাপ বন্ধ হয়ে যায়
ক্র্যাশ হলে নিজে থেকে পুনরায় চালু হয় না

সমাধান: PM2

PM2 (Process Manager 2) হলো Node.js-এর জন্য একটি Process Manager। এটি আপনার অ্যাপকে ব্যাকগ্রাউন্ডে চালু রাখে।

PM2 ইনস্টল করা:

npm install -g pm2

PM2 দিয়ে অ্যাপ চালু করা:

# অ্যাপ শুরু করা
pm2 start server.js --name my-app

# চলমান প্রসেসের তালিকা দেখা
pm2 list

# লগ দেখা
pm2 logs my-app

# অ্যাপ থামানো
pm2 stop my-app

# অ্যাপ রিস্টার্ট করা
pm2 restart my-app

# অ্যাপ ডিলিট করা
pm2 delete my-app

সার্ভার রিবুটের পরেও PM2 চালু রাখা:

# PM2 কে startup script তৈরি করতে বলুন
pm2 startup

# বর্তমান প্রসেস সেভ করুন
pm2 save

এরপর সার্ভার রিবুট হলেও PM2 স্বয়ংক্রিয়ভাবে আপনার অ্যাপ চালু করবে।

PM2 vs নিজে চালানো:

বিষয়	`node server.js`	PM2
SSH বন্ধ হলে	অ্যাপ বন্ধ	চলতে থাকে
সার্ভার রিবুট হলে	বন্ধ	স্বয়ংক্রিয় চালু
ক্র্যাশ হলে	বন্ধ	স্বয়ংক্রিয় রিস্টার্ট
লগ ম্যানেজমেন্ট	নেই	আছে

অধ্যায় ১৫: সম্পূর্ণ ওয়ার্কফ্লো — শুরু থেকে শেষ পর্যন্ত

এতক্ষণ আমরা আলাদা আলাদা টুকরো দেখলাম। এবার পুরো ছবিটি একসাথে:

একবার সেটআপের কাজ (শুধু প্রথমবার):

১. DigitalOcean-এ সার্ভার কেনা + Ubuntu ইনস্টল
      ↓
২. SSH Key তৈরি (লোকাল মেশিনে)
      ↓
৩. Public Key সার্ভারে যোগ করা
      ↓
৪. সার্ভারে SSH করে ঢোকা
      ↓
৫. সার্ভারে গিট, Node.js, PM2 ইনস্টল
      ↓
৬. সার্ভারে প্রজেক্ট ক্লোন করা (git clone)
      ↓
৭. PM2 দিয়ে অ্যাপ চালু করা
      ↓
৮. GitHub Secrets সেট করা (DO_HOST, DO_SSH_KEY)
      ↓
৯. .github/workflows/deploy.yml তৈরি করা
      ↓
১০. Workflow ফাইল push করা → প্রথম পাইপলাইন টেস্ট

প্রতিদিনের কাজের ওয়ার্কফ্লো (সেটআপের পরে):

আপনি কোড পরিবর্তন করলেন
      ↓
git add .
git commit -m "নতুন ফিচার যোগ"
git push origin main
      ↓
GitHub main branch-এ push দেখে Workflow ট্রিগার হলো
      ↓
GitHub একটি Runner (Ubuntu মেশিন) চালু করল
      ↓
Runner আপনার .yml ফাইলের নির্দেশ মেনে কাজ শুরু করল
      ↓
Runner আপনার DigitalOcean সার্ভারে SSH করল
(Secrets থেকে IP ও Private Key নিল)
      ↓
Runner সার্ভারে গিয়ে "git pull" চালাল
      ↓
সার্ভারে নতুন কোড চলে এলো
      ↓
PM2 restart করা হলো
      ↓
ইউজাররা নতুন ভার্সন দেখতে পেলেন!

সবুজ চেকমার্ক মানে কী?

GitHub Actions ট্যাবে যদি সবুজ চেকমার্ক দেখেন:

✓ Checkout Repository    (সফল)
✓ Deploy to Server       (সফল)

তার মানে সার্ভারে নতুন কোড পৌঁছে গেছে!

লাল ক্রস মানে কী?

✗ Deploy to Server       (ব্যর্থ)

তার মানে কোথাও সমস্যা আছে। এরর মেসেজ পড়ুন, সমস্যা খুঁজুন, ঠিক করুন। এটি স্বাভাবিক — প্রথমবার পাইপলাইন সেটআপে অনেকবার ব্যর্থ হওয়া স্বাভাবিক।

অধ্যায় ১৬: বাস্তব দলে ডেপ্লয়মেন্ট কীভাবে হয়?

পাঠাও, বিকাশ বা বড় কোম্পানিতে কীভাবে কাজ হয় সেটা জানা দরকার।

Branch Strategy (শাখা কৌশল):

main (production) ← সরাসরি push নিষিদ্ধ
  └── develop (staging)
        └── feature/login-page (ডেভেলপারের কাজ)
        └── feature/payment    (আরেকজনের কাজ)
        └── bugfix/checkout    (বাগ ঠিক করা)

প্রতিটি Branch-এ আলাদা Workflow:

# ডেভেলপার branch-এ push করলে → শুধু test চলবে
on:
  push:
    branches: [feature/*, bugfix/*]
jobs:
  test:
    steps:
      - run: npm test

# main-এ merge হলে → production deploy হবে
on:
  push:
    branches: [main]
jobs:
  deploy-production:
    steps:
      - run: ssh ... "git pull && pm2 restart"

Pull Request (PR) Review Process:

১. ডেভেলপার নিজের branch-এ কাজ করে
২. PR তৈরি করে main-এ merge করার অনুরোধ দেয়
৩. CI চলে: টেস্ট পাস না হলে merge করা যাবে না
৪. টিম লিড/সিনিয়র দেখে Approve করেন
৫. Approve হলেই main-এ merge হয়
৬. Merge হওয়া মাত্র Production deploy শুরু হয়

এই প্রক্রিয়ায় ভুলভাল কোড production-এ যাওয়ার সুযোগ অনেক কম।

আরেকটু উন্নত পাইপলাইন (Docker সহ):

Docker ব্যবহার করলে প্রক্রিয়া একটু ভিন্ন:

কোড push হলো
      ↓
CI: Test চলল → Pass হলো
      ↓
Docker Image তৈরি হলো (পুরো অ্যাপ প্যাকেজ করা)
      ↓
Docker Hub/Registry-তে Image push হলো
      ↓
Production সার্ভার নতুন Image pull করল
      ↓
নতুন Container চালু হলো, পুরনো বন্ধ হলো

Docker ব্যবহারে সুবিধা: "আমার মেশিনে চলছে কিন্তু সার্ভারে চলছে না" এই সমস্যা থাকে না।

অধ্যায় ১৭: AI/NLP কোডিং — ভবিষ্যতের কোডিং পদ্ধতি

এই ধারণাটি বোঝা আধুনিক ডেভেলপারদের জন্য অত্যন্ত গুরুত্বপূর্ণ।

NLP Coding কী?

NLP Coding মানে হলো — প্রোগ্রামিং ভাষায় কোড না লিখে, স্বাভাবিক ভাষায় (ইংরেজি, বাংলা) বলে দিলে AI কোড লিখে দেয়।

আগের দুনিয়া:

ডেভেলপার → HTML/CSS/JS হাতে লেখেন → ওয়েবপেজ

এখনকার দুনিয়া:

ডেভেলপার → AI-কে বাংলা/ইংরেজিতে বলেন → AI কোড লেখে → ওয়েবপেজ

উদাহরণ:

AI-কে বলা হলো:

"Please make me a Contact Us form with TailwindCSS, mobile responsive and good looking. Use icons where necessary. Use consistent colors following color theory."

AI সম্পূর্ণ HTML ফর্ম তৈরি করে দিল।

এর মানে কি ডেভেলপারদের কাজ নেই?

না! বরং উল্টো। AI ভালো আউটপুট দেওয়ার জন্য আপনাকে জানতে হবে:

Frontend Terminology: "color theory", "information hierarchy", "responsive design" — এই শব্দগুলো না জানলে AI-কে সঠিকভাবে বলতে পারবেন না
কী লেখা আছে সেটা বোঝার ক্ষমতা: AI যা লিখে দেয় তা আপনি বুঝতে না পারলে বাগ ঠিক করতে পারবেন না
সিদ্ধান্ত নেওয়ার ক্ষমতা: AI কি লিখল সেটা সঠিক কিনা বোঝার জন্য ফান্ডামেন্টাল জ্ঞান দরকার

AI-এর সীমাবদ্ধতা:

একটি বাস্তব অভিজ্ঞতার কথা মনে রাখুন: AI দিয়ে ক্লাস প্রিপেয়ার করতে ১০-১২ ঘণ্টা লেগেছিল। কারণ এক জায়গায় এরর হয়েছিল যেটা AI ঠিক করতে পারছিল না।

AI দিয়ে কাজ দ্রুত হয়, কিন্তু জটিল সমস্যায় এখনো মানুষের বিচারবুদ্ধি দরকার।

কীভাবে AI দিয়ে ভালো কাজ করবেন?

স্পষ্টভাবে বলুন: যত বেশি বিস্তারিত, তত ভালো আউটপুট
Technical term ব্যবহার করুন: "TailwindCSS", "responsive", "modal" — এই ধরনের শব্দ AI ভালো বোঝে
Iteratively কাজ করুন: প্রথম আউটপুট মনমতো না হলে আরো বিস্তারিত বলুন
ফলাফল যাচাই করুন: AI যা দেয় সেটা অন্ধভাবে ব্যবহার না করে বুঝে নিন

অধ্যায় ১৮: পরবর্তী পদক্ষেপ ও রিসোর্স

এখনই যা করুন:

১. একটি ছোট সার্ভার কিনুন

মাসে $4-5 দিয়ে DigitalOcean বা লোকাল প্রোভাইডার থেকে একটি Linux সার্ভার নিন। এটি আপনার শেখার হাতিয়ার।

২. একটি সরল প্রজেক্ট ডেপ্লয় করুন

একটি সাধারণ HTML/CSS/JS পেজ বা Node.js অ্যাপ ডেপ্লয় করুন। প্রথমবার ম্যানুয়ালি করুন, তারপর GitHub Actions দিয়ে।

৩. GitHub Actions ডকুমেন্টেশন পড়ুন

GitHub-এর অফিশিয়াল ডকুমেন্টেশন পড়ুন:

Workflow syntax বুঝুন
বিভিন্ন Action ব্যবহার করে দেখুন

৪. Bash Scripting শিখুন

৩-৪ দিন Bash Scripting দেখুন। এটি deployment পাইপলাইনের জন্য অপরিহার্য।

সিভিতে যা যোগ করতে পারবেন:

এই বিষয়গুলো শিখলে আপনার সিভিতে লিখতে পারবেন:

Technical Skills:
- CI/CD Pipeline Setup (GitHub Actions)
- Cloud Server Management (DigitalOcean/AWS)
- Linux Server Administration (Ubuntu)
- SSH Key Management
- PM2 Process Management
- Git/GitHub Workflow

এই দক্ষতাগুলো চাকরির বাজারে অত্যন্ত মূল্যবান।

গুরুত্বপূর্ণ বিষয়গুলো মনে রাখুন:

┌─────────────────────────────────────────────────────┐
│  মূল শিক্ষা                                        │
│  ──────────                                         │
│  ✓ তিনটি মেশিন: Local → GitHub → Server            │
│  ✓ পোর্ট 22 = SSH টানেলিং                          │
│  ✓ পোর্ট 80/443 = HTTP/HTTPS                        │
│  ✓ SSH Key: Private আপনার কাছে, Public সার্ভারে    │
│  ✓ GitHub Actions = কোড push হলে স্বয়ংক্রিয় কাজ  │
│  ✓ Runner = GitHub-এর সাময়িক সার্ভার               │
│  ✓ YAML ফাইল = পাইপলাইনের নির্দেশনা               │
│  ✓ Secrets = গোপন তথ্য নিরাপদে সংরক্ষণ            │
│  ✓ PM2 = Node.js অ্যাপ ব্যাকগ্রাউন্ডে রাখা         │
└─────────────────────────────────────────────────────┘

উপসংহার

সফটওয়্যার ডেপ্লয়মেন্ট প্রথম দেখায় জটিল মনে হয়। কিন্তু মূল ধারণাগুলো বুঝলে এটি একটি পরিষ্কার এবং যুক্তিসঙ্গত প্রক্রিয়া।

মনে রাখুন: ফান্ডামেন্টাল একই, প্ল্যাটফর্ম যেটাই হোক। DigitalOcean, AWS, Azure, GCP — সবজায়গায় SSH, পোর্ট, Key Management, এবং CI/CD-এর ধারণা একই।

প্রথমবার সেটআপে ভুল হবে, অনেক error দেখবেন — এটা স্বাভাবিক। প্রতিটি error আপনাকে একটু বেশি শেখায়।

একটি সার্ভার কিনুন, একটি পাইপলাইন বানান, নিজের প্রজেক্ট deploy করুন — শেখার এটাই সেরা পথ।

SDLC-1

Saiful Islam — Sun, 07 Jun 2026 19:25:28 +0000

সফটওয়্যার ইঞ্জিনিয়ারিং: একটি সম্পূর্ণ বাংলা গাইড

শূন্য থেকে ডেপ্লয়মেন্ট পর্যন্ত

পাঠকের উদ্দেশ্যে: এই বইটি একটি পূর্ণ দিনের বুটক্যাম্প সেশনের উপর ভিত্তি করে রচিত। বইয়ের প্রতিটি অধ্যায় এতটাই বিস্তারিতভাবে লেখা হয়েছে যাতে একজন পাঠক মূল ভিডিও না দেখেও সম্পূর্ণ জ্ঞান অর্জন করতে পারেন।

বইটি রচিত হয়েছে হিরা হাসানের সফটওয়্যার ইঞ্জিনিয়ারিং ডে-লং বুটক্যাম্প সেশনের উপর ভিত্তি করে।

সূচিপত্র

প্রথম অধ্যায়: সফটওয়্যার কী এবং কেন দরকার
দ্বিতীয় অধ্যায়: সফটওয়্যার ডেভেলপমেন্ট লাইফ সাইকেল (SDLC)
তৃতীয় অধ্যায়: সফটওয়্যারের প্রযুক্তিগত কাঠামো
চতুর্থ অধ্যায়: ডেস্কটপ অ্যাপ্লিকেশন — Python দিয়ে হাতে-কলমে
পঞ্চম অধ্যায়: ওয়েব অ্যাপ্লিকেশন — HTML, CSS ও জাভাস্ক্রিপ্ট
ষষ্ঠ অধ্যায়: ব্যাক-এন্ড ডেভেলপমেন্ট — Node.js ও Express.js
সপ্তম অধ্যায়: Git ও GitHub — ভার্সন কন্ট্রোল
অষ্টম অধ্যায়: ক্লাউড সার্ভার ও ডেপ্লয়মেন্ট
নবম অধ্যায়: রিয়েল-টাইম অ্যাপ্লিকেশন — Socket.io দিয়ে চ্যাট অ্যাপ
দশম অধ্যায়: CI/CD পাইপলাইন
একাদশ অধ্যায়: ক্যারিয়ার পথ ও অর্থ উপার্জনের উপায়

প্রথম অধ্যায়: সফটওয়্যার কী এবং কেন দরকার

১.১ সফটওয়্যার কি জিনিস?

আমরা প্রতিদিন ফেসবুক ব্যবহার করি, বিকাশ দিয়ে টাকা পাঠাই, Google Map দিয়ে রাস্তা খুঁজি — এগুলো সবই সফটওয়্যার। কিন্তু সফটওয়্যার আসলে কী?

সহজ ভাষায়, সফটওয়্যার হলো নির্দেশনার একটি সেট যা কম্পিউটারকে বলে দেয় কী করতে হবে। যেমন একটি রেসিপি বই রান্নার নির্দেশনা দেয়, তেমনি সফটওয়্যার কম্পিউটারকে নির্দিষ্ট কাজ করার নির্দেশনা দেয়।

কিন্তু শুধু সংজ্ঞা জেনে লাভ নেই। আরও গুরুত্বপূর্ণ প্রশ্ন হলো — আমরা সফটওয়্যার কেন বানাই?

১.২ সফটওয়্যার বানানোর তিনটি প্রধান কারণ

মডার্ন সফটওয়্যার ডেভেলপমেন্টের পেছনে তিনটি মূল কারণ রয়েছে। এগুলো বুঝলে সফটওয়্যার জগতটা অনেক পরিষ্কার হয়ে যায়।

কারণ ১: বড় হিসাব-নিকাশ স্বয়ংক্রিয় করা (Calculation Automation)

একটি সহজ উদাহরণ দিয়ে শুরু করি।

ধরুন কেউ আপনাকে বললো: ১২ + ১২ = ?

এটা আপনার মস্তিষ্ক সহজেই করতে পারে। কোনো ক্যালকুলেটর লাগে না।

এবার: ১২৩৪৫৬ ÷ ৫৬ × ৩ + ৭৮৯ − ৪৫৬ = ?

এখন একটু কঠিন হয়ে গেল। ক্যালকুলেটর লাগতে পারে।

কিন্তু এবার কল্পনা করুন: বাংলাদেশের প্রায় ১৭ কোটি মানুষের বয়সের গড় বের করতে হবে। সবার জন্মতারিখ আছে। এই হিসাব মানুষের পক্ষে করা কার্যত অসম্ভব। কিন্তু একটি কম্পিউটার মাত্র কয়েক সেকেন্ডে করে ফেলতে পারে।

এই কাজের জন্যই সফটওয়্যার দরকার।

আরও উদাহরণ:

Google Maps যখন ঢাকা থেকে চট্টগ্রামের সবচেয়ে দ্রুততম রুট বের করে — এটা একটা জটিল অ্যালগরিদম চলছে
ChatGPT যখন আপনার প্রশ্নের উত্তর দেয় — এটা বিশাল গাণিতিক হিসাব
ফেসবুক যখন আপনার বন্ধুদের খুঁজে বের করে — এটা সার্চ অ্যালগরিদম

সারাংশ: যখন কোনো কাজ এত বড় বা জটিল যে মানুষের পক্ষে করা কঠিন বা সময়সাপেক্ষ, তখন সফটওয়্যার সেটা স্বয়ংক্রিয়ভাবে করে দেয়।

কারণ ২: ডেটা আদান-প্রদান (Data Communication)

চিন্তা করুন — ৩০ বছর আগে মানুষ কীভাবে যোগাযোগ করতো?

ধাপ ১ — টেলিফোন যুগ:
একটা টেলিফোন ডায়াল করলে অপর প্রান্তে ঘণ্টি বাজতো। উত্তর দিলে কথা হতো। দুটো ডিভাইস একটি তার বা রেডিও লিংকের মাধ্যমে যুক্ত থাকতো। সংযোগ স্থাপিত হলে ভয়েস ডেটা ট্র্যাভেল করতো।

ধাপ ২ — মোবাইল ফোন যুগ:
নোকিয়া ১১০০-এর মতো মোবাইল ফোন এলো। তারবিহীন যোগাযোগ হলো। কিন্তু সেই ফোনে ওয়েবসাইট দেখা যেতো না।

ধাপ ৩ — ইন্টারনেট ও স্মার্টফোন যুগ:
অ্যান্ড্রয়েড ফোন আর ওয়েবসাইট — এই দুটো প্রায় একই সময়ে বিশাল আকারে বিস্তার লাভ করলো। এখন আপনি ঢাকায় বসে আমেরিকায় থাকা বন্ধুকে WhatsApp বা Facebook Messenger দিয়ে বিনামূল্যে ভিডিও কল করতে পারছেন।

এই যোগাযোগটা কীভাবে হচ্ছে? ইন্টারনেটের মাধ্যমে। আর ইন্টারনেটের মাধ্যমে এই যোগাযোগ সম্ভব করতে সফটওয়্যার লাগে।

উদাহরণ: আপনি যখন WhatsApp-এ বার্তা পাঠান, আপনার বার্তাটা:

আপনার ফোন থেকে WhatsApp-এর সার্ভারে যায়
সার্ভার থেকে আপনার বন্ধুর ফোনে যায়
এই পুরো প্রক্রিয়া সফটওয়্যার পরিচালনা করে

সারাংশ: এক জায়গা থেকে আরেক জায়গায় ডেটা পাঠানোর জন্য — ভয়েস, ভিডিও, ছবি, টেক্সট — সব কিছুর জন্য সফটওয়্যার দরকার।

কারণ ৩: এন্টারপ্রাইজ ডেটা ম্যানেজমেন্ট (Enterprise Data Storage & Access)

বড় প্রতিষ্ঠানগুলোর কথা ভাবুন — ব্যাংক, বীমা কোম্পানি, সরকার।

উদাহরণ — ব্যাংকিং সফটওয়্যার:

ধরুন আপনার Standard Chartered ব্যাংকের অ্যাকাউন্টে ১,০০০ টাকা আছে। আপনি একই সময়ে তিনটি ATM বুথ থেকে ৫০০ টাকা করে তোলার চেষ্টা করা হচ্ছে (আপনার কার্ড ও PIN তিনজন জানে)।

মোট তোলার চেষ্টা: ৫০০ × ৩ = ১,৫০০ টাকা
কিন্তু অ্যাকাউন্টে আছে: ১,০০০ টাকা

এই পরিস্থিতিতে কী হওয়া উচিত? কাউকে সর্বোচ্চ ১,০০০ টাকা তুলতে দেওয়া উচিত, বাকিদের না। এই কাজটা কীভাবে হয়?

তিনটি ATM বুথ একটি কেন্দ্রীয় ডেটাবেসের সাথে যুক্ত থাকে। প্রথম ৫০০ টাকা তোলার সাথে সাথে ডেটাবেস আপডেট হয়ে যায় (১,০০০ − ৫০০ = ৫০০)। দ্বিতীয় ও তৃতীয় বুথ থেকে তোলার চেষ্টা করলে সিস্টেম জানে যে মাত্র ৫০০ টাকা আছে।

এই পুরো সিস্টেম পরিচালনার জন্য সফটওয়্যার লাগে।

আরও বড় উদাহরণ: Standard Chartered ব্যাংকের শাখা আছে বাংলাদেশে, ভারতে এবং আমেরিকায়। আপনি বাংলাদেশ থেকে ২০০ টাকা তুললেন, ভারত থেকে ১০০ টাকা তুললেন, আমেরিকা থেকে ১৫০ টাকা তুললেন — সব লেনদেন একটি কেন্দ্রীয় লেজার বইতে রেকর্ড হয়। এটা সম্ভব করে সফটওয়্যার।

সারাংশ: বড় প্রতিষ্ঠানগুলো তাদের বিশাল পরিমাণ ডেটা সংরক্ষণ, প্রক্রিয়াকরণ ও বিতরণের জন্য সফটওয়্যার ব্যবহার করে।

১.৩ ইন্টারনেট কীভাবে কাজ করে — সহজ ভাষায়

সফটওয়্যার বোঝার আগে ইন্টারনেট বোঝাটা জরুরি।

ইন্টারনেট হলো ডিভাইসগুলোর একটি বিশাল নেটওয়ার্ক। পৃথিবীর প্রতিটি কম্পিউটার, মোবাইল, সার্ভার — সবকিছু কোনো না কোনোভাবে যুক্ত।

এই যোগাযোগ দুটো উপায়ে হয়:

১. তার (Wired): বাংলাদেশ থেকে আমেরিকার সাথে যোগাযোগ হয় সমুদ্রের তলদেশ দিয়ে যাওয়া সাবমেরিন ক্যাবলের মাধ্যমে। এই তারগুলো হাজার হাজার কিলোমিটার লম্বা।

২. তারবিহীন (Wireless): মোবাইল টাওয়ার, ওয়াইফাই, এবং এখন স্যাটেলাইট ইন্টারনেট (যেমন Starlink)। স্যাটেলাইট ইন্টারনেটের সুবিধা হলো পৃথিবীর যেকোনো জায়গা থেকে একই সংযোগ ব্যবহার করা যায়।

IP Address কী?
পৃথিবীর প্রতিটি ডিভাইসের একটি অনন্য ঠিকানা আছে — এটাকে বলে IP Address। যেমন আপনার বাড়ির ঠিকানা আছে, তেমনি প্রতিটি কম্পিউটারের ঠিকানা আছে। এই ঠিকানার মাধ্যমেই ডেটা সঠিক গন্তব্যে পৌঁছায়।

১.৪ সফটওয়্যারের তিনটি পক্ষ (Parties)

যেকোনো সফটওয়্যারে সাধারণত তিনটি পক্ষ জড়িত থাকে:

১. ডেভেলপার (Developer):
যারা সফটওয়্যার বানায়। সিনেমার উপমায় — যারা ক্যামেরা চালায়, অভিনয় করায়, সিনেমা এডিট করে। ফেসবুকের ডেভেলপাররা ফেসবুক তৈরি করেছে।

২. এন্ড ইউজার (End User / Client):
যারা সফটওয়্যার ব্যবহার করে। আমরা যখন ফেসবুক চালাই, আমরা ইউজার। তারা টেকনিক্যাল জিনিস না জানলেও চলে।

৩. মালিক / বিজনেস ওনার (Owner):
যিনি সফটওয়্যার বানানোর উদ্যোগ নেন এবং বিনিয়োগ করেন। মার্ক জাকারবার্গ ফেসবুকের মালিক। তিনি সরাসরি কোড না লিখলেও ব্যবসায়িক সিদ্ধান্ত নেন।

বাস্তব উদাহরণ:

মালিক: মার্ক জাকারবার্গ
ডেভেলপার: ফেসবুকের ইঞ্জিনিয়াররা
ইউজার: আমরা সবাই যারা ফেসবুক চালাই

১.৫ সফটওয়্যারের প্রধান বিভাগ

আধুনিক যুগে সফটওয়্যার তিন ধরনের হয়:

১. ক্যালকুলেশন-ভিত্তিক সফটওয়্যার:
বড় হিসাব করে, যেমন বৈজ্ঞানিক গবেষণার সফটওয়্যার, AI সিস্টেম।

২. কমিউনিকেশন-ভিত্তিক সফটওয়্যার:
মানুষকে সংযুক্ত রাখে — WhatsApp, Facebook, Gmail।

৩. এন্টারপ্রাইজ সফটওয়্যার:
বড় প্রতিষ্ঠানের ব্যবস্থাপনার জন্য — ব্যাংকিং সিস্টেম, হাসপাতাল ম্যানেজমেন্ট, সরকারি রেকর্ড।

নতুন সংযোজন — AI ডোমেইন:
আজকের যুগে চতুর্থ একটি বিভাগ যুক্ত হয়েছে। AI-ভিত্তিক সফটওয়্যার, যা মূলত প্রথম বিভাগেরই উন্নত রূপ। বিশাল পরিমাণ ডেটা ব্যবহার করে বুদ্ধিমান সিদ্ধান্ত নেওয়ার ক্ষমতা অর্জন করে।

দ্বিতীয় অধ্যায়: সফটওয়্যার ডেভেলপমেন্ট লাইফ সাইকেল (SDLC)

২.১ লাইফ সাইকেল মানে কী?

মানুষের জীবনচক্র আমরা স্কুলে পড়েছি — জন্ম, শৈশব, কৈশোর, যৌবন, বার্ধক্য, মৃত্যু। ব্যাঙের জীবনচক্র আমরা জীববিজ্ঞানে পড়েছি।

ঠিক তেমনি, সফটওয়্যারেরও একটি জীবনচক্র আছে। একটি সফটওয়্যার কীভাবে শুরু হয়, কীভাবে তৈরি হয়, কীভাবে মানুষের কাছে পৌঁছায়, এবং কীভাবে রক্ষণাবেক্ষণ হয় — এটাই SDLC বা Software Development Life Cycle।

SDLC বোঝা গুরুত্বপূর্ণ কারণ:

একটি সফটওয়্যারে কতজন মানুষ কাজ করে তা বোঝা যায়
কোথায় সমস্যা হলে কী পরিমাণ ক্ষতি হয় তা বোঝা যায়
ক্যারিয়ার পথ বেছে নেওয়া সহজ হয়

২.২ SDLC-এর ধাপগুলো

একটি সফটওয়্যার তৈরির প্রক্রিয়া নিচের ধাপে হয়:

ধাপ ১: পরিকল্পনা (Planning) — বিজনেস ওনারের ভূমিকা

সফটওয়্যারের ধারণা প্রথমে আসে মালিকের মাথায়।

উদাহরণ: ধরুন একজন উদ্যোক্তা ভাবছেন একটি রাইড-শেয়ারিং অ্যাপ বানাবেন (Uber-এর মতো)। তার মাথায় আসে:

আমি এটা বানাবো
প্রতি বছর কোটি টাকা আয় করবো
আমার একটি মোবাইল অ্যাপ লাগবে

মালিক এই পর্যায়ে টেকনিক্যাল বিষয় জানেন না। তিনি শুধু ব্যবসায়িক পরিকল্পনা করেন।

এই পর্যায়ে যে ডকুমেন্ট তৈরি হয় তাকে বলে BRD — Business Requirements Document (ব্যবসায়িক প্রয়োজনীয়তার দলিল)।

BRD-তে কী থাকে:

সফটওয়্যার কী করবে (হাই-লেভেলে)
ব্যবসায়িক লক্ষ্য কী
কোন ধরনের পেমেন্ট গ্রহণ করবে
কোন পণ্য বা সেবা বিক্রি হবে
সপ্তাহের ৭ দিন ২৪ ঘণ্টা চলতে হবে কি না

গুরুত্বপূর্ণ বিষয়: BRD-তে কোনো টেকনিক্যাল বিষয় থাকে না। ডেটাবেস কী, কোন প্রোগ্রামিং ভাষা ব্যবহার হবে — এসব মালিকের দরকার নেই।

ধাপ ২: বিশ্লেষণ (Analysis) — বিজনেস অ্যানালিস্টের ভূমিকা

মালিকের BRD পেয়ে বিজনেস অ্যানালিস্টরা কাজ শুরু করেন।

বিজনেস অ্যানালিস্ট কী করেন:

ব্যবসাটি আসলেই লাভজনক হবে কি না তা যাচাই করেন
বাজারে এই পণ্যের চাহিদা আছে কি না দেখেন
প্রতিযোগীরা কে কে — Uber-এর মতো অ্যাপ কতটি আছে, তাদের মার্কেট শেয়ার কত
লাভ-লোকসানের সম্ভাবনা কী
ঝুঁকি কোথায়

অ্যানালিস্টরা বলতে পারেন "ভাই, এই ব্যবসায় লোকসান হবে, যাবেন না" — অথবা "এখানে বিশাল সুযোগ আছে, তাড়াতাড়ি বিনিয়োগ করুন।"

ধাপ ৩: পণ্য বিশ্লেষণ (Product Analysis) — প্রোডাক্ট ম্যানেজারের ভূমিকা

বিজনেস অ্যানালিসিসের পরে আসেন প্রোডাক্ট ম্যানেজার।

প্রোডাক্ট ম্যানেজার কী করেন:
প্রোডাক্ট ম্যানেজার সেতুবন্ধন করেন ব্যবসার উদ্দেশ্য এবং ব্যবহারকারীর চাহিদার মধ্যে।

তারা ভাবেন:

ব্যবহারকারী কী চায়?
অ্যাপে কোন কোন ফিচার থাকলে ব্যবহারকারীরা খুশি হবে?
বিকাশ অ্যাপের নিচে যে বার থাকে সেটা কি এইভাবে থাকা উচিত?
ফিচার লিস্ট কী হবে?

কীভাবে তথ্য সংগ্রহ করেন:

ব্যবহারকারীদের সার্ভে করেন
প্রতিযোগী অ্যাপ ব্যবহার করে দেখেন
Product Hunt (producthunt.com) এ নতুন পণ্য খোঁজেন
Tech Crunch-এর মতো ওয়েবসাইট পড়েন
ব্যবহারকারীর আচরণ সংক্রান্ত গবেষণাপত্র পড়েন

চূড়ান্ত আউটপুট কী:
প্রোডাক্ট ম্যানেজার একটি Wireframe তৈরি করেন। Wireframe হলো অ্যাপের হাতে আঁকা কাঠামো — কোথায় কী থাকবে সেটার প্রাথমিক রূপরেখা।

এটা সুন্দর ডিজাইন নয়। কাগজে পেন্সিল দিয়ে আঁকা হতে পারে। কিন্তু এটা থেকে বোঝা যায়:

এই বাটনে ক্লিক করলে কোথায় যাবে
কোন স্ক্রিনে কী থাকবে
ব্যবহারকারীর যাত্রা কেমন হবে (User Journey)

User Requirements Document (URD): প্রোডাক্ট ম্যানেজারের কাজের চূড়ান্ত ফলাফল হলো URD। এতে ফিচারগুলো তালিকাবদ্ধ করা থাকে।

উদাহরণ:

ব্যবহারকারীরা লগইন ছাড়া কোনো পণ্য অর্ডার করতে পারবে না
লগইন ছাড়া অবস্থান দেখা যাবে না
ব্যবহারকারীরা পণ্যের ক্যাটালগ দেখতে পারবে

ধাপ ৪: ডিজাইন (Design) — UI/UX ডিজাইনারের ভূমিকা

প্রোডাক্ট ম্যানেজারের Wireframe পেয়ে UI/UX ডিজাইনাররা কাজ শুরু করেন।

UI (User Interface): অ্যাপটি দেখতে কেমন — রঙ, ফন্ট, বোতামের আকার।

UX (User Experience): ব্যবহারকারীর অভিজ্ঞতা — অ্যাপ ব্যবহার করা কতটা সহজ।

তারা কী তৈরি করেন:
Figma বা Adobe XD সফটওয়্যার ব্যবহার করে সম্পূর্ণ অ্যাপের চেহারা তৈরি করেন। এটা দেখতে একদম আসল অ্যাপের মতো, কিন্তু এটা ক্লিক করলে কাজ করে না। এটা শুধু "দেখার জন্য" — কোড নেই।

কারা Figma ব্যবহার করেন:
গ্রাফিক ডিজাইনার, UI ডিজাইনার — যারা Figma বা Photoshop জানেন।

ধাপ ৫: বাস্তবায়ন (Implementation) — ডেভেলপমেন্ট টিমের ভূমিকা

এখন সফটওয়্যার ডেভেলপাররা কাজ শুরু করেন।

তাদের কাছে থাকে:

প্রোডাক্ট ম্যানেজারের Requirements Document
UI/UX টিমের ডিজাইন ফাইল

এই দুটো ইনপুট নিয়ে তারা আসল সফটওয়্যার কোড লেখেন।

ডেভেলপমেন্ট টিমের ভেতরে কত রকম ভূমিকা:

ফ্রন্ট-এন্ড ডেভেলপার (যা ব্যবহারকারী দেখেন)
ব্যাক-এন্ড ডেভেলপার (সার্ভারের কাজ)
ডেটাবেস অ্যাডমিনিস্ট্রেটর
DevOps ইঞ্জিনিয়ার
টিম লিড

কাজ ম্যানেজ করার পদ্ধতি:
কাজগুলো ছোট ছোট ভাগে ভাগ করা হয়। Scrum এবং Kanban নামের পদ্ধতি ব্যবহার করা হয়। এগুলো দিয়ে ট্র্যাক রাখা হয় কে কোন কাজ করছেন, কোন কাজ শেষ হয়েছে, কোথায় সমস্যা আছে।

ধাপ ৬: টেস্টিং (Testing) — QA টিমের ভূমিকা

সফটওয়্যার বানানো হলে সরাসরি বাজারে ছাড়া হয় না। আগে টেস্ট করা হয়।

কেন টেস্টিং দরকার:
কল্পনা করুন বিকাশ অ্যাপে এমন বাগ আছে যে কারো অ্যাকাউন্টে টাকা না থাকলেও সে ক্যাশআউট করতে পারছে। এটা কোম্পানির জন্য বিপর্যয়কর।

টেস্টিংয়ের ধরন:

ম্যানুয়াল টেস্টিং: মানুষ হাতে হাতে প্রতিটি ফিচার যাচাই করেন
অটোমেটেড টেস্টিং: কোড লিখে স্বয়ংক্রিয়ভাবে টেস্ট করা হয়
ব্ল্যাকবক্স টেস্টিং: ভেতরের কোড না জেনে বাইরে থেকে টেস্ট
স্যানিটি টেস্ট: মূল ফিচারগুলো সঠিক কাজ করছে কি না দেখা

টেস্টিং একটি আলাদা ক্যারিয়ার:
বাংলাদেশে এবং বিশ্বে QA (Quality Assurance) ইঞ্জিনিয়ার হিসেবে ক্যারিয়ার গড়া যায়। এটি একটি সম্পূর্ণ আলাদা পেশা।

ধাপ ৭: ডেপ্লয়মেন্ট (Deployment) — ব্যবহারকারীর কাছে পৌঁছানো

টেস্টিং শেষে সফটওয়্যার ডেপ্লয় করা হয় — মানে ব্যবহারকারীদের কাছে পৌঁছানো হয়।

প্রথমে Internal Release: কোম্পানির ভেতরের মানুষজন প্রথমে ব্যবহার করেন।

তারপর Public Release: সাধারণ ব্যবহারকারীরা অ্যাপ আপডেট পান।

ডেপ্লয়মেন্টের পর যদি বাগ থাকে:

ব্যবহারকারীরা রিপোর্ট করেন
সেটা Bug Board-এ যায়
ডেভেলপমেন্ট টিম সমস্যা সমাধান করে
পরবর্তী আপডেটে ঠিক হয়

ধাপ ৮: রক্ষণাবেক্ষণ (Maintenance)

সফটওয়্যার ডেপ্লয়ের পরেও কাজ শেষ হয় না।

মেইনটেন্যান্সের কাজগুলো:

নিরাপত্তা আপডেট (Security Patches)
নতুন ফিচার যোগ করা
সার্ভার পর্যবেক্ষণ করা
পারফরম্যান্স উন্নত করা
বাগ ফিক্স করা

মেইনটেন্যান্সে কারা কাজ করেন:

DevOps টিম
Cloud ইঞ্জিনিয়ার
Cybersecurity টিম
সফটওয়্যার ডেভেলপার

২.৩ SDLC একটি চক্র — শেষ নেই

SDLC কখনো শেষ হয় না। সফটওয়্যার মেইনটেন্যান্সের পরে নতুন ফিচার আসে, নতুন ফিচারের জন্য আবার পরিকল্পনা হয়, আবার বিশ্লেষণ হয়, আবার ডিজাইন হয়...

এটা একটি অসীম চক্র।

আধুনিক পদ্ধতি: আধুনিক সফটওয়্যার ডেভেলপমেন্টে কখনো "সব ফিচার একসাথে বানিয়ে তারপর রিলিজ" করা হয় না। ছোট ছোট অংশে (Incremental) ডেভেলপ করা হয়:

একটু বানাও
টেস্ট করো
রিলিজ করো
ব্যবহারকারীর মতামত নাও
আবার শুরু করো

২.৪ সবচেয়ে বড় সমস্যা: ভুল বোঝাবুঝি (Miscommunication)

SDLC-তে সবচেয়ে বড় সমস্যা হলো তথ্যের ভুল বোঝাবুঝি।

কীভাবে হয়:
মালিক একটি বিষয় ভাবলেন → বিজনেস অ্যানালিস্ট অন্যভাবে বুঝলেন → প্রোডাক্ট ম্যানেজার আরেকভাবে ব্যাখ্যা করলেন → ডেভেলপার ভিন্নভাবে কোড লিখলেন → ব্যবহারকারী একদম অন্য জিনিস চেয়েছিলেন।

সমাধান: স্পষ্ট যোগাযোগ। সফটওয়্যার ইঞ্জিনিয়ারের সবচেয়ে গুরুত্বপূর্ণ দক্ষতা কোড লেখা নয়, বরং পরিষ্কার যোগাযোগ করার ক্ষমতা।

ভুল বোঝাবুঝির খরচ: যদি শেষ ধাপে (ডেভেলপমেন্ট) ভুল ধরা পড়ে, তাহলে সব ধাপ আবার করতে হতে পারে — এটা অত্যন্ত ব্যয়বহুল।

২.৫ AI যুগে সফটওয়্যার ডেভেলপমেন্ট

অনেকে ভাবেন AI আসলে কি সফটওয়্যার ডেভেলপারের কাজ শেষ হয়ে যাবে?

উত্তর হলো — না।

কারণগুলো:

ব্যবসা বোঝা: ব্যবসার উদ্দেশ্য কী, সফটওয়্যার সেটা পূরণ করছে কি না — এটা AI বুঝতে পারে না।
যোগাযোগ: ক্লায়েন্টের সাথে কথা বলে সঠিক চাহিদা বোঝা।
টেস্টিং: সফটওয়্যার সঠিকভাবে কাজ করছে কি না যাচাই।
স্কেল করা: লক্ষ লক্ষ ব্যবহারকারীর জন্য সফটওয়্যার চলবে কি না।
নতুন প্রযুক্তি: নতুন প্রযুক্তি এলে নতুন ইঞ্জিনিয়ারিং দরকার।

AI একটি শক্তিশালী সহকারী। কিন্তু মানুষের বিচার এবং সিদ্ধান্তের বিকল্প নয়।

তৃতীয় অধ্যায়: সফটওয়্যারের প্রযুক্তিগত কাঠামো

৩.১ সফটওয়্যারের তিনটি মূল অংশ

যেকোনো আধুনিক সফটওয়্যারের তিনটি অংশ থাকে:

┌──────────────────────────────────────────────────┐
│                    CLIENT SIDE                    │
│         (ব্যবহারকারীর ডিভাইসে চলে)              │
│   Mobile App | Browser | Desktop App             │
└──────────────────────┬───────────────────────────┘
                       │  ইন্টারনেট
                       │
┌──────────────────────┴───────────────────────────┐
│                    SERVER SIDE                    │
│          (সার্ভারে চলে, ব্যবহারকারী দেখেন না)   │
│         API | Business Logic | Auth               │
└──────────────────────┬───────────────────────────┘
                       │
┌──────────────────────┴───────────────────────────┐
│                    DATABASE                       │
│              (ডেটা সংরক্ষণ করে)                 │
│      PostgreSQL | MySQL | MongoDB | Redis         │
└──────────────────────────────────────────────────┘

অংশ ১: ক্লায়েন্ট সাইড (Client Side / Front-End)

সংজ্ঞা: ব্যবহারকারীর ডিভাইসে যে সফটওয়্যার চলে সেটা ক্লায়েন্ট সাইড।

উদাহরণ:

আপনার ফোনে বিকাশ অ্যাপ → ক্লায়েন্ট সাইড
আপনার ব্রাউজারে Facebook.com → ক্লায়েন্ট সাইড
আপনার কম্পিউটারে VS Code → ক্লায়েন্ট সাইড

তিন ধরনের ক্লায়েন্ট:

মোবাইল অ্যাপ: Android বা iOS ফোনে চলে। বিতরণ হয় Play Store বা App Store-এর মাধ্যমে।
ওয়েব অ্যাপ: ব্রাউজার (Chrome, Firefox) দিয়ে চলে। HTML, CSS, JavaScript দিয়ে তৈরি।
ডেস্কটপ অ্যাপ: কম্পিউটারে সরাসরি ইনস্টল হয়।

অংশ ২: সার্ভার সাইড (Server Side / Back-End)

সংজ্ঞা: ইন্টারনেটে যুক্ত একটি কম্পিউটার যেখানে সফটওয়্যারের মূল যুক্তি চলে।

সার্ভার কী:
সার্ভার একটি সাধারণ কম্পিউটারের মতোই। পার্থক্য হলো এটি:

সবসময় চালু থাকে (২৪/৭)
ইন্টারনেটে সংযুক্ত থাকে
অনেক মানুষের রিকোয়েস্ট একসাথে সামলাতে পারে

উদাহরণ: আপনি যখন Facebook খোলেন, আপনার ব্রাউজার Facebook-এর সার্ভারে রিকোয়েস্ট পাঠায়। সার্ভার আপনার নিউজফিড ডেটা পাঠায়। আপনার ব্রাউজার সেটা সুন্দর করে দেখায়।

অংশ ৩: ডেটাবেস (Database)

সংজ্ঞা: ডেটা স্থায়ীভাবে সংরক্ষণ করার ব্যবস্থা।

কেন ডেটাবেস দরকার:
কল্পনা করুন বিকাশের কোটি কোটি গ্রাহকের তথ্য। এই তথ্য কোথাও রাখতে হবে। সার্ভার বন্ধ হলেও ডেটা যেন না যায়।

ডেটাবেসের ধরন:

SQL ডেটাবেস: MySQL, PostgreSQL (টেবিল আকারে ডেটা রাখে)
NoSQL ডেটাবেস: MongoDB (নমনীয় কাঠামোতে ডেটা রাখে)
Cache: Redis (দ্রুত অ্যাক্সেসের জন্য অস্থায়ী সংরক্ষণ)

৩.২ HTTP প্রোটোকল — ক্লায়েন্ট ও সার্ভারের কথা বলার ভাষা

ক্লায়েন্ট এবং সার্ভার কীভাবে কথা বলে? তারা ব্যবহার করে HTTP (HyperText Transfer Protocol)।

HTTP কী:
এটি একটি নিয়মের সেট। এই নিয়ম মেনে ক্লায়েন্ট রিকোয়েস্ট পাঠায় এবং সার্ভার রেসপন্স দেয়।

HTTP-এর চারটি মূল পদ্ধতি (Methods):

পদ্ধতি	মানে	উদাহরণ
GET	ডেটা নিয়ে আসো	Facebook নিউজফিড লোড
POST	নতুন ডেটা পাঠাও	নতুন পোস্ট করা
PUT	বিদ্যমান ডেটা আপডেট করো	প্রোফাইল ছবি পরিবর্তন
DELETE	ডেটা মুছে দাও	পোস্ট মুছে দেওয়া

HTTPS: HTTP-এর নিরাপদ সংস্করণ। এতে ডেটা এনক্রিপ্ট হয়ে যায়, মাঝখানে কেউ পড়তে পারে না।

৩.৩ API — সার্ভারের দরজা

API (Application Programming Interface) হলো সার্ভারের নির্দিষ্ট "দরজা" যার মাধ্যমে ক্লায়েন্ট নির্দিষ্ট কাজ করতে পারে।

সহজ উদাহরণ:
রেস্টুরেন্টে ওয়েটার হলো API। আপনি (ক্লায়েন্ট) ওয়েটারকে অর্ডার দেন। ওয়েটার রান্নাঘরে (সার্ভার) যায়। রান্নাঘর থেকে খাবার এনে দেয়।

API Endpoint এর উদাহরণ:

GET  /api/users/profile     → ব্যবহারকারীর প্রোফাইল দেখো
POST /api/posts/create      → নতুন পোস্ট তৈরি করো
PUT  /api/posts/123/update  → পোস্ট নম্বর ১২৩ আপডেট করো
DELETE /api/posts/123       → পোস্ট নম্বর ১২৩ মুছে দাও

৩.৪ PORT — সার্ভারের দরজা নম্বর

Port কী:
একটি সার্ভারে অনেক সফটওয়্যার একসাথে চলতে পারে। Port নম্বর দিয়ে বোঝা যায় কোন সফটওয়্যারের সাথে কথা বলতে হবে।

উদাহরণ:

Port 80: সাধারণ ওয়েব ট্র্যাফিক (HTTP)
Port 443: নিরাপদ ওয়েব ট্র্যাফিক (HTTPS)
Port 3000: আমরা আমাদের Node.js অ্যাপের জন্য ব্যবহার করি
Port 4040: আমাদের চ্যাট অ্যাপের জন্য ব্যবহার করি

তুলনা: ভাবুন একটি বড় অফিস বিল্ডিং। বিল্ডিং হলো সার্ভার, বিভিন্ন অফিস হলো বিভিন্ন সার্ভিস, অফিস নম্বর হলো Port নম্বর।

চতুর্থ অধ্যায়: ডেস্কটপ অ্যাপ্লিকেশন — Python দিয়ে হাতে-কলমে

৪.১ ডেস্কটপ অ্যাপ দুই ধরনের

১. স্বতন্ত্র অ্যাপ (Standalone / Offline):
ইন্টারনেট ছাড়া চলে। উদাহরণ: ক্যালকুলেটর, নোটপ্যাড।

২. ইন্টারনেট-নির্ভর ডেস্কটপ অ্যাপ:
ইন্টারনেটের সাথে যুক্ত থাকে। উদাহরণ: VS Code (এক্সটেনশন ডাউনলোডের জন্য), GitHub Desktop।

৪.২ সফটওয়্যার আউটপুটের দুটি ধরন

১. কনসোল অ্যাপ্লিকেশন:
টার্মিনালে (কালো পর্দায়) চলে। ব্যবহারকারী দেখতে পায়:

1 + 2 = 3

কোনো সুন্দর গ্রাফিক্স নেই।

২. গ্রাফিক্যাল ইউজার ইন্টারফেস (GUI) অ্যাপ:
সুন্দর উইন্ডো, বোতাম, ইনপুট বক্স সহ চলে। উদাহরণ: Windows Calculator, VS Code।

৪.৩ Python দিয়ে সহজ ক্যালকুলেটর বানানো

আমরা Python এর Tkinter লাইব্রেরি ব্যবহার করবো GUI অ্যাপ বানাতে।

প্রথম প্রোগ্রাম — "Hello World" উইন্ডো

import tkinter as tk

def main():
    root = tk.Tk()
    root.title("হ্যালো বিশ্ব!")

    label = tk.Label(root, text="হ্যালো বিশ্ব!", 
                     font=("Arial", 20))
    label.pack(pady=20)

    root.mainloop()

main()

কোড ব্যাখ্যা:

import tkinter as tk → Tkinter লাইব্রেরি ব্যবহার করছি
tk.Tk() → একটি উইন্ডো তৈরি
root.title("হ্যালো বিশ্ব!") → উইন্ডোর শিরোনাম
tk.Label(...) → একটি টেক্সট লেবেল
root.mainloop() → উইন্ডো খোলা রাখো

চালানোর নিয়ম:

python app.py

এটি চালালে একটি উইন্ডো খুলবে যাতে "হ্যালো বিশ্ব!" লেখা থাকবে।

ক্যালকুলেটর অ্যাপ

import tkinter as tk

def add_numbers():
    try:
        num1 = float(entry1.get())
        num2 = float(entry2.get())
        result = num1 + num2
        result_label.config(text=f"ফলাফল: {result}")
    except ValueError:
        result_label.config(text="সঠিক সংখ্যা দিন!")

def main():
    global entry1, entry2, result_label

    root = tk.Tk()
    root.title("ক্যালকুলেটর")
    root.geometry("300x200")

    tk.Label(root, text="প্রথম সংখ্যা:").pack()
    entry1 = tk.Entry(root)
    entry1.pack()

    tk.Label(root, text="দ্বিতীয় সংখ্যা:").pack()
    entry2 = tk.Entry(root)
    entry2.pack()

    tk.Button(root, text="যোগ করো", 
              command=add_numbers).pack(pady=10)

    result_label = tk.Label(root, text="")
    result_label.pack()

    root.mainloop()

main()

কোড ব্যাখ্যা:

entry1.get() → ইনপুট বক্স থেকে মান নেওয়া
float(...) → সংখ্যায় রূপান্তর
try/except ValueError → ভুল ইনপুট থেকে সুরক্ষা
result_label.config(text=...) → লেবেলের টেক্সট পরিবর্তন

৪.৪ হোমওয়ার্ক প্রজেক্ট: পাসওয়ার্ড ম্যানেজার

একটি অফলাইন পাসওয়ার্ড ম্যানেজার বানান যা:

পাসওয়ার্ড এনক্রিপ্ট করে রাখে
গোপন কী দিয়ে আনলক করা যায়
ইন্টারনেট ছাড়া চলে

এটি একটি চমৎকার পোর্টফোলিও প্রজেক্ট।

পঞ্চম অধ্যায়: ওয়েব অ্যাপ্লিকেশন — HTML, CSS ও JavaScript

৫.১ ব্রাউজার কীভাবে কাজ করে

আপনি যখন কোনো ওয়েবসাইটের ঠিকানা টাইপ করেন:

ব্রাউজার সেই ঠিকানার সার্ভারে GET রিকোয়েস্ট পাঠায়
সার্ভার HTML, CSS, JavaScript ফাইল পাঠায়
ব্রাউজার সেগুলো নিয়ে সুন্দর পেজ তৈরি করে

ব্রাউজারের মালিক কে: Google Chrome মালিক Google। Firefox-এর মালিক Mozilla। কিন্তু ব্রাউজারের ভেতরে যে পেজ দেখছেন সেটার মালিক সেই ওয়েবসাইটের স্বত্বাধিকারী।

৫.২ HTML — পেজের কাঠামো

HTML (HyperText Markup Language) দিয়ে পেজের কাঠামো তৈরি হয়।

<!DOCTYPE html>
<html>
<head>
    <title>আমার ওয়েবসাইট</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <h1>স্বাগতম!</h1>
    <p>এটি আমার প্রথম ওয়েবসাইট।</p>
    <button onclick="greet()">ক্লিক করুন</button>

    <script src="script.js"></script>
</body>
</html>

ট্যাগের ব্যাখ্যা:

<h1> → শিরোনাম
<p> → অনুচ্ছেদ
<button> → বোতাম
<link> → CSS ফাইল যুক্ত করা
<script> → JavaScript ফাইল যুক্ত করা

৫.৩ CSS — পেজের সৌন্দর্য

CSS (Cascading Style Sheets) দিয়ে পেজ সুন্দর করা হয়।

body {
    font-family: Arial, sans-serif;
    background-color: #f0f0f0;
}

h1 {
    color: #333;
    text-align: center;
}

button {
    background-color: #007bff;
    color: white;
    padding: 10px 20px;
    border: none;
    border-radius: 5px;
    cursor: pointer;
}

button:hover {
    background-color: #0056b3;
}

৫.৪ Tailwind CSS — আধুনিক CSS Framework

Tailwind CSS দিয়ে সরাসরি HTML-এ ক্লাস লিখে ডিজাইন করা যায়।

<!-- Tailwind CSS সহ বোতাম -->
<button class="bg-blue-500 text-white px-4 py-2 rounded hover:bg-blue-700">
    ক্লিক করুন
</button>

Tailwind CDN ব্যবহার করতে HTML-এ যোগ করুন:

<script src="https://cdn.tailwindcss.com"></script>

৫.৫ স্ট্যাটিক ও ডায়নামিক ওয়েবসাইট

স্ট্যাটিক ওয়েবসাইট:
শুধু দেখানোর জন্য। কোনো ব্যবহারকারীর ইনপুট নেয় না, ডেটা সংরক্ষণ করে না। উদাহরণ: সাধারণ পোর্টফোলিও সাইট।

ডায়নামিক ওয়েবসাইট:
ব্যবহারকারীর সাথে ইন্টারঅ্যাক্ট করে, ডেটা নেয় এবং সংরক্ষণ করে। উদাহরণ: Facebook, Gmail।

ষষ্ঠ অধ্যায়: ব্যাক-এন্ড ডেভেলপমেন্ট — Node.js ও Express.js

৬.১ Node.js কী এবং কেন ব্যবহার করি

JavaScript মূলত ব্রাউজারে চলে। কিন্তু Node.js দিয়ে JavaScript সার্ভারেও চালানো যায়।

Node.js হলো:

JavaScript-এর সার্ভার-সাইড রানটাইম
একটি ইঞ্জিন যা সার্ভারে JavaScript কোড চালায়
C++ দিয়ে তৈরি (ভেতরে)

কেন Node.js জনপ্রিয়:

Front-end এবং Back-end দুটোতেই একই ভাষা (JavaScript)
দ্রুত এবং হালকা
বিশাল NPM ইকোসিস্টেম

৬.২ Express.js — ওয়েব সার্ভার ফ্রেমওয়ার্ক

Node.js দিয়ে সরাসরি ওয়েব সার্ভার বানানো যায়, কিন্তু কঠিন। Express.js সেটা সহজ করে দেয়।

Express.js ইনস্টল:

npm install express

৬.৩ সম্পূর্ণ ওয়েব অ্যাপ্লিকেশন — Contact Form

এটি একটি পূর্ণাঙ্গ ওয়েব অ্যাপ্লিকেশন যেখানে:

ব্যবহারকারী একটি ফর্ম পূরণ করবেন
ডেটা সার্ভারে যাবে
সার্ভার ডেটা সংরক্ষণ করবে

প্রজেক্ট কাঠামো

my-web-app/
├── public/
│   └── index.html
├── app.js
└── package.json

index.html (Front-End)

<!DOCTYPE html>
<html lang="bn">
<head>
    <meta charset="UTF-8">
    <title>যোগাযোগ ফর্ম</title>
    <script src="https://cdn.tailwindcss.com"></script>
</head>
<body class="bg-gray-100 min-h-screen flex items-center justify-center">

    <div class="bg-white p-8 rounded-lg shadow-md w-96">
        <h1 class="text-2xl font-bold text-center mb-6">
            আমার সাথে যোগাযোগ করুন
        </h1>

        <form action="/submit-form" method="POST">
            <div class="mb-4">
                <label class="block text-gray-700 mb-2">নাম</label>
                <input 
                    type="text" 
                    name="name"
                    class="w-full border rounded px-3 py-2 focus:outline-none focus:border-blue-500"
                    placeholder="আপনার নাম লিখুন"
                    required
                >
            </div>

            <div class="mb-4">
                <label class="block text-gray-700 mb-2">ইমেইল</label>
                <input 
                    type="email" 
                    name="email"
                    class="w-full border rounded px-3 py-2"
                    placeholder="আপনার ইমেইল"
                    required
                >
            </div>

            <div class="mb-4">
                <label class="block text-gray-700 mb-2">মোবাইল নম্বর</label>
                <input 
                    type="tel" 
                    name="mobile"
                    class="w-full border rounded px-3 py-2"
                    placeholder="০১XXXXXXXXX"
                >
            </div>

            <div class="mb-6">
                <label class="block text-gray-700 mb-2">বার্তা</label>
                <textarea 
                    name="message"
                    class="w-full border rounded px-3 py-2 h-24"
                    placeholder="আপনার বার্তা লিখুন"
                ></textarea>
            </div>

            <button 
                type="submit"
                class="w-full bg-blue-500 text-white py-2 rounded hover:bg-blue-700 transition"
            >
                পাঠান
            </button>
        </form>
    </div>

</body>
</html>

app.js (Back-End)

// প্রয়োজনীয় লাইব্রেরি আনা হচ্ছে
const express = require('express');
const path = require('path');
const fs = require('fs');

// Express অ্যাপ তৈরি
const app = express();

// Middleware সেটআপ
// এই দুটি লাইন ছাড়া form data পড়া যাবে না
app.use(express.urlencoded({ extended: true }));
app.use(express.json());

// Static ফাইল সার্ভ করা (HTML, CSS)
app.use(express.static(path.join(__dirname, 'public')));

// ==========================================
// ROUTE 1: প্রথম পেজ দেখানো
// ==========================================
app.get('/', (req, res) => {
    // index.html ফাইল ব্রাউজারে পাঠানো হচ্ছে
    res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

// ==========================================
// ROUTE 2: ফর্ম ডেটা গ্রহণ করা
// ==========================================
app.post('/submit-form', (req, res) => {
    // ব্যবহারকারীর পাঠানো ডেটা
    const { name, email, mobile, message } = req.body;

    console.log('নতুন বার্তা পাওয়া গেছে:');
    console.log('নাম:', name);
    console.log('ইমেইল:', email);
    console.log('মোবাইল:', mobile);
    console.log('বার্তা:', message);

    // ডেটা JSON ফাইলে সংরক্ষণ
    const newEntry = {
        name,
        email,
        mobile,
        message,
        timestamp: new Date().toISOString()
    };

    // বিদ্যমান ডেটা পড়া
    let existingData = [];
    if (fs.existsSync('requests.json')) {
        const fileContent = fs.readFileSync('requests.json', 'utf8');
        existingData = JSON.parse(fileContent);
    }

    // নতুন ডেটা যোগ করে সংরক্ষণ
    existingData.push(newEntry);
    fs.writeFileSync('requests.json', JSON.stringify(existingData, null, 2));

    // ব্যবহারকারীকে ধন্যবাদ জানানো
    res.send(`
        <h1>ধন্যবাদ, ${name}!</h1>
        <p>আপনার বার্তা পাওয়া গেছে।</p>
        <a href="/">ফিরে যান</a>
    `);
});

// ==========================================
// ROUTE 3: সব বার্তা দেখা (Admin)
// ==========================================
app.get('/admin/submissions', (req, res) => {
    if (!fs.existsSync('requests.json')) {
        return res.json([]);
    }

    const data = JSON.parse(fs.readFileSync('requests.json', 'utf8'));
    res.json(data);
});

// ==========================================
// সার্ভার চালু করা
// ==========================================
const PORT = 3000;
app.listen(PORT, () => {
    console.log(`সার্ভার চলছে: http://localhost:${PORT}`);
});

সার্ভার চালানো

# প্রথমে npm ইনিশিয়ালাইজ
npm init -y

# Express ইনস্টল
npm install express

# সার্ভার চালু
node app.js

এরপর ব্রাউজারে যান: http://localhost:3000

৬.৪ ডেটার প্রবাহ বোঝা (Data Flow)

ব্যবহারকারী → ফর্ম পূরণ → Submit বোতাম
         ↓
    HTML (Client Side)
    POST /submit-form রিকোয়েস্ট তৈরি
         ↓
  ইন্টারনেট (HTTP Protocol)
         ↓
    Express.js Server (Back-End)
    req.body থেকে ডেটা পড়া
         ↓
    ডেটাবেস / ফাইলে সংরক্ষণ
         ↓
    Response পাঠানো ("ধন্যবাদ!")
         ↓
  ব্যবহারকারীর স্ক্রিনে দেখানো

মনে রাখার বিষয়: app.js ফাইল কখনো ব্যবহারকারীর ব্রাউজারে যায় না। এটা সার্ভারেই থাকে। ব্যবহারকারী শুধু index.html দেখতে পান।

সপ্তম অধ্যায়: Git ও GitHub — ভার্সন কন্ট্রোল

৭.১ Git কেন দরকার?

কল্পনা করুন আপনি পাঁচ মাস ধরে একটি প্রজেক্টে কাজ করেছেন। হঠাৎ আপনার ল্যাপটপ নষ্ট হয়ে গেল। সব কোড চলে গেল। এই পরিস্থিতি থেকে বাঁচার জন্য Git।

Git-এর তিনটি প্রধান কাজ:

১. পরিবর্তনের ইতিহাস রাখা:
আপনি কখন কী পরিবর্তন করেছেন সব রেকর্ড থাকে। ভুল হলে আগের অবস্থায় ফেরা যায়।

২. দলীয় কাজ সহজ করা:
৬০ জন ডেভেলপার একসাথে কাজ করতে পারেন। কে কখন কী পরিবর্তন করেছেন সবাই দেখতে পারেন।

৩. কোড নিরাপদ রাখা:
GitHub-এ কোড রাখলে ল্যাপটপ নষ্ট হলেও কোড হারায় না।

৭.২ GitHub কী?

GitHub হলো Git-এর জন্য একটি অনলাইন প্ল্যাটফর্ম — কোডের জন্য Google Drive।

মজার তথ্য: GitHub এর Arctic Vault প্রকল্পে পৃথিবীর গুরুত্বপূর্ণ কোড নরওয়ের আর্কটিক অঞ্চলে একটি সুরক্ষিত গুহায় সংরক্ষিত আছে। পৃথিবীতে বড় কোনো বিপর্যয় হলেও কোড টিকে থাকবে।

৭.৩ Git এর মূল কমান্ড

প্রজেক্ট শুরু করা

# নতুন Git রিপোজিটরি তৈরি
git init

# GitHub থেকে রিপোজিটরি ডাউনলোড
git clone https://github.com/username/project-name.git

পরিবর্তন ট্র্যাক করা

# কী কী পরিবর্তন হয়েছে দেখুন
git status

# সব পরিবর্তন স্টেজে আনুন
git add .

# অথবা নির্দিষ্ট ফাইল স্টেজে আনুন
git add filename.js

পরিবর্তন সংরক্ষণ করা (Commit)

# Commit করা — একটি নাম দিয়ে সেভ করা
git commit -m "ব্যবহারকারীর ফর্ম যোগ করা হলো"

# Commit-এর ইতিহাস দেখুন
git log

GitHub-এ পাঠানো (Push)

# GitHub-এ পাঠানো
git push origin main

# GitHub থেকে আনা
git pull origin main

Branch নিয়ে কাজ

# সব Branch দেখুন
git branch

# নতুন Branch তৈরি
git checkout -b chat-app

# Branch পরিবর্তন
git checkout main

৭.৪ GitHub Account সেটআপ

ধাপ ১: github.com-এ যান এবং অ্যাকাউন্ট খুলুন।

ধাপ ২: আপনার কম্পিউটারে Git ইনস্টল করুন:

Windows: git-scm.com থেকে ডাউনলোড
Linux: sudo apt install git
Mac: brew install git

ধাপ ৩: পরিচয় সেটআপ:

git config --global user.name "আপনার নাম"
git config --global user.email "আপনার@ইমেইল.com"

ধাপ ৪: SSH Key তৈরি (নিরাপদ সংযোগের জন্য):

ssh-keygen -t rsa -b 4096 -C "আপনার@ইমেইল.com"

তারপর ~/.ssh/id_rsa.pub ফাইলের বিষয়বস্তু GitHub-এ যোগ করুন।

৭.৫ .gitignore — কী পাঠাবেন না

কিছু ফাইল GitHub-এ পাঠানো উচিত নয়:

# Node.js এর ডিপেন্ডেন্সি ফোল্ডার
node_modules/

# পরিবেশ পরিবর্তনশীল (গোপন তথ্য)
.env

# অপারেটিং সিস্টেমের ফাইল
.DS_Store
Thumbs.db

# Build ফাইল
dist/
build/

.gitignore ফাইলে এই নাম লিখলে Git সেই ফাইলগুলো উপেক্ষা করে।

অষ্টম অধ্যায়: ক্লাউড সার্ভার ও ডেপ্লয়মেন্ট

৮.১ ডেপ্লয়মেন্ট কী?

আপনার কম্পিউটারে সফটওয়্যার বানালে শুধু আপনিই ব্যবহার করতে পারবেন। সবাই ব্যবহার করতে পারলে আপনার সফটওয়্যার সার্ভারে রাখতে হবে। এটাই ডেপ্লয়মেন্ট।

৮.২ ক্লাউড সার্ভার প্রোভাইডার

বিশ্বের প্রধান ক্লাউড সার্ভার প্রদানকারী:

প্রদানকারী	বৈশিষ্ট্য	কখন ব্যবহার করবেন
DigitalOcean	সহজ, সাশ্রয়ী	শিক্ষানবিস ও ছোট প্রজেক্ট
AWS (Amazon)	সবচেয়ে বড়, জটিল	বড় কোম্পানি
Google Cloud	Google সেবা ইন্টিগ্রেশন	ML/AI প্রজেক্ট
Azure (Microsoft)	Microsoft সেবা	.NET প্রজেক্ট
Vercel	ফ্রি, সহজ	স্ট্যাটিক সাইট

শিক্ষানবিসদের জন্য: DigitalOcean সবচেয়ে ভালো। মাত্র $6/মাসে একটি সার্ভার পাওয়া যায়।

৮.৩ DigitalOcean-এ সার্ভার তৈরি (Droplet)

DigitalOcean-এ একটি সার্ভারকে "Droplet" বলা হয়।

ধাপ ১: DigitalOcean-এ অ্যাকাউন্ট তৈরি করুন।

ধাপ ২: "Create Droplet" ক্লিক করুন।

ধাপ ৩: সেটিং:

OS: Ubuntu 22.04 LTS
Plan: Basic, Regular, $6/মাস (1GB RAM, 1 CPU)
Data Center: Singapore (বাংলাদেশের কাছে)
Authentication: SSH Key (নিরাপদ) অথবা Password

ধাপ ৪: "Create Droplet" ক্লিক করুন।

কয়েক মিনিট পরে আপনার সার্ভার প্রস্তুত। একটি IP Address পাবেন।

৮.৪ সার্ভারে প্রবেশ (SSH)

# SSH দিয়ে সার্ভারে প্রবেশ
ssh root@YOUR_SERVER_IP

# উদাহরণ
ssh root@164.90.xxx.xxx

পাসওয়ার্ড দিলে সার্ভারে প্রবেশ হবে। এখন আপনি সার্ভারের terminal-এ আছেন।

৮.৫ সার্ভারে Node.js ইনস্টল

# প্যাকেজ আপডেট করুন
apt update && apt upgrade -y

# Node.js ডাউনলোড লিংক পেতে
curl -fsSL https://deb.nodesource.com/setup_18.x | bash -

# Node.js ইনস্টল
apt install -y nodejs

# যাচাই করুন
node --version
npm --version

৮.৬ সার্ভারে প্রজেক্ট ডেপ্লয় করা

পদ্ধতি ১: সরাসরি কপি করে

# সার্ভারে ফোল্ডার তৈরি
mkdir hira-web
cd hira-web

# ফাইল তৈরি এবং কোড পেস্ট
nano app.js
# কোড পেস্ট করুন, Ctrl+X দিয়ে সেভ করুন

# ডিপেন্ডেন্সি ইনস্টল
npm install express

# সার্ভার চালু
node app.js

পদ্ধতি ২: GitHub থেকে ডাউনলোড করে (বেশি ভালো)

# GitHub থেকে ক্লোন
git clone git@github.com:username/project.git

# ফোল্ডারে প্রবেশ
cd project

# ডিপেন্ডেন্সি ইনস্টল
npm install

# সার্ভার চালু
node app.js

এখন আপনার সার্ভারের IP দিয়ে যে কেউ অ্যাক্সেস করতে পারবেন:
http://YOUR_IP:PORT

৮.৭ PM2 — সার্ভার সবসময় চালু রাখা

সমস্যা: টার্মিনাল বন্ধ করলে সার্ভার বন্ধ হয়ে যায়।

সমাধান: PM2 ব্যবহার করুন।

# PM2 ইনস্টল
npm install -g pm2

# PM2 দিয়ে সার্ভার চালু
pm2 start app.js

# সার্ভারের অবস্থা দেখুন
pm2 status

# সার্ভার বন্ধ করুন
pm2 stop app.js

# সার্ভার রিস্টার্ট করুন
pm2 restart app.js

# সিস্টেম রিবুটের পরেও চালু থাকতে
pm2 startup
pm2 save

এখন টার্মিনাল বন্ধ করলেও সার্ভার চলতে থাকবে।

৮.৮ Vercel — সহজ বিনামূল্যে ডেপ্লয়মেন্ট

ছোট প্রজেক্টের জন্য Vercel সবচেয়ে সহজ।

কীভাবে:
১. vercel.com-এ GitHub অ্যাকাউন্ট দিয়ে লগিন করুন
২. "Import Project" ক্লিক করুন
৩. আপনার GitHub রিপোজিটরি বেছে নিন
৪. Deploy ক্লিক করুন

কয়েক মিনিটে আপনার সাইট লাইভ হয়ে যাবে। একটি URL পাবেন যেটা সবাই ব্যবহার করতে পারবে।

৮.৯ ডেপ্লয়মেন্ট পাইপলাইন

সম্পূর্ণ প্রবাহ:

আপনার কম্পিউটার (Local)
        ↓ git push
GitHub Repository
        ↓ স্বয়ংক্রিয় ডেপ্লয়
Vercel / DigitalOcean Server
        ↓
ব্যবহারকারীর ব্রাউজার

GitHub Actions দিয়ে স্বয়ংক্রিয় ডেপ্লয়মেন্ট:
GitHub-এ কোড push করলে স্বয়ংক্রিয়ভাবে সার্ভারে ডেপ্লয় হয়। এটাই CI/CD (Continuous Integration/Continuous Deployment)।

নবম অধ্যায়: রিয়েল-টাইম অ্যাপ্লিকেশন — Socket.io দিয়ে চ্যাট অ্যাপ

৯.১ সাধারণ HTTP vs WebSocket

সাধারণ HTTP:

ব্যবহারকারী রিকোয়েস্ট পাঠায়
সার্ভার রেসপন্স দেয়
সংযোগ শেষ

এটা চিঠি পাঠানোর মতো। চিঠি পাঠালে জবাব আসবে। কিন্তু মাঝখানে সার্ভার কিছু পাঠাতে পারবে না।

WebSocket:

একটি স্থায়ী সংযোগ তৈরি হয়
যেকোনো সময় যেকোনো দিকে ডেটা যেতে পারে
সংযোগ বিচ্ছিন্ন না হওয়া পর্যন্ত চলে

এটা ফোন কলের মতো। দুজনে একসাথে কথা বলতে পারেন।

কোথায় WebSocket দরকার:

চ্যাট অ্যাপ্লিকেশন
রিয়েল-টাইম নোটিফিকেশন
অনলাইন গেম
স্টক মার্কেট প্রাইস আপডেট
Uber-এর ড্রাইভার ট্র্যাকিং

৯.২ মোবাইলে নোটিফিকেশন কীভাবে আসে?

আপনার ফোন বিশ্রামে আছে, কোনো অ্যাপ খোলা নেই। হঠাৎ WhatsApp নোটিফিকেশন আসলো।

আপনি কোনো বোতাম চাপেননি। তাহলে কীভাবে এলো?

উত্তর: আপনার ফোনে একটি অদৃশ্য সংযোগ সবসময় চালু থাকে। এটি WebSocket। WhatsApp-এর সার্ভার থেকে আপনার ফোনে একটি "পাইপ" খোলা আছে। নতুন বার্তা এলে এই পাইপ দিয়ে নোটিফিকেশন আসে।

৯.৩ Socket.io কী?

Socket.io হলো Node.js-এর একটি লাইব্রেরি যা WebSocket সহজে ব্যবহার করতে দেয়।

দুটো অংশ:

Server-side Socket.io: সার্ভারে চলে (Node.js)
Client-side Socket.io: ব্রাউজারে চলে (JavaScript)

দুটো মিলে একটি রিয়েল-টাইম সংযোগ তৈরি করে।

৯.৪ সম্পূর্ণ চ্যাট অ্যাপ্লিকেশন

প্রজেক্ট কাঠামো

chat-app/
├── public/
│   └── index.html
├── server.js
└── package.json

সার্ভার ইনস্টলেশন

npm init -y
npm install express socket.io

server.js — ব্যাক-এন্ড

const express = require('express');
const http = require('http');
const socketIO = require('socket.io');
const path = require('path');

// Express এবং HTTP সার্ভার তৈরি
const app = express();
const server = http.createServer(app);

// Socket.io এর সাথে HTTP সার্ভার যুক্ত
const io = socketIO(server);

// Static ফাইল সার্ভ করা
app.use(express.static(path.join(__dirname, 'public')));

// প্রধান পেজ দেখানো
app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

// ======================================
// Socket.io ইভেন্ট হ্যান্ডলিং
// ======================================
io.on('connection', (socket) => {
    console.log('নতুন ব্যবহারকারী সংযুক্ত হয়েছেন');

    // ব্যবহারকারী নাম দিয়ে ঢুকলে
    socket.on('join', (username) => {
        socket.username = username;

        // সবাইকে জানানো
        io.emit('user-joined', `${username} চ্যাটে যোগ দিয়েছেন!`);

        console.log(`${username} যোগ দিয়েছেন`);
    });

    // বার্তা পাঠালে
    socket.on('message', (data) => {
        console.log(`বার্তা পাওয়া: ${data.text} from ${data.username}`);

        // সবার কাছে বার্তা পাঠানো
        io.emit('message', {
            username: data.username,
            text: data.text,
            time: new Date().toLocaleTimeString('bn-BD')
        });
    });

    // ব্যবহারকারী বের হলে
    socket.on('disconnect', () => {
        if (socket.username) {
            io.emit('user-left', `${socket.username} চ্যাট ছেড়ে গেছেন।`);
            console.log(`${socket.username} বের হয়েছেন`);
        }
    });
});

// সার্ভার চালু
const PORT = 4090;
server.listen(PORT, () => {
    console.log(`চ্যাট সার্ভার চলছে: http://localhost:${PORT}`);
});

public/index.html — ফ্রন্ট-এন্ড

<!DOCTYPE html>
<html lang="bn">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>চ্যাট রুম</title>
    <script src="https://cdn.tailwindcss.com"></script>
    <!-- Socket.io Client লাইব্রেরি -->
    <script src="/socket.io/socket.io.js"></script>
</head>
<body class="bg-gray-900 text-white min-h-screen">

    <!-- নাম দেওয়ার স্ক্রিন -->
    <div id="login-screen" class="flex items-center justify-center min-h-screen">
        <div class="bg-gray-800 p-8 rounded-lg w-80">
            <h1 class="text-2xl font-bold text-center mb-6">চ্যাট রুমে স্বাগতম</h1>
            <input 
                type="text" 
                id="username-input"
                placeholder="আপনার নাম লিখুন"
                class="w-full bg-gray-700 rounded px-4 py-2 mb-4 focus:outline-none focus:ring-2 focus:ring-blue-500"
            >
            <button 
                onclick="joinChat()"
                class="w-full bg-blue-600 hover:bg-blue-700 py-2 rounded font-bold transition"
            >
                ঢুকুন
            </button>
        </div>
    </div>

    <!-- চ্যাট স্ক্রিন (শুরুতে লুকানো) -->
    <div id="chat-screen" class="hidden flex flex-col h-screen">

        <!-- শিরোনাম বার -->
        <div class="bg-gray-800 p-4 flex items-center shadow">
            <div class="w-10 h-10 bg-blue-600 rounded-full flex items-center justify-center mr-3">
                <span>💬</span>
            </div>
            <div>
                <h2 class="font-bold">গ্রুপ চ্যাট</h2>
                <p class="text-green-400 text-sm">● সক্রিয়</p>
            </div>
        </div>

        <!-- বার্তার জায়গা -->
        <div id="messages" class="flex-1 overflow-y-auto p-4 space-y-3">
            <!-- বার্তাগুলো এখানে দেখাবে -->
        </div>

        <!-- বার্তা পাঠানোর বার -->
        <div class="bg-gray-800 p-4 flex gap-2">
            <input 
                type="text" 
                id="message-input"
                placeholder="বার্তা লিখুন..."
                class="flex-1 bg-gray-700 rounded-full px-4 py-2 focus:outline-none"
                onkeypress="handleKeyPress(event)"
            >
            <button 
                onclick="sendMessage()"
                class="bg-blue-600 hover:bg-blue-700 w-10 h-10 rounded-full flex items-center justify-center transition"
            >
                ➤
            </button>
        </div>

    </div>

    <script>
        // Socket.io সংযোগ
        const socket = io();

        let currentUsername = '';

        // নামে যুক্ত হওয়া
        function joinChat() {
            const usernameInput = document.getElementById('username-input');
            const username = usernameInput.value.trim();

            if (!username) {
                alert('নাম লিখুন!');
                return;
            }

            currentUsername = username;

            // সার্ভারে পাঠানো
            socket.emit('join', username);

            // স্ক্রিন পরিবর্তন
            document.getElementById('login-screen').classList.add('hidden');
            document.getElementById('chat-screen').classList.remove('hidden');
        }

        // বার্তা পাঠানো
        function sendMessage() {
            const messageInput = document.getElementById('message-input');
            const text = messageInput.value.trim();

            if (!text) return;

            // সার্ভারে পাঠানো
            socket.emit('message', {
                username: currentUsername,
                text: text
            });

            messageInput.value = '';
        }

        // Enter চাপলে পাঠানো
        function handleKeyPress(event) {
            if (event.key === 'Enter') {
                sendMessage();
            }
        }

        // ========================================
        // সার্ভার থেকে ইভেন্ট গ্রহণ
        // ========================================

        // বার্তা পাওয়া গেলে
        socket.on('message', (data) => {
            const messagesDiv = document.getElementById('messages');
            const isOwn = data.username === currentUsername;

            const messageEl = document.createElement('div');
            messageEl.className = `flex ${isOwn ? 'justify-end' : 'justify-start'}`;
            messageEl.innerHTML = `
                <div class="max-w-xs">
                    ${!isOwn ? `<p class="text-blue-400 text-xs mb-1">${data.username}</p>` : ''}
                    <div class="${isOwn ? 'bg-blue-600' : 'bg-gray-700'} rounded-2xl px-4 py-2">
                        <p>${data.text}</p>
                        <p class="text-xs opacity-70 mt-1">${data.time}</p>
                    </div>
                </div>
            `;

            messagesDiv.appendChild(messageEl);
            messagesDiv.scrollTop = messagesDiv.scrollHeight;
        });

        // কেউ যোগ দিলে
        socket.on('user-joined', (message) => {
            addSystemMessage(message, 'text-green-400');
        });

        // কেউ বের গেলে
        socket.on('user-left', (message) => {
            addSystemMessage(message, 'text-red-400');
        });

        // সিস্টেম বার্তা দেখানো
        function addSystemMessage(text, colorClass) {
            const messagesDiv = document.getElementById('messages');
            const el = document.createElement('div');
            el.className = `text-center text-sm ${colorClass} py-1`;
            el.textContent = text;
            messagesDiv.appendChild(el);
            messagesDiv.scrollTop = messagesDiv.scrollHeight;
        }
    </script>

</body>
</html>

চালানোর নিয়ম

node server.js

ব্রাউজারে যান: http://localhost:4090

একাধিক ট্যাব বা ব্রাউজার খুলুন। বিভিন্ন নামে ঢুকুন। একজনের বার্তা সবাই একসাথে দেখতে পাবেন!

৯.৫ চ্যাট অ্যাপের প্রযুক্তি বোঝা

ব্রাউজার ১          ব্রাউজার ২          ব্রাউজার ৩
(রাহেলা)           (করিম)             (সুমাইয়া)
    |                   |                   |
    |===Socket.io===========Socket.io=====|
                         |
                    Socket.io Server
                    (app.js চলছে)
                         |
                  io.emit('message', data)
                  ↙              ↓             ↘
              রাহেলা          করিম         সুমাইয়া
           (সবাই পায়)       (সবাই পায়)   (সবাই পায়)

socket.emit vs io.emit পার্থক্য:

socket.emit(...) → শুধু যে পাঠিয়েছে তাকে পাঠায়
io.emit(...) → সবাইকে পাঠায় (broadcast)
socket.broadcast.emit(...) → যে পাঠিয়েছে সে ছাড়া সবাইকে পাঠায়

দশম অধ্যায়: CI/CD পাইপলাইন

১০.১ CI/CD কী?

CI (Continuous Integration): নিরন্তর একীভূতকরণ। ডেভেলপাররা ছোট ছোট পরিবর্তন নিয়মিত GitHub-এ পাঠান। প্রতিটি পরিবর্তন স্বয়ংক্রিয়ভাবে টেস্ট হয়।

CD (Continuous Deployment): নিরন্তর ডেপ্লয়মেন্ট। টেস্ট পাস হলে স্বয়ংক্রিয়ভাবে সার্ভারে ডেপ্লয় হয়।

আগের সমস্যা:
কোনো পরিবর্তন করলে:

কোড লিখুন
GitHub-এ পাঠান
সার্ভারে SSH করুন
git pull করুন
npm install করুন
সার্ভার রিস্টার্ট করুন

এটা ম্যানুয়াল, সময়সাপেক্ষ এবং ভুলের সম্ভাবনা বেশি।

CI/CD সমাধান:
শুধু GitHub-এ push করুন। বাকি সব স্বয়ংক্রিয়।

১০.২ GitHub Actions দিয়ে CI/CD

.github/workflows/deploy.yml

name: ডেপ্লয় করুন

# কখন চলবে
on:
  push:
    branches: [ main ]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
    # কোড ডাউনলোড
    - name: কোড চেকআউট
      uses: actions/checkout@v3

    # টেস্ট চালানো
    - name: Node.js সেটআপ
      uses: actions/setup-node@v3
      with:
        node-version: '18'

    - name: ডিপেন্ডেন্সি ইনস্টল
      run: npm install

    # সার্ভারে ডেপ্লয়
    - name: সার্ভারে পাঠানো
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.SERVER_HOST }}
        username: root
        key: ${{ secrets.SSH_PRIVATE_KEY }}
        script: |
          cd /root/my-project
          git pull origin main
          npm install
          pm2 restart app

এই ফাইলটি প্রজেক্টে যোগ করলে GitHub-এ push করার সাথে সাথে সার্ভারে স্বয়ংক্রিয় ডেপ্লয় হবে।

১০.৩ সম্পূর্ণ ডেপ্লয়মেন্ট প্রবাহ

আপনার কম্পিউটার
        |
   [কোড লেখুন]
        |
   git add .
   git commit -m "নতুন ফিচার"
   git push origin main
        |
        ↓
   GitHub Repository
        |
   [GitHub Actions চালু হয়]
        |
   ↓ টেস্ট চলে
   ↓ বিল্ড হয়
        |
   সার্ভারে SSH
   git pull
   npm install
   pm2 restart
        |
        ↓
   DigitalOcean Server
        |
        ↓
   ব্যবহারকারীরা নতুন ভার্সন পান

একাদশ অধ্যায়: ক্যারিয়ার পথ ও অর্থ উপার্জনের উপায়

১১.১ SDLC-তে কত ধরনের ক্যারিয়ার আছে

একটি সফটওয়্যারের জীবনচক্রের প্রতিটি ধাপে আলাদা ক্যারিয়ার আছে:

ধাপ	ক্যারিয়ার
পরিকল্পনা	Business Analyst
পণ্য বিশ্লেষণ	Product Manager
ডিজাইন	UI/UX Designer
ডেভেলপমেন্ট	Front-end Developer, Back-end Developer, Full-stack Developer
টেস্টিং	QA Engineer
ডেপ্লয়মেন্ট	DevOps Engineer, Cloud Engineer
রক্ষণাবেক্ষণ	Site Reliability Engineer (SRE)
নিরাপত্তা	Cybersecurity Engineer
ডেটা	Data Scientist, Data Engineer
AI	ML Engineer, AI Researcher

১১.২ একজন সফটওয়্যার ইঞ্জিনিয়ারের সত্যিকারের ভূমিকা

অনেকে ভাবেন সফটওয়্যার ডেভেলপারের কাজ শুধু কোড লেখা। এটা ভুল।

একজন ভালো সফটওয়্যার ইঞ্জিনিয়ার:

ব্যবসার উদ্দেশ্য বোঝেন
পরিষ্কারভাবে যোগাযোগ করেন
প্রয়োজনীয়তা সঠিকভাবে বোঝেন (না বুঝলে জিজ্ঞেস করেন)
ডেটা দিয়ে সিদ্ধান্ত নেন
টিমকে সহায়তা করেন
ব্যবসার পরিবর্তনের সাথে মানিয়ে নেন

১১.৩ সফটওয়্যার দিয়ে অর্থ উপার্জন — চাকরির বাইরে

চাকরি ছাড়াও সফটওয়্যার দিয়ে অনেকভাবে অর্থ উপার্জন করা যায়:

পথ ১: ফ্রিল্যান্সিং

Fiverr, Upwork, Freelancer.com-এ প্রজেক্ট করুন। বাংলাদেশে বসে বিদেশী ক্লায়েন্টের কাজ করুন।

কী কী বিক্রি করা যায়:

ওয়েবসাইট তৈরি
বাগ ফিক্স
API তৈরি
মোবাইল অ্যাপ

পথ ২: প্রোডাক্ট বিক্রি

নিজের সফটওয়্যার বানিয়ে বিক্রি করুন।

CodeCanyon (codecanyon.net):
Node.js, Django, Laravel দিয়ে তৈরি স্ক্রিপ্ট এখানে বিক্রি করা যায়।

উদাহরণ প্রজেক্ট:

YouTube ডাউনলোডার (AI-চালিত)
চ্যাট অ্যাপ
অ্যাডমিন ড্যাশবোর্ড
বুকিং সিস্টেম

পথ ৩: SaaS (Software as a Service)

একটি অনলাইন টুল বানান যেখানে মাসিক সাবস্ক্রিপশন নেওয়া হয়।

উদাহরণ SaaS আইডিয়া:

AI ভিডিও এডিটর (সাইলেন্ট কাট, রিপিট রিমুভ)
YouTube ট্রান্সক্রিপশন টুল
সেন্টিমেন্ট অ্যানালাইসিস টুল
স্বয়ংক্রিয় সোশ্যাল মিডিয়া পোস্ট জেনারেটর

SaaS-এ অর্থ উপার্জন:

বিজ্ঞাপন দেখানো (AdSense)
মাসিক সাবস্ক্রিপশন
প্রিমিয়াম ফিচার

পথ ৪: ইন্ডি হ্যাকার (Indie Hacker)

IndieHackers.com-এ গিয়ে দেখুন কত ডেভেলপার একা একা প্রোডাক্ট বানিয়ে লক্ষ টাকা আয় করছেন।

কীভাবে শুরু করবেন:
১. একটি সমস্যা খুঁজুন যা আপনি অনুভব করেছেন
২. সেটার সমাধান বানান
৩. ProductHunt-এ লঞ্চ করুন
৪. ফিডব্যাক নিন এবং উন্নত করুন
৫. ধীরে ধীরে ব্যবহারকারী বাড়ান

পথ ৫: AI-চালিত প্রোডাক্ট

আইডিয়া: AI ভিডিও এডিটর

যারা YouTube বা TikTok-এর জন্য ভিডিও বানান তারা সবচেয়ে বেশি সময় নষ্ট করেন এডিটিংয়ে। বিশেষত:

সাইলেন্ট পার্ট কাটা
রিটেকের পুনরাবৃত্তি মুছে দেওয়া
ক্যাপশন যোগ করা

Python দিয়ে এটা তৈরি করা সম্ভব:

# সাইলেন্ট ডিটেকশনের জন্য
from pydub import AudioSegment
from pydub.silence import detect_silence

# অডিও থেকে টেক্সটে রূপান্তরের জন্য
import speech_recognition as sr

# ভিডিও প্রক্রিয়াকরণের জন্য
from moviepy.editor import VideoFileClip

Google এর বিনামূল্যে Speech-to-Text API ব্যবহার করা যায়।

বাজার বিশ্লেষণ (Semrush/Google Trends):
"AI video editor" - বৈশ্বিক মাসিক সার্চ ভলিউম: ১২,০০০+

১১.৪ প্রজেক্ট পোর্টফোলিও — কী করবেন, কী করবেন না

যা করবেন:
✅ AI বা ML যুক্ত প্রজেক্ট বানান
✅ ক্লাউডে ডেপ্লয় করুন (লাইভ লিংক দিন)
✅ GitHub-এ কোড রাখুন
✅ README.md তে ভালো ডকুমেন্টেশন লিখুন
✅ ডেটাবেস সহ Full-stack প্রজেক্ট বানান
✅ নিজে ব্যাখ্যা করতে পারেন এমন প্রজেক্ট বানান

যা করবেন না:
❌ টিউটোরিয়াল কপি করে সিভিতে দেবেন না
❌ সবাই যা বানায় (To-do List, Calculator) শুধু সেটা দেবেন না
❌ লাইভ নেই এমন প্রজেক্ট দেবেন না
❌ বুঝতে পারবেন না এমন কোড দেবেন না

১১.৫ মার্কেট বিশ্লেষণ টুল

নিজের প্রোডাক্টের চাহিদা যাচাই করুন:

Semrush / Ahrefs:

কত মানুষ এই কীওয়ার্ড সার্চ করে
প্রতিযোগীরা কে কে

Google Trends:

চাহিদা বাড়ছে নাকি কমছে

ProductHunt:

নতুন পণ্যের ট্রেন্ড
ব্যবহারকারীর প্রতিক্রিয়া

IndieHackers:

সফল ইন্ডি ডেভেলপারদের গল্প
রাজস্বের পরিসংখ্যান

পরিশিষ্ট ক: প্রজেক্ট আইডিয়ার তালিকা

এই বইয়ের জ্ঞান দিয়ে আপনি নিচের প্রজেক্টগুলো বানাতে পারবেন:

শিক্ষানবিস পর্যায়

১. পোর্টফোলিও ওয়েবসাইট — HTML, CSS, JavaScript
২. সাধারণ ক্যালকুলেটর — Python + Tkinter
৩. Contact Form — Express.js + JSON সংরক্ষণ
৪. Offline Password Manager — Python + Encryption

মধ্যবর্তী পর্যায়

৫. চ্যাট অ্যাপ — Socket.io + Express.js
৬. YouTube Downloader — Python + yt-dlp
৭. Blog Platform — Full-stack (React + Node.js + Database)
৮. Task Manager — Express.js + PostgreSQL

উন্নত পর্যায়

৯. AI ভিডিও এডিটর — Python + MoviePy + Whisper
১০. YouTube Transcriber + Sentiment Analyzer — Python + NLP
১১. রিয়েল-টাইম নোটিফিকেশন সিস্টেম — Socket.io + Push API
১২. অফলাইন LLM চ্যাটবট — Python + Ollama

পরিশিষ্ট খ: দ্রুত রেফারেন্স কার্ড

Git কমান্ড চিট শিট

# শুরু করা
git init                          # নতুন রিপো
git clone URL                     # ক্লোন করা

# ডেইলি কাজ
git status                        # অবস্থা দেখা
git add .                         # সব স্টেজ করা
git commit -m "বার্তা"           # কমিট করা
git push origin main              # GitHub-এ পাঠানো
git pull origin main              # GitHub থেকে আনা

# Branch কাজ
git branch                        # Branch দেখা
git checkout -b নতুন-branch       # Branch তৈরি
git checkout main                 # Branch পরিবর্তন
git merge branch-name             # Merge করা

# ইতিহাস
git log                           # ইতিহাস দেখা
git log --oneline                 # সংক্ষেপে দেখা

npm কমান্ড চিট শিট

npm init -y                       # প্রজেক্ট শুরু
npm install express               # প্যাকেজ ইনস্টল
npm install -g pm2               # গ্লোবাল ইনস্টল
npm start                         # সার্ভার চালু
npm test                          # টেস্ট চালু

Linux সার্ভার কমান্ড

ls                                # ফাইল দেখা
cd folder                         # ফোল্ডারে যাওয়া
mkdir folder                      # ফোল্ডার তৈরি
nano file.js                      # ফাইল সম্পাদনা
cat file.js                       # ফাইল পড়া
rm file.js                        # ফাইল মুছা
top                               # চলমান প্রক্রিয়া দেখা

HTTP Status Codes

কোড	মানে
200	সফল
201	তৈরি হয়েছে
400	ভুল রিকোয়েস্ট
401	অনুমতি নেই
404	পাওয়া যায়নি
500	সার্ভার ত্রুটি

পরিশিষ্ট গ: শেখার রোডম্যাপ

মাস ১-২: ভিত্তি গড়া

সপ্তাহ ১-২:

HTML মূল বিষয়
CSS মূল বিষয়
সহজ ওয়েবপেজ তৈরি

সপ্তাহ ৩-৪:

JavaScript মূল বিষয়
ফাংশন, লুপ, অ্যারে
DOM manipulation

সপ্তাহ ৫-৬:

Python মূল বিষয়
একই ধারণা Python-এ
ছোট স্ক্রিপ্ট লেখা

সপ্তাহ ৭-৮:

Git ও GitHub শেখা
প্রথম প্রজেক্ট GitHub-এ

মাস ৩-৪: ব্যাক-এন্ড শেখা

সপ্তাহ ৯-১০:

Node.js ও Express.js
REST API তৈরি

সপ্তাহ ১১-১২:

ডেটাবেস (PostgreSQL বা MongoDB)
CRUD অপারেশন

সপ্তাহ ১৩-১৪:

Authentication (JWT)
নিরাপত্তার মূল বিষয়

সপ্তাহ ১৫-১৬:

ক্লাউড ডেপ্লয়মেন্ট (DigitalOcean)
প্রথম লাইভ প্রজেক্ট

মাস ৫-৬: উন্নত বিষয়

Socket.io / রিয়েল-টাইম অ্যাপ
CI/CD পাইপলাইন
পারফরম্যান্স অপ্টিমাইজেশন
AI/ML ইন্টিগ্রেশন

উপসংহার

এই বইয়ে আমরা শিখেছি:

১. সফটওয়্যার কেন বানানো হয় — তিনটি প্রধান কারণ এবং বাস্তব উদাহরণ

২. SDLC — মালিক থেকে শুরু করে ব্যবহারকারী পর্যন্ত সফটওয়্যারের পুরো যাত্রা

৩. প্রযুক্তিগত কাঠামো — ক্লায়েন্ট, সার্ভার এবং ডেটাবেস কীভাবে একসাথে কাজ করে

৪. হাতে-কলমে তৈরি — Python, HTML, CSS, JavaScript, Node.js দিয়ে বাস্তব অ্যাপ্লিকেশন

৫. ভার্সন কন্ট্রোল — Git ও GitHub দিয়ে কোড পরিচালনা

৬. ক্লাউড ডেপ্লয়মেন্ট — সার্ভারে সফটওয়্যার রাখা যাতে সবাই ব্যবহার করতে পারে

৭. রিয়েল-টাইম সংযোগ — Socket.io দিয়ে চ্যাট অ্যাপ

৮. CI/CD — স্বয়ংক্রিয় ডেপ্লয়মেন্ট পাইপলাইন

৯. ক্যারিয়ার পথ — চাকরি থেকে নিজের প্রোডাক্ট — অনেক পথ খোলা

মনে রাখুন: সফটওয়্যার ইঞ্জিনিয়ারিং কোনো নির্দিষ্ট ভাষা বা ফ্রেমওয়ার্কের নাম নয়। এটি একটি চিন্তার ধরন। সমস্যা চিহ্নিত করুন, ভেঙে ছোট করুন, সমাধান করুন। এই দক্ষতা একবার অর্জন হলে যেকোনো প্রযুক্তিতে কাজ করা সম্ভব।

পরিশেষে, সবচেয়ে গুরুত্বপূর্ণ কথা — তৈরি করুন। পড়া, দেখা, শোনা — এর সবই শেষ পর্যন্ত কম গুরুত্বপূর্ণ যদি আপনি নিজে হাতে কিছু না বানান। এই বই পড়ার পরে আজই একটি প্রজেক্ট শুরু করুন। ভুল হবে, সমস্যা আসবে — সেগুলো থেকেই শেখা হবে।

শুভকামনা!

Go Types Are Not What You Think: Numbers, Strings, and Memory Explained

Saiful Islam — Mon, 25 May 2026 18:18:55 +0000

Most developers write Go code every day without thinking about what actually lives in memory. Then a bug shows up — a balance is slightly off, a counter wraps to negative, or Bengali text gets garbled mid-slice. This post explains exactly why these things happen.

The Foundation: Computers Only Know 0 and 1

Everything stored in a computer — numbers, text, images — is ultimately a sequence of bits. A bit is a single 0 or 1.

0  →  off
1  →  on

Group 8 bits together and you get a byte. Memory is measured in bytes.

8  bits = 1 byte
16 bits = 2 bytes
32 bits = 4 bytes
64 bits = 8 bytes

This is the foundation for understanding every number type.

Integer Types: Exact, But Bounded

An integer type defines two things: how much memory to use, and how large a number you can store.

Type	Memory	Range
int8	1 byte	-128 to 127
int16	2 byte	-32,768 to 32,767
int32	4 byte	~±2 billion
int64	8 byte	~±9.2 quintillion

The range is not arbitrary. With 8 bits, you have exactly 2⁸ = 256 possible values. Split between negative and positive (using one bit for the sign), you get -128 to 127. No more. That's physics.

var x int8 = 127  // fine
var y int8 = 128  // compile error

Why Only Powers of 2?

int4 and int12 don't exist because CPU architecture works in powers of 2. Hardware is optimized for 8, 16, 32, 64. Anything else would be slower or require special handling. Go follows this convention.

Unsigned Integers

If you know a value is always positive, you can use unsigned types:

var score uint8 = 255  // range: 0 to 255

You get the full 256 values on the positive side.

What Happens When You Overflow?

This is where things get dangerous. If you exceed an integer's range, Go doesn't crash or throw an exception — it silently wraps around.

package main

import "fmt"

func main() {
    var x int8 = 127
    x++
    fmt.Println(x) // -128
}

In memory, 127 is stored as:

01111111

Add 1:

10000000

That pattern means -128 in a signed integer. The counter silently became negative.

In a banking or financial system, this is a critical bug. A transaction counter hits max, wraps to a negative, and your system thinks money was subtracted instead of added.

The fix: use int64 for financial counters. Its max (~9.2 quintillion) is large enough for any real-world value.

Floating-Point Types: Range, But Not Exactness

Float types (float32, float64) handle decimal numbers:

var pi float64 = 3.14159
var price float32 = 9.99

The key difference from integers:

Type	Memory	Accurate Digits
float32	4 byte	~7 digits
float64	8 byte	~15-16 digits

Go's default floating-point type is float64.

How Float Is Actually Stored

A float64 is stored in three parts following the IEEE 754 standard:

| 1 bit  | 11 bits  | 52 bits  |
| sign   | exponent | fraction |

A number like 3.14 is not stored as "3.14". It's converted into binary scientific notation:

(For an example, Value Representation of Binary: 11.001000111...=1.1001000111... × 2¹)
decimal to binary: 3.14 ≈ 1.5700... × 2¹

Then each part (sign, exponent, fraction) is encoded into those fixed bit slots. The problem: 52 bits of fraction is finite. Many decimal values need an infinite binary representation. The computer stores the closest approximation it can fit.

The Famous 0.1 + 0.2 Problem

fmt.Println(0.1 + 0.2)
// 0.30000000000000004

This is not a Go bug. It happens in Python, JavaScript, Java, C++, Rust — every language using IEEE 754 floating-point (which is almost all of them).

Here's why:

0.1 in binary is:

0.0001100110011001100110011...  (infinite)

Similar to how 1/3 = 0.3333... never ends in decimal. The computer can't store infinite digits, so it rounds. The stored value of 0.1 is actually:

0.10000000000000000555...

And 0.2 is:

0.20000000000000001110...

Add them, and the tiny errors accumulate:

0.30000000000000004

Want to see what's really happening under the surface?

fmt.Printf("%.20f\n", 0.1 + 0.3)
// 0.40000000000000002220

The output looks fine with default formatting, but the error is there.

The rule: Float is an approximation. It's designed for range and performance, not for exactness.

The Three Types Compared

Type	Exact?	Handles Decimals?	Max Size
int64	✅ Yes	❌ No	~9.2 × 10¹⁸
float64	❌ No	✅ Yes	~1.8 × 10³⁰⁸
big.Int	✅ Yes	❌ No	Unlimited

big.Int: When You Need Huge Exact Numbers

int64 is exact but has a ceiling. For numbers beyond that — cryptography, arbitrary-precision math — Go provides math/big:

package main

import (
    "fmt"
    "math/big"
)

func main() {
    n := new(big.Int)
    n.SetString("999999999999999999999999999999999", 10)
    fmt.Println(n)
    // 999999999999999999999999999999999  — exact
}

How does it work? Instead of one fixed 8-byte block, big.Int allocates multiple memory chunks and chains them together. The number grows as needed. Slower than int64, but unlimited and exact.

The Banking Rule

Money is the most common place developers get this wrong.

Never use float for money.

One cent of precision loss per transaction. Multiplied by millions of transactions. That's real money, and it's gone to rounding errors.

The industry-standard approach: store money as an integer in the smallest unit.

// DON'T do this
var balance float64 = 100.50

// DO this
var balance int64 = 10050  // stored as paisa or cents

When displaying:

10050 paisa → 100.50 taka

Integer arithmetic is exact. The display logic handles the decimal point. No precision issues.

For even more control — like fixed decimal arithmetic with explicit rounding rules — use a dedicated decimal library. But for most applications, the integer-as-smallest-unit approach is sufficient and battle-tested.

Text Types: rune and string

Go has two types for text. They look similar but work completely differently.

rune is an alias for int32. It holds one Unicode character — just a number under the hood.

var r rune = 'ক'   // stored as: 2453 (its Unicode code point)
var e rune = '😊'  // stored as: 128522

string is a read-only sequence of UTF-8 encoded bytes — not characters.

var s string = "Go😊ক"

That string takes 9 bytes in memory, not 4 characters:

Char	Bytes used
G	1
o	1
😊	4
ক	3

Go stores strings as raw bytes. Unicode meaning only appears when Go decodes them.

The len() Trap

s := "Go😊ক"
fmt.Println(len(s))  // 9 — bytes, not characters

len() on a string returns byte count, not character count. For ASCII-only strings this looks correct. For anything else, it misleads you.

fmt.Println(len("😊"))  // 4
fmt.Println(len("ক"))   // 3

The correct way to count characters:

fmt.Println(len([]rune("Go😊ক")))  // 4 ✓

Or iterate with range, which decodes UTF-8 properly:

for _, r := range "Go😊ক" {
    fmt.Printf("%c\n", r)  // prints each character correctly
}

Why String Slicing Breaks Characters

Since strings are byte arrays, slicing cuts bytes — not characters.

s := "😊"
fmt.Println(s[:2])  // prints: � (broken)

You cut the emoji's 4 bytes in half. The output is invalid UTF-8.

Bengali is even more dangerous. ক is 3 bytes (E0 A6 95). Almost every possible slice position cuts it mid-byte:

s := "ক"
fmt.Println(s[:1])  // E0 alone → broken
fmt.Println(s[:2])  // E0 A6 → still broken

And unlike emoji corruption (which renders visibly as ?), Bengali corruption can silently produce blank or wrong glyphs — harder to catch.

Safe slicing always goes through runes:

r := []rune("বাংলা")
fmt.Println(string(r[:2]))  // ✓ safe, correct characters

[]byte ↔ string: Memory Is Always Copied

Converting between []byte and string is not free — Go allocates new memory and copies every byte.

b := []byte("Hello")
s := string(b)   // new allocation + full copy
b[0] = 'X'       // does NOT affect s

This is intentional. Strings in Go are immutable. Sharing memory between a mutable []byte and an immutable string would cause data races and bugs. So Go always copies.

The cost is O(n). In hot paths that do many conversions, use strings.Builder or keep data as []byte for as long as possible.

Summary

Bit = one 0 or 1. Byte = 8 bits. All numbers are stored in binary.
int types are exact, but have a fixed range. Exceeding it causes silent overflow — it wraps around without error.
float types handle decimals, but are approximations. They use IEEE 754 binary scientific notation, and most decimals cannot be represented exactly in binary.
The 0.1 + 0.2 problem is not a language bug — it's how IEEE 754 works, and it applies to almost every modern language.
big.Int is exact and unlimited, but slower and uses more memory.
For financial systems, store amounts as integers (cents, paisa). Never use floats for money.

In the END:

Counting things       → int / int64
Decimal math          → float64 (if approximation is acceptable)
Financial values      → int64 (in smallest unit)
Huge exact numbers    → big.Int

Understanding this distinction is the difference between code that works and code that silently corrupts data.

golang beauty

Saiful Islam — Thu, 15 Jan 2026 05:54:10 +0000

Beyond the `go` Keyword: The Secret Life of Goroutines & The Go Runtime

Saiful Islam ・ Jan 14

#go #opensource #webdev #systems

Beyond the `go` Keyword: The Secret Life of Goroutines & The Go Runtime

Saiful Islam — Wed, 14 Jan 2026 18:46:23 +0000

The Complex and Beautiful Truth About Go's Concurrency Model

The Core Revelation: Goroutines Are Virtual, But Their Behavior Is Real

The most mind-bending insight: A goroutine has no physical form in your operating system. It is not in your process table. It is not a real OS resource.

A goroutine is a virtual thread.

Let me illustrate with a powerful analogy:

The Facebook Profile Analogy

Consider your social media profile. The profile itself is virtual—no flesh and blood. It's a logical construct. But when your virtual profile sends a message, a real person reads it. The behavior is real. The effect is real. The impact on the real world is undeniable.

Goroutines work the same way.

Virtual Profile → Sends Message → Real Person Reads It
Virtual Thread  → Executes Code  → Real Effect on State

A goroutine is logical. It exists as a concept within the Go Runtime. But when it executes, when it modifies variables, when it prints to stdout, when it sends over a network—those effects are profoundly real, executed by real OS threads on real CPU cores.

This distinction is not mere philosophy. It's the foundation for understanding everything that follows.

The Code Simulation: What Actually Happens

Let's trace through a simple example:

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("main function started")
    go fmt.Println("hello this is Islam Saiful-5")
    goRoutine()
    time.Sleep(5 * time.Second)
    fmt.Println("main function ended")
}

func goRoutine() {
    go fmt.Println("hello this is saiful")
    fmt.Println("hello world")
    go fmt.Println("hello this is saiful2")
    go fmt.Println("hello this is saiful3")
    go fmt.Println("hello this is saiful4")
    fmt.Println("bye world")
}

Without the `go` Keyword (Sequential Execution)

If we remove all go keywords:

Output:
main function started
hello world
bye world
hello this is Islam Saiful-5
main function ended

The execution is linear, predictable, deterministic. One thing after another.

With the `go` Keyword (Concurrent Execution)

With the go keywords, multiple things happen "simultaneously":

Output (Run 1):
main function started
hello world
bye world
hello this is saiful
hello this is saiful2
hello this is saiful3
hello this is saiful4
hello this is Islam Saiful-5
main function ended

Output (Run 2):
main function started
hello this is Islam Saiful-5
hello world
hello this is saiful
bye world
hello this is saiful4
hello this is saiful3
hello this is saiful2
main function ended

Output (Run 3):
main function started
hello world
hello this is saiful3
hello this is saiful
bye world
hello this is saiful4
hello this is Islam Saiful-5
hello this is saiful2
main function ended

Notice: The order is different every time. The goroutines are executing concurrently, and their relative ordering is non-deterministic.

The Critical Question: Why Do We Need `time.Sleep`?

time.Sleep(5 * time.Second)  // Why is this line essential?

This is the barrier protecting you from a hard truth: The main goroutine is a tyrant. When it finishes, it terminates the entire process—no exceptions.

If main returns before other goroutines complete, they are instantly killed. The OS doesn't care about them. The Go Runtime doesn't get a say. The process exits. Period.

The time.Sleep is a crude but effective way to keep the main goroutine alive long enough for others to finish. Without it:

func main() {
    go fmt.Println("Will this print?")
    // Nope. Main returns, process dies.
}

The answer is no. You never see that output.

This is why understanding the main goroutine's dominance is crucial.

The Birth of a Process: Disk → Binary → RAM → Execution

Step 1: Compilation (`go build main.go`)

When you compile your Go code:

go build main.go

You create a binary executable file. This file is structured:

Binary File
├── Code Segment
│   ├── Machine instructions (functions)
│   └── Constants (read-only)
├── Data Segment
│   └── Global variables (initialized)
└── BSS Segment
    └── Uninitialized globals

This binary sits on your hard disk, inert and lifeless. It's potential energy.

Step 2: Execution (`./main`)

When you run the binary:

./main

The OS loader springs into action:

Loads the binary into RAM from the hard disk
Allocates memory for the process
Creates a process structure (virtual computer)
Creates the main thread (first execution context)
Jumps to the entry point (typically, the Go Runtime initialization)

Now the binary transforms:

┌──────────────────────────┐
│      Hard Disk           │ (Inert binary file)
└─────────┬────────────────┘
          │ OS Loader
          ↓
┌──────────────────────────┐
│    RAM (Memory Layout)   │
├──────────────────────────┤
│   Code Segment           │ ← Machine instructions
├──────────────────────────┤
│   Data Segment           │ ← Global variables
├──────────────────────────┤
│   Stack                  │ ← Function calls, local vars
├──────────────────────────┤
│   Heap                   │ ← Dynamic memory
└──────────────────────────┘
          ↓
┌──────────────────────────┐
│    CPU Execution         │
│  (Fetches, Decodes,      │
│   Executes instructions) │
└──────────────────────────┘

This is where your program comes alive.

Enter the Go Runtime: The Mini-Operating System

This is the game-changer. The Go Runtime is a mini operating system running inside your Go process.

Think about it: The OS is a program that manages hardware, schedules threads, allocates memory. The Go Runtime does the same thing, but at a higher level, with different resources (goroutines instead of threads, logical processors instead of physical cores).

Timeline of Execution

1. OS loads binary into RAM
2. Process created with main thread
3. Main thread starts at the entry point
4. Go Runtime INITIALIZES (before your code runs!)
5. Go Runtime sets up:
   - 8MB main stack
   - Goroutine Scheduler
   - Heap Allocator
   - Garbage Collector
   - Logical Processors
6. THEN your main() function executes
7. When main() returns, Go Runtime shuts down
8. Process terminates

Key insight: Your code doesn't have exclusive control. The Go Runtime is always present, always managing, always orchestrating.

The Four Core Components

1. Goroutine Scheduler

The traffic controller of your program. It:

Tracks all goroutines
Decides which goroutine runs when
Manages the G-M-P model (Goroutine-Machine-Processor)
Works like the OS kernel scheduler, but in user-space

2. Heap Allocator

The memory banker. It:

Allocates memory for goroutine stacks
Manages the make() and new() allocations
Tracks where every byte lives
Works alongside the Garbage Collector

3. Garbage Collector

The janitor of memory. It:

Identifies unreachable memory
Reclaims it automatically
Runs concurrently with your code
Uses mark-and-sweep algorithms

4. Logical Processors (P)

Virtual CPUs. They:

Correspond to your system's actual CPU cores
If your CPU has 4 cores, you get 4 Logical Processors
Each has a run queue of goroutines
Each is paired with an OS thread (M)

CPU has 4 cores
    ↓
Go Runtime creates 4 Logical Processors (P)
    ↓
OS creates 4 OS Threads (M)
    ↓
Each M executes goroutines from its P's queue

The Complete Layer Hierarchy: From CPU to Your Code

Understanding concurrent execution requires understanding all layers:

┌────────────────────────────────────────────┐
│         Your Go Code                       │
│  func main() { go doWork() }               │
└────────────────────────────────────────────┘
                    ↓
┌────────────────────────────────────────────┐
│      Goroutines (G)                        │
│  - Virtual threads                         │
│  - 2KB initial stack                       │
│  - Auto-growing stacks (heap)              │
│  - Thousands can exist                     │
└────────────────────────────────────────────┘
                    ↓
┌────────────────────────────────────────────┐
│  Logical Processors (P)                    │
│  - Virtual CPUs                            │
│  - Count = runtime.NumCPU()                │
│  - Each has a run queue of Gs              │
│  - Owned by Go Runtime Scheduler           │
└────────────────────────────────────────────┘
                    ↓
┌────────────────────────────────────────────┐
│    OS Threads (M)                          │
│  - Real OS threads                         │
│  - 8MB stack each (kernel memory)          │
│  - ~1 per P                                │
│  - Owned by OS Kernel                      │
└────────────────────────────────────────────┘
                    ↓
┌────────────────────────────────────────────┐
│  Go Runtime Scheduler                      │
│  - Maps G → P → M                          │
│  - User-space scheduling                   │
│  - Work-stealing algorithm                 │
└────────────────────────────────────────────┘
                    ↓
┌────────────────────────────────────────────┐
│  OS Kernel Scheduler                       │
│  - Schedules OS threads (M)                │
│  - Kernel-space scheduling                 │
│  - Preemptive scheduling                   │
└────────────────────────────────────────────┘
                    ↓
┌────────────────────────────────────────────┐
│    CPU Cores                               │
│  - Physical execution                      │
│  - Execute machine instructions            │
│  - Control Unit, Program Counter,          │
│    Registers                               │
└────────────────────────────────────────────┘

This is the symphony. Each layer abstracts the one below, providing a simplified interface. Your code sees only goroutines. The Go Runtime handles the rest.

The 2KB Secret: Why Goroutines Are Lightweight

This is where goroutines become magical.

OS Thread Stack: Fixed 8MB

When the OS creates a thread, it immediately allocates 8MB for its stack. This is fixed. Whether you use 1KB or 7.9MB, the OS has reserved 8MB.

Implication: You can create only thousands of threads. Beyond that, you run out of memory.

1,000,000 threads × 8 MB = 8,000,000 MB = 8 TB

No modern system has 8TB of memory for thread stacks.

Goroutine Stack: 2KB Initial, Dynamic Growth

A goroutine starts with 2KB—that's a 4000:1 ratio.

But here's the magic: It's not fixed. When a goroutine needs more stack (due to nested function calls), the Go Runtime reallocates:

2KB stack is full
    ↓
Go Runtime detects overflow
    ↓
Allocates new 4KB stack in heap
    ↓
Copies all data from old to new
    ↓
Deletes old stack
    ↓
Continues execution seamlessly

This is transparent to your code. You never see it. It just works.

Implication: You can create millions of goroutines.

1,000,000 goroutines × 2 KB = 2,000,000 KB = 2 GB

Most modern systems have 2GB of RAM available.

The Memory Efficiency Advantage

Aspect	OS Thread	Goroutine
Stack Size	8 MB (fixed)	2 KB (initial)
Stack Location	Kernel memory	Heap memory
Growth	None	Dynamic
Max Stack	Fixed	Up to 1 GB
Creation Overhead	High (syscall)	Low (runtime call)
Thousands Possible?	~4,000	Yes
Millions Possible?	No	Yes

This memory efficiency is why Go can handle massive concurrency. This is why you can build a server handling 1 million concurrent connections. This is why goroutines exist.

The Scheduling Model: (from BGCE ARCHIEVE)

The Go Runtime's scheduler implements the G-M-P model:

G = Goroutine (user-created concurrent units)
M = Machine (OS thread)
P = Processor (logical CPU)

How the Scheduler Works

You write: go printHello(1)
    ↓
Go Runtime creates Goroutine G1
    ↓
Scheduler adds G1 to a Processor's run queue
    ↓
When a Machine (OS thread) is free on that Processor
    ↓
M picks G1 from P's queue
    ↓
M executes G1 on the CPU
    ↓
When G1 blocks or finishes
    ↓
M picks next G from queue
    ↓
Repeat

Visual Example

Imagine a CPU with 4 cores:

Go Runtime Scheduler
         │
    ┌────┼────┬────┐
    ↓    ↓    ↓    ↓
   P1   P2   P3   P4  (4 Logical Processors)
   │    │    │    │
   M1   M2   M3   M4  (4 OS Threads)
   │    │    │    │
   G1,G5,G9 G2,G6,G10 G3,G7,G11 G4,G8,G12
   │         │        │        │
   (4 Gs per queue, 12 total goroutines)
   │         │        │        │
   ↓         ↓        ↓        ↓
 Core1    Core2    Core3    Core4  (Physical CPU Cores)

The scheduler's job: Keep those 4 cores busy by swapping goroutines in and out.

Scheduling Example: 100,000 Goroutines

100,000 goroutines on 4 cores:
- P1, P2, P3, P4 each have a queue of ~25,000 Gs
- M1, M2, M3, M4 rapidly swap goroutines
- If G1 blocks on I/O, M1 picks G2 from queue
- Context switching happens microseconds
- From CPU's perspective, all 4 cores are always busy
- From your perspective, 100,000 things happen "simultaneously"

This is the magic. It's not parallel (only 4 at a time). It's concurrent (interleaved, but appears simultaneous).

📚 Stack & Heap: Where Goroutines Live

Main Goroutine vs Other Goroutines

Main Goroutine:
  - Executes main() function
  - Stack in kernel memory (8MB)
  - Special status: only one per process
  - When it exits, process terminates

Other Goroutines:
  - Created with `go func()`
  - Stack in heap memory (2KB initial)
  - Completely interchangeable
  - Process continues even if they exit

Memory Layout During Execution

Process Memory
├─ Kernel Stack (8MB for main goroutine)
│  ├─ main()
│  ├─ printHello()
│  ├─ fmt.Println()
│  └─ ... (other function frames)
│
└─ Heap
   ├─ Goroutine 1 Stack (2KB → 4KB → 8KB)
   │  ├─ printHello(1)
   │  ├─ fmt.Println()
   │  └─ ...
   │
   ├─ Goroutine 2 Stack (2KB)
   │  ├─ printHello(2)
   │  └─ ...
   │
   ├─ Goroutine 3 Stack (2KB → grows)
   │  └─ ...
   │
   └─ ... (more goroutines)

Each goroutine is independent. Their stacks are separate, managed individually. When a goroutine needs more stack, the Go Runtime handles it—allocating new space, copying data, updating pointers.

Summarized

Goroutines are virtual threads
- Logical, not physical
- Managed by Go Runtime, not OS
- Their behavior is real, their existence is virtual
Go Runtime is a mini-operating system
- Initializes before your code
- Manages scheduler, allocator, garbage collector
- Orchestrates everything transparently
Memory efficiency is the secret
- 2KB goroutine vs 8MB OS thread (4000:1 ratio)
- Dynamic growth in heap memory
- Millions possible, not thousands
Scheduling is sophisticated
- G-M-P model: Goroutines → Processors → Machines → CPU
- Work-stealing algorithm for load balancing
- Non-deterministic by design, not accident
Main goroutine is your control point
- First goroutine to run
- Process persists while it's alive
- Control its lifetime via blocking mechanisms
Non-determinism is a feature
- Prevents race conditions by forcing safe code
- Scales with confidence
- Forces channels over shared memory
Layers of abstraction protect you
- You write code; don't manage threads
- Go Runtime handles scheduling
- OS Kernel handles execution
- CPU handles actual computation

Separate Stack for separate Thread.

Saiful Islam — Sat, 10 Jan 2026 08:31:05 +0000

Threads & Processes:

Core Concept: Each thread needs its own stack, but threads within a process share code, data, and heap. The OS Kernel orchestrates everything.

What is a Process?

A process is a running program isolated from other processes. When you open Chrome or Spotify, the OS creates a process. It starts with one thread (the main thread) and has its own memory space. The kernel creates a Process Control Block (PCB) to track everything about the process.

What is a Thread?

A thread is an execution path within a process. Multiple threads can exist in one process and share code and data, but each thread must have its own stack. The kernel creates a Thread Control Block (TCB) for each thread to track its state.

Process Memory Layout

Segment	Type	Shared?	Notes
Code	Compiled program instructions	✅ All threads	Read-only, fixed size
Data	Global variables	✅ All threads	Fixed size, initialized
Heap	Dynamic memory (malloc/new)	✅ All threads	Grows upward, managed by programmer
Stack	Local variables, function calls	❌ Per thread	Grows downward, isolated per thread

Why Separate Stacks?

If two threads shared one stack, their function calls would collide and corrupt each other's data. When Thread A calls a function, it creates a stack frame. If Thread B also calls a function and adds its frame to the same stack, the frames overlap and overwrite each other. When Thread B returns and pops its frame, Thread A's data becomes corrupted.

Solution: Each thread has its own stack for its function calls and local variables. This way, Thread A and Thread B can execute different functions simultaneously without interfering with each other. Both threads execute independently and safely.

Stack Frames and LIFO

Stack frames work with LIFO (Last In, First Out) order. When main() calls functionA(), which calls functionB(), a new frame is created for each function on the stack. When functionB() completes and returns, its frame is removed from the stack, revealing functionA()'s frame. Then functionA() returns and its frame is removed. This ensures proper return flow and variable access.

Each thread has its own stack, so multiple threads can call the same functions simultaneously without interference. Thread A's stack frames remain separate from Thread B's stack frames.

Thread Creation: Main vs. Sub-threads

When a process starts, the OS automatically creates one thread—the main thread. This main thread is the entry point for the program and begins execution at the main() function.

The main thread can then create additional threads by calling pthread_create(). These new threads are called sub-threads. However, once created, all threads are treated as peers by the kernel. The main thread is not special anymore—it has no more authority than the sub-threads.

Thread Hierarchy

Process Created by OS
    ↓
Main Thread (created automatically by kernel)
    ├─→ Sub-thread 1 (created by main thread)
    ├─→ Sub-thread 2 (created by any thread)
    └─→ Sub-thread 3 (created by any thread)

Each sub-thread receives its own stack (allocated by the kernel), its own TCB (Thread Control Block), and shares the process's code, data, and heap. Sub-threads can also create more sub-threads if needed.

Music Player Example

A music player demonstrates multi-threading well. The main thread handles the UI and user interactions. But instead of blocking on audio playback or file I/O, it creates sub-threads to handle these tasks concurrently. One sub-thread decodes and plays audio continuously. Another sub-thread handles file system operations like loading songs. A third sub-thread updates the timer display.

All threads share the music player's code and data (the song list, player settings, etc.). But each thread has its own stack for local variables and function execution. The kernel rapidly switches between threads, giving each one a time slice to execute. This makes it appear that all tasks happen simultaneously.

The OS Kernel: Central Orchestrator

The kernel is the central manager of the OS. It handles all resource allocation and coordination for processes and threads.

Process Management

The kernel creates a Process Control Block (PCB) for every process. This PCB stores the process's ID, state (running, waiting, ready, etc.), memory layout information, file descriptors, and signal handlers. The kernel uses this information to manage the process, isolate it from other processes, and enforce security.

Thread Management

For each thread, the kernel creates a Thread Control Block (TCB). The TCB stores the thread's ID, state, CPU registers (Program Counter, Stack Pointer), stack address and size, thread-local storage, and scheduling information. The kernel tracks all this information so it can schedule and manage threads properly.

Memory Management

The kernel allocates memory for thread stacks using system calls like mmap(). It reserves virtual address space for each thread's stack. The kernel also creates guard pages at the stack boundaries to detect stack overflow conditions. When a thread actually uses its stack, the kernel allocates physical memory on demand.

CPU Scheduling

The kernel decides which thread runs on which CPU core and for how long. It uses scheduling algorithms to fairly distribute CPU time among all threads. When a thread's time slice expires or it needs to wait for I/O, the kernel performs a context switch.

Context Switching

During a context switch, the kernel saves the current thread's CPU state (Program Counter, Stack Pointer, and all CPU registers) into the thread's TCB. It then loads the next thread's saved state from its TCB into the CPU registers. The CPU then resumes execution from the restored Program Counter, effectively transferring control to the next thread. The thread resumes as if it was never interrupted.

Default Stack Size by OS

Different operating systems allocate different amounts of stack space per thread. This is virtual address space, not physical RAM.

Linux: 8 MB per thread. For 10 threads, that's 80 MB of reserved virtual space, but actual physical RAM used is only what the threads actually consume (typically a few kilobytes per thread).

Windows: 1 MB per thread. For 10 threads, that's 10 MB of reserved space. Windows balances stack size with resource efficiency.

macOS: 512 KB per thread. For 10 threads, that's 5 MB of reserved space. macOS is more conservative with memory.

Java: 1 MB per thread on most systems. The JVM handles stack allocation for Java threads.

Go: Approximately 2 KB per goroutine. Go's goroutines are much lighter because Go's runtime manages them, not the operating system. A single Go program can have thousands or even millions of goroutines running efficiently.

Why Different Sizes?

Linux's larger 8 MB stack supports deep recursion and large local variables in complex applications. Windows's 1 MB stack balances stability with resource usage. macOS's smaller 512 KB stack reflects its design philosophy of resource efficiency. Go's tiny goroutine stacks work because the Go runtime manages memory and context switching with more efficiency than the OS kernel.

Virtual vs. Physical Memory

When the kernel allocates 8 MB of stack space for a thread, it reserves 8 MB of virtual address space. However, it doesn't immediately use 8 MB of physical RAM. Instead, it uses demand paging. Only when the thread actually writes to stack memory does the kernel allocate physical pages. If a thread only uses 100 KB of its 8 MB stack, then only 100 KB of actual RAM is used. The remaining 7.9 MB of virtual space uses no physical memory at all.

This allows the kernel to efficiently allocate stacks without wasting memory, even for systems with hundreds or thousands of threads.

Kernel Data Structures

Process Control Block (PCB)

The PCB contains the process ID, process state, memory layout (where code, data, heap, and stacks are located), file descriptor table, signal handlers, and a list of all threads in the process. The kernel uses this information to manage the process's lifecycle and resources.

Thread Control Block (TCB)

The TCB contains the thread ID, thread state, CPU registers (Program Counter, Stack Pointer, etc.), the address and size of the thread's user-mode stack, thread-local storage information, scheduling priority, and a pointer to the kernel stack. The kernel uses the TCB during context switches to save and restore thread state.

Kernel Stack vs. User Stack

Every thread actually has two stacks: a user-mode stack and a kernel-mode stack.

The user-mode stack is what we've been discussing. It's used when the thread executes user code. It holds local variables, function parameters, and return addresses. It's located in the process's virtual address space and has a typical size like 8 MB on Linux.

The kernel-mode stack is used when the kernel executes on behalf of the thread. This happens during system calls (like reading a file), handling interrupts, or other kernel operations. The kernel-mode stack is separate and in kernel memory, which is protected from user code. This prevents user code from corrupting kernel data structures.

When a thread calls a system call like read() or write(), the CPU switches to kernel mode, loads the kernel stack pointer for that thread, and the kernel code executes on the kernel stack. After the system call completes, the CPU switches back to user mode and restores the user stack pointer.

Key Late Flourish at once!

Processes are isolated: Each process has its own memory space and is protected from other processes. The kernel enforces this isolation.

Threads share resources: All threads within a process share the code, data, and heap. They cooperate to perform the process's tasks.

Each thread has its own stack: The stack is the only memory region per thread within a process. This ensures independent execution.

Main thread is special only initially: It's the entry point (at main()), but all threads become peers once created.

Sub-threads created via pthread_create(): The main thread or any other thread can create new threads.

Kernel allocates all stacks: Stack size defaults are 8 MB (Linux), 1 MB (Windows), 512 KB (macOS).

Kernel manages scheduling: The kernel controls which thread runs, for how long, and on which CPU core.

Context switching enables multitasking: Rapid context switches between threads create the illusion of parallel execution on a single core.

Stack frames implement LIFO: Function calls push frames, returns pop frames. This is fundamental to how program control flow works.

Demand paging saves RAM: Virtual stack space doesn't consume physical memory until actually used.

TCBs track all thread state: The kernel maintains TCBs to manage threads throughout their lifetime.

Understanding This Matters

Understanding how threads work at the operating system level is fundamental to computer science. It reveals how your code actually executes at the hardware level. You're not just using threading APIs—you're understanding the real mechanisms that make concurrent programming possible. This foundation is essential for building efficient, safe multithreaded applications and for understanding more advanced concurrency concepts like goroutines in Go.

Go's Defer: Simple Rules, Deep Runtime Truths with intuitions.

Saiful Islam — Fri, 09 Jan 2026 10:21:27 +0000

Introduction

defer schedules a function call to run just before the surrounding function returns. If you think it's just "a function that runs at the end," you're missing the important details about how Go actually executes your code.

This guide explains what defer really does and how it works at the runtime level.

Quick Mental Model

Before diving deep, understand this fundamental truth:

return x (unnamed): The value is copied immediately, frozen in a register
return with named result: The variable stays mutable until the function exits

This single insight explains 90% of defer behavior.

What `defer` Does

defer stores a function call and executes it when the function returns.

func basicExample() {
    defer fmt.Println("This runs last")
    fmt.Println("This runs first")
    // Output:
    // This runs first
    // This runs last
}

What actually happens:

The function call is stored (not executed)
Execution continues normally
At return time, all deferred calls execute

Argument Evaluation vs Execution Time

Arguments are evaluated immediately, not when the deferred function runs.

func argumentTiming() {
    i := 1
    defer fmt.Println("Deferred print:", i)  // i is evaluated NOW (value 1)
    i = 2
    // Output: Deferred print: 1
}

The value 1 is captured when defer is encountered. Changing i later has no effect.

Stack Frames and Execution

When a function is called:

A stack frame is created
Local variables are allocated
A defer list pointer is attached to the frame

When defer is encountered, the function call is stored in the defer list:

┌─────────────────────┐
│    Stack Frame      │
├─────────────────────┤
│ Local Variables     │
│ Return Address      │
│ Defer List Pointer──┼──→┌─────────────┐
└─────────────────────┘   │  Defer Node │
                          ├─────────────┤
                          │ Function    │
                          │ Arguments   │
                          │ Next ───────┼─→ [More Defers]
                          └─────────────┘

LIFO Order: Last-In, First-Out

Multiple defer statements execute in reverse order:

func lifoExample() {
    defer fmt.Println("First")
    defer fmt.Println("Second")
    defer fmt.Println("Third")

    // Output:
    // Third
    // Second
    // First
}

The last defer added is the first one to execute.

Named vs Unnamed Return Values

This is the core concept. Named and unnamed returns behave differently with defer.

Unnamed Return (Value is Captured)

func unnamedReturn() int {
    x := 5
    defer func() {
        x = x + 10  // Too late to affect return value
    }()
    return x  // Value 5 is captured here
}
// Returns: 5

When return x executes, Go immediately captures the value 5. Deferred functions run after, but they can't change what's already captured.

Named Return (Variable is Shared)

func namedReturn() (result int) {
    defer func() {
        result = result + 10  // Modifies the return variable!
    }()
    result = 5
    return // Returns the modified value
}
// Returns: 15

result is a variable in the stack frame that deferred functions can access and modify until the function actually returns.

Deep Dive: Named vs Unnamed Returns with Closures

Example 1: Named Return

package main

import "fmt"

func calculate() (result int) {
    result = 0
    fmt.Println("first", result)

    show := func() {
        result = result + 10
        fmt.Println("defer", result)
    }
    defer show()

    result = 5
    p := func(a int) {
        fmt.Println("me", a)
    }
    defer p(result)

    defer fmt.Println(result)

    fmt.Println("second", result)

    defer fmt.Println(5)

    return result
}

func main() {
    fmt.Println("calculate result:", calculate())
}

Output:

first 0
second 5
5
me 5
5
defer 15
calculate result: 15

Explanation:

result = 0 → prints "first 0"
defer show() → closure registered (captures reference to result)
result = 5
defer p(result) → function called with value 5 (argument captured immediately)
defer fmt.Println(result) → value 5 captured
defer fmt.Println(5) → literal 5
fmt.Println("second", result) → prints "second 5"
return result → return statement reached

Defers execute in LIFO order:

defer fmt.Println(5) → "5"
defer fmt.Println(result) → "5"
defer p(result) → "me 5"
defer show() → closure modifies result to 15, prints "defer 15"

Return value becomes 15 because the named return variable was modified by the closure before the function actually returned.

Example 2: Named vs Unnamed Comparison

package main

import "fmt"

// Named return: defer can modify it
func calculate() (result int) {
    result = 0
    fmt.Println("first", result)

    show := func() {
        result = result + 10
        fmt.Println("defer", result)
    }
    defer show()

    result = 5
    fmt.Println("second", result)
    return result
}

// Unnamed return: defer cannot modify it
func calc() int {
    result := 0
    fmt.Println("first", result)

    show := func() {
        result = result + 10
        fmt.Println("defer", result)
    }
    defer show()

    result = 5
    fmt.Println("second", result)
    return result
}

func main() {
    fmt.Println("calculate result:", calculate())
    fmt.Println("calc result:", calc())
}

Output:

first 0
second 5
defer 15
calculate result: 15
first 0
second 5
defer 15
calc result: 5

The Difference:

Aspect	`calculate()` (Named)	`calc()` (Unnamed)
Return Value	15	5
What Happens	Closure modifies return variable	Closure modifies local variable
Return Mechanism	Returns modified variable	Returns captured value

Execution Timeline

Named Return (calculate()):

1. Enter function → result = 0 (named return in stack frame)
2. Register defer show() → closure captures reference to 'result'
3. Set result = 5
4. Return statement reached → process defer list
5. Execute show() → result = 15
6. Return final value of 'result' = 15

Unnamed Return (calc()):

1. Enter function → result = 0 (local variable)
2. Register defer show() → closure captures reference to 'result'
3. Set result = 5
4. Return statement reached → value 5 captured in register
5. Process defer list → execute show() → result = 15 (local changed)
6. Return value from register = 5 (unchanged!)

Understanding Closures in Defer

Deferred closures capture variables by reference, not by value:

func closureExample() (result int) {
    defer func() {
        result = result * 2  // Shares the same memory address
    }()

    result = 5
    return  // Returns 10, not 5
}

The closure has access to the actual result variable and can modify it.

Reference vs Copy Semantics

Scenario	Behavior	Example
Direct value in `defer`	Copy	`defer fmt.Println(x)`
Closure capturing variable	Reference	`defer func() { use(x) }()`
Named return variable	Reference	`func f() (x int)`
Unnamed return value	Copy (captured)	`return x`

func referenceVsCopy() {
    x := 1
    defer fmt.Println("Copy:", x)  // Captures value 1
    x = 2

    y := 1
    defer func() {
        fmt.Println("Reference:", y)  // Will see y=2
    }()
    y = 2
}
// Output:
// Reference: 2
// Copy: 1

How Go Implements defer Internally

Go implements defer using a singly linked list where each function's stack frame maintains a pointer to a chain of defer records.

Defer Record Allocation

When defer is encountered, Go:

Creates a new defer record (stack- or heap-allocated depending on escape analysis)
Stores the function pointer and captured arguments
Links it to the defer chain starting from the most recent addition

This means each defer statement prepends to the chain, naturally achieving LIFO order.

Defer Record Structure

A conceptual view of the defer record structure:

// Simplified conceptual structure
// (actual runtime definitions vary by Go version)
type _defer struct {
    fn   func()       // Function to call
    args []uintptr    // Captured argument values
    next *_defer      // Pointer to next defer in chain
}

Note: This is a simplified conceptual structure; actual runtime definitions vary by Go version and may include additional fields for panic handling and frame pointers.

Execution Flow

Stack Frame
├─ Local Variables
├─ Return Address
└─ Defer List Pointer ──→ [Defer Record #3] (most recent)
                          ├─ Function: show()
                          ├─ Arguments: captured values
                          └─ Next ──→ [Defer Record #2]
                                      ├─ Function: p()
                                      ├─ Arguments: 5
                                      └─ Next ──→ [Defer Record #1]
                                                  ├─ Function: fmt.Println()
                                                  ├─ Arguments: 5
                                                  └─ Next ──→ NULL

When the function returns, execution starts at the head (most recently added defer) and follows the chain:

func example() {
    defer fmt.Println("1")  // Record 1
    defer fmt.Println("2")  // Record 2 (becomes head)
    defer fmt.Println("3")  // Record 3 (new head)

    // At return:
    // Head → Record 3 (execute) → Record 2 (execute) → Record 1 (execute) → NULL

    // Output:
    // 3
    // 2
    // 1
}

Why This Design?

Per-function management: Each function tracks its own defer chain independently
Dynamic size: No fixed limit on defer count; scales with runtime behavior
O(1) insertion: Adding a new defer is a single pointer operation
Natural LIFO: Prepending to the head automatically gives reverse execution order
Closure support: Each record can capture different closure environments
Panic handling: The defer chain is traversed even during panic recovery

Common Pitfalls

Loop Variable Capture

// WRONG: All closures see final value of i
func problematicLoop() {
    for i := 0; i < 3; i++ {
        defer func() {
            fmt.Println(i)  // Prints: 3, 3, 3
        }()
    }
}

// RIGHT: Pass as parameter to capture value
func fixedLoop() {
    for i := 0; i < 3; i++ {
        defer func(n int) {
            fmt.Println(n)  // Prints: 2, 1, 0
        }(i)
    }
}

Resource Cleanup in Loops

// WRONG: All Close() calls happen at end of function
func processFiles(filenames []string) {
    for _, name := range filenames {
        f, _ := os.Open(name)
        defer f.Close()  // Accumulates
    }
}

// RIGHT: Use a wrapper function for scope
func processFilesCorrect(filenames []string) {
    for _, name := range filenames {
        func() {
            f, _ := os.Open(name)
            defer f.Close()  // Closes immediately after this iteration
        }()
    }
}

Error Handling in Defer

func mightFail() (err error) {
    f, err := os.Open("file.txt")
    if err != nil {
        return err
    }
    defer func() {
        if closeErr := f.Close(); closeErr != nil {
            if err == nil {
                err = closeErr  // Combine errors with named return
            }
        }
    }()

    // Process file...
    return nil
}

Practical Patterns

Resource Cleanup (Named Return)

func openResource() (err error) {
    r, err := acquireResource()
    if err != nil {
        return
    }

    defer func() {
        if closeErr := r.Close(); closeErr != nil && err == nil {
            err = closeErr  // Can modify named return
        }
    }()

    // Use resource...
    return nil
}

Panic Recovery

func safeOperation() (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic: %v", r)
        }
    }()

    // Code that might panic...
    return nil
}

Transaction Pattern

func transaction() error {
    tx := db.Begin()
    defer func() {
        if r := recover(); r != nil {
            tx.Rollback()
            panic(r)
        }
    }()

    // Do work...
    return tx.Commit().Error
}

Performance Considerations

Defer is cheap for most use cases. However, in very tight loops with millions of iterations, the overhead of managing the defer chain becomes measurable:

// Slower: defer in tight loop (millions of iterations)
func processBatch1(items []Item) {
    for _, item := range items {
        mu.Lock()
        defer mu.Unlock()  // Creates millions of deferred records
        process(item)
    }
}

// Faster: explicit unlock (millions of iterations)
func processBatch2(items []Item) {
    for _, item := range items {
        mu.Lock()
        process(item)
        mu.Unlock()  // Immediate cleanup, no defer overhead
    }
}

When to use defer:

One-time resource cleanup (file opens, lock acquisition)
Error handling and panic recovery
Any non-performance-critical code

When to avoid defer:

Extremely hot loops with millions of iterations
Real-time systems with strict latency requirements

Modern Go (1.20+) has optimized defer significantly with open-coded defers, making it even cheaper in most scenarios.

Closures in Go:- escape analysis, memory layout, and runtime behavior

Saiful Islam — Thu, 06 Nov 2025 13:29:30 +0000

Closures in Go Includes the exact code, what the compiler does at compile-time, runtime steps, stack vs heap comparison, a compact memory diagram, and GC is here.

Starting with a code Example
Program output
What is a closure
Why closures matter
Compiler time: code/data segments & compilation flow
Key segments (table)
Escape analysis — what it is and how it decides
Runtime behavior — stepwise
- Program startup
- Call to outer()
- Invoking the closure
- Multiple closures
- End of life
Stack vs Heap — compact comparison table
Memory visualization (CLI)
Garbage collector role

12. Minimal step-by-step trace (first `outer()` and two closure calls)

1. Starting with a code Example

package main

import "fmt"

const a = 10    // compile-time constant
var p = 100     // package-level variable

func init() {
    fmt.Println("Bangla Bank")
}

func outer() func() {
    age := 30
    money := 100

    fmt.Printf("Age = %d\n", age)

    show := func() {
        money = money + a + p
        fmt.Println(money)
    }

    return show
}

func main() {
    incr1 := outer() // creates closure capturing `money`
    incr1()          // prints updated money
    incr1()          // prints updated money again

    incr2 := outer() // new closure instance — independent `money`
    incr2()
    incr2()
}

2. Program output

Bangla Bank
Age = 30
210
320
Age = 30
210
320

Note: two separate closures created by two calls to outer() (incr1 and incr2), each with its own money value so their state does not interfere.

3. What is a closure

A closure in Go is a function value (commonly an anonymous function) that captures identifiers (variables) from its surrounding lexical scope. Captured variables remain accessible to the closure after the outer function returns. In the example above, show captures money. Because show is returned and can be invoked later, the captured money must survive the lifetime of outer().

Implementation note (runtime view): a function value is usually represented as a small runtime struct containing a pointer to the compiled code and a pointer to the closure's environment (the captured variables).

4. Why closures matter

Closures allow a function to carry state with it (function + environment).
Each call to outer() returns an independent function value with its own captured environment. That’s why incr1() and incr2() maintain separate money values.
Knowing how captured variables are stored (stack vs heap) is essential for reasoning about performance and lifetime.

5. Compiler time: code/data segments & compilation flow

At compile-time the Go toolchain typically:

Compiles function bodies into machine code → code segment (read-only).
Places package-level variables into the data segment (globals).
Treats local variables as stack candidates until escape analysis decides they must escape.
Produces a binary where constants, functions, and globals are laid into appropriate areas.

The escape analysis pass marks variables that must live beyond their creating function; the compiler will then arrange for those variables to be heap-allocated.

6. Key segments and examples from the program

Segment	What it stores (this program)
Code segment	compiled instructions for `init`, `main`, `outer`, and the anonymous `show` function. (Note: `const a` is a compile-time constant — see "Anomalies & fine points" for nuance.)
Data segment	package/global vars: `p`
Stack	local variables used only during function execution (e.g., `age`)
Heap	variables that escape (e.g., the `money` cell when captured by the closure)

7. Escape analysis- what it is and how it decides

Escape analysis is a compile-time analysis that decides whether a variable can safely live on the stack or must be moved (escape) to the heap.

Simplified rules (high level):

If a variable is used only inside the function and cannot be referenced afterwards → keep it on the stack.
If a variable's address is taken, stored in a place that outlives the function, or is captured by a function value that may outlive the function (returned or stored elsewhere) → the variable escapes and is allocated on the heap.

In the example:

age is used only inside outer() and is never referenced by show → stays on the stack.
money is referenced by show and show is returned → money escapes and is allocated on the heap.

8. Runtime behavior- function values, stack frames, heap objects

Program startup

Package init() runs (prints Bangla Bank).
Program loads code/data segments and prepares to execute main().

Call to `outer()`

A stack frame for outer() is created.
age := 30 is allocated as a stack-local candidate.
money := 100 is created but marked by escape analysis as escaping; the compiler arranges for it to be allocated on the heap (addressable by the closure environment).
The anonymous function show has compiled code in the code segment; the runtime builds a function value that contains:
- a pointer to the compiled code for the anonymous function, and
- a pointer to the captured environment (a heap object holding money).
outer() returns that function value; the stack frame is popped but the heap environment remains reachable through the function value.

Invoking the closure

Calling the function value (e.g., incr1()) jumps to the code pointed to by the function value.
The closure code uses the environment pointer to access and modify the heap-stored money cell.
Repeated calls mutate the same heap cell referenced by the closure (so state persists across calls).

Multiple closures

Each call to outer() that returns a closure creates a separate heap allocation for money.
incr1 and incr2 therefore refer to different heap objects; their money states do not interfere.

End of life

When there are no remaining references to a closure's function value (and thus to its environment), the heap object becomes unreachable and the GC may reclaim it.

9. Stack vs Heap- compact comparison table

Property	Stack	Heap
Allocation	Automatic per function call	By compiler/runtime when variable escapes
Lifetime	LIFO — ends when function returns	Lives until GC collects unreachable objects
Use case	Temporary locals (`age`)	Captured locals that outlive function (`money`)
Management	Implicit, no GC involvement	Managed by Go garbage collector
Access cost	Fast, no pointer indirection	Additional indirection; GC overhead
Visibility to closure	Not available after return	Reachable via closure function value

10. Memory visualization (CLI-style)

┌─────────────────────────────┐
│ Code segment                │
│ --------------------------- │
│ compiled code: init, main,  │
│ outer, anonymous show       │
│ (const a inlined at compile time)
└─────────────────────────────┘
           ↓
┌─────────────────────────────┐
│ Data segment                │
│ --------------------------- │
│ var p = 100                 │
└─────────────────────────────┘
           ↓
┌─────────────────────────────┐
│ Stack                       │
│ --------------------------- │
│ outer() frame               │
│   age = 30                  │
│   return address, locals    │
└─────────────────────────────┘
           ↓
┌─────────────────────────────┐
│ Heap                        │
│ --------------------------- │
│ money = 100 (for incr1)     │
│ money = 100 (for incr2)     │
└─────────────────────────────┘

Each returned closure function value points to the code segment (function code) and a pointer to its own heap block that holds money.

11. Garbage collector role

When closures (and references to them) go out of scope, the heap objects they reference become unreachable. Go's GC reclaims unreachable heap memory using concurrent mark-and-sweep techniques (collection timing is nondeterministic and happens automatically). From the programmer's perspective: you don't free these captured variables manually — the runtime does it when they become unreachable.

12. Minimal step-by-step trace (first `outer()` and two closure calls)

outer() called:
- age := 30 (stack)
- money := 100 → marked to escape → heap allocation for money
- fmt.Printf("Age = %d\n", age) prints Age = 30
- show is created as a function value (code pointer + pointer to heap money)
- outer() returns show
incr1() (first call):
- money = money + a + p → 100 + 10 + 100 = 210
- prints 210
incr1() (second call):
- money = 210 + 10 + 100 = 320
- prints 320
incr2 := outer() repeats the above steps and creates a new heap cell for money for the second closure.
When incr1 and incr2 become unreachable, GC reclaims their respective money blocks.

Mastering Scopes in Go

Saiful Islam — Tue, 14 Oct 2025 09:01:15 +0000

Scopes ins and outs

Basics for all advanced Go concepts, it is scope. Without a rock-solid understanding of scope, your programs will feel confusing and unpredictable—if a variable isn't accessible where you expect it, you'll get that dreaded "undefined" error.

It’s important to understand why they exist. One of the best ways to master scope is to simulate how the computer manages memory (RAM) and allocates space for your variables and functions.

Now, let's dive into scope of Go and see how the computer handles each of them.

The Pillars of Scope in Go

Go classifies scope into a few main categories: global scope, local (or block) scope, and package scope. Understanding how these layers interact and which one takes priority is crucial for writing bug-free Go programs.

Global Scope:

When your program starts running, the Go runtime allocates a dedicated portion of memory (RAM) known as the global scope. Any variable or function declared outside of any function (that is, at the package level) is placed in this space.

package main

import "fmt"

// Global variables A and B
var A = 20 
var B = 30 

func add(x int, y int) {
    // ...
}

func main() {
    // ...
}

In this code, A and B are declared in the global scope. During program startup, Go stores A = 20 and B = 30 in global memory. It also registers references to the add function and the main function at the global level.

Search Priority from: The global scope serves as the final fallback. If the compiler can't find a variable or function in the current local scope (or any enclosing local scopes), it then checks the global scope. If it finds the name there, the code compiles successfully. Otherwise, you'll get an undefined error.

Local Scope and Blocks:

Local scope is created whenever a function (or another block) is executed. Each time you call a function, Go allocates a fresh block of memory for that function’s variables, often on the call stack. A block in Go is defined by opening and closing curly braces {}. Each function, as well as conditional (if/else), loop, or switch block, creates a new local scope.

Consider this example:

func main() {
    // Local to main's scope
    X := 18 

    if X >= 18 {
        // Local to the IF block (a nested scope)
        P := 10 
        fmt.Println("I have", P, "points") // Output: 10
    }

    // P is out of scope here!
    // fmt.Println(P) // Uncommenting this will cause a compile error: undefined P
}

In this snippet, X is a local variable in main's scope. When the if condition is true, Go creates a new, nested scope for the if block, and P is a local variable in that inner scope. As soon as the if block completes, Go clears the memory for P. If you try to use P outside that block, the compiler will say it's undefined because P no longer exists in any active scope.

The Crucial Scope Resolution Sequence

Whenever your code needs to look up a name (variable or function), Go follows this sequence: 1->2->3;

Current Block/Function Scope: Check the innermost local scope first.
Enclosing/Parent Scopes: If not found, look in any outer local scopes (for example, the enclosing function's scope).
Global Scope: Finally, check the global (package-level) scope.

If the name isn't found by the time you reach the global scope, the compiler will give an error.

Real-World Scope Failure Example: If you declare a variable Z inside a function add(), it only lives in the local scope of add().

Trying to use Z in main() will fail with undefined: Z, because Z was never in scope in main().

Package Scope: Cross-File Accessibility

Package scope governs how code is visible across different files and packages.

Multiple Files in the Same Package

If you have multiple Go files in the same package (for example, main.go and add.go both with package main), you need to compile or run them together. For example:

go run main.go add.go

If you run only main.go by itself, Go won’t see the contents of add.go. Any functions or variables declared in add.go would be "undefined" in that case. Running both files together ensures all package-level declarations are included.

Importing from a Custom Package

When using separate packages (for example, you create your own package math_library), Go enforces that only identifiers starting with an uppercase letter are exported. For instance:

// Inside math_library/math.go
package math_library

// Exported: accessible from other packages
func Add(x int, y int) int {
    return x + y
}

// Not exported: starts with a lowercase letter
var money = 100

After doing go mod init example.com for this module, you might use math_library from main.go like this:

package main

import (
    "fmt"
    "example.com/math_library"
)

func main() {
    result := math_library.Add(4, 7) // Works, since Add is exported
    fmt.Println(result)              // Output: 11

    // fmt.Println(math_library.money) // Error: money is unexported (undefined outside math_library--// Not exported: starts with a lowercase letter)
}

This ensures that only the parts of your code you intend to share are visible to other packages.

Variable Shadowing:

A common pitfall in Go is variable shadowing, which occurs when an inner scope declares a variable with the same name as one in an outer scope. The inner declaration "shadows" the outer one within its block.

package main

import "fmt"

var A = 10 // Global A

func main() {
    age := 30 

    if age > 18 {
        // This A shadows the global A inside this if-block
        A := 47 
        fmt.Println(A) // Output 1: 47 (prints the inner A)****After printing it will disappear then or end of it's scope tasks.****
    }

    fmt.Println(A) // Output 2: 10 (prints the global A)
}

Shadowing Example

In the code above:

Globally, A is set to 10.
When the if block executes, a new local scope is created. Inside this block, A is redeclared and set to 47.
The fmt.Println(A) inside the block finds the inner A (47) first, so it prints 47.
When the block finishes, the inner A (47) goes out of scope and is removed.
The next fmt.Println(A) (outside the block) now only sees the global A, which is still 10, so it prints 10.

The inner A temporarily takes precedence, but only within the if block.

Conclusion: Master Simulation, Master Go

Scope is not just an abstract idea—it's a direct reflection of how memory is allocated and cleaned up in your program. By mastering scope, you gain insight into your program’s inner workings. Instead of rote learning, focus on simulating execution flow and memory allocation. Visualize exactly when each variable is created and when it goes out of scope. As you write more Go code, keep imagining those memory blocks for your variables. The clearer your mental model, the fewer surprises (like "undefined" errors) you'll encounter.

Start simulating today—your future self (and your future code) will thank you. Pardon me for not visualizing RAM memory allocations.
All credit goes to Habib vai.

Variables and Data Types in Go (Golang)

Saiful Islam — Sat, 04 Oct 2025 15:33:37 +0000

"Understand variables, how they live in RAM, Go’s core data types, declaration styles, reassignment rules, and constants."

When learning Go (Golang), understanding variables and data types is essential.

They form the foundation of every program — acting as the bridge between logic and memory.

In this guide, we’ll explore

The concept of variables
How memory (RAM) works with variables
Go’s primary data types
Different variable declaration methods
Reassignment rules and type immutability
Constants in Go

Let’s dive in 👇

The Concept of Variables

A variable is simply a container — a vessel, bucket, or pot (বালতি, গামলা, বাসন) used to store something.

Just like you might store coffee in a mug or rice in a dish, a program stores data in variables.

Purpose: To store and manage data — the heart of programming and computer science.
Naming: Programmers often use Var (V-A-R) as shorthand for "Variable." They also shorten other terms, like writing int instead of “Integer.”

Variables and Computer Memory

When you declare a variable, it doesn’t just exist in code — it occupies space in your computer’s RAM (memory).

Components of a Computer Relevant to Variables

Component	Function / Role
CPU (Central Processing Unit)	Executes instructions.
RAM (Random Access Memory)	Temporarily stores variables and data during program execution.
Hard Disk	Long-term data storage (not directly used for variables at runtime).

How Variables Occupy RAM

When you declare something like a := 10, Go asks the computer to allocate space for it in memory:

RAM is divided into many small storage spaces called cells.
Declaring a variable occupies one of those empty cells.
That cell is given a name (e.g., a).
The value (e.g., 10) is stored inside that cell.

So a := 10 means:

“Hey computer, take one cell in RAM, label it a, and put 10 inside it.”

Data Types (ডাটা টাইপ)

Every variable stores data — but not all data is the same type.

Go’s data types define what kind of value a variable can hold.

Table of Primary Data Types in Go

Category	Meaning / Example	Go Type	Description
Numeric	Numbers of any kind.	—	Divided into integers and floating-point types.
->Integer (পূর্ণ সংখ্যা)	Whole numbers (e.g., `10`, `-5`).	`int`, `int8`, `int16`, `int32`, `int64`, `uint`, `uint8`, etc.	Whole numbers. The suffix (8, 16, 32, 64) refers to bit size.
->Floating Point (দশমিক সংখ্যা)	Decimal numbers (e.g., `10.5`, `40.34`).	`float32`, `float64`	For numbers with decimals.
Boolean (বুলিয়ান)	True or False values.	`bool`	Can only be `true` or `false`.
String (স্ট্রিং)	Words or text.	`string`	Enclosed in double quotes, e.g., `"Hello World"`.

Note: More complex types (like arrays, slices, and structs) come later — start simple!

Declaring Variables in Go

Go offers several ways to declare variables.

Knowing one or two is enough to start coding efficiently.

A. Explicit Declaration (Type Specified)

You tell Go exactly what type the variable will hold:

var x int = 10

var → tells Go you’re declaring a variable.
x → the variable name.
int → its data type.
= 10 → the assigned value.

B. Type Inference (Let Go Decide)

Go is smart — it can infer the data type automatically based on the value.

Example 1 — Long Form

var a = 10 // Go infers: a is int

Example 2 — Short-Hand Declaration

a := 10       // infers int
pi := 3.14    // infers float64
name := "Go"  // infers string
isCool := true // infers bool

The := operator both declares and initializes a variable in one step.

Reassigning Variables

Variables are “containers,” so their contents can change.

Rules for Reassignment

You cannot use := again — that’s only for declaring.
To update, use the simple = operator.

a := 100
a = 50 // ✅ OK (reassignment)

If you try this:

a := 100
a := 50 // ❌ Error: no new variables on left side

Go will complain — you’re redeclaring instead of reassigning.

Type Immutability

Once a variable is assigned a type, it cannot hold a value of a different type.

flag := true
flag = false   // ✅ OK
flag = "saifulire" // ❌ Error: cannot assign string to bool

Variables in Go are “loyalenough_haha;)” — they stick to their original type.

Constants

A constant (const) holds a value that never changes — like a permanent variable.

const Pi = 3.1416

Declared using const.
Cannot be reassigned — doing so triggers a compiler error:

const P = 100
P = 200 // ❌ Error: cannot assign to P

Constants are great for fixed values like configuration keys, mathematical constants, or version numbers.

Conclusion

Variables are at the core of Go programming — they link your logic to memory.
They occupy RAM cells and store data with a defined type.
Go offers smart type inference and multiple declaration styles.
Variable types are fixed after declaration, ensuring type safety.
Use constants for unchangeable values.

All credit goes to @-> Habib vai.

vectors a smart dynamic array

Saiful Islam — Sun, 28 Sep 2025 04:33:09 +0000

Saiful Islam

Sep 28 '25

Vectors in C++: The Smart Dynamic Array

#programming #performance

4 min read

Vectors in C++: The Smart Dynamic Array

Saiful Islam — Sun, 28 Sep 2025 04:20:52 +0000

When coding in C++, one of the most common data structures you’ll encounter is the vector.

It behaves like an array but with runtime flexibility — it can grow or shrink dynamically, making it one of the most powerful tools in the Standard Template Library (STL).

In this guide we’ll cover:

Vectors and STL basics
Initialization methods
Common functions and operations
Static vs dynamic allocation
Array vs vector differences
How vectors manage memory
Iterators
2D vectors
Performance considerations
Comparison with other containers
Automatic memory cleanup

STL and Vectors

The Standard Template Library (STL) provides ready-made containers and algorithms. Some commonly used containers:

vector → Dynamic array
queue → FIFO
stack → LIFO
set → Unique, ordered elements

👉 Compilation note: always use at least C++11:

g++ -std=c++11 code.cpp -o runfile && ./runfile

If you forget -std=c++11, you may run into compile errors or unexpected runtime issues.

Vector Initialization

Different ways to initialize std::vector:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // Direct initialization (C++11)
    vector<int> v1 = {1, 2, 3};

    // Fill constructor (size, initial_value)
    vector<int> v2(3, 0); // [0, 0, 0]

    // Empty then push_back
    vector<int> v3;
    v3.push_back(10);
    v3.push_back(20);

    // Printing using range-for loop
    for (int x : v1) cout << x << " ";
    cout << endl;
}

Output:

1 2 3

Vector Functions & Operations

Common vector operations:

Insertion / Removal
- push_back(x) → add at end
- pop_back() → remove last element
Access
- v[i] → element by index (no bounds check)
- v.at(i) → bounds-checked access (throws out_of_range)
- front() / back()
Information
- size() → number of elements
- capacity() → allocated memory size
- empty() → check if empty

Example:

vector<int> v = {10, 20, 30};
v.push_back(40);  // [10,20,30,40]
v.pop_back();     // [10,20,30]

cout << v.front() << endl;    // 10
cout << v.back() << endl;     // 30
cout << v.at(1) << endl;      // 20
cout << v.size() << endl;     // 3
cout << v.capacity() << endl; // capacity >= 3

Static vs Dynamic Memory Allocation

Static arrays

int arr[5]; // size fixed at compile-time

Usually stored on the stack
Size rigid, cannot grow

Dynamic arrays (manual)

int* arr = new int[5];
delete[] arr;

Stored on the heap
Requires manual memory management

Vectors use dynamic memory under the hood but manage it automatically, making them safer and more flexible than raw dynamic arrays.

Array vs Vector — Key Differences

Feature	Array (Static)	Vector (Dynamic)
Size	Fixed at compile-time	Can grow/shrink at runtime
Memory location	Stack (usually)	Heap (managed internally)
Memory management	Manual (if dynamic)	Automatic
Functions available	None (raw access only)	Rich API: `push_back`, `at`, `size`...
Initialization	Limited forms	Flexible constructors
Safety	No bounds checking	`at()` provides bounds-checked access

How Vectors Work in Memory

vector maintains two core concepts:

size → number of stored elements
capacity → allocated storage space (may be >= size)

When capacity is exceeded, implementations typically grow the capacity (commonly by doubling), which amortizes insertion costs.

Example:

vector<int> v;
for (int i = 0; i < 10; i++) {
    v.push_back(i);
    cout << "Size: " << v.size()
         << " Capacity: " << v.capacity() << endl;
}

Typical output (implementation-dependent):

Size: 1 Capacity: 1
Size: 2 Capacity: 2
Size: 3 Capacity: 4
Size: 5 Capacity: 8
Size: 9 Capacity: 16

Use reserve(n) to pre-allocate memory if you know the expected size — this avoids repeated reallocations.

Iterators

Iterators behave like pointers and are used to traverse containers:

vector<int> v = {10,20,30,40};

// Forward
for (auto it = v.begin(); it != v.end(); ++it) cout << *it << " ";

// Reverse
for (auto it = v.rbegin(); it != v.rend(); ++it) cout << *it << " ";

Output:

10 20 30 40
40 30 20 10

Iterators are the common way to use STL algorithms like std::sort, std::find, etc.

2D Vectors

Nested vectors are useful for matrices, graphs, and dynamic 2D storage:

vector<vector<int>> matrix(3, vector<int>(3, 0));
matrix[0][1] = 5;
matrix[2][2] = 7;

for (auto& row : matrix) {
    for (auto val : row) cout << val << " ";
    cout << endl;
}

Output:

0 5 0
0 0 0
0 0 7

Performance Tips

size() is O(1). Use it freely.
capacity() shows reserved memory; use reserve(n) when you know the expected size.
Avoid excessive copying — prefer emplace_back() to construct in-place.
Random access is O(1); inserting/removing at the middle is O(n).
For frequent front insertions, consider deque; for frequent middle insert/delete, consider list (but lists have poor cache locality).

Vector vs Other Containers

Vector → best for random access, fast end insertions.
Deque → fast insertions at both ends.
List → fast middle insertions/deletions (no random access).
Set → unique, ordered elements (logarithmic operations).

👉 Default choice: vector unless you have a specific reason to choose another container.

Automatic Memory Cleanup

Vectors free their managed memory automatically when they go out of scope:

void func() {
    vector<int> v(1000, 1);
} // memory is released when the function returns

✅ Conclusion

std::vector is array-like but flexible, safe (with at()), and efficient for most general-purpose needs. Prefer vectors over raw arrays unless you need a fixed-size, stack-allocated buffer or have very specific performance constraints.

DEV Community: Saiful Islam

SDLC-2

সফটওয়্যার ডেপ্লয়মেন্ট: লোকাল মেশিন থেকে লাইভ সার্ভার পর্যন্ত

একটি সম্পূর্ণ বাংলা গাইড

সূচিপত্র

অধ্যায় ১: ভূমিকা — আমরা কী শিখব এবং কেন?

অধ্যায় ২: ডেপ্লয়মেন্ট কী? — মূল ধারণা

ডেপ্লয়মেন্টে কী কী শেখা যায়?

অধ্যায় ৩: তিনটি মেশিনের পরিবেশ

মেশিন ১: আপনার লোকাল মেশিন (Development Environment)

মেশিন ২: গিটহাব সার্ভার (Code Repository)

মেশিন ৩: ক্লাউড ডেপ্লয়মেন্ট সার্ভার (Production Server)

কেন আলাদা মেশিন দরকার?

অধ্যায় ৪: পোর্ট — দুই কম্পিউটারের কথোপকথনের দরজা

গুরুত্বপূর্ণ পোর্ট নম্বরগুলো:

পোর্ট 80 এবং 443 কীভাবে কাজ করে?

পোর্ট 22 কেন বিশেষ?

অধ্যায় ৫: গিট ও গিটহাব — কোডের গুগল ড্রাইভ

গিট (Git) কী?

গিটহাব (GitHub) কী?

মূল গিট কমান্ডগুলো:

গিটহাবে রিপোজিটরি তৈরি করা:

লোকাল প্রজেক্টকে গিটহাবে লিংক করা:

অধ্যায় ৬: ক্লাউড সার্ভার — আপনার অনলাইন কম্পিউটার

ক্লাউড সার্ভার এবং সাধারণ ল্যাপটপের পার্থক্য:

জনপ্রিয় ক্লাউড সার্ভার প্রোভাইডার:

ক্লাউড সার্ভারের অপারেটিং সিস্টেম:

অধ্যায় ৭: SSH Key — ডিজিটাল চাবির সিস্টেম

SSH Key কী?

কেন পাসওয়ার্ডের বদলে SSH Key?

SSH Key কীভাবে তৈরি করবেন?

তৈরি হওয়া Key ফাইলগুলো কোথায় থাকে?

Public Key কেমন দেখায়?

একাধিক Key তৈরি করা কি যায়?

অধ্যায় ৮: DigitalOcean থেকে সার্ভার কেনা (ধাপে ধাপে)

ধাপ ১: একাউন্ট তৈরি ও লগইন

ধাপ ২: Droplets মেনু খুলুন

ধাপ ৩: "Create Droplet" বাটনে ক্লিক করুন

ধাপ ৪: Region (অবস্থান) বেছে নিন

ধাপ ৫: Operating System বেছে নিন

ধাপ ৬: Plan (দাম) বেছে নিন

ধাপ ৭: Authentication Method বেছে নিন

ধাপ ৮: সার্ভারের নাম দিন

ধাপ ৯: "Create Droplet" ক্লিক করুন

অধ্যায় ৯: লোকাল মেশিন থেকে সার্ভারে SSH সংযোগ

SSH কানেক্ট করার কমান্ড:

প্রথমবার সংযোগে কী হবে?

সফল সংযোগের চিহ্ন:

সার্ভার থেকে বেরিয়ে আসা:

অধ্যায় ১০: গিট ইনস্টল ও সার্ভারে গিটহাব সেটআপ

সার্ভারে গিট ইনস্টল করা:

সার্ভারে গিটহাব কনফিগার করা:

গিটহাব রিপো ক্লোন করা:

অধ্যায় ১১: GitHub Actions — স্বয়ংক্রিয় ডেপ্লয়মেন্ট পাইপলাইন

GitHub Actions কী?

GitHub Actions-এর মূল উপাদান:

GitHub Runner কী?

Events (ঘটনা) কী কী হতে পারে?

অধ্যায় ১২: YAML ওয়ার্কফ্লো ফাইল — পাইপলাইনের হৃদয়

YAML ফাইল কোথায় রাখতে হয়?

সহজ পরীক্ষামূলক Workflow:

Workflow চলছে কিনা দেখবেন কীভাবে?

সার্ভারে ডেপ্লয় করার Workflow:

অধ্যায় ১৩: Secrets ও Environment Variables — গোপন তথ্য সুরক্ষা

GitHub Secrets কীভাবে সেট করবেন?

Private Key কপি করবেন কীভাবে?

কোন Key সার্ভারে রাখা থাকবে?

Secrets কেন আলাদা Key ব্যবহার করা উচিত?

অধ্যায় ১৪: PM2 — Node.js সার্ভার ব্যাকগ্রাউন্ডে চালানো

সমস্যাটা কী?

সমাধান: PM2

PM2 ইনস্টল করা:

PM2 দিয়ে অ্যাপ চালু করা:

সার্ভার রিবুটের পরেও PM2 চালু রাখা:

PM2 vs নিজে চালানো:

অধ্যায় ১৫: সম্পূর্ণ ওয়ার্কফ্লো — শুরু থেকে শেষ পর্যন্ত

একবার সেটআপের কাজ (শুধু প্রথমবার):

প্রতিদিনের কাজের ওয়ার্কফ্লো (সেটআপের পরে):

সবুজ চেকমার্ক মানে কী?

লাল ক্রস মানে কী?