সরাসরি পর্বে যান
পর্ব ০১ · ৮৬-এর মধ্যে · মডিউল ১

প্রোগ্রামিং ভাষা আর কম্পাইলারের মানচিত্র — কোর্সে কী, কেন আর কীভাবে

A Map of Programming Languages and Compilers — What the Course Covers, Why It Matters and How to Use It

Taught in Bangla, this lesson explains why understanding languages and compilers helps with debugging, speed and safety, then follows one Haat line, print(2 + 3 * 4);, through ten tokens, an AST and a tree-walking interpreter to 14, and previews the same line as stack-VM bytecode in JavaScript. In-page Python (Pyodide) runs a Haat lexer and expression evaluator, a C version of the bazar program runs from the page, and steppers map the 14 course modules and three reader paths.

এই পর্বে যা শিখবেন

  • প্রোগ্রামিং ভাষা আর 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 পর্যন্ত পৌঁছাতে তিনটি বড় ধাপ লাগে। নিচের ডায়াগ্রামে “পরে” চেপে প্রতিটি ধাপে ভেতরের জিনিস কীভাবে বদলায়, তা দেখুন।

  1. Source17 অক্ষরমানুষের লেখা
  2. Lexertokenশব্দে ভাঙা
  3. Parserprecedenceকে কার সঙ্গে
  4. ASTগাছগঠন
  5. Interpreterevalহিসাব
  6. Output14ফল
Sourceঅনুবাদকের কাছে শুধু অক্ষর
p r i n t ( 2 ␣ + ␣ 3 ␣ * ␣ 4 ) ;
১৭টি অক্ষর; ␣ = ফাঁকা ঘর
Tokenline:col kind text
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
Parserbinding power-এর সিদ্ধান্ত
2   '+' lbp 50 ≥ 0  → '+' 2-কে নেয়
3   '*' lbp 60 ≥ 51 → '*' 3-কে নেয়
4   ')' operator নয় → থামা
ফল: 2 + (3 * 4)
ASTবন্ধনী আর ; নেই, শুধু গঠন
Print
└─ Binary +
   ├─ Num 2
   └─ Binary *
      ├─ Num 3
      └─ Num 4
(print (+ 2 (* 3 4)))
Interpreterনিচ থেকে ওপরে হিসাব
Binary *  : 3 * 4  = 12
Binary +  : 2 + 12 = 14
Print     : 14 ছাপা
Terminalফল
$ python haat.py run line.haat
14
  1. ধাপ ১ — শুধু অক্ষর। অনুবাদকের হাতে আসে ১৭টি অক্ষর। “print” যে একটি শব্দ, বা 2 আর 3 যে সংখ্যা, এখনো কেউ জানে না। ঠিক যেন হাতে লেখা একটি বাজারের ফর্দ, যা এখনো কেউ পড়েনি।
  2. ধাপ ২ — Lexer: শব্দে ভাঙা। Lexer অক্ষর পড়ে ছোট অর্থপূর্ণ টুকরো বানায়, যার প্রতিটি একটি token: keyword PRINT, পূর্ণসংখ্যা INT, চিহ্ন PLUS. ফাঁকা ঘর ফেলে দেওয়া হয়। প্রতিটি token-এর সঙ্গে থাকে তার অবস্থান (line:col), যাতে পরে error বার্তায় ঠিক জায়গা বলা যায়। মোট ১০টি token, শেষেরটি EOF (লেখা শেষ); লাইনের শেষে newline আছে বলে EOF-এর অবস্থান 2:1.
  3. ধাপ ৩ — Parser: কে কার সঙ্গে বাঁধা। Parser ঠিক করে, 3 কি +-এর সঙ্গে যাবে না *-এর সঙ্গে। এখানে প্রতিটি operator-এর একটি বাঁ দিকের “binding power” (lbp) আছে: + 50, * 60. +-এর ডান অংশ পড়া হয় সীমা 51 নিয়ে। 3-এর পরে * এসেছে, যার lbp 60 ≥ 51, তাই 3 যায় *-এর সঙ্গে। এই নিয়মই operator precedence.
  4. ধাপ ৪ — AST: গঠনের গাছ। Parser-এর ফল একটি abstract syntax tree. বন্ধনী আর ; নেই, কারণ গাছের আকারই এখন বলে কোনটি আগে হবে: * নিচে, তাই আগে। বাকি সব ধাপ এই গাছ নিয়েই কাজ করে।
  5. ধাপ ৫ — Interpreter: গাছ বেয়ে হিসাব। একটি সহজ interpreter গাছের নিচ থেকে ওপরে যায়: আগে 3 * 4 = 12, তারপর 2 + 12 = 14, শেষে Print. এই ধরনের interpreter-এর নাম tree-walking interpreter; মডিউল ১০-এ Haat-এর জন্য পুরোটা বানাবেন।
  6. ধাপ ৬ — ফল। পর্দায় আসে 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. নিচের বেগুনি পট্টি প্রতিটি ধাপের নিয়মের উৎস।

