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

অনুবাদক — compiler, interpreter, transpiler আর JIT

Translators — Compilers, Interpreters, Transpilers, JIT Compilation and Bootstrapping

Taught in Bangla, this lesson defines compilers and interpreters by meaning preservation and shows that compiled or interpreted describes an implementation. A real Clang run shows one C file through each translator. In-page Python contrasts interpreting and compiling a Haat program, exposes a naive transpiler's pitfalls and inspects CPython's bytecode path. It weighs AOT against JIT in the JVM and JS engines, runs a tiny WebAssembly module, and covers bootstrapping with T-diagrams and Trusting Trust.

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

  • Compiler আর interpreter-এর সংজ্ঞা অর্থ দিয়ে লেখা, আর “অর্থ ঠিক রাখা” শর্তটি নিজের কোডে যাচাই করা
  • Transpiler, assembler, linker, loader আর preprocessor-এর ইনপুট ও আউটপুট চেনা, সত্যিকারের Clang-এর ফলসহ
  • CPython, JVM আর JavaScript engine-এর মিশ্র পথ, আর AOT বনাম JIT-এর আপস বিচার করা
  • T-diagram এঁকে bootstrapping আর cross-compilation-এর হিসাব করা, আর একটি ছোট প্রমাণ লেখা
  • Haat-এর জন্য এই কোর্সে কোন কোন অনুবাদক বানাবেন, আর AI-এর দাবি কীভাবে যাচাই করবেন

১ · দোভাষী আর অনুবাদক — দুই রকম অনুবাদ

বাজারঘরের অফিসে একজন জাপানি সরবরাহকারী এসেছেন। তাঁর সঙ্গে কথা বলার দুটি উপায় আছে। প্রথম উপায়: একজন দোভাষী পাশে বসেন; আপনি একটি বাক্য বলেন, তিনি সঙ্গে সঙ্গে সেটি জাপানিতে বলেন। দ্বিতীয় উপায়: আপনি পুরো চুক্তিপত্রটি আগে লিখে একজন অনুবাদকের হাতে দেন; তিনি কয়েক দিন খেটে পুরো লেখাটি জাপানিতে অনুবাদ করে দেন, আর সরবরাহকারী সেটি যতবার খুশি পড়েন।

দোভাষী হলেন interpreter: অনুবাদ আর কাজ একসঙ্গে, প্রতিবার বলার সময় আবার অনুবাদ। লিখিত অনুবাদক হলেন compiler: অনুবাদ একবার, আগে; পরে শুধু অনূদিত লেখাটি ব্যবহার। দোভাষী দ্রুত শুরু করতে পারেন, কিন্তু প্রতিটি বৈঠকে তাঁকে লাগে। লিখিত অনুবাদে শুরুতে সময় যায়, কিন্তু পরে আর খরচ নেই। প্রোগ্রামিং ভাষার জগতে এই দুই পথের আপস ঠিক এমনই।

এখন একটু নির্দিষ্ট করে বলি। একটি translator (অনুবাদক) হলো এমন একটি program, যার ইনপুট আরেকটি program. যে ভাষায় ইনপুট-program লেখা, সেটি source language (উৎস-ভাষা); অনুবাদের ফল যে ভাষায়, সেটি target language (লক্ষ্য-ভাষা); আর অনুবাদক নিজে যে ভাষায় লেখা, সেটি তার implementation language. যেমন Clang একটি compiler, যার source language C, target language x86-64 বা RISC-V-এর machine code, আর implementation language C++.

আরেকটি জোড়া শব্দ পুরো কোর্সে বারবার আসবে। Static মানে program চালানোর আগে (compile time), আর dynamic মানে program চলার সময় (run time). কোনো ভুল static-ভাবে ধরা পড়ে মানে চালানোর আগেই ধরা পড়ে।

সংজ্ঞা — “অর্থ ঠিক রাখা” দিয়ে

অনুবাদক ঠিক কাজ করছে কি না বলতে হলে program-এর “অর্থ” লাগে। ধরুন ⟦p⟧S লিখলে বোঝায়: ভাষা S-এর নিয়মে program p-এর অর্থ, অর্থাৎ একটি function যা ইনপুট x নিয়ে আউটপুট দেয় (অথবা runtime error). এই ⟦ ⟧ বন্ধনীকে বলে semantic bracket; মডিউল ৭-এ (পর্ব ৪০–৪২) এর পুরো গণিত আসবে। আজ শুধু এটুকুই দরকার।

সংজ্ঞা ৪.১ — interpreter আর compiler

Interpreter: ভাষা S-এর একটি interpreter, ভাষা L-এ লেখা, হলো একটি program I, যেন প্রতিটি S-program p আর প্রতিটি ইনপুট x-এর জন্য
⟦I⟧L(p, x) = ⟦p⟧S(x).

Compiler: S থেকে T-তে একটি compiler, ভাষা L-এ লেখা, হলো একটি program C, যেন প্রতিটি S-program p-এর জন্য q = ⟦C⟧L(p) একটি T-program, আর প্রতিটি ইনপুট x-এর জন্য
⟦q⟧T(x) = ⟦p⟧S(x).

এই দ্বিতীয় সমীকরণকে বলে compiler-এর সঠিকতা (correctness) বা অর্থ-রক্ষা (semantics preservation).

দুটি সংজ্ঞার পার্থক্য খেয়াল করুন। Interpreter-এর হাতে program আর ইনপুট একসঙ্গে আসে, আর সে সরাসরি আউটপুট দেয়। Compiler-এর হাতে আসে শুধু program; ইনপুট সে কখনো দেখে না। সে বানায় আরেকটি program, যা পরে ইনপুট পাবে। এজন্যই compiler “আগে” কাজ করে, আর interpreter “চলার সময়”।

সমীকরণটি সব ভাষায় হুবহু “সমান” নয়। C17-এ undefined behavior আছে, যেমন signed int overflow; সেখানে মান নির্ধারিত নয়, তাই compiler যেকোনো আচরণ বেছে নিতে পারে, আর সমীকরণটি দাঁড়ায় “অনুমোদিত আচরণগুলোর একটি”. Haat-এ এমন ফাঁক নেই: Int overflow wrap করে, আর শূন্য দিয়ে ভাগ একটি নির্দিষ্ট runtime error. তাই Haat-এর প্রতিটি অনুবাদক একই ইনপুটে একই আউটপুট দিতে বাধ্য।

২ · একই program, দুই পথ — interpreter বনাম compiler

এবার একটি ছোট Haat program দুই পথে চালাই। দুই পথেই প্রথম কাজ এক: লেখাকে token-এ ভাঙা (lexer) আর token থেকে একটি গাছ বানানো, যার নাম abstract syntax tree (AST). পার্থক্য শুরু হয় তার পরে। নিচের stepper-এ দুই পথ পাশাপাশি দেখুন; সংখ্যাগুলো একটু পরের Python কোড চালিয়ে মেলানো।

1let qty = 2;2let unit = 520;3print(qty * unit - qty * unit / 10);
এই ধাপে দুই পথ
Interpreter
Compiler
  1. পড়া। দুই পথেই lexer তিনটি লাইনকে token-এ ভাঙে আর parser একটি AST বানায়। এ পর্যন্ত interpreter আর compiler একই কাজ করে; ভাষার “front end” দুজনেরই লাগে।
  2. Compiler-এর আলাদা ধাপ। Compiler পুরো AST ঘুরে একবারে target code লেখে, কিন্তু কিছুই চালায় না। Interpreter এখানে কিছু করে না; সে অনুবাদ জমিয়ে রাখে না।
  3. লাইন ১–২ চলে। Interpreter নিজের একটি environment (নাম থেকে মানের টেবিল) বানায়: qty=2, unit=520. Compiled program একই কাজ করে নিজের নির্দেশে; সেখানে AST আর নেই।
  4. গুণ। Interpreter Binary(*) node-এ গিয়ে দুই সন্তানের মান নেয় আর গুণ করে: 1040; গাছে qty * unit দুবার আছে, তাই কাজটিও দুবার। Compiled code-এও এখানে দুটি গুণ, কারণ আমাদের ছোট compiler কোনো optimization করে না।
  5. ভাগ আর বিয়োগ। Haat-এর / শূন্যের দিকে কাটে: 1040 / 10 = 104; তারপর 1040 − 104 = 936. Interpreter প্রতিটি node-এ গিয়ে “এটি কোন ধরনের node?” জিজ্ঞেস করে, compiled code সেই প্রশ্ন আগেই মিটিয়ে রেখেছে।
  6. একই উত্তর। দুই পথেই 936 ছাপা হলো, ঠিক যেমন সংজ্ঞা ৪.১ দাবি করে। পার্থক্য সময়ে: program আবার চালালে interpreter আবার গাছ ঘুরবে, আর compiled code সরাসরি চলবে।

এবার এই দুই পথ সত্যিই লিখে চালাই, ব্রাউজারের ভেতরের Python-এ (Pyodide). AST-এর node-এর নাম কোর্সের Haat reference-এর মতোই: Num, Var, Binary. ev একটি tree-walking interpreter: গাছের ওপর দিয়ে হেঁটে মান বের করে। gen একটি ছোট compiler: গাছ থেকে Python source লেখে, তারপর Python নিজের compiler দিয়ে সেটিকে চালানোর উপযোগী করে। Haat-এর নিয়ম মানতে দুটি সাহায্যকারী function আছে: w ৬৪-বিট wrap করে, আর hdiv শূন্যের দিকে কেটে ভাগ করে।

from dataclasses import dataclass
@dataclass
class Num: value: int
@dataclass
class Var: name: str
@dataclass
class Binary: op: str; left: object; right: object

def w(x): return (x + 2**63) % 2**64 - 2**63     # Int: 64-bit, overflow wraps
def hdiv(a, b):                                    # Haat '/': truncate toward 0
    if b == 0: raise ZeroDivisionError("division by zero")
    q = abs(a) // abs(b)
    return q if (a >= 0) == (b >= 0) else -q

def ev(e, env):                 # interpreter: walk the tree on every run
    if isinstance(e, Num): return e.value
    if isinstance(e, Var): return env[e.name]
    a, b = ev(e.left, env), ev(e.right, env)
    if e.op == "/": return hdiv(a, b)
    return w(a + b if e.op == "+" else a - b if e.op == "-" else a * b)

def gen(e):                     # compiler: translate once, to Python source
    if isinstance(e, Num): return str(e.value)
    if isinstance(e, Var): return e.name
    l, r = gen(e.left), gen(e.right)
    return f"hdiv({l}, {r})" if e.op == "/" else f"w({l} {e.op} {r})"

