🌐 Golang Community Vault

Welcome to Golang Community Archive, a community-driven digital archive designed to collect, organize, and preserve the vast knowledge, resources, and experiences from the Go programming ecosystem and beyond. Whether you're a beginner, job seeker, seasoned contributor, or mentor — this is the place where we give and receive knowledge.

🎯 Project Purpose

The Golang Community Vault is not just an archive, it's a vibrant, evolving repository that serves:

• 📚 Preservation of valuable community-generated content.
• 🤝 Collaboration to promote open knowledge sharing and growth.
• 🔎 Job Seekers & Learners can gain insights from real-world experiences.
• 🧠 Centralized Resources to gather knowledge and tools scattered across the web.

💬 Stay Connected & Grow With Us!

We believe in community-driven learning. Whether you're here to contribute, collaborate, or just explore — your presence makes a difference. 💛

Join the Best Golang Community Ever and become part of something bigger than just code!

🌐 Connect With Us

🤝 Get Involved

✅ Share your stories, notes, code, or insights
✅ Help with templates, docs, automation, or structure
✅ Collaborate on our static site or web vault
✅ Be part of building something that helps thousands

✨ Together, We Learn & Grow

“Code fades. Community lasts.”
Let’s archive knowledge, share what we’ve learned, and help the next generation of Gophers grow. 🐹🚀

📂 Archive Categories

Here's a quick look at the structure of the archive, where each folder represents a key area of Golang knowledge, experience, and resources.

golang-community-vault/
├── 1-interview-qa/         # Real interview Q&A and topic-wise challenges
│   ├── company-wise/       # Interview questions by company (Google, etc.)
│   ├── topic-wise/         # Go concepts (goroutines, interfaces, etc.)
│   └── curated-challenges/ # Problem-solving & deep dives
├── 2-class-notes/          # Course notes & summaries
│   ├── university-notes/   # Academic notes from CS/SE courses
│   ├── bootcamp-notes/     # Bootcamp summaries
│   └── online-course-summaries/ # Udemy, Coursera, etc.
├── 3-project-archive/      # Real-world Golang projects
│   ├── cli-tools/          # Command-line Go utilities
│   ├── web-servers/        # REST/HTTP server projects
│   ├── microservices/      # Auth, DB, API services
│   └── misc-projects/      # Other cool stuff
├── 4-image-infographic-archive/ # Visual aids like diagrams, cheat sheets
│   ├── architecture-diagrams/
│   ├── cheat-sheets/
│   └── flowcharts/
├── 5-community-stories/    # Real experiences, job search, career switch
│   ├── job-search-experience/
│   ├── rejection-learnings/
│   └── career-switch-tales/
├── 6-package-archive/     # Community-built Go libraries and tools
│   ├── utils/
│   ├── api-clients/
│   ├── middleware/
│   └── tools-and-libs/
├── 7-community-blogs/     # Written insights from the community
│   ├── how-tos/
│   ├── internals/
│   ├── opinion-pieces/
│   └── tutorials/
├── 8-news-events/         # Updates from the Go world
│   ├── newsletters/
│   ├── conference-recaps/
│   ├── meetup-summaries/
│   └── hackathons/
├── 9-video-archive/       # Curated video learning
│   ├── tutorials/
│   ├── tech-talks/
│   ├── documentaries/
│   └── playlists/
├── 10-course-content/     # Full-length open-source Go courses
│   ├── community-courses/
│   ├── mini-moocs/
│   └── challenge-series/
├── 11-link-resource-archive/ # Curated bookmarks and links
│   ├── tooling/
│   ├── blogs/
│   ├── documentation/
│   ├── slide-decks/
│   └── benchmarks/

📁 Category Overview

comprehensive and detailed RBAC permission list Golang Community Vault platform. This will allow fine-grained control for various roles across all the directories and content types outlined in README.

🔒 Universal Permission Categories (Applicable to all modules)

🔖 Resource-Specific Permissions

Here's a breakdown by directory and subtype:

1. interview-qa/

2. class-notes/

3. project-archive/

4. image-infographic-archive/

5. community-stories/

6. package-archive/

7. community-blogs/

8. news-events/

9. video-archive/

10. course-content/

11. link-resource-archive/

✅ Bonus System Permissions

🧩 Tech Stack & Tools

This vault is powered by several modern tools and practices for collaboration, code sharing, and documentation. Feel free to explore more about our tech stack.

🌟 Inspiration & Vision

“Code fades. Community lasts.”

This archive is designed to support, uplift, and celebrate the Golang Community. It’s not just about sharing code — it’s about collecting collective knowledge, hard-won experiences, and stories that shape our journey. Whether you're new to Go or a veteran, this vault is your home.

🧩 Tech Stack (Future Web App Vision)

This vault is powered by several modern tools and practices for collaboration, code sharing, and documentation. Feel free to explore more about our tech stack:

If this turns into a community-driven web interface:

• Frontend: React / Svelte / Next.js / Vue
• Backend: Go
• Storage: GitHub + SQLite/Postgres
• Auth: GitHub OAuth (optional)
• Deployment: AWS

UI/UX ideas for the future web App

Most preferable one for now:
1. Modern Library-Style UI
   - Homepage: A clean, minimalist grid of featured archives with a search bar in the center.
   - Filters & Categories: Sidebar with quick access to categories (by year, author, tags, etc.).
   - Reading Mode: Dark/light mode toggle, distraction-free fullscreen mode.
   - Bookmarking & Notes: Users can highlight text and add personal notes to archives.

Other types of UI

2. Timeline-Based UI
3. Grid & Gallery UI
4. Terminal-Inspired UI
5. Tag-Based UI
6. Map-Based UI
7. AI-Assisted UI
8. Infinite Scroll vs. Pagination Debate

Contribution Guide

✍️ How to Contribute?

We're excited to have you contribute to the Golang Community Vault! Whether you’re adding resources, sharing your experiences, or helping to maintain content — you are adding to the growth and strength of our community.

🚀 Types of Contributions

We welcome a wide range of contributions! Here’s how you can help:

• Knowledge Sharing
  Contribute articles, tutorials, or reference material that can help others learn and grow.

• Real-world Experiences
  Share your job search stories, career-switch insights, rejection learnings, or any other experiences that can inspire and educate others.

• Code & Projects
  Upload your open-source Golang projects, libraries, tools, or code snippets that can benefit the community.

• Learning Resources
  Contribute notes, video tutorials, course summaries, or any other educational content to help others learn Golang.

📚 Contributor’s Guides

• For Non-Tech Contributions
  No coding required! Learn how you can help with documentation, resources, and content.
  🔗 Contributor’s Guide (No-Code)

• For Code Contributions
  If you want to contribute code or projects, follow our code contribution guidelines.
  🔗 Contributor’s Guide (Code)

📌 COMMIT STRATEGY

🔧 Setup

make setup-commit-hook

✅ Commit Message Format

[<service>] (<type/feature-name>): <Capitalized short description>

💡 Allowed Types

• feat – New feature or functionality
• fix – Bug fix or issue correction
• patch – Minor updates or hotfixes
• docs – Documentation changes
• style – Code style changes (formatting, linting)
• refactor – Code restructuring without behavior change
• test – Adding or updating tests
• chore – Build tasks, CI configs, or other maintenance

🧪 Example Commits

[inventory] (feat/add-product): Add product listing endpoint
[auth] (fix/token-expiry): Correct token expiry issue
[payment] (patch/update-paypal): Update PayPal integration
[docs] (docs/readme): Update CLI tool usage instructions

✅ Notes for contributors:

• Service: Use the relevant service or package name in square brackets.
• Type/feature-name: Specify the type and concise feature name in parentheses.
• Description: Must start with an uppercase letter and clearly state the change.

🧩 CONTRIBUTION TEMPLATES FOR GOLANG COMMUNITY VAULT

Welcome to the Golang Community Vault!

We’re excited to have your contributions. Here's how you can help:

📌 Guidelines:

• Fork the repo and create a new branch (name it feat/<title> or fix/<title>).
• Add your Markdown files to the appropriate subfolder.
• Follow our [README] For Complete Documentation.
• Ensure links are working and code is properly formatted.
• Commit strategy using our COMMIT STRATEGY.
• Submit a pull request using our PULL REQUEST Template.

📂 Folder Naming Convention:

• All folders must use kebab-case.
• Use README.md inside folders for summaries.

📝 Markdown File Template

# [Title]

**Author:** @yourhandle
**Date:** YYYY-MM-DD
**Category:** e.g., interview-qa/topic-wise
**Tags:** [go, concurrency, channels]

---

## 🧠 Summary

_Brief explanation of the content._

## 🧩 Content

### Overview

### Key Concepts

### Code

```go
// Example snippet\`
```

📚 Resources

• Link1

## ✅ Contribution Rules

-   Must include summary, author, and tags
-   Format code blocks
-   External links must be verified

## 🔗 Links

-   [Templates](../templates)
-   [Static Site Preview](../site)

💡 Non-Tech Contributions (No code required!)

You can still make a huge impact without writing any code. Here’s how:

• Content Contributions
  Add value by submitting resources, notes, blog posts, or guides. You don’t need to write code to make a meaningful contribution!

• Community Engagement
  Help grow the knowledge base by engaging with others. Review content, offer suggestions, and be a part of discussions that improve the Vault.

We accept many types of contributions:

• 🧠 Interview Content – Real-world Q&A, curated challenges, topic-wise notes.
• 📚 Class Notes – University, bootcamp, or online course summaries.
• 🖼️ Visual Resources – Architecture diagrams, cheat sheets, flowcharts.
• 📖 Blog Posts – How-tos, opinion pieces, technical deep-dives.
• 🎬 Videos – Tech talks, tutorials, playlists, or webinars.
• 📖 Personal Stories – Career transitions, rejections, job search journeys.
• 🔗 Curated Links – Tools, docs, slide decks, benchmarks.

✅ PULL REQUEST TEMPLATE

### 📘 Description

What this PR adds/fixes/improves.

### 📂 Related Issue

Closes #[issue-number]

### 🚀 Changes Made

- Added/Updated [category/file-name.md]
- Fixed formatting/link issues

### ✅ Checklist

- [ ] Follows contribution guidelines
- [ ] Uses correct Markdown format
- [ ] Tested rendering in preview

📘 BGCE Translation Guide (Simple & Clear Bangla Style)

This is how we’ll translate stuff for the BGCE book to make sure it's beginner-friendly, chill, and clear for Bengali devs. To ensure consistency, clarity, and accessibility, follow these guidelines while translating technical content to Bengali for the BGCE book:

Retain English for Key Technical Terms

• Always use English for programming keywords, tools, and common dev jargon.

• Examples:

  • ✅ code (❌ কোড)

  • ✅ closure (❌ ক্লোজার)

  • ✅ visualization (❌ ভিজ্যুয়ালাইজেশন)

⚠️ Use discretion — if the English term is very commonly used in Bengali dev circles, retain it.

Prefer Natural Language Over Literal Translation

• Avoid overly formal or uncommon Bengali words.

• Translate meaning, not word-for-word.

• Example:

  • ❌ "স্ট্যাক বনাম হিপ"

  • ✅ "Stack vs Heap" or "স্ট্যাক vs হিপ"

CLI and Code Blocks Must Stay in English

• Never translate code snippets, terminal commands, or code block outputs.

• Example:

  • ❌ git push → গিট পুশ

  • ✅ Leave git push as-is.

Don’t translate word-for-word, make it feel natural

• Say it the way you'd explain to a friend.

• Example:

  • English:

  "If a variable is used outside a function (like in a returned closure), it moves to the heap."

  • ✅ Good Bangla:

  “যদি কোনো ভেরিয়েবল ফাংশনের বাইরে ইউজ হয় (যেমন রিটার্ন করা কোনো ক্লোজার-এর ভিতরে), তখন সেটা হিপে চলে যায়।”

  • ❌ Bad Bangla:

  “যদি কোনো ভেরিয়েবল ফাংশনের বাইরে (যেমন একটি রিটার্ন হওয়া ক্লোজারে) ব্যবহৃত হয়, তবে সেটি হিপে স্থানান্তরিত হয়।”

Add extra words if needed cause clarity > literal

• Sometimes adding 2–3 extra words makes things way easier to understand. Do that.

• Example:

  • English: "Stack and Heap"

  • Bangla: “স্ট্যাক আর হিপ কীভাবে কাজ করে”

Small add-ons = big clarity

No bookish or rare Bengali words

• Don’t use words people don’t even hear in movies or the street.

• Instead, use how devs actually talk.

UI terms, buttons, tool names - keep original English

• Example:

  • ✅ "Click the Run button" → keep Run in English

Markdown formatting stays same

• Don’t break bullet points, code formatting, bold text, etc.

🎯 Goal: বাংলা হবে এমন, যেটা একজন নতুন ডেভেলপার পড়ে হাসে না বরং বুঝে। Simple, clear, and helpful. No extra drama.

Mehraz Obaydullah

Microservice Documentation Template for each category, following a Domain-Driven Design (DDD) approach for your golang-community-vault project:

# 📘 Microservice - 1-interview-qa

## 📌 Domain Context

This microservice belongs to the **Interview Q&A Domain**, responsible for organizing and serving real-world interview questions and structured problem-solving content. It reflects bounded contexts like company-specific Q&A, topic-wise Go concepts, and curated deep dives.

## 🧩 Subdomains

-   `company-wise/` - Q&A by hiring companies (Google, Meta, etc.)
-   `topic-wise/` - Q&A by technical concept (e.g., Goroutines, Channels)
-   `curated-challenges/` - Problem-solving sets with expected patterns

## 🧪 Core Capabilities

-   Serve categorized Markdown-based content for interviews
-   Support contributor-submitted Q&A in structured format
-   Enable easy search/navigation via tags and metadata

## 🏗️ Expected Structure - Coming Soon

## 🔄 Input/Output Contract

### Input
- Markdown files via pull requests
- Validated metadata in frontmatter (e.g., tags, difficulty, author)

### Output
- Rendered HTML pages for Docusaurus
- Searchable metadata (for filtering/search)

## ⚙️ Internal Models