Haat compiler pipeline mapped to course modules bazar.haat source code: অক্ষর Lexer → token মডিউল ৮ · front end Parser → AST মডিউল ৮ · front end নাম আর type যাচাই মডিউল ৯ · semantic Interpreter, VM মডিউল ১০ সরাসরি চালানো 996 · 5000 · 3 IR আর optimization মডিউল ১১ RISC-V, Wasm code generation মডিউল ১২ runtime, GC মডিউল ১২ ভাষার ধারণা · মডিউল ২–৭ প্রতিটি ধাপের নিয়মের উৎস
ছবি ১.১ — একটি ভাষা-বাস্তবায়নের পূর্ণ পথ। প্রতিটি বাক্স কোর্সের একটি মডিউলে নিজের হাতে বানানো হবে।

মানচিত্রটি তিন ভাগে পড়ুন। ওপরের নীল বাক্সগুলো front end: এরা উৎস-ভাষাকে বোঝে, ভুল ধরে, আর একটি যাচাই-করা গাছ দেয়। এখানে semantic analysis মানে ব্যাকরণের পরের যাচাই: প্রতিটি নাম কোথায় ঘোষিত, আর type মেলে কি না (এই কাজ করে type checker). হলুদ বাক্সগুলো middle end আর back end: IR নামের একটি মাঝামাঝি ভাষায় optimization, তারপর code generation, অর্থাৎ একটি নির্দিষ্ট যন্ত্রের নির্দেশ বানানো। আর বাঁ দিকের লাল-সবুজ পথটি interpreter-এর: অনুবাদ শেষ না করেই সরাসরি চালানো।

ধাপগুলোর ভেতরে কী আসে আর কী বের হয়, আর এই ভাগাভাগি কেন বড় compiler-এ এত কাজের, তা পর্ব ০৫-এ (Compiler-এর ধাপগুলো) সত্যিকারের Clang-এর আউটপুট দিয়ে দেখবেন। এখানে শুধু মানচিত্রটি মনে রাখুন। এবার পুরো কোর্সটি ধাপে ধাপে:

  1. ভিত্তিM1পর্ব ১–৬
  2. ভাষার গঠনM2–M5পর্ব ৭–৩২
  3. Type, অর্থM6–M7পর্ব ৩৩–৪৪
  4. Front end, VMM8–M10পর্ব ৪৫–৬১
  5. IR, back endM11–M12পর্ব ৬২–৭৫
  6. আধুনিক, প্রস্তুতিM13–M14পর্ব ৭৬–৮৬
মডিউল ১Haat: পরিচয়
ইতিহাস · syntax/semantics · অনুবাদক
compiler-এর ধাপ · নকশার আপস
Haat: bazar.haat পড়তে পারা
মডিউল ২–৫Haat: নিয়মের যুক্তি
M2 paradigm   M3 নাম, scope, closure
M4 data type  M5 expression, call stack
Haat: scope আর closure-এর নিয়ম কেন
মডিউল ৬–৭Haat: নিয়ম গণিতে
M6 type system: Γ ⊢ e : τ, inference
M7 semantics: small-step, Hoare logic
Haat: typing rule আর অর্থের সংজ্ঞা
মডিউল ৮–১০Haat: প্রথম চলমান রূপ
M8 lexer, parser, AST, diagnostic
M9 symbol table, type checker
M10 interpreter, bytecode, VM, JIT
Haat: bazar.haat → 996, 5000, 3
মডিউল ১১–১২Haat: machine code
M11 three-address code, SSA, optimization
M12 register allocation, RISC-V, Wasm, GC
Haat: browser আর RISC-V-এ চলা
মডিউল ১৩–১৪Haat: পূর্ণ compiler
M13 Rust ownership, concurrency, DSL, LSP
    ক্যাপস্টোন: পূর্ণ Haat compiler