# Haat: qty * unit - qty * unit / 10
p = Binary("*", Var("qty"), Var("unit"))
expr = Binary("-", p, Binary("/", p, Num(10)))
target = "lambda qty, unit: " + gen(expr)
print(target)
fn = eval(target, {"w": w, "hdiv": hdiv})        # Python's own compiler takes over
for q, u in [(2, 520), (3, 100), (-7, 1), (-15, 1)]:
    print((q, u), "interpreter:", ev(expr, {"qty": q, "unit": u}), " compiled:", fn(q, u))

আসল আউটপুট (ব্রাউজারের Python):

lambda qty, unit: w(w(qty * unit) - hdiv(w(qty * unit), 10))
(2, 520) interpreter: 936  compiled: 936
(3, 100) interpreter: 270  compiled: 270
(-7, 1) interpreter: -7  compiled: -7
(-15, 1) interpreter: -14  compiled: -14

প্রথম লাইন compiler-এর ফল: একটি target program, এখানে target language Python. এটি একবারই তৈরি হয়েছে; তারপর চারটি ইনপুটে শুধু fn চলেছে, আর কোনো গাছ ঘোরা হয়নি। ev কিন্তু প্রতিটি ইনপুটে পুরো গাছ নতুন করে ঘুরেছে। চারটি ইনপুটেই দুই পথের উত্তর এক, ঋণাত্মক সংখ্যাতেও: −15 / 10 শূন্যের দিকে কেটে −1, তাই −15 − (−1) = −14. এই মিলিয়ে দেখাকে বলে differential testing: একই program দুটি স্বাধীন বাস্তবায়নে চালিয়ে আউটপুট মেলানো। এই কোড কোর্সের Haat reference-এর interp.py (পুরো interpreter) আর runtime.py (wrap আর C-ধরনের ভাগ)-এর একটি ছোট অংশ; পুরোটা আসবে পর্ব ৫৬-এ (Tree-walking interpreter — Haat চালানো)। Reference-ও এই program-এ 936 ছাপে।

একটি সূক্ষ্ম কথা: gen শুধু Python লেখা পর্যন্ত গেছে; Python-কে machine code-এ নামিয়েছে CPython নিজে (আসলে bytecode-এ, অংশ ৫-এ দেখবেন)। বাস্তবের অনুবাদক প্রায়ই এভাবে শিকলে জোড়া থাকে: একজনের target আরেকজনের source.

৩ · Toolchain-এর অন্য অনুবাদক — assembler, linker, loader

“Compiler” শব্দটি দৈনন্দিন কথায় পুরো toolchain বোঝায়, কিন্তু ভেতরে কয়েকজন আলাদা অনুবাদক আছে। C-র toolchain আপনি হয়তো C প্রোগ্রামিং কোর্সের পর্ব ০৩-এ দেখেছেন; এখানে প্রতিটিকে “অনুবাদক” হিসেবে দেখব: কী ঢোকে, কী বের হয়।

অনুবাদকইনপুটআউটপুটকখন
PreprocessorC source, #include আর macro সহmacro খোলা C source (.i)compile-এর আগে
Compiler (সরু অর্থে)C sourceassembly (.s)build-এর সময়
Assemblerassemblyobject file (.o), ফাঁকা ঠিকানাসহbuild-এর সময়
Linkerকয়েকটি .o আর libraryexecutablebuild-এর শেষে
Loaderexecutable ফাইলমেমরিতে সাজানো, চলার জন্য তৈরি processprogram খোলার মুহূর্তে
Transpilerএক উচ্চ-স্তরের ভাষার sourceআরেক উচ্চ-স্তরের ভাষার sourcebuild-এর সময়

Assembler-ও একটি পূর্ণ অনুবাদক: source language assembly, target language machine code. Linker অনুবাদ কম করে, জোড়া বেশি দেয়; তবু সে object file-এর ফাঁকা ঠিকানা (relocation) পূরণ করে একটি নতুন program লেখে। Loader-এর কাজ অপারেটিং সিস্টেমের ভেতরে; পূর্ণ বিবরণ আসবে পর্ব ৭৪-এ (Linking আর loading). Compiler-এর ভেতরের সব ধাপ আর তাদের মাঝের ডেটা পরের পর্বে, পর্ব ০৫-এ (Compiler-এর ধাপগুলো)।

সত্যিকারের run — একটি C ফাইল, প্রতিটি অনুবাদকের ফল

নিচের সবকিছু সত্যিকারের run: PyPI-র ziglang 0.17.1 প্যাকেজ (MIT licence), যার ভেতরে Zig-এর সঙ্গে আসা Clang 22.1.8 (LLVM-এর Apache-2.0 with LLVM exception licence). এখানে zig মানে python -m ziglang. ফাইলটি বাজারঘরের দাম-হিসাব, Haat-এর price function-এর C রূপ:

#include <stdio.h>

int price(int qty, int unit) {
    int p = qty * unit;
    if (p >= 1000) return p - p / 10;
    return p;
}

int main(void) {
    printf("%d\n", price(2, 520));
    return 0;
}
~/haat $ zig version
0.17.1
~/haat $ zig cc --version
clang version 22.1.8
~/haat $ zig cc -target x86_64-linux-musl -E price.c -o price.i
~/haat $ zig cc -target x86_64-linux-musl -O2 -g0 -S price.c -o price.s
~/haat $ zig cc -target x86_64-linux-musl -O2 -g0 -c price.c -o price.o
~/haat $ zig cc -target x86_64-linux-musl -O2 -g0 -s price.c -o price
~/haat $ zig cc -target riscv64-linux-musl -O2 -g0 -c price.c -o price_rv.o
~/haat $ zig cc -O2 -g0 -s price.c -o price.exe
~/haat $ ./price.exe
936
~/haat $ wc -l price.c price.i price.s
  12 price.c
 183 price.i
  63 price.s
~/haat $ python elfinfo.py price.o price_rv.o price
price.o        1512 bytes  ELF  x86-64  relocatable (.o)
price_rv.o     1976 bytes  ELF  RISC-V  relocatable (.o)
price         19576 bytes  ELF  x86-64  executable

ফাইলের আকার (byte): price.c 198, price.i 6729, price.s 1527, আর এই Windows ল্যাপটপে চালানো price.exe 71168. elfinfo.py একটি ৭ লাইনের নিজের লেখা script, যা ELF header-এর দুটি ঘর পড়ে বলে ফাইলটি কোন CPU-র আর কোন ধরনের। -O2-এর assembly থেকে main-এর কাজের অংশ:

main:                                   # @main
	pushq	%rbp
	movq	%rsp, %rbp
	movl	$.L.str, %edi
	movl	$936, %esi                      # imm = 0x3A8
	xorl	%eax, %eax
	callq	printf

তিনটি জিনিস খেয়াল করুন। এক, preprocessor ফাইল বড় করে: ১২ লাইনের source #include খুলে ১৮৩ লাইন, কারণ stdio.h-এর ঘোষণাগুলো ঢুকেছে। দুই, একই compiler, দুই target: শুধু -target বদলে একই source থেকে x86-64 আর RISC-V-এর object file পেলাম; অন্য CPU-র জন্য কোড বানানো এমন compiler-কে বলে cross-compiler. Linux-এর price এই Windows ল্যাপটপে চলে না, তাই চালানোর জন্য আলাদা করে Windows-এর price.exe বানানো হলো। তিন, compiler আগেই হিসাব সেরে ফেলেছে: main-এ কোনো গুণ বা ভাগ নেই, সরাসরি $936. price(2, 520)-এর দুটি argument-ই ধ্রুবক, তাই Clang function-টি ভেতরে বসিয়ে (inlining) পুরো হিসাব build-এর সময়েই করেছে (constant folding). একটি সাধারণ interpreter এ কাজ চলার সময় প্রতিবার করে; এটিই আগে অনুবাদ করার একটি বড় সুবিধা।

৪ · Transpiler — source থেকে source, আর অর্থ হারানোর ফাঁদ

যে অনুবাদকের target-ও একটি উচ্চ-স্তরের ভাষা, তাকে সাধারণত transpiler বা source-to-source compiler বলে। পরিচিত উদাহরণ: TypeScript-এর tsc TypeScript থেকে JavaScript লেখে (type-এর লেখা মুছে দিয়ে); Babel নতুন JavaScript-কে পুরোনো browser-এর উপযোগী JavaScript-এ নামায়; আর C++-এর প্রথম দিকের compiler Cfront (Bjarne Stroustrup, ১৯৮০-এর দশক) C++ থেকে C লিখত, তারপর একটি সাধারণ C compiler বাকি কাজ করত। অংশ ২-এর gen-ও একটি ছোট transpiler: Haat থেকে Python.

নামটি নতুন শোনালেও তত্ত্বে transpiler একটি সাধারণ compiler, শুধু target-টি উঁচু স্তরের। তাই সংজ্ঞা ৪.১-এর শর্তও একই: অর্থ হুবহু রাখতে হবে। এখানেই সবচেয়ে বেশি ভুল হয়, কারণ দুই ভাষার “একই রকম দেখতে” operator-এর অর্থ আলাদা হতে পারে। নিচের কোডে একজন তাড়াহুড়ো করে Haat-এর /-কে Python-এর //-এ বদলে দিয়েছেন। তারপর differential testing দিয়ে ১৮৩টি ইনপুটে interpreter-এর সঙ্গে মেলানো হলো। (এই block আগের block-এর ev আর expr ব্যবহার করে; আগেরটি না চালালে নিজে থেকেই আগে চলবে।)

def gen_naive(e):               # a "quick" transpiler: Haat '/' -> Python '//'
    if isinstance(e, Num): return str(e.value)
    if isinstance(e, Var): return e.name
    return f"({gen_naive(e.left)} {e.op.replace('/', '//')} {gen_naive(e.right)})"

naive = eval("lambda qty, unit: " + gen_naive(expr))
bad = [(q, u) for q in range(-30, 31) for u in (1, 2, 3)
       if ev(expr, {"qty": q, "unit": u}) != naive(q, u)]
print("tested:", 61 * 3, " mismatches:", len(bad))
q, u = bad[0]
print("first:", (q, u), "Haat says", ev(expr, {"qty": q, "unit": u}),
      "but naive Python says", naive(q, u))