```go
type InterviewQuestion struct {
    Title       string   `json:"title"`
    Company     string   `json:"company,omitempty"`
    Topics      []string `json:"topics"`
    Difficulty  string   `json:"difficulty"` // easy | medium | hard
    Author      string   `json:"author"`
    Content     string   `json:"content"` // Markdown
}

🛠 Maintainers

📂 Directory Ownership

This service owns:

• interview-qa/**

📚 References

• Markdown contribution templates
• Content schema definition
• RBAC permissions

🐹 Golang Playground

Welcome to my Golang knowledge hub — a growing collection of experiments, course notes, and practical learnings as I dive deeper into Go 🚀

📂 Structure (will be updated in future)

golang/ 
    ├── experiment/
    └── go-with-habib-class-notes/

🔬 experiment/

A sandbox for all my Go experiments. From testing features to quick problem-solving attempts, this folder is all about learning by doing.

📘 go-with-habib-class-notes/

Detailed notes and example code from the "Go with Habib" course. Organized by class, with code and key takeaways.

📌 What's Next?

• Add more Go mini-projects and tools under experiment/
• Continue documenting the Habib course in markdown
• Add README.md for each class and experiment
• Eventually turn this entire golang/ folder into part of the bytebook mdBook

[Author: @ifrunruhin12 Date: 2025-05-01 Category: interview-qa/class-wise ]

Class 07: Hello, World!

📄 কোড:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

🔍 ব্যাখ্যা:

✅ package main

• Go-তে প্রতিটি প্রোগ্রাম একটি প্যাকেজের অংশ।
• main প্যাকেজ মানে এটি একটি executable program এটি চালানো যাবে।
• যদি main না দাও, তাহলে Go বুঝবে এটা লাইব্রেরি।

✅ import "fmt"

• fmt Go এর স্ট্যান্ডার্ড প্যাকেজ, যেটা input/output এর কাজ করে।
• এখানে আমরা fmt.Println ব্যবহার করেছি স্ক্রিনে কিছু প্রিন্ট করতে।

✅ func main() { ... }

• main() ফাংশন হলো Go প্রোগ্রামের entry point।
• প্রোগ্রাম চালালে প্রথমেই এই ফাংশনটি রান হয়।

✅ fmt.Println("Hello, World!")

• এটি Go এর স্ট্যান্ডার্ড ফাংশন যা স্ক্রিনে "Hello, World!" প্রিন্ট করে।
• Println মানে print line এটি নতুন লাইনে প্রিন্ট করে।

🧠 মনে রাখার মতো কিছু বিষয়:

🚀 রান করার নিয়ম (Go ইনস্টল থাকার পর):

go run (file name).go

Extra :

• Go একটি compiled language, যার মানে হলো কোড compile হয়ে এক্সিকিউটেবল ফাইল তৈরি করে।

• Go এর compiler খুব দ্রুত এবং lightweight।

• Go concurrency-friendly, অর্থাৎ একই সাথে অনেক কাজ (goroutines) সহজে হ্যান্ডেল করতে পারে।

• Go এ garbage collection থাকে, যা অপ্রয়োজনীয় মেমোরি নিজে থেকে ম্যানেজ করে।

• Go এর syntax খুব সহজ এবং readable, যা নতুনদের জন্য শেখা সহজ করে তোলে।

[Author : @shahriar-em0n Date: 2025-06-09 Category: interview-qa/class-wise ]

Class 08: Variables and Data Types

Go একটি strongly typed এবং statically typed compiled language, যার ফলে প্রতিটি ভ্যারিয়েবলের টাইপ স্পষ্টভাবে নির্ধারিত এবং গুরুত্বপূর্ণ

🧠 Variable Declare করার নিয়ম

Go তে ভেরিয়েবল declare করার তিনটি পদ্ধতি আছে:

1. Short Variable Declaration (: =)

Short declaration (:=) শুধুমাত্র ফাংশনের ভেতরে ব্যবহার করা যায়:

func main() {
    a := 10
}

• টাইপ উল্লেখ করতে হয় না, Go নিজে থেকে টাইপ নির্ধারণ করে নেয় (Type Inference)৷

2. Explicit Type Declaration

var x int = 10

• এখানে x explicitly int টাইপের বলে দেওয়া হয়েছে।

3. Implicit Type Declaration

var a = 10

• টাইপ উল্লেখ করা হয়নি, তবে a এর টাইপ int হিসাবে নির্ধারিত হবে ১০ দেখে।

📘 Data Types

Go ভাষায় বিভিন্ন ধরনের ডেটা টাইপ আছে, যেগুলো মূলত 3 টি ভাগে ভাগ করা যায়।

১. Numeric Types

Go-তে numeric types মূলত তিনটি ভাগে বিভক্ত থাকে।

Integer Types

Floating Point Types

Complex Types

২. String Type

• Represents text.

var message string = "Hello, Go!"

৩. Boolean Type

• Holds either true or false.

var isGoFun bool = true

✅ Summary Table

✅ Valid Examples with Different Data Types

a := 10           // int
a := 40.34        // float64
a := "Hello"      // string
a := true         // bool
a = false         // bool (reassigned)

⚠️ Note: একই স্কোপে একই ভেরিয়েবলকে বারবার := দিয়ে declare করা যাবে না।

🔒 Constant Declaration

const p = 100

const দিয়ে declare করা ভেরিয়েবল পরিবর্তন করা যাবে না।

[Author : @shahriar-em0n Date: 2025-06-09 Category: interview-qa/class-wise ]

Class 09 : If else and switch

Go তে কন্ডিশনাল স্টেটমেন্ট ব্যবহৃত হয় সিদ্ধান্ত নেওয়ার জন্য। নিচে if, else if, else, এবং switch এর বিস্তারিত ব্যাখ্যা এবং উদাহরণ দেওয়া হলো।

✅ if Statement

package main
import "fmt"

func main() {
    number := 10
    if number > 5 {
        fmt.Println("Number is greater than 5")
    }
}

যদি if এর স্টেটমেন্ট সত্য হয়, তবে ব্লকের ভিতরের কোড এক্সিকিউট হবে।

✅ if-else Statement

package main
import "fmt"

func main() {
    number1 := 3
    if number1 > 5 {
        fmt.Println("Greater than 5")
    } else {
        fmt.Println("5 or less")
    }
}

যদি if এর স্টেটমেন্ট মিথ্যা হয়, তাহলে else ব্লকের কোড এক্সিকিউট হবে |

✅ if,else if, else Statement

package main
import "fmt"

func main() {
    package main
import "fmt"

func main() {
    age := 18 // বয়স ১৮ সেট করা হয়েছে

    if age > 18 {
        // যদি বয়স ১৮ এর বেশি হয়, তাহলে নিচের মেসেজ দেখা যাবে
        fmt.Println("You are eligible to be married") // প্রাপ্তবয়স্ক, বিয়ের জন্য উপযুক্ত
    } else if age < 18 {
        // যদি বয়স ১৮ এর কম হয়, তাহলে এই অংশ এক্সিকিউট হবে 
        fmt.Println("You are not eligible to be married, but you can love someone") // নাবালক, প্রেম করা যেতে পারে
    } else if age == 18 {
        // যদি বয়স একদম ১৮ হয়, তাহলে এই অংশ এক্সিকিউট হবে
        fmt.Println("You are just a teenager, not eligible to be married") // টিনএজার, বিয়ের জন্য ঠিক উপযুক্ত না
    }
}

}

একাধিক স্টেটমেন্ট চেক করার জন্য else if ব্যবহার করা হয় | উপরের কোডে বয়স অনুসারে তিনটি ভিন্ন রেসপন্স দেখানো হয়েছে।

🔁 switch Statement

package main
import "fmt"

func main() {
    day := 3 // day ভ্যারিয়েবলটি ৩ দেওয়া হয়েছে

    switch day {
    case 1:
        fmt.Println("Sunday") // যদি day == 1 হয়, তাহলে Sunday প্রিন্ট হবে
    case 2:
        fmt.Println("Monday") // যদি day == 2 হয়, তাহলে Monday প্রিন্ট হবে
    case 3:
        fmt.Println("Tuesday") // যদি day == 3 হয়, তাহলে Tuesday প্রিন্ট হবে
    default:
        fmt.Println("Another day") // যদি কোন case না মিলে , তাহলে default অংশে চলে যাবে 
    }
}

switch স্টেটমেন্ট অনেকগুলো if-else if কে রিপ্লেস করতে পারে এবং কোডকে cleaner করে তোলে। এটি একটি নির্দিষ্ট ভ্যালুর উপর ভিত্তি করে বিভিন্ন আউটপুট দেয়।

⚠️ Note:

• Go তে if এবং switch ব্লকে ব্র্যাকেট {} আবশ্যক।
• switch ব্লকে প্রতিটি case এর পরে break লিখতে হয় না, কারণ Go নিজেই implicity break করে দেয়, যদি না fallthrough ব্যবহার করা হবে |

[Author : @shahriar-em0n Date: 2025-06-11 Category: interview-qa/class-wise ]

Class 10 : Introduction to Functions

🔍 Function কী?

Function (ফাংশন) হল কোডের একটি পুনঃব্যবহারযোগ্য ব্লক যা নির্দিষ্ট একটি কাজ করে।
যখন আমাদের একই কোড বারবার লেখা লাগে, তখন আমরা সেটাকে একটা ফাংশনের মধ্যে রেখে দিই।
এতে করে কোড clean হয়, readable হয় এবং বারবার ব্যবহার করা যায়।

🧠 Function কেন ব্যবহার করি?

• ✅ Reusability (একই কোড বারবার ব্যবহার করা যায়)
• ✅ Readability (কোড আরও পরিষ্কার হয়)
• ✅ Maintainability (বাগ ফিক্স করা বা পরিবর্তন সহজ হয়)
• ✅ Logic কে ছোট ছোট অংশে ভাগ করে বুঝতে সুবিধা হয়

🧪 উদাহরণ: দুটি সংখ্যার যোগফল বের করা

package main

import "fmt"

// এই ফাংশনটি দুটি সংখ্যা নেয় এবং তাদের যোগফল প্রিন্ট করে
func add(num1 int, num2 int){ 
    sum := num1 + num2
    fmt.Println(sum)
}

func main() {
    a := 10
    b := 20

    add(a, b)     // Output: 30
    add(5, 7)     // Output: 12
}

ব্যাখ্যা:

• func add(num1 int, num2 int) - এটি একটি function definition, যেখানে num1 এবং num2 হল parameters।
• sum := num1 + num2 - এখানে দুই সংখ্যার যোগফল বের করা হচ্ছে।
• fmt.Println(sum) - যোগফল প্রিন্ট করা হচ্ছে।
• main() ফাংশনের মধ্যে add(a, b) ব্যবহার করে আমরা ফাংশনটি কল করেছি।

[Author : @shahriar-em0n Date: 2025-06-11 Category: interview-qa/class-wise ]

📘 Class 11 : Function with Return Values and Types

Go তে ফাংশনের মাধ্যমে আমরা একটি অথবা একাধিক ভ্যালু রিটার্ন করতে পারি।। ফাংশন শুধু কাজ করেই শেষ নয় আমরা চাইলে ফাংশন থেকে ফলাফলও (result) ফিরে পেতে পারি। একে বলে Return Value।

Go-তে ফাংশন থেকে দুই ধরনের রিটার্ন হতে পারে:

• ✅ Single Return Value (একটি মান ফেরত দেয়)
• ✅ Multiple Return Values (একাধিক মান ফেরত দেয়)

🔹 Single Return Value

ফাংশন যখন একটি মাত্র ফলাফল ফেরত দেয়, তখন তাকে Single Return Function বলা হয়।

✅ উদাহরণঃ

package main

import "fmt"

// একক রিটার্ন ভ্যালু সহ ফাংশন
func add(num1 int, num2 int) int {
	sum := num1 + num2
	fmt.Println("ফাংশনের ভিতরে যোগফল:", sum)
	return sum
}

func main() {
	a := 10
	b := 20

	result := add(a, b) // রিটার্ন মানটি result এ রাখছি
	fmt.Println("main ফাংশনে রিটার্ন মান:", result)
}

🔎 ব্যাখ্যাঃ

• add() ফাংশন দুটি ইনপুট নেয়: num1 এবং num2।
• এটি তাদের যোগফল sum হিসেব করে ফেরত দেয় return sum।
• main() ফাংশনে এই রিটার্ন মানটি result ভ্যারিয়েবলে রাখা হয়।

🔹 Multiple Return Values

ফাংশন যদি একাধিক ফলাফল একসাথে ফেরত দেয়, তাহলে সেটাকে Multiple Return Function বলা হয়।

✅ উদাহরণঃ

package main

import "fmt"

// একাধিক রিটার্ন ভ্যালু সহ ফাংশন
func getNumbers(num1 int, num2 int) (int, int) {
	sum := num1 + num2
	mul := num1 * num2
	return sum, mul
}

func main() {
	a := 10
	b := 20

	// দুটি রিটার্ন মান আলাদা করে নিচ্ছি
	p, q := getNumbers(a, b)
	
	fmt.Println("যোগফল =", p)
	fmt.Println("গুণফল =", q)
}

🔎 ব্যাখ্যাঃ

• getNumbers() ফাংশন দুটি ইনপুট নেয় এবং দুইটি আউটপুট দেয়: যোগফল (sum) এবং গুণফল (mul)।
• আমরা main() ফাংশনে p, q := getNumbers(a, b) ব্যবহার করে রিটার্ন মানগুলো আলাদা করে নিই।

✅ সংক্ষেপে মনে রাখুন:

Go প্রোগ্রামিং ভাষায় ফাংশন থেকে আমরা একটি বা একাধিক মান রিটার্ন করতে পারি।

ফাংশনের Return Value: Single vs Multiple

সাধারণ Return টাইপ ব্যাখ্যা

• int - পূর্ণসংখ্যা (যেমন: 5, 100)
• float64 - দশমিক সংখ্যা (যেমন: 3.14, 9.81)
• string - স্ট্রিং বা টেক্সট (যেমন: "Shahriar")
• rune - একটি ইউনিকোড ক্যারেক্টার (যেমন: 'A', 'ক')

📝 নোট: Go ফাংশনে আমরা দুইটির বেশি মানও রিটার্ন করতে পারি - যেমন ৩টি বা তার বেশি মান। তবে এই টেবিল ও উদাহরণগুলোতে আমরা শুধুমাত্র দুটি মান রিটার্নের উদাহরণ দিয়েছি, যেন বিষয়টি সহজভাবে বোঝানো যায়। প্রয়োজনে ফাংশন থেকে আরও বেশি সংখ্যক মান রিটার্ন করাও সম্ভব এবং এটি পুরোপুরি বৈধ।

এভাবে Go ফাংশন return value এর মাধ্যমে কার্যকরভাবে তথ্য ফেরত দিতে পারে, যা কোডকে modular এবং পরিষ্কার করে তোলে।

Note

Go-তে ফাংশনের মাধ্যমে কোডকে পরিষ্কার ও পুনঃব্যবহারযোগ্য করা যায়। return value ব্যবহার করে আমরা ফাংশনের কাজের ফলাফল main() ফাংশনে এনে ব্যবহার করতে পারি। একাধিক মান ফেরত দেওয়ার ক্ষমতা Go ভাষাকে আরও শক্তিশালী করে তোলে।

[Author : @shahriar-em0n Date: 2025-06-13 Category: interview-qa/class-wise ]

📘 Class 12 : More Function Examples

এখানে আরও কিছু ফাংশনের উদাহরণ দেওয়া হলো।

✅ Function 1: printSomething()

এই ফাংশনটি কোন আর্গুমেন্ট নেয় না এবং কোন রিটার্ন ভ্যালুও দেয় না। শুধুমাত্র একটি লাইন প্রিন্ট করে।

📄 Code:

func printSomething(){
    fmt.Println("Education must be free!")
}

🧠 ব্যাখ্যা:

• printSomething() ফাংশনটি কোন ইনপুট নেয় না।
• এটি fmt.Println() ফাংশনের মাধ্যমে একটি মেসেজ প্রিন্ট করে দেয়।

✅ Function 2: sayHello(name string)

এই ফাংশনটি একটি প্যারামিটার (string টাইপের name) নেয় এবং একটি স্বাগত বার্তা প্রিন্ট করে।

📄 Code:

func sayHello(name string){
    fmt.Println("Welcome to the golang course, ", name)
}

🧠 ব্যাখ্যা:

• sayHello ফাংশনটি একটি name ইনপুট নেয়, যা string টাইপের।
• এরপর fmt.Println() ব্যবহার করে সেই নামসহ একটি মেসেজ প্রিন্ট করে।

🔁 Main Function

📄 Code:

func main() {
    printSomething()
    sayHello("Shahriar")
}

🧠 ব্যাখ্যা:

• main() ফাংশন হচ্ছে Go প্রোগ্রামের এন্ট্রি পয়েন্ট।

• এখানে প্রথমে printSomething() কল করা হয়েছে, তাই এটি "Education must be free!" প্রিন্ট করবে।

• তারপর sayHello("Shahriar") কল করা হয়েছে, তাই এটি "Welcome to the golang course, Shahriar" প্রিন্ট func showPrice(price float64){

  fmt.Println("The product price is: $", price)

}করবে।

🧾 সংক্ষেপে

[Author : @shahriar-em0n Date: 2025-06-13 Category: interview-qa/class-wise ]

📘 Class 13: Why Functions Are Needed?

✅ ১. কেন ফাংশন দরকার?

প্রোগ্রাম লেখার সময় অনেক সময় দেখা যায় একই ধরণের কাজ বারবার করতে হচ্ছে। যেমন: ইউজারের নাম নেওয়া, সংখ্যা নেওয়া, বা একটা মেসেজ প্রিন্ট করা।

👉 যদি এগুলো আমরা বারবার main() ফাংশনের মধ্যে লিখি, তাহলে:

• কোড অনেক বড় ও জটিল হয়ে যায়
• একই কোড বারবার লিখতে হয় (repetition)
• কোড মেইনটেইন করা কঠিন হয়

📌 ফাংশন ব্যবহার করলে:

• কোড ছোট ছোট অংশে ভাগ করা যায় (Modular Code)
• একবার লিখে বারবার ব্যবহার করা যায় (Reusable)
• বোঝা এবং মেইনটেইন করা সহজ হয়
• বাগ (bug) ধরা ও ঠিক করা সহজ হয়

Example : ফাংশন ব্যবহার করার আগে

এখানে একটি প্রোগ্রাম দেখানো হয়েছে যেখানে কোন ফাংশন ব্যবহার করা হয়নি:

package main

import "fmt"

func main() {
    // Print welcome message
    fmt.Println("Welcome to the application")

    // Get user name as input
    var name string
    fmt.Println("Enter your name - ")
    fmt.Scanln(&name)

    var num1 int
    var num2 int
    fmt.Println("Enter first number - ")
    fmt.Scanln(&num1)
    fmt.Println("Enter second number - ")
    fmt.Scanln(&num2)

    sum := num1 + num2

    // display results
    fmt.Println("Hello, ", name)
    fmt.Println("Summation = ", sum)

    // print a goodbye message
    fmt.Println("Thank you for using the application")
    fmt.Println("Goodbye")
}

🧠 সমস্যা:

• একই main() ফাংশনে সবকিছু একত্রে থাকায় কোডটি বড় ও জটিল হয়ে গেছে
• পুনরায় ব্যবহারযোগ্যতা নেই
• মেইনটেন করা কঠিন

✅ ফাংশন ব্যবহার করার পরে

একই কাজকে ফাংশনের মাধ্যমে ভাগ করে সহজ করা হয়েছে:

package main

import "fmt"

func printWelcomeMessage() {
    fmt.Println("Welcome to the application")
}

func getUserName() string {
    var name string
    fmt.Println("Enter your name - ")
    fmt.Scanln(&name)
    return name
}

func getTowNumbers() (int, int) {
    var num1 int
    var num2 int
    fmt.Println("Enter first number - ")
    fmt.Scanln(&num1)
    fmt.Println("Enter second number - ")
    fmt.Scanln(&num2)-
    return num1, num2
}

func add(num1 int, num2 int) int {
    sum := num1 + num2
    return sum
}

func display(name string, sum int) {
    fmt.Println("Hello, ", name)
    fmt.Println("Summation = ", sum)
}

func printGoodByeMessage() {
    fmt.Println("Thank you for using the application")
    fmt.Println("Goodbye")
}

func main() {
    printWelcomeMessage()
    name := getUserName()
    num1, num2 := getTowNumbers()
    sum := add(num1, num2)
    display(name, sum)
    printGoodByeMessage()
}

✅ সুবিধা:

• প্রতিটি কাজ আলাদা ফাংশনে রাখা হয়েছে
• কোড সহজ ও সুন্দর হয়েছে
• বারবার ব্যবহারযোগ্যতা বেড়েছে
• মেইনটেন করা সহজ হয়েছে

✅ ২. মডুলার কোড কাকে বলে?

Modular code মানে হচ্ছে, পুরো প্রোগ্রামকে ছোট ছোট "module" বা অংশে ভাগ করে লেখা। প্রতিটি অংশ একটা নির্দিষ্ট কাজ করে।

📌 উদাহরণ:

এভাবে প্রতিটি কাজের জন্য আলাদা ফাংশন থাকলে:

✅ বুঝতে সহজ
✅ পুনঃব্যবহারযোগ্য (Reusable)
✅ টেস্ট/বাগ ফিক্স সহজ
✅ ভবিষ্যতে বড় সফটওয়্যারে সহজে এক্সটেন্ড করা যায়

✅ ৩. SOLID এর S – Single Responsibility Principle

S = Single Responsibility Principle (SRP)
👉 এটি বলে: "একটি ফাংশনের মাত্র একটি কাজ (responsibility) থাকা উচিত।"

🧠 কেন SRP গুরুত্বপূর্ণ?

• এতে কোড সুস্পষ্ট ও সহজবোধ্য হয়
• একটি ফাংশনে পরিবর্তন করলে অন্যগুলো ভাঙে না
• বাগ ফিক্সিং সহজ হয়
• টেস্টিং সহজ হয়

📌 উদাহরণ:

❌ খারাপ ডিজাইন (SRP ভঙ্গ করছে):

func handleEverything() {
    // ইনপুট নেয়
    // হিসাব করে
    // প্রিন্ট করে
}

এই ফাংশন অনেক কাজ করছে একসাথে - যা SRP ভঙ্গ করে।

✅ ভালো ডিজাইন (SRP মেনে চলছে):

func getUserName() {}
func add() {}
func display() {}

এখানে প্রতিটি ফাংশন একটি মাত্র কাজ করছে - এটিই SRP।

🎯 ক্লাসের সারাংশ:

[Author : @shahriar-em0n Date: 2025-06-13 Category: interview-qa/class-wise ]

🧱 Class 14: What is Scope

Scope বলতে code এর part বুঝায় যেখানে একটি নির্দিষ্ট variable কে access করা যাবে।

📘 ক্লাসে ব্যবহৃত কোড

package main

import "fmt"

var (
	a = 20
	b = 30
)

func add(x int, y int) {
	z := x + y
	fmt.Println(z)
}

func main() {
	p := 30
	q := 40

	add(p, q)

	add(a, b)

	add(a, p)

	add(b, z) // ❌ error!
}

✨ Code Explain

var (
	a = 20
	b = 30
)

🔸 RAM এ একটা জায়গায় এ variable গুলো রাখা হয় যেটাকে global memory বলা হয়।

🔸 a এবং b এই দুইটা RAM এর global scope এ declare করা হয়েছে।

🔸 যেকোন ফাংশনের ভেতর থেকে এগুলোকে ব্যবহার করা যাবে।

🧠 যেসব ভ্যারিয়েবল main() বা অন্য কোনো ফাংশনের বাইরে delare করা হয় - সেগুলো global.

👉 main() এবং add() function ও RAM এর global scope এ থাকে (বুঝার সুবিধার্থে)।

💡 শুরুতে RAM এ যা থাকে

				    RAM
+------------------------------------------+
| 20 | 30 | ---- |---- |   |   |   |   |   |
+------------------------------------------+
   a    b   add()  main()

				 global

Go প্রোগ্রামে main() ফাংশন না থাকলে, প্রোগ্রাম চলবে না। main() হচ্ছে execution শুরু করার জায়গা; ওটা ছাড়া Go বুঝতে পারে না কোথা থেকে শুরু করবে।

main() Execution

func main() {
	p := 30
	q := 40

	add(p, q)

	add(a, b)

	add(a, p)

	add(b, z)
}

🔸RAM এ main() এর জন্য আলাদা জায়গা দখল করে

🔸p ও q হলো main() এর local variable

🔸এগুলো main() এর বাইরে থেকে ব্যবহার করা যাবে না

				    RAM
+------------------------------------------+
| 30 | 40 |  |  |  |  |  |  |  |  |  |  |  |
+------------------------------------------+
  p    q

  				main()

• main() এ add() function না থাকায় add() কে global এ খুঁজে

add() Execution

func add(x int, y int) {
	z := x + y
	fmt.Println(z)
}

🔸 RAM এ add() এর জন্য আলাদা জায়গা নেয়

🔸 x, y & z হল add() এর local variable

🔸 x এবং y হল add() function এর parameter

🔸add() function শেষ হলে RAM থেকে এদের মুছে ফেলা হয়।

				    RAM
+------------------------------------------+
| 30 | 40 | 70 |  |  |  |  |  |  |  |  |  |
+------------------------------------------+
  x    y    z

  				add()

❌ যদি স্কোপ ভুলে যাও

func add(x int, y int) {
	z := x + q
	fmt.Println(z)
}

🔸q variable add() এর local scope এ নেই

🔸q -> main() এর local variable হওয়ায় global scope এ পাওয়া যাবে না

Scope এর বাইরের variable use করলে undefined compilation error দিবে।

Output:

# command-line-arguments
./main.go:11:11: undefined: q

🧠 Scope Rule

[Author : @nazma98 Date: 2025-06-13 Category: interview-qa/class-wise ]

Class 15 - Local Scope and Block

🧠 Scope types

Scope ৩ টাইপের।

• Global scope
• Local scope
• Package scope

1️⃣ Global Scope

🔹 যে variable বা function, main() এর বাইরে declare করা হয়

🔹 সব ফাংশন থেকে access করা যায়

var x = 100

func main() {
	fmt.Println(x)
}

এখানে x একটি global variable, তাই main() function একে access করতে পারছে।

🧱 Block Scope

Go তে যেকোনো {} curly brace কে Block বলে।

Block এর ভিতরে যদি variable declare করা হয়, তাহলে সেটা সেই block এর local scope এ পরে এবং একে ওই Block এর local variable বলে।

✨ Code Example

func main() {
	x := 18

	if x >= 18 {
		p := 10
		fmt.Println("I'm matured boy")
		fmt.Println("I've ", p, " girlfriends")
	}
}

✨ Code Explanation

🔹 main() ফাংশন শুরু

func main() {
	x := 18

• এখানে x variable টি main() ফাংশনের ভিতরে declare করা হয়েছে।
• x এর scope পুরো main() ফাংশনের ভিতর - একে বলে local variable to main()

🔹 if Block

if x >= 18 {
	p := 10
	fmt.Println("I'm matured boy")
	fmt.Println("I've ", p, " girlfriends")
}

• if block শুরু হয়েছে { দিয়ে এবং শেষ হয়েছে } দিয়ে - এটি হলো একটা Block।
• block এর ভিতরে p := 10 - তাই p এর scope কেবল if block এর ভিতরেই সীমাবদ্ধ।
• p কে main() ফাংশনের বাইরে বা if block এর বাইরে ব্যবহার করা যাবে না

🧠 RAM Visualization (Scope অনুযায়ী)

                      RAM
+------------------------------+
| x = 18       ← main() scope  |
+------------------------------+

        ⬇ if block executed

+------------------------------+
| x = 18                       |
| p = 10   ← if block scope    |
+------------------------------+

        ⛔ if block শেষ হওয়ার পর

+------------------------------+
| x = 18                       |
| p = ❌ (not accessible)      |
+------------------------------+

🚫 Scope এর বাইরে variable access

📄Code Example - 01

func main() {
	x := 18

	if x >= 18 {
		p := 10
		fmt.Println("I'm matured boy")
		fmt.Println("I've ", q, " girlfriends")
	}
}

💬 Code Explanation

🔹main() ফাংশন

func main() {
	x := 18

x হল একটি local variable to main() তাই main() ফাংশনের যেকোনো জায়গা থেকে access করা যাবে।

🔹 if block

p := 10

if block এর ভেতরে declare করা হয়েছে, তাই block scope অনুযায়ী p শুধু if block এর ভিতরে accessible

fmt.Println("I've ", q, " girlfriends")

• এখানে q কোথাও declare করা হয়নি
• Go এখন main() বা global scope এ খুঁজে দেখবে - কিন্তু সেখানে নেই
• তাই Go কম্পাইলার "undefined: q" error দিবে

🧠 RAM Visualization (Scope অনুযায়ী)

             RAM (Execution Time)
+-------------------------------+
| x = 18         ← main() scope |
+-------------------------------+
        ↓ if block executed
+-------------------------------+
| x = 18                        |
| p = 10     ← if block scope   |
| q = ??? ❌  (not found!)       |
+-------------------------------+

📄 Code Example - 02

func main() {
	x := 18

	if x >= 18 {
		p := 10
		fmt.Println("I'm matured boy")
		fmt.Println("I've ", p, " girlfriends")
	}

		fmt.Println("I've ", p, " girlfriends")

}

🧱 Scope বিশ্লেষণ

🔹 x := 18

• main() ফাংশনের ভিতরে declare করা হয়েছে → তাই x এর scope হলো পুরো main() ফাংশনের ভিতর।

🔹 if x >= 18 { ... }

• এই block এর ভিতরে p := 10 declare করা হয়েছে।
• তাই p এর scope শুধুমাত্র এই if block এর ভিতরে।

🔹 fmt.Println("I've ", p, " girlfriends")

• এখানে p কে use করা হয়েছে তার নিজের scope এর মধ্যেই

🔹 if block এর বাহিরের fmt.Println("I've ", p, " girlfriends")

• p, if block এর ভিতরে declare হয়েছে → তাই বাইরে access করা যাবে না
• ❌ এখানে p এর scope এর বাইরে চলে গেছে
• তাই Go কম্পাইলার error দিবে: undefined: p

💾 RAM Visualization (Scope অনুযায়ী)

                   RAM
+-----------------------------+
| x = 18        ← main scope  |
+-----------------------------+
        ⬇ if block শুরু হলে
+-----------------------------+
| x = 18                      |
| p = 10     ← if block only  |
+-----------------------------+
        ⬇ if block শেষ
+-----------------------------+
| x = 18                      |
| p = ❌ (Not Found!)         |
+-----------------------------+

🧠 Block Scope এর মূল পয়েন্টগুলো

✅ Block আসলে memory তে নতুন জায়গা দখল করে।

• প্রতিবার কোনো block (যেমন: if, for, switch, function) চালু হলে RAM এ সেই block এর জন্য অস্থায়ী জায়গা (temporary memory space) তৈরি হয়।

✅ Block এর ভিতরে declare করা variable বাইরে থেকে access করা যাবে না।

• Variable শুধুমাত্র সেই block এর local scope এর ভিতরে কাজ করে।

✅ Block শেষ হলেই সেই variable RAM থেকে মুছে যায় বা আর access করা যায় না।

• কারণ Go এর compiler বুঝে - variable টি তার scope এর বাইরে চলে গেছে।

[Author: @nazma98 Date: 2025-06-14 Category: interview-qa/class-wise ]

🧠 Class 16: GoLang package scope

১. Package কী?

Package হলো GoLang কোড গুছিয়ে রাখার একটি পদ্ধতি। একটি Package অনেকগুলো ফাইল থাকতে পারে, এবং সবগুলোর package নাম একই হলে তারা একে অপরের কোড ব্যবহার করতে পারে।

✅ নিয়ম:

• একই ফোল্ডারে সব .go ফাইলের package নাম এক হওয়া উচিত।
• package main হলে সেটি রানযোগ্য প্রোগ্রাম।
• অন্য প্যাকেজ যেমন package mathlib → লাইব্রেরি বা ইউটিলিটি হিসেবে ব্যবহৃত হয়।

২. Scope এবং Export কী?

📌 কোন জায়গা থেকে কোন ফাংশন বা ভেরিয়েবল অ্যাক্সেস করা যাবে।

• যদি function নাম ছোট হাতের অক্ষরে শুরু হয় (যেমন add), তাহলে এটি শুধুমাত্র সেই Packageর ভিতরেই ব্যবহার করা যাবে।
• যদি বড় হাতের অক্ষরে শুরু হয় (যেমন Add), তাহলে সেটি এক্সপোর্টেড হয় এবং অন্য প্যাকেজ থেকেও ব্যবহার করা যায়।

৩. কোড উদাহরণ

📁 add.go

package main

import "fmt"

func add(n1, n2 int) {
    res := n1 + n2
    fmt.Println(res)
}

📌 add() function নাম ছোট হাতের অক্ষরে, তাই এটা শুধু main Packageর ভিতরেই কাজ করবে।

📁 main.go

package main

var (
    a = 20
    b = 30
)

func main() {
    add(4,7)
}

📌 এখানে add() কল করা হয়েছে কারণ add.go ফাইল একই Package আছে (package main)।
👉 রান করতে হবে:

go run main.go add.go

📁 কাস্টম প্যাকেজ mathlib/math.go

package mathlib

import "fmt"

func Add(x int, y int) {
    z := x + y
    fmt.Println(z)
}

📌 এবার Add() function বড় হাতের অক্ষরে শুরু → Exported
📌 mathlib নামে প্যাকেজ → একে অন্য ফোল্ডারে রাখতে হবে (যেমন: mathlib/)

📁 main.go (পরিবর্তিত ভার্সন)

package main

import (
    "fmt"
    "example.com/mathlib"
)

var (
    a = 20
    b = 30
)

func main() {
    fmt.Println("Showing Custom Package")
    mathlib.Add(4,7)
}

📌 এখানে mathlib.Add() ব্যবহার করা হয়েছে কারণ Add() এক্সপোর্টেড এবং আমরা import করেছি।

৪. মডিউল ব্যবস্থাপনা

✅ মডিউল শুরু করতে:

go mod init example.com/mathlib

৫. Key Concepts

🧠 সারাংশ:

• প্যাকেজ ব্যবহারে কোড পরিষ্কার ও পুনঃব্যবহারযোগ্য হয়।
• স্কোপ বুঝে কোড গঠন করলে সমস্যা হয় না।
• এক্সপোর্টেড ফাংশন ও মডিউল ব্যবস্থাপনা জানলে বড় প্রজেক্টেও কাজ সহজ হয়।

[Author: @ifrunruhin12 @shahriar-em0n Date: 2025-05-01 Category: interview-qa/class-wise ]

🧠 Class 17: Scope with another boring example

🧑‍💻 Code Example :

package main

import "fmt"

var (
    a = 10
    b = 20
)

func printNum(num int) {
    fmt.Println(num)
}

func add(x int, y int) {
    res := x + y
    printNum(res)
}

func main() {
    add(a, b)
}

🧠 মূল ধারণাসমূহ

✅ অর্ডার ম্যাটার করে না (প্যাকেজ-লেভেলের জন্য)

Go তে ফাংশন এবং গ্লোবাল ভ্যারিয়েবলগুলোর অর্ডার (ক্রম) গুরুত্বপূর্ণ নয়। মানে main() ফাংশনের পরেও যদি অন্য ফাংশন বা ভ্যারিয়েবল ডিক্লেয়ার করা হয়, Go ঠিকই সব চিনে নেয় এবং কম্পাইল করে।

🤓 Go ≠ ফাংশনাল প্রোগ্রামিং প্যারাডাইম

Go কিছু দারুণ ফিচার ধার করেছে ফাংশনাল ল্যাঙ্গুয়েজ থেকে (যেমন: ফার্স্ট-ক্লাস ফাংশন, ক্লোজার ইত্যাদি), কিন্তু Go নিজে ফাংশনাল প্রোগ্রামিং ল্যাঙ্গুয়েজ নয়।

⚖️ তাহলে Go কোন প্যারাডাইমে পড়ে?

Go হলো একাধিক প্যারাডাইম সাপোর্ট করে এমন ভাষা, তবে এর মূল স্টাইল হচ্ছে imperative এবং procedural। এটি ক্লাসিক OOP-এর বদলে struct-based composition কে গুরুত্ব দেয়।

এটি ডিজাইন করা হয়েছে যাতে ভাষাটি হয়:

• সহজ
• ভবিষ্যৎ অনুমানযোগ্য (Predictable)
• সহজে পড়া যায় এমন (Readable)

তুমি চাইলে functional-এর মতো স্টাইলে কোড লিখতে পারো, কিন্তু Go কে ডিজাইন করা হয়নি অনেক জটিল functional abstraction-এর জন্য।

[Author: @ifrunruhin12 @shahriar-em0n Date: 2025-05-01 Category: interview-qa/class-wise ]

💡 ইন্টারভিউ প্রশ্ন: Go-তে variable shadowing

🧪 Code Example :

package main

import "fmt"

var a = 10

func main() {
    age := 30

    if age > 18 {
        a := 47        //  শুধু এই if ব্লকের ভিতরে গ্লোবাল `a` কে shadow করে
        fmt.Println(a) // ➜ 47
    }

    fmt.Println(a)     // ➜ 10 (গ্লোবাল `a` প্রিন্ট করে)
}

📌 গুরুত্বপূর্ণ বিষয়:

• ভেরিয়েবল শ্যাডোয়িং হয় যখন লোকাল ভেরিয়েবলের নাম বাইরের স্কোপের ভেরিয়েবলের নামের সঙ্গে মিলে যায়।
• Go কোন Error দিবে না এটি শুধুমাত্র বর্তমান স্কোপে থাকা সবচেয়ে ভিতরের ভেরিয়েবলটি ব্যবহার করবে।
• Global a অপরিবর্তিত থাকে এবং if ব্লকের বাইরে প্রিন্ট হয়।

🧠 Memory ও stack animation

⏱ প্রোগ্রাম শুরু

📦 Data segment:

┌─────────────┐
│ global a=10 │ ◄── প্রোগ্রাম শেষ হওয়া পর্যন্ত থাকে
└─────────────┘

🚀 main() কল হয়

📚 Stack:

┌────────────────────────────┐
│ 🧩 main() stack frame      │
│   └── age = 30             │
└────────────────────────────┘

✅ if ব্লকে প্রবেশ (কারণ age > 18 সত্য)

🧱 নতুন ব্লক স্কোপ শুরু
📚 Stack:

┌────────────────────────────┐
│ 🧩 main() stack frame      │
│   └── age = 30             │
│   🔸 a (shadow করা) = 47   | ◄── global `a` কে shadow করে
└────────────────────────────┘

🖨️ fmt.Println(a) ➜ output: 47 ✅

🔚 if ব্লক শেষ, shadow করা a ডিলিট হয়

📚 Stack:

┌────────────────────────────┐
│ 🧩 main() stack frame      │
│   └── age = 30             │
└────────────────────────────┘

🖨️ fmt.Println(a) ➜ output: 10 ✅ (global a)

🔚 main() শেষ, stack clear

📚 Stack:

(empty)

🧼 প্রোগ্রাম শেষ

📌 ভিজ্যুয়াল সারাংশ

• গ্লোবাল variable (যেমন a = 10) ডাটা সেগমেন্টে থাকে।
• লোকাল variable (যেমন age বা shadow করে a) স্ট্যাকে থাকে।
• নতুন scope (যেমন if, for, function block) এ ঢুকলে নতুন variable স্ট্যাকে পুশ হয়।
• ব্লক শেষ হলে shadow করা variable স্ট্যাক থেকে মুছে যায়।
• প্রোগ্রাম শেষ হলে স্ট্যাক ক্লিয়ার হয়, কিন্তু ডাটা সেগমেন্ট পুরো সময় জীবিত থাকে।

[Author: @ifrunruhin12 @shahriar-em0n Date: 2025-05-01 Category: interview-qa/class-wise ]

🧠 Class 19: Function Types in Go

1️⃣ Standard Function (নির্ধারিত function)

একটি সাধারণভাবে নামযুক্ত function যা func কীওয়ার্ড দিয়ে তৈরি করা হয়।

func add() {
    fmt.Println("Hello!")
}

2️⃣ Anonymous Function (নামহীন function)

এই ফাংশনের কোনো নাম থাকে না। একে ইনলাইন বা তৎক্ষণাৎ ব্যবহার করা যায়।

func() {
    fmt.Println("I have no name!")
}()

3️⃣ Function Expression (ভেরিয়েবলে function সংরক্ষণ)

ফাংশনটিকে একটি ভেরিয়েবলে সংরক্ষণ করে পরে ব্যবহার করা হয়।

hello := func() {
    fmt.Println("Hi there!")
}
hello()

4️⃣ Higher-Order Function / First-Class Function

যে function অন্য ফাংশনকে প্যারামিটার হিসেবে গ্রহণ করে অথবা function রিটার্ন করে।

func operate(a int, b int, fn func(int, int) int) int {
    return fn(a, b)
}

5️⃣ Callback Function (পুনরায় কল করা হয় এমন function)

একটি function যা আরেকটি ফাংশনে প্যারামিটার হিসেবে পাঠানো হয় এবং নির্দিষ্ট সময়ে কল করা হয়।

func process(callback func()) {
    callback()
}

6️⃣ Variadic Function (বহু সংখ্যক প্যারামিটার গ্রহণ করে)

একটি function যা পরিবর্তনশীল সংখ্যক আর্গুমেন্ট গ্রহণ করতে পারে।

func sum(nums ...int) {
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

7️⃣ Init Function (Go নিজে থেকে কল করে)

Go প্রোগ্রাম রান করার সময় main() এর আগেই init() ফাংশনটি কল হয়। এটি ম্যানুয়ালি কল করা যায় না।

func init() {
    fmt.Println("Initializing...")
}

8️⃣ Closure (বাইরের স্কোপের ভেরিয়েবল বন্ধ করে ফেলে)

একটি function যা বাইরের স্কোপের ভেরিয়েবল "বন্ধ" বা retain করে রাখে।

func outer() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

9️⃣ Defer Function (শেষে কল হয় Stack এর Last In First Out নিয়মে)

defer কীওয়ার্ড ব্যবহারে ফাংশনটি পরে কল হয়, সাধারণত function শেষ হওয়ার আগে।

func test() {
    defer fmt.Println("Three")
    defer fmt.Println("Two")
    fmt.Println("One")
}

🟢 output:

One
Two
Three

🔟 Receiver Function / Method (struct এর সাথে যুক্ত function)

Go তে struct এর সাথে method সংযুক্ত করা যায়।

type Person struct {
    name string
}

func (p Person) add() {
    fmt.Println("Hello", p.name)
}

1️⃣1️⃣ IIFE - Immediately Invoked Function Expression

একটি function যা একসাথে define এবং invoke করা হয়।

func(msg string) {
    fmt.Println(msg)
}("IIFE Example")

[Author: @ifrunruhin12 @shahriar-em0n Date: 2025-05-01 Category: interview-qa/class-wise ]

🧠 Class 20: Init Function

📺 Video Topic: init() Function in Go

🔤 Code Written in This Class

✅ Example 1

package main

import "fmt"

func main() {
    fmt.Println("Hello Init Function!")
}

func init() {
    fmt.Println("I am the function that is executed first")
}

✅ Example 2

package main

import "fmt"

var a = 10

func main() {
    fmt.Println(a)
}

func init() {
    fmt.Println(a)
    a = 20
}

🔍 Key Concepts

• init() একটি বিশেষ Go function যা main() এর আগে automatically run হয় ।
• একাধিক ফাইল এবং প্যাকেজে একাধিক init() থাকতে পারে। চালানোর ক্রম:
  • Dependency packages আগে
  • তারপর ফাইল অর্ডার অনুযায়ী (উপরে থেকে নিচে)
• init() ম্যানুয়ালি কল করা যায় না। এটি প্রোগ্রাম শুরু হওয়ার আগেই চলে।

🧠 CLI Memory & Execution Visualization (Example 1)

🛠 Compile Time: Go detects init()
Found init() in main package ✅

----------- EXECUTION BEGINS -----------

🧠 Data Segment:
(none)

📚 Stack:
┌────────────────────┐
│ 🧩 init()           │
└────────────────────┘

🖨️ Output:
"I am the function that is executed first"

👋 init() returns

📚 Stack:
┌────────────────────┐
│ 🧩 main()           │
└────────────────────┘

🖨️ Output:
"Hello Init Function!"

✅ Program ends gracefully

🔍 CLI Visualization: Execution & Memory Layout (Example 2)

=========== Program Compilation ===========
Found global variable: a = 10
Found init() ✅
Found main() ✅

=========== Execution Begins ==============

🧠 Data Segment (Globals):
a = 10 ← initialized before anything runs

📚 Stack Frame:
┌────────────┐
│  init()    │
└────────────┘

🔁 init() runs
→ Prints: 10
→ Updates a = 20

Stack after init():
(returns to runtime)

📚 Stack Frame:
┌────────────┐
│  main()    │
└────────────┘

🔁 main() runs
→ Prints: 20

=========== Execution Ends ================

📌 Summary

• Global variable a প্রোগ্রাম চলার আগেই initialized হয়।
• init() প্রথমে execute হয়:
  • a = 10 পড়ে
  • a = 20 করে আপডেট করে
• main() updated value দেখায়: 20

এটি একটি ক্লাসিক উদাহরণ, যেখানে init() মূল প্রোগ্রাম চলার আগে runtime environment প্রস্তুত করে।

⚡ Quick Recap

• init() সবসময় main() এর আগে চলে, এমনকি যদি কোডে পরে লেখা থাকে।
• এটি config, database connection, default value ইত্যাদি initialize করার জন্য ব্যবহার করা হয়।
• একটি Go ফাইলে একটাই main() থাকতে পারে, কিন্তু একাধিক init() থাকতে পারে।

Init is like the secret backstage crew. You don’t see them during the show, but they’re the reason the lights come on.

[Author: @ifrunruhin12 @shahriar-em0n Date: 2025-05-01 Category: interview-qa/class-wise ]

Class 21 – expression, anonymous function ও IIFE - in go

🎥 ভিডিও নাম: anonymous function, expression ও IIFE

🔤 Code Written in This Class

// anonymous function
// IIFE - ইমিডিয়েটলি ইনভোকড function expression

package main

import "fmt"

func main() {
    // anonymous function
    func(a int, b int) {
        c := a + b
        fmt.Println(c)
    }(5, 7) // IIFE
}

func init() {
    fmt.Println("আমি সবার আগে কল হব")
}

🧠 মূল ধারণাসমূহ

Go-তে Expression (expression)

expression হলো যেকোনো code snippet যা কোনো মান (value) রিটার্ন করে।

example:

a + b          // একটি expression
func(x, y){}   // একটি function expression

expression মান হিসেবে ব্যবহার, pass অথবা সাথে সাথেই execute করা যায়।

anonymous function

anonymous function হলো নামবিহীন function।

func(a, b int) int {
    return a + b
}

✅ এটি ভ্যারিয়েবল হিসেবে সংরক্ষণ, আর্গুমেন্ট হিসেবে pass বা সাথে সাথেই কল করা যায়।

⚡ IIFE (Immediately Invoked Function Expression)

IIFE হলো এমন একটি anonymous function যেটি ডিক্লেয়ার করার সাথেসাথে execute হয়।

func(a int, b int) {
    // কাজ
}(5, 7)

ব্যবহার: ছোট লজিক ব্লক তাৎক্ষণিক চালানোর জন্য উপযোগী, নতুন নাম না দিয়েই।

🖥️ CLI- execution vizualization

=========== compilation ধাপ =============
init() function খুঁজে পাওয়া গেছে ✅
main() function খুঁজে পাওয়া গেছে ✅

=========== এক্সিকিউশন ধাপ =============

🔁 init() প্রথমে চলে
→ আউটপুট: আমি সবার আগে কল হব

🧠 ডেটা সেগমেন্ট:
(কোনো গ্লোবাল ভ্যারিয়েবল নেই)

📚 stack frame:
┌─────────────────────┐
│    main()           │
│ ┌─────────────────┐ │
│ │  anonymous function │ │
│ └─────────────────┘ │
└─────────────────────┘

main() একটি IIFE কল করে:
→ 5 এবং 7 pass করে
→ ভিতরে: c := 5 + 7 = 12
→ output: 12

=========== execution সম্পূর্ণ ============

🧵 TL;DR (সংক্ষেপে)

• [] expression- মান রিটার্ন করে, এসাইন বা execute করা যায়।
• [] anonymous function- দ্রুত লজিক ব্লক চালাতে ব্যবহৃত হয়।
• [] IIFE- ডিফাইন এবং execute একসাথে — একবারের কাজের জন্য দারুন!

[Author: @ifrunruhin12 @shahriar-em0n Date: 2025-05-01 Category: interview-qa/class-wise ]

📘 CLass 22 – Go Function Expression & Shadowing

🎥 ভিডিও নাম: Function Expression Example

✅ Example 1:

package main

import "fmt"

// গ্লোবাল ফাংশন এক্সপ্রেশন
var add = func(x, y int) {
    fmt.Println(x + y)
}

func main() {
    add(4, 7) // গ্লোবাল `add` কল হচ্ছে

    // লোকাল ভেরিয়েবলে ফাংশন এক্সপ্রেশন অ্যাসাইন করা
    add := func(a int, b int) {
        c := a + b
        fmt.Println(c) কোড ২
    }

    add(2, 3) // এখন লোকাল `add` কল হচ্ছে
}

func init() {
    fmt.Println("আমি প্রথমে কল হব")

🧠 মূল ধারণাসমূহ

🔧 Function Expression

যখন কোনো ফাংশনকে একটি ভেরিয়েবলে সংরক্ষণ করা হয়। এর মাধ্যমে আমরা —

• logic একটি ভেরিয়েবলে রাখতে পারি
• ফাংশনকে ফার্স্ট-ক্লাস সিটিজেন হিসেবে ব্যবহার করতে পারি
• inline বা anonymous ফাংশন তৈরি করতে পারি

উদাহরণ:

add := func(a int, b int) {
    fmt.Println(a + b)
}

🧱 Shadowing

যখন একটি ছোট স্কোপে (লোকাল স্কোপে) থাকা ভেরিয়েবলের নাম বড় স্কোপে থাকা একই নামের ভেরিয়েবলকে ঢেকে ফেলে বা “শ্যাডো” করে।

add := func(a int, b int) {...}

এই add লোকাল স্কোপে গ্লোবাল add কে ঢেকে দেয়।

🖥️ CLI- execution vizualization

========== কম্পাইলেশন ফেজ ==========
✔ init() পাওয়া গেছে
✔ main() পাওয়া গেছে
✔ গ্লোবাল `add` ফাংশন অ্যাসাইন করা হয়েছে

========== এক্সিকিউশন শুরু ==========
init():
→ প্রিন্ট করে: আমি প্রথমে কল হব

main():
→ গ্লোবাল `add(4, 7)` → প্রিন্ট: 11

main() এর ভিতরের লোকাল স্কোপ:
┌──────── Stack Frame ───────┐
│ main()                     │
│ ┌──────────────┐          │
│ │ add (লোকাল)  │────────┐ │
│ └──────────────┘        │ │
└─────────────────────────┘ │
       (গ্লোবালটিকে ঢেকে দেয়) ◄───┘

→ লোকাল `add(2, 3)` → প্রিন্ট: 5

========== এক্সিকিউশন শেষ ==========

❌ Example 2: কম্পাইল হয় না

package main

import "fmt"

// গ্লোবাল ফাংশন এক্সপ্রেশন
var add = func(x, y int) {
    fmt.Println(x + y)
}

func main() {
    adder(4, 7) // ❌ ERROR: undefined: adder

    adder := func(a int, b int) {
        c := a + b
        fmt.Println(c)
    }

    add(2, 3)
}

func init() {
    fmt.Println("আমি প্রথমে কল হব")
}

❌ কেন এটা কাজ করে না?

এই লাইনটি:

adder(4, 7)

ডিক্লেয়ারেশনের উপরে আছে:

adder := func(a int, b int) { ... }

🛑 সমস্যা: Temporal Dead Zone

Go তে তুমি কোনো ভেরিয়েবলকে তার ডিক্লেয়ারেশনের আগে ব্যবহার করতে পারো না even একই ব্লকের মধ্যেও।

তাই adder ব্যবহার করার সময়ে সেটি এখনো ডিক্লেয়ার হয়নি।

ভুল:

./main.go:10:2: undefined: adder

📚 TL;DR

[Author: @ifrunruhin12 @shahriar-em0n Date: 2025-05-01 Category: interview-qa/class-wise ]

Class 23: Go-তে Functional Programming ধারণা

package main

import "fmt"

func add(a int, b int) { // Parameter: a and b
    c := a + b
    fmt.Println(c)
}

func main() {
    add(2, 5) // 2 এবং 5 হলো argument
    processOperation(4, 5, add)
    sum := call() // function expression
    sum(4, 7)
}

func processOperation(a int, b int, op func(p int, q int)) { // Higher order function
    op(a, b)
}

func call() func(x int, y int) {
    return add
}

🧠 মূল ধারণাসমূহ

১. Parameter বনাম Argument

• Parameter: ফাংশনের ভিতরে ডিফাইন করা ভেরিয়েবল (যেমন: a int, b int in add(a, b)).
• Argument: ফাংশন কল করার সময় যেসব মান পাঠানো হয় (যেমন: add(2, 5) এ 2 এবং 5).

২. First Order Function

• এমন ফাংশন যেটি অন্য কোনো ফাংশন নেয় না বা ফেরত দেয় না।
• উদাহরণ:
  • Named function: func add(a, b int)
  • Anonymous function: func(a int, b int) { ... }
  • IIFE: func(a, b int) { ... }(5, 7)
  • Function expression: sum := func(a, b int) { ... }

৩. Higher Order Function

• এমন ফাংশন যা অন্য ফাংশন নেয়, ফেরত দেয়, অথবা দুটোই করে।
• উদাহরণ:
  • processOperation একটি ফাংশন নেয়
  • call() একটি ফাংশন রিটার্ন করে

৪. Callback Function

• যেসব ফাংশন অন্য ফাংশনের ভিতরে পাঠানো হয় এবং পরে কল করা হয়।
• উদাহরণ: processOperation(4, 5, add) → এখানে add হলো callback function

৫. First-Class Citizen (Function)

• Go-তে ফাংশনগুলো first-class citizen অর্থাৎ:
  • ফাংশন ভেরিয়েবলে রাখা যায়
  • আর্গুমেন্ট হিসেবে পাঠানো যায়
  • অন্য ফাংশন থেকে রিটার্ন করা যায়

🧠 ধারণাগত প্রেক্ষাপট (Functional Programming Paradigm)

• Functional programming হলো গণিতের ফাংশনের মত হিসাব করা এবং mutable state পরিহার করা।
• অনুপ্রেরণা: গণিতের দুইটি লজিক ধারা —
  • First Order Logic → বস্তু ও তার প্রপার্টি
  • Higher Order Logic → ফাংশন এবং তার সম্পর্ক
• Haskell, Racket ইত্যাদি ভাষা ফাংশনাল প্রোগ্রামিং ভিত্তিক।
• Go এই ধারণা কিছুটা গ্রহণ করলেও মূলত এটি imperative/procedural ভাষা।

🖥️ CLI Visualization (Call Stack + Segment)

ডেটা সেগমেন্ট:

• add (গ্লোবাল ফাংশন)
• call (ফাংশন রিটার্ন করে)
• processOperation (স্টোর করা ফাংশন)

এক্সিকিউশন ফ্লো (স্ট্যাক ফ্রেম অনুযায়ী):

Call Stack:
┌──────────────────────────┐
│ main()                   │
│ ├── add(2, 5)            │ => ৭ প্রিন্ট করে
│ ├── processOperation     │
│ │   └── op(4, 5) → add   │ => ৯ প্রিন্ট করে
│ ├── call()               │ => add রিটার্ন করে
│ └── sum(4, 7)            │ => ১১ প্রিন্ট করে
└──────────────────────────┘

সারসংক্ষেপ

• Go ফাংশনাল প্রোগ্রামিং এর অনেক ধারণা সমর্থন করে যেমন: first-class ও higher-order functions।
• ফাংশনগুলোকে ভেরিয়েবলের মত ব্যবহার করা যায় — কোড মডুলার ও পরিষ্কার হয়।
• Parameter বনাম Argument, First vs Higher Order Function, এবং Callback Function ভালোভাবে বোঝা clean এবং power-efficient কোড লেখার জন্য জরুরি।

[Author: @ifrunruhin12 @shahriar-em0n Date: 2025-05-01 Category: interview-qa/class-wise ]

ক্লাস ২৪ - Go Internal Memory (Code, Data, Stack, Heap)

🧠 আলোচনার বিষয়বস্তু

এই ক্লাসে একটি Go program কম্পিউটারের মেমরিতে কীভাবে বিন্যস্ত থাকে সেটি নিয়ে বিস্তারিত আলোচনা করা হয়েছে। নিচে প্রয়োজনীয় ধারনাগুলো উল্লেখ করা হল :

• কোড সেগমেন্ট (Code Segment): কম্পাইল্ড ইন্সট্রাকশন (যেমন ফাংশন, কনস্ট্যান্ট ভ্যারিয়েবল ইত্যাদি যা পরবর্তীতে পরিবর্তন হওয়ার সুযোগ নেই) সংরক্ষণ করে।
• ডেটা সেগমেন্ট (Data Segment): প্রোগ্রামের স্ট্যাটিক (static) এবং গ্লোবাল (global) ভ্যারিয়েবল সংরক্ষণের জন্য ব্যবহৃত হয় (যেমন var a = 10)।
• স্ট্যাক (Stack): ফাংশনের মধ্যে ব্যবহৃত লোকাল ভেরিয়েবলগুলো স্ট্যাকে সংরক্ষণ করা হয়। প্রতিটি ফাংশন কলের জন্য নতুন স্ট্যাকফ্রেম (Stack Frame) তৈরি করে।
• হিপ (Heap): ডাইনামিক মেমোরি অ্যালোকেশন (dynamic memory allocation) এর জন্য ব্যবহৃত হয় (এটি নিয়ে পরবর্তীতে বিস্তারিত আলোচনা করা হবে)।
• গারবেজ কালেক্টর (Garbage Collector): হিপ মেমোরি (heap memory) থেকে অব্যবহৃত বা অপ্রয়োজনীয় মেমোরি সরিয়ে মেমোরি ফাঁকা করে।

📜 ক্লাসের কোড:

package main

import "fmt"

var a = 10

func add(x, y int) {
    z := x + y
    fmt.Println(z)
}

func main() {
    add(5,4)
    add(a,3)
}

func init() {
    fmt.Println("Hello")
}

🔍 কোড এক্সিকিউশন ফ্লো এবং মেমোরি লেআউট

       ┌────────────────────────────────────────────┐
       │               Code Segment                 │
       │--------------------------------------------│
       │ Functions: init, main, add                 │
       └────────────────────────────────────────────┘
                      │
                      ▼
       ┌────────────────────────────────────────────┐
       │              Data Segment                  │
       │--------------------------------------------│
       │ Global Variable: a = 10                    │
       └────────────────────────────────────────────┘
                      │
                      ▼
          ┌────────────────────────────┐
          │          Stack             │
          │----------------------------│
          │ main() Stack Frame         │
          │   - Calls add(5, 4)        │
          │       - x=5, y=4           │
          │       - z=9                │
          │   - Calls add(10, 3)       │
          │       - x=10, y=3          │
          │       - z=13               │
          └────────────────────────────┘
                      │
                      ▼
       ┌────────────────────────────────────────────┐
       │               Heap (Unused here)           │
       │       (Managed by the Garbage Collector)   │
       └────────────────────────────────────────────┘

⚙️ এক্সিকিউশন অর্ডার (Execution Order)

১। init() একটি বিশেষ ফাংশন, যা main() ফাংশনের আগে স্বয়ংক্রিয়ভাবে (automatically) রান হয়। তাই এটি শুরুতে Hello প্রিন্ট করবে।

Hello

২। এই পর্যায়ে main() ফাংশন রান হবে এবং -[] add(5, 4) ফাংশনকে কল করবে। ফলে প্রিন্ট হবে 9

9

এরপর -[] add(a, 3) ফাংশনকে কল করবে যেখানে a এর মান 10 ব্যবহার করবে (ডেটা সেগমেন্ট থেকে)। ফলে প্রিন্ট হবে 13

13

📌 মূল ধারনা পুনরালোচনা (Key Concepts Recap)

• কোড সেগমেন্ট | সব ফাংশন কম্পাইল হওয়ার পর যেখানে থাকে
• ডেটা সেগমেন্ট | গ্লোবাল ভেরিয়েবল সংরক্ষণ করে
• স্ট্যাক | ফাংশন রান হওয়ার সময় অস্থায়ী মেমরি (লোকাল ভেরিয়েবল, প্যারামিটার)
• হিপ | ডাইনামিক মেমরির জন্য
• গারবেজ কালেক্টর | হিপে থাকা মেমরি স্বয়ংক্রিয়ভাবে ম্যানেজ করে
• init() ফাংশন | Go-তে বিশেষ ফাংশন — main() এর আগে রান হয়

🧼 গারবেজ কালেক্টর সম্পর্কে উপলব্ধি: Go-এর গারবেজ কালেক্টর হিপে থেকে অব্যবহৃত মেমরি মুছে ফেলে। ছোট প্রোগ্রামে এটি তেমন বোঝা যায় না, তবে অ্যাপ বড় হলে এটি আপনার সেরা বন্ধু।

[Author: @ifrunruhin12, @nazma98 Date: 2025-05-01 - 2025-05-14 Category: interview-qa/class-wise ]

ক্লাস ২৫ - ইন্টারনাল মেমরি গভীর বিশ্লেষণ: কম্পাইলেশন ও এক্সিকিউশন পর্যায়

✨ আলোচিত বিষয়বস্তু

এই ক্লাসে একটি Go প্রোগ্রামের অভ্যন্তরীণ কার্যকলাপ নিয়ে আলোচনা করা হয়েছে, বিশেষ করে নিচের বিষয়গুলোর ওপর:

• কম্পাইলেশন পর্যায় (Compilation Phase)
• এক্সিকিউশন পর্যায় / রানটাইম (Execution Phase / Runtime)
• Go কীভাবে go build দিয়ে বাইনারি ফাইল তৈরি করে
• সেই বাইনারি ফাইলে কী কী সংরক্ষিত হয় (ফাংশন, কনস্ট্যান্ট, গ্লোবাল ভেরিয়েবল ইত্যাদি)
• ফাংশন এক্সপ্রেশনের (যেমন, add := func(...)) মেমরিতে কীভাবে হ্যান্ডল করা হয়

👍 আলোচনার বিষয়বস্তু

📋 ক্লাস ২৫ এর কোড:

package main

import "fmt"

const a = 10 // constant
var p = 100

func call() {
	add := func(x int, y int) {
		z := x + y
		fmt.Println(z)
	}

	add(5, 6)
	add(p, a)
}

func main() {
	call()
	fmt.Println(a)
}

func init() {
	fmt.Println("Hello")
}

🔄 কম্পাইলেশন পর্যায়ের ভিজ্যুয়ালাইজেশন

go build main.go

• পার্সার/কম্পাইলার: সিনট্যাক্স, স্কোপ এবং ডিপেন্ডেন্সি যাচাই করে।
• সংরক্ষণ করে:
  • কনস্ট্যান্ট: a = 10
  • গ্লোবাল ভেরিয়েবল: p = 100
  • ফাংশন: init, main, call, এবং call এর ভেতরের anonymous add ফাংশন
  • প্রয়োজনীয় মেশিন কোড + মেটাডাটার বাইনারি জেনারেট করে

বাইনারি ফাইলে থাকে:

• কোড সেগমেন্ট: কনস্ট্যান্ট a, main, call, anonymous ফাংশন
• ডেটা সেগমেন্ট: ভ্যারিয়েবল p
• এখানে কোনো এক্সিকিউশন হয় না।

⏱ এক্সিকিউশন পর্যায়ের ভিজ্যুয়ালাইজেশন

   ১. init()            => "Hello"
   ২. main()            => call() ফাংশনকে কল করে
   ৩. call()            => add() ফাংশনকে ডিক্লেয়ার এবং কল করে
       - add(5, 6)      => 11
       - add(100, 10)   => 110
   ৪. fmt.Println(a)    => 10

🧠 মেমরি লেআউট

┌─────────────────────────────┐
│       Code Segment          │
│-----------------------------│
│ const a = 10                |
| main, call, init, add-func  │
└─────────────────────────────┘
          ↓
┌─────────────────────────────┐
│       Data Segment          │
│-----------------------------│
│ var p = 100                 │
└─────────────────────────────┘
          ↓
┌─────────────────────────────┐
│           Stack             │
│-----------------------------│
│ call() frame → add func     │
│   x=5,y=6,z=11              │
│   x=100,y=10,z=110          │
└─────────────────────────────┘

🔹সারাংশ

• একটি Go প্রোগ্রাম দুইটি পর্যায়ে রান হয়: কম্পাইলেশন এবং এক্সিকিউশন।
• কম্পাইলেশন চলাকালে, Go মেমরি লেআউট প্রস্তুত করে, ফাংশন এবং এক্সপ্রেশন কম্পাইল করে।
• এক্সিকিউশন পর্যায়ে, প্রথমে init() এবং তারপর main() রান হয়।
• ফাংশন এক্সপ্রেশন (যেমন, add := func(...)) হলো ফার্স্ট ক্লাস ভ্যালু, যা কোড সেগমেন্টে সংরক্ষিত থাকে।
• go build থেকে তৈরি হওয়া বাইনারি ফাইলে কোড, ডেটা, এবং মেটাডাটা সহ প্রয়োজনীয় সবকিছু থাকে।

[Author: @ifrunruhin12, @nazma98 Date: 2025-05-01 - 2025-05-14 Category: interview-qa/class-wise ]

ক্লাস ২৬: ক্লোজার এবং Go এর অভ্যন্তরীণ মেমোরি গভীর বিশ্লেষণ 💡

এই ক্লাসে আমরা closure, escape analysis নিয়ে বিস্তারিত পড়াশুনা করব এবং অভ্যন্তরীণ মেমরি কিভাবে মেনেজ করা হয় তা জানব! 🧠🔥

📋 ক্লাস ২৬ এর কোড:

package main

import "fmt"

const a = 10
var p = 100

//Closure
func outer(money int) func() {
	age := 30
	fmt.Println("Age =", age)

	show := func() {
		money = money + a + p
		fmt.Println(money)
	}

	return show
}

func call() {
	incr1 := outer(100)
	incr1() // money = 100 + 10 + 100 = 210
	incr1() // money = 210 + 10 + 100 = 320

	incr2 := outer(100)
	incr2()
	incr2()
}

func main() {
	call()
}

func init() {
	fmt.Println("=== Bank ===")
}

🔍 মূল বিষয়বস্তু

🔒ক্লোজার (Closure) কী?

ক্লোজার এমন একটি ফাংশন যা তার নিজস্ব স্কোপের বাইরের ভেরিয়েবলগুলোর সাথে সম্পর্ক স্থাপন করতে পারে। এই ক্ষেত্রে:

show := func() {
    money = money + a + p
    fmt.Println(money)
}

show ফাংশনটি outer() ফাংশনের ভেতরের money ভেরিয়েবলটি মনে রাখার মাধ্যমে একটি ক্লোজার তৈরি করে।

🧠 ক্লোজার কেন গুরুত্বপূর্ণ?

ক্লোজার যুক্তি ও অবস্থাকে একসাথে ধরে রাখতে সাহায্য করে। এজন্য incr1() এবং incr2() একই ফাংশন ব্যবহার করলেও আলাদা money মান ধরে রাখতে পারে।

🧮 স্ট্যাক বনাম হিপ

স্ট্যাক: দ্রুত মেমোরি, ফাংশন কল এবং লোকাল ভেরিয়েবলের জন্য ব্যবহৃত হয়।

হিপ: যখন ভেরিয়েবল ফাংশন কলের পরেও থাকা দরকার (যেমন ক্লোজারে), তখন ব্যবহৃত হয়।

money ফাংশন outer() শেষ হওয়ার পরও থাকতে হবে, তাই এস্কেপ অ্যানালাইসিস এটা বুঝে money হিপে রাখে।

🧪 এস্কেপ অ্যানালাইসিস (Escape Analysis) কী?

এস্কেপ অ্যানালাইসিস হলো একটি প্রক্রিয়া যার মাধ্যমে Go কম্পাইলার ফাংশনগুলো কম্পাইল করার সময় বুঝতে পারে কোন ভেরিয়েবল স্ট্যাকে নিরাপদে রাখা যাবে আর কোনগুলো হিপে পাঠাতে হবে।

• ✅ যদি কোনো ভেরিয়েবল শুধুমাত্র ফাংশনের ভেতর ব্যবহার হয়, তাহলে সেটি স্ট্যাকে রাখা হয়।
• 🚀 যদি কোনো ভেরিয়েবল ফাংশনের বাইরে (যেমন একটি রিটার্ন করা ক্লোজারে) ব্যবহার হয়, তাহলে সেটি হিপে স্থানান্তরিত হয়।

🧱 মেমোরি সেগমেন্ট

🧠 ভিজ্যুয়ালাইজেশন

CLI-স্টাইল মেমোরি বিন্যাস

┌─────────────────────────────┐
│       কোড সেগমেন্ট           │
│-----------------------------│
│ const a = 10,               |
| main, call, init, outer,    │
│ anonymous show function     │
└─────────────────────────────┘
          ↓
┌─────────────────────────────┐
│        ডেটা সেগমেন্ট          │
│-----------------------------│
│ var p = 100                 │
└─────────────────────────────┘
          ↓
┌─────────────────────────────┐
│            স্ট্যাক             │
│-----------------------------│
│ outer() frame               │
│   age = 30                  │
│   return address            │
└─────────────────────────────┘
          ↓
┌─────────────────────────────┐
│            হিপ              │
│-----------------------------│
│ money = 100 (for incr1)     │
│ money = 100 (for incr2)     │
└─────────────────────────────┘

প্রতিটি ক্লোজারের জন্য হিপে নিজস্ব money থাকে। প্রতিবার outer(100) কল করার সময় একটি নতুন মেমোরি ব্লক অ্যালোকেট করা হয়।

গারবেজ কালেক্টরের ভূমিকা 🧹

যখন কোনো ক্লোজার আর রেফারেন্স করা হয় না (যেমন incr1 বা incr2 স্কোপের বাইরে চলে যায়), তখন গারবেজ কালেক্টর সেই হিপ মেমোরি (যেমন money) মুছে ফেলে, যাতে অপ্রয়োজনীয় মেমোরি দখল না থাকে। অনেক ক্লোজার থাকলে কর্মদক্ষতা বজায় রাখতে এটা খুবই গুরুত্বপূর্ণ।

GC স্বয়ংক্রিয়ভাবে ট্রিগার হয় এবং প্রোগ্রামের সাথে একযোগে চলে। এটি কার্যকরভাবে কাজ করার জন্য mark-and-sweep এবং concurrent garbage collection techniques ব্যবহার করে।

🧠 সংক্ষেপে

• ক্লোজার ভেরিয়েবলের অবস্থা ধরে রাখতে পারে 🔁
• এস্কেপ অ্যানালাইসিস নির্ধারণ করে কোন ভেরিয়েবল হিপে রাখা প্রয়োজন 📦
• স্ট্যাক সাময়িক, হিপ স্থায়ী (GC 🧹 এর সাথে)
• Go মেমোরি চারটি ভাগে ভাগ করে: কোড, ডেটা, স্ট্যাক, হীপ 🧩
• GC অপ্রচলিত হীপ মেমোরি পুনর্ব্যবহারযোগ্য করে তোলে ♻️

[Author: @ifrunruhin12, @nazma98 Date: 2025-05-01 - 2025-05-17 Category: interview-qa/class-wise ]

ক্লাস ২৭: Go স্ট্রাক্ট এবং মেমোরি বিন্যাস 🧱

এই ক্লাসে আমরা স্ট্রাক্ট কীভাবে ডিফাইন ও ইন্সট্যানশিয়েট করতে হয়, এবং এগুলো কীভাবে Go এর মেমোরি মডেলের সাথে কাজ করে তা শিখব। 🧠💡

✍️ ক্লাস ২৭ এর কোড:

package main

import "fmt"

type User struct {
	Name string
	Age  int
}

func (usr User) printDetails() {
	fmt.Println("Name:", usr.Name)
	fmt.Println("Age:", usr.Age)
}

func main() {
	user1 := User{
		Name: "Ruhin",
		Age:  21,
	}

	user2 := User{
		Name: "Mukim",
		Age:  15,
	}

	user1.printDetails()
	user2.printDetails()
}

🧠 মূল ধারণা

🧩 স্ট্রাক্ট (Struct) কী?

Go তে স্ট্রাক্ট হলো একটি ইউজার ডিফাইন্ড টাইপ(user-defined type), যা ব্যবহারকারী নিজের মতো করে তৈরি করতে পারে, যাতে সম্পর্কিত ডেটা একসাথে রাখা যায়। এটি মূলত বিভিন্ন ফিল্ডের জন্য একটি কাস্টম কন্টেইনার।

type User struct {
	Name string
	Age  int
}

এটি User নামে একটি নতুন টাইপ ডিফাইন করে, যার ফিল্ড হলো Name এবং Age।

🔨 ইনস্ট্যান্স তৈরি (Instantiation)

যখন আমরা স্ট্রাক্ট টাইপ ব্যবহার করে একটি আসল মান তৈরি করি, সেটাই ইনস্ট্যান্সিয়েশন (Instantiation).।

user1 := User{
	Name: "Ruhin",
	Age:  21,
}

এখানে user1 হলো User টাইপের একটি ইনস্ট্যান্স। এটি Name এবং Age মানগুলো রাখার জন্য মেমোরি অ্যালোকেট করে।

🧠 মেমোরি লেআউট (ভিজ্যুয়ালাইজেশন)

┌─────────────────────────────┐
│       কোড সেগমেন্ট         │
│-----------------------------│
│ main, printDetails,         │
│ type User struct {...}      │
└─────────────────────────────┘
          ↓
┌─────────────────────────────┐
│       ডেটা সেগমেন্ট         │
│-----------------------------│
│ -                           │
│(গ্লোবাল ভেরিয়েবল থাকলে)    │
└─────────────────────────────┘
          ↓
┌─────────────────────────────┐
│           স্ট্যাক             │
│-----------------------------│
│ main() frame →              │
│   user1 → Name: "Ruhin"     │
│           Age: 21           │
│   user2 → Name: "Mukim"     │
│           Age: 15           │
└─────────────────────────────┘

⚠️ NOTE: If a struct is returned from a function or captured by a closure, it may escape to the heap instead of stack. ⚠️ নোট: যদি কোনো স্ট্রাক্ট ফাংশন থেকে রিটার্ন হয় বা ক্লোজারে ব্যবহার হয়, তাহলে এটি স্ট্যাকের বদলে হিপে স্থানান্তরিত হতে পারে।

📋 উদাহরণ

type Book struct {
	Title  string
	Author string
	Pages  int
}

book1 := Book{
	Title: "1984",
	Author: "George Orwell",
	Pages: 328,
}

এভাবে আমরা একাধিক তথ্য নিয়ে বাস্তব জীবনের মতো মডেল তৈরি করতে পারি।

🧹 গারবেজ কালেক্টরের ভূমিকা

• যদি কোনো স্ট্রাক্ট ইনস্ট্যান্স এস্কেপ করে (ফাংশনের বাইরে ব্যবহার হয়, দীর্ঘ সময় ধরে রাখা হয়), তাহলে Go সেটি হিপে রাখে।
• Go এর গারবেজ কালেক্টর তখন সেটি ট্র্যাক করে আর ব্যবহার না হলে মেমোরি ফাঁকা করে দেয়।
• তাই ম্যানুয়ালি free() করার দরকার নেই, Go নিজেই হিপের মেমোরি পরিচ্ছন্ন করে।

🚀 সংক্ষেপে

• type User struct {...} হলো টাইপের তথ্য → কোড সেগমেন্ট-এ থাকে।
• user1 := User{...} হলো রানটাইম ডেটা → স্ট্যাক বা হিপের রাখা হয় ব্যবহার অনুযায়ী।
• স্ট্রাক্ট একসাথে অনেক ফিল্ডকে একটি লজিক্যাল ইউনিটে গুছিয়ে রাখে ✅
• মেমোরি লেআউট ব্যবহার অনুসারে বদলায় → এস্কেপ অ্যানালাইসিসের সিদ্ধান্ত অনুসারে 📦🧳
• গারবেজ কালেক্টর শুধু হিপের মেমোরি পরিষ্কার করে, স্ট্যাক নয় 🧹

প্রশ্ন: স্ট্রাক্ট কি একটি ডেটাটাইপ?

উত্তর: হ্যাঁ, ১০০% — Go-তে স্ট্রাক্ট হলো ব্যবহারকারীর তৈরি একটি ডেটাটাইপ। এটা এমন একটা "ব্লুপ্রিন্ট" যেটা দিয়ে তুমি নিজের মতো করে ডেটা অবজেক্ট বানাতে পারো। 💡

কিভাবে:

-[] Go তে int, string, bool ইত্যাদির মতো প্রিমিটিভ ডেটা টাইপ থাকে। -[] তুমি struct ব্যবহার করে নিজের কাস্টম টাইপ তৈরি করতে পারো, যাতে একাধিক ফিল্ড একসাথে থাকে।

যেমন:

type User struct {
	Name string
	Age  int
}

এখন User নিজেই একটা ডেটাটাইপ এর মতো কাজ করবে, আর তুমি এর ইনস্ট্যান্স তৈরি করে কাজ করতে পারো ঠিক int বা string এর মতো:

var u User
u.Name = "Ruhin"
u.Age = 21

এটা এমন যেন তুমি নিজের মতো একটা লেগো ব্রিক তৈরি করছো, আর যত খুশি কপি বানাতে পারো। 🧱✨

তোমার Go প্রোগ্রাম এখন স্ট্রাকচার্ড! 😎 পরের বার ডেটা মডেল করলে নিজের টাইপ তৈরি করো আর মেমোরি সেগমেন্ট বুঝে কাজ করো!

[Author: @ifrunruhin12, @nazma98 Date: 2025-05-01 - 2025-05-17 Category: interview-qa/class-wise ]

ক্লাস ২৮: Go তে রিসিভার ফাংশন (Receiver Functions)

🔑 মূল ধারণা: : রিসিভার ফাংশন

Go তে, একটি রিসিভার ফাংশন (receiver function) (যাকে method ও বলা হয়) হলো এমন একটি ফাংশন যা কোনো নির্দিষ্ট টাইপ (সাধারণত struct) এর সাথে জুড়ে থাকে। এটা আমাদের ডেটাটাইপের কোনো কাজ বা ব্যবহার যুক্ত করার সুযোগ দেয়, যেমন অন্য প্রোগ্রামিং ভাষায় অবজেক্টের method থাকে।

🧠 রিসিভার ফাংশন কি?

একটা রিসিভার ফাংশন দেখতে সাধারণ ফাংশনের মতোই, কিন্তু func কী-ওয়ার্ড এবং ফাংশনের নামের মাঝে একটা বিশেষ receiver parameter থাকে।

func (r ReceiverType) FunctionName(params) returnType {
    // function body
}

রিসিভার টাইপটি হতে পারে:

• একটি ভ্যালু রিসিভার (value receiver): (t Type) → একটি কপি রিসিভ করে
• একটি পয়েন্টার রিসিভার (pointer receiver): (t *Type) → একটি রেফারেন্স রিসিভ করে (অরিজিনাল ডেটা পরিবর্তন করতে পারে)

🏗️ প্রোজেক্টের কোড থেকে দেখতে পাই

func (todos *Todos) add(title string) {
    todo := Todo{
        Title: title,
        Completed: false,
        CompletedAt: nil,
        CreatedAt: time.Now(),
    }
    *todos = append(*todos, todo)
}

হলো রিসিভার এই মেথড টি এর সাথে এটাচড

• todos *Todos হলো রিসিভার
• এই method টি Todos এর সাথে যুক্ত ([]Todo: একটি কাস্টম টাইপ)
• *Todos পয়েন্টারটি অরিজিনাল স্লাইসকে পরিবর্তন করতে দেয়

main.go এ ব্যবহারের উদাহরণ:

todos.add("Buy milk")

🔁 রিসিভার ফাংশন কেন ব্যবহার করব?

• ডেটার সাথে সম্পর্কিত লজিক গুছিয়ে রাখা ✅
• Go-তে OOP-এর মতো আচরণ পাওয়া ✅
• কোডকে আরও পরিষ্কার ও মডুলার রাখা ✅

💡 আরও সহজ উদাহরণ

type User struct {
    Name string
}

// Value receiver (no change to original)
func (u User) SayHi() {
    fmt.Println("Hi, I am", u.Name)
}

// Pointer receiver (can change original)
func (u *User) ChangeName(newName string) {
    u.Name = newName
}

func main() {
    user := User{Name: "Ruhin"}
    user.SayHi() // Hi, I am Ruhin
    user.ChangeName("Mukim")
    user.SayHi() // Hi, I am Mukim
}

⚙️ ⚙️ সারাংশ

📘 ভিজ্যুয়ালাইজেশন

todos.add()কে অবজেক্টের কোনো কাজ বা আচরণ কল করার মতো ভাবা যেতে পারে:

object.method()

এই প্যাটার্নটি Todos কে কাস্টম লজিক যোগ করার সুযোগ দেয়, যেমন add, delete, toggle, print ইত্যাদি, ঠিক Python বা Java-এর ক্লাস মেথডের মতো।

[Author: @ifrunruhin12, @nazma98 Date: 2025-05-01 - 2025-05-17 Category: interview-qa/class-wise ]

ক্লাস ২৯ - অ্যারে (Array) এবং মেমোরি লেআউট

📅 Date: April 24, 2025

🔑 মূল বিষয়বস্তু

✅ অ্যারে (Array) কী?

• অ্যারে হলো এক ধরনের ডেটা স্ট্রাকচার, যেখানে নির্দিষ্ট সাইজের একই টাইপের একাধিক উপাদান (Element) থাকে।
• Go তে, অ্যারে হলো value type, যার মানে হলো, ফাংশনে পাস করলে এর কপি তৈরি হয়।

🧠 Go তে অ্যারে

var arr [2]int       // ২ টি ইন্টিজারের একটি ডিক্লেয়ার করে যার ডিফল্ট ভ্যালু: [0, 0]
arr[0] = 3           // ইনডেক্স ব্যবহার করে ভ্যালু এসাইন করে
arr[1] = 6

// সংক্ষেপে ভ্যালুসহ অ্যারে ডিক্লেয়ার করা
arr := [2]int{3, 6}

💡 ইনডেক্সিং

• Go অ্যারে জিরো-ইনডেক্সড, অর্থাৎ প্রথম উপাদান array[0] দিয়ে অ্যাক্সেস করা হয়।

⚙️ ডিফল্ট মান (Default Value)

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

• যদি অ্যারে ডিক্লেয়ার করা হয় কিন্তু ইনিশিয়ালাইজ না করা হয়, Go কিছু ডিফল্ট ভ্যালু সেট করে:
  • int, float ইত্যাদির জন্য 0
  • string এর জন্য "" (ফাঁকা স্ট্রিং)
  • bool এর জন্য false
  • pointers/interfaces এর জন্য nil

🔍 মেমোরি লেআউট ভিজ্যুয়ালাইজেশন

উদাহরণ:

arr := [2]int{3, 6}

মেমোরি লেআউট

নোট: আসল এড্রেস এখানে কল্পনা করা হয়েছে। মূল ধারণা হলো, অ্যারের সব উপাদান মেমোরিতে একসাথে (contiguously) সংরক্ষিত থাকে।

আরেকটি উদাহরণ:

arr2 := [3]string{"I", "love", "you"}

arr2[1] এক্সেস করলে "love" রিটার্ন করে।

🧪 ক্লাসের কোড উদাহরণসহ

package main

import "fmt"

var arr2 = [3]string{"I", "love", "you"}

func main() {
    arr := [2]int{3,6}
    fmt.Println(arr)
    fmt.Println(arr2)
    fmt.Println(arr2[1])
}

📦 সারাংশ

• অ্যারে নির্দিষ্ট সাইজের ডেটা সংরক্ষণে ভালো।
• ডিফল্ট মান সম্পর্কে সচেতন থাকুন।
• মেমোরিতে একসাথে (contiguously) সংরক্ষিত থাকে।
• Go তে অ্যারের সাথে কাজ করা সহজ, যা স্লাইসে যাওয়ার আগে ভালো ভিত্তি তৈরি করে।

[Author: @ifrunruhin12, @nazma98 Date: 2025-05-01 - 2025-05-17 Category: interview-qa/class-wise ]

ক্লাস ৩০: Go পয়েন্টার

পয়েন্টার কি?

পয়েন্টার হলো এমন একটি ভেরিয়েবল যা আরেকটি ভেরিয়েবলের মেমোরি এড্রেস সংরক্ষণ করে।

Go তে মেমোরি কয়েকটি ভাগে বিভক্ত থাকে। যেমন:

• কোড সেগমেন্ট: কম্পাইল করা প্রোগ্রামের নির্দেশনা (ফাংশন) সংরক্ষণ করে।
• ডেটা সেগমেন্ট: গ্লোবাল/স্ট্যাটিক ভেরিয়েবল এবং কনস্ট্যান্ট সংরক্ষণ করে।
• স্ট্যাক: লোকাল ভেরিয়েবল এবং ফাংশন কলের তথ্য সংরক্ষণ করে।
• হিপ: ডায়নামিকালি অ্যালোকেট করা মেমোরি সংরক্ষণ করে।

পয়েন্টারের মাধ্যমে সরাসরি মেমোরি এড্রেসের সাথে কাজ করা যায়।

গুরুত্বপূর্ণ চিহ্নগুলো:

• & (Ampersand): ভেরিয়েবলের এড্রেস পেতে ব্যবহার হয়।
• * (Star/Dereference operator): মেমোরি এড্রেসে থাকা মান পেতে ব্যবহার হয়।

উদাহরণ:

x := 20
p := &x // p ভেরিয়েবল, x এর এড্রেস রাখে

*p = 30 // এড্রেস p তে থাকা মান (x) পরিবর্তন করে

fmt.Println(x)  // 30
fmt.Println(p)  // x এর এড্রেস
fmt.Println(*p) // 30 (এড্রেসে থাকা মান)

পয়েন্টার কেন ব্যবহার করবেন?

• ইফিসিয়েন্সি (Efficiency): বড় স্ট্রাকচার (যেমন অ্যারে) কপি না করে শুধুমাত্র তাদের মেমোরি এড্রেস পাস করা যায়।
• শেয়ারড মডিফিকেশন (Shared Modification): যখন একাধিক ফাংশনকে একই ডেটা পরিবর্তন করতে হয়।
• মেমোরি ম্যানেজমেন্ট (Memory Management): লো-লেভেল বা হাই-পারফরম্যান্স প্রোগ্রামিংয়ে বিশেষভাবে গুরুত্বপূর্ণ।

পয়েন্টার ছাড়া, প্রতিটি ফাংশন কলের সময় পুরো অবজেক্ট কপি করতে হতো। এটা ধীর গতির এবং মেমোরি অপচয় করে!

পাস বাই ভ্যালু (Pass by Value) vs পাস বাই রেফারেন্স (Pass by Reference)

পাস বাই ভ্যালু (Pass by Value):

• ভেরিয়েবলের একটি কপি পাস করা হয়।
• ফাংশনের ভেতরে পরিবর্তন অরিজিনাল ভেরিয়েবলকে প্রভাবিত করে না।

func print(numbers [3]int) {
	fmt.Println(numbers)
}

arr := [3]int{1, 2, 3}
print(arr) // একটি কপি পাস

পাস বাই রেফারেন্স (Pass by Reference):

• কপি না করে ভেরিয়েবলের এড্রেস পাস করা হয়।
• ফাংশনের ভেতরে করা পরিবর্তন অরিজিনাল ভেরিয়েবলকে প্রভাবিত করে।

func print2(numbers *[3]int) {
	fmt.Println(numbers)
}

arr := [3]int{1, 2, 3}
print2(&arr) // একটি পয়েন্টার পাস

স্ট্রাক্ট পয়েন্টার (and why Go is chill with them)

যখন স্ট্রাক্ট এ পয়েন্টার থাকে, Go বার বার * (dereference) করার পরিবর্তে নিজেই বুঝে নিয়ে field access দেয়।

user1 := User{
	Name: "Ruhin",
	Age: 21,
	Salary: 0,
}
p2 := &user1
fmt.Println(p2.Age) // no need to write (*p2).Age

Go নিজে থেকে pointer কে dereference করে field টা দেয়। অসাধারণ, তাই না?

Full Code Example from Class:

package main

import "fmt"

type User struct {
	Name   string
	Age    int
	Salary float64
}

func print(numbers [3]int) {
	fmt.Println(numbers)
}

func print2(numbers *[3]int) {
	fmt.Println(numbers)
}

func main() {
	x := 20
	p := &x
	*p = 30

	fmt.Println(x)           // 30
	fmt.Println("Address:", p)
	fmt.Println("Value:", *p)

	arr := [3]int{1, 2, 3}
	print(arr)   // pass by value
	print2(&arr) // pass by reference

	user1 := User{
		Name:   "Ruhin",
		Age:    21,
		Salary: 0,
	}
	p2 := &user1
	fmt.Println(p2.Age)
}

মেমরি লেআউটের ভিজ্যুয়ালাইজেশন (CLI)

+--------------------+----------------------------------+
| সেগমেন্ট             |  কি আছে                 |
+--------------------+----------------------------------+
| Code Segment       | main(), print(), print2()        |
| Data Segment       | (এখানে কোনো গ্লোবাল ভ্যারিয়েবল নেই)       |
| Stack              | arr [3]int {1,2,3}, x=30         |
|                    | p (pointer to x)                 |
|                    | user1 (User struct)              |
|                    | p2 (pointer to user1)            |
| Heap               | (এই প্রোগ্রামে ব্যবহার হয়নি) |
+--------------------+----------------------------------+

বিস্তারিত মেমরি ভিজ্যুয়ালাইজেশন (এড্রেস এবং মানসহ)

Stack Memory:

[ Address 0x1000 ] x = 30
[ Address 0x1004 ] p -> 0x1000 (address of x)
[ Address 0x1008 ] arr = [1, 2, 3]
[ Address 0x1010 ] user1 = {"Ruhin", 21, 0.0}
[ Address 0x1018 ] p2 -> 0x1010 (address of user1)

Code Segment:
- Compiled code of main, print, print2

Data Segment:
-  খালি (কোন গ্লোবাল ভ্যারিয়েবল নেই)

Heap:
- এই প্রোগ্রামে ব্যবহার হয়নি

আরও উদাহরণ: পয়েন্টার ব্যবহার করে দুইটি নম্বর বিনিময় (Swap) করা

পয়েন্টার ছাড়া (FAIL):

func swap(x, y int) {
	temp := x
	x = y
	y = temp
}

func main() {
	a, b := 1, 2
	swap(a, b)
	fmt.Println(a, b) // still 1 2
}

পয়েন্টার ব্যবহার করে (WIN):

func swap(x, y *int) {
	temp := *x
	*x = *y
	*y = temp
}

func main() {
	a, b := 1, 2
	swap(&a, &b)
	fmt.Println(a, b) // 2 1
}

সংক্ষিপ্ত সারাংশ

• & দিয়ে ভেরিয়েবলের ঠিকানা পাওয়া যায়।
• * দিয়ে ঠিকানায় থাকা মান পাওয়া যায়।
• Pointers = efficient + powerful
• struct pointer থাকলে Go নিজে থেকে field access দেয়, আলাদা dereference করার দরকার নেই।
• বড় ডেটা (array, struct) পাস করার সময় পয়েন্টার ব্যবহার করে মেমোরি সেভ করা যায়।

Bro Tip:

When in doubt, think: "Am I copying a whole dang castle, or just giving a map to it?"

Pointers = the map. ✅

[Author: @ifrunruhin12, @nazma98 Date: 2025-05-01 - 2025-05-17 Category: interview-qa/class-wise ]

📚 Class 31 : Go Slice

🚀 Main Topics

• Slice কী?
• একটি Slice এ কয়টি অংশ থাকে?
• Slice এর Pointer, Length, এবং Capacity নির্ণয় করা
• বিদ্যমান Array থেকে Slice তৈরি
• বিদ্যমান Slice থেকে নতুন Slice তৈরি
• Slice Literal (সরাসরি ঘোষণা)
• make() দিয়ে Slice তৈরি (শুধু length)
• make() দিয়ে Slice তৈরি (length এবং capacity)
• খালি বা Nil Slice তৈরি
• Slice এ নতুন element যোগ করা (append)
• append করার সময় অভ্যন্তরীণ প্রক্রিয়া (Heap এবং Underlying Array)
• Underlying Array কীভাবে dynamic ভাবে বাড়ে
• কিছু মজার উদাহরণ এবং ইন্টারভিউ প্রশ্ন
• Variadic Functions

🧠 ১. Slice কী?

• Slice হলো Go এর একটি flexible data structure।
• এটি মূলত array এর উপরে নির্মিত একটি dynamic view।
• array এর মত হলেও, slice এর সাইজ পরিবর্তন করা যায় (বড় বা ছোট করা যায়)।

মূল পয়েন্ট:

• Slice, array নয়।
• Slice, array এর উপরে তৈরি হয়।

🔥 ২. একটি Slice এর কয়টি অংশ থাকে?

Slice মূলত একটি struct যা তিনটি অংশ নিয়ে গঠিত:

struct Slice {
    pointer *T // points underlying array
    length  int // current elements number
    capacity int // maximum elements (until reallocation)
	}

Slice কে মূলত একটি array এর "window" হিসেবে ভাবা যেতে পারে।

🕵️‍♂️ ৩. Pointer, length এবং capacity নির্ধারণ করার উপায়

নিম্নোক্ত built-in ফাংশন ব্যবহার করে Slice এর length এবং capacity বের করা যায়:

• len(slice) ➡️ Length
• cap(slice) ➡️ Capacity

উদাহরণ:

s := arr[1:4] // index 1 to 3
fmt.Println(len(s)) // 3
fmt.Println(cap(s)) //  index 1 to end of the array

🏗 ৪. Array থেকে Slice তৈরি করা

arr := [6]string{"This", "is", "a", "Go", "interview", "Questions"}
s := arr[1:4] // slice ["is", "a", "Go"]

• pointer: arr এর index 1 নির্দেশ করে
• length: 3 (index 1 to 3)
• capacity: 5 (index 1 to 5)

🔄 ৫. Slice থেকে নতুন Slice তৈরি

s1 := s[1:2] // Slice "a"

• s1 Slice টি একই Array এর একটি view!
• s1 পরিবর্তন করলে arr এর মানও পরিবর্তিত হতে পারে।

✍️ 6. Slice Literal

একটি Slice তৈরি করতে সরাসরি মান ব্যবহার করা যায়, আলাদা করে Array তৈরি করার প্রয়োজন নেই।

s2 := []int{3, 4, 7}

এখানে Go automatically একটি underlying Array তৈরি করে।

🏗️ ৭. make() দিয়ে একটি Slice তৈরি করা

s3 := make([]int, 3)

• make() দিয়ে ৩টি শূন্য মান (zero) সহ একটি Slice তৈরি করে। অর্থাৎ, ৩টি empty element থাকবে।
• len = 3, cap = 3

🏗️🏗️ ৮. make() দিয়ে একটি Slice তৈরি করা (length এবং capacity)

s4 := make([]int, 3, 5)

• len = 3, কিন্তু capacity cap = 5 পর্যন্ত হতে পারে reallocation এর আগ পর্যন্ত

🕳 9. Empty / Nil Slice তৈরি

var s5 []int

• len = 0, cap = 0
• Still valid! এতে নতুন element যোগ (append) করা যাবে।

➕ ১০. Slice এ নতুন element append করা

s6 := append(s6, 1)

• Go নিজে থেকে underlying Array বড় করে।
• অনেক বড় Array তৈরি এবং আগের element গুলো copy করার কাজও করে থাকে।

🧬 ১১. append করার সময় আসলে কী হয়?

যখন একটি Slice এর capacity পূর্ণ হয়:

• একটি নতুন Array (সাধারণত দ্বিগুণ সাইজের) তৈরি করা হয়।
• আগের Array এর সমস্ত elements নতুন Array তে কপি করা হয়।

এ কারণেই কখনও কখনও append করা দ্রুত মনে হয় এবং কখনও বড় মেমরি অপারেশন তৈরি করতে পারে।

📈 ১২. Underlying Array কিভাবে বৃদ্ধি পায়:

যে প্যাটার্নে capacity পায় (Capacity Growth Pattern): (simplified)

• Cap 1 ➡️ 2 ➡️ 4 ➡️ 8 ➡️ 16 ➡️ ...

এটি একটি optimization technique যা নিশ্চিত করে যেন append অপারেশনগুলো গড়ে O(1) সময়ে সম্পন্ন হয়।

Go Slice বৃদ্ধি: len এবং cap এর dynamics বোঝা

Go Slice একটি শক্তিশালী এবং flexible data structure, যা dynamic Array এর মতো কাজ করে। এর একটি মূল বৈশিষ্ট্য হলো, যখন নতুন element যোগ করা হয়, তখন Slice নিজে নিজেই বৃদ্ধি পায়। Slice কীভাবে এবং কখন বৃদ্ধি পায়, আর এর মেমরি অ্যালোকেশনের পদ্ধতি বুঝলে অনেক efficient program design করা সম্ভব।

এখন আমরা Go Slice এর বৃদ্ধির পদ্ধতি বিশ্লেষণ করব:

• যদি Slice এর len এবং cap 1024-এর কম হয়, তাহলে এটি সাধারণত দ্বিগুণ (2x) বৃদ্ধি পায়।
• len এবং cap, 1024 ছাড়িয়ে গেলে, এটি প্রায় 25% হারে বৃদ্ধি পায়।
• Slice কেন নির্দিষ্ট পরিমাণে (যেমন 1024 থেকে 1280) না বাড়িয়ে বড় ব্লকে (যেমন 1536) বাড়ে, সেটিও ব্যাখ্যা করা হবে।

Slice Growth Overview

Go তে slice মূলত array এর উপরে ভিত্তি করে কাজ করে। যখন একটি slice এ নতুন element append করা হয়, তখন প্রয়োজনে Go একটি বড় array তৈরি করে এবং পুরানো element গুলো তাতে কপি করে। এই প্রসেসটি নির্ভর করে Go কিভাবে নতুন capacity নির্ধারণ করে এবং মেমরি allocate করে।

১২.১. ছোট Slice এর ক্ষেত্রে দ্বিগুণ বৃদ্ধি (len(cap) < 1024)

যখন slice ছোট থাকে (অর্থাৎ, এর len এবং cap দুটোই 1024 এর কম), তখন Go সাধারণত capacity দ্বিগুণ করে। এর মানে, যখন slice এ একটি element যোগ করা হয় এবং নতুন মেমরি প্রয়োজন হয়, তখন Go আগের capacity এর দ্বিগুণ আকারের একটি নতুন array তৈরি করে এবং পুরানো element গুলো সেখানে কপি করে। Slice এর len ১ বাড়বে, কিন্তু cap দ্বিগুণ হবে।

উদাহরণ:

s := []int{1, 2, 3}
fmt.Println(len(s), cap(s)) // len: 3, cap: 3

s = append(s, 4)
fmt.Println(len(s), cap(s)) // len: 4, cap: 6

s = append(s, 5)
fmt.Println(len(s), cap(s)) // len: 5, cap: 6

• প্রথমে, slice এর len ৩ এবং cap ৩ থাকে।
• চতুর্থ element যোগ করার সময়, slice এর capacity ৩ থেকে দ্বিগুণ হয়ে ৬ হয়ে যায়।
• পরবর্তী অ্যাপেন্ডে, slice এর capacity ৬ ই থাকবে কারণ len < cap।

১২.২. বড় Slice এর ক্ষেত্রে ২৫% বৃদ্ধি (len(cap) >= 1024)

যখন slice এর len এবং cap 1024 বা তার বেশি হয়, তখন Go দ্বিগুণের পরিবর্তে বর্তমান capacity এর ২৫% বৃদ্ধি করে। এই কৌশলটি ঘন ঘন মেমরি reallocation এড়াতে এবং অপ্রয়োজনীয় মেমরি অপচয় কমাতে সহায়তা করে।

উদাহরণ:

s := make([]int, 1024)  // len: 1024, cap: 1024
fmt.Println(len(s), cap(s))

s = append(s, 1025) // len: 1025, cap: 1280 (1024 + 25% of 1024)
fmt.Println(len(s), cap(s))

s = append(s, 1300) // len: 1300, cap: 1600 (1280 + 25% of 1280)
fmt.Println(len(s), cap(s))

• শুরুতে, আমরা length এবং capacity 1024 সহ একটি slice তৈরি করি।
• পরের element append করলে slice এর capacity 1024 থেকে 1280 হয়, যা 1024 এর সাথে ২৫% যোগ করে পাওয়া যায়।
• আরেকটি element append করলে capacity 1600 হয় (1280 এর সাথে ২৫% যোগ করে)।

১২.৩. মেমরি ব্লকের ভূমিকা (যেমন, 1536 ক্ষমতার Slice)

যখন slice এর len এবং cap 1024 এর কাছাকাছি বা তার বেশি হয়, তখন Go সর্বদা নিখুঁত গণনা অনুযায়ী মেমরি বরাদ্দ করে না। এর পরিবর্তে এটি সিস্টেম মেমরি বরাদ্দের ধরণ অনুযায়ী Optimal Memory Block ব্যবহার করে।

উদাহরণস্বরূপ, যদি একটি slice এর capacity 1024 এর কাছাকাছি থাকে, পরবর্তী বরাদ্দ সরাসরি 256 যোগ করে 1280 না হয়ে, এর থেকে বড় 1536 এর মতো ব্লকে হতে পারে। এটি বড় মেমরি ব্লকের জন্য আরও কার্যকর মেমরি ব্যবহারে সহায়তা করে।

কেন 1536 এর পরিবর্তে 1280?

এটি মূলত Hardware Memory Alignment এর উপর নির্ভর করে। 1536 সংখ্যাটি বেছে নেওয়া হয় কারণ এটি সাধারণত 2-এর গুণিতক আকারের মেমরি ব্লকের সাথে ভালোভাবে মিলে যায় এবং আধুনিক CPU এবং মেমরি সিস্টেমের জন্য optimize করা। মেমরি অ্যালোকেশন সাধারণত সিস্টেমের memory page size বা cache line এর সাথে সামঞ্জস্য রেখে বড় ব্লকে করা হয়, যা মেমরি অ্যাক্সেসকে আরও ইফিশিয়েন্ট করে তোলে।

উদাহরণ (memory alignment):

s := make([]int, 1024) // len: 1024, cap: 1024
fmt.Println(len(s), cap(s)) // 1024, 1024

s = append(s, 1025) // len: 1025, cap: 1536 (next optimal block size)
fmt.Println(len(s), cap(s)) // 1025, 1536

• 1024 থেকে 1536 এ capacity বৃদ্ধি হয়, কারণ 1536 একটি বেটার মেমরি ব্লক যা সিস্টেমের ইফিশিয়েন্ট মেমরি অ্যালোকেশন করে।

১২.৪. কেন এমন হয়?

efficiency considerations Go সরাসরি 256 করে বৃদ্ধি করে না (যেমন আমরা মনে করি 1024 থেকে 1280)। কারণ এটি ইফিশিয়েন্সি বৃদ্ধির জন্য গুরুত্বপূর্ণ। এই অ্যালোকেশন স্ট্র্যাটেজির ফলে ঘন ঘন রি-অ্যালোকেশন এড়ানো যায় এবং অপ্রয়োজনীয় মেমরি অপচয় কমে যায়। বরং বড় ব্লকে (1536) মেমরি বরাদ্দ করে Go রানটাইম নিশ্চিত করে Sliceে পর্যাপ্ত capacity আছে আরও element এপেন্ড করার জন্য এবং খুব তাড়াতাড়ি Sliceকে বাড়াতে হবে না।

এর ফলে আরও ভালো performance পাওয়া যায়, বিশেষ করে যখন slice দ্রুত বৃদ্ধি পায়।

Conclusion

Go-এর slice বৃদ্ধি কৌশল অনেক ইফিশিয়েন্ট কোড লিখা সম্ভব। ছোট সাইজের slice এর ক্ষেত্রে, Go capacity দ্বিগুণ করে যাতে কম রি-অ্যালোকেশনে আরও element ধারণ করতে পারে। বড় slice (1024 এবং এর বেশি) হলে, এটি capacity ২৫% বৃদ্ধি করে এবং মাঝে মাঝে অপ্টিমাল মেমরি ব্লকের সাথে সামঞ্জস্য রাখে। এই পদ্ধতিটি slice কে দ্রুত এবং মেমরি সাশ্রয়ী করে তোলে।

🤯১৩. কিছু ইন্টারেস্টিং ইন্টারভিউ প্রশ্নের উদাহরণ

⚡ Some Underlying Array Trick

var x []int
x = append(x, 1)
x = append(x, 2)
x = append(x, 3)

y := x
x = append(x, 4)
y = append(y, 5)

x[0] = 10
fmt.Println(x)
fmt.Println(y)

-x এবং y একই backing array শেয়ার করে

• একটিতে পরিবর্তন (mutation) করলে দুটোরই মান পরিবর্তিত হতে পারে।

কিন্তু cap অতিক্রম করে অ্যাপেন্ড করলে, তারা আলাদা Array তে বিভক্ত হতে পারে।

🛠 ১৪. Variadic Functions

কোন ফাংশন ... (ellipsis) operator ব্যবহার করে অসংখ্য argument receive করতে পারে।

func variadic(numbers ...int) {
    fmt.Println(numbers)
}

variadic(2, 3, 4, 6, 8, 10)

এখানে numbers কিন্তু একটি slice!

🧠 RAM এ Slice এর visualization (arr এবং s এর জন্য)

Array arr (indexes):
[0] "This"
[1] "is"  <- s.ptr points here
[2] "a"
[3] "Go"
[4] "interview"
[5] "Questions"

Slice s:
- ptr = &arr[1]
- len = 3 ("is", "a", "Go")
- cap = 5 (from "is" to "Questions")

Memory Visualization:

+----+--+-+--+---------+---------+
|This|is|a|Go|interview|Questions|
+----+--+-+--+---------+---------+
       ^ ^  ^
     s[0] s[1] s[2]

📄 Full Code with Detailed Comments

package main

import "fmt"

func main() {
	// Create an array of strings
	arr := [6]string{"This", "is", "a", "Go", "interview", "Questions"}
	fmt.Println(arr)

	// Create a slice from array indexes 1 to 3 (exclusive of 4)
	s := arr[1:4]
	fmt.Println(s) // [is a Go]

	// Create a slice from a slice
	s1 := s[1:2]
	fmt.Println(s1) // [a]
	fmt.Println(len(s1)) // 1
	fmt.Println(cap(s1)) // 4 (capacity depends on the underlying array)

	// Slice literal
	s2 := []int{3, 4, 7}
	fmt.Println("slice", s2, "lenght:", len(s2), "capacity:", cap(s2))

	// make() function with length only
	s3 := make([]int, 3)
	s3[0] = 5
	fmt.Println(s3)
	fmt.Println(len(s3))
	fmt.Println(cap(s3))

	// make() function with length and capacity
	s4 := make([]int, 3, 5)
	s4[0] = 5
	fmt.Println(s4)
	fmt.Println(len(s4))
	fmt.Println(cap(s4))

	// Empty slice
	var s5 []int
	fmt.Println(s5) // []

	// Appending elements to empty slice
	var s6 []int
	s6 = append(s6, 1)
	fmt.Println(s6) // [1]

	var s7 []int
	s7 = append(s7, 1, 2, 3)
	fmt.Println(s7, len(s7), cap(s7)) // [1 2 3] 3 3

	// Interview question: Sharing underlying array
	var x []int
	x = append(x, 1)
	x = append(x, 2)
	x = append(x, 3)

	y := x
	x = append(x, 4)
	y = append(y, 5)

	x[0] = 10

	fmt.Println(x) // [10 2 3 5]
	fmt.Println(y) // [10 2 3 5]

	// Another interview question
	slc := []int{1, 2, 3, 4, 5}
	slc = append(slc, 6)
	slc = append(slc, 7)

	slcA := slc[4:]

	slcY := changeSlice(slcA)

	fmt.Println(slc)  // [1 2 3 4 10 6 7]
	fmt.Println(slcY) // [10 6 7 11]
	fmt.Println(slc[0:8]) // [1 2 3 4 10 6 7 11]

	// Variadic function call
	variadic(2, 3, 4, 6, 8, 10)
}

// Function that changes the slice passed
func changeSlice(a []int) []int {
	a[0] = 10
	a = append(a, 11)
	return a
}

// Variadic function that takes multiple integers
func variadic(numbers ...int) {
	fmt.Println(numbers)
	fmt.Println(len(numbers))
	fmt.Println(cap(numbers))
}

[Author: @ifrunruhin12, @nazma98 Date: 2025-05-01 - 2025-05-18 Category: interview-qa/class-wise ]

Class 36:কম্পিউটার আর্কিটেকচার এবং ইতিহাস

🕰️ কম্পিউটার ইতিহাসের সংক্ষিপ্ত বিবরণ

মানুষ তার কাজকে সহজ করতে যন্ত্র উদ্ভাবন করেছে, আর এরই ধারাবাহিকতায় এসেছে কম্পিউটার।

• ২৭০০ খ্রিস্টপূর্বে, প্রথম গণনা যন্ত্র Abacus আবিষ্কৃত হয়। এটি কাঠ বা বাঁশের তৈরি একটি ফ্রেমে রাখা গুটির মাধ্যমে কাজ করত।

• ১৭০৩ সালে, Gottfried Wilhelm Leibniz সর্বপ্রথম Binary Number System আবিষ্কার করেন, যা কম্পিউটারের ভিত্তি গড়ে দেয়।

• ১৮৩৭ সালে, Charles Babbage আবিষ্কার করেন পৃথিবীর প্রথম মেকানিক্যাল কম্পিউটার, যার নাম Analytical Engine।
  এজন্য তাকে Father of the Computer বলা হয়।

🧾 Analytical Engine এবং Punch Card

• Analytical Engine-এ ইনপুট দেয়ার জন্য Punch Card ব্যবহার করা হতো।
• এটি একধরনের শক্ত কাগজ যেটাতে গর্ত করে তথ্য encode করা হতো।
• গর্তের উপস্থিতি এবং অনুপস্থিতির ভিত্তিতে কম্পিউটার বুঝত কোন নির্দেশনা দেয়া হচ্ছে।

👩‍💻 বিশ্বের প্রথম প্রোগ্রামার

Ada Lovelace (১৮১৫–১৮৫২) ছিলেন বিশ্বের প্রথম প্রোগ্রামার।
তিনি ১৮৪৩ সালে Charles Babbage-এর Analytical Engine-এর জন্য একটি অ্যালগরিদম লিখেন, যেটি Bernoulli Numbers গণনা করতে পারত।

🧠 Theoretical Computer Science এর জনক

Alan Turing কে বলা হয় Father of Theoretical Computer Science।

Alan Turing-কে Father of Theoretical Computer Science বলা হয় কারণ তিনি কম্পিউটারের theoretical foundation গড়ে তোলেন এবং Turing Machine ধারণা দেন। যেগুলোর ভিত্তিতেই আধুনিক কম্পিউটার বিজ্ঞান দাঁড়িয়ে আছে।

১. Turing Machine (1936)

Turing Machine ছিল একটি কল্পিত যন্ত্র, যা নির্দিষ্ট নিয়মে ইনপুট পেলে যে কোনো গণনাযোগ্য সমস্যার সমাধান করতে পারত। এটি প্রথম বুঝিয়ে দেয়:

• কোন সমস্যাগুলো কম্পিউটারে সমাধানযোগ্য (computable)
• আর কোন সমস্যাগুলো সমাধানযোগ্য নয় (non-computable)

এই ধারণা থেকেই আধুনিক কম্পিউটার ও অ্যালগরিদম ডিজাইনের ভিত্তি তৈরি হয়েছে।

📌 উদাহরণ: আজকের সফটওয়্যার, কোড, প্রোগ্রাম - সবই Turing Machine-এর theoretical foundation এর উপর তৈরি।

২. Computability Theory জন্ম

Turing-এর গবেষণা থেকেই তৈরি হয় Computability Theory। এই শাখা ঠিক করে দেয়:

• কোন কাজগুলো কম্পিউটারে করা সম্ভব,
• কোন কাজগুলো অসম্ভব।

এই শাখাই ছিল Theoretical Computer Science এর মূল ভিত্তি।

৩. কোড ব্রেকিং ও কৃত্রিম বুদ্ধিমত্তার সূচনা

• দ্বিতীয় বিশ্বযুদ্ধে Turing জার্মানির Enigma Code ভাঙার জন্য একটি মেশিন (Bombe) তৈরি করেন। এটি আধুনিক কম্পিউটারের ধারণা বাস্তবে রূপ দিতে সহায়তা করে।

• তিনি একটি বিখ্যাত প্রশ্ন করেন:

  "Can machines think?"

  এই প্রশ্ন থেকেই Artificial Intelligence (AI) এর ধারণার সূচনা হয়।

Alan Turing শুধু একজন গাণিতিক বিজ্ঞানী ছিলেন না, তিনি ছিলেন ভবিষ্যতের প্রযুক্তির দিকদর্শক। তার চিন্তাধারা এবং তাত্ত্বিক মডেলগুলো আজকের পুরো কম্পিউটার বিজ্ঞানের ভিত্তি।

এই কারণেই তাঁকে বলা হয়: "Father of Theoretical Computer Science"

💡 প্রথম ইলেকট্রনিক কম্পিউটার

• ১৯৪৫ সালে, ENIAC (Electronic Numerical Integrator and Computer) তৈরি করা হয়।
• এটি ছিল বিশ্বের প্রথম ইলেকট্রনিক জেনারেল-পারপাস কম্পিউটার।
• এতে Vacuum Tube ব্যবহৃত হতো, যা অনেক বড় ও গরম হতো।

কিভাবে বিশাল আকৃতির কম্পিউটার ছোট হলো?

প্রথম দিকের কম্পিউটারগুলো যেমন ENIAC, সেগুলো তৈরি হতো Vacuum Tube দিয়ে। এগুলোর আকার ছিল বিশাল, অনেক বিদ্যুৎ খরচ হতো এবং খুব গরম হয়ে যেত। অনেক সময় একটি ছোট সমস্যার জন্য পুরো মেশিন বন্ধ হয়ে যেত। তাই, বিজ্ঞানীরা খুঁজছিলেন এমন কোনো প্রযুক্তি যা:

• আকারে ছোট হবে,
• কম বিদ্যুৎ খরচ করবে,
• কম তাপ উৎপন্ন করবে,
• এবং নির্ভরযোগ্যভাবে কাজ করবে।

এই প্রয়োজন থেকেই শুরু হয় কম্পিউটারের বিবর্তনের যাত্রা।

পরিবর্তনের ধাপসমূহ:

১. Transistor (1947):

Vacuum Tube-এর বিকল্প হিসেবে Transistor আবিষ্কৃত হয়। এটি ছিল একধরনের ছোট ইলেকট্রনিক যন্ত্রাংশ, যেটি একই কাজ করতে পারতো অনেক কম জায়গা ও শক্তি দিয়ে। ট্রানজিস্টরের সুবিধা হলো:

• এটি ছোট আকারের,
• কম গরম হয়,
• বেশি দিন টেকে।

এই কারণে Transistor ব্যবহার করে কম্পিউটার আরও ছোট ও কার্যকর হলো।

২. Integrated Circuit (IC) (1958):

এরপর বিজ্ঞানীরা একাধিক ট্রানজিস্টরকে একসাথে একটি ছোট চিপে বসিয়ে তৈরি করলেন Integrated Circuit (IC)। এর ফলে:

• একই সার্কিটে অনেক কাজ করা সম্ভব হলো,
• কম খরচে অনেক শক্তিশালী যন্ত্র তৈরি করা গেল,
• কম্পিউটার আরও ছোট ও দ্রুততর হলো।

৩. Microprocessor (1971):

এরপর আসে সবচেয়ে বড় বিপ্লব – Microprocessor। Intel 4004 ছিল পৃথিবীর প্রথম মাইক্রোপ্রসেসর। এটি একটি ছোট চিপ, যেখানে পুরো একটি CPU-এর কাজ করা যায়। এর ফলে:

• কম্পিউটার তৈরি করা আরও সহজ হলো,
• ব্যক্তি পর্যায়ে কম্পিউটার (Personal Computer) আসা শুরু করল,
• ঘরে বসে মানুষ কম্পিউটার ব্যবহার করতে পারল।

৪. VLSI (Very Large Scale Integration):

সবশেষে, VLSI প্রযুক্তির মাধ্যমে হাজার হাজার ট্রানজিস্টর ও সার্কিট একসাথে একটি ছোট চিপে স্থাপন করা সম্ভব হয়। এর ফলাফল:

• কম্পিউটার আরও বেশি শক্তিশালী হলো,
• মোবাইল, ল্যাপটপ, স্মার্ট ডিভাইসের মতো ছোট যন্ত্রে কম্পিউটার শক্তি যোগ হলো।

🧮 বিট ও বাইট

কম্পিউটার তথ্য সংরক্ষণ ও প্রক্রিয়াকরণে বিট (bit) এবং বাইট (byte) ব্যবহার করে।

• ১ Byte = ৮ Bits
• ১ Bit = ০ অথবা ১ (Binary value)

🧠 র‍্যাম (RAM) ও মেমোরি

RAM এর পূর্ণরূপ হলো Random Access Memory।
এটি একটি Primary Memory, যা ভলাটাইল (Volatile) মেমোরি।
এর মানে হলো, কম্পিউটার বন্ধ হলে RAM-এ সংরক্ষিত তথ্য মুছে যায়।

RAM সাধারণত কাজের সময়কার তথ্য বা চলমান প্রোগ্রামগুলো সাময়িকভাবে রাখে।

অন্যদিকে,

• SSD (Solid State Drive) এবং
• HDD (Hard Disk Drive)

এই দুটি হলো Secondary Memory, যেখানে দীর্ঘমেয়াদে ডেটা সংরক্ষণ করা যায় এবং কম্পিউটার বন্ধ হলেও তথ্য থাকে।

🖥️ CPU (Central Processing Unit)

CPU-এর ভেতরে নিচের অংশগুলো থাকে:

• ALU (Arithmetic Logic Unit): গাণিতিক ও লজিক্যাল কাজ করে
• CU (Control Unit): CPU-এর সব কার্যক্রম নিয়ন্ত্রণ করে
• Registers: অস্থায়ীভাবে তথ্য ধরে রাখে
• Cache Memory: দ্রুত গতির ছোট মেমোরি, বারবার ব্যবহৃত ডেটা রাখে

💼 IBM, Apple, এবং Microsoft-এর প্রাথমিক কম্পিউটার ইতিহাস

🖥️ IBM (International Business Machines)

• 1952 সালে, IBM তৈরি করে তাদের প্রথম commercial computer - IBM 701।
• এরপর 1964 সালে, IBM তৈরি করে System/360, একটি Mainframe Computer সিরিজ যা ব্যবসা, গবেষণা এবং সরকারে বিপ্লব আনে।
• এই কম্পিউটারগুলোর মেমোরি ছিল kilobytes (KB) লেভেলের - সাধারণত 8KB থেকে 512KB পর্যন্ত।
• প্রাথমিকভাবে 8-bit বা 16-bit architecture ব্যবহৃত হতো, পরবর্তীতে তা 32-bit হয়।

📌 বিষেষত্ব:
IBM-এর Mainframe কম্পিউটারগুলো ছিল অনেক বড় এবং ভারী, কিন্তু শক্তিশালী। আজও ব্যাংকিং বা সরকারি কাজে Mainframe-এর ভিত্তি ব্যবহার করা হয়।

🍎 Apple Inc.

• 1976 সালে, Steve Jobs এবং Steve Wozniak তৈরি করেন Apple I - একটি single-board পার্সোনাল কম্পিউটার।
• 1977 সালে, Apple II বাজারে আসে, যা প্রথম color graphics, keyboard, and floppy drive সাপোর্ট করত।
• Apple I তে ছিল 8-bit MOS 6502 processor এবং 4KB RAM।
• Apple II তেও ছিল 8-bit processor, এবং RAM ছিল 4KB থেকে 48KB পর্যন্ত উন্নত করা যেত।

📌 Apple-এর ভূমিকা:
Apple ই ছিল সেই কোম্পানি যারা পার্সোনাল কম্পিউটারকে সাধারণ মানুষের নাগালে এনে দেয়। Apple II ব্যাপকভাবে জনপ্রিয় হয় স্কুল, ব্যবসা এবং ঘরের ব্যবহারের জন্য।

🪟 Microsoft

• 1980 সালে, Microsoft তৈরি করে MS-DOS (Microsoft Disk Operating System), যেটা IBM PC-তে ব্যবহার হতো।
• পরে 1985 সালে, তারা তৈরি করে Windows 1.0 - একটি GUI-ভিত্তিক অপারেটিং সিস্টেম যা MS-DOS-এর উপর কাজ করত।
• এই অপারেটিং সিস্টেমগুলো প্রথমে 8-bit এবং 16-bit architecture এ চলে, পরে 32-bit এবং 64-bit OS আসে।
• Windows OS এর কারণে কম্পিউটার ব্যবহার অনেক সহজ হয়, এবং সাধারণ মানুষও কম্পিউটার চালাতে আগ্রহী হয়।

📌 Microsoft-এর অবদান:
MS-DOS এবং Windows-এর মাধ্যমে Microsoft সফটওয়্যার ইন্ডাস্ট্রিতে বিপ্লব আনে। তারা হার্ডওয়্যার না বানিয়ে সফটওয়্যারের উপর ফোকাস করে, যার ফলে তাদের OS অনেক ধরনের কম্পিউটারেই চলত।

🔢 Bit Architecture Summary:

IBM শুরুতে মেইনফ্রেম বানালেও পরে পার্সোনাল কম্পিউটারে রূপান্তর হয়।
Apple এবং Microsoft ছিল সেই দুই কোম্পানি যারা সাধারণ মানুষের হাতে কম্পিউটার এনে দেয় - Apple হার্ডওয়্যার দিয়ে আর Microsoft সফটওয়্যার দিয়ে।

তাদের তৈরি কম্পিউটার ও OS গুলোর bit size শুরুতে 8-bit, পরে 16-bit → 32-bit → 64-bit পর্যন্ত উন্নত হয়, যার ফলে গতি, ক্ষমতা ও ব্যবহারযোগ্যতা অনেক বাড়ে।

[Author:@shahriar-em0n Date: 2025-06-05 Category: interview-qa/class-wise ]

✨ CLass 33 - Into The Operating System

🖥️ ENIAC ও Punch Card

ENIAC (Electronic Numerical Integrator and Computer) ছিল একেবারে প্রথম দিকের একটি general purpose computer যা Punch card ব্যবহার করত:

• Input (Data এবং Instruction)
• Output (Result)
• Storage (Storing temporary data)

ENIAC সাধারণত IBM এর ৮০ কলামের Punch card ব্যবহার করত।

🧠 Punch Card (80x12)

• শক্ত কাগজ, যাতে ৮০টি কলাম ও ১২টি সারি থাকে।
• ছিদ্র দিয়ে তথ্য encode করা হয়
• ছিদ্র = 1
• ছিদ্র না থাকলে = 0

🧾 Punch card RAM এ লোড এবং Program execute

• Punch Card তৈরি
  • প্রোগ্রামের কোড বা ডেটা আগে কাগজে Punch card এ লেখা হতো (প্রতিটি কার্ড = ১ লাইন কোড বা তথ্য)।
  • keypunch machine দিয়ে ছিদ্র করা হতো।
• Computer এ Feed
  • Punch card গুলো card reader এ ঢোকানো হতো।
  • Reader ছিদ্রগুলো পড়ে Binary signal এ (1 বা 0) রূপান্তর করত।
• RAM এ Load
  • Binary signal গুলো কম্পিউটারের Memory ইউনিটে পাঠানো হতো।
  • সেই সময়কার RAM ছিল টিউব বা flip-flop ধরনের মেমোরি।
  • প্রতিটি instruction বা data নির্দিষ্ট location এ সংরক্ষিত হতো।
• Execution
  • কম্পিউটারের control unit(CU), memory থেকে একে একে instruction নিত।
  • Pointing Register (Program Counter) প্রথমে প্রথম instruction address কে point করে।
  • CPU সেই instruction -> fetch -> decode -> execute করে।
  • Instruction শেষ হলে, Pointing register এক ধাপ বাড়ে, অর্থাৎ পরবর্তী instruction address এ চলে যায়।
  • Loop বা condition থাকলে সেটা plugboards বা বিশেষ কার্ডে আগে থেকেই সেট করে দিতে হতো।

🛠️ Note:

• তখন কোনো operating system ছিল না। সব কিছু manually করতে হতো।
• RAM আজকের মতো উন্নত ছিল না; বরং ছিল একটি সীমিত মেমোরি ইউনিট।
• পুরো কাজটি ছিল ধীর ও খুবই টেকনিক্যাল।

CPU = Register Set (ডেটা রাখে) + Processing Unit (ডেটা প্রসেস করে) এবং Processing Unit = ALU + Control Unit

💡 The Idea of Operating System

🕰️ ১৯৪০ - ৫০ দশকে, কম্পিউটারে প্রতিটি প্রোগ্রাম manually চালাতে হতো - punch card, আলাদা কোড, অনেক সময়।

🎯 সমাধান :

"একটা সফটওয়্যার থাকুক, যা প্রোগ্রাম চালানোসহ সব কাজ নিজে করবে" - এটাই Operating System।

প্রথম দিকে OS শুধু প্রোগ্রাম চালাত, পরে I/O, memory, file, security management যুক্ত হয়।

⚙️ OS এর Pointing Register (Program Counter) ব্যবহার করে Program Execution

💡 Pointing Register (Program Counter aka PC)

• CPU-র একটি register।
• পরবর্তী যেই instruction execute হবে, তার address রাখে।

👣 Program Execution Steps:

• Computer On -> OS প্রথমে HDD থেকে RAM এ Load হয়
• OS sets up -> Hardware, memory, File System ইত্যাদি
• একটি Program execute -> Click app icon
• OS সেই Program টি HDD থেকে খুঁজে বের করে এবং RAM এ লোড করে
• OS এরপর Pointing Register কে program এর first instruction address সেট করে দেয়
• CPU সেই address থেকে instruction -> fetch -> decode -> execute করতে শুরু করে

➡️ প্রতিটি Instruction শেষ হওয়ার পর, Pointing Register নিজে থেকেই পরবর্তী address update হয়। যদি কোনো loop, function call বা condition থাকে, তাহলে Pointing Register সেই অনুযায়ী নতুন address এ jump করে।

🧬 Evolution of Operating System

🕰️ Early Stages (1940s-1960s):

🔹 1st Generation: Batch Processing Systems:

• প্রথমদিকে কম্পিউটার OS ছাড়াই কাজ করত, প্রোগ্রাম manually load করতে হতো।
• GM-NAA I/O (1956) ছিল First Operating System, যা IBM 704 এর জন্য input/output ম্যানেজ করত।

🔹 2nd Generation: Multiprogramming & Timesharing:

• Multiprogramming: CPU একাধিক প্রোগ্রামের মাঝে কাজ ভাগ করে efficiency বাড়ায়।
• Time-sharing systems (যেমন: CTSS, Multics): একাধিক ব্যবহারকারী একসাথে কম্পিউটারের সাথে কাজ করতে পারে।

🖥️ The Rise of User-Friendly Interfaces (1970s-1990s):

🔹 3rd Generation: Graphical User Interfaces (GUIs) Apple Macintosh ও Microsoft Windows. Graphical User Interface (GUI) চালু করে, যা কম্পিউটারকে সহজ করে তোলে।

🔹 Unix ও Personal Computers

• Unix: সহজ, বহনযোগ্য ও multitasking সাপোর্টের জন্য জনপ্রিয়।
  • 🏛️ History:
    • 📅 1970 সালে AT&T Bell Labs এ Ken Thompson ও Dennis Ritchie Unix তৈরি করেন।
    • 🧪 এটি C programming language ব্যবহার করে লেখা হয়, যা একে আরও বহনযোগ্য করে তোলে।
  • 📚 Unix থেকে জন্ম নেওয়া জনপ্রিয় OS:
    • Linux 🐧
    • Mac OS 🍎
    • BSD, Solaris ইত্যাদি
• CP/M, PC-DOS: ব্যক্তিগত কম্পিউটারের জন্য সহজ Operating System।

🔹 Linux ও উন্নত GUI

• Linux: Open source OS হিসেবে জনপ্রিয় হয়।

🔹 Windows ও Mac OS

• GUI আরও উন্নত করে।

📱 Modern Era (2000s-Present):

🔹 Mobile & Cloud Computing iOS, Android: মোবাইল OS বাজারে আধিপত্য বিস্তার করে।

Cloud ও Virtualization প্রযুক্তি কম্পিউটিংকে নতুন রূপ দেয়।

🔹 AI Integration AI, Machine Learning, Quantum Computing OS কে আরও বুদ্ধিমান ও অভিযোজিত করে তুলছে।

📌 Key Milestones:

[Author: @nazma98 Date: 2025-06-09 Category: interview-qa/class-wise ]

Class-34 : 🧩 Breaking The CPU and Process

🧠 Central Processing Unit (CPU)

• The brain of the computer
• Process instructions

CPU এর ২টি প্রধান অংশ হলো:

1. Processing Unit (PU)

• Arithmetic Logic Unit(ALU) + Control Unit(CU) থাকে।

2. Register Set

• Data ও Instructions সাময়িক রাখা হয়।
• Processing Unit এর কাজ সহজ করতে সাহায্য করে।

🔹 Register Set

🗄️ General Purpose Registers

🧮 Registers AL, BL, CL, DL in x86 Architecture

AL, BL, CL, এবং DL respective general-purpose register এর lower 8 bits কে represent করে। CPU architecture এর ওপর ভিত্তি করে এগুলো 16-bit, 32-bit, এবং 64-bit হয়।

🏛️ Register Hierarchy

⚙️ Control Unit (CU) executes a program stored on a HDD

💾 Program যখন HDD এ থাকে

• Program file → HDD এ থাকে
• Direct access → Slow

⚡ RAM এ Load

• Operating System → Program, HDD থেকে RAM এ নিয়ে আসে → Program Load / Fetch

🚀 Execution শুরু

• Control Unit (CU) → RAM থেকে Program এর First memory address নেয়
• memory address → Program Counter (PC) এ set করা হয়

📥 CU RAM থেকে Instruction Fetch

• CU → PC থেকে memeory address নিয়ে RAM থেকে Instruction fetch করে
• Instruction → Instruction Register (IR) এ store হয়

⚙️ Decode & Execute

• CU → IR এর Instruction কে Decode করে
• CU → ALU/অন্যান্য ইউনিটকে কাজ করতে নির্দেশ দেয়
• PC → পরের Instruction memory address update হয়

⚙️ Go Program Execution Flow by CPU

🧠 Go প্রোগ্রাম রান

• go run main.go → Go compiler → binary executable file
• CPU, load এবং execute করে → binary executable file

📦 Memory Division

• Code Segment → const, func / instructions (যা পরিবর্তন হবে না / Read only)
• Data Segment → global variable
• Stack → function calls & local variable
• Heap → dynamic memory

🧱 Stack Frame

main() (বা অন্য কোনো function) call হলে Stack Frame create হয়। Stack Frame এ থাকে:

• Local variables (a := 10)
• Return address (function শেষে কোথায় return)
• Function parameters (যদি থাকে)
• Saved registers (CPU registers)

📊 Stack Frame Structure

↑ Higher memory address
---------------------
| Return Address    | ← main() call
--------------------
| Old Base Pointer  | ← BP
--------------------
| Local variable y  |
| Local variable x  | ← SP (grows downwards)
--------------------
↓ Lower memory address

Stack pointer (SP) এবং Base pointer (BP) হল CPU registers, যা stack frame manage করতে ব্যবহৃত হয়।

💡 Process

• Program execution শুরু হলে → process create হয়

• Process → Program execution সাহায্য করে

• এর ভেতরে থাকে → Code Segment, Data Segment, Stack, Heap, এবং CPU রেজিস্টার

• Process Dead বা Terminated → OS সমস্ত memory ও resources (RAM, file, etc.) free করে

    | অংশ                  |
    | -------------------- |
    | Code Segment         |
    | Data Segment         |
    | Heap                 |
    | Stack                |
    | Registers            |
    | Program Counter (PC) |
    | File Descriptors     |
  

[Author: @nazma98 Date: 2025-06-11 Category: interview-qa/class-wise ]

🧠 CPU Structure and Stack Frame Execution Notes

🔹 CPU: Two Core Components

1. Processing Unit

   • Arithmetic Logic Unit (ALU): সব ধরনের গাণিতিক (arithmetic) এবং যৌক্তিক (logical) operations করে থাকে।
   • Control Unit (CU): CPU এর মধ্যে গাণিতিক (arithmetic) এবং যৌক্তিক (logical) operations পরিচালনা করে, input/output এবং instruction decoding কীভাবে হবে তা কন্ট্রোল করে।

2. Register Set

   • Program Counter (PC): পরবর্তীতে যেই Instruction টি execute হবে তার address ধারণ করে ।
   • Stack Pointer (SP): মেমরিতে বর্তমানে যে stack আছে তার Top কে point করে।
   • Base Pointer (BP): বর্তমান stack frame এর base কে point করে।
   • Instruction Register (IR): এই মুহূর্তে যে instruction টি execute হচ্ছে সেটি রাখে।
   • General Purpose Registers: Data manipulation যেমন arithmetic ও logical operation এবং data movement এর জন্য অস্থায়ীভাবে data রাখে।

🔹 Bits and Bytes

• 8-bit = 1 byte
• 16-bit = 2 bytes
• 32-bit = 4 bytes
• 64-bit = 8 bytes

Memory addressing = ( 2^n )

🔹 RAM Addressing on 32-bit System

Memory cell 4 bytes করে বাড়তে থাকে। (since 32-bit = 4 bytes):

Address:  0   4   8  12  16  20  24  ...
         [ ] [ ] [ ] [ ] [ ] [ ] [ ]

🔹 OS, RAM, and Process Execution

1. OS executable code আনে HDD থেকে → RAM এ লোড করে
2. OS একটি process create করে
3. RAM process memory কে কয়েকটি ভাগে ভাগ করে:

• Code Segment (constants এবং instructions এর জন্য)
• Data Segment (global/static variables এর জন্য)
• Stack (function calls এবং local variables এর জন্য)
• Heap (dynamically memory allocate করার জন্য)

🔹 Stack Frame in Function Call

• OS, SP এবং BP set করে দেয়।
• SP < BP ( SP memory তে lower address কে point করে)।

Stack Frame Layout:

[ Local Variables        ]   <-- SP (grows downward)
[ Old Base Pointer       ]
[ Return Address         ]
[ Parameters (right→left)]   <-- BP

• Return Address সাধারণত রাখা হয় BP + 4 (32 bit computer), BP + 8 (64 bit computer) etc. ( Base pointer এর ঠিক উপরে )
• BP ব্যবহার করে CPU সহজেই যা access করতে পারে:
  • Function parameters
  • Return address
  • Local variables

🔹 Stack Frame Exit

• Stack frame যা pop করে (সরিয়ে ফেলে):
  • Local variables
  • Old BP value register set এর BP তে restore হয়
  • SP reset হয়
  • Execution, Return Address কে follow করে সেখানে jump করে

Final Condition:

BP == SP  => Stack Frame Close হয়ে যায়

🧭 Diagram: Stack Frame Example (32-bit)

Memory Address ↓

+----------------------+  <- BP
| Parameter 1          |
+----------------------+
| Parameter 2          |
+----------------------+
| Return Address       | <- BP + 4
+----------------------+
| Old Base Pointer     | <- BP + 8
+----------------------+
| Local Variable A     | <- SP
+----------------------+

Stack grows downward ↓

✅ Summary

• CPU mainly Processing Unit এবং Register Set এ বিভক্ত।
• Stack Frame function call handling এর জন্য responsible থাকে।
• Base Pointer (BP) একটি fixed reference point হিসেবে কাজ করে।
• Stack Pointer (SP) function execution এর সময় move করতে থাকে।
• একটি function Return করলে BP এবং SP reset হয়ে যায়।

debugging, compiler design, এবং low-level programming এর জন্য stack frames বুঝা অত্যন্ত প্রয়োজনীয়।

Class 36: Context Switching, PCB, Concurrency

context switching কী ?

Context Switching মানে হল, CPU একটা প্রসেস রেখে আরেকটা প্রসেস চালানো শুরু করে।

ঠিক যেমন ক্লাসে তুমি ম্যাথ করছিলে, হঠাৎ টিচার বলল “এবার ইংরেজি করো” তখন তুমি ম্যাথের খাতা বন্ধ করে ইংরেজির খাতা খুললে।
এই খাতা বদলানোই হলো Context Switch! 🧑‍🏫

🧱 কিভাবে কাজ করে?

1. CPU এখন একটা প্রসেস (ধরো গেম) চালাচ্ছে।
2. হঠাৎ OS বলে “এই তো, ভিডিও কল আসছে! আগে এটাকে চালাও।”
3. তখন CPU গেমের অবস্থা (registers, state) একটা PCB-তে রেখে দেয়।
4. এরপর নতুন প্রসেস (ভিডিও কল) এর অবস্থা PCB থেকে নিয়ে চালানো শুরু করে।

এভাবেই CPU বারবার প্রসেস বদলায়।

🎯 কেন দরকার?

• অনেক কাজ একসাথে করার জন্য
• যেই কাজটা এখন বেশি দরকার, সেটাকে চালানোর জন্য
• RAM বা CPU কে সঠিকভাবে ব্যবহার করার জন্য

🔍 Process Control Block (PCB)

কম্পিউটার যখন একসাথে অনেকগুলো প্রোগ্রাম চালায় (যেমন: গেম, মিউজিক, ব্রাউজার), তখন প্রতিটা প্রোগ্রাম একেকটা আলাদা Process (প্রসেস) হয়ে চলে।
এই প্রসেসগুলোকে চিনে রাখা, মনিটর করা আর নিয়ন্ত্রণ করার জন্য অপারেটিং সিস্টেম (OS) ব্যবহার করে একটা বিশেষ জিনিস যেটার নাম Process Control Block (PCB)।

🧠 PCB কী ❓

PCB হলো একটি ছোট্ট তথ্যের বাক্স (Data Structure) যেখানে একটি প্রসেস সম্পর্কিত সব দরকারি তথ্য জমা থাকে।

একে তুমি ভাবতে পারো, প্রতিটা প্রসেসের আইডি কার্ড বা রিপোর্ট কার্ড হিসেবে।

কেন PCB দরকার ❓

যখন অনেকগুলো প্রসেস একসাথে চলছে, তখন অপারেটিং সিস্টেমকে প্রতিটা প্রসেস সম্পর্কে জানতে হয়

• কে কোন জায়গা পর্যন্ত কাজ করেছে?
• কে এখন রানিং মোডে?
• কার কী রিসোর্স লাগছে?
• কতটুকু মেমোরি বা CPU লাগবে?

এই সব প্রশ্নের উত্তর থাকে PCB-তে।
আর যখন প্রসেস পরিবর্তন করতে হয় (একটা থেকে আরেকটাতে যেতে হয়), তখন PCB ছাড়া OS কিছুই করতে পারত না!

PCB-তে কী কী থাকে ❓

🌀 উদাহরণ দিয়ে বোঝা যাক:

ধরো তুমি একটি গেম খেলছো, আর তোমার ভাই ইউটিউবে ভিডিও দেখছে।

➡️ গেমটা এক ধরনের প্রসেস, ইউটিউব আরেকটা।
➡️ অপারেটিং সিস্টেম এই দুই প্রসেসকে আলাদা করে রাখতে PCB ব্যবহার করে।

➡️ প্রতিটা গেম/ভিডিও প্রসেসের জন্য আলাদা PCB থাকে যখন তুমি গেম থেকে বের হয়ে ইউটিউবে গেলে, তখন OS:

1. গেমের সব তথ্য PCB-তে রেখে দেয়
2. ইউটিউবের তথ্য PCB থেকে নিয়ে কাজ শুরু করে

এটাকে বলে Context Switch।

🎯 PCB কী কী করে ❓

✅ প্রসেসকে আলাদা করে চিনে রাখে
✅ প্রসেস চলাকালীন অবস্থা রেকর্ড রাখে
✅ প্রসেসের মেমোরি, CPU এবং I/O ব্যবস্থাপনা করে
✅ প্রসেস পরিবর্তনের সময় আগের কাজ মনে রাখে
✅ প্রসেস চলার হিসাব রাখে (অ্যাকাউন্টিং)

📌 মনে রাখার মতো বিষয়:

• PCB = প্রসেসের আইডি কার্ড + রিপোর্ট কার্ড + ফাইল
• এটা অপারেটিং সিস্টেমের জন্য সবচেয়ে দরকারি টুল
• প্রতিটা প্রসেসের জন্য একটা আলাদা PCB থাকে
• PCB ছাড়া প্রসেস ম্যানেজমেন্ট সম্ভব নয়

📋 Example :

-------------------------------------
| Process ID        : 101           |
| State             : Running       |
| Program Counter   : 0x0034        |
| Registers         : AX=5, BX=2    |
| Memory            : 200MB         |
| I/O Devices       : Keyboard      |
| User Time         : 0.05 sec      |
------------------------------------
        ⬆️
    Process Control Block

শেষ কথা:

• কম্পিউটার যেভাবে অনেক কাজ একসাথে করে,
• ঠিক তেমনি PCB-এর মাধ্যমে প্রতিটা কাজ (প্রসেস) আলাদা করে হ্যান্ডেল করে।
• এটা অপারেটিং সিস্টেমের অদৃশ্য সেনাপতি!

⏱️ Concurrency একসাথে অনেক কাজ!

👶 সহজভাবে বললে:

Concurrency মানে হলো, CPU যেন একসাথে অনেকগুলো কাজ করছে এমন একটা ধোঁকা দেয়।

ধরো তোমার মা একসাথে ভাত রান্না করছে, ডাল দিচ্ছে, আবার ফোনেও কথা বলছে মানে কাজগুলো একসাথে চলছে।
একসাথে সব কাজ না করলেও, অল্প অল্প করে সবকিছু সামলাচ্ছে। এটাকেই বলে Concurrency।

👨‍💻 কম্পিউটারে কিভাবে হয়?

• CPU একসাথে অনেক Process চালায় না, কিন্তু একটা একটু চালায়, তারপর আরেকটা, তারপর আবার প্রথমটা এভাবে।
• এতে মনে হয়, সবকিছু একসাথে চলছে।

📌 মনে রাখো:

[Author : @shahriar-em0n Date: 2025-06-05 Category: interview-qa/class-wise ]

🧠 Parallelism vs Concurrency

১. Concurrency

Concurrency এমন একটি প্রক্রিয়া যেখানে CPU একসাথে অনেকগুলো কাজ একইসাথে run করছে এমন একটি illusion তৈরি করা, এটি এমনভাবে কাজ করে যেন সবগুলো কাজ একইসাথে চলছে অর্থাৎ ব্যবহারকারীর চোখে এটি যেন একসাথে অনেক কাজ হচ্ছে এমন একটি illusion তৈরি করে।

🛠 উদাহরণ :

YouTube অ্যাপ চালানোর সময় তুমি দেখতে পারো:

• ভিডিও প্লে হচ্ছে
• কমেন্ট লোড হচ্ছে
• বিজ্ঞাপন আসছে
• স্ক্রল করলে নতুন ভিডিও সাজেশন আসছে

সবকিছুই একসাথে ঘটছে বলে মনে হয়, কিন্তু মূলত এই কাজগুলো context switching এর মাধ্যমে একে একে execute হচ্ছে।

✅ মূল বৈশিষ্ট্য:

• একসাথে অনেক কাজ handle করা হয়
• CPU এক সময়ে একটিই কাজ করে, কিন্তু দ্রুত context switch করে
• Single-core CPU-তেও কাজ করে

২. Parallelism

Parallelism বোঝায় একাধিক কাজ একই সময়ে, একাধিক CPU বা processor/core ব্যবহার করে execute হওয়া। প্রতিটি কাজ আলাদা processor/core দ্বারা একসাথে চালানো হয়।

🛠 উদাহরণ :

ধরো, তুমি Adobe Premiere Pro তে ভিডিও এক্সপোর্ট দিচ্ছো একি সময়ে

• একটি core ভিডিও প্রসেস করছে
• অন্য core অডিও রেন্ডার করছে
• আরেকটি core এফেক্ট প্রসেস করছে

এই কাজগুলো processor/CPU multiple core দ্বারা একসাথে চলায় যাতে রেন্ডারিং দ্রুত সম্পন্ন হয়। এটি Parallelism।

✅ মূল বৈশিষ্ট্য:

• একাধিক কাজ একই সময়ে সত্যিকারের parallel চলে
• Multi-core processor দরকার
• সময় বাঁচে এবং efficiency বাড়ে

৩. তুলনামূলক পার্থক্য

৪. সংক্ষেপে:

• Concurrency হলো কাজগুলোকে একসাথে handle করার কৌশল, যেখানে একসাথে অনেক কিছু ঘটলেও, CPU এক সময়ে একটিই কাজ করে।
• Parallelism হলো সত্যিকারের একসাথে অনেক কাজ করা, যেখানে প্রতিটি কাজ ভিন্ন ভিন্ন processor/core দ্বারা চলে।

[Author : @shahriar-em0n Date: 2025-06-09 Category: interview-qa/class-wise ]

Class 38 - Thread

🧵 Thread কী?

• Thread হল কোন process এর একটি execution unit.
• একটি process creation এর সাথে সাথে by default একটি thread create হয় যাকে main thread ও বলা হয়।
• Thread মূলত RAM এ load করা instruction/program code গুলো execute করে থাকে।

🧠 Thread কোথায় থাকে?

                User software/program এ double click করে
                                  ⬇️
            RAM এ লোড হওয়া program এর binary executable code load হয়
                                  ⬇️
                      OS একটি process create করে
                                  ⬇️
                      default thread create হয়

• Thread কে process এর একটি অংশ বলা যায়।
• Process creation এর শুরুতে thread এবং process একই থাকে।
• Process is container, thread is executor

🔍 Thread কে Virtual Process কেন বলা হয়?

• New Process create ➡️ Default Thread Create হয়
• Thread এর Code Segment, Data Segment, Stack, Heap ইত্যাদি থাকে ➡️ Process এর অনুরূপ
• Process এর মতোই behave করে থাকে।
• Logical Process বলা হয়।

🧶🔄 Multi-threading

একটি process এর মধ্যে অনেকগুলো কাজ বা functionality execute করার জন্য, OS ওই process এর ভেতরে একাধিক execution unit তৈরি করে, যেগুলো একসাথে কাজ করে, তখন তাকে Multi-threading বলে।

✨ একই Process এর অন্তর্ভুক্ত Multiple Threads এর কিছু Characteristics

• প্রতিটি Thread এর নিজস্ব CPU state (যেমন: Register, Program Counter) এবং Stack থাকে।
• সব Thread একই Process এর code section, data section এবং OS resources (e.g. open files and signals) share করে।
• প্রতিটি Thread এর নিজস্ব TCB (Thread Control Block) থাকে।
• Thread গুলো lightweight হওয়ায় context switching দ্রুত হয়।
• একে অপরের সাথে সহজে Data শেয়ার করতে পারে → Fast Communication সম্ভব।
• এক Thread এ bug থাকলে পুরো process crash করতে পারে।
• Data sharing এর জন্য synchronization দরকার (mutex/semaphore)।

🧵 Visualization: Multi-threading Inside a Process

                  +-----------------------------+
                  |         Process             |
                  |  (e.g., Media Player App)   |
                  |                             |
                  |  +-----------------------+  |
                  |  |       Thread 1        |  |  --> Play Audio
                  |  +-----------------------+  |
                  |                             |
                  |  +-----------------------+  |
                  |  |       Thread 2        |  |  --> Display Video
                  |  +-----------------------+  |
                  |                             |
                  |  +-----------------------+  |
                  |  |       Thread 3        |  |  --> Handle User Input
                  |  +-----------------------+  |
                  |                             |
                  +-----------------------------+

🔍 Explanation

Process হচ্ছে একটি চলমান প্রোগ্রাম (যেমন: VLC Player)। সেই প্রোগ্রামের ভেতরে একাধিক Thread কাজ করছে। যেমন:

• 🎵 Thread 1: অডিও প্লে করছে
• 📺 Thread 2: ভিডিও দেখাচ্ছে
• 🎮 Thread 3: ইউজারের কীবোর্ড/মাউস ইনপুট নিচ্ছে

সব thread মিলে একটি process এর কাজকে দ্রুত ও কার্যকর করে।

🔄 Context Switching in Thread

• Thread ➡️ একটি নির্দিষ্ট কাজ/functionality এর জন্য দায়ী
• Process দ্রুত execute করার লক্ষ্যে ➡️ OS, multiple thread create করে
• Program Counter একটি নির্দিষ্ট সময়ে শুধু একটি thread এর instruction address ধরে রাখতে পারে ➡️ CPU একসাথে সব থ্রেড চালাতে পারে না
• CPU কিছু সময় একটি thread execute করে ➡️ একটি thread এর সময় শেষ বা thread blocked (যেমন: I/O wait)
• OS সেই thread এর current state (registers, stack pointer, program counter) সংরক্ষণ করে ➡️ TCB (Thread Control Block)
• এরপর OS অন্য thread এর state load করে
• এই পুরো প্রক্রিয়াটিকেই বলা হয় ➡️ Thread Context Switching

Thread Pool 🧵🧵

Thread pool হলো আগেই তৈরি করা কিছু Thread, যেগুলো Process এ বসে থাকে আর কাজ এলে তা করে ফেলে। প্রতিবার নতুন Thread না বানিয়ে আগের তৈরি Thread ব্যবহার করায় সময় ও রিসোর্স বাঁচে; বিশেষভাবে ছোট ও অনেক কাজ থাকলে এটা খুবই উপকারী।

⚙️ Process Vs Thread 🧵

[Author: @nazma98 Date: 2025-06-02 Category: interview-qa/class-wise ]

💐 Class 39 - Vogus Data Types

🔢 Signed Integer Type

Golang এ int8, int16, int32, এবং int64 হল signed integer types যাদের specific bit size থাকে। নিচে এ সম্পর্কে বিস্তারিত দেওয়া হল:

Go Runtime handles how to store each type of variable

🧠 int type কী?

Golang এ int টাইপের কোন নির্দিষ্ট সাইজ নেই। এটি Computer architecture এর উপর নির্ভর করে:

32-bit computer → int = 32 bit

64-bit computer → int = 64 bit

🌷 Example

package main

import "fmt"

func main() {
    var a int8 = 5

    fmt.Println(a)
}

🖼️ Visualization of storing int8 in 32-bit computer

Decimal to Binary (8-bit signed):

5 in binary = 00000101 (as int8)

🧮 32-bit Memory Cell Visualization for int8 a = 5

📌 Tips:

• Memory save → int8, int16
• Performance / Process easy → int বা int32
• সব সময় Range এর মধ্যে data থাকবে কিনা তা আগে ভাবুন।

📦 Unsigned Integer Type

Golang এ unsigned int - uint টাইপ হলো এমন সংখ্যা যা কখনোই ঋণাত্মক (negative) হতে পারে না।

• 👉 শুধুমাত্র ধনাত্মক সংখ্যা (positive) বা শূন্য (0) নিতে পারে।

🧪 Example

package main

import "fmt"

func main() {
    var age uint8 = 25
    fmt.Println(age)
}

🧠 uint type

Golang এ uint টাইপের কোন নির্দিষ্ট সাইজ নেই। এটি Computer architecture এর উপর নির্ভর করে:

32-bit computer → uint = 32 bit

64-bit computer → uint = 64 bit

🔢 Float Type

দশমিক সংখ্যা (fractional numbers) রাখার জন্য float টাইপ ব্যবহার করা হয়। যেমনঃ 3.14, -2.75, 0.001।

🧪 Golang এ Float দুই types:

শুধু float নামে কোনো type নেই।

🧪 Example

package main

import "fmt"

func main() {
    var x float32 = 3.1415
    var y float64 = 2.7182818284

    fmt.Println("x =", x)
    fmt.Println("y =", y)
}

📌 Note: Golang এ দশমিক সংখ্যা লিখলে সেটা default float64 হয়।

f := 1.5 // float64

🔢 Boolean Type

Boolean টাইপ bool শুধু দুইটি value রাখতে পারে:

• true
• false

🌸 Example

package main

import "fmt"

func main() {
    var isActive bool = true

    fmt.Println("isActive:", isActive)
}

bool type memory তে সঠিকভাবে 1 bit নয়, বরং 1 byte (8 bits) জায়গা নেয়।

✳️ Byte Type

• alias for uint8
• 8 bits per character

package main

import "fmt"

func main() {
    var a byte = 65
    fmt.Println(a)           // Output: 65
    fmt.Println(string(a))   // Output: A
}

🔎 Note:

• byte শুধু 0 থেকে 255 পর্যন্ত value রাখতে পারে।
• character encoding এর সাথে কাজ করতে গেলে byte খুবই দরকারি।

🧮 Rune

• alias for int32 (unicode point) - 32 bits / 4 bytes
• Unicode character রাখে

🌻 Example

package main

import "fmt"

func main() {
    r := '❤'
    fmt.Printf("%c\n", r) // Output: ❤
}

🔢 Format Specifiers Table

🌻 Example

package main

import "fmt"

func main() {
	var a int8 = -128

	var x uint8 = 255

	var j float32 = 10.23343
	var k float64 = 10.4455235

	var flag bool = true

	var s string = "The sky is beautiful"

	r := '❤'

	fmt.Printf("%c\n", r) // Output: ❤
	fmt.Printf("%d\n", a) // Output: -128
    fmt.Printf("%d\n", x) // Output: 255
	fmt.Printf("%.2f\n", j) // Output: 10.23
    fmt.Printf("%.5f\n", k) // Output: 10.44552
	fmt.Printf("%v\n", flag) // Output: true
	fmt.Printf("%s\n", s) // Output: The sky is beautiful

	fmt.Printf("** Type of variable s = %T", s) // Output: string
}

[Author: @nazma98 Date: 2025-06-05 Category: interview-qa/class-wise ]

🌀 Golang এর defer: ভিতরের স্ট্যাক, রিটার্ন ফাঁদ, এবং বাস্তব উদাহরণে ডুব

"defer মানে হচ্ছে — তোমার কাজ হবে, কিন্তু পরে হবে।"

Go-এর defer হলো এমন একটা ফিচার যেটা clean code লেখার জন্য অনবদ্য, কিন্তু ভুল বুঝলে subtle bug এর উৎস। চলুন আজ defer-কে সম্পূর্ণভাবে বোঝার চেষ্টা করি — তার পেছনের স্টোরি সহ।

🔸 defer কি?

defer একটি কিওয়ার্ড যেটি কোন ফাংশনের শেষ মুহূর্তে অন্য একটি ফাংশনকে চালাতে বলে। মূলতঃ এটি ব্যবহৃত হয় cleanup কাজের জন্য — যেমন:

• file.Close()
• unlock()
• recover()
• লগিং

🎯 কীভাবে কাজ করে defer?

Go কম্পাইলার defer স্টেটমেন্টগুলোকে compile time এ detect করে এবং runtime এ একটি internal stack এ রেখে দেয়। যখন function return করে, তখন এই stack থেকে একে একে ফাংশনগুলো পিছন থেকে সামনে (LIFO) চালানো হয়।

func main() {
    defer fmt.Println("A")
    defer fmt.Println("B")
    fmt.Println("C")
}

🖨️ Output:

C
B
A

📌 defer গুলো পিছনের দিকে যায় কারণ: Go stack এ push করে defer গুলোকে → পরে reverse করে pop করে।

🔧 পিছনের দিক থেকে ব্যাখ্যা (Behind-the-scenes)

func sayHello() {
    defer log("1")
    defer log("2")
    defer log("3")
}

Go internally কিছুটা এরকম করে:

deferStack := []func(){}
deferStack = append(deferStack, log("1"))
deferStack = append(deferStack, log("2"))
deferStack = append(deferStack, log("3"))

for i := len(deferStack)-1; i >= 0; i-- {
    deferStack[i]()
}

Go runtime defer গুলিকে একটি linked list structure-এ সংরক্ষণ করে, কিন্তু সেটা Stack behavior অনুযায়ী কাজ করে।

🎭 Named Return vs Unnamed Return — defer এর দুইরকম ব্যবহার

এই হলো defer এর “দুই মুখো” চরিত্র। 🤹‍♂️

✅ Named Return Value ব্যবহার করলে:

func example1() (result int) {
    defer func() {
        result = 99
    }()
    return 10
}

📌 এখানে result হল named return variable, তাই defer যখন চলে, তখন result এখনও accessible, এবং সেটাকে modify করা যায়।

🖨️ Output:

99

❌ Unnamed Return Value ব্যবহার করলে:

func example2() int {
    result := 10
    defer func() {
        result = 99
    }()
    return result
}

📌 এখানে return result বলার সাথে সাথে result এর ভ্যালু রিটার্ন buffer-এ কপি হয়ে যায় — তারপরে defer চালানো হয়, তাই এর কোনো প্রভাব পড়ে না।

🖨️ Output:

10

🧠 আরও কিছু মন ভোলানো Example

🔄 defer with loop

func loopDefer() {
    for i := 1; i <= 3; i++ {
        defer fmt.Println("Deferred:", i)
    }
}

🖨️ Output:

Deferred: 3
Deferred: 2
Deferred: 1

📌 প্রতিবার loop এ defer নতুন করে register হয়। তাই stack অনুযায়ী উল্টোভাবে execute হয়।

🔒 Defer behaviour for closures

func closureDefer() {
    for i := 1; i <= 3; i++ {
        defer func() {
            fmt.Println("Deferred:", i)
        }()
    }
}

🖨️ Output:

Deferred: 3
Deferred: 2
Deferred: 1

😵‍💫 কেন?

কারণ defer-এর ক্ষেত্রে ফাংশনে ব্যবহৃত ভ্যারিয়েবল গুলো ইমিডিয়েটলি ডিটেক্ট হয় এবং ডেফার স্টাকে সেভাবেই সেভড থাকে

🛠️ Practical Use Cases

1. File Handling:

func readFile(path string) error {
    f, err := os.Open(path)
    if err != nil {
        return err
    }
    defer f.Close()

    // read file...
    return nil
}

2. Mutex Unlock:

mu.Lock()
defer mu.Unlock()
// critical section

3. Recover from panic:

func safe() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        }
    }()
    panic("something went wrong")
}

🧾 Key Takeaways (সংক্ষেপে)

🎁 Bonus: Debug Suggestion

✅ If you're debugging defer issues:

• Use go run -gcflags=all="-m" to see escape analysis.
• Print log inside defer to see the order.
• Add named returns if defer needs to modify output.

🧠 শেষ কথা

Go-এর defer যত ছোট দেখতে, তত গভীর তার আচরণ। একে সঠিকভাবে বোঝা মানে হচ্ছে —

• Cleaner code
• Resource leak রোধ
• কম Bug

শুধু syntax জানলেই হবে না — এর ভিতরের Stack-মাথা, Return-trap খেলাও বোঝা জরুরি।

🧵 Class 41 : Separate Stack For Separate Thread

🔁 Recap

• Thread সম্পর্কে জানতে হবে।
• Process সম্পর্কে জানতে হবে।
• SP BP সম্পর্কে ভালো ধারনা থাকতে হবে।

🧠 Program Execution

• Program execute → Process create
• Process create → default একটি thread create (main thread)
• OS (Kernel) → Thread execute করে
• Thread execute → Independent task / features

🧪 Example

একটি প্রোগ্রাম যেমন Music Player — তার অনেক গুলো কাজ (functionality) একসাথে চালানো লাগে: যেমন:

• 🎵 Music List দেখানো
• ▶️ Music PLay
• 🎶 বিট/Visualizer দেখানো

এগুলো একসাথে চলতে পারে, কিন্তু একটার কাজ আরেকটাকে আটকে রাখতে পারে না। এই জন্যই Thread ব্যবহার করা হয়।

Program (Process)
│
├── Thread 1 (Main Thread)
│   └── Stack: funcA(), var x, return addr
│
├── Thread 2
│   └── Stack: funcPlay(), var song, return addr
│
└── Thread 3
    └── Stack: funcVisual(), var beat, return addr

🧷 Main Function Execution

প্রায় প্রতিটি compiled এবং structured language-এ execution শুরু হয় main() function দিয়ে, কারণ এটি একটি নির্ধারিত entry point যা runtime system বা OS খুঁজে নিয়ে চালায়।

• main function → stackframe create হয়
• main() এর ভিতর অন্য function invoke → তার জন্য stackframe create হয়
• প্রতিটি Stack, একটি Thread এর জন্য বরাদ্দ থাকে
• Stack Execute → Thread Execute

Stack একটা একটা করে সব function execute করে।

Stack কে Thread execute করে।

🗂️ Thread এবং Stack

একটি Program execute করতে হলে multiple tasks parallely করতে হতে পারে।

এর জন্য দরকার হয় Multiple Threads।

প্রতিটি Thread যখন তৈরি হয়, তখন নিজস্ব Stack memory বরাদ্দ পায়।

এই Stack এ থাকে:

• ফাংশন কলের return address
• Local variables
• Function arguments

💾 Stack কোথায় থাকে

• main thread → main stack
• Linux → RAM এ Stack এর জন্য 8MB allocate হয়
• Independent task এর জন্য আলাদা Thread লাগবে → new Stack → RAM এ 8MB Storage
• Process এর জন্য → No. of Thread * 8MB allcoate হয়
  • Process এ 10 Thread থাকলে 10 * 8 = 80 MB RAM allocated হয়
• Stack, RAM এর যে কোন ফাঁকা জায়গায় থাকতে পারে
• Code Segment, Data Segment, Heap → সব thread access / use করতে পারে
• Process, main thread বাদে অন্য thread track / execute করে না
• Thread → Stack এ কোন variable / function না থাকলে → kernel কে code segment, data segment এ search করতে request করে

📌 Code Segment, Data Segment, Stack এর size fixed থাকে। Heap dynamically grow / shrink করতে পারে তাই data, Heap এ বেশি রাখা হয়।

🖥️ Kernel

• main thread বাদে অন্য thread → Kernel create করে
• Thread execute → Opeating System (Kernel)
• Kernel decide করে → কোন processor কোন process / thread কে execute করবে
• Kernel track রাখে → কোন process এর under এ কয়টি thread থাকে
• Kernel (Modern computer) → execution এর ক্ষেত্রে only thread count রাখে

🧠 Operating System core component → Kernel; Kernel process schedule, concurrency / parallelism handle করে।

🧾 Programming language এর উপর depend করে কীভাবে thread create হবে।

📊 Default Stack Sizes by Platform

[Author: @nazma98 Date: 2025-06-19 Category: interview-qa/class-wise ]

Class 42 : ✨ Complex And Beautiful Go Routine

🌀 Goroutine

• Lightweight thread / Virtual thread
• Logically thread এর মতো কাজ করে
• Concurrently অনেকগুলো function execute করে
• Go Runtime একে manage করে

🛠️ Creating a Goroutine

কোনো function এর আগে go keyword লিখে দিলে সেটা goroutine হয়।

💡 Example

package main

import (
    "fmt"
    "time"
    )

var a = 10

const p = 11

func printHello(num int) {
	fmt.Println("Hello Habib", num)
}

func main() {
	go printHello(1)

	go printHello(2)

	go printHello(3)

	go printHello(4)

	go printHello(5)

	fmt.Println(a, " ", p)

	time.Sleep(5 * time.Second)
}

এই Go কোডে একটা printHello নামের ফাংশন আছে, যেটা "Hello Habib" লিখে সাথে একটা সংখ্যা প্রিন্ট করে।

main() ফাংশনে এই ফাংশনটা ৫ বার goroutine দিয়ে চালানো হয়েছে

সবগুলা goroutine যেন কাজ শেষ করতে পারে, তাই শেষে time.Sleep(5 * time.Second) দিয়ে ৫ সেকেন্ড প্রোগ্রামটাকে অপেক্ষা করানো হয়েছে।

📦 How gorouitne works Internally

Goroutine কীভাবে কাজ করে বুঝার জন্য আমাদের একটি Go program এর compilation, execution phase এবং Thread ভালভাবে বুঝতে হবে।

🔧 Compilation Phase of Go Program

Go program কে compile করার জন্য নিচের command টি ব্যবহার করা হয়

go build main.go

• এতে একটি binary executable file তৈরি হবে (Linux এ main, Windows এ main.exe)
• Binary executable file → Code Segment
• Code Segment → const (read only) → functions
• main binary executable file store → HDD

                        **Code Segment**

			p = 11
			printHello = printHello() {...}
			main = main() {...}

🚀 Execution Phase of Go Program

Binary executable file run করার জন্য command -

./main

• Binary executable file load → RAM
• RAM Memory Layout → Code Segment, Data Segment, Stack, Heap
• main program → Process create হয়

যে কোনও programming language (যেমন C, C++, Go, Rust) এর প্রোগ্রাম যখন compile হয়ে binary (.exe / .out) তে convert হয় এবং execution শুরু হয়, তখন একটা process তৈরি হয় এবং সেই process এর জন্য memory তে Code Segment, Data Segment, Stack, Heap থাকে।

🔍 RAM Memory Layout Visualization

┌──────────────────────────┐
│       Heap               │ ← Grows Upward
├──────────────────────────┤
│     Stack (Top ↓)        │ ← Grows Downward
├──────────────────────────┤
│     Data Segment         │ ← Initialized global/static variables
├──────────────────────────┤
│     Code Segment         │ ← Machine Instructions
└──────────────────────────┘

⚙️ Program Execution Process Visualization

HDD ➜ OS Loader ➜ RAM ➜ CPU Executes

📁 HDD (Hard Disk)
│
│  → Executable File (.exe, .out, etc.)
│
▼
📥 Loader (Operating System)
│
│  → Loads program into RAM
│
▼
🧠 RAM (Main Memory)
│
├── 📄 Code Segment        → compiled machine code (instructions)
│
├── 🗃️ Data Segment        → global & static variables
│
├── 📦 Heap Segment        → dynamic memory (malloc/new)
│
├── 📚 Stack Segment       → function calls, local variables
│
▼
⚡ CPU (Processor)
   ├── Fetch → Decode → Execute instructions
   ├── Uses Registers (like AL, BL, etc.)
   └── Uses Stack Pointer (SP), Base Pointer (BP)

🖥️ Process & Thread

• Process initially একটি Thread থাকে → Deafult Thread / Main Thread
• Thread কে OS এর kernel execute করলে → Stack execute হয়
• Stack execute → Stack frame create & execute হয়

🌀 Go Runtime = A Mini OS or Virtual Operating System

Go program → Run → main binary load → Code Segment

⚙️ main Binary – More Than Just Code Segment

• শুধু code segment নয়
• আরও অনেক binary থাকে
• code segment শুধু একটা অংশ মাত্র

• Thread execute → Process start
• Process → Virtual computer
• Go Runtime → Virtual Operating System
• Process start → Go Runtime execute

🧩 Go Runtime Code Execute

• Stack → 8MB Stack (main stack) → Stack Frame create
• main thread execute করে → Go runtime

Go Runtime initialize করে -

• 1. Go Routine Scheduler
• 2. Heap Allocator
• 3. Garbage Collector
• 4. Logical Processors

Go Routine Scheduler

OS Kernel scheduler → Process schedule, Concurrency, Parallelism handle করে।

Go Routine Scheduler ও Real OS Kernel Scheduler এর মতো কাজ করে।

Logical Processors

🔁 Recap

• CPU কীভাবে Code execute করে

• OS এর ভিতর → virtual processors (vCPU) create হয়
• CPU তে যে কয়টি vCPU (virtual CPU / logical Processor) থাকে → Go Runtime সে কয়টি logical processor create করে
• প্রতিটি logical processor এর জন্য → OS আলাদা OS Thread create করে
  • CPU 2 core → 4 vCPU
  • Go Runtime initilize করে → 4 logical processors
  • 4 logical processors এর জন্য → OS আলাদা 4 OS Thread create করে
  • 4 OS Thread → 4 stack
  • Total threads in process → 4 (OS thread) + 1 (main thread) → 5 threads
  • OS kernel → 5 threads কে track করে
  • 1 main thread এর জন্য → 1 main stack
  • 4 supporting thread এর জন্য → 4 supporting stack
• go runtime kernel → go routine schedule করে
  • 4 thread → 10 goroutine execute করে concurrency follow করে

🧠 Go Runtime: OS Thread, Scheduler, and Logical Processor Mapping

                    🌀 Go Runtime Scheduler
                             │
                             ▼
──────────────────────────────────────────────────────
|                   Logical Processors (P)           |
|────────────────────────────────────────────────────|
|      P1               P2              P3           |
|        										     |
|   [G1, G4, G6]     [G2, G5]        [G3, G7, G8]    |
──────────────────────────────────────────────────────
      │               │              │
      ▼               ▼              ▼
  Assigned to     Assigned to    Assigned to
      │               │              │
      ▼               ▼              ▼
─────────────────────────────────────────────
|             OS Threads (M)                 |
|─────────────────────────────────────────── |
|     M1             M2             M3       |
|   (running)     (running)      (idle)      |
─────────────────────────────────────────────
      │               │
      ▼               ▼
   🖥️ CPU Core 1     🖥️ CPU Core 2

Go runtime, OS Thread কীভাবে create করতে হয় সেটি handle করে।

Go runtime শুরুতেই সিস্টেমের vCPU (logical core) অনুযায়ী Logical Processor (P) তৈরি করে।

• Go Runtime নিজেই একটি kernel এর মতো কাজ করে
• এই "kernel" এর scheduler থাকে
• Scheduler, Goroutine গুলোকে execute করতে OS thread কে কাজ ভাগ করে দেয়
• OS Thread গুলোই CPU তে বসে goroutine গুলো execute করে
• Go Scheduler ঠিক করে কোন goroutine কখন execute হবে
• Scheduler OS thread এ map করে thousands of goroutine efficiently চালায়

🖥️ Go Runtime Kernel & Goroutine Scheduling

                       🌀 Go Runtime (Mini Kernel)
                               │
                               ▼
                      🧠 Go Routine Scheduler (Scheduler)
                               │
      -----------------------------------------------------
      |                       |                           |
      ▼                       ▼                           ▼
  G1: Goroutine         G2: Goroutine               G3: Goroutine
 (Task 1)                 (Task 2)                     (Task 3)
      \_______________________|________________________/
                               │
                               ▼
                    📦 Placed into P's Run Queue
                               │
                               ▼
        🔄 Scheduler decides which G to run on which M
                               │
      -----------------------------------------------------
      |                       |                          |
      ▼                       ▼                          ▼
   🧵 M1: OS Thread        🧵 M2: OS Thread           🧵 M3: OS Thread
 (Executes Gs)          (Executes Gs)              (Executes Gs)
      |                       |                          |
      ▼                       ▼                          ▼
   🖥️ CPU Core 1          🖥️ CPU Core 2             🖥️ CPU Core 3


   → G (goroutine)
   → P (Processor)
   → M (OS Thread)

Programmer Goroutine create করে।

📈🧵 Effects of Excessive Goroutines in Go

• Scheduler notice করে → excessive gorutines
• Go Runtime → প্রয়োজন অনুযায়ী logical processors & OS Thread create করে
• RAM full → OS Thread create করা possible হয় না
• ❌ OS Thread → ❌ Goroutine execution

First যে goroutine run হয় → main goroutine

main function execute হয় → main goroutine এ

🏠 Goroutine's Home: Stack & Heap

Goroutine - mini thread / virtual thread / logical thread

প্রতিটি goroutine

• এর stack থাকে heap memory এ
• শুরুতে মাত্র 2KB stack পায়

main() → Main Goroutine

• Go প্রোগ্রাম রান হলেই main() function চালু হয়
• এটিই প্রথম goroutine - যাকে বলে Main Goroutine
• সব normal function call (যেমন f(), g()) এর stack frame তৈরি হয় এই একই stack এ

go functionName() → New Goroutine

go functionName() লিখলে তখন Go runtime:

• নতুন goroutine তৈরি করে
• সেটার জন্য আলাদা stack তৈরি করে (initially 2KB)
• এটিকে scheduling queue তে দেয়

🖼️ Example

var a = 10

const p = 11

func add(a, b int) {
  fmt.Println(a + b)
}

func printHello(num int) {
	fmt.Println("Hello Habib", num)

     add(2, 4)
}

func main() {
    var x int = 10

    fmt.Println("Hello", x)

    printHello(10)

    go printHello(1)

    go printHello(2)

    go printHello(3)

    go printHello(4)

    go printHello(5)

    fmt.Println(a, " ", p)

    time.Sleep(5 * time.Second)
}

Main Goroutine

• এখানে main() এর জন্য main goroutine create হবে
• main goroutine এ main(), printHello(10) এবং fmt.Println() এর জন্য Stack Frame create হবে
• যদি Go program এ init() থাকে তবে init() এর জন্য ও Stack Frame, main goroutine এ create হবে

Other Goroutines

• printHello() এর জন্য Go runtime ৫টি আলাদা goroutine তৈরি করবে
• go printHello(1) এর জন্য Heap এ যে goroutine create হয় সেখানে printHello(1), fmt.Println() এবং add(2, 4) এর জন্য Stack Frame create হবে
• একই ভাবে অন্য goroutine এর জন্যও Stack Frame create হবে

🔍 যদি 2KB Stack যথেষ্ট না হয়

• ➡️ Go runtime automatically stack এর size বড় করে দেয় (dynamic grow করে)

📈 কিভাবে কাজ করে?

• শুরুতে: 2KB
• দরকার হলে: 4KB, 8KB, 16KB... → যত দরকার তত বাড়তে পারে
• সর্বোচ্চ: 1 GB পর্যন্ত

Go runtime পুরা stack copy করে নতুন বড় stack এ নিয়ে যায়, old stack ফেলে দেয়।

Go Runtime reallocate করতে পারে।

Heap এর Stack এ যে SP, BP থাকে তা মূলত Go Runtime এর initialized logical processor এর SP, BP, return address etc.

                    🧵 Goroutines & Their Stack Memory

┌──────────────────────────────┬─────────────────────────────┬─────────────────────────────┐
│ Goroutine 1 (main)           │ Goroutine 2 (printHello 1)  │ Goroutine 3 (printHello 2)  │
├──────────────────────────────┼─────────────────────────────┼─────────────────────────────┤
│ Stack:                       │ Stack:                      │ Stack:                      │
│ - main()                     │ - printHello(1)             │ - printHello(2)             │
│ - printHello(10)             │ - fmt.Println()             │ - fmt.Println()             │
│ - fmt.Println()              │ - add(2, 4)                 │ - add(2, 4)                 │
└──────────────────────────────┴─────────────────────────────┴─────────────────────────────┘

┌─────────────────────────────┬─────────────────────────────┬──────────────────────────────┐
│ Goroutine 4 (printHello 3)  │ Goroutine 5 (printHello 4)  │ Goroutine 6 (printHello 5)   │
├─────────────────────────────┼─────────────────────────────┼──────────────────────────────┤
│ Stack:                      │ Stack:                      │ Stack:                       │
│ - printHello(3)             │ - printHello(4)             │ - printHello(5)              │
│ - fmt.Println()             │ - fmt.Println()             │ - fmt.Println()              │
│ - add(2, 4)                 │ - add(2, 4)                 │ - add(2, 4)                  │
└─────────────────────────────┴─────────────────────────────┴──────────────────────────────┘

Main goroutine শেষ হলেই পুরো program শেষ, তাই অন্য goroutine চালাতে চাইলে main goroutine কে কিছু সময় বাঁচিয়ে রাখতে হবে ✅

💥 When & How Main Thread, Go Runtime & Main Goroutine Get Destroyed

main thread ≠ main goroutine

goroutine গুলো শেষ পর্যন্ত execute করার জন্য main() কে block করে রাখা যায় যেমন:

• time.Sleep()
• sync.WaitGroup
• select {} (infinite block)

🧵 Thread vs Goroutine

[Author: @nazma98 Date: 2025-06-24 Category: interview-qa/class-wise ]

🌐 Into The Backend Development

🧱 Static Era of Web Development (Web 1.0)

🔹 সময়কাল: Early 1990s

• এই সময়কে Web 1.0 বলা হয়।
• website ছিল একদম Static HTML ফাইলগুলো পূর্বে তৈরি করে সার্ভারে রাখা হতো।

💡 কীভাবে কাজ করতো:

• User যখন একটি webpage চায়, তখন browser server একটি request পাঠাতো।
• server সেই HTML ফাইলকে ইউজারের browser এ পাঠিয়ে দিতো।
• কোনও dynamic content বা user interaction ছিল না।

🖥️ Server কী?

Server একটি কম্পিউটার যেটি নেটওয়ার্কের মাধ্যমে ইউজারের অনুরোধে webpage বা data serve করে।

⚙️ Web 2.0 & Server Side Rendering

🔹 সময়কাল: Mid 1990s - Early 2000s

• Web 2.0 সময়কালে web dynamic হয়ে উঠল।
• এখন backend থেকে dynamically generated HTML, CSS পাঠানো শুরু হল।

✨ Backend Programming Language:

• এই সময়ে জনপ্রিয় কিছু ভাষা ছিল:
  • PHP
  • Java
  • ASP.NET
  • Python

⚡ The AJAX Revolution (2005 - 2010)

🔄 AJAX কী?

AJAX (Asynchronous JavaScript and XML) এর মাধ্যমে browser, page reload না করেই server এর সাথে data আদান-প্রদান করতে পারে।

🔸 API ব্যবহার বাড়ে:

• AJAX এর মাধ্যমে API-এর গুরুত্ব বাড়ে এবং API endpoint ব্যবহার শুরু হয়।

🔹 API Endpoint কী?

API endpoint হল সার্ভারে নির্দিষ্ট একটি URL যেটি ডেটা রিসিভ বা রিটার্ন করার জন্য ব্যবহৃত হয়।

🕰️ আগের সময়ের তুলনা:

• AJAX আসার আগে: ইউজারের অনুরোধে পুরো পেইজ রিলোড হতো।
• AJAX আসার পরে: শুধুমাত্র প্রয়োজনীয় ডেটা JSON আকারে পাঠানো শুরু হয়।

📌 Backend Development এর প্রসার:

• এই সময় থেকে backend বিশেষভাবে important হয়ে ওঠে API design, authentication, data processing ইত্যাদি কাজ শুরু হয়।

🔄 REST API & JSON (2010)

👨‍🔬 REST-এর জনক:

• Dr. Roy Fielding
• REST ধারণা দেন 2000 সালে তার PhD ডিসার্টেশনে।

📖 REST এর পূর্ণরূপ:

Representational State Transfer

📐 REST কী?

REST হচ্ছে একটি software architectural style বা blueprint, যেটা API বানানোর সময় অনুসরণ করা হয়।

🧠 REST Concepts

📌 Representational মানে কী?

Representation বলতে বোঝায় resource এর state কে কিভাবে প্রকাশ করা হচ্ছে।

উদাহরণ: JSON, XML, YAML, HTML ইত্যাদি

📦 Resource & State

🔹 Resource:

Resource হচ্ছে একটি entity বা ধারণা (concept) যেমন: user, post

• user বলতে আমরা বুঝি একজন মানুষ, কিন্তু কে সে সেটা আমরা জানি না।
• post বলতে আমরা বুঝি একটি কনটেন্ট, কিন্তু কী পোস্ট করা হয়েছে জানি না।

🔹 State:

Resource-এর বর্তমান অবস্থা বা condition হলো state।

উদাহরণ:

User:
{
  "id": 42,
  "name": "Shahriar",
  "age": 20
}

Post:
{
  "id": 42,
  "title": "Into the backend development",
  "author": "Shahriar"
}

যখন আমরা এই data-কে JSON এর মতো ফরম্যাটে প্রেজেন্ট করি, তখন সেটিকে বলে Representational State

🔁 Transfer কী?

Client যখন কোনও resource চায়, তখন server সেই resource এর state কে JSON বা অন্য ফরম্যাটে represent করে পাঠায়। এটিই হল Representational State Transfer (REST)।

🔍 REST vs RESTful

একটি RESTful service অনেকগুলি REST API নিয়ে গঠিত হয়।

🧰 What is API?

API (Application Programming Interface) হলো এমন একটি ইন্টারফেস যা দুটি সফটওয়্যারের মধ্যে যোগাযোগ করে।

💬 Frontend ও Backend কিভাবে কথা বলে?

Frontend এবং Backend API-এর মাধ্যমে একে অপরের সাথে যোগাযোগ করে।

উদাহরণস্বরূপ, user form পূরণ করে submit করলে, তা backend API-এর মাধ্যমে প্রক্রিয়াজাত হয় এবং ফলাফল ফিরিয়ে আনা হয়।

[Author : @shahriar-em0n Date: 2025-07-30 Category: interview-qa/class-wise ]

Class 46 : 🐹 Go Runtime

🧠 Guide to RAM: Kernel Space vs User Space

কম্পিউটার চালু হলে RAM (Random Access Memory) কে দুইটা ভাগে ভাগ করা হয়:

• 🛡️ Kernel Space
• 👨‍💻 User Space

🛡️ Kernel Space:

এটা Operating System (OS) এর নিজের জন্য allocated space

এখানে থাকে:

• OS এর মূল কোড (kernel code)
• kernel data structures
• page table (memory mapping এর জন্য)

Kernel সব কিছু access করতে পারে।

🔐 Why it's protected?

• যাতে user program গুলো kernel এর sensitive অংশে ভুল করে বা ইচ্ছা করে access করতে না পারে।
• Security আর stability এর জন্য।

🧩 Access from user programs

• User program যদি OS এর help চায়, তখন system call ব্যবহার করে (যেমন read(), write(), open()).
• তখন একটা software interrupt (যেমন 0x80) তৈরি হয়।
• এতে CPU user mode থেকে kernel mode এ যায়, kernel কাজটা করে দিয়ে আবার ফিরে আসে।

🧵 Kernel Stack

• যখন kernel কাজ করে, তখন একটা kernel stack ব্যবহার করে।
• এটা সব process মিলে share করে।

👨‍💻 User Space:

RAM এর এই space → user application (যেমন browser, notepad) এর জন্য।

প্রতিটা process তার নিজের একটা virtual memory পায়।

এর মধ্যে থাকে:

• Code: প্রোগ্রামের instruction
• Data: global বা static variables
• Heap: dynamic memory allocation (যেমন malloc)
• Stack: function call আর local variables

⚠️ এই space থেকে kernel space সরাসরি access করা যায় না।

🧩 System Call

• System Call হলো একধরনের function call
• এর মাধ্যমে কোন user program, Operating System এর kernel থেকে কোন service চায়
• System Call এর সাহায্য user mode থেকে kernel mode এ সুইচ করে OS এর বিশেষ কাজগুলো করার অনুমতি দেয়

⚙️ User Mode vs Kernel Mode

• সাধারণভাবে program চলে user mode এ, যেখানে resource access সীমিত থাকে।
• কোন special কাজ (যেমন file read/write, process তৈরি) করতে হলে system call দিতে হয়, তখন program kernel mode এ যায়।

✨ Intro to Go Runtime

go build main.go

Go compiler:

• main.go ফাইলটা compile করে
• তারপর একটা binary executable file তৈরি করে - সাধারণভাবে সেটা হয় main নামে (Linux/Unix-এ)

./main

একটা process create হয়

🔁 সংক্ষেপে flow:

go build main.go   →  main (binary file)
./main             →  OS creates a process
                   →  program runs

📦 Main Stack এবং Stack Frame

• Main thread এর জন্য একটি stack তৈরি হয় - এটাকে বলে main stack।
• Go runtime এর function গুলোর জন্য এই main stack এ stack frames তৈরি হয়।
• Main thread → execute → go runtime stack

🔹 Stack Frame: প্রতিটা function call এর জন্য একটা stack frame তৈরি হয়।

Stack frame এর মধ্যে থাকে:

• function এর local variables,
• return address (function শেষে কোথায় ফিরে যাবে),
• কিছু runtime bookkeeping data।

🔹Go Runtime -

• Memory allocate
• Set up → Stack & Heap
• Initialize → Go Scheduler
• Go Runtime → System Call → Kernel → epoll_create

🌀 What is epoll in Linux?

• epoll হলো Linux kernel এর একটি I/O event notification system
• এটি ব্যবহার করা হয় একসাথে অনেকগুলো file descriptor (fd) এর ওপর efficiently নজর রাখার জন্য।

এটি select() বা poll() এর থেকে আরও scalable, efficient, এবং faster।

Linux-এর epoll এর মতো high-performance I/O event notification mechanisms অন্য OS-গুলোতেও আছে

🖥️ MacOS (Darwin/BSD) ➤ kqueue

• Equivalent of epoll in macOS is kqueue.
• এটি BSD-based systems (macOS, FreeBSD, OpenBSD) এ ব্যবহৃত হয়।

🪟 Windows ➤ IOCP (I/O Completion Ports)

• Windows-এর equivalent হল ➤ IOCP (I/O Completion Ports)।

🔹 IOCP-এর কাজ:

• Asynchronous I/O operations handle করতে ব্যবহৃত হয়।
• Efficient এবং scalable, especially high-performance servers-এর জন্য।

🧠 epoll কবে দরকার হয়?

• Network socket
• File
• Pipe

ইত্যাদি একসাথে monitor করতে এবং কোনটা read/write এর জন্য ready হয়েছে

epfd = epoll_create1(0);                // epoll instance তৈরি
epoll_ctl(epfd, ADD, sockfd, &event);   // কোন socket watch করবো?
epoll_wait(epfd, events, MAX, timeout); // wait করবো কখন data আসবে

🔧 epoll এর জন্য ব্যবহৃত ৩টি main syscall

epoll_create / epoll_create1

• একটি নতুন epoll instance তৈরি করে এবং একটি file descriptor (fd) রিটার্ন করে।
• এই fd কে ব্যবহার করে আপনি পরবর্তীতে ইভেন্ট monitor করবেন।

epoll_ctl

• epoll instance এ কোন file descriptor monitor করতে হবে সেটা বলে দেয়।
• অর্থাৎ: add / modify / delete operation।

epoll_wait

• এটি block করে (অপেক্ষা করে) যতক্ষণ না কোন monitored file descriptor থেকে I/O event আসে।
• যখন আসে, তখন সেই event return করে দেয়।

🏷️ Scenario: epoll-based Non-blocking File Read in Linux

Process & Threads

• P1: T1, T2
• P2: T1
• P3: T1, T2, T3

P1-T1 একটি ফাইল পড়তে চায়, অর্থাৎ I/O operation করতে চায়।

আমরা ধরছি এটা non-blocking I/O এবং epoll ব্যবহৃত হচ্ছে (Linux system)।

১️⃣ T1 ফাইল পড়তে চায়

• T1 kernel-এ read request পাঠায়, কিন্তু ফাইল তখনও রেডি না।
• তাই T1 বলে, "ফাইল রেডি হলে আমাকে জানিও" — non-blocking mode

2️⃣ T1 syscall করে → epoll_ctl

• এটা দিয়ে kernel-কে জানানো হয়:
• "এই ফাইলের জন্য আমি অপেক্ষা করবো। ফাইলটা read করতে পারলেই আমাকে ডাকো।"

3️⃣ Kernel T1 কে ঘুম পাড়িয়ে দেয়

• যেহেতু ফাইল এখনো রেডি না, তাই kernel T1 কে sleep/wait করিয়ে দেয়।
• T1 wait queue তে চলে যায়
• তখন P1-এর অন্য থ্রেড T2, বা অন্য প্রসেসের থ্রেডগুলো স্বাভাবিকভাবে কাজ করে

4️⃣ kernel ফাইল চেক করতে থাকে

• kernel backend-এ ফাইল ready কিনা সেটা monitor করে।
• যখন ফাইলটা readable হয়ে যায়, তখন kernel ফাইলটা load করে, এবং ফাইলের জন্য file descriptor তৈরি করে

5️⃣ kernel epoll কে notify করে

• kernel epoll_wait কে বলে: "এই file descriptor এখন ready"
• epoll_wait তখন সেই FD কে ready list-এ রাখে

6️⃣ epoll_wait Thread কে জাগিয়ে তোলে

epoll_wait এর কাজ:

• যারা অপেক্ষা করছিল, তাদের জানিয়ে দেয়া "তোমার ফাইল রেডি"
• T1 এখন wake up হয়

7️⃣ T1 এখন read(fd) দিয়ে ফাইল পড়ে

• এবার T1 ফাইলটি read করে নেয় file descriptor ব্যবহার করে
• File descriptor একটি token এর মতো কাজ করে — এটি বলে দেয় kernel-এর কোন জায়গা থেকে ফাইল পড়তে হবে

📦 File descriptor

• File descriptor হচ্ছে kernel-এর একটি token বা ID যা file/socket-এর represent করে।
• User-space access করতে পারে না, কিন্তু kernel আর Go runtime, file/socket কে চিনে ফেলে এই FD দিয়ে।

🚀 Back to Go Runtime Story

1. Go Runtime শুরুতেই কী করে?

• Go runtime নিজের মধ্যে একটা epoll instance তৈরি করে (epoll_create syscall ব্যবহার করে)।
• যখন epoll তৈরি করে, তখন kernel-কে বলে দেয় কতগুলো file descriptor (FD) একসাথে পড়তে চায়
  • Go Runtime kernel-কে বলে দেয় 100 file descriptor (FD) একসাথে পড়তে চায়
  • Max 100 FD read করার জন্য epoll_ctl send করা যাবে kernel এর কাছে
  • 100 FD list আকারে epoll_wait thread কে দিয়ে দিবে
  • epoll_wait thread FD list Go runtime কে দিয়ে দিবে
• এই instance handle করে সব network I/O বা file I/O অপারেশন।
• এরপর Go runtime একটি আলাদা OS thread তৈরি করে যেখানে epoll_wait বসে থাকে। এই থ্রেডকে বলা যায় "Netpoller Thread"।

2. একটি goroutine file/socket read করতে চায়

• main goroutine (যেমন go func() { conn.Read() }) socket থেকে কিছু পড়তে চায়।
• যদি data তখনই available না থাকে, Go runtime:
  • ওই goroutine কে block না করে park (ঘুম পাড়িয়ে) দেয়।
  • একইসাথে, সেই socket বা file descriptor কে epoll instance-এ register করে রাখে (epoll_ctl দিয়ে)।

3. epoll_wait কী করে?

• আলাদা Netpoller Thread সবসময় epoll_wait syscall চালিয়ে ঘুমিয়ে থাকে।
• যখন kernel detect করে যে socket/data ready, তখন সেই Netpoller Thread কে wake করে দিয়ে data দেয়।
• এরপর Netpoller জানায় যে fd ready।

4. Go Runtime পুনরায় goroutine চালু করে

• Go runtime বুঝে যায় যে যে goroutine file/socket read করতে চেয়েছিল তার data এসে গেছে।
• তাকে আবার runnable করে দেয়, এবং data পড়া শুরু হয়।

⚙️ Setting Up Garbage Collector (GC)

• Go runtime GC চালানোর জন্য আলাদা OS thread ব্যবহার করে, যাতে প্রোগ্রামের মূল কাজ বিঘ্ন না ঘটে
• thread গুলো background-এ silently কাজ করে memory clean রাখে
• Go Runtime পুরোপুরি GC thread control করে

🧠 Go Scheduling

Go runtime M:P:G model scheduling follow করে, যেখানে

• M = Machine (OS-level Thread) — যেটা বাস্তবে CPU-তে কাজ চালায়।
• P = Processor (Logical Processor) — এটি goroutine run করার জন্য প্রয়োজনীয় execution context ধরে রাখে, যেমন: local run queue, stack, scheduler info ইত্যাদি।
• G = Goroutine — আমরা যেসব Go function/logic concurrently চালাই, এগুলোকে Go runtime “goroutine” নামে চালায়।

🏗️ Go Scheduler Initialization

M (Machine, বা OS Thread) তৈরি

Go runtime শুরুতেই exactly vCPU সংখ্যক machine thread (M) তৈরির জন্য OS কে request করে।

• 1 core → 2 vCPU → 2 M
• 2 core → 4 vCPU → 4 M

P (Logical Processor) তৈরি

🔹 Go runtime M সংখ্যক "Logical Processor" তৈরি করে, যাকে P বলা হয়

• 4 M : 4 P

🔹 এই P গুলো দেখতে অনেকটা Virtual CPU (vCPU) এর মতো

🔹 কিন্তু এগুলো hardware vCPU না, বরং Go runtime এর internal scheduling unit

G (Goroutine) তৈরি

🔸 Go runtime-এর সবচেয়ে lightweight execution unit হচ্ছে Goroutine (G)

🔸 প্রতিটি go someFunction() কল করলে নতুন একটা goroutine তৈরি হয়

🧩 Go Scheduler: 1M : 1P : 2G Diagram

মনে করি, 1M:1P:2G — এবং মনে হচ্ছে 1P দুইটা goroutine একসাথে চালাচ্ছে, আর 1M চালাচ্ছে সেই 1P-কে

                        ┌──────────────┐
                        │   Machine M  │  ← OS Thread (Executes G via P)
                        └──────┬───────┘
                               │
                               ▼
                        ┌──────────────┐
                        │ Logical P    │  ← Holds G run queue
                        └──────┬───────┘
                               │
                ┌──────────────┴──────────────┐
                ▼                             ▼
        ┌──────────────┐             ┌──────────────┐
        │ Goroutine G1 │             │ Goroutine G2 │
        └──────────────┘             └──────────────┘

🧠 1 Core Scenario in Go Scheduler

✅ Initialization Phase:

• OS থেকে পাওয়া যায় → 1 Core ⇒ 2 vCPU
• তাই Go runtime তৈরি করে:
  • 2 Machine Thread (M)
  • 2 Logical Processor (P)

          🧠 Physical Core (1)
                │
        ╔═══════╧════════╗
        ▼                ▼
     M1 (Thread)      M2 (Thread)
       │                 │
       ▼                 ▼
    ┌─────┐           ┌─────┐
    │  P1 │           │  P2 │
    └─┬───┘           └─┬───┘
      │                 │

┌───▼───┐ ┌───▼───┐
│ G1,G2 │ │ G3,G4 │ ← Each P has its G queue
└───────┘ └───────┘

🧪 Run Queue

Go এর scheduler-এ ২ ধরনের run queue থাকে

🧵 ১. Local Run Queue (per P)

প্রতিটি Logical Processor (P) এর নিজস্ব একটি Run Queue থাকে, যেখানে goroutine (G) গুলো রাখা হয়।

🧩 কীভাবে কাজ করে:

• প্রতিটি P একটি fixed-size circular run queue মেইনটেইন করে যা ring এর মতো
• প্রতিটি Local Run Queue এর slot 256 → 256 goroutine
• প্রতিটি P তার queue এর G গুলোকে FIFO ভিত্তিতে চালায় (First-In-First-Out).
• যেই P বর্তমানে M দ্বারা চালিত হচ্ছে, সেই P তার queue থেকে goroutine G নিয়ে চালায়।
• যদি কোন G ব্লক করে (I/O, sleep etc), তাহলে P আবার queue থেকে নতুন G চালায়।
• যদি P এর queue খালি হয়ে যায়, তাহলে:
  • সে work stealing করে — অন্য P এর queue থেকে G চুরি করে নেয়।

🌍 ২. Global Run Queue

যেসব goroutine-কে কোনো নির্দিষ্ট P-তে assign করা যায় না, সেগুলো Global Run Queue-তে রাখা হয়।

• System-wide queue, সব P access করতে পারে।
• Locking দরকার পড়ে, তাই একটু ধীর।
• যখন কোনো P-র local queue খালি হয়, তখন সে Global queue থেকে কাজ নেয়।

🔐 Locking হচ্ছে এমন একটা ব্যবস্থা, যেটা দিয়ে একই সময় একাধিক goroutine যেন একসাথে একই জিনিসে হাত না দিতে পারে, সেটা নিশ্চিত করা হয়।

• newly created goroutines যে local run queue তে জায়গা পাবে বসে যাবে।

• logical processor free থাকলে local run queue থেকে goroutine নিয়ে execute করতে থাকে।

• প্রতিটি local run queue একটি করে goroutine execute করে এবং slot গুলোতে 256 টি করে goroutines থাকলে newly created goroutines গুলো global run queue তে গিয়ে বসে

• যদি local run queue খালি হয়ে যায়, তাহলে সে অন্য P এর queue থেকে half goroutines নিয়ে নেয় (this is called Work Stealing).

• কোন processor free হলে এবং এর local run queue তে কোন goroutine না থাকলে, এবং অন্য logical processor এর local run queue তেও goroutines না থাকলে (এক্ষেত্রে work stealing করতে পারেনা) এটি global run queue থেকে goroutines নিয়ে execute করে

🔹 Execution of main.go

package main

import (
	"fmt"
	"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	fmt.Fprintln(w, "hello world")
}

func aboutHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "About page")
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/", handler)
	mux.HandleFunc("/about", aboutHandler)

	fmt.Println("Server running on :8080")
	err := http.ListenAndServe(":8080", mux)
	if err != nil {
		fmt.Println("Error starting server", err)
	}
}

go build main.go
./main

📦 Go Program Memory Layout

                        +----------------------------+
                        |        Code Segment        |
                        |----------------------------|
                        | - func handler             |
                        | - func aboutHandler        |
                        | - func main                |
                        | - imported fmt, net/http   |
                        +----------------------------+

                        +----------------------------+
                        |       Data Segment         |
                        |----------------------------|
                        | - Static/global data       |
                        | - Function/method metadata |
                        | - String constants         |
                        |   e.g., "hello world"      |
                        |         "About page"       |
                        |         ":8080"            |
                        +----------------------------+

                        +----------------------------+
                        |           Heap             |
                        |----------------------------|
                        | - Dynamically allocated    |
                        |   memory during runtime    |
                        | - mux := http.NewServeMux()|
                        | - Each request's data      |
                        | - Goroutines' data         |
                        +----------------------------+

                        +----------------------------+
                        |           Stack            |
                        |----------------------------|
                        | - Go Runtime Code          |
                        |                            |
                        +----------------------------+

🌀 Go HTTP Server Execution

🔹 ১. Go রানটাইম চালু হওয়ার শুরুতে:

• Go প্রোগ্রাম চালু হলে:
  • প্রথমে init() ফাংশনগুলো (যদি থাকে) execute হয়।
  • এরপর memory layout অনুযায়ী code segment, data segment, ইত্যাদি সেটআপ হয়।

🔹 ২. Main Thread & Stack Setup

• Go runtime একটা main OS thread তৈরি করে।
• এই থ্রেডের জন্য একটা main stack allocate করে।
• এই stack-এ runtime code ও অন্যান্য execution চলবে।

🔹 ৩. Main Goroutine তৈরি

• Go automatically একটা main goroutine তৈরি করে।
• এর initial stack size হয় 2KB (heap-এ allocate করা হয়)।
• এই goroutine থাকবে local run queue-তে।

🔹 ৪. Scheduler এবং Processor

• Go runtime-এ আছে:
  • M (Machine = Thread)
  • P (Processor = Logical executor)
  • G (Goroutine)
• যখন Go start হয়, main goroutine local run queue তে enqueue হয়।
• একটি P (logical processor) active থাকে — শুধু সে কাজ করে কারণ এই মুহূর্তে একমাত্র main goroutine-টাই active।
• অন্য P গুলো sleep করে থাকবে যদি আর কোনো goroutine না থাকে।

🔹 ৫. main() Function Execution শুরু

• Main goroutine-এর ভিতর:
  • main() function-এর জন্য একটা stack frame তৈরি হয়।
  • তারপর main() ফাংশনের ভিতরের কোড execute হতে থাকে।

🔹 ৬. Router Creation

• http.NewServeMux() কল করা হয়:
  • এটি একটি ServeMux object তৈরি করে।
  • এই object টি main goroutine-এর stack frame এ থাকে।

🔹 ৭. Route Register

• mux.Handle("/", handler):
  • Mux object-এর ভিতরে route pattern ও handler function register হয়।
  • এগুলো map আকারে ServeMux struct-এ store হয়।

🔹 ৮. Server Start

• http.ListenAndServe(":8080", mux):
  • এটা main goroutine থেকে call হয়।
  • এর জন্য একটি নতুন stack frame তৈরি হয়।

🔹 ৯. Internal serve() Call

• ListenAndServe() এর ভিতর:
  • srv.Serve(l net.Listener) function call হয়।
  • এর জন্য আরেকটি stack frame তৈরি হয়।

🔂 🔁 ১০. Server-এর Infinite Loop

• Serve() function-এর ভিতরে থাকে একটি infinite for loop:
  • যেটা প্রতি iteration-এ করে:
    • Accept() করে নতুন connection।
    • প্রতিটি connection এর জন্য নতুন goroutine তৈরি করে।
    • সেই goroutine handle করে HTTP request-response।

Program Start
│
├─> Execute init()
├─> Setup code/data segment
├─> Create main thread + main stack
├─> Create main goroutine (2KB heap stack)
│
└─> main goroutine enqueued → local run queue → executed by P

Main Goroutine:
│
├─> main() stack frame created
│ ├─> mux := http.NewServeMux()
│ ├─> mux.Handle("/", handler)
│ └─> http.ListenAndServe(":8080", mux)
│ └─> srv.Serve(listener)
│ └─> infinite for loop
│ └─> accept conn → new goroutine → handle request

for {
    rw, err := l.Accept()
    go c.serve(connCtx)
}

🧠 Go HTTP Server accepts connection and handles it

🔹 ১. l.Accept() কল হয়

• এটি একটি network socket accept call।
• এর জন্য একটি নতুন stack frame তৈরি হয়।
• এর কাজ হচ্ছে:
  • নতুন কেউ connect করতে চাইলে, তার সাথে communication শুরু করা।

🔹 ২. Accept() কী করে?

• main goroutine → Accept() call করে → এটি Go runtime কে বলে:
  • “আমাকে একটা socket দাও, যাতে আমি নতুন connection handle করতে পারি।”
  • Go runtime তখন দেখে, “আমার কাছে কি socket আগে থেকেই ready আছে?”

🔹 ৩. Socket না থাকলে কী হয়?

• যদি socket না থাকে:
  • Go runtime → epoll_ctl() call করে → kernel কে বলে:
    • “তুমি একটা socket তৈরি করো এবং future-এ ready হলে আমাকে জানিও।”
• এই কাজটা Go-এর netpoll library এর মাধ্যমে করা হয়।

🔹 ৪. epoll_ctl → kernel

• epoll_ctl() একটা asynchronous system call:
  • মানে এটা main goroutine কে block করে না।
  • Go runtime meanwhile অন্যান্য কাজ চালাতে পারে।

🔹 ৫. Linux kernel কী করে?

• Linux-এ সবকিছু file হিসেবে treat করা হয় (socket, file, device — সবকিছু)।
• Kernel একটি socket তৈরি করে — এটা এক প্রান্ত যা দিয়ে data পাঠানো ও গ্রহণ করা যায় (like pipe)।
• এই socket-এর জন্য kernel একটি file descriptor (FD) দেয়।
  • যেমন, ধরো FD = 5

🔹 ৬. Main Thread Sleep করে

• main goroutine তখন sleep করে থাকে, কারণ সে অপেক্ষা করছে নতুন socket connection-এর জন্য।
• কিন্তু এই সময়েও Go runtime বন্ধ হয় না — অন্যান্য goroutine গুলো চালু থাকতে পারে।

🔹 ৭. New Connection এলে

• কেউ যখন connect করে:
  • Kernel বলে: “এই socket (FD 5) now ready!”
  • Go runtime এর netpoller জেগে উঠে (via epoll_wait) এবং সেই connection গ্রহণ করে।

🔹 ৮. New goroutine handle করে

• তারপর Go runtime:
  • go c.serve(connCtx) কল করে
  • নতুন goroutine তৈরি হয় → এটি সেই connection এর request/response handle করে

🌐 যখন একটি HTTP Request করা হয় — ভিতরের জগৎ (Go HTTP Server + OS + NIC + Kernel)

🔹 ১. ব্রাউজারে আমরা URL দিই (যেমন: http://localhost:8080/)

• এই request প্রথমে যায় router → router → server router এর দিকে (DNS resolve ধরে নেওয়া হয়েছে)।

🔹 ২. Server এর Network Interface

• Server-side এর Network Interface Controller (NIC) — হতে পারে Ethernet Cable বা Wi-Fi Adapter — এই request ধরে।
• এই NIC data গুলো লেখে তার NIC Receive Buffer (RAM এর একটা অংশ) এ।

**🔹 ৩. NIC Interrupt **

• যেই মুহূর্তে NIC data পায়, সে তখন Interrupt Signal পাঠায় Kernel কে।
• Kernel তখন এসে NIC Receive Buffer থেকে data পড়ে।

🔹 ৪. Kernel → Socket Receive Buffer

• Kernel data কে write করে Socket Receive Buffer এ (যেটা File Descriptor fd 5 এর সাথে যুক্ত)।

🔹 ৫. Kernel → fd 5 Ready

• এরপর Kernel fd 5 কে ready for read হিসেবে mark করে।

🔹 ৬. epoll_wait() → Wake Up

• যেহেতু Go runtime epoll_wait() দিয়ে অপেক্ষা করছিল, kernel এখন:
  • সেই sleeping epoll_wait() thread কে wake করে।
  • এবং বলে: “fd 5 এখন ready।”

🔹 ৭. epoll_wait → Go Runtime

• epoll_wait() এই fd 5 কে Go runtime এর কাছে পাঠায়।

🔹 ৮. Go Runtime → Sleeping Goroutines

• Go runtime দেখে, “এই fd 5 এর জন্য কোনো goroutine আগে থেকে ঘুমিয়ে ছিলো?”
• যদি থাকে, তবে সেই goroutine কে wake করে।
• এরপর Go runtime এর scheduler সেই goroutine কে Local Run Queue তে রাখে।
• একটি Logical Processor (P) সেই goroutine টি চালানোর জন্য একটি dedicated OS thread (M) পায়।

🔹 🔁 Execution শুরু

• সেই Logical Processor এখন main goroutine execute করে।
• Go runtime fd 5 কে main goroutine এর কাছে পাঠায়।

🔹 🔍 Data Read হয়

• এখন main goroutine fd 5 থেকে data পড়ে
• socket receive buffer থেকে data আসে
• rw → data store হয়

🔹 🚀 Serve করার জন্য নতুন goroutine তৈরি

• এরপর Go runtime go c.serve(connCtx) কল করে
  -নতুন একটা goroutine তৈরি হয়

এই goroutine টি rw তে থাকা data ব্যবহার করে HTTP request handle করে।

🔄 পরবর্তী request-এর জন্য অপেক্ষা

• এরপর main goroutine আবার l.Accept() এ যায়।
• Go runtime জানে যে আগেই socket (fd 5) তৈরি হয়েছে।
• সে এখন new incoming request এর জন্য অপেক্ষা করে।

🔁 নতুন data এলে আবারো একই cycle

• NIC → kernel → socket receive buffer → mark fd ready → wake epoll_wait

• Go runtime → wake goroutine → read → serve

এভাবেই একটি HTTP server concurrency + efficiency সহকারে thousands of connections handle করতে পারে।

Client Request (Browser)
↓
Router → Server NIC → NIC Buffer (RAM)
↓ (Interrupt)
Linux Kernel → Copy to Socket Buffer (fd 5)
↓
Mark fd 5 ready → Wake epoll_wait()
↓
Go Runtime → Finds sleeping goroutine
↓
Wake up → Scheduler → Local Run Queue → OS Thread
↓
Execute main goroutine
↓
main goroutine reads from fd 5 → rw = l.Accept()
↓
go c.serve(connCtx) → spawn goroutine to handle
↓
main goroutine again waits for next request...

📦 Newly Spawned goroutine

• যখন go c.serve(connCtx) এর মাধ্যমে একটি নতুন goroutine spawn করা হয়, তখন একটি নতুন stack তৈরি হয়, এবং এই stack টি heap memory এর মধ্যে সংরক্ষিত হয়।
• Go তে goroutine এর stack ছোট (প্রথমে 2KB), কিন্তু এটি dynamic ভাবে বাড়তে পারে।
• এই goroutine টি তারপর local run queue তে যুক্ত হয়, যেখানে অনেক goroutine লাইন ধরে অপেক্ষা করে।
• প্রতিটি logical processor (P) এর সাথে একটি dedicated OS thread (M) mapped থাকে। এই logical processor (P) সেই local run queue থেকে goroutine টিকে তুলে নেয় এবং execution শুরু করে।

🧵 goroutine spawn = “নতুন একটি lightweight thread তৈরি করে সেটাকে চালু করা।”

✅ mux এবং handler execution ধাপ:

• এর আগে server এর মধ্যে mux (যেমন http.NewServeMux()) তৈরি করা হয়েছে এবং সেখানে HandleFunc() এর মাধ্যমে route ও handler function register করা হয়েছে।
• goroutine ওই router-এর মধ্যে খুঁজে দেখে, request-এর URL path /about এর মতো কোন route এর সাথে match করে কিনা।
• নতুন goroutine যখন চালু হয়, তখন request-এর URL path, header, এবং অন্যান্য metadata দেখে বোঝার চেষ্টা করে, কোন route বা path টি মিলে যাচ্ছে।
• যখন একটি HTTP request আসে, তখন router চেক করে সেই URL path এর সাথে কোন pattern match করছে এবং সেই অনুযায়ী handler function execute করে।
  • যেমন goroutine ওই router-এর মধ্যে খুঁজে দেখে, request-এর URL path /about এর মতো কোন route এর সাথে match করে কিনা।
  • /about path এর জন্য aboutHandler() নামের handler function register করা আছে।
• handler match হবার পর, সেই matched handler function এর জন্য একটি নতুন stack frame তৈরি হয়, যাতে ওই ফাংশনটি তার কোড execute করতে পারে।
  • যখন aboutHandler() চালু হয়:
    • তার জন্য একটি নতুন stack frame তৈরি হয়, যাতে ফাংশনের ভিতরের কোড execute করা যায়।
    • এই ফাংশন w (response writer) & fprintln এর মাধ্যমে socket এর কাছে "About page" write করে।
    • socket send buffer এ syscall এর মাধ্যমে data store হয়।

🧠 NIC-এ ডেটা যাওয়ার প্রসেস

• Go app থেকে socket
  • fmt.Fprintln(w, "About page") → Go runtime ResponseWriter এর ভিতরে Write() method call করে → অবশেষে syscall.Write() এর মাধ্যমে kernel socket send buffer এ data জমা হয়।
  • ResponseWriter.Write() → অবশেষে Go syscall layer-এ গিয়ে syscall.Write() call হয়।
  • syscall.Write() এর মাধ্যমে data kernel space-এ যায় এবং Socket Send Buffer এ জমা হয়।
  • Kernel তখন socket FD (File Descriptor) অনুযায়ী check করে data ready কিনা।
• Kernel থেকে NIC
  • Kernel-এর network stack সেই data কে প্যাকেট করে (TCP/IP header সহ) NIC-এর TX (Transmit) ring buffer-এ লেখা হয় (এটা hardware circular queue)।
• NIC প্যাকেট নেয় এবং Physical Layer-এ পাঠায়
  • NIC Controller → DMA (Direct Memory Access) দিয়ে data ring buffer থেকে পড়ে → electromagnetic signal আকারে Ethernet cable / WiFi দিয়ে router/switch-এর দিকে পাঠায়।
• Router hopping
  • একাধিক router, switch এবং network node পার হয়ে destination client (user-এর PC বা mobile) পর্যন্ত পৌঁছায়।
• Client receives
  • Client এর NIC → OS → Browser → renders "About page"

+--------------------+               +-----------------+
|  Go Application    |               |     Kernel      |
|--------------------|               |-----------------|
| fmt.Fprintln(w,…)  |               |                 |
|   ↓                |               | syscall.Write() |
| ResponseWriter     |               |   ↓             |
|   ↓                |               | Socket Buffer   |
+--------------------+               |   ↓             |
                                     | NIC Driver      |
                                     +--------↓--------+
                                              |
                           +------------------↓-------------------+
                           |       NIC TX Ring Buffer (DMA)       |
                           +------------------↓-------------------+
                                              |
                                 Electromagnetic Signal
                                              ↓
                                        Ethernet/WiFi
                                              ↓
                                           Router
                                              ↓
                                          Client PC
                                        "About page"

[Author: @nazma98 Date: 2025-07-30 Category: interview-qa/class-wise ]

Topic wise

[Author: @mdimamhosen, @mahabubulhasibshawon Date: 2025-04-19 Category: interview-qa/arrays Tags: [go, arrays, functions] ]

Go তে Array

Array declare করা

Go-তে নিচের syntax ব্যবহার করে array declare করা যায়:

var arrayName [size]elementType

উদাহরণ:

var numbers [5]int

Arrays initialize করা

Array declare করার সময় Array initialize করা যেতে পারে:

var numbers = [5]int{1, 2, 3, 4, 5}

অথবা short-hand notation ব্যবহার করতে পারেন:

numbers := [5]int{1, 2, 3, 4, 5}

Array element access করা

Array এর element index ব্যবহার করে access করা যায়, যেটি 0 থেকে শুরু হয়:

fmt.Println(numbers[0]) // Output: 1

Array তে loop run করা

for loop ব্যবহার করে Array উপর loop run করা যায়:

for i := 0; i < len(numbers); i++ {
    fmt.Println(numbers[i])
}

অথবা range keyword ব্যবহার করতে পারেন:

for index, value := range numbers {
    fmt.Println(index, value)
}

Multidimensional Arrays

Go multidimensional array সাপোর্ট করে। একটি two-dimensional array নিচেরভাবে declare করা হয়:

var matrix [3][3]int

উদাহরণ:

matrix := [3][3]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
}

Array of Arrays

array of arrays হলো এমন একটি data structure, যেখানে একটি array প্রতিটি element আরেকটি array বা slice। এটি সাধারণত variable সাইজের 2D data রাখার জন্য ব্যবহৃত হয়, যেমন প্রতিটি row তে ভিন্ন ভিন্ন element থাকতে পারে।

উদাহরণ:

arrayOfArrays := [][]int{
    {1, 2},
    {3, 4, 5},
    {6},
}

ফাংশনে Arrays পাঠানো

Go-তে array ফাংশনে পাঠানো হয় value হিসেবে, অর্থাৎ ফাংশনটি array এর একটি copy পায়:

func printArray(arr [5]int) {
    for i := 0; i < len(arr); i++ {
        fmt.Println(arr[i])
    }
}

মূল array পরিবর্তন করতে হলে, আপনাকে array এর pointer পাঠাতে হবে:

func modifyArray(arr *[5]int) {
    arr[0] = 100
}

Frequently Asked Questions

Q1: Go-তে কিভাবে array এর দৈর্ঘ্য নির্ধারণ করব?

array এর দৈর্ঘ্য নির্ধারণ করতে len() built-in function ব্যবহার করুন।

উদাহরণ:

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    fmt.Println("Length of the array:", len(arr)) // Output: 5
}

Q2: Go-তে কিভাবে একটি array copy করব?

Go-তে array copy করার জন্য আপনি সেটিকে একই type এবং size এর অন্য array তে assign করতে পারেন।

উদাহরণ:

package main

import "fmt"

func main() {
    original := [3]int{1, 2, 3}
    copy := original
    fmt.Println("Original:", original) // Output: [1 2 3]
    fmt.Println("Copy:", copy)         // Output: [1 2 3]
}

Q3: কিভাবে copy না করে function এ array পাঠিয়ে সেটিকে পরিবর্তন করা যায়?

copy না করে পরিবর্তন করতে চাইলে array এর pointer পাঠান।

উদাহরণ:

package main

import "fmt"

func modifyArray(arr *[3]int) {
    arr[0] = 42
}

func main() {
    arr := [3]int{1, 2, 3}
    modifyArray(&arr)
    fmt.Println("Modified array:", arr) // Output: [42 2 3]
}

test করার জন্য উদাহরণ: main.go

package main

import "fmt"

func main() {
	arr1 := [5]int{1, 2, 3, 4, 5}
	arr2 := [5]int{1, 2, 3, 4, 5}

	fmt.Println(arr1)
	fmt.Println(arr2)

	var arr3 [5]int
	// fmt.Println(arr3) // this should print [0 0 0 0 0]
	// println("Length:", len(arr3))

	for i := 0; i < len(arr3); i++ {
	    fmt.Scan(&arr3[i])
	}
	fmt.Println(arr3)

	strArr := [3]string{"one", "two", "three"}

	for i := 0; i < len(strArr); i++ {
		fmt.Print(strArr[i]+ "")
	}


}

[Author: @mdimamhosen, @n8fury Date: 2025-04-19 Category: interview-qa/boolean Tags: [go, boolean, data-types] ]

একটি boolean data-type হয় "TRUE" অথবা "FALSE" হতে পারে

package main
import "fmt"
func main() {
 isGolangPL := true
 isHtmlPL := false
 fmt.Println(isGolangPL)
 fmt.Println(isHtmlPL)
}

Frequently Asked Questions

Q1: conditional statement এ boolean value কিভাবে ব্যবহার করব?

উত্তর: Boolean value সাধারণত conditional statement এ program এর flow control করার জন্য ব্যবহার করা হয়। উদাহরণ:

package main
import "fmt"
func main() {
 isEven := true
 if isEven {
  fmt.Println("The number is even.")
 } else {
  fmt.Println("The number is odd.")
 }
}

Q2: boolean value গুলো কি সরাসরি compare করা যায়?

উত্তর: হ্যাঁ, boolean value গুলো comparison operator ব্যবহার করে সরাসরি compare করা যায়। উদাহরণ:

package main
import "fmt"
func main() {
 isTrue := true
 isFalse := false
 fmt.Println(isTrue == isFalse) // আউটপুট: false
 fmt.Println(isTrue != isFalse) // আউটপুট: true
}

Callback Functions

If a function is passed as an argument to another function, then such types of functions are known as a Higher-Order function. This passing function as an argument is also known as a callback function or first-class function in the Go language.

package main
import "fmt"

func addName(name string, callback func(string)) {
    callback(name)
}

func main() {
    addName("HuXn", func(nm string) {
        fmt.Printf("Hi, my name is %v\n", nm)
    })
}

[Author: @mdimamhosen, @mahabubulhasibshawon Date: 2025-04-22 Category: interview-qa/arrays Tags: [go, clousers, functions] ]

Closure

🔁 Program Code Example

package main

import "fmt"

const a = 10
var b = 20

func Outer() func() {
	// Outer function variables
	money := 100
	age := 20

	fmt.Println("Outer function")
	fmt.Println("Age:", age)

	show := func() {
		money += a + b
		fmt.Println("Money:", money)
	}

	return show
}

func call() {
	inc := Outer()
	inc()
	inc()
	fmt.Println("=========================")
	inc1 := Outer()
	inc1()
	inc1()
}

func main() {
	call()
}

func init() {
	fmt.Print("============ Begin ============\n")
}

⚙️ Code Execution ধাপসমূহ

🧩 ধাপ ১: Compilation

• Compile করে binary তৈরি করুন:

go build main.go

🚀 ধাপ ২: Execution

• Binary run করুন:

./main

🔒 Go-তে Closures

✅ Closure কী?

Closure হলো এমন একটি funtion, যা অন্য একটি funtion এর ভিতরে define করা হয় এবং যা তার নিজের scope ছাড়াও তার outer scope থাকা variable গুলোকে মনে রাখে এবং ব্যবহার করতে পারে, এমনকি সেই outer scope টি execute হওয়া শেষ হয়ে গেলেও।

func Outer() func() {
    money := 100
    show := func() {
        money += 10
        fmt.Println("Money:", money)
    }
    return show
}

• money variable টি inner function দ্বারা capture করা হয়।
• প্রতিবার call করলে money update হয়।

✅ Multiple Closures

• প্রতিবার Outer() call করলে নতুন money instance তৈরি হয়, যা অন্যগুলোর থেকে আলাদা।

🧠 Output ব্যাখ্যা

init() runs first: ============ Begin ============

Outer function  
Age: 20  
Money: 130  
Money: 160  
=========================  
Outer function  
Age: 20  
Money: 130  
Money: 160

• দুইটি closure তৈরি হয়েছে, প্রতিটির নিজস্ব money instance আছে।
• এরা একে অপরকে প্রভাবিত করে না।

🧱 Memory segment বিশ্লেষণ

🧠 Visualization

CLI-style Memory বিন্যাস

┌──────────────────────────────┐
│        Code segment          │
│------------------------------│
│ const a = 10,                │
│ func main, call, Outer, init │
│ show (anonymous function)    │
└──────────────────────────────┘
          ↓
┌──────────────────────────────┐
│        Data segment         │
│------------------------------│
│ var b = 20                   │
└──────────────────────────────┘
          ↓
┌──────────────────────────────┐
│           Stack              │
│------------------------------│
│ Outer() frame                │
│   age = 20                   │
│   return address             │
└──────────────────────────────┘
          ↓
┌──────────────────────────────┐
│            Heap               │
│------------------------------│
│ money = 100 (inc)            │
│ money = 130 (after inc())    │
│ money = 160 (after inc())    │
│                              │
│ money = 100 (inc1)           │
│ money = 130 (after inc1())   │
│ money = 160 (after inc1())   │
└──────────────────────────────┘

🧠 ব্যাখ্যা:

• a ও b Global — তাই a Code segment (const), আর b Data segment এ যায়।
• age একটি Local variable, এবং কেবল Outer function ব্যবহৃত — Stack থাকে।
• money একটি Closer এর অংশ, কারণ show() function এর মধ্যে ব্যবহৃত ও return করা হচ্ছে — তাই এটি Heap এ সংরক্ষিত।
• প্রতিবার Outer() call হলে, নতুন money variable Heap তৈরি হয়, আলাদা করে (inc, inc1)।

🔍 Types of Closures

1. Closure with Outer Variable

প্রশ্ন: একটি Go program লিখুন যা দেখায় কীভাবে closure outer function থেকে variable access ও modify করতে পারে।

Code:

package main

import "fmt"

func outer() func() {
    x := 10
    return func() {
        x++
        fmt.Println(x)
    }
}

func main() {
    closure := outer()
    closure() // Output: 11
    closure() // Output: 12
}

ব্যাখ্যা:

• outer function একটি closure তৈরি করে যা x ভেরিয়েবল capture করে এবং modify করে।
• প্রতিবার call করলে x এর মান বাড়ে।

2. Multiple Closures with Separate States

প্রশ্ন: দেখান কীভাবে একই function এ তৈরি হওয়া একাধিক closures তাদের নিজস্ব state ধরে রাখে।

Code:

package main

import "fmt"

func createCounter() func() int {
    counter := 0
    return func() int {
        counter++
        return counter
    }
}

func main() {
    counter1 := createCounter()
    counter2 := createCounter()

    fmt.Println(counter1()) // Output: 1
    fmt.Println(counter1()) // Output: 2
    fmt.Println(counter2()) // Output: 1
    fmt.Println(counter2()) // Output: 2
}

ব্যাখ্যা:

• counter1 এবং counter2 প্রতিটিই আলাদা closure, যাদের নিজস্ব counter state রয়েছে।
• এরা একে অপরকে প্রভাবিত করে না।

3. Closure with Parameters

প্রশ্ন: এমন একটি closure লিখুন যা parameter accept করে এবং দেখায় যে closures কীভাবে arguments ব্যবহার করতে পারে।

Code:

package main

import "fmt"

func multiplier(factor int) func(int) int {
    return func(n int) int {
        return n * factor
    }
}

func main() {
    double := multiplier(2)
    triple := multiplier(3)

    fmt.Println(double(5))  // Output: 10
    fmt.Println(triple(5))  // Output: 15
}

ব্যাখ্যা:

• multiplier নামের closure factor parameter accept করে এবং একটি function return করে যা n কে factor দিয়ে গুণ করে।
• double এবং triple আলাদা আলাদা factor ব্যবহার করে।

4. Closures with Deferred Execution

প্রশ্ন: Go-তে closures কীভাবে deferred execution এর সঙ্গে ব্যবহার করা যায় এবং outer function শেষ হওয়ার পর variable access করলে কী ঘটে?

Code:

package main

import "fmt"

func main() {
    a := 10
    defer func(a int) { // Pass 'a' as a parameter to the deferred function
        fmt.Println("Deferred closure:", a)
    }(a) // Pass the current value of 'a' here
    a = 20
    fmt.Println("Inside main:", a)
}

ব্যাখ্যা:

• যদিও main এ a পরিবর্তিত হয়েছে, deferred closure-এ a এর যে মান পাঠানো হয়েছে সেটাই print হবে।
• কারণ a parameter হিসেবে capture করা হয়েছে, reference নয়।

5. Closure Capturing Loop Variable

প্রশ্ন: একটি Go program লিখুন যা দেখায় কীভাবে closure loop variable ভুলভাবে capture করে।

Code:

package main

import "fmt"

func main() {
    funcs := []func(){}

    for i := 0; i < 3; i++ {
        funcs = append(funcs, func() {
            fmt.Println(i) // Output: 3, 3, 3
        })
    }

    for _, f := range funcs {
        f()
    }
}

ব্যাখ্যা:

• সব closures একই i variable capture করে।
• loop শেষ হওয়ার পরে i এর মান হয় 3, তাই সব output হয় 3।
• এটা ঠিক করার জন্য এর i মান parameter হিসাবে closures এ পাঠাতে হবে।

সঠিক code:

package main

import "fmt"

func main() {
    funcs := []func(){}

    for i := 0; i < 3; i++ {
        i := i // Create a new variable inside the loop
        funcs = append(funcs, func() {
            fmt.Println(i) // Output: 0, 1, 2
        })
    }

    for _, f := range funcs {
        f()
    }
}

6. Closures with Function Arguments

প্রশ্ন: এমন একটি closure তৈরি করুন যা দুটি সংখ্যা যোগ করে এবং দেখায় কীভাবে closures argument capture করে।

Code:

package main

import "fmt"

func adder(a int) func(int) int {
    return func(b int) int {
        return a + b
    }
}

func main() {
    add5 := adder(5)
    fmt.Println(add5(3))  // Output: 8
    fmt.Println(add5(10)) // Output: 15
}

ব্যাখ্যা:

• adder function a কে capture করে এবং b এর সাথে যোগ করে।
• add5 closure a = 5 মনে রাখে এবং তার সাথে নতুন b যোগ করে।

7. Closures with a Function Factory

প্রশ্ন: একটি closure তৈরি করুন যা function factory হিসেবে কাজ করে এবং pass করা argument অনুসারে বিভিন্ন mathematical operation return করে।

Code:

package main

import "fmt"

func operationFactory(operator string) func(int, int) int {
    switch operator {
    case "add":
        return func(a, b int) int {
            return a + b
        }
    case "subtract":
        return func(a, b int) int {
            return a - b
        }
    case "multiply":
        return func(a, b int) int {
            return a * b
        }
    }
    return nil
}

func main() {
    add := operationFactory("add")
    subtract := operationFactory("subtract")
    multiply := operationFactory("multiply")

    fmt.Println(add(3, 4))       // Output: 7
    fmt.Println(subtract(9, 4))  // Output: 5
    fmt.Println(multiply(3, 4))  // Output: 12
}

ব্যাখ্যা:

• operationFactory pass করা operator অনুযায়ী একটি closure return করে।
• প্রতিটি closure নির্দিষ্ট operation সম্পাদন করে।

8. Closures with State Preservation

প্রশ্ন: এমন একটি closure লিখুন যা বারবার call করার পরও তার state সংরক্ষণ করে (যেমন একটি simple counter)

Code:

package main

import "fmt"

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    c1 := counter()
    c2 := counter()

    fmt.Println(c1()) // Output: 1
    fmt.Println(c1()) // Output: 2
    fmt.Println(c2()) // Output: 1
}

ব্যাখ্যা:

• প্রতিটি counter() call একটি নতুন count variable সহ closure তৈরি করে।
• c1 এবং c2 আলাদা আলাদা state সংরক্ষণ করে।

9. Closure with Function Composition

প্রশ্ন: একটি Go প্রোগ্রাম তৈরি করুন যা closures ব্যবহার করে function composition demonstrate করে।

Code:

package main

import "fmt"

func compose(f, g func(int) int) func(int) int {
    return func(x int) int {
        return f(g(x))
    }
}

func double(x int) int {
    return x * 2
}

func addFive(x int) int {
    return x + 5
}

func main() {
    composed := compose(double, addFive)
    fmt.Println(composed(3)) // Output: 16 (3 + 5 = 8, 8 * 2 = 16)
}

ব্যাখ্যা:

• compose function দুটি function f এবং g accept করে এবং একটি নতুন function return করে যা g(x) এর ওপর f() apply করে।
• এখানে double(addFive(3)) => double(8) => 16

Go Closures - code উদাহরণ ও ব্যাখ্যাসহ ২০টি প্রশ্ন

এই document Go-এর closures নিয়ে ২০টি প্রশ্ন, code উদাহরণ এবং বিস্তারিত ব্যাখ্যা রয়েছে।

1. Go-তে closure কী?

প্রশ্ন: Go-এ closure কী তা ব্যাখ্যা করুন একটি উদাহরণসহ।

Code:

package main

import "fmt"

func outer() func() {
    return func() {
        fmt.Println("This is a closure")
    }
}

func main() {
    closure := outer()
    closure()
}

ব্যাখ্যা:
একটি closure এমন একটি function যা তার চারপাশের scope থেকে variable ধরে রাখতে পারে। উপরের উদাহরণে outer function যেটি return করছে সেটি একটি closure, কারণ এটি তার তৈরি হওয়া environment-এর context access করতে পারে।

2. একটি closure কীভাবে outer function-এর variable access করে?

প্রশ্ন: দেখান কিভাবে একটি closure outer variable access ও modify করতে পারে।

Code:

package main

import "fmt"

func outer() func() {
    x := 10
    return func() {
        x++
        fmt.Println(x)
    }
}

func main() {
    closure := outer()
    closure() // Output: 11
    closure() // Output: 12
}

ব্যাখ্যা:
এই closure outer x variable ধরে রাখে এবং প্রতিবার call করার সময় তাকে modify করে।

3. closure যখন loop-এর variable access করে তখন কী হয়?

প্রশ্ন: closure দ্বারা loop variable capture করার সময় কী ধরনের ভুল হতে পারে তা দেখান।

Code:

package main

import "fmt"

func main() {
    funcs := []func(){}

    for i := 0; i < 3; i++ {
        funcs = append(funcs, func() {
            fmt.Println(i)
        })
    }

    for _, f := range funcs {
        f()
    }
}

ব্যাখ্যা:
এখানে সবগুলো closure একই i variable ধরে রাখে, তাই প্রত্যেকটা closure call করার সময় 3 print হয়। কারণ loop শেষ হবার পর i এর final value 3 হয়ে যায়, এবং closure সেই reference-টাই ধরে রাখে।

4. loop closure সমস্যা কীভাবে সমাধান করবেন?

প্রশ্ন: loop-এর প্রতিটি iteration-এ আলাদা variable কিভাবে capture করবেন?

Code:

package main

import "fmt"

func main() {
    funcs := []func(){}

    for i := 0; i < 3; i++ {
        i := i // New variable for each iteration
        funcs = append(funcs, func() {
            fmt.Println(i)
        })
    }

    for _, f := range funcs {
        f()
    }
}

ব্যাখ্যা:
i := i দিয়ে প্রতি iteration-এ নতুন i তৈরি হওয়ায়, closure গুলো ভিন্ন ভিন্ন value ধরে রাখে এবং আলাদা আলাদা output দেয়: 0, 1, 2।

5. Function parameter হিসেবে closure

প্রশ্ন: কিভাবে closure-কে অন্য function-এ argument হিসেবে pass করবেন?

Code:

package main

import "fmt"

func applyClosure(f func()) {
    f()
}

func main() {
    closure := func() {
        fmt.Println("Closure passed as argument")
    }
    applyClosure(closure)
}

ব্যাখ্যা:
closure-কে কোনো function-এর argument হিসেবে pass করা যায়। এখানে applyClosure function-টি একটি closure নেয় এবং তাকে execute করে।

6. parameter সহ closure

প্রশ্ন: একটি closure লিখুন যেটি একটি parameter নেয় ?

Code:

package main

import "fmt"

func multiplier(factor int) func(int) int {
    return func(n int) int {
        return n * factor
    }
}

func main() {
    double := multiplier(2)
    fmt.Println(double(4)) // Output: 8
}

ব্যাখ্যা:
এই closure factor ধরে রাখে এবং return করা function n এর সাথে তাকে গুণ করে। এইভাবে double(4) output দেয় 8।

7. closure যখন value return করে

প্রশ্ন: দেখান কিভাবে closure return value দেয়।

Code:

package main

import "fmt"

func adder(a int) func(int) int {
    return func(b int) int {
        return a + b
    }
}

func main() {
    addFive := adder(5)
    fmt.Println(addFive(3)) // Output: 8
}

ব্যাখ্যা:
এই closure a ধরে রাখে এবং প্রতিবার নতুন input b এর সাথে তা যোগ করে result return করে।

8. একটি function থেকে closure return করা

প্রশ্ন: দেখান কিভাবে একটি function closure return করতে পারে।

Code:

package main

import "fmt"

func createCounter() func() int {
    counter := 0
    return func() int {
        counter++
        return counter
    }
}

func main() {
    counter1 := createCounter()
    counter2 := createCounter()

    fmt.Println(counter1()) // Output: 1
    fmt.Println(counter2()) // Output: 1
}

ব্যাখ্যা:
createCounter প্রত্যেকবার call করলে নতুন একটি closure return করে যার নিজস্ব counter থাকে।

9. closure যেটি তার পূর্ববর্তী state মনে রাখে

প্রশ্ন: এমন একটি closure লিখুন যা আগের state ধরে রাখতে পারে।

Code:

package main

import "fmt"

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    c1 := counter()
    c2 := counter()

    fmt.Println(c1()) // Output: 1
    fmt.Println(c1()) // Output: 2
    fmt.Println(c2()) // Output: 1
}

ব্যাখ্যা:
প্রতিটি closure আলাদা count ধরে রাখে। তাই c1 এবং c2 এর মধ্যে একে অপরের সাথে কোনো সম্পর্ক নেই।

10. closure এবং anonymous function

প্রশ্ন: কিভাবে anonymous function ব্যবহার করে closure তৈরি করা যায়?

Code:

package main

import "fmt"

func main() {
    a := 5
    closure := func() {
        fmt.Println("Captured value:", a)
    }
    closure() // Output: Captured value: 5
}

ব্যাখ্যা:
anonymous function closure হিসেবে কাজ করতে পারে। এখানে a variable টি capture করে রেখেছে function টা।

11. Closure দিয়ে lazy evaluation

প্রশ্ন: কিভাবে closure ব্যবহার করে lazy evaluation করা যায়?

Code:

package main

import "fmt"

func lazySum(a, b int) func() int {
    return func() int {
        return a + b
    }
}

func main() {
    sum := lazySum(3, 4)
    fmt.Println("Doing something else...")
    fmt.Println("Now evaluating sum:", sum())
}

ব্যাখ্যা:
এই উদাহরণে, lazySum function টি actual calculation defer করে রাখে যতক্ষণ না sum() call করা হয়।

12. Closure ব্যবহার করে filter function তৈরি করা

প্রশ্ন: কিভাবে closure ব্যবহার করে একটি filter function তৈরি করা যায়?

Code:

package main

import "fmt"

func filter(data []int, predicate func(int) bool) []int {
    result := []int{}
    for _, v := range data {
        if predicate(v) {
            result = append(result, v)
        }
    }
    return result
}

func main() {
    nums := []int{1, 2, 3, 4, 5}
    even := func(n int) bool {
        return n%2 == 0
    }
    fmt.Println(filter(nums, even)) // Output: [2 4]
}

ব্যাখ্যা:
filter function টি একটি closure নেয় যেটি প্রতিটি item evaluate করে। এখানে, even একটি closure যা শুধু জোড় সংখ্যা বেছে নেয়।

13. Closure দিয়ে memoization

প্রশ্ন: কিভাবে closure ব্যবহার করে memoization implement করা যায়?

Code:

package main

import "fmt"

func memoize() func(int) int {
    cache := map[int]int{}
    return func(n int) int {
        if val, ok := cache[n]; ok {
            return val
        }
        result := n * n
        cache[n] = result
        return result
    }
}

func main() {
    square := memoize()
    fmt.Println(square(4)) // Output: 16
    fmt.Println(square(4)) // Cached output: 16
}

ব্যাখ্যা:
এই closure একটি map-এর মাধ্যমে আগে হিসাব করা ফলাফল মনে রাখে। একই input দিলে সে পুরোনো result ব্যবহার করে।

14. Closure দিয়ে callback implement করা

প্রশ্ন: কিভাবে closure ব্যবহার করে callback তৈরি করা যায়?

Code:

package main

import "fmt"

func doSomething(callback func(string)) {
    callback("Hello from callback")
}

func main() {
    doSomething(func(msg string) {
        fmt.Println(msg)
    })
}

ব্যাখ্যা:
closure callback হিসেবে কাজ করছে যা doSomething function থেকে invoke হচ্ছে।

15. Closure এবং goroutine

প্রশ্ন: closure কিভাবে goroutine এর মধ্যে ব্যবহার করা যায়?

Code:

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        i := i
        go func() {
            fmt.Println(i)
        }()
    }
    time.Sleep(1 * time.Second)
}

ব্যাখ্যা:
closure গুলো goroutine এর মধ্যে চলেছে। i := i দিয়ে প্রতি iteration-এ আলাদা value ensure করা হয়েছে।

16. Closure scope এর প্রভাব

প্রশ্ন: একটি closure কিভাবে ভিন্ন scope এ ভিন্ন আচরণ করে?

Code:

package main

import "fmt"

func main() {
    x := 5
    {
        x := 10
        closure := func() {
            fmt.Println(x)
        }
        closure() // Output: 10
    }
}

ব্যাখ্যা:
closure সেই scope-এর variable ধরে যেখানে এটি define হয়েছে। এখানে closure x := 10 এর value ধরে রেখেছে।

17. Closure-এ pointer capture করা

প্রশ্ন: কিভাবে closure pointer capture করে ?

Code:

package main

import "fmt"

func main() {
    x := 10
    ptr := &x

    closure := func() {
        fmt.Println(*ptr)
    }

    x = 20
    closure() // Output: 20
}

ব্যাখ্যা:
closure একটি pointer ধরে রাখলে, variable-এর যে কোনো পরিবর্তন সে reflect করবে কারণ address ধরেই access হয়।

18. Closure reference vs value capture

প্রশ্ন: Go-তে closure variable কে reference না value হিসাবে ধরে রাখে?

Code:

package main

import "fmt"

func main() {
    x := 10
    closure := func(val int) {
        fmt.Println(val)
    }

    x = 20
    closure(x) // Output: 20
}

ব্যাখ্যা:
যখন আপনি closure-এ variable pass করেন (যেমন val int), তখন সেটি value হিসাবে যায়। তবে যদি variable capture করা হয় closure scope-এ, সেটা reference এর মতো behave করে।

19. Closure এবং defer

প্রশ্ন: closure কিভাবে defer statement এর সঙ্গে কাজ করে?

Code:

package main

import "fmt"

func main() {
    for i := 0; i < 3; i++ {
        i := i
        defer func() {
            fmt.Println(i)
        }()
    }
}

ব্যাখ্যা:
সব defer statement পরে একসাথে execute হয় (LIFO)। এখানে i := i দিয়ে প্রতিটি closure আলাদা value capture করে।

20. Closure debugging এর টিপস

প্রশ্ন: closure ব্যবহার করার সময় common debugging সমস্যা ও সমাধান কী?

Explanation (no code):

• loop variable capture করলে সব closure একই variable reference ধরে রাখতে পারে (সমস্যা)। সমাধান: নতুন variable declare করে capture করা।
• closure asynchronous context (যেমন goroutine) এ ব্যবহার করলে, race condition তৈরি হতে পারে। সমাধান: value copy করে capture করা।
• closure capturing unexpected state? সরাসরি log print করুন বা debugger দিয়ে scoped variable inspect করুন।

[Author: @mdimamhosen Date: 2025-04-19 Category: e.g., interview-qa/topic_name Tags: [go, concurrency, channels] ]

Comparison Operators

Comparison operators are used to compare two values

package main

import "fmt"

func main() {
	fmt.Println(2 > 2) // false
	fmt.Println(2 < 2) // false
	fmt.Println(2 >= 2) // true
	fmt.Println(2 <= 2) // true
	fmt.Println(2 == 2) // true
	fmt.Println(2 != 2) // false
}

Frequently Asked Questions

1. What is the purpose of comparison operators in Go?

Answer: Comparison operators are used to compare two values and return a boolean result (true or false).

Example:

package main

import "fmt"

func main() {
	x := 10
	y := 20
	fmt.Println(x > y) // false
	fmt.Println(x < y) // true
}

2. Can comparison operators be used with strings in Go?

Answer: Yes, comparison operators can be used with strings to compare their lexicographical order.

Example:

package main

import "fmt"

func main() {
	fmt.Println("apple" > "banana") // false
	fmt.Println("apple" < "banana") // true
}

3. How does the == operator work with structs in Go?

Answer: The == operator can be used to compare structs if all their fields are comparable.

Example:

package main

import "fmt"

type Point struct {
	x, y int
}

func main() {
	p1 := Point{1, 2}
	p2 := Point{1, 2}
	fmt.Println(p1 == p2) // true
}

4. What happens if you compare two different types in Go?

Answer: Comparing two different types will result in a compile-time error.

Example:

package main

func main() {
	// Uncommenting the following line will cause a compile-time error
	// fmt.Println(10 == "10")
}

5. Can comparison operators be used with pointers?

Answer: Yes, comparison operators can be used to compare pointers for equality or inequality.

Example:

package main

import "fmt"

func main() {
	a := 10
	b := 10
	pa := &a
	pb := &b
	fmt.Println(pa == pb) // false
}

6. How does the != operator work?

Answer: The != operator checks if two values are not equal.

Example:

package main

import "fmt"

func main() {
	x := 5
	y := 10
	fmt.Println(x != y) // true
}

7. Can comparison operators be used with arrays?

Answer: Yes, arrays can be compared using == and != if their elements are comparable.

Example:

package main

import "fmt"

func main() {
	a1 := [3]int{1, 2, 3}
	a2 := [3]int{1, 2, 3}
	fmt.Println(a1 == a2) // true
}

8. What is the result of comparing two slices using ==?

Answer: Slices cannot be compared using == except for comparison with nil.

Example:

package main

import "fmt"

func main() {
	s1 := []int{1, 2, 3}
	s2 := []int{1, 2, 3}
	fmt.Println(s1 == nil) // false
	// Uncommenting the following line will cause a compile-time error
	// fmt.Println(s1 == s2)
}

9. How does Go handle floating-point comparison?

Answer: Floating-point numbers can be compared using comparison operators, but be cautious of precision issues.

Example:

package main

import "fmt"

func main() {
	x := 0.1 + 0.2
	y := 0.3
	fmt.Println(x == y) // false due to precision issues
}

10. Can you compare custom types using comparison operators?

Answer: Custom types can be compared if their underlying types support comparison.

Example:

package main

import "fmt"

type Age int

func main() {
	var a1 Age = 30
	var a2 Age = 25
	fmt.Println(a1 > a2) // true
}

[Author: @mdimamhosen Date: 2025-04-19 Category: interview-qa/conditional-statements Tags: [go, conditional-statements, if-else] ]

Go Conditions

Conditional statements allow us to control the structure of our program.

There are different ways by which we can control the flow of our program, (If, else if, else) are one of them.

(If, else if, else) statments allow us to make "decisions" while our program is running, They're also called (conditional statments) in programming.

    // Sudo Syntax
     if condition { <code> }
     else if condition { <code> }
     else { <code> }

// Actual Code
package main
import "fmt"

func main() {
	password := "12345678"
	if len(password) > 7 {
		fmt.Println("Valid Password")
	} else {
		fmt.Println("Invalid Password")
	}
}

Frequently Asked Questions (FAQs)

1. What is the syntax of an if-else statement in Go?

Answer: The syntax of an if-else statement in Go is as follows:

if condition {
    // code to execute if condition is true
} else {
    // code to execute if condition is false
}

Example:

package main
import "fmt"

func main() {
	number := 10
	if number%2 == 0 {
		fmt.Println("Even Number")
	} else {
		fmt.Println("Odd Number")
	}
}

2. Can we use an if statement without an else block?

Answer: Yes, an if statement can be used without an else block. Example:

package main
import "fmt"

func main() {
	number := 5
	if number > 0 {
		fmt.Println("Positive Number")
	}
}

3. What is an else-if ladder in Go?

Answer: An else-if ladder is used to check multiple conditions sequentially. Example:

package main
import "fmt"

func main() {
	score := 85
	if score >= 90 {
		fmt.Println("Grade: A")
	} else if score >= 75 {
		fmt.Println("Grade: B")
	} else {
		fmt.Println("Grade: C")
	}
}

4. How do you use a short statement in an if condition?

Answer: A short statement can be used to initialize a variable within an if condition. Example:

package main
import "fmt"

func main() {
	if num := 10; num%2 == 0 {
		fmt.Println("Even Number")
	}
}

5. Can we nest if-else statements in Go?

Answer: Yes, if-else statements can be nested. Example:

package main
import "fmt"

func main() {
	number := 15
	if number > 0 {
		if number%2 == 0 {
			fmt.Println("Positive Even Number")
		} else {
			fmt.Println("Positive Odd Number")
		}
	} else {
		fmt.Println("Non-Positive Number")
	}
}

6. What is the difference between if-else and switch statements?

Answer: If-else is used for conditional branching, while switch is used for selecting one of many blocks of code. Example:

package main
import "fmt"

func main() {
	day := 3
	switch day {
	case 1:
		fmt.Println("Monday")
	case 2:
		fmt.Println("Tuesday")
	case 3:
		fmt.Println("Wednesday")
	default:
		fmt.Println("Invalid Day")
	}
}

7. How do you handle multiple conditions in a single if statement?

Answer: Logical operators like && (AND) and || (OR) can be used to handle multiple conditions. Example:

package main
import "fmt"

func main() {
	number := 15
	if number > 0 && number%3 == 0 {
		fmt.Println("Positive and Divisible by 3")
	}
}

8. What happens if the condition in an if statement is not a boolean?

Answer: In Go, the condition in an if statement must evaluate to a boolean. Otherwise, it will result in a compilation error. Example:

// This will cause a compilation error
// if 10 {
//     fmt.Println("Invalid Condition")
// }

9. Can we use a function call in an if condition?

Answer: Yes, a function call can be used in an if condition. Example:

package main
import "fmt"

func isEven(num int) bool {
	return num%2 == 0
}

func main() {
	if isEven(10) {
		fmt.Println("Even Number")
	}
}

10. How do you use if-else with user input?

Answer: You can use the fmt.Scan function to take user input and use it in an if-else statement. Example:

package main
import "fmt"

func main() {
	var age int
	fmt.Print("Enter your age: ")
	fmt.Scan(&age)
	if age >= 18 {
		fmt.Println("You are eligible to vote.")
	} else {
		fmt.Println("You are not eligible to vote.")
	}
}

[Author: @mdimamhosen Date: 2025-04-19 Category: interview-qa/constants Tags: [go, constants, beginner] ]

The const keyword declares the variable as "constant", which means that it is unchangeable and read-only.

package main
import ("fmt")

const user = "admin" // cannot be changed

func main() {
  fmt.Println("admin")
}

Constant Rules

1. Constant names follow the same naming rules as variables

2. Constant names are usually written in uppercase letters

3. Constants can be declared both inside and outside of a function

Frequently Asked Questions

1. What is a constant in Go?

Answer: A constant is a variable whose value cannot be changed once it is assigned. Constants are declared using the const keyword.

Code Example:

package main
import "fmt"

const PI = 3.14

func main() {
    fmt.Println("The value of PI is:", PI)
}

2. Can constants be declared inside a function?

Answer: Yes, constants can be declared both inside and outside of a function.

Code Example:

package main
import "fmt"

func main() {
    const GREETING = "Hello, World!"
    fmt.Println(GREETING)
}

3. Can constants hold values other than numbers?

Answer: Yes, constants can hold string, boolean, or even character values.

Code Example:

package main
import "fmt"

const IS_ACTIVE = true
const MESSAGE = "Welcome to Go!"

func main() {
    fmt.Println("Is Active:", IS_ACTIVE)
    fmt.Println("Message:", MESSAGE)
}

4. Can constants be computed at runtime?

Answer: No, constants must be assigned a value that can be determined at compile time.

Code Example:

package main
import "fmt"

const VALUE = 10 * 2 // Valid

func main() {
    fmt.Println("Value:", VALUE)
}

5. What happens if you try to change a constant's value?

Answer: The compiler will throw an error if you try to change the value of a constant.

Code Example:

package main
import "fmt"

const NAME = "John"

func main() {
    // NAME = "Doe" // Uncommenting this line will cause a compilation error
    fmt.Println(NAME)
}

6. Can constants be used in expressions?

Answer: Yes, constants can be used in expressions to compute other constants.

Code Example:

package main
import "fmt"

const A = 5
const B = 10
const SUM = A + B

func main() {
    fmt.Println("Sum:", SUM)
}

7. What is the difference between const and var in Go?

Answer: const is used for values that do not change, while var is used for variables whose values can change.

Code Example:

package main
import "fmt"

const FIXED = 100
var changeable = 200

func main() {
    fmt.Println("Fixed:", FIXED)
    fmt.Println("Changeable:", changeable)
    changeable = 300
    fmt.Println("Updated Changeable:", changeable)
}

8. Can constants be of type array or slice?

Answer: No, constants cannot be of type array, slice, or map.

Code Example:

package main
import "fmt"

func main() {
    // const ARR = [3]int{1, 2, 3} // This will cause a compilation error
    fmt.Println("Constants cannot be arrays or slices.")
}

9. Can constants be exported in Go?

Answer: Yes, constants can be exported if their names start with an uppercase letter.

Code Example:

package main
import "fmt"

const ExportedConstant = "I am exported!"

func main() {
    fmt.Println(ExportedConstant)
}

10. What are untyped constants in Go?

Answer: Untyped constants do not have a specific type until they are assigned to a variable.

Code Example:

package main
import "fmt"

const VALUE = 42

func main() {
    var x int = VALUE
    var y float64 = VALUE
    fmt.Println("x:", x, "y:", y)
}

Defer Keyword

The defer keyword is used to delay the execution of a function or a statement until the nearby function returns. In simple words, defer will move the execution of the statement to the very end inside a function.

package main
import "fmt"

func greet() {
    defer fmt.Println("World")
    fmt.Println("Hello")
}

func main() {
    greet()
}

[Author: @fardinabir Date: 2025-04-27 Category: interview-qa/go-routines Tags: [go, go-routines, concurrency, routine]

Top 15 Golang Interview Questions on Concurrency and Goroutines (Detailed Answers with Bonus)

This page provides a comprehensive list of 15 Go interview questions focused on concurrency and goroutines, with detailed, explanatory answers, followed by a bonus question comparing Go’s concurrency model to other languages. The questions cover theoretical concepts, practical applications, and common pitfalls, suitable for interview preparation or deepening your understanding of Go’s concurrency model. The bonus question explores why Go’s goroutines are praised compared to concurrency mechanisms in Java, Python, and other languages, with a focus on efficiency and performance.

1. What are goroutines, and how do they differ from threads?

Answer:

Goroutines are lightweight, user-space threads managed by the Go runtime rather than the operating system. They enable concurrent execution of functions with minimal overhead, making it practical to create thousands or even millions of goroutines in a single program.

Key Differences from Threads:

• Management: Goroutines are managed by the Go runtime’s scheduler, while threads are managed by the OS. This allows Go to optimize goroutine scheduling without relying on OS-level thread switching, which is costly.
• Memory Overhead: Goroutines start with a small stack (as low as 2KB, dynamically growing as needed), whereas OS threads typically require a fixed, larger stack (e.g., 1MB on Linux). This makes goroutines far more memory-efficient.
• Creation and Switching: Creating and context-switching goroutines is faster because it happens in user space, avoiding system calls. Thread creation and switching involve OS kernel operations, which are slower.
• Scalability: Go’s scheduler multiplexes many goroutines onto a smaller number of OS threads, enabling efficient scaling. Threads are limited by OS constraints and resource availability.
• Concurrency Model: Goroutines follow Go’s concurrency model, emphasizing channels for communication, while threads often rely on locks and shared memory, which can lead to complex synchronization issues.

Example:

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    go printNumbers() // Runs concurrently
    printNumbers()   // Runs in main goroutine
    time.Sleep(1 * time.Second) // Wait for goroutines to finish
}

In this example, go printNumbers() spawns a new goroutine, allowing two functions to run concurrently. Unlike threads, creating this goroutine is inexpensive and managed entirely by Go.

2. How does the Go scheduler work with goroutines?

Answer:

The Go scheduler is part of the Go runtime and is responsible for managing the execution of goroutines. It uses a model called the M:N scheduler, where M goroutines are multiplexed onto N OS threads. The scheduler ensures efficient utilization of CPU resources and minimizes overhead.

Key Components:

• G (Goroutine): Represents a single goroutine, including its stack, program counter, and state.
• M (Machine): Represents an OS thread, which executes goroutines.
• P (Processor): A logical processor that schedules goroutines onto an M. The number of Ps is set by GOMAXPROCS (defaults to the number of CPU cores).

How It Works:

1. Goroutine Creation: When a goroutine is created (via go keyword), it’s added to a run queue managed by a P.
2. Scheduling: Each P has a local run queue of goroutines. The scheduler assigns Ps to Ms (OS threads), and Ps execute goroutines from their queues.
3. Work Stealing: If a P’s run queue is empty, it can steal goroutines from another P’s queue, balancing the workload.
4. Preemption: The scheduler can preempt long-running goroutines (e.g., during function calls or blocking operations like syscalls) to ensure fairness.
5. Blocking Handling: If a goroutine performs a blocking operation (e.g., I/O), the scheduler parks it and assigns another goroutine to the thread, maximizing CPU usage.

Example:

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Println("GOMAXPROCS:", runtime.GOMAXPROCS(0)) // Number of Ps
    for i := 0; i < 10; i++ {
        go func(id int) {
            for {
                fmt.Printf("Goroutine %d running\n", id)
            }
        }(i)
    }
    select {} // Keep main goroutine alive
}

Here, multiple goroutines are scheduled across available Ps. The scheduler ensures they share CPU time, and GOMAXPROCS determines how many threads can run goroutines simultaneously.

3. What is the purpose of the go keyword in Go?

Answer:

The go keyword is used to launch a new goroutine, enabling a function to execute concurrently with other goroutines, including the main program. It’s a simple, idiomatic way to introduce concurrency in Go without explicitly managing threads.

Purpose:

• Concurrency: Allows functions to run independently, improving performance for tasks like parallel processing, I/O-bound operations, or background tasks.
• Simplicity: Abstracts away low-level thread management, letting the Go runtime handle scheduling.
• Scalability: Enables creating many goroutines (e.g., for handling thousands of connections) due to their low overhead.

How It Works: When go function() is called, the Go runtime creates a new goroutine, places it in a run queue, and schedules it for execution. The calling goroutine continues immediately, without waiting for the new goroutine to complete.

Example:

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    fmt.Println("Hello from goroutine!")
}

func main() {
    go sayHello() // Launch goroutine
    fmt.Println("Hello from main!")
    time.Sleep(100 * time.Millisecond) // Allow goroutine to run
}

In this example, go sayHello() runs sayHello concurrently. Without time.Sleep, the main goroutine might exit before sayHello prints, as goroutines are not guaranteed to execute immediately.

Note: The time.Sleep is used here for demonstration. In production, use synchronization mechanisms like sync.WaitGroup or channels to coordinate goroutines.

4. How do you synchronize goroutines in Go?

Answer:

Synchronization in Go ensures that goroutines coordinate their actions, avoiding issues like race conditions or accessing shared resources incorrectly. Go provides two primary approaches: channels for communication-based synchronization and sync package primitives for traditional locking.

Approaches:

1. Channels:

   • Channels are the idiomatic way to synchronize goroutines, following Go’s philosophy: “Don’t communicate by sharing memory; share memory by communicating.”
   • Channels allow goroutines to send and receive data, inherently synchronizing their execution.
   • Example:

     package main
     
     import "fmt"
     
     func main() {
         ch := make(chan string)
         go func() {
             ch <- "Hello from goroutine!" // Send
         }()
         msg := <-ch // Receive, blocks until data is sent
         fmt.Println(msg)
     }
     

     Here, the main goroutine waits for the message, ensuring synchronization.

2. sync.WaitGroup:

   • Used to wait for multiple goroutines to complete.
   • Methods: Add(n) to set the number of goroutines, Done() to signal completion, and Wait() to block until all are done.
   • Example:

     package main
     
     import (
         "fmt"
         "sync"
     )
     
     func worker(id int, wg *sync.WaitGroup) {
         defer wg.Done()
         fmt.Printf("Worker %d done\n", id)
     }
     
     func main() {
         var wg sync.WaitGroup
         for i := 1; i <= 3; i++ {
             wg.Add(1)
             go worker(i, &wg)
         }
         wg.Wait()
         fmt.Println("All workers done")
     }
     

3. sync.Mutex and sync.RWMutex:

   • sync.Mutex provides mutual exclusion, ensuring only one goroutine accesses a critical section at a time.
   • sync.RWMutex allows multiple readers or one writer, useful for read-heavy workloads.
   • Example:

     package main
     
     import (
         "fmt"
         "sync"
     )
     
     var counter int
     var mu sync.Mutex
     
     func increment(wg *sync.WaitGroup) {
         defer wg.Done()
         mu.Lock()
         counter++
         mu.Unlock()
     }
     
     func main() {
         var wg sync.WaitGroup
         for i := 0; i < 100; i++ {
             wg.Add(1)
             go increment(&wg)
         }
         wg.Wait()
         fmt.Println("Counter:", counter) // Always 100
     }
     

Best Practice: Prefer channels for coordination and data passing, as they reduce the risk of errors like deadlocks or race conditions compared to mutexes.

5. What are channels, and how do they facilitate concurrency?

Answer:

Channels are typed, thread-safe conduits that allow goroutines to communicate by sending and receiving values. They are a core feature of Go’s concurrency model, enabling safe and idiomatic coordination without shared memory.

Key Characteristics:

• Typed: Channels carry values of a specific type (e.g., chan int, chan string).
• Synchronized: Sending and receiving operations block until both sender and receiver are ready (for unbuffered channels), ensuring coordination.
• Safe: Channels prevent race conditions by serializing access to data.

Types of Channels:

• Unbuffered: Created with make(chan T). Sending blocks until a receiver is ready, and receiving blocks until a sender is ready.
• Buffered: Created with make(chan T, n). Allows sending up to n values without blocking, but blocks when the buffer is full or empty.

How Channels Facilitate Concurrency:

• Communication: Channels allow goroutines to pass data, coordinating their execution. For example, a producer goroutine can send data to a consumer goroutine.
• Synchronization: Blocking behavior ensures goroutines wait for each other, preventing premature execution.
• Control Flow: Channels can signal events, like completion or cancellation, using empty structs (chan struct{}).

Example:

package main

import (
    "fmt"
    "time"
)

func producer(ch chan<- int) {
    for i := 1; i <= 5; i++ {
        ch <- i
        time.Sleep(100 * time.Millisecond)
    }
    close(ch)
}

func main() {
    ch := make(chan int)
    go producer(ch)
    for v := range ch {
        fmt.Println("Received:", v)
    }
}

Here, the producer sends integers, and the main goroutine receives them. The range loop exits when the channel is closed, demonstrating clean coordination.

Use Cases:

• Pipelines for data processing.
• Worker pools for task distribution.
• Signaling completion or cancellation.

6. What is the difference between buffered and unbuffered channels?

Answer:

Channels in Go can be unbuffered or buffered, and their behavior differs significantly in terms of blocking and synchronization.

Unbuffered Channels:

• Created with make(chan T).
• Behavior: Sending (ch <- v) blocks until a receiver is ready (<-ch), and receiving blocks until a sender is ready. This ensures strict synchronization.
• Use Case: Ideal for scenarios requiring guaranteed handoff, like coordinating two goroutines.
• Example:

  package main
  
  import "fmt"
  
  func main() {
      ch := make(chan string)
      go func() {
          ch <- "Hello" // Blocks until main receives
      }()
      fmt.Println(<-ch) // Blocks until goroutine sends
  }
  

Buffered Channels:

• Created with make(chan T, n), where n is the buffer size.
• Behavior: Sending blocks only if the buffer is full, and receiving blocks only if the buffer is empty. This allows asynchronous communication within the buffer’s capacity.
• Use Case: Useful for decoupling producers and consumers or handling bursts of data.
• Example:

  package main
  
  import "fmt"
  
  func main() {
      ch := make(chan int, 2)
      ch <- 1 // Non-blocking
      ch <- 2 // Non-blocking
      // ch <- 3 // Would block (buffer full)
      fmt.Println(<-ch) // 1
      fmt.Println(<-ch) // 2
  }