এই পর্বে যা শিখবেন
- প্রোগ্রামিং ভাষা আর compiler বোঝা কেন একজন programmer-এর দৈনন্দিন কাজে লাগে: debugging, গতি, নিরাপত্তা আর নিজের tool বানানো
- একটি লাইন কীভাবে lexer, parser আর interpreter পেরিয়ে ফল দেয়, আর একই লাইন কীভাবে bytecode হয়ে একটি virtual machine-এ চলে
- কোর্সের ১৪টি মডিউলের মানচিত্র, আর compiler-এর কোন অংশ কোন মডিউলে বানানো হবে
- Haat ভাষার নিয়ম,
bazar.haatপ্রোগ্রাম আর তার আউটপুট, আর কোর্স জুড়ে Haat কীভাবে বড় হবে - নিজের লক্ষ্য অনুযায়ী পড়ার পথ বাছাই, আর পাতার ভেতরের Python, JavaScript ও Wandbox ব্যবহারের নিয়ম
১ · কেন ভাষা আর compiler শিখবেন — প্রতিদিনের অদৃশ্য সহকারী
সকালে আপনি একটি Python script চালালেন, দুপুরে একটি ওয়েবসাইটের JavaScript ঠিক করলেন, বিকেলে একটি C প্রোগ্রাম compile করলেন। তিনটি কাজেই আপনার লেখা লাইনগুলো সরাসরি CPU-তে যায়নি। প্রতিবার মাঝখানে একটি প্রোগ্রাম আপনার লেখা পড়েছে, বুঝেছে, ভুল খুঁজেছে আর তারপর চালিয়েছে। যে লেখায় আপনি নির্দেশ দেন, সেটি একটি programming language; আর যে প্রোগ্রাম সেই লেখা পড়ে চালানোর ব্যবস্থা করে, সেটি একটি compiler বা interpreter.
একজন দোভাষীর কথা ভাবুন। ঢাকার এক ব্যবসায়ী জাপানি ক্রেতার সঙ্গে কথা বলছেন। দোভাষী দুইভাবে কাজ করতে পারেন। এক, পুরো চুক্তিপত্র আগেই জাপানিতে অনুবাদ করে ছাপিয়ে দিতে পারেন; ক্রেতা পরে যতবার খুশি পড়বেন, দোভাষীর আর দরকার নেই। এটি compiler-এর ধরন। দুই, সভায় পাশে বসে প্রতিটি বাক্য শোনামাত্র মুখে মুখে অনুবাদ করতে পারেন। এটি interpreter-এর ধরন। দুই ক্ষেত্রেই ভালো দোভাষী শুধু শব্দ বদলান না; তিনি বাক্যের গঠন বোঝেন, অর্থ ধরেন, আর অস্পষ্ট বাক্যে থেমে জিজ্ঞেস করেন। এই কোর্স সেই দোভাষীর মাথার ভেতরের কাজটি খুলে দেখাবে, তারপর আপনাকে দিয়ে একটি দোভাষী বানাবে।
আপনার লেখা কোড, অর্থাৎ source code, মানুষের পড়ার জন্য। CPU বোঝে শুধু তার নিজের machine code. এই দুইয়ের মাঝের দূরত্ব পার করাই অনুবাদকের কাজ। এই কাজ দুটি আলাদা সময়ে ঘটতে পারে, আর পুরো কোর্সে এই দুটি শব্দ বারবার আসবে:
Static (চালানোর আগে): প্রোগ্রাম চালানোর আগে যা জানা যায় বা যাচাই করা যায়, যেমন বানান, ব্যাকরণ, type-এর মিল। এই সময়কে বলে compile time. Dynamic (চলার সময়): প্রোগ্রাম চলার সময়ই যা জানা যায়, যেমন ব্যবহারকারী কোন সংখ্যা দিলেন, শূন্য দিয়ে ভাগ হলো কি না। এই সময়কে বলে runtime. একটি ভাষার নকশার বড় অংশই হলো ঠিক করা, কোন ভুল static-ভাবে ধরা হবে আর কোনটি dynamic-ভাবে।
কেন এসব জানা দরকার, যখন compiler নিজেই কাজটি করে দেয়? পাঁচটি বাস্তব কারণ আছে:
Error পড়তে পারা
expected ';', undefined variable, type mismatch: প্রতিটি বার্তা অনুবাদকের একটি নির্দিষ্ট ধাপ থেকে আসে। ধাপটি চিনলে ভুলের জায়গা অর্ধেক খোঁজা হয়ে যায়।
গতি বোঝা
একই হিসাব একটি ভাষায় ধীর আর আরেকটিতে দ্রুত কেন, -O2 আসলে কী বদলায়, JIT কখন সাহায্য করে: এসবের উত্তর অনুবাদকের ভেতরে।
নিরাপত্তা
C-তে কিছু ভুলের ফল ভাষার নিয়মে নির্দিষ্ট নেই (undefined behavior), আর optimizer সেই ফাঁক কাজে লাগায়। কোন ভাষা কোন ভুল আটকায়, তা জানলে নিরাপদ কোড লেখা সহজ।
মডিউল ৬, ১৩নিজের tool বানানো
Config ফাইল পড়া, সূত্র হিসাব করা, নিয়মের ছোট ভাষা: বাস্তব কাজে প্রায়ই একটি ছোট parser বা interpreter লাগে। একে বলে DSL.
মডিউল ৮, ১৩পঞ্চম কারণটি সবচেয়ে বড়: নতুন ভাষা শেখা সহজ হয়। প্রতিটি ভাষা কয়েকটি মৌলিক ধারণার একটি নির্দিষ্ট মিশ্রণ: নামের scope কীভাবে কাজ করে, function-এ argument কীভাবে যায়, type কখন যাচাই হয়, মেমরি কে ফেরত নেয়। এই ধারণাগুলো একবার স্পষ্ট হলে Go বা Kotlin শেখা মানে শুধু জানা, এই ভাষা প্রতিটি প্রশ্নে কোন উত্তর বেছে নিয়েছে। একটি ভাষার লেখার নিয়ম (syntax), অর্থ (semantics) আর ব্যবহারের রীতি (pragmatics) কীভাবে আলাদা করে ভাবতে হয়, তা পর্ব ০৩-এ দেখবেন।
“কোড লিখে অনুবাদকের হাতে দেওয়া” ধারণাটি নতুন নয়। ১৯৫০-এর দশকের শুরুতে Grace Hopper-এর দলের A-0-কে অনেকে প্রথম compiler বলেন, যদিও আজকের অর্থে এটি বেশি ছিল subroutine জোড়ার একটি ব্যবস্থা। ১৯৫৭ সালে IBM-এ John Backus-এর দল FORTRAN-এর compiler প্রকাশ করে, আর তাদের বড় লক্ষ্য ছিল দেখানো যে compiler-এর বানানো কোড হাতে লেখা assembly-র কাছাকাছি দ্রুত হতে পারে। ভাষার পুরো ইতিহাস আর পরিবার পর্ব ০২-এ (প্রোগ্রামিং ভাষার ইতিহাস আর পরিবার) দেখবেন।
২ · একটি লাইনের যাত্রা — print(2 + 3 * 4);
পুরো কোর্সের সারাংশ একটি লাইনেই ধরা যায়। Haat ভাষার এই লাইনটি নিন: print(2 + 3 * 4);. মানুষ দেখেই বলবেন উত্তর 14, কারণ গুণ আগে হয়। কিন্তু অনুবাদকের কাছে এটি প্রথমে শুধু ১৭টি অক্ষরের একটি সারি। সেখান থেকে 14 পর্যন্ত পৌঁছাতে তিনটি বড় ধাপ লাগে। নিচের ডায়াগ্রামে “পরে” চেপে প্রতিটি ধাপে ভেতরের জিনিস কীভাবে বদলায়, তা দেখুন।
- Source
17 অক্ষরমানুষের লেখা - Lexer
tokenশব্দে ভাঙা - Parser
precedenceকে কার সঙ্গে - AST
গাছগঠন - Interpreter
evalহিসাব - Output
14ফল
p r i n t ( 2 ␣ + ␣ 3 ␣ * ␣ 4 ) ;
১৭টি অক্ষর; ␣ = ফাঁকা ঘর
1:1 PRINT 1:6 LPAREN 1:7 INT 2
1:9 PLUS 1:11 INT 3 1:13 STAR
1:15 INT 4 1:16 RPAREN 1:17 SEMI
2:1 EOF
ফাঁকা ঘর বাদ, ১০টি token
2 '+' lbp 50 ≥ 0 → '+' 2-কে নেয়
3 '*' lbp 60 ≥ 51 → '*' 3-কে নেয়
4 ')' operator নয় → থামা
ফল: 2 + (3 * 4)
Print
└─ Binary +
├─ Num 2
└─ Binary *
├─ Num 3
└─ Num 4
(print (+ 2 (* 3 4)))
Binary * : 3 * 4 = 12
Binary + : 2 + 12 = 14
Print : 14 ছাপা
$ python haat.py run line.haat
14
- ধাপ ১ — শুধু অক্ষর। অনুবাদকের হাতে আসে ১৭টি অক্ষর। “print” যে একটি শব্দ, বা 2 আর 3 যে সংখ্যা, এখনো কেউ জানে না। ঠিক যেন হাতে লেখা একটি বাজারের ফর্দ, যা এখনো কেউ পড়েনি।
- ধাপ ২ — Lexer: শব্দে ভাঙা। Lexer অক্ষর পড়ে ছোট অর্থপূর্ণ টুকরো বানায়, যার প্রতিটি একটি token: keyword
PRINT, পূর্ণসংখ্যাINT, চিহ্নPLUS. ফাঁকা ঘর ফেলে দেওয়া হয়। প্রতিটি token-এর সঙ্গে থাকে তার অবস্থান (line:col), যাতে পরে error বার্তায় ঠিক জায়গা বলা যায়। মোট ১০টি token, শেষেরটি EOF (লেখা শেষ); লাইনের শেষে newline আছে বলে EOF-এর অবস্থান 2:1. - ধাপ ৩ — Parser: কে কার সঙ্গে বাঁধা। Parser ঠিক করে, 3 কি
+-এর সঙ্গে যাবে না*-এর সঙ্গে। এখানে প্রতিটি operator-এর একটি বাঁ দিকের “binding power” (lbp) আছে:+50,*60.+-এর ডান অংশ পড়া হয় সীমা 51 নিয়ে। 3-এর পরে*এসেছে, যার lbp 60 ≥ 51, তাই 3 যায়*-এর সঙ্গে। এই নিয়মই operator precedence. - ধাপ ৪ — AST: গঠনের গাছ। Parser-এর ফল একটি abstract syntax tree. বন্ধনী আর
;নেই, কারণ গাছের আকারই এখন বলে কোনটি আগে হবে:*নিচে, তাই আগে। বাকি সব ধাপ এই গাছ নিয়েই কাজ করে। - ধাপ ৫ — Interpreter: গাছ বেয়ে হিসাব। একটি সহজ interpreter গাছের নিচ থেকে ওপরে যায়: আগে 3 * 4 = 12, তারপর 2 + 12 = 14, শেষে Print. এই ধরনের interpreter-এর নাম tree-walking interpreter; মডিউল ১০-এ Haat-এর জন্য পুরোটা বানাবেন।
- ধাপ ৬ — ফল। পর্দায় আসে 14. এক লাইনের জন্য তিনটি যন্ত্র কাজ করল। আসল ভাষায় এর মাঝে আরও ধাপ থাকে: নাম খোঁজা, type যাচাই, optimization. সেগুলো অংশ ৩-এর মানচিত্রে দেখবেন।
এবার ঠিক এই কাজটি নিজের চোখে চালিয়ে দেখুন। নিচের Python কোড Haat-এর lexer: একটি regular expression দিয়ে প্রতিটি token-এর ধরন চেনে, আর line:col হিসাব রাখে। কোডটি আপনার ব্রাউজারে আসল CPython-এ চলে (Pyodide), কোনো সার্ভারে নয়। এটি কোর্সের Haat reference বাস্তবায়নের lexer.py-এর ছোট রূপ, একই token-নাম আর একই error বার্তা নিয়ে; পুরো lexer (string-এর escape, খুব বড় সংখ্যার error-সহ) পর্ব ৪৬-এ (হাতে লেখা lexer) বানাবেন।
import re
from collections import namedtuple
Token = namedtuple("Token", "kind text line col")
KEYWORDS = {"let", "var", "fn", "if", "else", "while", "return", "true", "false", "print"}
OPS = {"->": "ARROW", "==": "EQ_EQ", "!=": "BANG_EQ", "<=": "LT_EQ", ">=": "GT_EQ",
"&&": "AND_AND", "||": "OR_OR", "+": "PLUS", "-": "MINUS", "*": "STAR", "/": "SLASH",
"%": "PERCENT", "<": "LT", ">": "GT", "!": "BANG", "=": "EQ", "(": "LPAREN",
")": "RPAREN", "{": "LBRACE", "}": "RBRACE", ",": "COMMA", ";": "SEMI", ":": "COLON"}
RX = re.compile(r'(?P<SKIP>[ \t\r]+|//[^\n]*)|(?P<NL>\n)|(?P<INT>[0-9]+)'
r'|(?P<STRING>"(?:\\["\\n]|[^"\\\n])*")|(?P<IDENT>[A-Za-z_][A-Za-z0-9_]*)'
r'|(?P<OP>->|[=!<>]=|&&|\|\||[-+*/%<>!=(){},;:])|(?P<BAD>.)')
def lex(src):
toks, line, line_start = [], 1, 0
for m in RX.finditer(src):
kind, text = m.lastgroup, m.group()
col = m.start() - line_start + 1 # positions are 1-based
if kind == "NL":
line, line_start = line + 1, m.end()
elif kind == "BAD":
raise SyntaxError(f"{line}:{col}: error: unexpected character '{text}'")
elif kind != "SKIP": # white space and comments vanish
if kind == "OP": kind = OPS[text]
elif text in KEYWORDS: kind = text.upper()
toks.append(Token(kind, text, line, col))
return toks + [Token("EOF", "", line, len(src) - line_start + 1)]
for t in lex("print(2 + 3 * 4);\n"):
print((f"{t.line}:{t.col}".ljust(7) + t.kind.ljust(9) + t.text).rstrip())
try:
lex("let dam = 520;\nlet total = dam # 2;\n")
except SyntaxError as e:
print(e)আসল আউটপুট (ব্রাউজারের Python):
1:1 PRINT print
1:6 LPAREN (
1:7 INT 2
1:9 PLUS +
1:11 INT 3
1:13 STAR *
1:15 INT 4
1:16 RPAREN )
1:17 SEMI ;
2:1 EOF
2:17: error: unexpected character '#'
উপরের stepper-এর ধাপ ২ হুবহু এখানে: keyword-এর kind তার বড় হাতের রূপ (PRINT), operator-এর kind তার নাম (PLUS, STAR), সংখ্যার kind INT; প্রতিটি অবস্থান ১ থেকে গোনা। Reference-এর python haat.py tokens একই লাইনে হুবহু এই দশটি লাইন দেয় (আমরা ল্যাবে মিলিয়ে দেখেছি), আর #-এর error বার্তাও হুবহু এক। শেষ লাইনটি একটি lexical error: দ্বিতীয় লাইনের ১৭ নম্বর ঘরে #, যা Haat-এর কোনো token-এর শুরু হতে পারে না। বার্তার রূপ line:col: error: …, যা Haat-এর সব error-এর নির্দিষ্ট রূপ। Regex দিয়ে lexer বানানোর তত্ত্ব (কেন এটি একটি finite automaton) গণনার তত্ত্ব কোর্সের পর্ব ২২-এ আছে; এই কোর্সে আমরা সেই তত্ত্ব ব্যবহার করে যন্ত্র বানাব।
এবার parser আর interpreter. নিচের কোড উপরের lex ব্যবহার করে (একই পাতার Python ব্লকগুলো একটি namespace ভাগ করে, তাই এটি চালালে উপরেরটি আগে নিজে থেকে চলে)। Parser-টি Pratt parsing পদ্ধতির, reference-এর parser.py-র একই সংখ্যা নিয়ে: একটি সংখ্যা পড়ে, তারপর যতক্ষণ পরের operator-এর lbp চলতি সীমার সমান বা বেশি, ততক্ষণ সেটিকে বাঁধে; তার ডান অংশ পড়া হয় সীমা lbp + 1 নিয়ে। Interpreter ev গাছ বেয়ে হিসাব করে, আর Haat-এর নিয়ম মানে: Int ৬৪-বিট, সীমা পেরোলে ঘুরে যায় (wrap); / শূন্যের দিকে কাটে আর %-এর চিহ্ন ভাজ্যের মতো, ঠিক C-র মতো।
Num, Bool = namedtuple("Num", "value"), namedtuple("Bool", "value")
Unary, Binary = namedtuple("Unary", "op operand"), namedtuple("Binary", "op left right")
LBP = {"OR_OR": 10, "AND_AND": 20, "EQ_EQ": 30, "BANG_EQ": 30, "LT": 40, "LT_EQ": 40, "GT": 40,
"GT_EQ": 40, "PLUS": 50, "MINUS": 50, "STAR": 60, "SLASH": 60, "PERCENT": 60}
def parse(toks, i=0, min_bp=0): # Pratt parser -> (AST, next index)
t = toks[i]; i += 1
if t.kind == "INT": left = Num(int(t.text))
elif t.kind in ("TRUE", "FALSE"): left = Bool(t.kind == "TRUE")
elif t.kind in ("MINUS", "BANG"): e, i = parse(toks, i, 70); left = Unary(t.text, e)
elif t.kind == "LPAREN": left, i = parse(toks, i); i += 1 # skip ')'
else: raise SyntaxError(f"{t.line}:{t.col}: error: expected expression")
while toks[i].kind in LBP and LBP[toks[i].kind] >= min_bp: # strong enough to bind?
op = toks[i]
right, i = parse(toks, i + 1, LBP[op.kind] + 1) # rbp = lbp + 1: left-assoc
left = Binary(op.text, left, right)
if LBP[op.kind] in (30, 40) and LBP.get(toks[i].kind) == LBP[op.kind]:
raise SyntaxError(f"{toks[i].line}:{toks[i].col}: error: comparison operators cannot be chained")
return left, i
def wrap(n): return (n + 2**63) % 2**64 - 2**63 # Int: 64-bit, overflow wraps
def ev(e):
if isinstance(e, (Num, Bool)): return e.value
if isinstance(e, Unary): return wrap(-ev(e.operand)) if e.op == "-" else not ev(e.operand)
if e.op == "&&": return ev(e.left) and ev(e.right) # short-circuit
if e.op == "||": return ev(e.left) or ev(e.right)
a, b = ev(e.left), ev(e.right)
if e.op in ("/", "%") and b == 0: raise ZeroDivisionError("division by zero")
q = abs(a) // abs(b) * (1 if (a < 0) == (b < 0) else -1) if e.op in ("/", "%") else 0
return {"+": wrap(a + b), "-": wrap(a - b), "*": wrap(a * b), "/": wrap(q), "%": a - b * q,
"==": a == b, "!=": a != b, "<": a < b, "<=": a <= b, ">": a > b, ">=": a >= b}[e.op]
show = lambda v: str(v).lower() if isinstance(v, bool) else v
for src in ["2 + 3 * 4", "(2 + 3) * 4", "10 - 4 - 3", "2 * 520 - 2 * 520 / 10",
"-7 / 2", "-7 % 2", "9223372036854775807 + 1", "1 < 2 && !false", "1 < 2 < 3"]:
try: print(f"{src:25} = {show(ev(parse(lex(src))[0]))}")
except SyntaxError as err: print(f"{src:25} -> {err}")
print(parse(lex("2 + 3 * 4"))[0])আসল আউটপুট (ব্রাউজারের Python):
2 + 3 * 4 = 14
(2 + 3) * 4 = 20
10 - 4 - 3 = 3
2 * 520 - 2 * 520 / 10 = 936
-7 / 2 = -3
-7 % 2 = -1
9223372036854775807 + 1 = -9223372036854775808
1 < 2 && !false = true
1 < 2 < 3 -> 1:7: error: comparison operators cannot be chained
Binary(op='+', left=Num(value=2), right=Binary(op='*', left=Num(value=3), right=Num(value=4)))
প্রথম লাইন stepper-এর 14. দ্বিতীয় লাইনে বন্ধনী গঠন বদলে দেয়, তাই 20. তৃতীয় লাইন associativity: 10 - 4 - 3 মানে (10 − 4) − 3 = 3, কারণ প্রথম --এর ডান অংশ পড়া হয় সীমা 51 নিয়ে, আর দ্বিতীয় --এর lbp 50 সেই সীমায় পৌঁছায় না; তাই সেটি বাঁ দিকের গাছেই যুক্ত হয়। চতুর্থ লাইন বাজারঘরের হিসাব: 2 × 520 = 1040, তার থেকে 1040 / 10 = 104 বাদ দিয়ে 936. পঞ্চম আর ষষ্ঠ লাইনে Haat-এর ভাগের নিয়ম: −7 / 2 = −3 (শূন্যের দিকে কাটা), আর −7 % 2 = −1 (ভাজ্য ঋণাত্মক, তাই ভাগশেষও ঋণাত্মক)। Python নিজে -7 // 2-তে −4 দেয়; আমাদের ev সেটি এড়াতে আলাদা করে হিসাব করে। সপ্তম লাইনে Int-এর সবচেয়ে বড় মানে 1 যোগ করলে মান ঘুরে সবচেয়ে ছোট ঋণাত্মক সংখ্যায় যায়, কারণ Haat-এর নিয়মে overflow wrap করে। অষ্টম লাইনে && আর !. নবম লাইনে Haat-এর একটি নিয়ম: তুলনা শিকলের মতো পাশাপাশি বসে না, তাই দ্বিতীয় <-এ (কলাম 7) syntax error. শেষ লাইন stepper-এর ধাপ ৪-এর গাছ, Python-এর নিজের ভাষায়। Reference-এর run আর vm দুটিই প্রথম আটটি expression-এ হুবহু এই মানগুলো দিয়েছে (ল্যাবে মেলানো)। এই ছোট সংস্করণে AST-তে অবস্থান রাখা হয়নি, তাই শূন্য দিয়ে ভাগের বার্তায় line:col নেই; reference-এর AST node-এ line, col থাকে, আর সে পুরো রূপ line:col: runtime error: division by zero দেয়।
৩ · Compiler-এর মানচিত্র আর কোর্সের ১৪টি মডিউল
অংশ ২-এর তিন যন্ত্র ছিল সবচেয়ে ছোট পথ। একটি পূর্ণ compiler-এ আরও কয়েকটি ধাপ থাকে, আর প্রতিটি ধাপের মাঝে একটি নির্দিষ্ট ডেটা-কাঠামো হাত বদলায়: token-এর সারি, গাছ, নামের তালিকা, মাঝামাঝি ভাষা। নিচের ছবিটি এই কোর্সের মানচিত্রও, কারণ প্রতিটি বাক্সের পাশে লেখা আছে কোন মডিউলে আপনি সেটি বানাবেন।
Haat-এর পূর্ণ পথ — কোন ধাপ কোন মডিউলে
ওপরে front end, তারপর দুই পথ: সরাসরি চালানো (interpreter, VM) অথবা IR হয়ে machine code. নিচের বেগুনি পট্টি প্রতিটি ধাপের নিয়মের উৎস।
মানচিত্রটি তিন ভাগে পড়ুন। ওপরের নীল বাক্সগুলো front end: এরা উৎস-ভাষাকে বোঝে, ভুল ধরে, আর একটি যাচাই-করা গাছ দেয়। এখানে semantic analysis মানে ব্যাকরণের পরের যাচাই: প্রতিটি নাম কোথায় ঘোষিত, আর type মেলে কি না (এই কাজ করে type checker). হলুদ বাক্সগুলো middle end আর back end: IR নামের একটি মাঝামাঝি ভাষায় optimization, তারপর code generation, অর্থাৎ একটি নির্দিষ্ট যন্ত্রের নির্দেশ বানানো। আর বাঁ দিকের লাল-সবুজ পথটি interpreter-এর: অনুবাদ শেষ না করেই সরাসরি চালানো।
ধাপগুলোর ভেতরে কী আসে আর কী বের হয়, আর এই ভাগাভাগি কেন বড় compiler-এ এত কাজের, তা পর্ব ০৫-এ (Compiler-এর ধাপগুলো) সত্যিকারের Clang-এর আউটপুট দিয়ে দেখবেন। এখানে শুধু মানচিত্রটি মনে রাখুন। এবার পুরো কোর্সটি ধাপে ধাপে:
- ভিত্তি
M1পর্ব ১–৬ - ভাষার গঠন
M2–M5পর্ব ৭–৩২ - Type, অর্থ
M6–M7পর্ব ৩৩–৪৪ - Front end, VM
M8–M10পর্ব ৪৫–৬১ - IR, back end
M11–M12পর্ব ৬২–৭৫ - আধুনিক, প্রস্তুতি
M13–M14পর্ব ৭৬–৮৬
ইতিহাস · syntax/semantics · অনুবাদক
compiler-এর ধাপ · নকশার আপস
Haat: bazar.haat পড়তে পারা
M2 paradigm M3 নাম, scope, closure
M4 data type M5 expression, call stack
Haat: scope আর closure-এর নিয়ম কেন
M6 type system: Γ ⊢ e : τ, inference
M7 semantics: small-step, Hoare logic
Haat: typing rule আর অর্থের সংজ্ঞা
M8 lexer, parser, AST, diagnostic
M9 symbol table, type checker
M10 interpreter, bytecode, VM, JIT
Haat: bazar.haat → 996, 5000, 3
M11 three-address code, SSA, optimization
M12 register allocation, RISC-V, Wasm, GC
Haat: browser আর RISC-V-এ চলা
M13 Rust ownership, concurrency, DSL, LSP
ক্যাপস্টোন: পূর্ণ Haat compiler
M14 সমস্যা, MCQ, ভাইভা, ইন্টারভিউ
- ভিত্তি (মডিউল ১, পর্ব ০১–০৬)। ভাষার ইতিহাস, syntax আর semantics-এর পার্থক্য, compiler আর interpreter-এর ধরন, compiler-এর ধাপ আর ভাষা নকশার আপস। শেষে আপনি
bazar.haatপড়ে বলতে পারবেন কোন লাইন কী করে। - ভাষার গঠন (মডিউল ২–৫, পর্ব ০৭–৩২)। Paradigm, নাম আর scope, closure, data type, memory layout, expression-এর ক্রম, parameter passing, call stack. এখানে Haat-এর প্রতিটি নিয়মের যুক্তি পাবেন, যেমন closure কেন variable-কে reference দিয়ে ধরে।
- Type আর অর্থ (মডিউল ৬–৭, পর্ব ৩৩–৪৪)। Type system, typing rule, Hindley–Milner inference, soundness; তারপর operational, denotational আর axiomatic semantics. Haat-এর নিয়ম এখানে গণিতের ভাষায় লেখা হবে।
- Front end থেকে VM (মডিউল ৮–১০, পর্ব ৪৫–৬১)। এখান থেকে বানানো শুরু: lexer, parser, AST, ভালো error বার্তা, symbol table, type checker, tree-walking interpreter, bytecode আর stack VM. এই ভাগের শেষে Haat প্রথমবার পুরো
bazar.haatচালাবে। - IR আর back end (মডিউল ১১–১২, পর্ব ৬২–৭৫)। Three-address code, control flow graph, SSA, dataflow analysis, optimization, সত্যিকারের LLVM IR; তারপর instruction selection, register allocation, calling convention, RISC-V আর WebAssembly code, linking আর garbage collection.
- আধুনিক ভাষা আর প্রস্তুতি (মডিউল ১৩–১৪, পর্ব ৭৬–৮৬)। Rust-এর ownership, concurrency-র memory model, macro, DSL নকশা, language tooling আর ক্যাপস্টোন: Haat-এর পূর্ণ compiler. শেষ মডিউলে বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষার জন্য সমস্যা, MCQ আর ভাইভা।
| মডিউল | বিষয় | পর্ব | Haat-এর যে অংশ |
|---|---|---|---|
| ১ | ভিত্তি | ০১–০৬ | ভাষার পরিচয়, নকশার যুক্তি |
| ২ | Programming paradigm | ০৭–১৩ | imperative, first-class function |
| ৩ | নাম, binding আর scope | ১৪–১৯ | block scope, shadowing, closure |
| ৪ | Data type | ২০–২৫ | Int, Bool, Str; বর্ধিত রূপের array/record |
| ৫ | Expression, control, subprogram | ২৬–৩২ | short-circuit, call stack, recursion |
| ৬ | Type system | ৩৩–৩৯ | Haat-এর typing rule |
| ৭ | ভাষার semantics | ৪০–৪৪ | Haat-এর formal অর্থ |
| ৮ | Compiler-এর front end | ৪৫–৫০ | lexer, parser, AST, diagnostic |
| ৯ | Semantic analysis | ৫১–৫৫ | name resolution, type checker |
| ১০ | Interpreter আর VM | ৫৬–৬১ | tree-walking interpreter, bytecode VM |
| ১১ | IR আর optimization | ৬২–৬৮ | three-address code, SSA, optimization |
| ১২ | Code generation আর runtime | ৬৯–৭৫ | RISC-V, WebAssembly, GC |
| ১৩ | আধুনিক ভাষা, tool, ক্যাপস্টোন | ৭৬–৮১ | পূর্ণ Haat compiler |
| ১৪ | পরীক্ষা ও ইন্টারভিউ প্রস্তুতি | ৮২–৮৬ | সমস্যা আর প্রশ্নব্যাংক |
৪ · Haat — বাজারঘরের ছোট ভাষা
ভাষা নিয়ে পড়া আর ভাষা বানানো এক জিনিস নয়। বই পড়ে সাঁতার শেখা যায় না, তাই এই কোর্সে একটি চলমান প্রজেক্ট আছে: Haat (হাট)। বাজারঘর একটি কাল্পনিক অনলাইন দোকান। তাদের ছাড়ের নিয়ম, ডেলিভারি চার্জ আর অর্ডারের মোট দাম লেখার জন্য একটি ছোট ভাষা দরকার, যা হিসাবরক্ষকও পড়তে পারবেন। Haat সেই ভাষা। ছোট, কিন্তু খেলনা নয়: এতে function, recursion, closure, type আর স্পষ্ট error বার্তা আছে, তাই বাস্তব ভাষার প্রায় সব কঠিন প্রশ্ন এখানে ছোট আকারে ওঠে।
Haat-এর নিয়ম কোর্সের শুরুতেই স্থির করা আছে, আর প্রতিটি পর্ব হুবহু সেই নিয়ম মানে। মূল কথাগুলো:
| দিক | Haat-এর নিয়ম |
|---|---|
| Type | Int (৬৪-বিট, overflow হলে wrap), Bool, Str, Unit, আর function type যেমন (Int, Int) -> Int; নিজে থেকে কোনো type-রূপান্তর নেই |
| নাম | let বদলানো যায় না, var বদলানো যায়; type না লিখলে মান থেকে অনুমান |
| Statement | if … else, while, return, print(e);, আর { … } block, যা নতুন scope খোলে |
| Function | fn name(p: T) -> R { … }; parameter আর return type লিখতে হয়; function একটি মান, closure variable-কে reference দিয়ে ধরে |
| Operator | সবচেয়ে দুর্বল ||, তারপর &&, == !=, < <= > >=, + -, * / %, unary - !; তুলনা শিকলের মতো বসে না (a < b < c বা a == b != c syntax error) |
| Error | line:col: error: … আর চলার সময় line:col: runtime error: division by zero |
এবার কোর্সের নমুনা প্রোগ্রাম। প্রথম অংশ একটি অর্ডারের দাম হিসাব করে: দুটি জিনিস, প্রতিটি 520 টাকা; মোট হাজার টাকা বা বেশি হলে ১০% ছাড়, আর হাজারের কম হলে 60 টাকা ডেলিভারি। দ্বিতীয় অংশ একটি while loop.
// বাজারঘর: অর্ডারের মোট দাম
fn price(qty: Int, unit: Int) -> Int {
let p = qty * unit;
if p >= 1000 { return p - p / 10; }
return p;
}
fn delivery(total: Int) -> Int {
if total >= 1000 { return 0; } else { return 60; }
}
let first = price(2, 520) + delivery(price(2, 520));
print(first);
var total = 0;
var rounds = 0;
while total < 5000 { total = total + 1250; rounds = rounds + 1; }
print(total);
print(rounds - 1);আউটপুট কী হবে, আগে নিজে ভাবুন। তারপর নিচের stepper-এ প্রতিটি লাইনের পরে variable-গুলোর মান মিলিয়ে দেখুন।
1// বাজারঘর: অর্ডারের মোট দাম2fn price(qty: Int, unit: Int) -> Int {3 let p = qty * unit;4 if p >= 1000 { return p - p / 10; }5 return p;6}7fn delivery(total: Int) -> Int {8 if total >= 1000 { return 0; } else { return 60; }9}10let first = price(2, 520) + delivery(price(2, 520));11print(first);12var total = 0;13var rounds = 0;14while total < 5000 { total = total + 1250; rounds = rounds + 1; }15print(total);16print(rounds - 1);
| p | |
| first | |
| total | |
| rounds |
- লাইন ১০ থেকে
price(2, 520). Function-এর ভেতরেp = 2 * 520 = 1040. 1040 >= 1000 সত্য, তাই ফেরত আসে 1040 − 1040 / 10 = 1040 − 104 = 936.first-এ এখনো কিছু রাখা হয়নি। - এবার
delivery(936). 936 >= 1000 মিথ্যা, তাই else অংশ: 60. যোগফল 936 + 60 = 996, যাfirst-এ যায়। খেয়াল করুন,price(2, 520)দুবার ডাকা হয়েছে;pপ্রতিটি ডাকের নিজস্ব, function শেষ হলে তার আর অস্তিত্ব নেই। - লাইন ১১।
print(first)পর্দায় লেখে 996. - লাইন ১২–১৩। দুটি
var:total = 0,rounds = 0. এগুলোletনয়, তাই পরে বদলানো যাবে। - লাইন ১৪, প্রথম পাক। 0 < 5000 সত্য।
totalহয় 1250,roundsহয় 1. - দ্বিতীয় পাক। 1250 < 5000 সত্য।
total= 2500,rounds= 2. - তৃতীয় পাক। 2500 < 5000 সত্য।
total= 3750,rounds= 3. - চতুর্থ পাক। 3750 < 5000 সত্য।
total= 5000,rounds= 4. - শর্ত আবার যাচাই। 5000 < 5000 মিথ্যা, কারণ সমান মানে ছোট নয়। Loop শেষ। এখানেই অনেকে ভুল করেন:
<আর<=-এর পার্থক্যে পাকের সংখ্যা বদলায়। - লাইন ১৫। পর্দায় 5000.
- লাইন ১৬।
rounds - 1= 4 − 1 = 3. পুরো আউটপুট: 996, 5000, 3.
এই আউটপুট আমরা দুইভাবে যাচাই করেছি। প্রথমত, কোর্সের Haat reference বাস্তবায়ন দিয়ে (Python-এ লেখা, CPython 3.14.4-এ চালানো), যার দুটি আলাদা back end আছে: run চালায় tree-walking interpreter, আর vm আগে bytecode বানিয়ে stack VM-এ চালায়। সত্যিকারের run:
$ python haat.py run bazar.haat
996
5000
3
$ python haat.py vm bazar.haat
996
5000
3
দ্বিতীয়ত, একই হিসাব একটি সম্পূর্ণ আলাদা বাস্তবায়নে: C ভাষায়, একটি আসল C compiler দিয়ে। Haat-এর / ইচ্ছে করেই C-র মতো শূন্যের দিকে কাটে, তাই ফল মেলার কথা। নিচের কোড Wandbox নামের একটি অনলাইন সেবায় আসল GCC দিয়ে compile হয়ে চলে:
#include <stdio.h>
/* bazar.haat, line by line, in C (long long = 64-bit here) */
long long price(long long qty, long long unit) {
long long p = qty * unit;
if (p >= 1000) { return p - p / 10; }
return p;
}
long long delivery(long long total) {
if (total >= 1000) { return 0; } else { return 60; }
}
int main(void) {
long long first = price(2, 520) + delivery(price(2, 520));
printf("%lld\n", first);
long long total = 0, rounds = 0;
while (total < 5000) { total = total + 1250; rounds = rounds + 1; }
printf("%lld\n", total);
printf("%lld\n", rounds - 1);
return 0;
}আসল আউটপুট (সত্যিকারের run: ল্যাবে Zig 0.17.1-এর সঙ্গে আসা Clang 22.1.8, -std=c17 -Wall -Wextra -O2, কোনো warning নেই; “চালিয়ে দেখুন” চাপলে Wandbox-এর GCC-তেও একই তিন লাইন আসার কথা):
996
5000
3
সম্পূর্ণ আলাদা বাস্তবায়ন, Python-এ লেখা Haat-এর interpreter ও VM আর একটি C compiler, একই ফল দিয়েছে। একই প্রোগ্রাম দুটি স্বাধীন বাস্তবায়নে চালিয়ে মেলানোর এই কৌশলের নাম differential testing. Compiler বানানোর জগতে এটি ভুল ধরার সবচেয়ে শক্তিশালী অস্ত্রগুলোর একটি (ভাবনার প্রশ্ন ০৫)। খেয়াল করুন, C-তে long long-এর overflow হলে ফল undefined behavior, যেখানে Haat-এ overflow wrap করে; এখানে মানগুলো ছোট, তাই এই পার্থক্য ওঠেনি। দুই ভাষার নিয়ম এক নয়, এই সচেতনতাই কোর্সের প্রথম শিক্ষা।
Haat কোর্স জুড়ে বড় হবে। মডিউল ৮–১২-এ এর বাস্তবায়ন এই ক্রমে তৈরি হবে, আর প্রতিটি নতুন অংশ আগের অংশের ফল ব্যবহার করবে:
| পর্ব | যা বানাবেন | ফল |
|---|---|---|
| ৪৬ | Lexer | token, line:col, lexical error |
| ৪৭–৪৯ | Recursive descent আর Pratt parser, AST | পুরো প্রোগ্রামের গাছ |
| ৫১–৫২ | Name resolution, type checker | type mismatch, undefined variable |
| ৫৬–৫৭ | Tree-walking interpreter, closure | bazar.haat → 996, 5000, 3 |
| ৫৮–৫৯ | Bytecode compiler আর stack VM | একই ফল, দ্রুততর পথে |
| ৬২–৬৭ | Three-address code, CFG, SSA, optimization | ছোট আর দ্রুত IR |
| ৭০–৭৩ | Register allocation, RISC-V আর WebAssembly | আসল যন্ত্রে আর browser-এ চলা |
| ৭৫ | Garbage collector | মেমরি নিজে ফেরত নেওয়া |
| ৮১ | ক্যাপস্টোন | source থেকে চলমান program |
৫ · একই লাইন, অন্য পথে — bytecode আর virtual machine (পূর্বরূপ)
অংশ ২-এর interpreter গাছ বেয়ে হিসাব করেছিল। এটি সহজ, কিন্তু প্রতিবার গাছের node থেকে node-এ লাফানো ধীর। তাই বাস্তবের অনেক ভাষা, যেমন CPython আর Java-র JVM, আরেকটি পথ নেয়: গাছকে আগে ছোট ছোট সমান মাপের নির্দেশের একটি সারিতে অনুবাদ করে, যার নাম bytecode, তারপর একটি সহজ loop সেই নির্দেশ একটি একটি করে চালায়। সেই loop-টিই একটি virtual machine. আমাদের VM একটি stack machine: মানগুলো একটি স্তূপে রাখে, যেমন রেস্তোরাঁর রান্নাঘরে অর্ডার স্লিপ একটির ওপর আরেকটি গাঁথা থাকে, আর রাঁধুনি সবসময় ওপরেরটি তোলেন।
Haat reference-এর dis command একটি প্রোগ্রামের bytecode দেখায়। print(2 + 3 * 4); লাইনটির সত্যিকারের run:
$ python haat.py dis line.haat
== <main> (arity 0, locals 0) ==
0 CONST 0 ; 2
1 CONST 1 ; 3
2 CONST 2 ; 4
3 MUL
4 ADD
5 PRINT
6 CONST 3 ; ()
7 RETURN
CONST 0 মানে “ধ্রুবকের তালিকার ০ নম্বর মান (এখানে 2) stack-এ রাখা”; ;-এর পরের অংশ শুধু মন্তব্য। শেষের দুটি নির্দেশ প্রোগ্রাম শেষ করে: Unit মান () রেখে ফেরত যাওয়া।
পূর্বরূপ: এখানে শুধু ধারণাটি দেখানো হচ্ছে। Haat VM-এর পুরো instruction set (৩১টি opcode, jump, function call, closure) পর্ব ৫৮-এ (Bytecode নকশা) আর পর্ব ৫৯-এ (Stack-based virtual machine) ধাপে ধাপে বানাবেন।
0CONST 0 ; 21CONST 1 ; 32CONST 2 ; 43MUL4ADD5PRINT6CONST 3 ; ()7RETURN
| stack | |
| গভীরতা |
CONST 0. ধ্রুবক-তালিকার ০ নম্বর মান 2 stack-এ রাখা হলো। Compiler গাছটি এমন ক্রমে হেঁটেছে যে আগে সন্তান, পরে বাবা (post-order); তাই প্রথম নির্দেশ বাঁ দিকের পাতা 2.CONST 1. 3 রাখা হলো 2-এর ওপরে। Stack: [2,3].CONST 2. 4 ওপরে। Stack-এর গভীরতা এখন 3, এই প্রোগ্রামের সর্বোচ্চ।MUL. ওপরের দুটি মান তোলা হলো (3 আর 4), গুণফল 12 আবার রাখা হলো। Stack: [2,12]. গাছে*নিচে ছিল, তাই bytecode-এ সেটি আগে।ADD. 2 আর 12 তুলে 14 রাখা হলো। Stack: [14].PRINT. ওপরের মান তুলে ছাপা হলো: 14. Stack খালি।CONST 3. Unit মান()রাখা হলো, কারণ প্রতিটি function, এমনকি পুরো প্রোগ্রাম (<main>) একটি মান ফেরত দেয়।RETURN. মানটি তুলে প্রোগ্রাম শেষ। প্রথম ছয়টি নির্দেশে অংশ ২-এর গাছের প্রতিটি node ঠিক একটি করে নির্দেশ হয়েছে, আর ক্রমটি গাছের post-order.
নিচের JavaScript কোডে এই দুটি অংশই আছে: কয়েক লাইনের একটি compiler, যা AST থেকে bytecode বানায়, আর একটি VM, যা সেটি চালায় আর প্রতিটি নির্দেশের পরে stack দেখায়। এটি reference-এর compiler.py আর vm.py-র খুব ছোট রূপ, একই opcode-নাম নিয়ে। কোডটি আপনার ব্রাউজারের একটি আলাদা sandbox-এ চলে।
// AST of the Haat line print(2 + 3 * 4); (same shape the parser builds)
const num = (v) => ({ kind: "Num", value: v });
const ast = { kind: "Print", value: { kind: "Binary", op: "+", left: num(2),
right: { kind: "Binary", op: "*", left: num(3), right: num(4) } } };
// compiler: walk the tree, children first, then the node itself
const OPCODE = { "+": "ADD", "-": "SUB", "*": "MUL" };
const consts = [], code = [];
function gen(node) {
if (node.kind === "Num") { consts.push(node.value); code.push(["CONST", consts.length - 1]); }
if (node.kind === "Binary") { gen(node.left); gen(node.right); code.push([OPCODE[node.op]]); }
if (node.kind === "Print") { gen(node.value); code.push(["PRINT"]); }
}
gen(ast);
consts.push("()"); code.push(["CONST", consts.length - 1], ["RETURN"]); // end of <main>
// stack VM: one loop, one instruction at a time
const stack = [];
code.forEach(([op, arg], ip) => {
if (op === "CONST") stack.push(consts[arg]);
else if (op === "ADD" || op === "SUB" || op === "MUL") {
const b = stack.pop(), a = stack.pop();
stack.push(op === "ADD" ? a + b : op === "SUB" ? a - b : a * b);
} else if (op === "PRINT") console.log(" >> output:", stack.pop());
else if (op === "RETURN") stack.pop();
const shown = arg === undefined ? "" : `${arg} ; ${consts[arg]}`;
console.log(String(ip).padStart(4), op.padEnd(7), shown.padEnd(8), `stack: [${stack.join(",")}]`);
});আসল আউটপুট (ব্রাউজারের JavaScript):
0 CONST 0 ; 2 stack: [2]
1 CONST 1 ; 3 stack: [2,3]
2 CONST 2 ; 4 stack: [2,3,4]
3 MUL stack: [2,12]
4 ADD stack: [14]
>> output: 14
5 PRINT stack: []
6 CONST 3 ; () stack: [()]
7 RETURN stack: []
প্রতিটি লাইন stepper-এর একটি ধাপ, আর বাঁ দিকের নির্দেশগুলো reference-এর dis-এর সঙ্গে হুবহু মেলে। PRINT-এর লাইনের আগে “output: 14” এসেছে, কারণ VM আগে মানটি ছাপে, তারপর stack দেখায়। gen function-টি খেয়াল করুন: এটি গাছ হাঁটে ঠিক interpreter-এর মতো, কিন্তু হিসাব করার বদলে হিসাবের নির্দেশ লেখে। Interpreter আর compiler-এর মূল পার্থক্য এই এক বাক্যে: interpreter কাজটি করে, compiler কাজটি করার নির্দেশ লেখে।
আসল ভাষা কী করে? এই পর্বের ল্যাবে CPython 3.14.4-এর নিজের dis module দিয়ে একই লাইনের bytecode দেখা হয়েছে (সত্যিকারের run):
$ python -c "import dis; dis.dis(compile('print(2 + 3 * 4)', '<haat>', 'exec'))"
0 RESUME 0
1 LOAD_NAME 0 (print)
PUSH_NULL
LOAD_SMALL_INT 14
CALL 1
POP_TOP
LOAD_CONST 1 (None)
RETURN_VALUE
এখানে একটি চমক আছে: 2, 3, 4, গুণ বা যোগের কোনো নির্দেশ নেই, সরাসরি LOAD_SMALL_INT 14. CPython-এর compiler bytecode বানানোর আগেই দেখেছে যে সব মান ধ্রুবক, তাই হিসাবটি নিজেই করে ফেলেছে। এই optimization-এর নাম constant folding, যা পর্ব ৬৫-এ Haat-এর জন্য বানাবেন। CPython-এর bytecode-এর নাম আর রূপ version ভেদে বদলায় (যেমন LOAD_SMALL_INT নতুন version-এ এসেছে), তাই এই আউটপুট শুধু 3.14-এর জন্য সত্য। বাস্তব VM-এর বিস্তারিত পর্ব ৬০-এ (বাস্তব virtual machine).
৬ · তিনটি পড়ার পথ, পূর্বজ্ঞান আর পাতার ভেতরের tool
এই কোর্স একসঙ্গে কয়েক ধরনের পাঠকের জন্য: যে programmer জানতে চান তাঁর ভাষা ভেতরে কীভাবে চলে, যে শিক্ষার্থী Programming Languages বা Compiler Design পড়ছেন, যে প্রার্থী চাকরির লিখিত পরীক্ষা বা ইন্টারভিউর প্রস্তুতি নিচ্ছেন, আর যিনি নিজে একটি ভাষা বানাতে চান। সবার একই গভীরতা দরকার নেই। তাই তিনটি পথ:
| পথ | মডিউল | কার জন্য | শেষে যা পারবেন |
|---|---|---|---|
| শুরুর পথ | ১–৬, ৮, ১০ | যিনি ভাষার ধারণা আর একটি চলমান interpreter চান | scope, type, call stack ব্যাখ্যা; Haat-এর lexer, parser, interpreter আর VM |
| মাঝারি পথ | শুরুর পথ + ৭, ৯, ১১ | Compiler Design-এর শিক্ষার্থী, চাকরির পরীক্ষার্থী | semantics, type checker, three-address code, SSA, optimization |
| উচ্চতর পথ | সব মডিউল + প্রতিটি “আরও গভীরে” | যিনি compiler বা language tooling নিয়ে কাজ করতে চান | RISC-V আর Wasm code, GC, Rust ownership, পূর্ণ Haat compiler |
যেকোনো পথে মডিউল ১৪ (পরীক্ষা ও ইন্টারভিউ প্রস্তুতি) যোগ করতে পারেন; সেখানে প্রতিটি পথের জন্য আলাদা প্রশ্ন আছে। প্রতিটি পর্বের ভেতরেও তিন স্তর থাকে: শুরুতে উদাহরণ আর তুলনা, তারপর নিখুঁত সংজ্ঞা, নিয়ম আর algorithm, আর শেষে “আরও গভীরে” বাক্স। শুরুর পথে থাকলে “আরও গভীরে” বাদ দিলেও কিছু হারাবেন না।
যা আগে থেকে জানা ভালো। যেকোনো একটি ভাষায় function, loop আর list লিখতে পারা: Python, C বা JavaScript. কোর্সের বেশিরভাগ কোড Python-এ, কারণ এটি পড়তে সহজ। Stack, tree আর hash table-এর মৌলিক ধারণা, যা DSA কোর্সে আছে। মডিউল ৮ থেকে regular expression আর grammar-এর তত্ত্ব কাজে লাগবে, যা গণনার তত্ত্ব কোর্সে বিস্তারিত আছে; যেমন Pratt parsing-এর তাত্ত্বিক ভিত্তি তার পর্ব ৪২-এ। এই কোর্স সেই তত্ত্ব আবার প্রমাণ করবে না, বরং তা দিয়ে যন্ত্র বানাবে।
পাতার ভেতরের tool. প্রতিটি পর্বে চার রকম কোড দেখবেন। লেবেল দেখে চিনুন কোনটি কোথায় চলে:
| লেবেল | কোথায় চলে | কী কাজে |
|---|---|---|
| Python (চালিয়ে দেখুন) | আপনার ব্রাউজারে, Pyodide: WebAssembly-তে compile করা CPython | Haat-এর lexer, parser, checker, VM; প্রথমবার চালাতে কয়েক সেকেন্ড লাগে |
| JavaScript (চালিয়ে দেখুন) | আপনার ব্রাউজারের একটি sandbox-এ | JS-এর নিজস্ব আচরণ, ছোট visualiser, আর আসল WebAssembly module |
| C, C++, Java (চালিয়ে দেখুন) | Wandbox নামের অনলাইন সেবায় আসল compiler | ভাষার আচরণ তুলনা; শুধু আউটপুট দেখা যায়, নিজের flag দেওয়া যায় না |
| সত্যিকারের run | লেখকের ল্যাবে আসল tool (Clang, CPython dis, LLVM) | assembly, LLVM IR, bytecode; version সহ লেখা থাকে |
আর দুটি লেবেল আছে যা কম দেখবেন। “উদাহরণ, চালানো হয়নি” মানে কোডটি দেখানোর জন্য, যেমন Haskell বা Prolog-এর এমন কোড যা পাতায় চালানোর ব্যবস্থা নেই। “নমুনা আউটপুট” মানে আউটপুটটি হাতে লেখা ধারণা, সত্যিকারের run নয়। কোনো আউটপুটে এই লেবেল না থাকলে সেটি আসল run থেকে নেওয়া।
মডিউল ৬-এ Haat-এর type নিয়ম এভাবে লেখা হবে। দাগের ওপরে শর্ত, নিচে সিদ্ধান্ত: “যদি Γ পরিবেশে e1-এর type Int হয় আর e2-এর type Int হয়, তাহলে e1 + e2-এর type Int.” এখানে Γ (গামা) হলো নাম থেকে type-এর তালিকা, যেমন qty : Int, unit : Int; আর ⊢ চিহ্ন পড়ুন “থেকে প্রমাণ হয়”।
| Γ ⊢ e1 : Int Γ ⊢ e2 : Int | (T-Add) |
| Γ ⊢ e1 + e2 : Int |
(Haat-এ + দুটি Str-কেও জোড়ে, তাই পূর্ণ নিয়মে আরেকটি সারি লাগবে; সেটি পর্ব ৩৪-এ।)
আরও গভীরে: “ছোট ভাষা বানিয়ে ভাষা শেখা” পদ্ধতির দীর্ঘ ঐতিহ্য আছে। Niklaus Wirth শিক্ষার জন্য PL/0-এর মতো ছোট ভাষা আর তার পূর্ণ compiler বই আকারে প্রকাশ করেছিলেন; MIT-এর বিখ্যাত বই Structure and Interpretation of Computer Programs Scheme-এ একটি interpreter লিখিয়ে ভাষার অর্থ শেখায়; আর আধুনিক কালে Robert Nystrom-এর Crafting Interpreters একটি ভাষার tree-walking interpreter আর bytecode VM দুটোই বানায়। Haat-এর পথও এই ধারার: তবে এখানে typed ভাষা, SSA, register allocation আর RISC-V ও WebAssembly পর্যন্ত যাওয়া হবে।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই বিষয়ে এমন প্রশ্ন প্রায়ই আসে:
- Compiler-এর ধাপগুলো কী কী? Lexical analysis → syntax analysis → semantic analysis → IR generation → optimization → code generation; সঙ্গে symbol table আর error handling সব ধাপে।
- Compiler আর interpreter-এর পার্থক্য? Compiler আগে পুরো অনুবাদ করে নির্দেশ লেখে; interpreter চলার সময় কাজটি নিজে করে। একটি ভাষার দুই ধরনের বাস্তবায়নই থাকতে পারে।
2 + 3 * 4-এর AST আঁকুন। মূলে+, বাঁয়ে 2, ডানে*যার সন্তান 3 আর 4; ফল 14.- Token আর lexeme-এর পার্থক্য? Token একটি শ্রেণি (NUM), lexeme তার আসল লেখা (520).
- “একটি calculator বা ছোট interpreter লিখুন।” Lexer, precedence-সহ parser (Pratt বা recursive descent), আর গাছ-হাঁটা eval; অংশ ২-এর কোড ঠিক এই কাঠামো।
৭ · AI-এর যুগে ভাষা আর compiler শেখা
AI assistant এক মিনিটে একটি calculator-এর parser লিখে দিতে পারে, আর একটি ভাষার নিয়ম গুছিয়ে বলতে পারে। তাহলে এসব শেখার দরকার কী? কারণ এই বিষয়ে AI-এর ভুল খুব বিশ্বাসযোগ্য শোনায়, আর ভুলগুলো প্রায়ই ঠিক সেই জায়গায় যেখানে নিয়ম সূক্ষ্ম। যিনি নিয়মটি জানেন, শুধু তিনিই ভুলটি ধরতে পারেন। এই বিষয়ে বারবার দেখা ভুলগুলো:
| AI-এর ভুল | উদাহরণ | কীভাবে ধরবেন |
|---|---|---|
| এক ভাষার নিয়ম সব ভাষায় চাপানো | “integer ভাগ সবসময় নিচের দিকে কাটে” (Python-এ সত্য, C আর Haat-এ নয়) | প্রতিটি ভাষার আসল interpreter বা compiler-এ -7 / 2 চালানো |
| Precedence বা associativity ভুল | Parser-এ 10 - 4 - 3 = 9 | সমান-শক্তির operator পাশাপাশি রেখে test লেখা |
| Undefined behavior-এর ফল নিশ্চিত বলা | “C-তে signed overflow হলে মান ঘুরে যায়” | C standard দেখা; ফল compiler আর flag-ভেদে বদলাতে পারে |
| না-থাকা compiler flag বা pass বানানো | এমন একটি -f… option যা GCC-তে নেই | Compiler-এর নিজের documentation আর --help |
| Bytecode বা assembly “অনুমান” করে লেখা | CPython 3.14-এ BINARY_ADD দেখানো | dis, -S, javap -c দিয়ে আসল আউটপুট দেখা |
| “Optimize” করতে গিয়ে অর্থ বদলানো | x / 2-কে x >> 1 বানানো; ঋণাত্মক x-এ ফল মেলে না (−7 / 2 = −3, কিন্তু ডানে সরালে সাধারণত −4) | দুই রূপ একই input-এ চালিয়ে মেলানো |
এই কোর্সে AI-কে শিক্ষকের সহকারী হিসেবে ব্যবহার করুন, শেষ কথা হিসেবে নয়। প্রশ্নে ভাষা আর version বলে দিন, আর উত্তরের সঙ্গে যাচাইয়ের উপায় চেয়ে নিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১“Python ধীর, C দ্রুত”: এটি কি ভাষার গুণ, না ভাষার বাস্তবায়নের?
প্রশ্নটির মধ্যেই একটি গুরুত্বপূর্ণ ভুল লুকিয়ে আছে। একটি ভাষা হলো নিয়মের সংজ্ঞা: কোন লেখা বৈধ, আর তার অর্থ কী। গতি হলো একটি নির্দিষ্ট বাস্তবায়নের গুণ। Python ভাষার প্রধান বাস্তবায়ন CPython কোডকে bytecode-এ অনুবাদ করে, আর একটি C-তে লেখা loop সেই bytecode একটি একটি করে চালায়। একই ভাষার আরেক বাস্তবায়ন PyPy চলার সময় বারবার চলা অংশকে machine code-এ বদলায় (JIT), আর অনেক loop-ভারী প্রোগ্রামে CPython-এর চেয়ে অনেক দ্রুত চলে। আবার CPython নিজেও 3.13 থেকে একটি পরীক্ষামূলক JIT যোগ করেছে, যা ডিফল্টে বন্ধ। তাহলে “Python ধীর” কথাটি আসলে “CPython-এর সাধারণ পথ ধীর”।
তবে ভাষার নকশাও গতির সীমা ঠিক করে। Python-এ a + b লিখলে চলার সময় দেখতে হয় a আর b কোন type-এর, কারণ ভাষাটি dynamic typing-এর; একটি সংখ্যাও heap-এ রাখা একটি object. C-তে compiler আগেই জানে দুটি int, তাই একটি মাত্র যন্ত্র-নির্দেশ লেখে। অর্থাৎ কিছু খরচ ভাষার নিয়ম থেকেই আসে, আর ভালো বাস্তবায়ন (JIT, type-এর অনুমান) সেই খরচের অনেকটা, কিন্তু সবটা নয়, কমাতে পারে। এই কারণেই NumPy-র মতো library ভারী হিসাব C-তে লিখে রাখে আর Python থেকে শুধু ডাকে: ভাষা একই থাকে, কিন্তু ভেতরের লম্বা loop আর CPython-এর VM-এ চলে না।
এই কোর্সে আপনি নিজেই এই পার্থক্য মাপবেন: একই Haat প্রোগ্রাম tree-walking interpreter, bytecode VM আর RISC-V code-এ চলবে, ভাষা একই থাকবে, শুধু বাস্তবায়ন বদলাবে। পরীক্ষায় “interpreted language” বা “compiled language” কথাটি দেখলে সতর্ক থাকুন: Java-কে প্রায়ই “interpreted” বলা হয়, অথচ আধুনিক JVM-এ ঘন ঘন চলা কোড JIT হয়ে machine code-এ চলে।
মূল উপলব্ধি: ভাষা আর বাস্তবায়ন আলাদা জিনিস। গতির প্রশ্নে আগে জিজ্ঞেস করুন “কোন বাস্তবায়ন, কোন version, কোন ধরনের কোড?”, আর দাবিটি সত্যিকারের মাপ দিয়ে যাচাই করুন।
প্র ০২প্রথম দিকের compiler-কে কেন মানুষ সন্দেহের চোখে দেখত, আর FORTRAN-এর দল সেই সন্দেহ কীভাবে কাটাল?
১৯৫০-এর দশকে কম্পিউটার ছিল অত্যন্ত দামি আর ধীর, আর প্রোগ্রামাররা machine code বা assembly-তে হাতে কোড লিখতেন। প্রতিটি নির্দেশ, প্রতিটি মেমরির ঘর তাঁরা নিজে বেছে নিতেন। “একটি প্রোগ্রাম আমার হয়ে কোড লিখবে” ধারণাটিকে অনেকে অবাস্তব ভাবতেন, আর যাঁরা মানতেন, তাঁরাও ভয় পেতেন যে যন্ত্রের লেখা কোড এত ধীর হবে যে দামি যন্ত্রের সময় নষ্ট হবে।
John Backus-এর নেতৃত্বে IBM-এর দল ১৯৫৪ সাল থেকে FORTRAN (FORmula TRANslation) নিয়ে কাজ করে, আর ১৯৫৭ সালে IBM 704-এর জন্য প্রথম compiler প্রকাশ করে। Backus পরে লিখেছেন, দলের মূল চিন্তা ছিল ভাষার নকশা নয়, বরং compiler-এর বানানো কোডের গতি: হাতে লেখা কোডের কাছাকাছি না হলে কেউ এটি ব্যবহার করবে না। তাই সেই প্রথম compiler-এই loop আর array-র হিসাব নিয়ে উল্লেখযোগ্য optimization ছিল। ফল দেখে অনেক প্রোগ্রামার মেনে নেন যে উচ্চ-স্তরের ভাষায় লেখা যায়, আর লেখার সময় বহুগুণ কমে।
এই ইতিহাস থেকে দুটি কথা আজও প্রাসঙ্গিক। প্রথমত, একটি নতুন ভাষা বা tool তখনই গৃহীত হয় যখন তার খরচ (ধীরতা, শেখার কষ্ট) লাভের চেয়ে কম মনে হয়; Rust বা WebAssembly-র গল্পেও একই প্রশ্ন উঠেছে। দ্বিতীয়ত, optimization compiler-এর গৌণ অংশ নয়, অনেক সময় অস্তিত্বের কারণ। সঠিক তারিখ আর কৃতিত্ব নিয়ে উৎসভেদে সামান্য পার্থক্য আছে; বিস্তারিত ইতিহাস পর্ব ০২-এ।
মূল উপলব্ধি: Compiler-কে আস্থা অর্জন করতে হয়েছে দুটি জিনিস দিয়ে: সঠিকতা (অর্থ বদলাবে না) আর গতি (হাতে লেখার কাছাকাছি)। এই কোর্সের মডিউল ১১–১২ ঠিক এই দুই দাবির পেছনের কৌশল শেখায়।
প্র ০৩নিজের একটি ছোট ভাষা (DSL) বানানো কখন বুদ্ধিমানের কাজ, আর কখন বিপদের?
চারপাশে তাকালেই ছোট ভাষা দেখবেন। SQL ডেটা খোঁজার ভাষা, regular expression লেখা মেলানোর, CSS পাতা সাজানোর, Makefile build-এর নিয়মের, আর spreadsheet-এর সূত্র হিসাবের। এগুলো সবই domain-specific language: একটি নির্দিষ্ট কাজের জন্য বানানো, সেই কাজের লোকের চেনা শব্দে। বাজারঘরের Haat-ও তাই: হিসাবরক্ষক if total >= 1000 { return 0; } পড়ে নিয়মটি বুঝতে পারেন, Python-এর পুরো জগৎ না শিখেও।
লাভগুলো স্পষ্ট। নিয়ম কোড থেকে আলাদা হয়, তাই ব্যবসার লোক নিজেই নিয়ম বদলাতে পারেন। ভাষাটি ছোট বলে নিরাপদ করা সহজ: Haat-এ ফাইল মোছা বা network-এ যাওয়ার কোনো উপায়ই নেই। আর ভাষার নিজের type checker ভুল নিয়ম চালানোর আগেই ধরে।
বিপদও আছে। প্রথমত, প্রতিটি ভাষা বড় হতে চায়: আজ শুধু হিসাব, কাল loop, পরশু function. Philip Greenspun-এর নামে প্রচলিত একটি ঠাট্টা আছে, যেকোনো যথেষ্ট জটিল C বা Fortran প্রোগ্রামের ভেতরে Common Lisp-এর অর্ধেকের একটি অগোছালো, ধীর আর ভুলে-ভরা বাস্তবায়ন থাকে। দ্বিতীয়ত, নিজের ভাষার জন্য editor support, debugger, documentation সব নিজেকে বানাতে হয়। তৃতীয়ত, ভালো error বার্তা না থাকলে ব্যবহারকারী হতাশ হন। এজন্য অনেকে “internal DSL” বেছে নেন: একটি বড় ভাষার ভেতরেই function আর object দিয়ে ছোট ভাষার মতো লেখার ব্যবস্থা, যাতে parser বানাতে না হয়। পর্ব ৭৯-এ দুই ধরনের তুলনা দেখবেন। Haat-এর নকশাতেও এই শৃঙ্খলা আছে: array বা record-এর মতো সুবিধা মূল নিয়মে নেই; যে পর্বে দরকার, শুধু সেখানেই সেগুলো “Haat-এর বর্ধিত রূপ” হিসেবে আসবে, যাতে মূল ভাষাটি ছোট আর যাচাই করার মতো থাকে।
মূল উপলব্ধি: ছোট ভাষা বানানো তখনই ঠিক, যখন নির্দিষ্ট মানুষের নির্দিষ্ট সমস্যা এতে সত্যিই সরল হয়, আর আপনি ভাষাটির পরিধি ছোট রাখার শৃঙ্খলা মানতে পারেন। আর বানাতে হলে, এই কোর্সের lexer-parser-checker-ই তার হাতিয়ার।
প্র ০৪Interpreter বানানো সহজ হলে বাস্তবের ভাষাগুলো compiler, bytecode আর JIT-এর এত জটিল ব্যবস্থা কেন বানায়?
অংশ ২-এর tree-walking interpreter মাত্র কয়েক লাইনের, আর সঠিকও। কিন্তু প্রতিটি হিসাবের জন্য এটি গাছের node-এ যায়, node-এর ধরন যাচাই করে, সন্তানদের জন্য নিজেকে আবার ডাকে। একটি loop দশ লাখ বার চললে এই বাড়তি কাজও দশ লাখ বার হয়। Bytecode VM সেই গাছকে একবারে একটি সমতল নির্দেশ-সারিতে বদলে নেয়; তারপর VM-এর loop প্রতিটি নির্দেশে খুব কম কাজ করে, আর মেমরিতে নির্দেশগুলো পাশাপাশি থাকে বলে CPU-র cache-ও ভালো কাজ করে। CPython, Lua আর JVM এই পথে চলে।
তারপরও VM প্রতিটি নির্দেশ “পড়ে, বোঝে, করে”। JIT compiler চলার সময় লক্ষ করে কোন অংশ বারবার চলছে, আর সেই অংশকে আসল machine code-এ বদলে দেয়। এর সুবিধা হলো, চলার সময়ের তথ্য (যেমন এই variable এতক্ষণ সবসময় একটি পূর্ণসংখ্যাই ছিল) কাজে লাগানো যায়, যা ahead-of-time compiler জানে না। অসুবিধা: শুরুতে সময় লাগে (warm-up), মেমরি বেশি লাগে, আর ভুল অনুমান হলে আবার VM-এ ফিরে যাওয়ার (deoptimization) জটিল ব্যবস্থা লাগে। ব্রাউজারের JavaScript ইঞ্জিনগুলোতে সাধারণত কয়েক স্তরের এমন ব্যবস্থা থাকে, যদিও প্রতিটি ইঞ্জিনের খুঁটিনাটি আলাদা আর সময়ের সঙ্গে বদলায়।
আর ahead-of-time compiler (C, Rust, Go) চলার আগেই পুরো অনুবাদ সেরে রাখে: শুরুতেই পূর্ণ গতি, কিন্তু প্রতিটি যন্ত্রের জন্য আলাদা build, আর চলার সময়ের তথ্য ব্যবহারের সুযোগ কম। কোনটি “সেরা”, তা নির্ভর করে প্রোগ্রাম কতক্ষণ চলবে, কোথায় চলবে আর কত দ্রুত শুরু হতে হবে তার ওপর। পর্ব ০৪ (অনুবাদক) আর মডিউল ১০-এ এই আপসগুলো বিস্তারিত।
মূল উপলব্ধি: জটিলতা আসে গতির চাহিদা থেকে। সরল interpreter সঠিকতার মাপকাঠি হিসেবেও কাজে লাগে: দ্রুত বাস্তবায়নের ফল সবসময় সরলটির সঙ্গে মিলিয়ে দেখা হয়।
প্র ০৫Compiler নিজেও কি ভুল করে? ভুল করলে সেটি ধরা হয় কীভাবে?
হ্যাঁ, করে। GCC আর LLVM কয়েক কোটি লাইনের সফটওয়্যার, আর তাদের bug-tracker-এ প্রতি বছর অনেক “wrong code” bug ধরা পড়ে, অর্থাৎ compiler এমন machine code বানিয়েছে যার অর্থ উৎস-কোডের অর্থ থেকে আলাদা। এগুলো বিশেষ বিপজ্জনক, কারণ প্রোগ্রামার নিজের কোডে কোনো ভুল খুঁজে পান না।
এমন ভুল ধরার একটি বিখ্যাত পদ্ধতি এসেছে Utah বিশ্ববিদ্যালয়ের Csmith প্রজেক্ট থেকে (Yang, Chen, Eide আর Regehr, PLDI ২০১১)। Csmith এলোমেলোভাবে বৈধ C প্রোগ্রাম বানায়, যেগুলোতে undefined behavior নেই, তারপর একই প্রোগ্রাম কয়েকটি compiler আর কয়েকটি optimization স্তরে চালিয়ে আউটপুট মেলায়। মিল না হলে কোথাও একটি compiler ভুল করেছে। এভাবে তাঁরা GCC আর LLVM-এ কয়েকশো আগে-অজানা bug খুঁজে পান। এটি ঠিক সেই differential testing, যা অংশ ৪-এ Haat interpreter আর C-র মধ্যে ছোট আকারে করেছেন।
আরেকটি পথ হলো প্রমাণ। Xavier Leroy-র নেতৃত্বে তৈরি CompCert একটি C compiler, যার মূল অংশের সঠিকতা Coq proof assistant-এ যন্ত্র-যাচাই করা প্রমাণ দিয়ে দেখানো: উৎস-প্রোগ্রামের অর্থ আর তৈরি assembly-র অর্থ এক। Csmith-এর গবেষকেরা জানিয়েছিলেন, CompCert-এর প্রমাণিত অংশে তাঁরা wrong-code bug পাননি, যদিও প্রমাণের বাইরের অংশে কিছু সমস্যা পেয়েছিলেন। পর্ব ৪৪-এ verified compiler নিয়ে আরও দেখবেন। Haat-এর reference বাস্তবায়নেও প্রথম কৌশলটি আছে: এর test প্রতিটি উদাহরণে interpreter আর VM-এর আউটপুট মেলায়, আর ৪০০টি এলোমেলো expression-এর ফল একটি আলাদা, স্বাধীনভাবে লেখা হিসাবের সঙ্গে মিলিয়ে দেখে।
দৈনন্দিন কাজে শিক্ষা হলো: অদ্ভুত আচরণ দেখলে আগে নিজের কোডে undefined behavior খুঁজুন (সেটিই বেশি সম্ভাব্য), তারপর optimization বন্ধ করে, অন্য compiler-এ চালিয়ে তুলনা করুন।
মূল উপলব্ধি: Compiler-এর ওপর আস্থা অন্ধ বিশ্বাস নয়; এটি আসে পরীক্ষা (differential testing, fuzzing) আর প্রমাণ (verified compiler) থেকে। Haat বানানোর সময় আপনিও দুটিই ব্যবহার করবেন।
অনুশীলন
প্রথমটিতে কোড লিখবেন, বাকিগুলোতে ভুল খোঁজা আর হাতে হিসাব।
-
Variable যোগ করুন (বাস্তবায়ন): অংশ ২-এর
haat_expr.pyশুধু সংখ্যা চেনে। এমন পরিবর্তন করুন যাতেqty * unit - qty * unit / 10হিসাব করা যায়, যেখানে নামের মান একটি dict থেকে আসে:{"qty": 2, "unit": 520}। কোন কোন জায়গায় বদল লাগবে, আর নামটি dict-এ না থাকলে কী হওয়া উচিত?তিন জায়গায় বদল লাগে। (১) একটি নতুন AST node:
Var = namedtuple("Var", "name"). (২)parse-এর শুরুর অংশে একটি নতুন শাখা:elif t.kind == "IDENT": left = Var(t.text); lexer আগেই নামকেIDENTহিসেবে চেনে। (৩)ev-কে একটি পরিবেশ দিতে হবে:def ev(e, env), প্রথম লাইনেif isinstance(e, Var): return env[e.name], আর প্রতিটি নিজেকে-ডাকায়envপাঠাতে হবে, যেমনev(e.left, env).ল্যাবে চালানো ফল:
qty * unit= 1040,qty * unit - qty * unit / 10= 936, আরqty * unit >= 1000= True (Python-এর রূপে; Haat-এরprintলিখতtrue). নাম না থাকলে PythonKeyError: 'totl'দেয়; Haat-এ এটি চালানোর আগেই, name resolution ধাপে ধরা পড়ে (পর্ব ৫১): reference-এরcheckদুই লাইনের একটি প্রোগ্রামে বলেছে2:7: error: undefined variable 'totl'. এই ছোট পরিবর্তনেই আপনি একটি environment-ভিত্তিক interpreter-এর বীজ বুনলেন। -
ভুলটি খুঁজুন (parser): একজন AI assistant অংশ ২-এর parser-এর একটি লাইন এভাবে লিখেছে:
right, i = parse(toks, i + 1, LBP[op.kind])(অর্থাৎ+ 1বাদ).2 + 3 * 4-এ ফল ঠিক 14 আসে। তাহলে ভুলটা কোথায়? এমন দুটি input দিন যাতে ভুল ধরা পড়ে, আর কারণ ব্যাখ্যা করুন।+ 1বাদ দিলে ডান দিকের অংশ পড়ার সীমা হয় operator-এর নিজের lbp, ফলে সমান শক্তির পরের operator-ও (যেমন দ্বিতীয়-) ডানের অংশে ঢুকে পড়ে। অর্থাৎ operator-গুলো ডান দিক থেকে জোড়া বাঁধে (right-associative), যা Haat-এর নিয়মের উল্টো।+আর*আলাদা শক্তির, তাই2 + 3 * 4-এ ভুল ধরা পড়ে না।ল্যাবে ভুল parser চালানোর আসল ফল:
10 - 4 - 3= 9 (গাছ: 10 − (4 − 3)), সঠিক 3; আর100 / 10 / 2= 20 (গাছ: 100 / (10 / 2)), সঠিক 5. শিক্ষা: precedence-এর test-এ সবসময় একই operator পরপর দুবার রাখুন; শুধু মিশ্র operator-এর test associativity-র ভুল ধরে না। -
আউটপুট অনুমান করুন:
bazar.haat-এ দুটি বদল করা হলো: লাইন ১০ হলোlet first = price(3, 400) + delivery(price(3, 400));, আর লাইন ১৪-এ 1250-এর জায়গায় 1500. প্রোগ্রাম কী তিনটি লাইন ছাপবে? প্রতিটি ধাপ দেখান।price(3, 400): p = 1200; 1200 >= 1000, তাই 1200 − 120 = 1080.delivery(1080): 1080 >= 1000, তাই 0.first= 1080. Loop: total 1500 (rounds 1), 3000 (2), 4500 (3), 6000 (4); 6000 < 5000 মিথ্যা, থামে। ছাপে 6000, তারপর 4 − 1 = 3.Reference-এর
run-এ আসল run:1080,6000,3. খেয়াল করুন, total ঠিক 5000-এ থামেনি; loop থামে প্রথম যে মান শর্ত ভাঙে সেখানে। -
Bytecode লিখুন আর stack মাপুন: অংশ ৫-এর নির্দেশ (
CONST,ADD,MUL,PRINT,RETURN) দিয়েprint((2 + 3) * 4);-এর bytecode লিখুন, প্রতিটি নির্দেশের পরে stack দেখান, আর সর্বোচ্চ গভীরতাprint(2 + 3 * 4);-এর সঙ্গে তুলনা করুন।গাছের মূলে এখন
*, বাঁয়ে+(2, 3), ডানে 4. Post-order হাঁটলে:CONST 0(2) → [2],CONST 1(3) → [2,3],ADD→ [5],CONST 2(4) → [5,4],MUL→ [20],PRINT→ [] (ছাপে 20), তারপরCONST 3(()) আরRETURN. Reference-এরdisএই লাইনে হুবহু এই আটটি নির্দেশ দিয়েছে, আর অংশ ৫-এর JS কোডে AST বদলে চালালে stack-এর মানও এই ক্রমে আসে।সর্বোচ্চ গভীরতা এখানে 2 (শেষের
()একাই থাকে), আর2 + 3 * 4-এ ছিল 3. কারণ: আগের গাছে ডান দিক গভীর, তাই 2 অপেক্ষায় থাকতে থাকতে 3 আর 4 জমে। একটি expression-এর জন্য কত stack লাগবে তা গাছের আকার থেকেই হিসাব করা যায়; register-এর সংখ্যা গোনার একটি পুরোনো কৌশল (Sethi–Ullman numbering) এই ধারণার ওপর দাঁড়িয়ে, যা মডিউল ১২-এর register allocation-এর সঙ্গে যুক্ত।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি compiler-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- ✍️ Source code: অক্ষরের সারি
- 🔤 Lexical analysis: token-এর সারি
- 🧭 Syntax analysis: AST
- 🔎 Semantic analysis: নাম আর type যাচাই
- ⚡ IR আর optimization
- 🖥️ Code generation: যন্ত্রের নির্দেশ
Haat ভাষার price(2, 520) >= 1000 লেখাটি lexer কয়টি token-এ ভাঙবে (শেষের EOF বাদে)?
- ৫টি
- ৮টি
- ৯টি
- ২১টি, প্রতিটি অক্ষর একটি
Haat-এ 2 + 3 * 4-এর AST-এর মূলে (root) কোন node থাকে?
- Num 2
- Binary *
- Binary +
- একটি Precedence node
Haat-এর নিয়মে (/ শূন্যের দিকে কাটে, %-এর চিহ্ন ভাজ্যের মতো) -7 / 2 আর -7 % 2-এর মান কী?
- −3 আর −1
- −4 আর 1
- −3.5 আর 1
- 3 আর 1
একটি stack VM পরপর এই কাজগুলো করে: 2, 3 আর 4-কে একে একে stack-এ তোলা, তারপর MUL, ADD, PRINT (MUL আর ADD ওপরের দুটি মান নামিয়ে ফল তোলে; PRINT একটি মান নামায়)। চলার সময় stack-এ একসঙ্গে সর্বোচ্চ কয়টি মান থাকে?
- ১
- ২
- ৩
- ৬
“Python একটি interpreted language আর C একটি compiled language”: এই কথা সম্পর্কে কোনটি সবচেয়ে সঠিক?
- কথাটি পুরোপুরি সঠিক, ভাষার সংজ্ঞাতেই এটি লেখা
- Python আসলে C-র মতো machine code-এ compile হয়
- Interpreted ভাষা সবসময় compiled ভাষার চেয়ে ধীর, তাই পার্থক্যটা গতিতে
- Compiled বা interpreted হওয়া বাস্তবায়নের গুণ; একই ভাষার দুই ধরনের বাস্তবায়নই থাকতে পারে
CPython 3.14-এ dis দিয়ে print(2 + 3 * 4)-এর bytecode দেখলে যোগ বা গুণের কোনো নির্দেশ নেই, আছে LOAD_SMALL_INT 14. কারণ কী?
- dis ছোট নির্দেশগুলো লুকিয়ে রাখে
- Compiler চালানোর আগেই হিসাবটি করে ফেলেছে (constant folding)
- Interpreter চলার সময় হিসাব করে bytecode বদলে দেয়
- Python-এ + আর *-এর precedence নেই
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন, অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- আপনার প্রতিটি লাইন একটি অনুবাদকের (compiler বা interpreter) হাত ঘুরে চলে; ভাষা আর তার বাস্তবায়ন আলাদা জিনিস।
- মূল পথ: lexer → parser → AST → semantic analysis, তারপর হয় interpreter/VM, নয়তো IR → optimization → code generation.
- Precedence আর associativity ঠিক করে গাছের আকার; গাছের আকারই ঠিক করে কোন হিসাব আগে।
- Haat কোর্সের চলমান প্রজেক্ট;
bazar.haatছাপে 996, 5000, 3, আর প্রতিটি নতুন যন্ত্রে একই ফল আসতে হবে। - তিনটি পথ বেছে নিন (শুরু, মাঝারি, উচ্চতর); প্রতিটি দাবি আসল run দিয়ে যাচাই করুন, AI-এর উত্তরও।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ০২ · প্রোগ্রামিং ভাষার ইতিহাস আর পরিবার — FORTRAN থেকে Rustপরবর্তী পর্বভাষার প্রজন্ম, পরিবার আর এক ভাষা থেকে আরেক ভাষায় যাওয়া ধারণা।
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের রোডম্যাপ, মডিউল ধরে।
- গণনার তত্ত্বতত্ত্বের ভিত্তিRegular expression, automata, grammar আর parsing-এর তত্ত্ব, যা এই কোর্সের front end-এর ভিত্তি।
- C প্রোগ্রামিং · পর্ব ০৩ · টুলচেইনপাশের ট্র্যাকPreprocessor, compiler, assembler আর linker: একটি বাস্তব toolchain ব্যবহারকারীর চোখে।
- Computer Architecture & Digital Logicপাশের ট্র্যাকRISC-V আর machine code: Haat-এর back end যে যন্ত্রের জন্য code বানাবে।