print("-7 / 2 in Haat:", hdiv(-7, 2), "  -7 // 2 in Python:", -7 // 2)

আসল আউটপুট (ব্রাউজারের Python):

tested: 183  mismatches: 78
first: (-29, 1) Haat says -27 but naive Python says -26
-7 / 2 in Haat: -3   -7 // 2 in Python: -4

১৮৩টি ইনপুটের ৭৮টিতে অনুবাদ ভুল! সব ধনাত্মক ইনপুটে মিলেছে, তাই হাতে দু-একটি উদাহরণ চালালে ভুলটি চোখেই পড়ত না। কারণ: Python 3-এর // floor division, অর্থাৎ নিচের দিকে (−∞-এর দিকে) কাটে; Haat-এর / C-র মতো শূন্যের দিকে কাটে। −29 / 10 Haat-এ −2, কিন্তু Python-এ −29 // 10 হলো −3. তাই −29 − (−2) = −27, অথচ ভুল অনুবাদ দেয় −26. সমাধান অংশ ২-এর মতো: /-এর জন্য hdiv ডাকা। শিক্ষা: transpiler লিখতে উৎস আর লক্ষ্য দুই ভাষার নিয়মই জানতে হয়, আর ঋণাত্মক সংখ্যা, শূন্য আর সীমার মান দিয়ে পরীক্ষা করতে হয়। একই /-এর অর্থ C আর Python-এ আলাদা কেন, তা পর্ব ০৩-এ (Syntax, semantics আর pragmatics) বিস্তারে আছে।

Transpiler-এর একটি ব্যবহারিক সমস্যাও আছে: debugging. Browser-এ error হলে লাইন নম্বর আসে তৈরি-করা JavaScript-এর, আপনার TypeScript-এর নয়। এজন্য transpiler সাধারণত একটি source map ফাইলও লেখে, যা target-এর প্রতিটি অবস্থানকে source-এর অবস্থানের সঙ্গে জোড়ে। Haat-এর error বার্তায় যে line:col থাকে, প্রতিটি অনুবাদকের সেটি ঠিক রাখার দায়িত্বও একই ধরনের।

৫ · মিশ্র পথ — bytecode আর virtual machine

বাস্তবের বেশিরভাগ ভাষা খাঁটি interpreter বা খাঁটি compiler কোনোটিই ব্যবহার করে না। জনপ্রিয় মাঝের পথ: প্রথমে source-কে একটি সরল, যন্ত্র-নিরপেক্ষ নির্দেশ-ভাষায় compile করা, যার নাম bytecode; তারপর একটি virtual machine (VM) সেই bytecode চালায়। রেস্তোরাঁর কথা ভাবুন: অতিথির লম্বা কথা ওয়েটার একটি ছোট অর্ডার স্লিপে সংকেতে লিখে নেন (“২ × কাচ্চি, ১ × বোরহানি”), আর রান্নাঘর সেই স্লিপ পড়ে কাজ করে। স্লিপ লেখা হলো compile, স্লিপ পড়ে রান্না হলো interpret.

CPython — compile, তারপর interpret

CPython (Python-এর প্রধান বাস্তবায়ন) আপনার .py ফাইল পড়ে tokenize আর parse করে, AST বানায়, তারপর AST থেকে একটি code object বানায়, যার ভেতরে bytecode. এরপর CPython-এর evaluation loop (C-তে লেখা একটি বড় লুপ) একটি একটি করে bytecode নির্দেশ চালায়। Python নিজের এই compiler-কে compile() নামে আপনার হাতেও দেয়। Python-এর দিক থেকে পূর্ণ গল্পটি আছে Python কোর্সের পর্ব ০৫-এ (Python কীভাবে চলে); এখানে অনুবাদকের চোখে দেখি:

import dis, sys
src = """
def price(qty, unit):
    p = qty * unit
    if p >= 1000:
        return p - p // 10
    return p
"""
print("Python", sys.version.split()[0])
code = compile(src, "bazar.py", "exec")   # source -> code object
print(type(code).__name__, "ready; nothing has run yet")
ns = {}
exec(code, ns)                            # run the module: defines price
price = ns["price"]
dis.dis(price)                            # the bytecode of price
print("price(2, 520) =", price(2, 520))   # the eval loop runs it
print("bytecode size:", len(price.__code__.co_code), "bytes")

আসল আউটপুট (ব্রাউজারের Python, Pyodide-এর CPython 3.14.2; একই তালিকা এই লেখকের ল্যাপটপের CPython 3.14.4-এও হুবহু এসেছে):

Python 3.14.2
code ready; nothing has run yet
  2           RESUME                   0

  3           LOAD_FAST_BORROW_LOAD_FAST_BORROW 1 (qty, unit)
              BINARY_OP                5 (*)
              STORE_FAST               2 (p)

  4           LOAD_FAST_BORROW         2 (p)
              LOAD_CONST               0 (1000)
              COMPARE_OP             188 (bool(>=))
              POP_JUMP_IF_FALSE       16 (to L1)
              NOT_TAKEN

  5           LOAD_FAST_BORROW_LOAD_FAST_BORROW 34 (p, p)
              LOAD_SMALL_INT          10
              BINARY_OP                2 (//)
              BINARY_OP               10 (-)
              RETURN_VALUE

  6   L1:     LOAD_FAST_BORROW         2 (p)
              RETURN_VALUE
price(2, 520) = 936
bytecode size: 66 bytes

compile() ফেরত দিয়েছে একটি code object, কিন্তু তখনো কিছুই চলেনি: এটিই compile ধাপ। dis সেই bytecode মানুষের পড়ার মতো করে দেখায়। প্রতিটি সারিতে একটি opcode: BINARY_OP 5 (*) গুণ, STORE_FAST local variable-এ রাখা, POP_JUMP_IF_FALSE শর্ত মিথ্যা হলে লাফ। বাঁ দিকের 3, 4, 5, 6 হলো source-এর লাইন নম্বর। LOAD_FAST_BORROW_LOAD_FAST_BORROW দুটি variable একসঙ্গে stack-এ তোলে; এমন জোড়া-নির্দেশ CPython-এর নতুন version-গুলোর নিজস্ব, তাই অন্য version-এ তালিকাটি একটু আলাদা দেখাবে। Bytecode-এর আকার ৬৬ byte, যার কিছু অংশ নির্দেশ নয়, CPython-এর গতি বাড়ানোর জন্য রাখা ফাঁকা “cache” ঘর।

নিচের stepper এই পথটি শেষ পর্যন্ত দেখায়: source থেকে bytecode, তারপর price(2, 520) চলার সময় VM-এর operand stack-এ কী থাকে। নির্দেশগুলো উপরের আসল dis আউটপুট থেকে নেওয়া (শুরুর RESUME বাদ দিয়ে)।

1source: def price(qty, unit): …2AST: FunctionDef → Assign, If, Return3code object: 66-byte bytecode4LOAD_FAST_BORROW_LOAD_FAST_BORROW (qty, unit)5BINARY_OP 5 (*)6STORE_FAST 2 (p)7LOAD_FAST_BORROW 2 (p)8LOAD_CONST 0 (1000)9COMPARE_OP 188 (bool(>=))10POP_JUMP_IF_FALSE 16 (to L1)11NOT_TAKEN12LOAD_FAST_BORROW_LOAD_FAST_BORROW (p, p)13LOAD_SMALL_INT 1014BINARY_OP 2 (//)15BINARY_OP 10 (-)16RETURN_VALUE
এই ধাপের অবস্থা
ধাপ
stack
p
  1. Tokenize. CPython-এর tokenizer লেখাটিকে NAME (def, price), OP ((, ,), NEWLINE, INDENT-এর মতো token-এ ভাঙে। কিছুই চলেনি।
  2. Parse. Parser token থেকে AST বানায়: একটি FunctionDef, যার শরীরে Assign, If আর Return. এখনো কিছু চলেনি।
  3. Compile. CPython-এর compiler AST থেকে code object বানায়: ৬৬ byte-এর bytecode, ধ্রুবকের তালিকা (1000), local-এর নাম (qty, unit, p). এই তিন ধাপই একটি compiler-এর কাজ।
  4. চলা শুরু। price(2, 520) ডাকা হলো; evaluation loop প্রথম নির্দেশ পড়ে qty আর unit দুটিকেই stack-এ তোলে: [2, 520].
  5. গুণ। BINARY_OP (*) ওপরের দুটি মান নামিয়ে গুণফল তোলে: [1040].
  6. রাখা। STORE_FAST মানটি stack থেকে নামিয়ে local p-তে রাখে। Stack এখন খালি, p = 1040.
  7. তুলনার প্রস্তুতি। p আর ধ্রুবক 1000 stack-এ ওঠে: [1040, 1000].
  8. তুলনা। COMPARE_OP (bool(>=)) দুটি নামিয়ে ফল তোলে: 1040 ≥ 1000, তাই [True].
  9. শাখা। POP_JUMP_IF_FALSE True নামিয়ে দেখে; মিথ্যা নয়, তাই লাফ নেই, পরের নির্দেশে চলে। NOT_TAKEN শুধু একটি চিহ্ন, “লাফ হয়নি”; stack খালি।
  10. ছাড়ের প্রস্তুতি। p দুবার আর ছোট পূর্ণসংখ্যা 10 stack-এ ওঠে: [1040, 1040, 10].
  11. ভাগ আর বিয়োগ। BINARY_OP (//) 1040 // 10 = 104 দেয়: [1040, 104]; তারপর BINARY_OP (-) 1040 − 104 = 936: [936].
  12. ফেরত। RETURN_VALUE 936 নামিয়ে ডাকা জায়গায় ফেরত দেয়। পুরো পথে CPython-এর compiler চলেছে একবার, আর evaluation loop চালিয়েছে ১৩টি নির্দেশ (শুরুর RESUME বাদে)।

Java আর JavaScript — আরও এক স্তর: JIT

Java (যেমন Java 21, OpenJDK-র HotSpot JVM): javac একটি সাধারণ ahead-of-time compiler, যা .java থেকে JVM bytecode-এর .class ফাইল লেখে। চলার সময় JVM প্রথমে bytecode interpret করে; কোনো method বারবার চললে (“গরম” হলে) HotSpot তাকে machine code-এ compile করে, প্রথমে দ্রুত C1 compiler দিয়ে, আরও গরম হলে বেশি optimize করা C2 দিয়ে। একে বলে tiered compilation. তাই “Java interpreted ভাষা” কথাটি অর্ধসত্য; বিস্তারে Java কোর্সের পর্ব ০৫ (Java কীভাবে চলে).

JavaScript: browser-এ program আসে source হিসেবে, তাই engine-কেই সব করতে হয়। V8 (Chrome, Node.js) দ্রুত bytecode বানিয়ে Ignition interpreter-এ চালায়, তারপর গরম কোড ধাপে ধাপে Sparkplug, Maglev আর TurboFan নামের compiler-এ তোলে; SpiderMonkey (Firefox) আর JavaScriptCore (Safari)-এর স্তরের নাম আর সংখ্যা আলাদা, আর এসব নাম আর স্তর engine-এর নতুন version-এ বদলাতে পারে। মূল ধারণা একই: আগে দ্রুত শুরু, পরে গরম কোডে গভীর অনুবাদ। বিস্তারে JavaScript কোর্সের পর্ব ০৫ (JavaScript কীভাবে চলে).

CPython-ও কি JIT? CPython 3.11 থেকে evaluation loop চলার সময় নিজের bytecode-কে ধরন-নির্দিষ্ট নির্দেশে বদলে নেয় (PEP 659, “specializing adaptive interpreter”); এটি interpreter-এর ভেতরেই, machine code বানায় না। CPython 3.13-এ PEP 744 অনুযায়ী একটি পরীক্ষামূলক JIT যোগ হয়েছে; 3.14-এও এটি পরীক্ষামূলক আর ডিফল্টে বন্ধ, চালু করতে বিশেষ build বা setting লাগে। অন্যদিকে PyPy নামের আরেকটি Python বাস্তবায়ন অনেক আগে থেকেই tracing JIT ব্যবহার করে। ভাষা এক, বাস্তবায়ন আলাদা।

৬ · AOT বনাম JIT — কখন অনুবাদ করবেন

যে compiler program চালানোর আগে অনুবাদ সেরে রাখে, তাকে বলে ahead-of-time (AOT) compiler: GCC, Clang, rustc, javac, Go-র compiler. যে compiler program চলার সময় অনুবাদ করে, সে just-in-time (JIT) compiler. JIT-এর আসল শক্তি সময় নয়, তথ্য: চলার সময় সে দেখতে পায় কোন শাখা বেশি নেওয়া হয়, কোন variable-এ আসলে কোন ধরনের মান আসে। সেই তথ্য দিয়ে সে অনুমান (speculation) করে বিশেষ কোড বানায়। অনুমান ভুল প্রমাণ হলে বিশেষ কোড ফেলে আবার interpreter-এ ফেরে; একে বলে deoptimization.

ঢাকার একজন রিকশাচালকের কথা ভাবুন। নতুন এলাকায় তিনি প্রতিটি মোড়ে জিজ্ঞেস করে করে যান (interpreter). একই পথে দশবার যাওয়ার পর পথটি তাঁর মুখস্থ, আর তিনি শর্টকাটও বের করে ফেলেছেন (JIT). হঠাৎ একদিন সেই গলি খোঁড়া, মুখস্থ শর্টকাট বাতিল, আবার জিজ্ঞেস করে চলা (deoptimization). আর AOT হলো যাত্রার আগের রাতে পুরো মানচিত্র দেখে পথ ঠিক করে রাখা: শুরুতেই দ্রুত, কিন্তু রাস্তার আজকের অবস্থা জানা নেই।

বিষয়AOT compilerInterpreter (tree বা bytecode)JIT (interpreter + compiler)
শুরু হতে সময়খুব কম (অনুবাদ আগেই)কমকম, কিন্তু সর্বোচ্চ গতিতে পৌঁছাতে সময় লাগে (warm-up)
সর্বোচ্চ গতিসাধারণত বেশিসাধারণত সবচেয়ে কমবেশি; কখনো চলার তথ্যের জোরে AOT-কেও ছাড়ায়
Optimization-এর তথ্যশুধু source আর অনুমানপ্রায় নেইআসল চলার profile
বিতরণ করা ফাইলপ্রতি CPU আর OS-এর জন্য আলাদা binarysource বা bytecode, সব যন্ত্রে একbytecode বা source, সব যন্ত্রে এক
মেমরি আর জটিলতাচলার সময় কমকম, বাস্তবায়ন সরলবেশি; compiler-ও চলার সময় মেমরিতে থাকে
আচরণের পূর্বানুমানউঁচু (একই binary, একই কোড)উঁচুকম; গতি নির্ভর করে কখন কী compile হলো তার ওপর

এখানে একটি প্রচলিত ভুল ধারণা ভাঙা দরকার: ভুল কখন ধরা পড়বে, সেটি মূলত ভাষার নকশা, অনুবাদকের ধরন নয়। Haat statically typed: let x = 1 + true; লিখলে Haat-এর type checker চালানোর আগেই error দেয় (reference বাস্তবায়নে 1:13: error: type mismatch: expected Int, found Bool), আপনি Haat-এর interpreter ব্যবহার করুন বা compiler. Python dynamically typed: CPython আগে compile করলেও 1 + "x"-এর ভুল ধরা পড়ে শুধু সেই লাইন চলার সময়। আর শূন্য দিয়ে ভাগ Haat-এও runtime error, কারণ ভাজকের মান চালানোর আগে জানা নেই।

Browser-ও একটি AOT-ধরনের ফরম্যাট বোঝে: WebAssembly (Wasm). C, Rust বা ভবিষ্যতের Haat compiler আগেই Wasm-এর bytecode লেখে; browser-এর engine সেটি পেয়ে নিজের যন্ত্রের machine code-এ অনুবাদ করে চালায়। নিচের JavaScript কোডে ৪১ byte-এর একটি Wasm module হাতে লেখা, যা qty * unit হিসাব করে; পুরো Haat → Wasm back end আসবে পর্ব ৭৩-এ।

// A WebAssembly module, written byte by byte: mul(qty, unit) = qty * unit
const bytes = new Uint8Array([
  0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00,   // "\0asm", version 1
  0x01, 0x07, 0x01, 0x60, 0x02, 0x7f, 0x7f, 0x01, 0x7f, // type: (i32, i32) -> i32
  0x03, 0x02, 0x01, 0x00,                           // one function, type 0
  0x07, 0x07, 0x01, 0x03, 0x6d, 0x75, 0x6c, 0x00, 0x00, // export "mul"
  0x0a, 0x09, 0x01, 0x07, 0x00,                     // code: one body, no locals
  0x20, 0x00, 0x20, 0x01, 0x6c, 0x0b                // local.get 0, local.get 1, i32.mul, end
]);
console.log("module size:", bytes.length, "bytes; valid:", WebAssembly.validate(bytes));
WebAssembly.instantiate(bytes).then(({ instance }) => {
  // the engine has now compiled these bytes to this machine's own code
  const mul = instance.exports.mul;
  console.log("mul(2, 520) =", mul(2, 520));
  console.log("mul(65536, 65536) =", mul(65536, 65536), "(i32 wraps)");
});

আসল আউটপুট (ব্রাউজারের JavaScript):

module size: 41 bytes; valid: true
mul(2, 520) = 1040
mul(65536, 65536) = 0 (i32 wraps)

প্রথম ৮ byte Wasm-এর পরিচয় (\0asm) আর version; তারপর type, function, export আর code নামের চারটি section. WebAssembly.validate চালানোর আগেই পুরো module যাচাই করেছে: Wasm-এর নকশাই এমন যে type-এর ভুল চলার আগে ধরা পড়ে। instantiate-এর ভেতরে engine bytecode-কে নিজের CPU-র machine code-এ অনুবাদ করেছে (কোন স্তরের compiler দিয়ে, তা engine-ভেদে আলাদা)। 2 × 520 = 1040 ঠিক এল। আর 65536 × 65536 = 232, যা ৩২-বিট i32-এ ধরে না, তাই wrap হয়ে 0: Wasm-এর i32.mul-এর নিয়মে এটি নির্ধারিত আচরণ, C-র signed overflow-এর মতো undefined নয়।

৭ · Compiler দিয়ে compiler — bootstrapping আর T-diagram

একটি মজার প্রশ্ন: Go-র compiler Go-তে লেখা (Go 1.5, ২০১৫ সাল থেকে), Rust-এর compiler rustc Rust-এ লেখা, TypeScript-এর compiler (এখনকার প্রধান সংস্করণ) TypeScript-এ লেখা। তাহলে প্রথম Go compiler-টি compile করল কে? উত্তর: bootstrapping. অন্য কোনো ভাষায় লেখা একটি পুরোনো compiler দিয়ে নতুন compiler-কে একবার compile করা, তারপর নতুনটি নিজেকেই compile করে। নিজের ভাষায় লেখা আর নিজেকে compile করতে পারা compiler-কে বলে self-hosting compiler.

এই হিসাব রাখার জন্য একটি ছোট ছবির ভাষা আছে: T-diagram. একটি compiler একটি “T” অক্ষর: ওপরের দণ্ডের বাঁয়ে source language, ডানে target language, আর নিচের পায়ে implementation language. আমরা এটিকে লিখব [S → T]L. Interpreter-কে আঁকা হয় একটি খাড়া বাক্সে, আর যন্ত্রকে একটি নিচু বাক্সে।

ছবি ৪.১ — T-diagram: Haat-এ লেখা compiler-কে Python-এ লেখা compiler দিয়ে compile করা

বাঁয়ের T-এর পা মাঝের T-এর বাঁ বাহুতে বসে; ফল ডানের T, যার পা মাঝের T-এর ডান বাহুতে।

T-diagram of compiling a compiler written in Haat with a compiler written in Python Haat → RV Haat Haat → RV Python Python interpreter, x86-64 Haat → RV RV ইনপুট: hc.haat ফল: stage1
ছবি ৪.১ — বাঁয়ে ইনপুট [Haat → RV]Haat, মাঝে চলছে [Haat → RV]Python, ডানে ফল [Haat → RV]RV. RV মানে RISC-V-এর machine code. মাঝের compiler-এর source language (Haat) বাঁয়ের T-এর পায়ের সঙ্গে মেলে, তাই সে এটি অনুবাদ করতে পারে।

ছবির নিয়মটি একটি অনুমান-নিয়ম (inference rule) হিসেবে লেখা যায়। দাগের ওপরে যা হাতে আছে (premise), নিচে যা পাওয়া যায় (conclusion):

[S → T]L[L → M]M(T-compose)
[S → T]M

পড়ুন এভাবে: L ভাষায় লেখা একটি S → T compiler আছে, আর যন্ত্র M-এ চলা একটি L → M compiler আছে। দ্বিতীয়টি দিয়ে প্রথমটিকে compile করলে পাই যন্ত্র M-এ চলা একটি S → T compiler. এখানে M একই সঙ্গে একটি ভাষা (machine code) আর একটি যন্ত্র।

দাবি ৪.২ — compile করা compiler-ও সঠিক

যদি C1 = [S → T]L আর C2 = [L → M]M দুটিই সংজ্ঞা ৪.১-এর অর্থে সঠিক হয়, তাহলে C1′ = ⟦C2⟧M(C1) একটি সঠিক [S → T]M.

প্রমাণ:

  1. C2 সঠিক, তাই যেকোনো L-program q আর ইনপুট y-এর জন্য ⟦⟦C2⟧M(q)⟧M(y) = ⟦q⟧L(y).
  2. q = C1 নিন, আর ইনপুট y হিসেবে যেকোনো S-program p. তাহলে ⟦C1′⟧M(p) = ⟦C1⟧L(p).
  3. অর্থাৎ C1′ ঠিক সেই T-program দেয়, যা C1 দিত। C1 সঠিক, তাই সেই T-program-টি প্রতিটি ইনপুট x-এ ⟦p⟧S(x) দেয়।
  4. তাই C1′ সংজ্ঞা ৪.১-এর শর্ত মানে, আর এটি M-এ চলে। ∎

খেয়াল করুন, প্রমাণটি দুটি compiler-এর সঠিকতা ধরে নিয়েছে। কোনো একটিতে লুকানো ভুল (বা ইচ্ছাকৃত চালাকি) থাকলে ফলটিও ভরসার নয়; অংশ ৮-এর Trusting Trust ঠিক এই ফাঁক নিয়ে।

এবার পুরো bootstrapping-এর গল্পটি ধাপে ধাপে, Haat-এর একটি কাল্পনিক ভবিষ্যৎ দিয়ে। ধরুন এই কোর্সে Python-এ Haat → RISC-V compiler বানানোর পর (পর্ব ৭২) আপনি সেটিকে Haat-এই আবার লিখলেন। RISC-V-এর binary চালানো হবে একটি RISC-V যন্ত্রে বা emulator-এ।

1hc0.py: [Haat → RV] in Python2hc.haat: [Haat → RV] in Haat3python hc0.py hc.haat → stage14stage1 hc.haat → stage25stage2 hc.haat → stage36compare stage2 stage37Python ছাড়াই পরের version
এই ধাপের অবস্থা
নতুন তৈরি
কে চালাল
codegen-এর যুক্তি
  1. প্রথম compiler অন্য ভাষায়। Python-এ লেখা hc0.py একটি [Haat → RV]Python. এটি চালাতে Python interpreter লাগে। কোর্সের মডিউল ৮–১২-এ ঠিক এমন একটি জিনিসই ধাপে ধাপে বানাবেন।
  2. Haat-এ আবার লেখা। একই compiler-এর যুক্তি এবার Haat-এ: hc.haat, একটি [Haat → RV]Haat. এখনো এটি চালানোর কোনো উপায় নেই, কারণ Haat সরাসরি কোনো যন্ত্র বোঝে না।
  3. প্রথম compile. hc0.py দিয়ে hc.haat compile করা হলো: ছবি ৪.১-এর T-compose নিয়ম। ফল stage1, একটি [Haat → RV]RV. এর ভেতরের machine code বানিয়েছে hc0.py-এর code generator, তাই কোডটি হয়তো ধীর বা অন্য রকম, কিন্তু অর্থে সঠিক (দাবি ৪.২)।
  4. নিজেকে compile. এবার stage1 RISC-V-এ চলে আর hc.haat compile করে, ফল stage2. এই প্রথম Haat compiler-এর machine code বানাল Haat-এ লেখা যুক্তি নিজেই।
  5. আরও একবার। stage2 দিয়ে আবার hc.haat compile করে stage3. stage1 আর stage2 আলাদা হতেই পারে, কারণ তাদের বানিয়েছে দুটি আলাদা code generator.
  6. Fixpoint যাচাই। stage2 আর stage3 দুটিই একই source থেকে একই যুক্তি দিয়ে তৈরি, তাই compiler deterministic হলে byte ধরে হুবহু মিলবে। না মিললে compiler-এ কোথাও ভুল আছে। GCC-র native “bootstrap” build ঠিক এমন তিন stage চালিয়ে stage2 আর stage3 মেলায়।
  7. Self-hosting. এখন থেকে Haat compiler-এর নতুন version আগের stage দিয়েই compile হবে; Python আর লাগে না। Go 1.5 আর rustc এভাবেই নিজের ভাষায় চলে এসেছিল। কিন্তু একটি প্রশ্ন থেকে যায়: পুরোনো binary-তে কী আছে, তা কে যাচাই করল?

T-diagram দিয়ে cross-compilation-ও হিসাব করা যায়। ধরুন আপনার হাতে x86-64 ল্যাপটপে চলা [C → x86]x86 আর C-তে লেখা [C → RV]C আছে। প্রথমটি দিয়ে দ্বিতীয়টি compile করলে T-compose নিয়মে পাবেন [C → RV]x86: ল্যাপটপে চলে, RISC-V-এর কোড বানায়। এটিই একটি cross-compiler, যা দিয়ে আপনি অংশ ৩-এ price_rv.o বানিয়েছেন।

প্রথম compiler-টি কে compile করেছিল? কেউ না; ১৯৫০-এর দশকে compiler লেখা হতো assembly-তে, আর assembler-এর আগে মানুষ হাতে machine code লিখতেন। John Backus-এর দল ১৯৫৭ সালে IBM 704-এর জন্য প্রথম FORTRAN compiler প্রকাশ করে, assembly-তে লেখা। LISP-এর ইতিহাসে প্রায়ই বলা হয়, ১৯৬২ সালে MIT-তে Tim Hart আর Mike Levin-এর LISP compiler, যা LISP-এই লেখা আর একটি LISP interpreter-এর ওপর চালিয়ে নিজেকে compile করেছিল, প্রথম self-hosting compiler-গুলোর একটি। ১৯৭০-এর দশকে Niklaus Wirth-এর দলের Pascal-P compiler আরেকটি কৌশল জনপ্রিয় করে: compiler একটি কাল্পনিক যন্ত্রের “P-code” বানায়, তাই নতুন কম্পিউটারে Pascal আনতে শুধু একটি ছোট P-code interpreter লিখলেই চলত।

৮ · Trusting Trust আর Haat-এর অনুবাদকের পরিকল্পনা

Ken Thompson তাঁর Turing Award বক্তৃতা “Reflections on Trusting Trust”-এ (১৯৮৩ সালে দেওয়া, ১৯৮৪ সালে Communications of the ACM-এ প্রকাশিত) bootstrapping-এর একটি অস্বস্তিকর দিক দেখান। একটি compiler binary-র ভেতরে এমন লুকানো আচরণ থাকতে পারে, যা নিজের source-এ নেই, কিন্তু compiler নিজেকে compile করার সময় নতুন binary-তে আবার ঢুকিয়ে দেয়। তখন source কোড পড়ে সব ঠিক দেখবেন, অথচ binary ঠিক নয়। তাঁর মূল শিক্ষা: যে কোড আপনি নিজে পুরোপুরি তৈরি করেননি, শুধু source পড়ে তাকে পুরো বিশ্বাস করা যায় না। (এখানে বিষয়টি প্রতিরক্ষার দিক থেকে দেখছি: কীভাবে ধরা যায় আর ঠেকানো যায়।)

প্রতিরক্ষার প্রধান উপায়গুলো:

  • Diverse double-compiling: David A. Wheeler (২০০৫ সালের গবেষণাপত্র, ২০০৯ সালের PhD গবেষণা) দেখান, compiler-এর source-কে একটি সম্পূর্ণ আলাদা, স্বাধীনভাবে তৈরি compiler দিয়ে দুই ধাপে compile করে ফল মূল binary-র সঙ্গে byte ধরে মেলালে এই ধরনের লুকানো আচরণ ধরা যায়, যদি দুটি compiler একই চালাকি না রাখে। এটি stepper-এর stage2 আর stage3 মেলানোর মতোই, শুধু শুরুর compiler আলাদা।
  • Reproducible build: একই source থেকে যে কেউ build করলে byte ধরে একই ফল পাবেন, তাই কারও binary আলাদা হলে ধরা পড়ে।
  • ছোট থেকে bootstrapping: হাতে যাচাই করা যায় এমন খুব ছোট একটি শুরু থেকে ধাপে ধাপে বড় compiler তৈরি করা, যাতে কোনো অজানা binary-র ওপর ভরসা না করতে হয়।

Software supply chain-এর বাকি দিক (dependency, signing, SBOM) Cybersecurity কোর্সের পর্ব ৪৮-এ (Supply chain নিরাপত্তা) আছে।

এই কোর্সে Haat-এর কোন কোন অনুবাদক বানাবেন

এখন পুরো কোর্সের পথটি অনুবাদকের ভাষায় পড়া যায়। একই Haat-এর জন্য আপনি কয়েকটি আলাদা বাস্তবায়ন বানাবেন, আর প্রতিটির আউটপুট একে অপরের সঙ্গে মেলাবেন (differential testing), কারণ সংজ্ঞা ৪.১ অনুযায়ী সবার উত্তর এক হতে বাধ্য:

অনুবাদকধরনকোন পর্বে
Lexer, parser, type checkerসবার front end (static error এখানেই)পর্ব ৪৬–৫২
Tree-walking interpreterAST সরাসরি চালানোপর্ব ৫৬–৫৭
Bytecode compiler + stack VMমিশ্র পথ, CPython-এর মতোপর্ব ৫৮–৫৯
JIT-এর ধারণাprofiling, deoptimizationপর্ব ৬১
IR আর optimizercompiler-এর middle endপর্ব ৬২–৬৮
RISC-V আর WebAssembly back endAOT compilerপর্ব ৭২–৭৩

আরও গভীরে: ১৯৭১ সালে Yoshihiko Futamura দেখান, একটি interpreter আর একটি program-কে partial evaluator (যে program ইনপুটের একটি অংশ আগে জেনে program-কে বিশেষ রূপ দেয়) দিয়ে একসঙ্গে বিশেষায়িত করলে compile করা program পাওয়া যায়; partial evaluator-কে interpreter-এর ওপর চালালে পাওয়া যায় একটি compiler. এগুলো “Futamura projections” নামে পরিচিত। এই ধারণা আজ বাস্তবে ব্যবহার হয়: GraalVM-এর Truffle framework-এ ভাষা-নির্মাতা শুধু একটি AST interpreter লেখেন, আর partial evaluation দিয়ে তা থেকে JIT-এর কোড বের হয়; PyPy-র RPython toolchain-ও interpreter থেকে tracing JIT তৈরি করে। আর সংজ্ঞা ৪.১-এর সঠিকতা যন্ত্রে প্রমাণ করা C compiler CompCert নিয়ে আসবে পর্ব ৪৪-এ।

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:

  • Compiler আর interpreter-এর পার্থক্য কী? Compiler শুধু program নিয়ে আরেকটি program বানায়, ইনপুট দেখে না; interpreter program আর ইনপুট একসঙ্গে নিয়ে সরাসরি আউটপুট দেয়।
  • Python কি compiled না interpreted? ভাষার নয়, বাস্তবায়নের প্রশ্ন; CPython bytecode-এ compile করে, তারপর interpret করে।
  • JIT-এর সুবিধা আর অসুবিধা? চলার profile দেখে optimize করে; কিন্তু warm-up লাগে, মেমরি আর জটিলতা বেশি।
  • Cross-compiler কী? যে compiler এক যন্ত্রে চলে কিন্তু আরেক যন্ত্রের কোড বানায়, যেমন x86 ল্যাপটপে RISC-V-এর কোড।
  • Bootstrapping আর T-diagram: [S → T]L-কে [L → M]M দিয়ে compile করলে [S → T]M.

৯ · AI-এর যুগে অনুবাদক বোঝা

“Python interpreted, তাই ধীর”, “Java interpreted ভাষা”, “JavaScript-এর কোনো compiler নেই”: এই ধরনের এক লাইনের সরল কথা AI assistant-এর উত্তরে খুব আসে, কারণ ইন্টারনেটে এগুলো লাখো বার লেখা হয়েছে। অনুবাদকের প্রশ্নে AI-এর বারবার দেখা ভুল:

AI-এর ভুলকীভাবে ধরবেন
ভাষাকে “compiled” বা “interpreted” বলা, যেন এটি ভাষার ধর্মনির্দিষ্ট বাস্তবায়নের নাম আর version জিজ্ঞেস করা (CPython 3.14, HotSpot, V8)
এক ভাষার নিয়ম আরেক ভাষায় চাপানো, যেমন / বা %-এর অর্থদুই ভাষায় ঋণাত্মক সংখ্যা দিয়ে আসলে চালানো
Transpiler-এর এমন কোড, যা সাধারণ ইনপুটে মেলে কিন্তু কোণের ইনপুটে নয়Interpreter বা reference-এর সঙ্গে অনেক ইনপুটে differential testing
বানানো compiler flag বা JIT-এর বানানো স্তর, যেমন “python -O JIT চালু করে”Tool-এর নিজের documentation আর --help দেখা, চালিয়ে দেখা
Bytecode বা assembly “দেখিয়ে দেওয়া”, যা আসল tool-এর সঙ্গে মেলে নাdis, javap -c, -S নিজে চালিয়ে মেলানো, version লিখে
“JIT সবসময় AOT-এর চেয়ে দ্রুত” বা উল্টোটা, সংখ্যা ছাড়ানিজের যন্ত্রে, নিজের কাজে মেপে দেখা, warm-up আলাদা করে
Bootstrapping বা Trusting Trust নিয়ে ভুল সাল, ভুল ব্যক্তিমূল প্রকাশনা (যেমন ১৯৮৪ সালে প্রকাশিত Thompson-এর বক্তৃতা) খুঁজে দেখা

AI-কে ভালোভাবে কাজে লাগানোর উপায়: সাধারণ কথা না চেয়ে নির্দিষ্ট বাস্তবায়ন, version আর যাচাইয়ের উপায় চাওয়া, তারপর নিজে চালিয়ে মেলানো।

আমি প্রোগ্রামিং ভাষা আর compiler শিখছি। Haat নামের একটি ছোট ভাষার expression (Int, + - * /, যেখানে / শূন্যের দিকে কাটে আর ৬৪-বিট overflow wrap করে) Python source-এ অনুবাদ করার একটি transpiler লিখে দাও, শুধু standard library দিয়ে। ১. Haat-এর / আর Python-এর // কোথায় আলাদা, উদাহরণসহ বলো; তোমার অনুবাদ কীভাবে অর্থ ঠিক রাখছে দেখাও। ২. একটি ছোট tree-walking interpreter-ও দাও, আর একটি test লেখো যা -50 থেকে 50 পর্যন্ত সব জোড়ায় দুটির ফল মেলায়। ৩. শূন্য দিয়ে ভাগ হলে দুই বাস্তবায়নই যেন একই error দেয়, তা দেখাও। ৪. তোমার দেওয়া কোনো তথ্য যদি নির্দিষ্ট Python version-এর ওপর নির্ভর করে, version লিখে দাও; নিশ্চিত না হলে বলো। ৫. কোনো আউটপুট অনুমান করে লিখবে না; কোন কোডের আউটপুট আমাকে চালিয়ে দেখতে হবে, তা আলাদা করে বলো।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১“Java একটি interpreted ভাষা” — কথাটি কতটা ঠিক?

কথাটি দুটি ভুল একসঙ্গে করে। প্রথম ভুল: “interpreted” বা “compiled” ভাষার ধর্ম নয়, বাস্তবায়নের। ভাষার specification বলে program-এর অর্থ কী; কোন অনুবাদক সেই অর্থ কীভাবে বাস্তবে আনবে, তা বাস্তবায়নের সিদ্ধান্ত। একই C-র জন্য interpreter আছে, আবার একই Python-এর জন্য JIT আছে।

দ্বিতীয় ভুল: Java-র সাধারণ পথেই একাধিক compiler আছে। javac একটি পুরোদস্তুর AOT compiler: source parse করে, type check করে, error দেয়, আর JVM bytecode লেখে। তারপর JVM (OpenJDK-র HotSpot) সেই bytecode প্রথমে interpret করে, কারণ সব method compile করতে গেলে শুরু ধীর হবে। কোন method কতবার চলছে আর কোন loop গরম, HotSpot তা গোনে; যথেষ্ট গরম হলে C1 compiler দ্রুত machine code বানায় আর আরও তথ্য জোগাড় করে, আরও গরম হলে C2 সেই তথ্য দিয়ে গভীর optimization করে (inlining, অপ্রয়োজনীয় পরীক্ষা বাদ)। এই ধাপে ধাপে ওঠা Java 8 থেকে HotSpot-এর ডিফল্ট আচরণ। ইতিহাসে Java-র প্রথম দিকের JVM (১৯৯০-এর দশকের মাঝামাঝি) মূলত interpreter ছিল, আর সেই সময়ের “Java ধীর” খ্যাতি থেকেই কথাটি টিকে আছে।

আরও পথ আছে: GraalVM-এর Native Image পুরো Java program-কে আগেই একটি native executable-এ AOT compile করে, যেখানে চলার সময় কোনো bytecode interpreter নেই। Android-এর ART-ও বিভিন্ন version-এ AOT আর JIT মিলিয়ে ব্যবহার করেছে। অর্থাৎ একই Java program চার রকম পথে চলতে পারে।

পরীক্ষার খাতায় তাই সঠিক উত্তর: “Java source প্রথমে javac দিয়ে bytecode-এ compile হয়; JVM bytecode interpret করে আর গরম অংশ JIT দিয়ে machine code-এ compile করে।”

মূল উপলব্ধি: ভাষা একটি চুক্তি, বাস্তবায়ন সেই চুক্তি মানার একটি উপায়। “কোন ভাষা?” জিজ্ঞেস না করে জিজ্ঞেস করুন “কোন বাস্তবায়ন, কোন version, কোন পথে?”

প্র ০২Interpreter কি সবসময় compiler-এর চেয়ে ধীর? তাহলে কেউ interpreter বানায় কেন?

একই কাজের জন্য একটি সরল interpreter সাধারণত AOT compile করা কোডের চেয়ে ধীর, কারণ প্রতিটি ধাপে সে বাড়তি কাজ করে: node-এর ধরন দেখা, bytecode পড়া, পরের নির্দেশ খোঁজা, stack-এ মান তোলা-নামানো। অংশ ৩-এর Clang পুরো price(2, 520) build-এর সময়েই 936-এ নামিয়ে ফেলেছে; অংশ ৫-এর CPython প্রতিবার ১৩টি bytecode নির্দেশ চালায়। কতগুণ ধীর, তা কাজ, ভাষা আর যন্ত্রের ওপর নির্ভর করে; কোনো একটি সংখ্যা সব ক্ষেত্রে খাটে না।

কিন্তু “সবসময়” শব্দটি ভুল। প্রথমত, শুরু হওয়ার সময়: ছোট script একবার চলবে, তাতে বড় compile-এর খরচ উল্টো লোকসান। দ্বিতীয়ত, ভারী কাজ প্রায়ই interpreter-এর বাইরে হয়: Python-এর NumPy-র মূল হিসাব C-তে লেখা, তাই Python-এর লুপ ধীর হলেও বড় matrix-এর গুণ দ্রুত। তৃতীয়ত, JIT: interpreter দিয়ে শুরু করা ব্যবস্থা চলার তথ্য দেখে কোড বানায়, যা AOT compiler আগে জানতে পারে না; কিছু কাজে এতে AOT-কেও ছাড়িয়ে যাওয়া যায়।

তাহলে interpreter কেন বানানো হয়? (১) বানানো সহজ: Haat-এর tree-walking interpreter কয়েকশো লাইনে হয়, পূর্ণ native compiler-এ অনেক বেশি লাগে। (২) Portability: C-তে লেখা একটি interpreter যেকোনো যন্ত্রে compile করলেই ভাষাটি সেখানে চলে; Pascal-P-র P-code কৌশল এভাবেই ১৯৭০-এর দশকে Pascal ছড়িয়েছিল। (৩) Debugging আর ইন্টারঅ্যাকটিভ ব্যবহার: REPL-এ একটি লাইন লিখে সঙ্গে সঙ্গে ফল দেখা। (৪) Dynamic ফিচার: eval, চলার সময় নতুন কোড লোড করা। (৫) ভাষার “সংজ্ঞা” হিসেবে: একটি সরল interpreter প্রায়ই reference বাস্তবায়ন, যার সঙ্গে দ্রুত compiler-এর ফল মেলানো হয়, যেমন এই কোর্সে।

মূল উপলব্ধি: গতি অনেকগুলো লক্ষ্যের একটি মাত্র। সরলতা, portability, শুরু হওয়ার সময় আর সঠিকতা যাচাই, এগুলোর হিসাবে interpreter প্রায়ই জেতে; আর গরম জায়গায় JIT দুই পক্ষের সুবিধা মেলাতে চায়।

প্র ০৩যদি compiler লিখতে compiler লাগে, তাহলে প্রথম compiler এল কীভাবে, আর আজকের ভাষাগুলো কীভাবে self-hosting হলো?

শিকলের শুরুতে মানুষ। প্রথম দিকের কম্পিউটারে program লেখা হতো সরাসরি machine code-এ, সুইচ বা punched card দিয়ে। তারপর এল assembler: একটি ছোট program, যা ADD-এর মতো নাম পড়ে সংখ্যার নির্দেশ লেখে; প্রথম assembler-টি হাতে machine code-এ লেখা। এরপর assembly-তে লেখা হলো উচ্চ-স্তরের ভাষার compiler: John Backus-এর দলের FORTRAN compiler ১৯৫৭ সালে IBM 704-এর জন্য প্রকাশিত হয়, assembly-তে লেখা, আর তার optimization-এর মান সেই সময়ের মানুষকে অবাক করেছিল।

Self-hosting-এর প্রথম দিকের একটি বিখ্যাত গল্প LISP-এর। John McCarthy LISP-এর eval function কাগজে LISP-এই লেখেন; Steve Russell সেটিকে হাতে IBM 704-এর machine code-এ অনুবাদ করে প্রথম LISP interpreter বানান (১৯৫০-এর দশকের শেষ দিকে)। ১৯৬২ সালে Tim Hart আর Mike Levin LISP-এ একটি LISP compiler লেখেন, সেটিকে interpreter-এ চালিয়ে নিজেকেই compile করান; এটিকে প্রায়ই প্রথম self-hosting compiler-গুলোর একটি বলা হয়।

আধুনিক উদাহরণ: Go-র compiler প্রথমে C-তে লেখা ছিল; Go 1.5 (২০১৫)-এ দলটি একটি যন্ত্রিক অনুবাদকের সাহায্যে C থেকে Go-তে কোড সরিয়ে নেয়, তারপর হাতে পরিষ্কার করে। Rust-এর প্রথম compiler OCaml-এ লেখা ছিল; ২০১১ সালের দিকে rustc নিজের ভাষায় চলে আসে। TypeScript-এর compiler TypeScript-এ লেখা, যদিও ২০২৫ সালে দলটি গতির জন্য একটি native সংস্করণ Go-তে লেখার কাজ ঘোষণা করেছে: self-hosting সবসময় শেষ লক্ষ্য নয়।

Self-hosting-এর লাভ: compiler-এর লেখকরাই ভাষার সবচেয়ে বড় ব্যবহারকারী হন, তাই ভাষার দুর্বলতা দ্রুত চোখে পড়ে; আর compiler নিজেই একটি বড়, কঠিন test. খরচ: নতুন যন্ত্রে ভাষা আনতে আগের একটি binary বা cross-compiler লাগে, আর অংশ ৮-এর বিশ্বাসের প্রশ্ন ওঠে।

মূল উপলব্ধি: প্রতিটি compiler-এর পেছনে একটি বংশতালিকা আছে, যার শুরু মানুষের হাতে লেখা machine code-এ। T-diagram সেই বংশতালিকা লেখার ভাষা।

প্র ০৪Thompson-এর “Trusting Trust” সমস্যা থাকলে আমরা কোনো compiler-কে কীভাবে বিশ্বাস করি?

Thompson-এর যুক্তির সারকথা: compiler binary নিজেই একটি program, আর সে যে program বানায় তার আচরণ ঠিক করে সে নিজে। যদি binary-তে এমন কিছু থাকে যা source-এ নেই, আর binary নিজেকে compile করার সময় সেটি আবার ঢুকিয়ে দেয়, তাহলে source পড়ে, এমনকি source থেকে নতুন করে build করেও, সমস্যাটি চোখে পড়বে না। ১৯৮৪ সালে প্রকাশিত তাঁর বক্তৃতার শিক্ষা ছিল নৈতিক আর ব্যবহারিক দুটোই: যে কোড আপনি নিজে তৈরি করেননি, তাকে শুধু source-এর ভিত্তিতে পুরো বিশ্বাস করা যায় না।

তবু বাস্তবে আমরা পুরো অন্ধকারে নেই। প্রথম অস্ত্র diverse double-compiling (David A. Wheeler, ২০০৫-এর গবেষণাপত্র আর ২০০৯-এর PhD): সন্দেহের compiler-এর source একটি সম্পূর্ণ আলাদা, স্বাধীনভাবে তৈরি compiler দিয়ে compile করুন, তারপর সেই ফল দিয়ে আবার একই source compile করুন। ফল যদি সন্দেহের binary-র সঙ্গে byte ধরে মেলে, তাহলে binary সত্যিই তার source-এর প্রতিনিধি, যদি না দুটি compiler একই চালাকি একইভাবে রাখে। এটি স্বাধীনতার ওপর ভরসা সরিয়ে দেয়, পুরো ভরসা দূর করে না।

দ্বিতীয় অস্ত্র reproducible build: Debian-এর মতো প্রকল্প চেষ্টা করে যেন একই source থেকে যে কেউ byte ধরে একই package পায়; তখন একজন বিতরণকারীর binary-তে গড়বড় থাকলে অন্যদের build-এর সঙ্গে মিলবে না। তৃতীয়: খুব ছোট, হাতে পড়ে যাচাই করা যায় এমন শুরু থেকে bootstrapping-এর প্রকল্প, যাতে কোনো পুরোনো অজানা binary-র ওপর নির্ভর করতে না হয়। চতুর্থ: verified compiler (যেমন CompCert), যেখানে compiler-এর সঠিকতা গাণিতিকভাবে প্রমাণ করা, যদিও প্রমাণ-যাচাইকারী আর যন্ত্রকে তখনো বিশ্বাস করতে হয়।

বাস্তবের ঝুঁকি শুধু compiler-এ নয়: build script, dependency আর package registry-ও একই শিকলের অংশ। ২০২৪ সালে xz নামের একটি compression library-র build প্রক্রিয়ায় লুকানো ক্ষতিকর কোড ধরা পড়ার ঘটনা দেখায়, source-এর বাইরের ধাপগুলোও সমান গুরুত্বপূর্ণ।

মূল উপলব্ধি: বিশ্বাস কখনো পুরোপুরি শূন্য থেকে আসে না; প্রকৌশলের কাজ হলো ভরসার ভিত্তি যতটা সম্ভব ছোট, স্বাধীন আর যাচাইযোগ্য করা।

প্র ০৫Transpiler আর compiler-এর মধ্যে কি সত্যিকারের কোনো পার্থক্য আছে, নাকি শুধু নামের?

তত্ত্বে পার্থক্য নেই: সংজ্ঞা ৪.১-এর compiler-এর target যেকোনো ভাষা হতে পারে। “Transpiler” নামটি ব্যবহারিক: যখন target-টি মানুষের পড়ার মতো একটি উচ্চ-স্তরের ভাষা, আর লক্ষ্য হলো অন্য একটি ব্যবস্থার ওপর ভর করা। ইতিহাসে এটি পুরোনো কৌশল: Bjarne Stroustrup-এর Cfront ১৯৮০-এর দশকে C++ থেকে C লিখত, যাতে যেকোনো C compiler আছে এমন যন্ত্রে C++ চলে। Nim-এর মতো আধুনিক ভাষাও C-তে compile করে। TypeScript (২০১২) JavaScript-এ নামে, যাতে প্রতিটি browser-এ চলে।

তবে কয়েকটি ব্যবহারিক পার্থক্য সত্যিই গুরুত্বপূর্ণ। (১) অর্থের ফাঁক বেশি বিপজ্জনক: machine code-এর নিয়ম সরল আর স্পষ্ট, কিন্তু উচ্চ-স্তরের দুই ভাষার “একই রকম” operator-এর অর্থ আলাদা হতে পারে, যেমন অংশ ৪-এর / বনাম //. C-তে target করলে আরও সাবধান হতে হয়, কারণ C-র undefined behavior আপনার ভাষার নিয়ম ভেঙে দিতে পারে: Haat-এর wrap-করা যোগকে সরাসরি C-র signed int-এর +-এ অনুবাদ করলে overflow-এ C17-এ আচরণ undefined, তাই unsigned গণনা বা বিশেষ পরীক্ষা লাগে। (২) Debugging: error-এর লাইন target-এর, source-এর নয়; তাই source map বা #line-এর মতো নির্দেশ লাগে। (৩) কাজের ভাগ: transpiler সাধারণত register allocation বা instruction selection করে না, target-এর compiler সেটি করে; তাই একটি ছোট দল দ্রুত নতুন ভাষা দাঁড় করাতে পারে।

উল্টো দিকে কিছু “compiler” আসলে transpiler-এর শিকল: Emscripten C/C++ থেকে WebAssembly বানায় LLVM-এর মাধ্যমে, আর এই কোর্সের Haat-ও শেষে Wasm-এ নামবে। নাম যা-ই হোক, পরীক্ষার পদ্ধতি একই: reference-এর সঙ্গে differential testing, আর কোণের ইনপুট।

মূল উপলব্ধি: “Transpiler” একটি compiler-ই, যার target উঁচু স্তরের। নাম বদলালেও অর্থ-রক্ষার দায় এতটুকু কমে না, বরং দুই ভাষার নিয়ম জানার দায় বাড়ে।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। কোডের প্রতিটি আউটপুট সত্যিকারের Python 3.14-এ চালিয়ে মেলানো।

  1. বাস্তবায়ন — % যোগ করুন: অংশ ২-এর ev আর gen-এ Haat-এর % যোগ করুন। Haat-এ %-এর চিহ্ন ভাজ্যের (dividend) মতো, C-র মতো; শূন্য দিয়ে হলে runtime error division by zero. তারপর লিখুন -7 % 2, 7 % -2 Haat-এ কত, আর Python-এ কত।

    সংজ্ঞা থেকে: a % b = a − b × (a / b), যেখানে / শূন্যের দিকে কাটা ভাগ। তাই একটি সাহায্যকারী function যথেষ্ট:

    def hmod(a, b):
        if b == 0: raise ZeroDivisionError("division by zero")
        return a - b * hdiv(a, b)

    ev-এ লিখুন if e.op == "%": return hmod(a, b), আর gen-এ "/"-এর মতো "%"-এর জন্য f"hmod({l}, {r})". Python 3.14-এ চালানো ফল:

    7 2 Haat %: 1  Python %: 1
    -7 2 Haat %: -1  Python %: 1
    7 -2 Haat %: 1  Python %: -1
    -7 -2 Haat %: -1  Python %: -1

    অর্থাৎ -7 % 2 Haat-এ −1 কিন্তু Python-এ 1; 7 % -2 Haat-এ 1 কিন্তু Python-এ −1. Python-এর % ভাজকের চিহ্ন নেয়, কারণ সে floor division-এর সঙ্গী। তাই %-কে সরাসরি %-এ অনুবাদ করাও অংশ ৪-এর মতো একটি নীরব ভুল হতো।

  2. ভুল খুঁজুন: একজন বললেন, “hdiv-এর দরকার নেই; Haat-এর x / y-কে Python-এ int(x / y) লিখলেই শূন্যের দিকে কাটা হয়।” ঋণাত্মক সংখ্যায় দাবিটি ঠিক। তাহলে ভুলটি কোথায়? একটি পাল্টা উদাহরণ দিন।

    Python-এ x / y সবসময় একটি float দেয়, আর float (IEEE 754 double)-এ পূর্ণসংখ্যা নিখুঁতভাবে ধরা যায় শুধু 253 পর্যন্ত। Haat-এর Int ৬৪-বিট, তাই বড় মানে float-এ যাওয়ার সময়ই মান বদলে যায়। Python 3.14-এ চালানো ফল:

    int(x / 1) = 9007199254740992  hdiv(x, 1) = 9007199254740993  x = 9007199254740993

    এখানে x = 253 + 1. এমনকি 1 দিয়ে ভাগেও উত্তর ভুল! আরেকটি পরীক্ষা: x = 1018 + 7, y = 7-এ int(x / 7) দেয় 142857142857142864, অথচ সঠিক উত্তর 142857142857142858. শিক্ষা: অনুবাদে মধ্যবর্তী ধরন (এখানে float) যেন উৎস-ভাষার মানের পরিসর ধরে রাখতে পারে, তা দেখতে হয়; পূর্ণসংখ্যার ভাগ পূর্ণসংখ্যাতেই করুন।

  3. T-diagram হিসাব: আপনার কাছে আছে (ক) x86-64 ল্যাপটপে চলা একটি Python interpreter, (খ) Python-এ লেখা [Haat → Wasm]Python, (গ) Haat-এ লেখা [Haat → Wasm]Haat. ধাপে ধাপে বলুন: (১) (খ) দিয়ে (গ) compile করলে কী পাবেন, আর সেটি কোথায় চলে? (২) সেই ফল দিয়ে আবার (গ) compile করলে কী পাবেন? (৩) Python ছাড়া Haat → Wasm compiler চালাতে কী লাগবে?

    (১) T-compose নিয়মে S = Haat, T = Wasm, L = Haat, আর (খ) একটি [Haat → Wasm], অর্থাৎ L → M যেখানে M = Wasm. ফল [Haat → Wasm]Wasm: একটি Wasm module, যা Haat পড়ে Wasm লেখে। (খ) নিজে চলে Python interpreter-এর ওপর, ল্যাপটপে।

    (২) ধাপ ১-এর ফল একটি Wasm engine-এ (browser বা wasmtime-এর মতো runtime) চালিয়ে আবার (গ) compile করলে পাবেন আবারও [Haat → Wasm]Wasm, কিন্তু এবার এর কোড বানিয়েছে Haat-এ লেখা যুক্তি। এটি bootstrapping-এর stage2; আরও একবার করলে stage3, আর stage2 = stage3 হলে fixpoint.

    (৩) শুধু একটি Wasm engine. যে যন্ত্রে browser বা অন্য Wasm runtime আছে, সেখানেই এই compiler চলবে: Wasm-কে target করলে compiler-টি নিজেই portable হয়ে যায়।

  4. আউটপুট অনুমান করুন: (ক) Haat program let a = 10; if a > 100 { print(a / 0); } print(a); কী ছাপবে? (খ) একই program-এ a / 0-এর জায়গায় a + true লিখলে কী হবে? (গ) Python 3.14-এ a = 10, if a > 100: print(a + "x"), print(a) কী ছাপবে? প্রতিটির কারণ বলুন।

    (ক) শুধু 10. Haat-এ শূন্য দিয়ে ভাগ একটি runtime error, যা ঘটে শুধু সেই expression চললে; a > 100 মিথ্যা, তাই শাখাটি চলেই না। এটি interpreter আর compiler দুই বাস্তবায়নেই এক।

    (খ) কিছুই ছাপা হবে না। Haat statically typed; type checker চালানোর আগেই +-এর দুই পাশে Int আর Bool দেখে type mismatch error দেয় (line:col: error: … আকারে), আর program আদৌ চলে না, শাখাটি চলত কি না তাতে কিছু যায় আসে না। কোর্সের Haat reference বাস্তবায়ন (interpreter আর VM দুটিই) ঠিক এই বার্তা দেয়: 2:24: error: type mismatch: expected Int, found Bool; আর (ক)-তে দুটিই ছাপে 10.

    (গ) 10. CPython আগে পুরো ফাইল bytecode-এ compile করে ঠিকই, কিন্তু Python dynamically typed, তাই int আর str-এর যোগের ভুল দেখা হয় শুধু সেই লাইন চললে। Python 3.14-এ চালানো ফলও 10. শিক্ষা: ভুল কখন ধরা পড়ে, তা ঠিক করে ভাষার type নিয়ম, “compiled না interpreted” নয়।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমCPython একটি .py ফাইল চালানোর সময় ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Source লেখা পড়ে token-এ ভাঙা (tokenize)
  2. Token থেকে AST বানানো (parse)
  3. AST থেকে bytecode-সহ code object বানানো (compile)
  4. Evaluation loop একটি একটি করে bytecode নির্দেশ চালায়
  5. Function-এর মান ফেরত দেয় (RETURN_VALUE)

Compiler আর interpreter-এর মৌলিক পার্থক্য কোনটি?

  • Compiler parse করে, interpreter করে না
  • Compiler ইনপুট না দেখে একটি নতুন program বানায়; interpreter program আর ইনপুট একসঙ্গে নিয়ে আউটপুট দেয়
  • Compiler-এর target সবসময় machine code
  • Interpreter কখনো চালানোর আগে কোনো ভুল ধরতে পারে না

CPython (Python-এর প্রধান বাস্তবায়ন) একটি function চালানোর আগে কী করে?

  • পুরো ফাইল machine code-এ compile করে
  • কিছুই না, প্রতিটি লাইন source থেকে সরাসরি পড়ে চালায়
  • Source-কে AST হয়ে bytecode-এ compile করে, তারপর একটি VM সেই bytecode interpret করে
  • Source-কে JVM bytecode-এ অনুবাদ করে

একটি JIT compiler একটি AOT compiler-এর চেয়ে কোন সুবিধা পেতে পারে?

  • আসল চলার তথ্য (profile) দেখে সেই অনুযায়ী optimize করা
  • শুরু থেকেই সর্বোচ্চ গতি, কোনো warm-up ছাড়া
  • চলার সময় কম মেমরি
  • প্রতিবার হুবহু একই machine code, তাই সময়ের পূর্বানুমান সহজ

একটি transpiler Haat-এর a / b-কে (Haat-এ / শূন্যের দিকে কাটে) Python 3-এর a // b-এ অনুবাদ করে। কোন ইনপুটে এই অনুবাদ ভুল ফল দেয়?

  • a = 7, b = 2
  • a = −30, b = 10
  • a = 0, b = 5
  • a = −7, b = 2

T-diagram-এর নোটেশনে [S → T]L মানে L ভাষায় লেখা একটি S → T compiler. [Haat → RV]Haat-কে যন্ত্র RV-তে চলা [Haat → RV]RV দিয়ে compile করলে কী পাবেন?

  • [RV → Haat]RV
  • [Haat → RV]RV
  • [Haat → RV]Haat, অপরিবর্তিত
  • একটি Haat interpreter

Ken Thompson-এর “Reflections on Trusting Trust” (১৯৮৪) সমস্যার বিরুদ্ধে কোন কৌশল সরাসরি তৈরি?

  • Compiler-এর source কোড মনোযোগ দিয়ে পড়া
  • একই compiler দিয়ে নিজেকে বারবার compile করা
  • Diverse double-compiling: স্বাধীন আরেকটি compiler দিয়ে compile করে ফল byte ধরে মেলানো
  • Optimization বন্ধ করে (-O0) compile করা

শব্দকোষ

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

মনে রাখুন

  1. Compiler ইনপুট না দেখে নতুন program বানায়; interpreter program আর ইনপুট একসঙ্গে নিয়ে চালায়। দুজনেরই শর্ত: ⟦q⟧T(x) = ⟦p⟧S(x), অর্থ বদলানো চলবে না।
  2. Toolchain-এ আরও অনুবাদক আছে: preprocessor, assembler, linker, loader আর transpiler; transpiler-এ দুই ভাষার নিয়মের পার্থক্যই সবচেয়ে বড় ফাঁদ।
  3. “Compiled/interpreted” বাস্তবায়নের ধর্ম: CPython bytecode + VM, Java javac + JVM-এর interpreter আর tiered JIT, JavaScript engine-এ interpreter আর কয়েক স্তরের JIT.
  4. AOT: দ্রুত শুরু, পূর্বানুমেয়; JIT: চলার তথ্য দিয়ে optimize, কিন্তু warm-up আর মেমরি লাগে। ভুল কখন ধরা পড়ে, তা ঠিক করে ভাষার type নিয়ম।
  5. T-compose: [S → T]L আর [L → M]M থেকে [S → T]M; bootstrapping-এ stage2 = stage3 যাচাই, আর Trusting Trust-এর জবাবে diverse double-compiling ও reproducible build.

পরের পর্বে: আজ অনুবাদকদের বাইরে থেকে দেখলেন। পর্ব ০৫-এ একটি compiler-এর ভেতরে ঢুকবেন: lexer থেকে executable পর্যন্ত প্রতিটি ধাপ, তাদের মাঝের ডেটা, আর সত্যিকারের GCC ও Clang-এর প্রতিটি ধাপের ফল।

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

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