M14 সমস্যা, MCQ, ভাইভা, ইন্টারভিউ
  1. ভিত্তি (মডিউল ১, পর্ব ০১–০৬)। ভাষার ইতিহাস, syntax আর semantics-এর পার্থক্য, compiler আর interpreter-এর ধরন, compiler-এর ধাপ আর ভাষা নকশার আপস। শেষে আপনি bazar.haat পড়ে বলতে পারবেন কোন লাইন কী করে।
  2. ভাষার গঠন (মডিউল ২–৫, পর্ব ০৭–৩২)। Paradigm, নাম আর scope, closure, data type, memory layout, expression-এর ক্রম, parameter passing, call stack. এখানে Haat-এর প্রতিটি নিয়মের যুক্তি পাবেন, যেমন closure কেন variable-কে reference দিয়ে ধরে।
  3. Type আর অর্থ (মডিউল ৬–৭, পর্ব ৩৩–৪৪)। Type system, typing rule, Hindley–Milner inference, soundness; তারপর operational, denotational আর axiomatic semantics. Haat-এর নিয়ম এখানে গণিতের ভাষায় লেখা হবে।
  4. Front end থেকে VM (মডিউল ৮–১০, পর্ব ৪৫–৬১)। এখান থেকে বানানো শুরু: lexer, parser, AST, ভালো error বার্তা, symbol table, type checker, tree-walking interpreter, bytecode আর stack VM. এই ভাগের শেষে Haat প্রথমবার পুরো bazar.haat চালাবে।
  5. 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.
  6. আধুনিক ভাষা আর প্রস্তুতি (মডিউল ১৩–১৪, পর্ব ৭৬–৮৬)। 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-এর নিয়ম
TypeInt (৬৪-বিট, overflow হলে wrap), Bool, Str, Unit, আর function type যেমন (Int, Int) -> Int; নিজে থেকে কোনো type-রূপান্তর নেই
নামlet বদলানো যায় না, var বদলানো যায়; type না লিখলে মান থেকে অনুমান
Statementif … else, while, return, print(e);, আর { … } block, যা নতুন scope খোলে
Functionfn name(p: T) -> R { … }; parameter আর return type লিখতে হয়; function একটি মান, closure variable-কে reference দিয়ে ধরে
Operatorসবচেয়ে দুর্বল ||, তারপর &&, == !=, < <= > >=, + -, * / %, unary - !; তুলনা শিকলের মতো বসে না (a < b < c বা a == b != c syntax error)
Errorline: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);
মান (Watch)
p
first
total
rounds
  1. লাইন ১০ থেকে price(2, 520). Function-এর ভেতরে p = 2 * 520 = 1040. 1040 >= 1000 সত্য, তাই ফেরত আসে 1040 − 1040 / 10 = 1040 − 104 = 936. first-এ এখনো কিছু রাখা হয়নি।
  2. এবার delivery(936). 936 >= 1000 মিথ্যা, তাই else অংশ: 60. যোগফল 936 + 60 = 996, যা first-এ যায়। খেয়াল করুন, price(2, 520) দুবার ডাকা হয়েছে; p প্রতিটি ডাকের নিজস্ব, function শেষ হলে তার আর অস্তিত্ব নেই।
  3. লাইন ১১। print(first) পর্দায় লেখে 996.
  4. লাইন ১২–১৩। দুটি var: total = 0, rounds = 0. এগুলো let নয়, তাই পরে বদলানো যাবে।
  5. লাইন ১৪, প্রথম পাক। 0 < 5000 সত্য। total হয় 1250, rounds হয় 1.
  6. দ্বিতীয় পাক। 1250 < 5000 সত্য। total = 2500, rounds = 2.
  7. তৃতীয় পাক। 2500 < 5000 সত্য। total = 3750, rounds = 3.
  8. চতুর্থ পাক। 3750 < 5000 সত্য। total = 5000, rounds = 4.
  9. শর্ত আবার যাচাই। 5000 < 5000 মিথ্যা, কারণ সমান মানে ছোট নয়। Loop শেষ। এখানেই অনেকে ভুল করেন: < আর <=-এর পার্থক্যে পাকের সংখ্যা বদলায়।
  10. লাইন ১৫। পর্দায় 5000.
  11. লাইন ১৬। 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 কোর্স জুড়ে বড় হবে। মডিউল ৮–১২-এ এর বাস্তবায়ন এই ক্রমে তৈরি হবে, আর প্রতিটি নতুন অংশ আগের অংশের ফল ব্যবহার করবে:

পর্বযা বানাবেনফল
৪৬Lexertoken, line:col, lexical error
৪৭–৪৯Recursive descent আর Pratt parser, ASTপুরো প্রোগ্রামের গাছ
৫১–৫২Name resolution, type checkertype mismatch, undefined variable
৫৬–৫৭Tree-walking interpreter, closurebazar.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 (ওপর ডানে)
stack
গভীরতা
  1. CONST 0. ধ্রুবক-তালিকার ০ নম্বর মান 2 stack-এ রাখা হলো। Compiler গাছটি এমন ক্রমে হেঁটেছে যে আগে সন্তান, পরে বাবা (post-order); তাই প্রথম নির্দেশ বাঁ দিকের পাতা 2.
  2. CONST 1. 3 রাখা হলো 2-এর ওপরে। Stack: [2,3].
  3. CONST 2. 4 ওপরে। Stack-এর গভীরতা এখন 3, এই প্রোগ্রামের সর্বোচ্চ।
  4. MUL. ওপরের দুটি মান তোলা হলো (3 আর 4), গুণফল 12 আবার রাখা হলো। Stack: [2,12]. গাছে * নিচে ছিল, তাই bytecode-এ সেটি আগে।
  5. ADD. 2 আর 12 তুলে 14 রাখা হলো। Stack: [14].
  6. PRINT. ওপরের মান তুলে ছাপা হলো: 14. Stack খালি।
  7. CONST 3. Unit মান () রাখা হলো, কারণ প্রতিটি function, এমনকি পুরো প্রোগ্রাম (<main>) একটি মান ফেরত দেয়।
  8. 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 করা CPythonHaat-এর 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 বলে দিন, আর উত্তরের সঙ্গে যাচাইয়ের উপায় চেয়ে নিন:

আমি একটি ছোট ভাষার interpreter বানাচ্ছি (Python 3.14-এ)। ভাষার নিয়ম: + - সমান শক্তির, * / % তার চেয়ে বেশি, সব binary operator বাঁ দিক থেকে জোড়া বাঁধে, / শূন্যের দিকে কাটে (C-র মতো)। নিচে আমার Pratt parser আর eval দিলাম। [এখানে কোড পেস্ট করুন] ১. কোনো ভুল থাকলে কোন লাইনে, আর কোন input-এ ভুল ফল আসবে, তা বলো। ২. ১০টি test input দাও, প্রতিটির সঠিক ফল সহ; অন্তত তিনটি ঋণাত্মক ভাগ আর তিনটি একই operator পাশাপাশি। ৩. কোনো নিয়ম নিয়ে নিশ্চিত না হলে স্পষ্ট করে বলো; অনুমানকে তথ্য হিসেবে লিখো না।

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 বানানোর সময় আপনিও দুটিই ব্যবহার করবেন।

অনুশীলন

প্রথমটিতে কোড লিখবেন, বাকিগুলোতে ভুল খোঁজা আর হাতে হিসাব।

  1. 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). নাম না থাকলে Python KeyError: 'totl' দেয়; Haat-এ এটি চালানোর আগেই, name resolution ধাপে ধরা পড়ে (পর্ব ৫১): reference-এর check দুই লাইনের একটি প্রোগ্রামে বলেছে 2:7: error: undefined variable 'totl'. এই ছোট পরিবর্তনেই আপনি একটি environment-ভিত্তিক interpreter-এর বীজ বুনলেন।

  2. ভুলটি খুঁজুন (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-র ভুল ধরে না।

  3. আউটপুট অনুমান করুন: 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 থামে প্রথম যে মান শর্ত ভাঙে সেখানে।

  4. 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-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. ✍️ Source code: অক্ষরের সারি
  2. 🔤 Lexical analysis: token-এর সারি
  3. 🧭 Syntax analysis: AST
  4. 🔎 Semantic analysis: নাম আর type যাচাই
  5. ⚡ IR আর optimization
  6. 🖥️ 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 নেই

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন, অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. আপনার প্রতিটি লাইন একটি অনুবাদকের (compiler বা interpreter) হাত ঘুরে চলে; ভাষা আর তার বাস্তবায়ন আলাদা জিনিস।
  2. মূল পথ: lexer → parser → AST → semantic analysis, তারপর হয় interpreter/VM, নয়তো IR → optimization → code generation.
  3. Precedence আর associativity ঠিক করে গাছের আকার; গাছের আকারই ঠিক করে কোন হিসাব আগে।
  4. Haat কোর্সের চলমান প্রজেক্ট; bazar.haat ছাপে 996, 5000, 3, আর প্রতিটি নতুন যন্ত্রে একই ফল আসতে হবে।
  5. তিনটি পথ বেছে নিন (শুরু, মাঝারি, উচ্চতর); প্রতিটি দাবি আসল run দিয়ে যাচাই করুন, AI-এর উত্তরও।

পরের পর্বে: FORTRAN-এর compiler থেকে Rust-এর borrow checker পর্যন্ত: প্রোগ্রামিং ভাষার পরিবারগুলো কীভাবে জন্মাল, আর garbage collection, object বা type inference-এর মতো ধারণা এক ভাষা থেকে আরেক ভাষায় কীভাবে গেল।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান