4 |
5 |
6 |
7 | >**🌟Best Golang Community Ever🌟**
8 |
9 | We have an active and growing community on Facebook where you can connect with like-minded individuals, ask questions, share ideas, and stay updated on the latest developments. Whether you're looking for support, collaboration, or just want to chat, this is the place for you!
10 |
11 | [](https://www.facebook.com/groups/1118405403169990)
12 |
13 |
14 |
15 | This is a complete ongoing **Golang Interview QnA** guideline that is growing for the Bangladeshi community.
16 |
17 |
18 |
19 |
Make sure to :star: this repository if you liked it!
24 |
25 | এই রিপোজিটরিতে গো (Golang) ল্যাঙ্গুয়েজের ইন্টারভিউ প্রশ্ন এবং উত্তর বাংলায় সংকলন করা হয়েছে। এটি জব ইন্টারভিউ প্রস্তুতির জন্য একটি সহায়ক রিসোর্স।
26 |
27 | ## কন্টেন্ট সূচি
28 | - [বেসিক প্রশ্ন](basic-questions.md)
29 | - [ইন্টারমিডিয়েট প্রশ্ন](intermediate-questions.md)
30 | - [অ্যাডভান্সড প্রশ্ন](advanced-questions.md)
31 | - [কম্পিউটার আর্কিটেকচার এন্ড অপারেটিং সিস্টেম](computer-architecture-&-operating-system.md)
32 |
33 | ## কন্ট্রিবিউট করার নির্দেশিকা
34 | আপনি চাইলে এই প্রোজেক্টে কন্ট্রিবিউট করতে পারেন। কন্ট্রিবিউট করার আগে [CONTRIBUTING.md](CONTRIBUTING.md) ফাইলটি পড়ুন।
35 |
36 | ## লাইসেন্স
37 | এই প্রোজেক্টটি [MIT লাইসেন্স](LICENSE) এর অধীনে প্রকাশিত হয়েছে।
38 |
--------------------------------------------------------------------------------
/advanced-questions.md:
--------------------------------------------------------------------------------
1 | # Golang Interview Questions and Answers (Advanced)
2 |
3 | ...***need your contribution***
4 |
--------------------------------------------------------------------------------
/basic-questions.md:
--------------------------------------------------------------------------------
1 | # Golang Interview Questions and Answers (BASIC)
2 |
3 | ## কন্টেন্ট সূচি
4 |
5 | | # | প্রশ্ন | উদাহরণ |
6 | | --- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
7 | | ১ | [What is scope?](#১-what-is-scope) | [উদাহরণ](#উদাহরণ) |
8 | | ২ | [What is block?](#২-what-is-block) | [উদাহরণ: (Nested Block Scope)](#উদাহরণ-nested-block-scope) |
9 | | ৩ | [How many types of scopes are there in Golang?](#৩-how-many-types-of-scopes-are-there-available-on-golang) | |
10 | | ৪ | [What is the standard or named function?](#৪-what-is-the-standard-or-named-function) | [উদাহরণ](#উদাহরণ-1) |
11 | | ৫ | [What is anonymous function?](#৫-what-is-anonymous-function) | [উদাহরণ](#উদাহরণ-2) |
12 | | ৬ | [What is expression?](#৬-what-is-expression) | [উদাহরণ](#উদাহরণ-3) |
13 | | ৭ | [What is function expression?](#৭-what-is-function-expression) | [উদাহরণ](#উদাহরণ-4) |
14 | | ৮ | [What is immediately invoked function expression (IIFE)?](#৮-what-is-immediately-invoked-function-expression-iife) | [উদাহরণ](#উদাহরণ-5) |
15 | | ৯ | [Difference between arguments and parameters](#৯-difference-between-arguments-and-parameters) | [উদাহরণ](#উদাহরণ-6) |
16 | | ১০ | [What is first-class function or higher-order function?](#১০-what-is-first-class-function-or-higher-order-function) | [উদাহরণ](#উদাহরণ-7) |
17 | | ১১ | [Difference between first-order function and higher-order function](#১১-difference-between-first-order-function-and-higher-order-function) | |
18 | | ১২ | [Difference between first-order logic and higher-order logic](#১২-difference-between-first-order-logic-and-higher-order-logic) | |
19 | | ১৩ | [What is callback function?](#১৩-what-is-callback-function) | [উদাহরণ](#উদাহরণ-8) |
20 | | ১৪ | [What is the first-class citizen?](#১৪-what-is-the-first-class-citizen) | |
21 | | ১৫ | [What is init function?](#১৫-what-is-init-function) | [উদাহরণ](#উদাহরণ-9) |
22 | | ১৬ | [Difference between compile time and run time](#১৬-difference-between-compile-time-and-run-time) | [কম্পাইল টাইম](#কম্পাইল-টাইম-compile-time), [রান টাইম](#রান-টাইম-run-time) |
23 | | ১৭ | [What is escape analysis?](#১৭-what-is-escape-analysis) | [উদাহরণ](#উদাহরণ-10) |
24 | | ১৮ | [Describe 2 phases of running a Go program](#১৮-describe-2-phases-of-running-a-go-program) | [উদাহরণ](#উদাহরণ-11) |
25 | | ১৯ | [What is closure in Go?](#১৯-what-is-closure-in-go) | [উদাহরণ](#উদাহরণ-12) |
26 | | ২০ | [What is struct in Go?](#২০-what-is-struct-in-go) | [উদাহরণ](#উদাহরণ-13) |
27 | | ২১ | [What is an instance?](#২১-what-is-an-instance) | [উদাহরণ](#উদাহরণ-14) |
28 | | ২২ | [What are member variables?](#২২-what-are-member-variables) | [উদাহরণ](#উদাহরণ-15) |
29 | | ২৩ | [What is instantiation?](#২৩-what-is-instantiation) | [উদাহরণ](#উদাহরণ-16) |
30 | | ২৪ | [What is the receiver function?](#২৪-what-is-the-receiver-function) | [উদাহরণ](#উদাহরণ-17) |
31 | | ২৫ | [Difference between expression and statement](#২৫-difference-between-expression-and-statement) | [উদাহরণ](#উদাহরণ-18), [পার্থক্য সংক্ষেপে](#পার্থক্য-সংক্ষেপে) |
32 | | ২৬ | [What is pointer? And difference between pass by value vs pass by reference](#২৬-what-is-pointer-and-difference-between-pass-by-value-vs-pass-by-reference) | [উদাহরণ](#উদাহরণ-19) |
33 | | ২৭ | [Difference between pass by value vs pass by reference](#২৭-difference-between-pass-by-value-vs-pass-by-reference) | [উদাহরণ](#উদাহরণ-20), [উদাহরণ](#উদাহরণ-21), [পার্থক্য সংক্ষেপে](#পার্থক্য-সংক্ষেপে-1) |
34 | | ২৮ | [Describe internal memory of a Go program](#২৮-describe-internal-memory-of-a-go-program) | [উদাহরণ](#উদাহরণ-22), [উদাহরণ](#উদাহরণ-23) |
35 |
36 | ---
37 |
38 | ## ১. What is scope?
39 |
40 | স্কোপ হলো একটি নির্দিষ্ট অংশ যেখানে কোনো ভেরিয়েবল বা ফাংশনকে অ্যাক্সেস বা ব্যবহার করা যায়।
41 |
42 | **Types of Scope:**
43 |
44 | **লোকাল স্কোপ (Local Scope):**
45 | যদি কোনো ভেরিয়েবল বা ফাংশন শুধুমাত্র একটি নির্দিষ্ট ব্লক (যেমন: ফাংশন, লুপ, অথবা কন্ডিশনাল স্টেটমেন্ট ( if else, switch ) এর ভিতরে ডিক্লেয়ার করা হয়, তাহলে তা ঐ ব্লকের বাইরে অ্যাক্সেস করা যায় না। এটাকেই লোকাল স্কোপ বলে।
46 |
47 | **গ্লোবাল স্কোপ (Global Scope):**
48 | যদি কোনো ভেরিয়েবল বা ফাংশন প্যাকেজ লেভেলে ডিক্লেয়ার করা হয়, তাহলে তা পুরো প্রোগ্রামের মধ্যে অ্যাক্সেসযোগ্য হয়। এটাকে গ্লোবাল স্কোপ বলে।
49 |
50 | ### উদাহরণ
51 |
52 | ```go
53 | package main
54 | import "fmt"
55 |
56 | // গ্লোবাল ভেরিয়েবল
57 | var globalVar = "আমি গ্লোবাল ভেরিয়েবল"
58 |
59 | func main() {
60 | // লোকাল ভেরিয়েবল
61 | localVar := "আমি লোকাল ভেরিয়েবল"
62 | fmt.Println(globalVar) // গ্লোবাল ভেরিয়েবল অ্যাক্সেস করা যায়
63 | fmt.Println(localVar) // লোকাল ভেরিয়েবল অ্যাক্সেস করা যায়
64 | }
65 |
66 | func anotherFunction() {
67 | fmt.Println(globalVar) // গ্লোবাল ভেরিয়েবল অ্যাক্সেস করা যায়
68 | // fmt.Println(localVar) // এটা কাজ করবে না, কারণ localVar লোকাল স্কোপে আছে
69 | }
70 | ```
71 |
72 | ---
73 |
74 | ## ২. What is block?
75 |
76 | Block বলতে একটি নির্দিষ্ট অঞ্চল বা সীমানা বোঝায়, যা `{}` দ্বারা আবদ্ধ থাকে। এই ব্লকের মধ্যে যেকোনো কোড লেখা হয় এবং তা একটি নির্দিষ্ট স্কোপ (Scope) তৈরি করে। ব্লকের ভিতরে ডিক্লেয়ার করা ভেরিয়েবল বা ফাংশন শুধুমাত্র ঐ ব্লকের মধ্যেই অ্যাক্সেসযোগ্য হয়।
77 |
78 | ### উদাহরণ: (Nested Block Scope)
79 |
80 | ```go
81 | func nestedBlockExample() {
82 | a := 5
83 | {
84 | b := 10 // এই ভেরিয়েবল b শুধুমাত্র এই নেস্টেড ব্লকের ভিতরে অ্যাক্সেসযোগ্য
85 | fmt.Println(a + b)
86 | }
87 | // fmt.Println(b) // এটি কাজ করবে না, কারণ b এর স্কোপ নেস্টেড ব্লকের বাইরে নেই
88 | }
89 | ```
90 |
91 | ---
92 |
93 | ## ৩. How many types of scopes are there available on Golang?
94 |
95 | 1. **Global scope** - পুরো প্রোগ্রামে অ্যাক্সেসযোগ্য।
96 | 2. **Local scope** - শুধুমাত্র নির্দিষ্ট ব্লকের ভিতরে অ্যাক্সেসযোগ্য।
97 | 3. **Package scope** - প্যাকেজের বাইরে থাকা ভেরিয়েবল ও ফাংশন একই প্যাকেজের অন্য ফাইলেও ব্যবহার করা যায়।
98 |
99 | ---
100 |
101 | ## ৪. What is the standard or named function?
102 |
103 | Standard বা Named Function হলো এমন একটি ফাংশন যার একটি নির্দিষ্ট নাম থাকে। ফাংশন কল করার জন্য এই নামটি ব্যবহার করা হয়।
104 |
105 | ### উদাহরণ
106 |
107 | ```go
108 | package main
109 | import "fmt"
110 |
111 | // একটি নেমড ফাংশন যা দুটি সংখ্যার যোগফল রিটার্ন করে
112 | func addNumbers(a int, b int) int {
113 | return a + b
114 | }
115 |
116 | func main() {
117 | // ফাংশনটি কল করা হচ্ছে
118 | result := addNumbers(5, 7)
119 | fmt.Println("যোগফল:", result) // আউটপুট: যোগফল: 12
120 | }
121 | ```
122 |
123 | ```
124 | - addNumbers হলো একটি standard or Named Function ফাংশন।
125 | - এটি দুটি প্যারামিটার (a এবং b) গ্রহণ করে এবং তাদের যোগফল রিটার্ন করে।
126 | - main ফাংশন থেকে addNumbers ফাংশনটি কল করা হয়েছে।
127 |
128 | ```
129 |
130 | ---
131 |
132 | ## ৫. What is anonymous function?
133 |
134 | Anonymous Function বলতে এমন ফাংশনকে বোঝায় যার কোনো নাম থাকে না। এই ফাংশনগুলো সাধারণত তখনই ব্যবহার করা হয় যখন আমাদের ফাংশনটি শুধুমাত্র একটি নির্দিষ্ট জায়গায় ব্যবহার করার প্রয়োজন হয়, এবং এটিকে পুনরায় ব্যবহার করার দরকার হয় না।
135 |
136 | ### উদাহরণ
137 |
138 | ```go
139 | package main
140 | import "fmt"
141 |
142 | func main() {
143 | // একটি এননিমাস ফাংশন ডিক্লেয়ার এবং কল করা
144 | func() {
145 | fmt.Println("এটি একটি এননিমাস ফাংশন")
146 | }()
147 | }
148 | ```
149 |
150 | ---
151 |
152 | ## ৬. What is expression?
153 |
154 | Expression হলো প্রোগ্রামিং-এ এমন একটি কোডের অংশ যা কোনো নির্দিষ্ট মান (value) তৈরি করে। অন্য কথায়, যখন কোনো কোড একটি ফলাফল বা আউটপুট দেয়, তখন সেই কোডকে এক্সপ্রেশন বলা হয়।
155 |
156 | ### উদাহরণ
157 |
158 | ```go
159 | - result := 2 + 3 // এটি একটি গাণিতিক এক্সপ্রেশন
160 | - isTrue := (5 > 3) && (10 < 20) // এটি একটি লজিক্যাল এক্সপ্রেশন
161 | - func add(a int, b int) int {
162 | return a + b
163 | }
164 | result := add(4, 6) // এটি একটি ফাংশন কল এক্সপ্রেশন
165 | - if (x > 10) { ... } // এটি একটি কন্ডিশনাল এক্সপ্রেশন
166 | ```
167 |
168 | ---
169 |
170 | ## ৭. What is function expression?
171 |
172 | ফাংশন এক্সপ্রেশন (Function Expression) বলতে এমন একটি ফাংশনকে বোঝায় যা একটি ভেরিয়েবলের মধ্যে স্টোর করা হয়।
173 |
174 | ### উদাহরণ
175 |
176 | ```go
177 | package main
178 | import "fmt"
179 | func main() {
180 | // একটি ফাংশন এক্সপ্রেশন তৈরি করা হচ্ছে
181 | add := func(a int, b int) int {
182 | return a + b
183 | }
184 | // ফাংশনটি কল করা হচ্ছে
185 | result := add(5, 7)
186 | fmt.Println("যোগফল:", result) // আউটপুট: যোগফল: 12
187 | }
188 | ```
189 |
190 | ---
191 |
192 | ## ৮. What is immediately invoked function expression (IIFE)?
193 |
194 | IIFE - Immediately Invoked Function Expression বলতে এমন একটি ফাংশনকে বোঝায় যা ডিক্লেয়ার করার সাথে সাথে তৎক্ষণাৎ কল করা হয়। অন্য কথায়, এটি একটি ফাংশন যা প্রোগ্রামে লেখার সময়ই এক্সিকিউট হয়ে যায়। এই ফাংশনটি শুধুমাত্র একবার ব্যবহার করা হয়, এবং পরে এটি পুনরায় কল করা যায় না।
195 |
196 | ### উদাহরণ
197 |
198 | ```go
199 | package main
200 | import "fmt"
201 | func main() {
202 | // একটি IIFE তৈরি এবং তৎক্ষণাৎ কল করা হচ্ছে
203 | func() {
204 | fmt.Println("এটি একটি IIFE")
205 | }() // ফাংশনটি ডিক্লেয়ার করার সাথে সাথে কল করা হচ্ছে
206 | }
207 | ```
208 |
209 | ---
210 |
211 | ## ৯. Difference between arguments and parameters
212 |
213 | **Parameter:** প্যারামিটার হল ফাংশন ডিফাইন করার সময় যে ভেরিয়েবলগুলো ব্যবহার করা হয়। এগুলো মূলত ফাংশনের জন্য একটা প্লেসহোল্ডার হিসেবে কাজ করে।
214 |
215 | **Argument:** আর্গুমেন্ট হল ফাংশন কল করার সময় যে ডাটাগুলি পাস করা হয়। পাস করা ডাটাগুলি প্যারামিটারে অ্যাসাইন হয়ে ফাংশনের কাজ চালায়।
216 |
217 | ### উদাহরণ
218 |
219 | ```go
220 | func add(a, b int) int { // a এবং b হল প্যারামিটার
221 | return a + b
222 | }
223 |
224 | result := add(3, 5) // 3 এবং 5 হল আর্গুমেন্ট
225 | ```
226 |
227 | ---
228 |
229 | ## ১০. What is first-class function or higher-order function?
230 |
231 | Higher-order function বলতে এমন ফাংশনকে বোঝায় যা অন্য ভেরিয়েবলের মতোই ব্যবহার করা যায়। অন্য কথায় ফাংশনটি একটি ভেরিয়েবলে স্টোর করা যায়, যে ফাংশন প্যারামিটারের ইনপুট হিসেবে আরেকটা ফানশনকে রিসিভ করতে পারে এবং অন্য ফাংশন থেকে রিটার্ন করা যায়।
232 |
233 | **Why we call Higher Order Function >< First class function**
234 |
235 | যেহুতু higher order function আরেকটা ফাংশনকে রিসিভ করতে পারে & ফাংশনটি একটি ভেরিয়েবলে স্টোর করা যায় as like first class citizen তাই higher order function কে first class function বলা হয়।
236 |
237 | ### উদাহরণ
238 |
239 | ```go
240 | // 1. ফাংশনকে প্যারামিটার হিসেবে গ্রহণ করা:
241 |
242 | func applyOperation(a int, b int, operation func(int, int) int) int {
243 | return operation(a, b)
244 | }
245 | func main() {
246 | add := func(x int, y int) int {
247 | return x + y
248 | }
249 | result := applyOperation(10, 5, add)
250 | fmt.Println(result) // আউটপুট: 15
251 | }
252 |
253 | // 2. ফাংশনকে রিটার্ন করা:
254 |
255 | func createGreeter(greeting string) func(string) string {
256 | return func(name string) string {
257 | return greeting + ", " + name + "!"
258 | }
259 | }
260 | func main() {
261 | greetInEnglish := createGreeter("Hello")
262 | greetInBangla := createGreeter("হ্যালো")
263 |
264 |
265 | fmt.Println(greetInEnglish("John")) // আউটপুট: Hello, John!
266 | fmt.Println(greetInBangla("রহিম")) // আউটপুট: হ্যালো, রহিম!
267 | }
268 |
269 | ```
270 |
271 | ---
272 |
273 | ## ১১. Difference between first-order function and higher-order function
274 |
275 | **First-Order Function:**
276 | ফার্স্ট অর্ডার ফাংশন হলো এমন ফাংশন যা অন্য কোনো ফাংশনকে প্যারামিটার হিসেবে গ্রহণ করে না এবং অন্য কোনো ফাংশনকে রিটার্নও করে না। এটি শুধুমাত্র নরমাল ডেটা (যেমন: সংখ্যা, স্ট্রিং, অ্যারে ইত্যাদি) নিয়ে কাজ করে।
277 |
278 | **Higher-Order Function:**
279 | হাইয়ার অর্ডার ফাংশন হলো এমন ফাংশন যা অন্য ফাংশনকে প্যারামিটার হিসেবে গ্রহণ করে অথবা অন্য ফাংশনকে রিটার্ন করে। এটি ফাংশনের উপর কাজ করে এবং ফাংশনকে ডেটা হিসেবে ব্যবহার করে।
280 |
281 | ---
282 |
283 | ## ১২. Difference between first order logic and higher order logic
284 |
285 | **First Order Logic:**
286 | First-Order Logic হলো এমন একটি লজিক সিস্টেম যা শুধুমাত্র Object, Property, Relation নিয়ে কাজ করে।
287 |
288 | **Higher-Order Logic:**
289 | Higher-Order Logic এমন একটি লজিক সিস্টেম যা Object, Property, Relation নিয়ে ত কাজ করেই এবং পাশাপাশি Rule নিয়েও কাজ করে।
290 |
291 | **সহজ কথায়:**
292 |
293 | ***ফার্স্ট-অর্ডার লজিক:*** এখানে আমরা শুধু "জিনিস" (অবজেক্ট) নিয়ে কথা বলি। যেমন, "সব ফল মিষ্টি"। এটি সাধারণ এবং সীমিত।
294 |
295 | ***হায়ার-অর্ডার লজিক:*** এখানে আমরা "জিনিস" ছাড়াও "বৈশিষ্ট্য" বা "পদ্ধতি" নিয়ে কথা বলতে পারি। যেমন, "কিছু বৈশিষ্ট্য আছে যা সব ফলের জন্য সত্য"। এটি আরও শক্তিশালী।
296 |
297 | **বিঃদ্রঃ** GO প্রোগ্রামিং-এ, ফার্স্ট-অর্ডার লজিক হলো সাধারণ ফাংশন যেগুলো শুধু ডেটা নিয়ে কাজ করে। আর হায়ার-অর্ডার লজিক হলো ফাংশন যেগুলো অন্য ফাংশন নিয়ে কাজ করে।
298 |
299 | ---
300 |
301 | ## ১৩. What is callback function?
302 |
303 | Callback Function হলো এমন একটি ফাংশন যা অন্য একটি ফাংশনের ভিতরে প্যারামিটার হিসেবে পাঠানো হয় এবং প্রথম ফাংশনটি যখন প্রয়োজন হয়, তখন এই কলব্যাক ফাংশনটিকে কল করে। অন্য কথায়, কলব্যাক ফাংশন হলো এমন একটি ফাংশন যা অন্য ফাংশনের দ্বারা "কল করার" জন্য পাঠানো হয়।
304 |
305 | ### উদাহরণ
306 |
307 | ```go
308 | // একটি ফাংশন যা কলব্যাক ফাংশন গ্রহণ করে
309 | func calculate(a int, b int, operation func(int, int) int) int {
310 | return operation(a, b)
311 | }
312 |
313 | func main() {
314 | // কলব্যাক ফাংশন হিসেবে add ফাংশন ব্যবহার করা হচ্ছে
315 | add := func(x int, y int) int {
316 | return x + y
317 | }
318 |
319 | // কলব্যাক ফাংশন হিসেবে subtract ফাংশন ব্যবহার করা হচ্ছে
320 | subtract := func(x int, y int) int {
321 | return x - y
322 | }
323 |
324 |
325 | result1 := calculate(10, 5, add)
326 | result2 := calculate(10, 5, subtract)
327 |
328 |
329 | fmt.Println("যোগফল:", result1) // আউটপুট: 15
330 | fmt.Println("বিয়োগফল:", result2) // আউটপুট: 5
331 | }
332 |
333 | ```
334 |
335 | ---
336 |
337 | ### ১৪. What is the first-class citizen?
338 |
339 | First-Class Citizen বলতে বোঝায় যা প্রোগ্রামের মধ্যে অন্য যেকোনো ডেটা টাইপের মতোই ব্যবহার করা যায়। GO-তে ফাংশন হলো ফার্স্ট ক্লাস সিটিজেন, কারণ ফাংশনকে ভেরিয়েবলে স্টোর করা, প্যারামিটার হিসেবে পাঠানো, অথবা অন্য ফাংশন থেকে রিটার্ন করা যায়।
340 |
341 | ---
342 |
343 | ### ১৫. What is init function?
344 |
345 | **init ফাংশন** হলো একটি বিশেষ ফাংশন যা কোনো প্যাকেজ বা ফাইল লোড হওয়ার সময় অটোমেটিকভাবে একবার কল হয়। এটি প্রোগ্রামের প্রাথমিক সেটআপ বা ইনিশিয়ালাইজেশন কাজে ব্যবহৃত হয়, যেমন: ভেরিয়েবল ইনিশিয়ালাইজ করা, ডাটাবেস কানেকশন তৈরি করা, কনফিগারেশন লোড করা ইত্যাদি।
346 |
347 | #### উদাহরণ
348 |
349 | ```go
350 |
351 | ## Folder Structure:
352 |
353 | sk/
354 | ├── go.mod
355 | ├── main.go
356 | └── mypackage/
357 | └── package.go
358 |
359 |
360 |
361 | // go.mod
362 | module sk
363 |
364 | go 1.24.2
365 |
366 |
367 | // mypackage/package.go
368 | package mypackage
369 |
370 | import "fmt"
371 |
372 | func init() {
373 | fmt.Println("Init from mypackage")
374 | }
375 |
376 | // main.go
377 | package main
378 |
379 | import (
380 | "fmt"
381 | "sk/mypackage"
382 | )
383 |
384 | func main() {
385 | fmt.Println("Main function")
386 | }
387 | ```
388 |
389 | ```
390 | ✅ Expected Output:
391 |
392 | Init from mypackage
393 | Main function
394 |
395 | ```
396 |
397 | ---
398 |
399 | ### ১৬. Difference between compile time and run time
400 |
401 | #### **কম্পাইল টাইম (Compile Time):**
402 |
403 | - কম্পাইল টাইম হলো যখন প্রোগ্রামটি কম্পাইলার দ্বারা কম্পাইল করা হয়। এই সময়ে কম্পাইলার প্রোগ্রামের সোর্স কোডকে মেশিন কোডে (বাইনারি কোড) রূপান্তর করে।
404 |
405 | - এই ধাপে কোডের সিনট্যাক্স (যেমন: একটি সেমিকোলন ; মিস করেন) এবং কিছু লজিক্যাল ভুল ধরা পড়ে। যদি কোডে কোনো ভুল থাকে, তবে কম্পাইলার সেটি চিহ্নিত করে এবং প্রোগ্রামটি run হবার আগেই প্রোগ্রামারকে জানিয়ে দেয়।
406 |
407 | **উদাহরণ:** ধরা যাক, আপনি একটি প্রোগ্রামে একটি ভেরিয়েবল ব্যবহার করেছেন কিন্তু সেটি ডিক্লেয়ার করেননি। এই ভুলটি কম্পাইল টাইমে ধরা পড়বে, এবং কম্পাইলার একটি এরর মেসেজ দেখাবে, যেমন "undefined variable"।
408 |
409 | #### **রান টাইম (Run Time):**
410 |
411 | - রান টাইম হলো যখন প্রোগ্রামটি চালু অবস্থায় থাকে এবং এক্সিকিউট হয়। এই সময়ে প্রোগ্রামটি ব্যবহারকারীর ইনপুট নেয়, ডেটা প্রসেস করে এবং আউটপুট দেয়।
412 |
413 | - এই ধাপে প্রোগ্রামটি ইনপুট নেয়, সেই ইনপুট প্রসেস করে, এবং আউটপুট দেয়। রান টাইমে কিছু ভুল ধরা পড়তে পারে যা কম্পাইল টাইমে ধরা পড়েনি, যেমন লজিক্যাল ভুল বা রানটাইম এরর (যেমন শূন্য দিয়ে ভাগ করা)।
414 |
415 | **উদাহরণ:** ধরা যাক, আপনার প্রোগ্রামে একটি লুপ আছে যা কোনো শর্তের কারণে চিরতরে চলতে থাকে (ইনফিনিট লুপ)। এই ভুলটি কম্পাইল টাইমে ধরা পড়বে না, কিন্তু যখন প্রোগ্রামটি চালানো হবে, তখন এটি রান টাইমে সমস্যা সৃষ্টি করবে।
416 |
417 | ---
418 |
419 | ### ১৭. What is escape analysis?
420 |
421 | Escape Analysis হলো গো (Go) প্রোগ্রামিং-এর একটি অপটিমাইজেশন টুল বা প্রক্রিয়া, যা কম্পাইলার দ্বারা ব্যবহৃত হয়। এটি ডিসাইড করে যে কোনো ভেরিয়েবল বা ডেটা ফাংশনের বাইরে ব্যবহার হতে পারে কিনা । এই বিশ্লেষণের উপর ভিত্তি করে কম্পাইলার ডিসাইড করে যে ভেরিয়েবলটি মেমোরির স্ট্যাক (Stack) নাকি হিপ (Heap) - এ store করা হবে।
422 |
423 | #### উদাহরণ
424 |
425 | ```go
426 | func createPointer() *int {
427 | x := 42 // x একটি ভেরিয়েবল
428 | return &x // x-এর পয়েন্টার রিটার্ন করা হচ্ছে
429 | }
430 |
431 | func main() {
432 | p := createPointer()
433 | fmt.Println(*p)
434 | }
435 | fmt.Println(*p)
436 | }
437 | ```
438 |
439 | ```
440 | এখানে x ভেরিয়েবলটি createPointer ফাংশনের ভিতরে তৈরি হয়েছে, কিন্তু এর পয়েন্টার ফাংশনের বাইরে রিটার্ন করা হয়েছে।
441 | তাই x ফাংশনের বাইরে ব্যবহার হতে পারে।
442 | এটি ফাংশন শেষ হওয়ার পরেও বিদ্যমান থাকতে হবে। তাই কম্পাইলার x-কে হিপ মেমোরি -তে store করবে।
443 | ```
444 |
445 | ---
446 |
447 | ### ১৮. Describe 2 phases of running a Go program
448 |
449 | **১। In the Compilation Phase:** এই Phase এ GO কম্পাইলার সোর্স কোডকে মেশিন কোডে (Executable Binary Code) রূপান্তর করে ও সিনট্যাক্স এবং টাইপ চেকিং করে।
450 |
451 | **২। In the Execution Phase:** এই Phase এ compiled binary code system এ run হয় এবং executing the program's logic.
452 |
453 | #### উদাহরণ
454 |
455 | ```bash
456 | go build main.go # Compilation Phase (creates an executable)
457 | ./main # Execution Phase (runs the program)
458 | ```
459 |
460 | ---
461 |
462 | ### ১৯. Closure কি এবং কিভাবে ক্রিয়েট হয়?
463 |
464 | Closure এমন এক ফাংশন, যেটা নিজের পুরনো ডাটা (যেমন: variables) মনে রাখে এবং পরের বার তার ওপর কাজ করে। বা Closure হলো একটি বিশেষ ধরনের ফাংশন, যা তার নিজের বাইরের স্কোপের (scope) ভেরিয়েবলগুলোকে "মনে রাখতে" পারে।
465 |
466 | Go প্রোগ্রামিং- escape analysis করে function তার ব্যবহৃত variables গুলাকে নিয়ে heap এ জায়গা নেয়। এইজন্য সে ফাংশন ইনবুক শেষ হবার পরেও মনে রাখতে পারে। হীপে জায়গা নেয়া ওই ফাংশন প্লাস ব্যবহৃত variables গুলা নিয়ে একত্রে closure ক্রিয়েট হয়।
467 |
468 | #### উদাহরণ
469 |
470 | ```go
471 | package main
472 | import "fmt"
473 | // একটি ফাংশন যা একটি ক্লোজার রিটার্ন করে
474 | func createCounter() func() int {
475 | counter := 0
476 | return func() int {
477 | counter++
478 | return counter
479 | }
480 | }
481 | func main() {
482 |
483 | counter1 := createCounter()
484 | fmt.Println(counter1()) // আউটপুট: 1
485 | fmt.Println(counter1()) // আউটপুট: 2
486 |
487 | counter2 := createCounter()
488 | fmt.Println(counter2()) // আউটপুট: 1
489 | fmt.Println(counter2()) // আউটপুট: 2
490 | }
491 |
492 | ```
493 |
494 | ---
495 |
496 | ### ২০. What is struct in Go?
497 |
498 | **Struct** হলো গো (Go) প্রোগ্রামিং-এর একটি গুরুত্বপূর্ণ ডেটা স্ট্রাকচার। এটি একটি কাস্টম ডেটা টাইপ যা বিভিন্ন ধরনের ডেটা ফিল্ড (ভেরিয়েবল) একত্রে গ্রুপ করে রাখতে ব্যবহৃত হয়। স্ট্রাক্ট ব্যবহার করে আমরা একটি একক ইউনিটে বিভিন্ন ধরনের ডেটা (যেমন: স্ট্রিং, ইন্টিজার, বুলিয়ান ইত্যাদি) সংরক্ষণ করতে পারি।
499 |
500 | #### উদাহরণ
501 |
502 | ```go
503 | package main
504 | import "fmt"
505 |
506 | type Person struct {
507 | Name string
508 | Age int
509 | Address string
510 | }
511 |
512 | func main() {
513 | p2 := Person{Name: "Alice", Age: 25, Address: "London"}
514 | fmt.Println("Name:", p2.Name)
515 | fmt.Println("Age:", p2.Age)
516 | fmt.Println("Address:", p2.Address)
517 | }
518 | ```
519 |
520 | ---
521 |
522 | ### ২১. What is an instance?
523 |
524 | **Instance** হলো যখন আমরা একটি struct বা কোনো কাস্টম ডেটা টাইপের জন্য একটি ভেরিয়েবল তৈরি করি, তখন সেই ভেরিয়েবলটিকে ওই ডেটা টাইপের একটি ইনস্ট্যান্স বলা হয়।
525 |
526 | - ডেটা টাইপ হলো একটি ব্লুপ্রিন্ট বা প্ল্যান (যেমন: struct), এবং ইনস্ট্যান্স হলো সেই প্ল্যান অনুযায়ী তৈরি একটি বাস্তব অবজেক্ট।
527 | - উদাহরণস্বরূপ, যদি আমরা একটি struct ডিক্লেয়ার করি যা "ব্যক্তি" (Person) প্রতিনিধিত্ব করে, তাহলে একটি বাস্তব ব্যক্তির ডেটা ধারণ করার জন্য যে ভেরিয়েবলটি তৈরি করা হয়, সেটি হলো একটি ইনস্ট্যান্স।
528 |
529 | #### উদাহরণ
530 |
531 | ```go
532 | package main
533 | import "fmt"
534 | // একটি স্ট্রাক্ট ডিক্লেয়ার করা
535 | type Person struct {
536 | Name string
537 | Age int
538 | }
539 | func main() {
540 | // স্ট্রাক্টের একটি ইনস্ট্যান্স তৈরি করা
541 | p1 := Person{Name: "John", Age: 30}
542 | p2 := Person{Name: "Alice", Age: 25}
543 |
544 |
545 | fmt.Println("Person 1:", p1)
546 | fmt.Println("Person 2:", p2)
547 | }
548 |
549 | ```
550 |
551 | ```
552 | ব্যাখ্যা:
553 | Person হলো একটি স্ট্রাক্ট (ব্লুপ্রিন্ট)।
554 | p1 এবং p2 হলো Person স্ট্রাক্টের দুটি ইনস্ট্যান্স।
555 | প্রতিটি ইনস্ট্যান্সের নিজস্ব ডেটা আছে (Name এবং Age)।
556 | ```
557 |
558 | ---
559 |
560 | ### ২২. What are member variables?
561 |
562 | Go প্রোগ্রামিং ভাষায় মেম্বার ভেরিয়েবল হল সেই সকল ভেরিয়েবল যা একটি Struct এর ভিতরে Define করা হয়। এগুলিকে আমরা 'ফিল্ড' (Fields) হিসেবেও উল্লেখ করি।
563 | স্ট্রাক্টের মেম্বার ভেরিয়েবলগুলি যেকোনো ডাটা টাইপের হতে পারে, যেমন:
564 |
565 | **প্রাথমিক টাইপ** (int, string, bool)
566 |
567 | **জটিল টাইপ** (array, slice, map)
568 |
569 | #### উদাহরণ
570 |
571 | ```go
572 | type কর্মচারী struct {
573 | আইডি int
574 | নাম string
575 | বিভাগ string
576 | বেতন float64
577 | সক্রিয় bool
578 | দক্ষতা []string
579 | }
580 | ```
581 |
582 | ```
583 | এখানে, কর্মচারী স্ট্রাক্টে নিম্নলিখিত মেম্বার ভেরিয়েবল আছে:
584 | আইডি: একটি integer ফিল্ড
585 | নাম: একটি string ফিল্ড
586 | বিভাগ: একটি string ফিল্ড
587 | বেতন: একটি floating-point ফিল্ড
588 | সক্রিয়: একটি boolean ফিল্ড
589 | দক্ষতা: একটি string slice ফিল্ড
590 |
591 | ```
592 |
593 | ---
594 |
595 | ### ২৩. What is instantiation?
596 |
597 | **Instantiation** হলো একটি ডেটা টাইপের জন্য একটি ইনস্ট্যান্স তৈরি করার পদ্ধতি।
598 |
599 | - ডেটা টাইপ হলো একটি ব্লুপ্রিন্ট বা প্ল্যান (যেমন: struct), এবং ইনস্ট্যান্টিয়েশন হলো সেই প্ল্যান অনুযায়ী একটি বাস্তব অবজেক্ট তৈরি করা।
600 | - উদাহরণস্বরূপ, যদি আমরা একটি struct ডিক্লেয়ার করি যা "ব্যক্তি" (Person) প্রতিনিধিত্ব করে, তাহলে একটি বাস্তব ব্যক্তির ডেটা ধারণ করার জন্য যে ভেরিয়েবলটি তৈরি করা হয়, সেটি হলো ওই struct-এর একটি ইনস্ট্যান্স , এবং এই প্রক্রিয়াটিকে বলা হয় ইনস্ট্যান্টিয়েশ।
601 |
602 | #### উদাহরণ
603 |
604 | ```go
605 | package main
606 | import "fmt"
607 | // একটি স্ট্রাক্ট ডিক্লেয়ার করা
608 | type Person struct {
609 | Name string
610 | Age int
611 | }
612 | func main() {
613 | // স্ট্রাক্টের ইনস্ট্যান্টিয়েশন
614 | p1 := Person{Name: "John", Age: 30}
615 | p2 := Person{Name: "Alice", Age: 25}
616 | fmt.Println("Person 1:", p1)
617 | fmt.Println("Person 2:", p2)
618 | }
619 | Output:
620 | Person 1: {John 30}
621 | Person 2: {Alice 25}
622 | ```
623 |
624 | ```
625 | ব্যাখ্যা:
626 | Person হলো একটি স্ট্রাক্ট (ব্লুপ্রিন্ট)।
627 | p1 এবং p2 হলো Person স্ট্রাক্টের দুটি ইনস্ট্যান্স।
628 | এই ইনস্ট্যান্স তৈরির প্রক্রিয়াকে বলা হয় ইনস্ট্যান্টিয়েশন।
629 | ```
630 |
631 | ---
632 |
633 | ### ২৪. What is the receiver function?
634 |
635 | Go ভাষায় "receiver function" হল একটি মেথড যেটি একটি নির্দিষ্ট টাইপের সাথে যুক্ত থাকে। এই মেথডগুলি একটি স্ট্রাক্ট (struct) বা অন্য কোনো টাইপের উপর অপারেশন সম্পাদন করতে ব্যবহৃত হয়। রিসিভার ফাংশন ডিফাইন করার সময় ফাংশনের নামের আগে একটি রিসিভার প্যারামিটার যোগ করা হয়, যা নির্দেশ করে যে এই মেথডটি কোন টাইপের সাথে যুক্ত।
636 |
637 | #### উদাহরণ
638 |
639 | ```go
640 | // একটি স্ট্রাক্ট ডিফাইন করা
641 | type Rectangle struct {
642 | width, height float64
643 | }
644 | // একটি রিসিভার ফাংশন ডিফাইন করা
645 | func (r Rectangle) Area() float64 {
646 | return r.width * r.height
647 | }
648 | func main() {
649 | // Rectangle টাইপের একটি ইনস্ট্যান্স তৈরি করা
650 | rect := Rectangle{width: 10, height: 5}
651 | // রিসিভার ফাংশন কল করা
652 | fmt.Println("Area of the rectangle:", rect.Area())
653 | }
654 |
655 | ```
656 |
657 | বিঃদ্রঃ এই উদাহরণে, Area ফাংশনটি Rectangle টাইপের একটি রিসিভার ফাংশন। rect.Area() কল করার মাধ্যমে Rectangle টাইপের rect অবজেক্টের উপর এই মেথডটি কাজ করে।
658 |
659 | ---
660 |
661 | ### ২৫. Difference between expression and statement
662 |
663 | **Expression (এক্সপ্রেশন):**
664 | Expression হল এমন একটি কোড অংশ যা একটি মান (value) তৈরি করে। এটি একটি ভ্যারিয়েবল, কনস্ট্যান্ট, অপারেটর, বা ফাংশন কলের সমন্বয়ে গঠিত হতে পারে। প্রতিটি এক্সপ্রেশন একটি নির্দিষ্ট মানে রূপান্তরিত হয়, যেমন: সংখ্যা, স্ট্রিং, বুলিয়ান ইত্যাদি।
665 |
666 | **Statement (স্টেটমেন্ট):**
667 | Statement হল এমন একটি কোড অংশ যা একটি নির্দিষ্ট কাজ (action) সম্পাদন করে। এটি প্রোগ্রামের এক্সিকিউশন ফ্লো নিয়ন্ত্রণ করে বা কোনো কাজ সম্পাদন করে, যেমন: ভ্যারিয়েবল ডিক্লেয়ার করা, লুপ চালানো, শর্ত পরীক্ষা করা ইত্যাদি। স্টেটমেন্ট সাধারণত কোনো মান তৈরি করে না, বরং এটি প্রোগ্রামের আচরণ পরিবর্তন করে।
668 |
669 | ## পার্থক্য সংক্ষেপে
670 |
671 | | **বিষয়** | **Expression (এক্সপ্রেশন)** | **Statement (স্টেটমেন্ট)** |
672 | | --------------- | ------------------------ | ---------------------- |
673 | | **সংজ্ঞা** | একটি মান তৈরি করে। | কোনো কাজ সম্পাদন করে। |
674 | | **উদাহরণ** | `x + y`, `5 * 3` | `x = 10`, `if x > 5` |
675 | | **প্রোগ্রামের আচরণ** | প্রোগ্রামের আচরণ পরিবর্তন করে না। | প্রোগ্রামের আচরণ পরিবর্তন করে। |
676 |
677 | #### উদাহরণ
678 |
679 | ```go
680 | package main
681 | import "fmt"
682 |
683 | func main() {
684 | // Expression
685 | result := 10 + 5 // 10 + 5 হল একটি এক্সপ্রেশন, যা 15 মান তৈরি করে।
686 |
687 |
688 | // Statement
689 | if result > 10 { // এটি একটি স্টেটমেন্ট, যা শর্ত পরীক্ষা করে।
690 |
691 | fmt.Println("Result is greater than 10") // এটি একটি স্টেটমেন্ট।
692 | }
693 | }
694 |
695 | ```
696 |
697 | ---
698 |
699 | ### ২৬. what is pointer? And difference between pass by value vs pass by reference
700 |
701 | **Pointer:**
702 | Pointer হলো একটি ভেরিয়েবল যা অন্য একটি ভেরিয়েবলের মেমোরি অ্যাড্রেস স্টোর করে। সহজ কথায়, পয়েন্টার আমাদের বলে দেয় যে, কোনো ডেটা মেমরির কোন স্থানে আছে, এবং আমরা সেই স্থানে গিয়ে ডেটার সাথে কাজ করতে পারি।
703 |
704 | #### উদাহরণ
705 |
706 | ```go
707 | package main
708 | import "fmt"
709 |
710 |
711 | func main() {
712 | x := 10
713 | p := &x // p হলো x এর মেমোরি অ্যাড্রেস
714 |
715 |
716 | fmt.Println("x এর মান:", x) // আউটপুট: 10
717 | fmt.Println("x এর মেমোরি অ্যাড্রেস:", p) // আউটপুট: x এর মেমোরি অ্যাড্রেস
718 | fmt.Println("p এর মাধ্যমে x এর মান:", *p) // আউটপুট: 10
719 | }
720 | ```
721 |
722 | **বিঃদ্রঃ** এখানে p হল পয়েন্টার এবং \*p দিয়ে আমরা x এর মান অ্যাক্সেস করতে পারি।
723 |
724 | ### ২৭. Difference between pass by value vs pass by reference
725 |
726 | **Pass by value:**
727 | যখন আমরা একটি ফাংশনে কোনো আর্গুমেন্ট পাস বাই ভ্যালু হিসেবে পাঠাই, তখন সেই আর্গুমেন্টের একটি কপি তৈরি হয় এবং ফাংশন সেই কপি নিয়ে কাজ করে। ফাংশনের ভিতরে কপির মান পরিবর্তন হলেও মূল ভেরিয়েবলের মান অপরিবর্তিত থাকে।
728 |
729 | #### উদাহরণ
730 |
731 | ```go
732 | package main
733 |
734 | import "fmt"
735 |
736 | func changeValue(val int) {
737 | val = 20 // শুধুমাত্র কপি পরিবর্তন করা হচ্ছে
738 | fmt.Println("ফাংশনের ভিতরে val:", val) // আউটপুট: 20
739 | }
740 |
741 | func main() {
742 | x := 10
743 | changeValue(x)
744 | fmt.Println("ফাংশনের বাইরে x:", x) // আউটপুট: 10 (মূল মান অপরিবর্তিত)
745 | }
746 | ```
747 |
748 | **Pass by Reference:**
749 | পাস বাই রেফারেন্সে আর্গুমেন্টের মেমরি অ্যাড্রেস (পয়েন্টার) ফাংশনে পাঠানো হয়। ফাংশন সেই অ্যাড্রেস ব্যবহার করে মূল ভেরিয়েবলের মান পরিবর্তন করতে পারে।
750 |
751 | #### উদাহরণ
752 |
753 | ```go
754 | package main
755 |
756 | import "fmt"
757 |
758 | func changeValue(num *int) {
759 | *num = 20 // পয়েন্টারের মাধ্যমে মূল ভেরিয়েবলের মান পরিবর্তন করা হল
760 | }
761 | func main() {
762 | x := 10
763 | fmt.Println("পরিবর্তনের আগে x:", x) // আউটপুট: 10
764 | changeValue(&x) // x এর মেমরি অ্যাড্রেস পাঠানো হল
765 | fmt.Println("পরিবর্তনের পরে x:", x) // আউটপুট: 20 (মূল মান পরিবর্তিত হয়েছে)
766 |
767 | ```
768 |
769 | #### পার্থক্য সংক্ষেপে
770 |
771 | | **বিষয়** | **Pass By Value** | **Pass By Reference** |
772 | | ---------------- | ------------------------- | --------------------------------- |
773 | | **ডাটা পাঠানো** | ভেরিয়েবলের মান পাঠানো হয়। | ভেরিয়েবলের মেমরি অ্যাড্রেস পাঠানো হয়। |
774 | | **মূল মান পরিবর্তন** | মূল ভেরিয়েবলের মান পরিবর্তন হয় না। | মূল ভেরিয়েবলের মান পরিবর্তন হয়। |
775 | | **ফাংশনে ডাটা ব্যবহার** | মূল ভেরিয়েবলের একটি কপি তৈরি হয়। | কপি তৈরি হয় না, মূল ভেরিয়েবল ব্যবহার করা হয়। |
776 |
777 | ---
778 |
779 | ### ২৮. Describe internal memory of a Go program
780 |
781 | Go প্রোগ্রাম রান হইলে প্রথমেই র্যামের কিছু অংশ অর্থাৎ মেমোরি ব্লক দখল করে ফেলে, প্রথম যে অংশ দখল করে সেটা Code Segment তারপর যে অংশ দখল করে সেটা Data segment এরপর Stack ও Heap নামে আরো ২ টা অংশ দখল করে।
782 |
783 | **বিঃদ্রঃ Go প্রোগ্রাম রান হওয়ার জন্য অবশ্যই একটা মেইন ফাংশন থাকতে হবে।**
784 |
785 | **Code Segemnt:** প্রোগ্রামে যত ফাংশন আছে সব ফাংশন চলে যায় কোড সেগমেন্টের মধ্যে অর্থাৎ ফাংশন ডেফিনিশন বা রিড অনলি ডাটাগুলি এই সেগমেন্টে স্টোর হয়।
786 |
787 | **Data Segment:** প্রোগ্রামে যত গ্লোবাল ভেরিয়েবল আছে সব জমা হবে ডাটা সেগমেন্টের ভিতরে। ডাটা সেগমেন্ট মানেই গ্লোবাল মেমোরি, এই গ্লোবাল মেমোরিতে যেকোনো ফাংশন হচ্ছে যদি তার মধ্যে না থাকে সে, কোথায় খুঁজবে ? সে দেখবে ডাটা সেগমেন্টে আছে কিনা অর্থাৎ গ্লোবাল মেমোরিতে আছে কিনা।
788 |
789 | **Stack:** Local Variables এবং ফাংশন কল স্ট্যাক মেমরিতে সংরক্ষিত হয় অর্থাৎ Code Segment এ থাকা ফাংশন যখন ইনবুক (invoke) হয় তখন ফাংশন কলের জন্য stack এ যে মেমরি অ্যালোকেট হয় তাকে বলা হয় StackFrame। এভাবে প্রতিটা ফাংশন এক্সিকিউশন শেষে StackFrame পপ আউট হয়ে যায়। এটি Last-In-First-Out (LIFO) পদ্ধতিতে কাজ করে।
790 |
791 | #### উদাহরণ
792 |
793 | ```go
794 |
795 | func calculate() int {
796 | x := 10 // `x` স্ট্যাক মেমরিতে অ্যালোকেট হয়
797 | y := 20
798 | return x + y
799 | }
800 | ```
801 |
802 | **Heap:** হিপ হলো মেমরির আরেকটি অংশ যেখানে দীর্ঘস্থায়ী ডেটা সংরক্ষণ করা হয়। ডায়নামিক অবজেক্ট যেমন গো'র স্ট্রাকচার, স্লাইস, ম্যাপ,পয়েন্টার, চ্যানেল ইত্যাদি হিপ মেমোরিতে সংরক্ষিত হয়। হিপ মেমোরি অনেক বড় এবং গার্বেজ কালেক্টর (Garbage Collector) এর দ্বারা পরিচালিত হয়।
803 |
804 | #### উদাহরণ
805 |
806 | ```go
807 |
808 | func createUser() *User {
809 | user := &User{Name: "John"} // `user` হিপে অ্যালোকেট হয় (কারণ পয়েন্টার রিটার্ন করা হচ্ছে)
810 | return user
811 | }
812 | ```
813 |
814 | **Garbage Collector:** এটি পর্যায়ক্রমে হিপ থেকে অব্যবহৃত ডেটা বা অবজেক্ট সরিয়ে দেয়, যাতে মেমরি লিক না হয় এবং মেমরি দক্ষতার সাথে ব্যবহার হয়।
815 |
816 | ***বিঃদ্রঃ Go কম্পাইলার এস্কেপ অ্যানালিসিস করে ডিসাইড করে কোন ভেরিয়েবল স্ট্যাক নাকি হিপ এ অ্যালোকেট হবে।***
817 |
818 | ---
819 |
820 |
821 | এই ডকুমেন্টের মাধ্যমে আপনি Go প্রোগ্রামিং ভাষার গুরুত্বপূর্ণ প্রশ্নোত্তর সম্পর্কে জানতে পারবেন, যা আপনার ইন্টারভিউ প্রস্তুতিতে সহায়ক হবে।
--------------------------------------------------------------------------------
/computer-architecture-&-operating-system.md:
--------------------------------------------------------------------------------
1 |
2 |
26 |
27 |
28 | ## 📚 কন্টেন্ট সূচি
29 |
30 | | ক্রম | বিষয় | লিংক |
31 | |-----|--------------------------------------------------|------------------------------------------------------|
32 | | ১ | Analytical Engine কিভাবে কাজ করতো? | [👉 এখানে দেখুন](#1-analytical-engine-কিভাবে-কাজ-করতো) |
33 | | ২ | Punch Card কি এবং এটি দিয়ে কিভাবে প্রোগ্রাম লিখতো? | [👉 এখানে দেখুন](#2-punch-card-কি-এবং-এটি-দিয়ে-কিভাবে-প্রোগ্রাম-লিখতো) |
34 | | ৩ | Punch Card থেকে ডাটা কিভাবে Ram এ উঠতো? | [👉 এখানে দেখুন](#3-punch-card-থেকে-ডাটা-কিভাবে-ram-এ-উঠতো) |
35 | | ৪ | CPU কিভাবে Pointing Register এর সাহায্যে RAM এর ডাটাকে Execute করে? | [👉 এখানে দেখুন](#4-cpu-কিভাবে-pointing-register-এর-সাহায্যে-ram-এর-ডাটাকে-execute-করে) |
36 | | ৫ | কোনটা ৩২ বিট, ৬৪ বিট, ২০ বিট কম্পিউটার কিভাবে বুঝবো? | [👉 এখানে দেখুন](#5-কোনটা-৩২-বিট-৬৪-বিট-২০-বিট-কম্পিউটার-কিভাবে-বুজবো) |
37 | | ৬ | কম্পিউটারের ডেটা প্রকাশের এককগুলো | [👉 এখানে দেখুন](#6-কম্পিউটারের-ডেটা-প্রকাশের-এককগুলো-কি-কি) |
38 | | ৭ | What is Process? | [👉 এখানে দেখুন](#7-what-is-process) |
39 |
40 | ---
41 |
42 | ## 1. Analytical Engine কিভাবে কাজ করতো?
43 |
44 | এনালিটিক্যাল ইঞ্জিনের মূল কাজ ছিল গাণিতিক হিসাব-নিকাশ করা। এটি যোগ, বিয়োগ, গুণ এবং ভাগের মতো মৌলিক গাণিতিক কাজ করতে সক্ষম ছিল। এটি আধুনিক কম্পিউটারের পূর্বসূরি বা ভিত্তি হিসেবে বিবেচিত হয়।
45 |
46 | **ইতিহাসঃ**
47 |
48 | চার্লস ব্যাবেজের অ্যানালিটিক্যাল ইঞ্জিন (Analytical Engine) হলো বিশ্বের প্রথম প্রস্তাবিত জেনারেল-পারপাস কম্পিউটার (সাধারণ উদ্দেশ্যে ব্যবহারযোগ্য গণনাযন্ত্র)। এটি ১৮৩৭ সালে ডিজাইন করা হয়েছিল, কিন্তু সম্পূর্ণ বাস্তবায়িত হয়নি। এটির কাজের পদ্ধতি আধুনিক কম্পিউটারের মতোই ছিল, নিচে সহজভাবে বোঝানো হলো:
49 |
50 | **১. ইনপুট দেওয়া (Input)**
51 | অ্যানালিটিক্যাল ইঞ্জিনে ডেটা এবং নির্দেশনা (প্রোগ্রাম) দেওয়া হতো পাঞ্চ কার্ড (ছিদ্রযুক্ত কার্ড) এর মাধ্যমে। এটি আজকের কী-বোর্ড বা মাউসের মতো কাজ করত।
52 |
53 | **২. প্রসেসিং ইউনিট (Mill)**
54 | এটির মূল গণনাকারী অংশকে "Mill" বলা হতো (আজকের CPU-র মতো)। এটি যোগ, বিয়োগ, গুণ, ভাগ সব ধরনের গাণিতিক অপারেশন করতে পারত।
55 |
56 | **৩. মেমোরি (Store)**
57 | ডেটা সংরক্ষণের জন্য ছিল "Store" (আজকের RAM বা হার্ড ডিস্কের মতো)। এখানে সংখ্যা এবং মধ্যবর্তী ফলাফল জমা রাখা হতো।
58 |
59 | **৪. কন্ট্রোল মেকানিজম**
60 | এটি শুধু গাণিতিক হিসাব করতে পারত না, বরং এটি শর্তসাপেক্ষ সিদ্ধান্তও নিতে পারত। যেমন, যদি একটি সংখ্যা শূন্যের চেয়ে বড় হয়, তবে একটি নির্দিষ্ট কাজ করবে; অন্যথায় আরেকটি কাজ করবে। (if-else লজিকের মতো)।
61 |
62 | **৫. আউটপুট**
63 | চূড়ান্ত ফলাফল (Output) প্রিন্ট করা যেত বা নতুন পাঞ্চ কার্ডে সংরক্ষণ করা যেত, যাতে পরে ব্যবহার করা যায়।
64 |
65 |
66 |
67 |
Picture Credit: Chatgpt
68 |
69 | ## 2. Punch Card কি এবং এটি দিয়ে কিভাবে প্রোগ্রাম লিখতো?
70 |
71 | **পাঞ্চ কার্ডঃ**
72 | পাঞ্চ কার্ড ছিল মোটা কাগজের কার্ড, সাধারণত ৭.৩৮ ইঞ্চি লম্বা আর ৩.২৫ ইঞ্চি চওড়া। এই কার্ডে ৮০টা কলাম থাকতো, আর প্রতি কলামে ১২টা সারি। প্রতিটা কলামে ছোট ছোট গর্ত পাঞ্চ করে নির্দিষ্ট অক্ষর বা নির্দেশনা লেখা হতো। এই গর্তগুলোই কম্পিউটার পড়তো। ধরেন, আপনি একটা প্রোগ্রাম লিখতে চান যেটা দুইটা সংখ্যা যোগ করবে। তাহলে এই নির্দেশনাগুলোকে প্রথমে একটা কোডিং ভাষায় (যেমন ফরট্রান বা কোবল) লিখতে হতো।
73 |
74 |
75 |
76 |
Picture Credit: Chatgpt
77 |
78 | **কোড লেখার প্রক্রিয়াটা ছিল এমন:**
79 |
80 |
81 |
Picture Credit: Cloude ai
82 |
83 | **১. কোড হাতে লেখা:** প্রোগ্রামার প্রথমে কাগজে হাতে কোড লিখতো। ধরেন, ফরট্রানে একটা লাইন: `Z = X + Y`। এটা একটা নির্দেশনা যে X আর Y যোগ করে Z তে রাখতে হবে।
84 |
85 | **২. পাঞ্চিং মেশিনে টাইপ:** এরপর একটা পাঞ্চিং মেশিনে (যেটা দেখতে অনেকটা টাইপরাইটারের মতো) বসে কোডের প্রতিটা অক্ষর বা নির্দেশনা টাইপ করা হতো। প্রতিটা অক্ষরের জন্য কার্ডে নির্দিষ্ট জায়গায় গর্ত হতো। যেমন, 'X' লেখার জন্য একটা নির্দিষ্ট প্যাটার্নে গর্ত করা হতো, আর '+' এর জন্য আরেকটা প্যাটার্ন।
86 |
87 | **৩. কার্ডের স্ট্যাক তৈরি:** একটা প্রোগ্রামে অনেক লাইন কোড থাকতে পারে, তাই অনেকগুলো কার্ড লাগতো। প্রতিটা কার্ডে একটা বা কয়েকটা নির্দেশনা থাকতো। এই কার্ডগুলোকে ঠিকঠাক সিরিয়ালে সাজিয়ে একটা স্ট্যাক বানানো হতো।
88 |
89 | **৪. কম্পিউটারে দেওয়া:** এই কার্ডের স্ট্যাকটা কম্পিউটারের কার্ড রিডারে দেওয়া হতো। রিডারটা গর্তগুলো পড়ে বুঝতো কী নির্দেশনা দেওয়া হচ্ছে। গর্তের প্যাটার্ন থেকে কম্পিউটার বাইনারি কোডে রূপান্তর করতো, আর সেই কোড চালিয়ে প্রোগ্রাম রান করতো।
90 |
91 | মজার ব্যাপার হলো, এই পাঞ্চ কার্ডে ভুল হলে পুরো কার্ডটা ফেলে নতুন করে লিখতে হতো। একটা কার্ড ভুল জায়গায় চলে গেলে বা ফেলে দিলে পুরো প্রোগ্রাম গোলমাল হয়ে যেতো! 😅 তাই প্রোগ্রামাররা খুব সাবধানে কার্ডগুলো সাজাতো, এমনকি কার্ডে নম্বর লিখে রাখতো যাতে সিরিয়াল ঠিক থাকে।
92 |
93 | তো, এভাবেই পাঞ্চ কার্ড দিয়ে প্রোগ্রাম লেখা হতো। এটা ছিল ধীর, কষ্টের কাজ, কিন্তু তখনকার দিনে এটাই ছিল কম্পিউটার প্রোগ্রামিংয়ের একমাত্র উপায়। এখন আমরা কিবোর্ডে টাইপ করে সেকেন্ডের মধ্যে কোড লিখে ফেলি, কিন্তু তখনকার প্রোগ্রামারদের ধৈর্য আর নিষ্ঠার কাছে স্যালুট দিতে হয়, তাই না? 😊
94 |
95 |
96 | ## 3. Punch Card থেকে ডাটা কিভাবে Ram এ উঠতো?
97 |
98 | অ্যানালিটিক্যাল ইঞ্জিনের যুগে RAM বলে আলাদা কোনো জিনিস ছিল না, কিন্তু "স্টোর" নামে একটা মেমরি সেকশন ছিল যেটা আজকের RAM-এর মতোই কাজ করত! পুরো প্রক্রিয়াটা এমন ছিল:
99 |
100 |
101 |
102 |
Picture Credit: Chatgpt
103 |
104 | **১. পাঞ্চ কার্ড পড়ার যন্ত্র (কার্ড রিডার):**
105 | - কার্ডটাকে এই যন্ত্রের মধ্যে ঢুকানো হতো যেখানে ছিদ্রের অবস্থান অনুযায়ী মেটাল পিন বা আলো তৈরি হত।
106 | - যেমন: কার্ডের ৩ নম্বর পজিশনে ছিদ্র/আলো থাকলে সেটা বাইনারি ১ আর না থাকলে ০ হিসাবে পড়া হতো।
107 |
108 | **২. ডাটা ট্রান্সফার:**
109 | - কার্ড রিডার থেকে ডাটা যেত "কন্ট্রোল ইউনিট"-এ (যেটা আজকের CPU-র মতো কাজ করত)।
110 | - কন্ট্রোল ইউনিট ঠিক করত ডাটাটা কোথায় জমা হবে—স্টোরের (মেমরি) কোন লোকেশনে।
111 | - উদাহরণ: ৫ + ৩ প্রোগ্রামে ৫ কে স্টোরের ০ নম্বর সেল-এ রাখা হতো, ৩ কে ১ নম্বর সেল-এ।
112 |
113 | **৩. মেমরিতে জমা হওয়া:**
114 | - অ্যানালিটিক্যাল ইঞ্জিনের স্টোর অংশটা ছিল গিয়ার, লিভার আর ডায়াল-এর সমষ্টি।
115 | - প্রতিটি সংখ্যা জমা হতো যান্ত্রিক ডায়াল ঘুরিয়ে (ঘড়ির মতো!)—যেমন: ডায়ালে ৫ সেট করলে সেটাই মেমরিতে সেভ হয়ে যেত।
116 | - আজকের RAM-এর মতো ইলেকট্রিক সিগনাল নয়, তখন মেকানিক্যাল মুভমেন্ট দিয়ে ডাটা স্টোর হতো!
117 |
118 | ### উদাহরণ:
119 | ধরুন, আপনি ১০ + ২০ গণনা করতে চান। তখন:
120 | - ১০ এর কার্ড পড়ে স্টোরের সেল ০ এ জমা হতো।
121 | - ২০ এর কার্ড পড়ে স্টোরের সেল ১ এ জমা হতো।
122 | - (+) এর কার্ড পড়ে মিল (প্রসেসর) সেল ০ ও সেল ১-এর ডাটা যোগ করে সেল ২-তে রাখত।
123 |
124 | **সংক্ষেপে:**
125 | পাঞ্চ কার্ড → Card Reader পড়ে → বাইনারি বানায় → RAM/STORE এ পাঠায় → CPU কাজ করে
126 |
127 | ## 4. CPU কিভাবে Pointing Register এর সাহায্যে RAM এর ডাটাকে Execute করে?
128 |
129 | Pointing Register হলো CPU-এর জন্য একটা "গাইড"। এটা বলে দেয় কোথায় কোন ডেটা আছে, যাতে CPU সেটা নিয়ে কাজ করতে পারে। তারপর CPU ডেটা প্রসেস করে এবং ফলাফল দেয়।
130 |
131 | ধাপে ধাপে যেভাবে কাজ হয়:
132 |
133 | **১. Program Counter (PC)**
134 |
135 | প্রথমে CPU দেখে, PC (Pointing Register)-তে যেই অ্যাড্রেস আছে, সেখানে RAM-এ কী লেখা আছে।
136 |
137 | **২. Instruction Fetch**
138 |
139 | সেই অ্যাড্রেস থেকে CPU RAM-এর ডাটা নেয় — এটাকেই বলে “fetch” করা।
140 |
141 | **৩. Decode & Execute**
142 |
143 | ডাটা বা নির্দেশনা CPU বুঝে ফেলে (decode করে) আর সেই অনুযায়ী কাজ করে (execute করে)। যেমন: যোগ করো,গুন করো, লিখো ইত্যাদি।
144 |
145 | **৪. Program Counter আপডেট হয়**
146 |
147 | একটা ইনস্ট্রাকশন শেষ হলে, PC নিজে থেকেই পরের অ্যাড্রেসে চলে যায় (ধরেন, প্রথমে 100 থাকলে এখন 104 হয়ে যাবে)। যেন CPU জানে, পরেরবার কোথা থেকে পড়তে হবে।
148 |
149 | ### উদাহরণ:
150 |
151 | ```go
152 | RAM এ আছে এমন ৩টা লাইন:
153 | 100: LOAD A
154 | 104: ADD B
155 | 108: PRINT
156 |
157 | ```
158 | ---
159 |
160 | তখন:
161 | PC = 100 → CPU যাবে 100 নম্বর অ্যাড্রেসে → “LOAD A” নিবে
162 |
163 | তারপর PC = 104 → “ADD B” নিবে
164 |
165 | তারপর PC = 108 → “PRINT” নিবে
166 |
167 | ***এইভাবে PC বা Pointing Register CPU কে পথ দেখিয়ে RAM থেকে একটার পর একটা নির্দেশনা বের করে আনে।***
168 |
169 | ## 5. কোনটা ৩২ বিট, ৬৪ বিট, ২০ বিট কম্পিউটার কিভাবে বুজবো?
170 |
171 | **বিট কী?**
172 |
173 | বিট হলো কম্পিউটারের ভাষায় ডেটা প্রকাশের সবচেয়ে ছোট একক। এটা হয় 0 অথবা 1। মনে রাখতে হবে, ৮ বিট = ১ বাইট।
174 |
175 | এখন যদি বলা হয় একটা **কম্পিউটার ৩২-বিট**, তার মানে হলো সেই কম্পিউটার একবারে ৩২টি বিট (অর্থাৎ ৩২টি 0 বা 1) নিয়ে কাজ করতে পারে। অর্থাৎ র্যামের একটি সেলে ৩২ টি বিট বা 0,1 পাশাপাশি রাখতে পারে।এরা সর্বোচ্চ ৪ জিবি RAM (2^32 বাইট) অ্যাড্রেস করতে পারে। এটা সাধারণত ছোট ধরনের কাজের জন্য ব্যবহৃত হয়।
176 |
177 | একটা **কম্পিউটার ৬৪-বিট** মানে হলো সেই কম্পিউটার একবারে ৬৪ টি বিট (অর্থাৎ ৬৪টি 0 বা 1) নিয়ে কাজ করতে পারে। অর্থাৎ র্যামের একটি সেলে ৬৪ টি বিট বা 0,1 পাশাপাশি রাখতে পারে।এরা অনেক বেশি RAM অ্যাড্রেস করতে পারে, তাত্ত্বিকভাবে ১৮ কোটি গিগাবাইট (2^64 বাইট)। এটা বড় ধরনের কাজ, যেমন গেমিং, ভিডিও এডিটিং, বা ভারী সফটওয়্যার চালানোর জন্য উপযোগী।
178 |
179 | **২০ বিট কম্পিউটার** আসলে খুব পুরোনো, ১৯৭০-৮০ এর দশকের কথা। এটা সাধারণত পুরোনো মেইনফ্রেম বা মিনি কম্পিউটারে ব্যবহৃত হতো, যেমন PDP-11 সিস্টেম। এগুলোর অ্যাড্রেস বাস ২০ বিটের হতো, মানে এরা ১ মেগাবাইট (2^20 বাইট) পর্যন্ত মেমরি অ্যাড্রেস করতে পারতো।
180 |
181 |
182 | ## 6. কম্পিউটারের ডেটা প্রকাশের এককগুলো কি কি?
183 |
184 | বিট → বাইট → কিলোবাইট → মেগাবাইট → গিগাবাইট → টেরাবাইট → পেটাবাইট
185 |
186 | | একক | সমান | উদাহরণ |
187 | |------------------|--------------|------------------------|
188 | | 1 KB (Kilobyte) | 1024 Bytes | ছোট TXT ফাইল |
189 | | 1 MB (Megabyte) | 1024 KB | ছবি, গান |
190 | | 1 GB (Gigabyte) | 1024 MB | মুভি, অ্যাপ |
191 | | 1 TB (Terabyte) | 1024 GB | হার্ডডিস্ক, SSD |
192 | | 1 PB (Petabyte) | 1024 TB | ডেটা সেন্টার |
193 | | 1 EB (Exabyte) | 1024 PB | পুরো ইন্টারনেটের ডেটা! |
194 |
195 | ## 7. What is Process?
196 |
197 | একটি প্রোগ্রামের লাইন ১ থেকে শেষ পর্যন্ত এক্সিকিউশন হওয়ার জন্য Ram এর একটা অংশ যেমনঃ (Code Segment,Data Segment,Stack,Heap) এবং CPU এর মধ্যে থাকা Processing unit, Register Set একসাথে মিলে যে কাজ সম্পাদন করে, ঐ কাজের প্রক্রিয়াকে Process বলে।
198 |
199 | নোটঃ একটা Physical Computer এর যা যা আছে (Ram,CPU) প্রসেসেরও তা তা আছে তাই প্রসেসরকে Virtual Computer বলা হয়।
200 |
201 |
202 |
