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

নাম, variable আর binding — binding time কখন ঠিক হয়

Names, Variables and Bindings — When Is Each Binding Fixed?

Taught in Bangla, this lesson defines names and variables, with a variable's six attributes: name, address, value, type, lifetime and scope. It sorts binding times from language design to run time, tracing when each part of Haat's let rate = 10; is bound using real bytecode. CPython's symtable and dis show names bound as local, global or free, environment and store formalise aliasing and rebinding, and JavaScript const is tested. It ends with overloading, keywords and a mini name resolver in Python.

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

  • নাম, identifier আর variable-এর পার্থক্য, আর variable-এর ছয়টি বৈশিষ্ট্য আলাদা করে চেনা
  • Binding time-এর ছয়টি ধাপ C, Python, Java আর Haat-এর উদাহরণে চেনা, আর static ও dynamic binding আলাদা করা
  • Environment আর store দিয়ে binding-কে গাণিতিকভাবে লেখা, আর তা দিয়ে aliasing ও rebinding ব্যাখ্যা করা
  • CPython-এর symtable আর dis দিয়ে দেখা, compiler কোন নামকে local, global বা free হিসেবে বাঁধে
  • Overloading, keyword, reserved word আর predeclared নামের পার্থক্য, আর Haat-এর নাম-বাঁধার একটি ছোট resolver নিজে চালানো

১ · নাম: program-এর জগতে ডাকনাম

মডিউল ২-এ দেখেছেন, একই কাজ আলাদা ধাঁচে (paradigm) লেখা যায়। এবার মডিউল ৩-এ আমরা একটি খুব মৌলিক প্রশ্নে ঢুকব, যা সব ধাঁচের নিচে আছে: program-এ একটি নাম লিখলে ভাষা কীভাবে বোঝে সেটি কোন জিনিসকে বোঝায়? এই পর্বে নাম আর binding, পরের পর্বগুলোতে scope (পর্ব ১৫), lifetime (পর্ব ১৬), closure (পর্ব ১৭), module (পর্ব ১৮) আর evaluation strategy (পর্ব ১৯)।

একটি পাড়ার কথা ভাবুন। “বাবু” নামটি বললে কাকে বোঝায়? বাড়িতে বললে ছোট ভাইকে, অফিসে বললে পিয়ন বাবু ভাইকে, আর ক্রিকেট মাঠে বললে হয়তো পাশের বাড়ির ছেলেটিকে। নামটি একই, কিন্তু কোথায় বলছেন আর কখন বলছেন, তার ওপর নির্ভর করে নামটি কার সঙ্গে জোড়া। আবার একই মানুষের দুটি নাম থাকতে পারে: বাড়িতে “বাবু”, অফিসে “রফিক সাহেব”। প্রোগ্রামিং ভাষায় এই তিনটি ঘটনারই আনুষ্ঠানিক নাম আছে: binding, scope আর aliasing.

প্রথমে শব্দগুলো ঠিক করে নিই। Program-এর লেখায় একটি নাম যে অক্ষরের সারি দিয়ে লেখা হয়, তাকে বলে identifier, যেমন total, discount, rate. Lexer এই সারিকে একটি token বানায় (Haat-এ IDENT). Identifier নিজে শুধু লেখা; সে কোনো জিনিস নয়। তাকে অর্থ দেয় binding: “এই জায়গায় rate মানে ওই ঘোষণাটি, যার মান 10”.

Identifier দেখতে কেমন হতে পারে, তা প্রতিটি ভাষার নকশার সিদ্ধান্ত। কয়েকটি উদাহরণ:

ভাষাকোন অক্ষর চলেবড়-ছোট হাতের অক্ষর
Haat v1শুধু ASCII: [A-Za-z_][A-Za-z0-9_]*; বাংলা শুধু comment আর string-এ (reference-এর নকশা-সিদ্ধান্ত ৪)আলাদা: Rate আর rate দুটি নাম
C17অক্ষর, অঙ্ক, _; অঙ্ক দিয়ে শুরু নয়। প্রথম ৬৩টি অক্ষর অন্তত আলাদা ধরা হয় (internal নামে, standard-এর ন্যূনতম সীমা)আলাদা
Python 3Unicode অক্ষরও চলে (PEP 3131), তাই দাম = 10 বৈধ Pythonআলাদা
FORTRAN (১৯৫৭)শুরুর FORTRAN-এ সর্বোচ্চ ৬টি অক্ষরশুধু বড় হাতের অক্ষর ছিল
SQL, Pascalঅক্ষর, অঙ্ক, _সাধারণত এক ধরা হয়: Total = TOTAL

এই ছোট টেবিলেও একটি আপস দেখা যায় (পর্ব ০৬-এর ভাষায় readability বনাম writability). লম্বা আর অর্থপূর্ণ নাম পড়তে সহজ; বড়-ছোট অক্ষর আলাদা হলে Rate আর rate দুটি আলাদা জিনিস হতে পারে, যা পড়ার সময় বিভ্রান্তি আনে। Haat ASCII বেছেছে একটি বাস্তব কারণে: বাংলা যুক্তাক্ষর একাধিক Unicode code point দিয়ে তৈরি, আর দেখতে একই রকম দুটি নাম ভেতরে আলাদা হতে পারে। পর্ব ২১-এ (String আর Unicode) এই সমস্যা বিস্তারে আসবে।

২ · Variable-এর ছয়টি বৈশিষ্ট্য

সবচেয়ে বেশি ব্যবহৃত নাম-ধরা জিনিস হলো variable. পর্ব ০৭-এ (Imperative আর procedural programming) variable-কে বলেছিলাম “মেমরির একটি নাম দেওয়া ঘর”। কথাটি ঠিক, কিন্তু অসম্পূর্ণ। পাঠ্যবইয়ে (যেমন Robert Sebesta-র “Concepts of Programming Languages”) variable-কে ছয়টি বৈশিষ্ট্যের একটি গুচ্ছ হিসেবে দেখা হয়। Haat-এর discount function-এর parameter total দিয়ে ছবিতে দেখুন:

ছবি ১৪.১ — একটি variable, ছয়টি বৈশিষ্ট্য, আর প্রতিটি কখন বাঁধা হয়

Haat-এ fn discount(total: Int) -> Int, ডাকা হয়েছে discount(1040) দিয়ে। নীল বাক্স চালানোর আগে (static), হলুদ বাক্স চলার সময় (dynamic) ঠিক হয়।

Six attributes of the variable total: name, type and scope fixed before running; address, value and lifetime fixed while running variable: total ১ · নাম total লেখার সময়ই ঠিক ২ · ঠিকানা frame-এর slot 0 প্রতি call-এ নতুন ৩ · type Int compile time (check) ৪ · মান 1040 run time, call-এর সময় ৫ · scope discount-এর body compile time (resolve) ৬ · lifetime call থেকে return run time চালানোর আগে চলার সময়
ছবি ১৪.১ — Haat-এ নাম, type আর scope চালানোর আগেই ঠিক, তাই নীল। ঠিকানা, মান আর lifetime প্রতিটি call-এ নতুন করে ঠিক হয়, তাই হলুদ। Reference বাস্তবায়নের dis-এ discount-এর total সত্যিই LOAD_LOCAL 0, অর্থাৎ frame-এর slot 0 (অংশ ৩-এ আসল listing).

ছয়টি বৈশিষ্ট্য একে একে:

  1. নাম (name): যে identifier দিয়ে variable-কে ডাকা হয়। সব variable-এর নাম থাকে না: Python-এ [520, 150][0] বা C-তে malloc দিয়ে পাওয়া ঘরের কোনো নাম নেই, শুধু পথ আছে।
  2. ঠিকানা (address): মেমরির যে ঘরে মান রাখা আছে। একই নামের ঠিকানা আলাদা সময়ে আলাদা হতে পারে: recursive function-এর প্রতিটি call-এ total নতুন frame-এ নতুন ঘর পায়। ঠিকানাকে প্রায়ই variable-এর l-value বলা হয়।
  3. মান (value): ঘরের ভেতরে এই মুহূর্তে যা আছে; এটি r-value. total = total + 1-এ বাঁ দিকে ঠিকানা লাগে, ডান দিকে মান (পর্ব ০৭-এর আলোচনা)।
  4. Type: কোন মানের সেট চলবে আর কোন operation বৈধ। Haat-এ Int মানে ৬৪-বিট signed পূর্ণসংখ্যা, যেখানে overflow হলে wrap হয়।
  5. Lifetime: চলার সময়ের যে অংশ জুড়ে ঘরটি আসলে বরাদ্দ থাকে। এটি পর্ব ১৬-এর মূল বিষয়।
  6. Scope: program-এর লেখার যে অংশে নামটি দিয়ে এই variable-কে পাওয়া যায়। এটি পর্ব ১৫-এর বিষয়।

Scope আর lifetime এক নয়: scope লেখার একটি এলাকা (কোডের কোন লাইনগুলো), lifetime সময়ের একটি এলাকা (কখন থেকে কখন)। C-তে function-এর ভেতরের static int count;-এর scope শুধু সেই function-এর body, কিন্তু lifetime পুরো program-এর চলার সময় জুড়ে (C কোর্সের পর্ব ১৪, স্কোপ ও স্টোরেজ ক্লাস)। উল্টো দিকে, closure একটি variable-কে তার function শেষ হওয়ার পরেও বাঁচিয়ে রাখে (পর্ব ১৭)।

সব ভাষায় ছয়টি বৈশিষ্ট্য একই চেহারায় থাকে না। Python-এ variable আসলে একটি নাম, যা একটি object-এর সঙ্গে বাঁধা; ঠিকানা, type আর মান সবই object-এর বৈশিষ্ট্য, নামের নয়। তাই Python-এ “variable-এর type” কথাটি একটু ঢিলা: নামের কোনো type নেই, যে object-এর সঙ্গে নামটি এই মুহূর্তে বাঁধা, তার type আছে। অংশ ৪-এ এটি সত্যিই চালিয়ে দেখবেন।

Binding-কে নিয়মে লেখা: environment আর store

নাম থেকে মান পর্যন্ত পথটি আসলে দুই ধাপের। প্রথম ধাপ: নাম থেকে ঘর। দ্বিতীয় ধাপ: ঘর থেকে মান। এই দুই ধাপ আলাদা রাখলে aliasing, assignment আর closure সব একই ভাষায় ব্যাখ্যা করা যায়, আর পর্ব ৪০-এর operational semantics-ও এভাবেই লেখা হয়।

সংজ্ঞা ১৪.১ — environment আর store

Environment ρ (গ্রিক অক্ষর “রো”) হলো নাম থেকে ঘরের (location) একটি টেবিল: ρ = {rate ↦ ℓ1, total ↦ ℓ7}. এখানে ℓ মানে একটি ঘরের পরিচয়, যেমন একটি ঠিকানা।

Store σ হলো ঘর থেকে মানের টেবিল: σ = {ℓ1 ↦ 10, ℓ7 ↦ 1040}.

নাম পড়া: x-এর মান = σ(ρ(x)). Assignment x = v store বদলায়: σ′ = σ[ρ(x) ↦ v], ρ একই থাকে। নতুন ঘোষণা (Haat-এর let/var) environment বদলায়: একটি নতুন ঘর ℓ নিয়ে ρ′ = ρ[x ↦ ℓ], আর σ′ = σ[ℓ ↦ v].

Aliasing: দুটি আলাদা নাম x ≠ y, কিন্তু ρ(x) = ρ(y).

একই নিয়ম inference rule আকারে (দাগের ওপরে শর্ত, নিচে সিদ্ধান্ত; ⟨x, ρ, σ⟩ ⇓ v পড়ুন “environment ρ আর store σ-তে x-এর মান v”):

ρ(x) = ℓσ(ℓ) = v(Var)
⟨x, ρ, σ⟩ ⇓ v
⟨e, ρ, σ⟩ ⇓ vρ(x) = ℓ(Assign)
⟨x = e;, ρ, σ⟩ ⇓ σ[ℓ ↦ v]
দাবি ১৪.২ — alias-এর মধ্য দিয়ে লেখা অন্য নামে দেখা যায়

যদি ρ(x) = ρ(y) হয়, তাহলে x = e; চালানোর পরে y পড়লে e-এর মান পাওয়া যায়।

প্রমাণ:

  1. ধরুন ⟨e, ρ, σ⟩ ⇓ v আর ρ(x) = ℓ. (Assign) নিয়মে নতুন store σ′ = σ[ℓ ↦ v].
  2. Assignment environment বদলায় না, তাই পরেও ρ(y) = ρ(x) = ℓ.
  3. (Var) নিয়মে y-এর মান = σ′(ρ(y)) = σ′(ℓ) = v, কারণ σ′-তে ℓ-এর ঘরে সদ্য v লেখা হয়েছে। ∎

উল্টো দিকটিও সমান গুরুত্বপূর্ণ: যদি ρ(x) ≠ ρ(y) হয়, তাহলে x = e; y-এর মান বদলায় না, কারণ σ′ শুধু ℓ = ρ(x)-এর ঘরে আলাদা। Optimizer ঠিক এই প্রশ্নটিই করে: “এই দুটি নাম কি একই ঘর হতে পারে?” উত্তর জানা না থাকলে নিরাপদ পথ নিতে হয় (পর্ব ০৭-এ C-র restrict-এর আলোচনা)।

৩ · Binding আর binding time

এবার মূল ধারণা। একটি binding হলো কোনো সত্তার (entity: নাম, variable, operator, function call) সঙ্গে তার একটি বৈশিষ্ট্যের জোড়া: নাম ↔ variable, variable ↔ type, variable ↔ ঘর, ঘর ↔ মান, + চিহ্ন ↔ “যোগ” operation. জোড়াটি যে মুহূর্তে তৈরি হয়, তার নাম binding time. প্রচলিত পাঠ্যবইয়ে ছয়টি সময় ধরা হয়:

Binding timeকী বাঁধা হয় (উদাহরণ)
ভাষা নকশার সময় (language design time)* মানে গুণ; Haat-এ let মানে বদলানো যায় না; Haat-এ Int মানে ৬৪-বিট; Python-এ / মানে সবসময় float-এর ভাগ
ভাষার বাস্তবায়নের সময় (implementation time)C-তে int কত বিট (standard বলে অন্তত ১৬ বিট, আজকের সাধারণ desktop compiler-এ ৩২ বিট); Haat reference-এ Int রাখা হয় Python int-এ, আর প্রতিটি ফল wrap() দিয়ে ৬৪ বিটে নামানো হয়
Compile timeC, Java আর Haat-এ variable-এর type; কোন নাম কোন ঘোষণাকে বোঝায় (name resolution); local variable-এর frame-এর ভেতরের slot বা offset; overload করা function-এর কোনটি ডাকা হবে
Link timeC-তে অন্য ফাইলে লেখা function বা extern variable-এর symbol কোন সংজ্ঞার সঙ্গে জোড়া (linker)
Load timeProgram মেমরিতে আনার সময় global আর static variable-এর আসল ঠিকানা (loader; position-independent executable-এ ঠিকানা load-এর সময় সরে)
Run timeVariable-এর মান; C-র local variable-এর আসল ঠিকানা (প্রতি call-এ stack-এর যেখানে frame পড়ে); Python-এ নামের সঙ্গে object আর তাই type; Java-তে override করা method-এর কোনটি চলবে

একটি ক্লাসিক উদাহরণে সবগুলো একসঙ্গে দেখা যায়। C-তে count = count + 5; লাইনটি ধরুন (এই ধরনের উদাহরণ Sebesta-র বইতেও আছে):

  • count-এর type: compile time (ঘোষণা int count; দেখে)।
  • count-এর সম্ভাব্য type-এর সেট (int, double, …): ভাষা নকশার সময়।
  • +-এর অর্থ: compile time, কারণ operand-এর type জানার পরেই বোঝা যায় এটি integer যোগ নাকি floating-point যোগ।
  • 5-এর ভেতরের রূপ (কত বিটে, কোন encoding-এ): বাস্তবায়নের সময়।
  • count-এর মান: run time, এই লাইন চলার মুহূর্তে।

এবার Haat-এ একই প্রশ্ন, আসল বাস্তবায়ন দিয়ে। নিচের program বাজারঘরের ১০% ছাড়ের হার একটি top-level নামে রাখে:

let rate = 10;
fn discount(total: Int) -> Int {
    let cut = total * rate / 100;
    return total - cut;
}
print(discount(1040));
~/haat $ python haat.py run rate.haat
936
~/haat $ python haat.py dis rate.haat
== <main> (arity 0, locals 0) ==
   0  MAKE_CLOSURE   0     ; <fn discount>
   1  DEFINE_GLOBAL  0     ; discount
   2  CONST          1     ; 10
   3  DEFINE_GLOBAL  1     ; rate
   4  LOAD_GLOBAL    0     ; discount
   5  CONST          2     ; 1040
   6  CALL           1
   7  PRINT
   8  CONST          3     ; ()
   9  RETURN

== discount (arity 1, locals 2) ==
   0  LOAD_LOCAL     0     ; total
   1  LOAD_GLOBAL    1     ; rate
   2  MUL
   3  CONST          0     ; 100
   4  DIV
   5  STORE_LOCAL    1     ; cut
   6  LOAD_LOCAL     0     ; total
   7  LOAD_LOCAL     1     ; cut
   8  SUB
   9  RETURN

সত্যিকারের run, কোর্সের Haat reference বাস্তবায়নে (CPython 3.14.4). 1040 × 10 / 100 = 104, আর 1040 − 104 = 936. Listing-টি ভালো করে দেখুন: rate নামটি bytecode-এ আর নেই, আছে শুধু “global ঘর 1”; total হলো “local ঘর 0”, cut হলো “local ঘর 1”. নাম থেকে ঘরের binding compiler চালানোর আগেই সেরে ফেলেছে। মন্তব্যের (; rate) নামগুলো শুধু মানুষের পড়ার জন্য। এখন ধাপে ধাপে দেখি, let rate = 10;-এর কোন অংশ কখন বাঁধা হলো।

1let rate = 10;2fn discount(total: Int) -> Int {3    let cut = total * rate / 100;4    return total - cut;5}6print(discount(1040));
এই ধাপে
binding time
কী বাঁধা হলো
globals
  1. ভাষা নকশার সময়। Haat spec-এ লেখা: let দিয়ে ঘোষিত নাম বদলানো যায় না, আর Int মানে ৬৪-বিট signed পূর্ণসংখ্যা, overflow হলে wrap. এই সিদ্ধান্তগুলো কোনো program লেখার আগেই নেওয়া।
  2. বাস্তবায়নের সময়। Reference বাস্তবায়নের লেখক ঠিক করেছেন Int রাখা হবে Python-এর int-এ, আর প্রতিটি ফল runtime.py-এর wrap() দিয়ে ৬৪ বিটে নামানো হবে; global-গুলো থাকবে একটি list-এ। অন্য বাস্তবায়ন (ধরুন C-তে লেখা) অন্যভাবে করতে পারত, ফল একই রেখে।
  3. Compile: lexer. এখন আসল program এল। Lexer লাইন ১-এর পঞ্চম ঘর থেকে rate পড়ে একটি IDENT token বানায় (haat.py tokens-এর আসল আউটপুট: 1:5 IDENT rate). এখনো এটি শুধু লেখা, কোনো জিনিসের সঙ্গে বাঁধা নয়।
  4. Compile: resolver, hoisting. Resolver আগে top-level function-গুলো ঘোষণা করে, যাতে program-এর শুরু থেকেই সেগুলো দেখা যায় (spec-এর নিয়ম)। তাই লাইন ২-এর discount পায় global ঘর 0, যদিও লেখায় সে rate-এর পরে।
  5. Compile: resolver, rate. এবার লাইন ১: rate হলো একটি let binding, depth 0 (top level), global ঘর 1. লাইন ৩-এর rate ব্যবহারটিও এই ঘোষণার সঙ্গে জোড়া হলো, তাই bytecode-এ LOAD_GLOBAL 1.
  6. Compile: type checker. 10 একটি Int literal, আর ঘোষণায় type লেখা নেই, তাই rate-এর type অনুমান করে Int বাঁধা হয়। এখান থেকে rate + "x" লিখলে চালানোর আগেই error আসত।
  7. Load: VM শুরু। Haat v1-এ একটিই ফাইল, তাই link-এর কোনো কাজ নেই। VM শুরুতে দুটি global ঘর তৈরি করে, দুটিতেই একটি বিশেষ চিহ্ন UNSET (vm.py): ঘর বাঁধা হয়ে গেছে, মান এখনো নয়।
  8. Run time: মান। নির্দেশ ০–১ ঘর 0-তে discount-এর closure রাখে, তারপর নির্দেশ ২–৩ (CONST 10, DEFINE_GLOBAL 1) ঘর 1-এ 10 লেখে। সংজ্ঞা ১৪.১-এর ভাষায়: ρ(rate) = global 1 compile-এর সময়েই ঠিক ছিল, σ(global 1) = 10 হলো এখন।
  9. Run time: ব্যবহার। discount(1040) ডাকা হলে নতুন frame তৈরি হয়, যেখানে slot 0-তে total = 1040 (এই ঠিকানা আর মান এই call-এরই)। LOAD_GLOBAL 1 ঘর 1 থেকে 10 পড়ে; 1040 − 104 = 936 ছাপা হয়।

Stepper থেকে একটি সাধারণ নিয়ম বেরিয়ে আসে: যত আগে binding, তত বেশি দক্ষতা; যত দেরিতে binding, তত বেশি নমনীয়তা। Compile-এর সময় নাম থেকে ঘর বাঁধা হয়েছে বলেই VM-কে চলার সময় “rate” লেখাটি কোনো টেবিলে খুঁজতে হয় না, সরাসরি ঘর 1 পড়ে। উল্টো দিকে, Python-এর মতো ভাষা অনেক কিছু দেরিতে বাঁধে বলে চলার সময় নতুন নাম যোগ করা বা একটি module-এর function বদলে দেওয়া সম্ভব। পুরো কোর্সে এই আপস বারবার ফিরে আসবে: JIT compiler (পর্ব ৬১) মূলত দেরিতে বাঁধা জিনিসকে চলার সময় দেখে “প্রায় আগে বাঁধা”-র মতো দ্রুত করার কৌশল।

৪ · Static বনাম dynamic binding

ছয়টি সময়কে দুই ভাগে ভাগ করা হয়। একটি binding যদি চালানোর আগে তৈরি হয় আর পুরো চলার সময় না বদলায়, তবে তা static binding. যদি প্রথম তৈরি হয় চলার সময়, অথবা চলার সময় বদলাতে পারে, তবে তা dynamic binding. “Static” মানে চালানোর আগে (compile time), “dynamic” মানে চলার সময় (run time), এই কোর্সের সাধারণ নিয়মেই।

বিয়ের কার্ডে লেখা থাকে “বর: রফিক, কনে: নাসরিন”। ছাপার আগেই এটি ঠিক, অনুষ্ঠানের দিন আর বদলায় না: static binding. কিন্তু “আজ রাতে কে রান্না করবে?” প্রশ্নের উত্তর ঠিক হয় সেদিন সন্ধ্যায়, কে বাসায় আছে তা দেখে: dynamic binding. প্রথমটির সুবিধা নিশ্চয়তা, আগে থেকে প্রস্তুতি নেওয়া যায়; দ্বিতীয়টির সুবিধা নমনীয়তা।

সবচেয়ে চোখে পড়ার মতো উদাহরণ type binding. C, Java আর Haat-এ একটি variable-এর type compile-এর সময় বাঁধা, আর বদলায় না: static typing. Python আর JavaScript-এ নামের সঙ্গে যে object বাঁধা, type তার; নামটি অন্য object-এ সরে গেলে “type”-ও বদলায়: dynamic typing. মডিউল ৬-এ (পর্ব ৩৩ থেকে) type system বিস্তারে আসবে; এখানে binding-এর চোখে দেখি। নিচের কোড ব্রাউজারের Python-এ (Pyodide) চালান:

# a name is a label; the object lives elsewhere
cart = [520, 150]            # one list object, one name
basket = cart                # a second name, the SAME object
print("same object?", basket is cart)
basket.append(40)            # change the object through one name
print("cart  :", cart)

old = id(cart)               # id() = identity of the object
cart = cart + [10]           # rebinding: + builds a NEW list
print("cart rebound?", id(cart) != old)
print("basket:", basket)     # still bound to the old list
print("cart  :", cart)

rate = 10                    # name -> int object
print("rate is", type(rate).__name__)
rate = "ten"                 # same name, now bound to a str
print("rate is", type(rate).__name__)

def total(q, u): return q * u
def total(q): return q * 100  # no overloading: rebinds 'total'
print(total(3))

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

same object? True
cart  : [520, 150, 40]
cart rebound? True
basket: [520, 150, 40]
cart  : [520, 150, 40, 10]
rate is int
rate is str
300

চারটি আলাদা binding-এর ঘটনা: ১. basket = cart কোনো কপি বানায়নি, শুধু দ্বিতীয় নামটি একই object-এ বাঁধল (aliasing). তাই basket দিয়ে যোগ করা 40 cart-এও দেখা গেল। ২. cart = cart + [10] object বদলায়নি; + একটি নতুন list বানাল, আর cart নামটি সেখানে সরে গেল। একে বলে rebinding. পুরোনো list এখনো basket-এর সঙ্গে বাঁধা, তাই তাতে 10 নেই। ৩. একই নাম rate প্রথমে int, পরে str object-এ বাঁধা: type নামের নয়, object-এর। ৪. Python-এ একই নামে দুটি def লিখলে দ্বিতীয়টি প্রথমটিকে সরিয়ে দেয়, কারণ def-ও একটি সাধারণ নাম-বাঁধা; তাই total(3) = 300. Python-এ C++ বা Java-র মতো function overloading নেই (অংশ ৭)।

Type ছাড়া আরও তিন ধরনের binding-এ static/dynamic প্রশ্নটি গুরুত্বপূর্ণ:

  • Storage binding (ঘর): C-র global আর static variable-এর ঘর load-এর আগেই ঠিক (static), function-এর local-এর ঘর প্রতি call-এ stack-এ (stack-dynamic), আর malloc-এর ঘর একেবারে চলার সময়ে (heap-dynamic). এই শ্রেণিবিভাগ পর্ব ১৬-এর বিষয়।
  • Method binding: Java-তে shape.area()-এর কোন সংস্করণ চলবে, তা object-এর আসল class দেখে চলার সময় ঠিক হয় (dynamic dispatch, পর্ব ০৮-এ Object-oriented ভাষার ধারণা)। কিন্তু overload করা কোন method-এর স্বাক্ষর বেছে নেওয়া হবে, তা Java compiler static type দেখে আগেই ঠিক করে। একই call-এ দুটি binding, দুটি আলাদা সময়ে।
  • নাম থেকে ঘোষণা: Haat, C, Java আর Python সবাই লেখার গঠন দেখে ঠিক করে কোন নাম কোন ঘোষণাকে বোঝায়: lexical scope. কিছু পুরোনো Lisp আর আজকের Bash-এর local variable কে কাকে ডেকেছে তা দেখে চলার সময় ঠিক করে: dynamic scope. একই program দুই নিয়মে আলাদা উত্তর দেয়, পর্ব ১৫-এ নিজে চালিয়ে দেখবেন।

৫ · CPython নিজে কী আগে বাঁধে — symtable আর dis

“Python dynamic ভাষা, তাই সব binding চলার সময়”, এই ধারণা পুরো ঠিক নয়। CPython একটি function-এর bytecode বানানোর আগে (compile-এর সময়) প্রতিটি নামকে একটি শ্রেণিতে ফেলে দেয়: local, global না free. এই সিদ্ধান্ত চলার সময় আর বদলায় না, অর্থাৎ এটি একটি static binding. মান অবশ্যই পরে আসে। CPython এই শ্রেণিবিভাগ একটি symbol table-এ রাখে, আর standard library-র symtable module দিয়ে সেটি সরাসরি পড়া যায়। নিচে বাজারঘরের একটি ছাড়-যন্ত্র, যা কতবার ব্যবহার হলো তা-ও গোনে:

import symtable
src = """
rate = 10
def make_discount(limit):
    count = 0
    def apply(total):
        nonlocal count
        count = count + 1
        if total >= limit:
            return max(0, total - total * rate // 100)
        return total
    return apply
"""
def kind(s):
    if s.is_parameter(): return "parameter (local)"
    if s.is_free(): return "free (from an outer function)"
    if s.is_declared_global(): return "global (declared)"
    if s.is_global(): return "global (implicit)"
    if s.is_local(): return "local"
    return "?"
def show(t, depth=0):
    pad = "  " * depth
    print(f"{pad}{t.get_type().name.lower()} {t.get_name()}:")
    for s in t.get_symbols():
        print(f"{pad}  {s.get_name():<14}{kind(s)}")
    for child in t.get_children():
        if child.get_type().name == "ANNOTATION": continue  # 3.14 helper scopes
        show(child, depth + 1)
show(symtable.symtable(src, "bazar.py", "exec"))

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

module top:
  rate          global (implicit)
  make_discount global (implicit)
  function make_discount:
    limit         parameter (local)
    count         local
    apply         local
    function apply:
      total         parameter (local)
      count         free (from an outer function)
      limit         free (from an outer function)
      max           global (implicit)
      rate          global (implicit)

কোডটি src চালায়নি, শুধু compile-এর প্রথম অংশটুকু করেছে, তবু প্রতিটি নামের শ্রেণি জানা হয়ে গেছে। apply-এর ভেতরে limit-এর জন্য কোনো nonlocal লেখা নেই, তবু সে free: শুধু পড়া হচ্ছে, আর সবচেয়ে কাছের বাইরের function-এ এই নাম আছে। max আর rate দুটিই “global (implicit)”, যদিও প্রথমটি built-in আর দ্বিতীয়টি module-এর নিজের: compiler শুধু জানে “এটি local বা free নয়, চলার সময় global আর built-in-এ খুঁজতে হবে”. একটি ছোট খেয়াল: Python 3.14-এ annotation আলস্যে (lazily) হিসাব হয় (PEP 649), তাই symbol table-এ __annotate__ নামের ছোট সহায়ক scope দেখা যায়; কোডে সেগুলো বাদ দেওয়া হয়েছে।

এই শ্রেণিবিভাগ সরাসরি bytecode-এ পৌঁছায়। একই কোড আমার যন্ত্রে CPython 3.14.4-এ চালিয়ে dis দিয়ে apply-এর bytecode (সত্যিকারের run; প্রথমে f = make_discount(1000), আর f(1040), f(500) দিয়েছে 936 500):

  --           COPY_FREE_VARS           2
   5           RESUME                   0
   7           LOAD_DEREF               1 (count)
               LOAD_SMALL_INT           1
               BINARY_OP                0 (+)
               STORE_DEREF              1 (count)
   8           LOAD_FAST_BORROW         0 (total)
               LOAD_DEREF               2 (limit)
               COMPARE_OP             188 (bool(>=))
               POP_JUMP_IF_FALSE       37 (to L1)
               NOT_TAKEN
   9           LOAD_GLOBAL              1 (max + NULL)
               LOAD_SMALL_INT           0
               LOAD_FAST_BORROW_LOAD_FAST_BORROW 0 (total, total)
               LOAD_GLOBAL              2 (rate)
               BINARY_OP                5 (*)
               ...

আর make_discount-এর শুরুতে দুটি নির্দেশ: MAKE_CELL 0 (limit) আর MAKE_CELL 2 (count). অর্থাৎ যে local-কে ভেতরের function ধরে রাখে, CPython তাকে সাধারণ ঘরে না রেখে একটি “cell” বাক্সে রাখে, যাতে বাইরের আর ভেতরের function একই বাক্স ভাগ করতে পারে। নিচের stepper-এ প্রতিটি নাম ধরে মিলিয়ে দেখুন।

1rate = 102def make_discount(limit):3    count = 04    def apply(total):5        nonlocal count6        count = count + 17        if total >= limit:8            return max(0, total - total * rate // 100)9        return total10    return apply
এই ধাপের নাম
নাম
symtable
CPython
মান খোঁজা
  1. Module-এর নাম। Top level-এ rate একটি global. Module-এর global-গুলো একটি dict-এ থাকে, তাই এদের নাম চলার সময়েও থাকে, আর globals()["rate"] দিয়ে পড়া বা বদলানো যায়।
  2. Parameter, কিন্তু ধরা পড়েছে। limit হলো make_discount-এর parameter, তাই local. কিন্তু ভেতরের apply এটি পড়ে, তাই compiler একে cell-এ রাখে: MAKE_CELL 0 (limit).
  3. Local, আবার ধরা পড়েছে। count-এ assignment আছে, তাই সে make_discount-এর local; ভেতরে ব্যবহার আছে বলে সে-ও cell (MAKE_CELL 2), আর count = 0 হয় STORE_DEREF 2 দিয়ে।
  4. সাধারণ local. apply-এর parameter total কেউ ধরে না, তাই সাধারণ frame-ঘর: LOAD_FAST_BORROW 0. দ্রুততম পথ, কারণ ঘরের নম্বর compile-এর সময়েই ঠিক।
  5. nonlocal মানে free. nonlocal count না লিখলে count = count + 1 দেখে compiler count-কে apply-এর local ভাবত, আর চলার সময় UnboundLocalError হতো। লেখার পরে সে free: LOAD_DEREF 1 আর STORE_DEREF 1, closure-এর cell দিয়ে।
  6. শুধু পড়া, তবু free. limit-এ apply কিছু লেখে না, তাই কোনো ঘোষণা লাগে না; সবচেয়ে কাছের বাইরের function-এ নামটি পাওয়া গেছে, তাই free: LOAD_DEREF 2.
  7. বাকি সব global. max আর rate local বা free নয়, তাই LOAD_GLOBAL. শ্রেণি compile-এর সময় ঠিক হলেও মান খোঁজা হয় চলার সময়: আগে module-এর globals-এ, না পেলে builtins-এ। তাই চলার সময় rate = 20 করলে পরের call-এ নতুন হার লাগবে।

এখানে দুই স্তরের binding পরিষ্কার দেখা যায়: নামের শ্রেণি (কোথায় খুঁজতে হবে) static, নামের মান dynamic. Haat reference ঠিক একই কাজ করে, শুধু আরও কড়া: global-এর ঘর নম্বরও compile-এর সময় ঠিক (LOAD_GLOBAL 1), নাম দিয়ে খোঁজাখুঁজি নেই। আর ধরা পড়া variable-এর জন্য Haat-এর VM-এও cell আছে (MAKE_CELL, LOAD_FREE); সেই গল্প পর্ব ১৭-এ (Closure). Python-এর scope-এর নিয়ম (LEGB) Python-এর দিক থেকে বিস্তারে আছে Python কোর্সের পর্ব ২০-এ.

৬ · Aliasing: এক ঘর, দুই নাম

সংজ্ঞা ১৪.১-এ aliasing মানে ρ(x) = ρ(y). অংশ ৪-এর Python কোডে ঠিক তা-ই ঘটেছে। ঘর আর নামের ছবি ধরে ধাপে ধাপে দেখি:

1cart = [520, 150]2basket = cart3basket.append(40)4cart = cart + [10]5print(basket, cart)
এই ধাপের পরে
cart →
basket →
object A
object B
basket is cart
  1. একটি object, একটি নাম। List-টি মেমরিতে কোথাও তৈরি হলো; ধরুন তার নাম object A. Environment-এ এখন cart ↦ A.
  2. দ্বিতীয় নাম। basket = cart নতুন কোনো list বানায় না, শুধু environment-এ basket ↦ A যোগ করে। এখন ρ(cart) = ρ(basket): aliasing.
  3. এক নামে বদল, দুই নামে দেখা। append object A-কেই বদলায় (mutation). দাবি ১৪.২ অনুযায়ী এখন cart দিয়ে পড়লেও 40 দেখা যাবে।
  4. Rebinding. cart + [10] একটি নতুন object B বানায়, আর = শুধু cart নামটিকে B-তে সরায়। A-কে কেউ ছোঁয়নি; basket এখনো A-তে। Alias সম্পর্ক ভেঙে গেল।
  5. আউটপুট। দুই নাম, দুই আলাদা list. মনে রাখার সূত্র: x.something(…) বা x[i] = … object বদলায় (সব alias দেখে); x = … শুধু নামটি সরায় (অন্য alias দেখে না)।

ভাষাভেদে alias তৈরির পথ আলাদা: C-তে pointer (int *p = &total;, তারপর *p = 936; total-কেই বদলায়), C++-এ reference (int& r = total;, C++ কোর্সের পর্ব ১০), পুরোনো FORTRAN-এ EQUIVALENCE বিবৃতি, যা দুটি আলাদা নামকে ইচ্ছে করে একই মেমরিতে বসাত, আর by-reference parameter passing (পর্ব ২৯)। Pointer আর reference-এর পূর্ণ আলোচনা পর্ব ২৩-এ।

JavaScript-এ const: নাম আটকানো, object নয়

Binding আর মানের পার্থক্য সবচেয়ে বেশি বিভ্রান্তি তৈরি করে JavaScript-এর const-এ। const নামটিকে একটি মানে আটকে দেয় (rebinding নিষেধ), কিন্তু সেই মান যদি object হয়, object-এর ভেতর বদলানো নিষেধ নয়। নিচের কোড ব্রাউজারেই চলবে:

"use strict";
const order = { id: 7, total: 1040 };
order.total = 936;                  // mutation: the binding is unchanged
console.log("total:", order.total);
try {
  order = { id: 8, total: 0 };      // rebinding a const name
} catch (e) {
  console.log(e.name + ":", e.message);
}
let rate = 10;
rate = 12;                          // let: rebinding is allowed
console.log("rate:", rate);
const fixed = Object.freeze({ total: 500 });
try {
  fixed.total = 0;                  // the object itself is frozen
} catch (e) {
  console.log(e.name + ":", e.message);
}
console.log("fixed.total:", fixed.total);
const alias = order;                // two names, one object
alias.total = 100;
console.log("order.total:", order.total, alias === order);

আসল আউটপুট (ব্রাউজারের JavaScript; Node 24-এও হুবহু এক):

total: 936
TypeError: Assignment to constant variable.
rate: 12
TypeError: Cannot assign to read only property 'total' of object '#<Object>'
fixed.total: 500
order.total: 100 true

order.total = 936 চলেছে, কারণ const শুধু order নাম আর object-এর জোড়াটি আটকায়। order = … সেই জোড়া বদলাতে চায়, তাই TypeError. Object নিজেকে অপরিবর্তনীয় করতে চাইলে Object.freeze লাগে; strict mode-এ ("use strict") frozen object-এ লেখার চেষ্টা error দেয়, strict mode ছাড়া চুপচাপ উপেক্ষিত হয়। শেষ লাইনে const alias = order: দুটি const নাম, একটি object, তাই alias দিয়ে লেখা 100 order-এও দেখা যায়। JavaScript-এর দিক থেকে var/let/const-এর পুরো গল্প আছে JavaScript কোর্সের পর্ব ০৭-এ.

Haat-এর let এখানে JavaScript-এর const-এর মতো: নাম বদলানো যায় না। পার্থক্য হলো Haat v1-এ কোনো mutable object নেই (Int, Bool, Str আর function মান), তাই let দিয়ে বাঁধা নামের মান সত্যিই কখনো বদলায় না। আর ভুলটি ধরা পড়ে চালানোর আগেই, type checker-এর আগের ধাপ resolver-এ (অংশ ৮-এ আসল error). JavaScript-এ একই ভুল ধরা পড়ে চলার সময়, যখন লাইনটি আসলে চলে।

৭ · Overloading, keyword আর reserved word

Aliasing-এর উল্টো ঘটনা: একটি নাম, অনেক জিনিস। একই নাম বা চিহ্ন যদি একই scope-এ একাধিক সত্তাকে বোঝায়, আর কোনটি বোঝাবে তা ঠিক হয় ব্যবহারের প্রসঙ্গ (সাধারণত operand বা argument-এর type) দেখে, তাকে বলে overloading.

  • Operator overloading, Haat-এ: + দুটি Int-এ যোগ, দুটি Str-এ জোড়া (reference-এর নকশা-সিদ্ধান্ত ১১)। Type checker বাঁ operand-এর type দেখে ঠিক করে কোনটি; তাই এটি compile time-এর binding. ==-ও overloaded: Int, Bool আর Str তিনটিতেই চলে। একে বলে operator overloading.
  • Function overloading, C++ আর Java-তে: area(int) আর area(double, double) একই নামে দুটি function; compiler argument-এর static type দেখে বেছে নেয় (function overloading; C++ কোর্সের পর্ব ০৯)। Linker যেন দুটিকে আলাদা চেনে, সেজন্য C++ compiler নামের সঙ্গে type জুড়ে দেয় (name mangling, পর্ব ১৮-এ)।
  • C আর Python-এ নেই: C-তে একই নামে দুটি function লেখা যায় না। Python-এ লেখা যায়, কিন্তু অংশ ৪-এ দেখেছেন, দ্বিতীয়টি প্রথমটিকে সরিয়ে দেয়। Python-এ argument-এর type দেখে বাছাই চাইলে functools.singledispatch আছে, যা চলার সময় প্রথম argument-এর type দেখে বাছে: overloading-এর dynamic রূপ।

Overloading-কে polymorphism-এর একটি রূপ (ad hoc polymorphism) হিসেবে পর্ব ৩৬-এ আবার দেখবেন।

Keyword, reserved word আর predeclared নাম

কিছু নাম ভাষা নিজের জন্য রাখে। কিন্তু “রাখা”-র তিনটি আলাদা মাত্রা আছে, আর পরীক্ষায় এই পার্থক্য প্রায়ই জিজ্ঞাসা করা হয়:

ধরনমানেউদাহরণ
Keywordকিছু প্রসঙ্গে ব্যাকরণের বিশেষ অর্থ বহন করেHaat-এর let var fn if else while return true false print
Reserved wordএমন শব্দ যা কখনো নাম হিসেবে ব্যবহার করা যায় না। আজকের বেশিরভাগ ভাষায় keyword মানেই reserved, কিন্তু সব ভাষায় নয়Java-র goto আর const: reserved, কিন্তু ভাষায় কোনো কাজ নেই
Contextual (soft) keywordশুধু নির্দিষ্ট প্রসঙ্গে keyword, অন্য জায়গায় সাধারণ নামPython 3.14-এর match case type _; Java-র var, record
Predeclared নামভাষা আগে থেকে ঘোষণা করে রেখেছে, কিন্তু আপনি একই নামে নতুন জিনিস বাঁধতে (shadow করতে) পারেনPython-এর print len list max; Haat-এর Int Bool Str Unit

Haat-এর reference এখানে একটি সচেতন সিদ্ধান্ত নিয়েছে (নকশা-সিদ্ধান্ত ৬): Int, Bool, Str, Unit keyword নয়, সাধারণ IDENT token; শুধু type-এর জায়গায় বসলে type বোঝায়। তাহলে Int নামে একটি variable বানানো যায় কি? চালিয়ে দেখা যাক (সত্যিকারের run):

let Int = 3;
let x: Int = Int + 1;
print(x);
~/haat $ python haat.py tokens intname.haat
1:1    LET      let
1:5    IDENT    Int
1:9    EQ       =
1:11   INT      3
1:12   SEMI     ;
2:1    LET      let
2:5    IDENT    x
2:6    COLON    :
2:8    IDENT    Int
2:12   EQ       =
2:14   IDENT    Int
2:18   PLUS     +
2:20   INT      1
2:21   SEMI     ;
...
~/haat $ python haat.py run intname.haat
4

লাইন ২-এ একই Int লেখা তিনবার এল, তিনটিই IDENT. কিন্তু x: Int-এর Int type-এর জায়গায়, তাই type; = Int + 1-এর Int expression-এর জায়গায়, তাই variable, যার মান 3. Type-এর নাম আর variable-এর নাম আলাদা দুটি “namespace”-এ থাকে। অন্যদিকে print একটি keyword (PRINT token), তাই let print = 3; লিখলে reference parser-এর ধাপেই থামে: 1:5: error: expected variable name after 'let'. ভালো ভাষা-নকশায় keyword-এর সংখ্যা কম রাখা হয়, কারণ প্রতিটি keyword প্রোগ্রামারের কাছ থেকে একটি নাম কেড়ে নেয়।

FORTRAN আর PL/I-এ কোনো reserved word ছিল না: IF বা DO নামেও variable রাখা যেত, আর compiler প্রসঙ্গ দেখে বুঝত কোনটি কী। PL/I-এর একটি বহুল উদ্ধৃত উদাহরণ IF IF = THEN THEN THEN = ELSE; ELSE ELSE = END;, যা বৈধ PL/I. এতে প্রোগ্রামারের স্বাধীনতা বাড়ে, কিন্তু lexer-এর কাজ খুব কঠিন হয়, কারণ শব্দ দেখে token-এর ধরন বলা যায় না। পরের প্রায় সব ভাষা reserved word বেছে নিয়েছে, আর নতুন keyword যোগ করার সময় পুরোনো কোড না ভাঙতে contextual keyword-এর পথ নিয়েছে (ভাবনার প্রশ্ন ৪)।

৮ · Compiler-এর চোখে: Haat-এর নাম বাঁধা, কোডে

পর্ব ০৫-এ (Compiler-এর ধাপগুলো) দেখেছেন, parser-এর পরে semantic analysis-এর প্রথম কাজ name resolution: প্রতিটি নাম-ব্যবহারকে তার ঘোষণার সঙ্গে জোড়া। Haat reference-এ এই কাজ করে resolver.py; প্রতিটি ঘোষণা একটি Binding(name, kind, depth, slot, …) পায়। নিচে তার একটি ছোট নমুনা, ব্রাউজারের Python-এ। ইনপুট হিসেবে AST-এর বদলে সরল tuple, যাতে মূল ভাবনাটুকু চোখে পড়ে: scope-এর একটি stack, প্রতি function-এ ঘরের একটি গণনা, আর ভেতর থেকে বাইরে খোঁজা। Program-টিতে ইচ্ছে করে দুটি ভুল রাখা হয়েছে:

let rate = 10;
fn discount(total: Int) -> Int {
    let cut = totl * rate / 100;
    rate = 12;
    return total - cut;
}
print(discount(1040));
from dataclasses import dataclass
@dataclass
class Binding:              # the same idea as Binding in resolver.py
    name: str; kind: str; depth: int; slot: int
# (kind, declared name or None, names used) for each statement
prog = [("let", "rate", []),                  # let rate = 10;
        ("fn", "discount", [], [              # fn discount(total: Int) -> Int {
            ("param", "total", []),
            ("let", "cut", ["totl", "rate"]), #   let cut = totl * rate / 100;
            ("set", "rate", []),              #   rate = 12;
            ("ret", None, ["total", "cut"])]),#   return total - cut; }
        ("print", None, ["discount"])]        # print(discount(1040));
scopes, slots = [{}], [0]
def declare(name, kind):
    b = Binding(name, kind, len(slots) - 1, slots[-1])
    slots[-1] += 1; scopes[-1][name] = b
    print(f"bind {name:<9}{kind:<6}depth {b.depth} slot {b.slot}")
def lookup(name):
    for scope in reversed(scopes):        # innermost scope first
        if name in scope: return scope[name]
    print(f"  error: undefined variable '{name}'")
def walk(stmts):
    for kind, name, uses, *body in stmts:
        for u in uses:
            if b := lookup(u):
                print(f"  use {u:<9}-> {b.kind} at depth {b.depth}, slot {b.slot}")
        if kind == "set" and lookup(name).kind == "let":
            print(f"  error: cannot assign to '{name}': it is declared with 'let'")
        elif kind in ("let", "param"): declare(name, kind)
        elif kind == "fn":
            scopes.append({}); slots.append(0)  # a new frame
            walk(body[0]); scopes.pop(); slots.pop()
for kind, name, *_ in prog:               # hoist top-level functions
    if kind == "fn": declare(name, "fn")
walk(prog)

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

bind discount fn    depth 0 slot 0
bind rate     let   depth 0 slot 1
bind total    param depth 1 slot 0
  error: undefined variable 'totl'
  use rate     -> let at depth 0, slot 1
bind cut      let   depth 1 slot 1
  error: cannot assign to 'rate': it is declared with 'let'
  use total    -> param at depth 1, slot 0
  use cut      -> let at depth 1, slot 1
  use discount -> fn at depth 0, slot 0

এবার একই program আসল reference-এ (সত্যিকারের run):

~/haat $ python haat.py check names_err.haat
3:15: error: undefined variable 'totl'
4:5: error: cannot assign to 'rate': it is declared with 'let'

দুটি error-ই মিলেছে, আর ঘরের নম্বরও অংশ ৩-এর আসল dis-এর সঙ্গে মেলে: discount global 0, rate global 1, total local 0, cut local 1. আমাদের নমুনায় অবস্থান (3:15) নেই, কারণ ইনপুটে line:col রাখা হয়নি; আর let-এ assignment-এর error-টি আসল reference-এ resolver-এর কাজ, ঠিক যেমন এখানে। Binding-এর depth বলে নামটি কোন function-স্তরের: depth 0 মানে top level, তাই VM সেখানে LOAD_GLOBAL দেয়; depth 1 মানে এই function-এর নিজের, তাই LOAD_LOCAL. পুরো resolver (block, shadowing, ঘোষণার আগে ব্যবহার, closure-এর জন্য captured চিহ্ন) পর্ব ৫১-এ (Symbol table আর name resolution) ধাপে ধাপে বানাবেন; অনুশীলন ১-এ এখনই block যোগ করবেন।

লক্ষ করুন, এই resolver চালানোর আগেই কাজ করে, কোনো মান না জেনে। totl বানান ভুল Python-এ চলার সময় NameError হয়ে ধরা পড়ত, আর তা-ও শুধু যদি লাইনটি চলে। Haat-এ ধরা পড়ে program চালানোর আগেই, প্রতিটি লাইনের জন্য। এটিই static name binding-এর সবচেয়ে ব্যবহারিক লাভ।

আরও গভীরে: Compiler-এর ভেতরে নামকে প্রায়ই পুরোপুরি সরিয়ে দেওয়া হয়। একটি পুরোনো কৌশল হলো de Bruijn index (Nicolaas de Bruijn, ১৯৭২): lambda calculus-এ প্রতিটি variable-এর নামের জায়গায় একটি সংখ্যা বসে, “কত স্তর বাইরের binder”, যাতে নাম বদলানো নিয়ে কোনো ঝামেলা না থাকে। Haat-এর (depth, slot) জোড়া একই ভাবনার আত্মীয়, আর ALGOL-ধাঁচের compiler-এ variable-এর ঠিকানা লেখা হতো “(স্তরের পার্থক্য, offset)” জোড়ায়, যা পর্ব ৩০-এর activation record আর static link-এর ভিত্তি। আধুনিক compiler (যেমন Clang) আরও এক ধাপ যায়: SSA form-এ (পর্ব ৬৩) প্রতিটি assignment নতুন একটি নাম পায়, ফলে IR-এর ভেতরে একটি নাম একটিমাত্র মানের সঙ্গে চিরকাল বাঁধা থাকে।

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

  • Binding time কী, ছয়টি ধাপ? একটি জোড়া যখন তৈরি হয়: ভাষা নকশা, বাস্তবায়ন, compile, link, load, run.
  • Static আর dynamic binding-এর পার্থক্য? Static চালানোর আগে তৈরি হয় আর বদলায় না; dynamic চলার সময় তৈরি হয় বা বদলাতে পারে।
  • Variable-এর বৈশিষ্ট্যগুলো? নাম, ঠিকানা (l-value), মান (r-value), type, lifetime, scope.
  • Keyword আর reserved word কি এক? না; reserved word কখনো নাম হতে পারে না, keyword কোনো কোনো ভাষায় শুধু প্রসঙ্গে বিশেষ (FORTRAN, Python-এর soft keyword).
  • Aliasing আর overloading? Aliasing: অনেক নাম, এক ঘর। Overloading: এক নাম, অনেক সত্তা, প্রসঙ্গ দেখে বাছাই।

৯ · AI-এর যুগে নাম আর binding

নাম আর binding এমন একটি বিষয়, যেখানে AI assistant-এর উত্তর শুনতে খুব আত্মবিশ্বাসী লাগে, কিন্তু প্রায়ই একটি ভাষার নিয়ম অন্য ভাষায় চাপিয়ে দেয়। এই বিষয়ে বারবার দেখা ভুলগুলো:

AI-এর ভুলকীভাবে ধরবেন
“Python-এ সব binding চলার সময়” বা “Python-এ compile বলে কিছু নেই”symtable আর dis চালিয়ে local/free/global শ্রেণি দেখা
JavaScript-এর const মানে object অপরিবর্তনীয়, এমন দাবিconst object-এর property বদলে চালিয়ে দেখা; Object.freeze-এর পার্থক্য পড়া
C-তে int সবসময় ৩২ বিট, এমন দাবিC standard-এ শুধু ন্যূনতম সীমা; লক্ষ্য compiler-এ sizeof(int) ছাপিয়ে দেখা
Overload আর override গুলিয়ে ফেলা, বা Java-তে overload-এর বাছাই চলার সময় হয় বলাএকই call-এ static type আর আসল class আলাদা রেখে ছোট program চালানো
Python-এ b = a কপি বানায় বলা, বা a += [x] আর a = a + [x]-কে এক ভাবাis আর id() দিয়ে আগে-পরে মিলিয়ে দেখা
কোনো শব্দকে keyword বলা যা আসলে predeclared নাম (Python-এর print, Haat-এর Int)Python-এ keyword.kwlist; Haat-এ haat.py tokens

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

আমি প্রোগ্রামিং ভাষার name binding শিখছি। নিচের প্রতিটি binding কখন তৈরি হয় (ভাষা নকশা, বাস্তবায়ন, compile, link, load, নাকি run time), C17, Java 21, Python 3.14 আর JavaScript (ECMAScript 2025) আলাদা করে বলো: ক) একটি local variable-এর type, খ) তার ঘরের ঠিকানা, গ) একটি global variable-এর ঘরের ঠিকানা, ঘ) একটি method call-এর আসল function, ঙ) “+” চিহ্নের অর্থ। ১. প্রতিটি উত্তরের পাশে লেখো, এটি ভাষার specification-এর নিয়ম নাকি একটি নির্দিষ্ট বাস্তবায়নের আচরণ। ২. প্রতিটি ভাষার জন্য ১৫ লাইনের কম একটি program দাও, যা চালিয়ে আমি অন্তত একটি দাবি নিজে যাচাই করতে পারি (যেমন Python-এ symtable বা dis). ৩. যেখানে উত্তর ভাষাভেদে আলাদা, সেখানে একটি ভাষার নিয়ম অন্য ভাষায় চাপাবে না। ৪. কোনো আউটপুট অনুমান করে লিখবে না; কোনগুলো আমাকে চালিয়ে দেখতে হবে, আলাদা করে বলো।

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

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

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

প্র ০১Python 3 কেন True, False আর None-কে keyword বানাল, অথচ print-কে keyword থেকে সাধারণ নামে নামাল?

Python 2-এ True আর False ছিল predeclared নাম, built-in module-এ রাখা দুটি মান। তাই True = 0 লেখা বৈধ ছিল, আর তারপর সেই module-এ if x == True একেবারে অন্য অর্থ দিত। কেউ ইচ্ছে করে এমন করে না, কিন্তু ভাষার দিক থেকে এর একটি বড় দাম ছিল: compiler কখনো নিশ্চিত হতে পারত না True মানে সত্যিই সত্য, কারণ এটি চলার সময় বদলাতে পারে এমন একটি global নাম। তাই প্রতিবার নাম দিয়ে খুঁজতে হতো। Python 3 এদের keyword বানিয়ে binding-টিকে ভাষা নকশার সময়ে নিয়ে গেল; এখন compiler সরাসরি একটি constant বসাতে পারে, আর True = 0 একটি syntax error.

print-এর ক্ষেত্রে ঠিক উল্টো পথ। Python 2-এ print একটি statement, অর্থাৎ keyword ছিল, তার নিজস্ব বিশেষ ব্যাকরণ সহ (print >>f, x). Python 3-এ (PEP 3105) এটি একটি সাধারণ built-in function হলো। লাভ হলো নমনীয়তা: এখন print-কে argument হিসেবে পাঠানো যায়, sep আর file-এর মতো keyword argument দেওয়া যায়, এমনকি পরীক্ষার সময় নিজের সংস্করণ দিয়ে shadow করা যায়। Binding-টি নকশার সময় থেকে সরে এল run time-এ।

দুই সিদ্ধান্তের পেছনে একটিই নীতি: কোন binding আগে হওয়া উচিত আর কোনটি দেরিতে। True-এর মান কখনো বদলানোর কোনো যুক্তিসঙ্গত কারণ নেই, তাই আগে বাঁধাই নিরাপদ আর দ্রুত। আউটপুট কোথায় যাবে, কীভাবে সাজানো হবে, তা নিয়ে প্রোগ্রামারের বাস্তব প্রয়োজন আছে, তাই দেরিতে বাঁধা ভালো। Haat-এ print এখনো keyword, আর এটি একটি statement (reference-এর নকশা-সিদ্ধান্ত ৮): ছোট শিক্ষার ভাষায় এটি parser আর type checker দুটিকেই সরল রাখে, কিন্তু Haat-এ print-কে argument হিসেবে পাঠানো যায় না। Python 2 থেকে 3-এর পরিবর্তন একটি সতর্কবার্তাও দেয়: keyword-এর তালিকা বদলানো পুরোনো কোড ভাঙে, আর Python 2-এর কোড Python 3-এ নিতে বহু প্রকল্পের অনেক বছর লেগেছিল।

মূল উপলব্ধি: একটি শব্দ keyword হবে নাকি predeclared নাম, তা আসলে binding time-এর সিদ্ধান্ত: আগে বাঁধলে নিশ্চয়তা আর গতি, দেরিতে বাঁধলে নমনীয়তা, আর সেই সিদ্ধান্ত পরে বদলানোর দাম অনেক।

প্র ০২“Late binding” কি শুধু ধীরগতির কারণ, নাকি এর পেছনে কোনো বড় নকশা-দর্শন আছে?

Alan Kay, Smalltalk-এর অন্যতম স্রষ্টা, ২০০৩ সালের একটি email-এ (পরে বহুবার উদ্ধৃত) লিখেছিলেন, তাঁর কাছে object-oriented programming মানে মূলত messaging, state লুকিয়ে রাখা আর “extreme late-binding of all things”. Smalltalk-এ প্রায় সবকিছু চলার সময় বাঁধা: কোন method চলবে, কোন class-এ কী method আছে, এমনকি চলমান program-এর ভেতরে class বদলে দেওয়াও সম্ভব। এর পেছনের দর্শন হলো, বড় আর দীর্ঘজীবী সিস্টেম কখনো “শেষ” হয় না; চলতে চলতেই বদলাতে হয়, তাই যত সিদ্ধান্ত দেরিতে নেওয়া যায়, সিস্টেম তত মানিয়ে নিতে পারে।

দাম অবশ্যই আছে। C-তে a.price-এর মতো field পড়া compile-এর সময় একটি নির্দিষ্ট offset-এ নেমে যায়, এক নির্দেশে কাজ শেষ। Python-এ a.price-এর জন্য চলার সময় object-এর dict, তারপর class, তারপর base class-গুলো খুঁজতে হতে পারে। Error-ও দেরিতে ধরা পড়ে: বানান ভুল নাম শুধু তখনই ধরা পড়ে যখন লাইনটি আসলে চলে।

কিন্তু বাস্তবায়নের কৌশল এই দামের বড় অংশ ফেরত দিয়েছে। ১৯৮০-এর দশকে Smalltalk-এর বাস্তবায়নে inline cache কৌশলটি জনপ্রিয় হয় (Deutsch আর Schiffman-এর ১৯৮৪ সালের কাজ প্রায়ই উদ্ধৃত হয়): একটি call-এর জায়গায় গতবার যে method পাওয়া গিয়েছিল, তা মনে রাখা, আর পরের বার object-এর class একই হলে সরাসরি সেটিতে লাফ দেওয়া। পরে Self ভাষার গবেষণা আর তার উত্তরসূরি JIT compiler-গুলো দেখায়, চলার সময় যা দেখা যায় তার ভিত্তিতে “আপাতত আগে বাঁধা” কোড বানানো যায়, আর অনুমান ভুল হলে ফিরে আসা যায় (deoptimization). আজকের JavaScript engine আর Java-র HotSpot এই ধারার উত্তরসূরি (পর্ব ৬১)। CPython 3.11 থেকে interpreter-এর ভেতরেই এই ধরনের কৌশল যোগ হয়েছে (PEP 659, “specializing adaptive interpreter”): একটি নির্দেশ কয়েকবার চলার পর যে type বারবার দেখা যায়, তার জন্য বিশেষ দ্রুত সংস্করণে বদলে যায়, আর অনুমান ভাঙলে আবার সাধারণ রূপে ফেরে।

অর্থাৎ binding time একটি ভাষার অর্থের প্রশ্ন, আর গতি তার বাস্তবায়নের প্রশ্ন। ভাষা যদি দেরিতে বাঁধার অনুমতি দেয়, বাস্তবায়ন তবু অনুমান করে আগে বাঁধতে পারে, যতক্ষণ সে অনুমান ভাঙলে ধরতে পারে।

মূল উপলব্ধি: late binding হলো পরিবর্তনশীলতার পক্ষে একটি নকশা-সিদ্ধান্ত; তার গতির দাম অনেকটাই JIT আর cache-এর মতো বাস্তবায়ন কৌশল দিয়ে পূরণ করা যায়, কিন্তু error দেরিতে ধরা পড়ার দাম থেকেই যায়।

প্র ০৩Aliasing কেন compiler-লেখকদের এত বড় মাথাব্যথা, আর বিভিন্ন ভাষা এর কী সমাধান দিয়েছে?

দাবি ১৪.২-এর দুই দিক মনে করুন। যদি দুটি নাম একই ঘর হয়, একটিতে লেখা অন্যটিতে দেখা যায়; যদি না হয়, দেখা যায় না। Optimizer-এর প্রায় প্রতিটি কৌশল, যেমন একটি মান register-এ রেখে দেওয়া, দুটি load একটিতে মেলানো বা loop-এর বাইরে একটি হিসাব সরানো, এই প্রশ্নের উত্তরের ওপর নির্ভর করে: “মাঝখানের এই store কি ওই ঘরটি বদলাতে পারে?” উত্তর “হয়তো” হলে compiler-কে ধরে নিতে হয় “হ্যাঁ”, আর কোড ধীর হয়।

ভাষাগুলো আলাদা পথ নিয়েছে। FORTRAN-এর নিয়মে একটি subroutine-এর দুটি argument যদি একই ঘর হয় আর একটির মাধ্যমে লেখা হয়, সেই program নিয়ম ভাঙে; তাই compiler ধরে নিতে পারে argument-গুলো alias নয়। সংখ্যা-হিসাবের কোডে FORTRAN-এর গতির এটি একটি প্রচলিত ব্যাখ্যা। C সেই নিশ্চয়তা দেয় না, তাই C99 restrict যোগ করে, যেখানে প্রোগ্রামার নিজে প্রতিশ্রুতি দেন (পর্ব ০৭)। C-তে আরেকটি নিয়মও আছে, যাকে সাধারণত “strict aliasing” বলা হয়: মোটামুটি, একটি float-কে int* দিয়ে পড়া undefined behavior, তাই compiler ধরে নিতে পারে আলাদা type-এর pointer সাধারণত একই ঘর নয় (কিছু ব্যতিক্রম, যেমন char*, standard-এ বলা আছে)। এই নিয়ম না জেনে লেখা কোড optimization চালু করলে অদ্ভুত আচরণ করতে পারে।

Rust আরও এক ধাপ গেছে: একটি ঘরে একই সময়ে হয় একটি &mut reference, নয়তো যত খুশি শুধু-পড়ার & reference থাকতে পারে, দুটো একসঙ্গে নয়। Borrow checker এটি compile-এর সময়েই যাচাই করে (পর্ব ৭৬)। ফলে “বদলানো যায় এমন alias” একসঙ্গে থাকতে পারে না, যা একদিকে optimizer-কে সাহায্য করে, অন্যদিকে data race-এর একটি বড় উৎস বন্ধ করে। Functional ভাষা আরও সরল সমাধান নেয়: কিছুই বদলায় না, তাই alias থাকলেও কোনো ক্ষতি নেই (পর্ব ০৯)। Haat v1-ও প্রায় এখানে: mutable object নেই, তাই alias-এর একমাত্র উৎস closure-এর ভাগ করা var (পর্ব ১৭)।

Compiler-এর দিকে এর পাল্টা অস্ত্র হলো alias analysis (বা points-to analysis): কোন pointer কোন ঘরে নির্দেশ করতে পারে, তার একটি নিরাপদ অনুমান। এটি সাধারণভাবে নিখুঁত করা অসম্ভব (Rice-এর theorem-এর আত্মীয়, গণনার তত্ত্ব কোর্সের পর্ব ৫৩), তাই সব বাস্তব analysis কিছুটা রক্ষণশীল।

মূল উপলব্ধি: aliasing একটি “নাম আর ঘর”-এর সম্পর্ক, আর এর উত্তর জানা না থাকলে compiler সাবধানী হতে বাধ্য; ভাষার নিয়ম (FORTRAN, restrict, Rust) সেই উত্তর আগে থেকে বলে দেওয়ার একেকটি উপায়।

প্র ০৪নতুন keyword যোগ করলে পুরোনো কোড ভাঙে। Python-এর match আর অন্য ভাষাগুলো এই সমস্যা কীভাবে সামলেছে?

একটি জনপ্রিয় ভাষায় নতুন reserved word যোগ করার মানে, পৃথিবীর যত কোডে সেই শব্দটি নাম হিসেবে ব্যবহার হয়েছে, সব হঠাৎ অবৈধ। Python-এ async আর await-এর গল্প এর উদাহরণ: Python 3.5-এ এগুলো এসেছিল প্রসঙ্গ-নির্ভর শব্দ হিসেবে, আর 3.7-এ পূর্ণ reserved keyword হয়; মাঝের সময়টি পুরোনো কোডকে নাম বদলানোর সুযোগ দেওয়ার জন্য। তারপরও কিছু লাইব্রেরিকে async নামের parameter বদলাতে হয়েছিল।

Structural pattern matching (Python 3.10, PEP 634) আনার সময় সমস্যাটি আরও বড় ছিল: match খুব সাধারণ একটি শব্দ, re.match থেকে শুরু করে অসংখ্য variable-এর নাম। সমাধান ছিল soft keyword: match আর case শুধু statement-এর শুরুতে নির্দিষ্ট আকারে বসলে keyword, বাকি সব জায়গায় সাধারণ নাম। এটি সম্ভব হয়েছিল কারণ Python 3.9 থেকে নতুন PEG parser (PEP 617) এসেছে, যা প্রয়োজনে পেছনে ফিরে অন্য ব্যাখ্যা চেষ্টা করতে পারে; পুরোনো LL(1) parser-এ এটি অনেক কঠিন হতো। পরে 3.12-এ type একই পথে এসেছে। আমার যন্ত্রে Python 3.14.4-এ keyword.kwlist-এ ৩৫টি keyword আর keyword.softkwlist-এ চারটি: _ case match type (সত্যিকারের run).

অন্য ভাষাও একই পথে: C#-এ var, async, yield contextual keyword; Java 10-এ var keyword না হয়ে “reserved type name” হলো, যাতে var নামের পুরোনো variable ভাঙে না (শুধু var নামের class আর বানানো যায় না)। C++11-এ override আর final শুধু নির্দিষ্ট জায়গায় বিশেষ অর্থ পায়। C কিছুটা ভিন্ন কৌশল নিয়েছিল: C99-এর _Bool-এর মতো keyword এমন বানানে আনা হয়েছিল (underscore আর বড় হাতের অক্ষর দিয়ে শুরু), যা standard আগে থেকেই বাস্তবায়নের জন্য সংরক্ষিত রেখেছিল; C23-এ এসে bool, true, false পূর্ণ keyword হলো।

দামটি lexer আর parser-এর ঘাড়ে পড়ে: contextual keyword মানে lexer আর একা বলতে পারে না একটি শব্দ keyword নাকি নাম; parser-কে প্রসঙ্গ দেখে ঠিক করতে হয়। এটি সেই পুরোনো FORTRAN-PL/I সমস্যারই ছোট, নিয়ন্ত্রিত সংস্করণ। Haat v1 সরল পথ নিয়েছে: দশটি পূর্ণ keyword, কোনো soft keyword নেই, আর type-এর নাম keyword নয়।

মূল উপলব্ধি: keyword-এর তালিকা একটি ভাষার সবচেয়ে কঠিন-বদলানো binding; contextual keyword হলো পেছনের দিকের সামঞ্জস্য (backward compatibility) রক্ষার জন্য parser-এ জটিলতা মেনে নেওয়ার একটি আপস।

প্র ০৫Python-এ type hint লিখলে কি variable-এর type binding static হয়ে যায়?

না, আর এই পার্থক্যটি binding time-এর একটি চমৎকার উদাহরণ। rate: int = 10 লিখলে CPython চলার সময় এটি যাচাই করে না; পরের লাইনে rate = "ten" লিখলে program নির্বিঘ্নে চলবে। অংশ ৪-এর কোডে দেখেছেন, Python-এ নামের সঙ্গে type বাঁধা নয়, object-এর সঙ্গে বাঁধা; hint সেই নিয়ম বদলায় না। Annotation শুধু একটি তথ্য হিসেবে রাখা হয় (যেমন function-এর __annotations__-এ), আর Python 3.14-এ সেগুলো হিসাবও হয় দেরিতে, প্রয়োজন হলে তবেই (PEP 649 আর PEP 749). অংশ ৫-এর symtable-এ যে __annotate__ scope দেখেছিলেন, তা এই নতুন ব্যবস্থার অংশ।

তাহলে hint-এর লাভ কোথায়? আলাদা একটি tool, যেমন mypy বা pyright, program চালানোর আগে hint পড়ে type-এর অসংগতি খোঁজে। অর্থাৎ type binding-এর একটি দ্বিতীয়, static স্তর তৈরি হয়, যা ভাষার নিজের নয়, tool-এর। এই ধারণার নাম gradual typing: program-এর কিছু অংশে type লেখা, কিছু অংশে নয়, আর লেখা অংশটুকু static ভাবে যাচাই (পর্ব ৩৯)। TypeScript একই পথের আরেকটি উদাহরণ: type যাচাই compile-এর সময় হয়, তারপর type মুছে সাধারণ JavaScript তৈরি হয়, আর চলার সময় type-এর কোনো চিহ্ন থাকে না।

এর একটি বাস্তব সতর্কতা আছে। Static checker যা বলছে আর program আসলে যা করছে, দুটি আলাদা জগৎ। একটি লাইব্রেরি hint-এ int বললেও চলার সময় str ফেরত দিতে পারে, আর checker তা জানবে না। Haat-এর মতো ভাষায় এই ফাঁক নেই: type checker ভাষার অংশ, আর type-এর binding compile-এর সময় হয়ে চলার সময় পর্যন্ত সত্য থাকে। এই “সত্য থাকা”-র আনুষ্ঠানিক রূপ type soundness, যা পর্ব ৩৮-এ প্রমাণ করবেন। Java-র generics-এ আরেকটি মাঝামাঝি অবস্থা দেখা যায়: type যাচাই compile-এর সময়, কিন্তু generic type-এর তথ্য চলার সময় মুছে যায় (erasure, পর্ব ৩৭)।

Python-এর দিক থেকে type hint-এর ব্যবহারিক দিক আছে Python কোর্সের type hint পর্বে.

মূল উপলব্ধি: type binding কোন সময়ে হয়, তা ভাষার অর্থ ঠিক করে; Python-এর hint ভাষার binding বদলায় না, শুধু একটি আলাদা static যাচাইয়ের স্তর যোগ করে, যার নিশ্চয়তা ভাষার নিজের type system-এর নিশ্চয়তার চেয়ে দুর্বল।

অনুশীলন

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

  1. বাস্তবায়ন — block scope যোগ করুন: অংশ ৮-এর ছোট resolver-এ একটি ("block", None, uses, [stmts]) ধরন যোগ করুন, যা Haat-এর { … }-এর মতো নতুন scope খোলে কিন্তু নতুন frame নয় (ঘরের গণনা একই function-এ চলতে থাকে)। একই scope-এ দ্বিতীয়বার একই নাম ঘোষণা করলে 'x' is already declared in this scope error দিন। তারপর নিচের Haat function-টি tuple-এ লিখে চালান, আর reference-এর check-এর সঙ্গে মেলান।
    fn bill(qty: Int, unit: Int) -> Int {
        let base = qty * unit;
        if base >= 1000 {
            let cut = base / 10;
            return base - cut;
        }
        let fee = 60;
        let base = 0;
        return base + fee + cut;
    }

    walk-এর elif kind in ("let", "param") শাখা বদলে, আর একটি নতুন শাখা যোগ করে:

            elif kind in ("let", "param"):
                if name in scopes[-1]:
                    print(f"  error: '{name}' is already declared in this scope")
                else: declare(name, kind)
            elif kind == "block":
                scopes.append({}); walk(body[0]); scopes.pop()  # same frame
    
    prog = [("fn", "bill", [], [
                ("param", "qty", []), ("param", "unit", []),
                ("let", "base", ["qty", "unit"]),
                ("block", None, ["base"], [            # if base >= 1000 { ... }
                    ("let", "cut", ["base"]),
                    ("ret", None, ["base", "cut"])]),
                ("let", "fee", []),
                ("let", "base", []),                   # same scope: an error
                ("ret", None, ["base", "fee", "cut"])])]

    Python 3.14-এ চালানো ফল:

    bind bill     fn    depth 0 slot 0
    bind qty      param depth 1 slot 0
    bind unit     param depth 1 slot 1
      use qty      -> param at depth 1, slot 0
      use unit     -> param at depth 1, slot 1
    bind base     let   depth 1 slot 2
      use base     -> let at depth 1, slot 2
      use base     -> let at depth 1, slot 2
    bind cut      let   depth 1 slot 3
      use base     -> let at depth 1, slot 2
      use cut      -> let at depth 1, slot 3
    bind fee      let   depth 1 slot 4
      error: 'base' is already declared in this scope
      use base     -> let at depth 1, slot 2
      use fee      -> let at depth 1, slot 4
      error: undefined variable 'cut'

    Reference-এর আসল ফল: 8:9: error: 'base' is already declared in this scope আর 9:25: error: undefined variable 'cut'. দুটিই মিলেছে। cut-এর ঘর (slot 3) block শেষ হলেও ফেরত যায়নি, তাই fee পেয়েছে slot 4: reference-ও ঘর পুনর্ব্যবহার করে না। কিন্তু block-এর scope শেষ, তাই শেষ লাইনের cut আর খুঁজে পাওয়া যায় না। এখানেই scope আর storage-এর পার্থক্য: নামটি অদৃশ্য, ঘরটি frame-এ রয়ে গেছে। এই নমুনায় এখনো একটি নিয়ম নেই: Haat-এর “ঘোষণার আগে ব্যবহার” নিয়ম (নকশা-সিদ্ধান্ত ১৬), যা পর্ব ১৫-এ আসবে।

  2. ভুল খুঁজুন — binding time-এর টেবিল: একজন শিক্ষার্থী নিচের টেবিল লিখেছেন। প্রতিটি সারিতে binding time ঠিক নাকি ভুল, বলুন, আর ভুল হলে ঠিক উত্তর আর কারণ দিন।
    (ক) C17-এ int কত বিট                        → ভাষা নকশার সময়
    (খ) Python 3-এ একটি local নামের সঙ্গে type  → compile time
    (গ) Haat-এ top-level let rate-এর global ঘর নম্বর → run time
    (ঘ) Java-তে overload করা println(int) বনাম println(String) বাছাই → run time
    (ঙ) Haat-এ + চিহ্ন Int-এর যোগ নাকি Str-এর জোড়া → compile time
    1. (ক) ভুল: বাস্তবায়নের সময়। C standard শুধু বলে int অন্তত ১৬ বিট আর একটি নির্দিষ্ট পরিসর ধরতে পারবে; আসল আকার ঠিক করে compiler আর লক্ষ্য platform. ভাষা নকশায় বাঁধা হয়েছে শুধু ন্যূনতম সীমা।
    2. (খ) ভুল: run time. Compile-এর সময় শুধু নামটির শ্রেণি (local) বাঁধা হয়, যা symtable দেখায়। Type আসে চলার সময় নামটি যে object-এ বাঁধা, তার থেকে, আর পরের assignment-এ বদলাতে পারে।
    3. (গ) ভুল: compile time. Reference-এর resolver চালানোর আগেই rate-কে global ঘর 1 দেয়; dis-এ সরাসরি LOAD_GLOBAL 1 দেখা যায়। Run time-এ বাঁধা হয় শুধু ঘরের মান (DEFINE_GLOBAL 1).
    4. (ঘ) ভুল: compile time. Java compiler argument-এর static type দেখে overload-এর স্বাক্ষর বেছে নেয়। Run time-এ যা বাঁধা হয়, তা হলো override-এর বাছাই (dynamic dispatch), যা এখানে প্রশ্ন নয়।
    5. (ঙ) ঠিক: Haat-এর type checker বাঁ operand-এর type দেখে ঠিক করে; Int, Int হলে যোগ, Str, Str হলে জোড়া (নকশা-সিদ্ধান্ত ১১)। VM-এ দুটিই একই ADD opcode, কিন্তু checker নিশ্চিত করেছে যে দুই operand-এর type মেলে।
  3. আউটপুট অনুমান করুন: Python 3.14-এ নিচের কোড কী ছাপবে? প্রতিটি লাইনের পরে কোন নাম কোন object-এ বাঁধা, লিখুন।
    a = [1, 2]
    b = a
    a += [3]
    c = a
    a = a + [4]
    print(b, c, a, b is c)

    Python 3.14-এ চালানো ফল: [1, 2, 3] [1, 2, 3] [1, 2, 3, 4] True.

    1. a = [1, 2]: a → A = [1, 2].
    2. b = a: b → A (alias).
    3. a += [3]: list-এর জন্য += object-টিকেই বদলায় (in-place), তাই A = [1, 2, 3], আর a আর b দুটিই A-তে। এটিই ফাঁদ: a = a + [3] লিখলে নতুন object হতো।
    4. c = a: c → A.
    5. a = a + [4]: নতুন object B = [1, 2, 3, 4], a → B. b আর c এখনো A-তে, তাই b is c = True.
  4. Trace — ঘরের নম্বর গণনা: Haat reference প্রতিটি function-এর ঘোষণাকে ক্রমানুসারে local ঘর দেয় (parameter থেকে শুরু), আর ঘর কখনো পুনর্ব্যবহার করে না। নিচের program-এ bill-এর প্রতিটি নাম কোন slot পাবে, dis-এ “locals” কত দেখাবে, আর program কী ছাপবে?
    fn bill(qty: Int, unit: Int) -> Int {
        let base = qty * unit;
        if base >= 1000 {
            let cut = base / 10;
            return base - cut;
        }
        let fee = 60;
        return base + fee;
    }
    print(bill(2, 520));
    print(bill(1, 300));

    qty → 0, unit → 1, base → 2, cut → 3, fee → 4; তাই locals 5. আউটপুট: 2 × 520 = 1040 ≥ 1000, তাই 1040 − 104 = 936; 1 × 300 = 300 < 1000, তাই 300 + 60 = 360. Reference-এর আসল dis-এর শুরু আর গুরুত্বপূর্ণ লাইন (সত্যিকারের run):

    == bill (arity 2, locals 5) ==
       0  LOAD_LOCAL     0     ; qty
       1  LOAD_LOCAL     1     ; unit
       2  MUL
       3  STORE_LOCAL    2     ; base
      ...
      11  STORE_LOCAL    3     ; cut
      ...
      17  STORE_LOCAL    4     ; fee

    আর python haat.py run ছাপে 936 আর 360. লক্ষ করুন, cut আর fee কখনো একসঙ্গে বেঁচে থাকে না (একটি return-এর পথে, অন্যটি অন্য পথে), তাই একই ঘর ভাগ করতে পারত। একটি optimizing compiler ঠিক এই কাজ করে; সেই পদ্ধতি register allocation-এ (পর্ব ৭০) আসবে, যেখানে “একসঙ্গে বেঁচে থাকা” মাপা হয় liveness দিয়ে (পর্ব ৬৪)।

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

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

ক্রমHaat-এর let rate = 10;-এর binding-গুলো আগে থেকে পরে, সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. ভাষা নকশা: let মানে বদলানো যায় না, Int মানে ৬৪-বিট
  2. বাস্তবায়ন: Int রাখা হবে Python int-এ, wrap() দিয়ে
  3. Compile: lexer rate-কে IDENT token বানায়
  4. Compile: resolver rate-কে একটি global ঘর দেয়
  5. Load: VM খালি (UNSET) global ঘর তৈরি করে
  6. Run: DEFINE_GLOBAL ঘরে 10 লেখে

C17-এ int type কত বিটের হবে, তা কোন binding time-এ ঠিক হয়?

  • ভাষা নকশার সময়
  • ভাষার বাস্তবায়নের সময়
  • প্রতিটি program-এর compile time
  • Run time

Python 3-এ rate = 10-এর পরে rate = "ten" চালালে কী ঘটে?

  • TypeError, কারণ rate-এর type int
  • "ten" রূপান্তরিত হয়ে int-এ রাখা হয়
  • rate নামটি এখন একটি str object-এ বাঁধা; type(rate) হবে str
  • আগের int object-এর ভেতরের মান "ten"-এ বদলে যায়

JavaScript-এ "use strict"; const order = { total: 1040 }; order.total = 936; console.log(order.total); কী ঘটবে?

  • 936 ছাপা হবে
  • TypeError: Assignment to constant variable.
  • 1040 ছাপা হবে, কারণ assignment নীরবে উপেক্ষিত
  • undefined ছাপা হবে

Haat-এ (যেখানে Int একটি keyword নয়, সাধারণ নাম) let Int = 3; let x: Int = Int + 1; print(x); চালালে কী হবে?

  • Syntax error, কারণ Int একটি keyword
  • Type error, কারণ x-এর type এখন 3
  • 3 ছাপা হবে
  • 4 ছাপা হবে

Python 3-এ def outer(limit):-এর ভেতরে def inner(total): return total >= limit. CPython-এর symbol table অনুযায়ী inner-এর ভেতরে limit কোন শ্রেণির?

  • Local
  • Free (বাইরের function থেকে)
  • Global (implicit)
  • Built-in

“Aliasing” আর “overloading”-এর সঠিক বর্ণনা কোনটি?

  • Aliasing: এক নাম, অনেক সত্তা; overloading: অনেক নাম, এক ঘর
  • দুটি একই জিনিসের দুই নাম
  • Aliasing: অনেক নাম, এক ঘর; overloading: এক নাম, অনেক সত্তা, প্রসঙ্গ দেখে বাছাই
  • Aliasing শুধু pointer-এ হয়, overloading শুধু operator-এ

শব্দকোষ

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

মনে রাখুন

  1. Binding মানে একটি সত্তা আর তার বৈশিষ্ট্যের জোড়া; binding time মানে জোড়াটি কখন তৈরি হয়: ভাষা নকশা, বাস্তবায়ন, compile, link, load, run.
  2. Variable-এর ছয় বৈশিষ্ট্য: নাম, ঠিকানা (l-value), মান (r-value), type, lifetime, scope. Scope লেখার এলাকা, lifetime সময়ের এলাকা।
  3. নাম থেকে মান দুই ধাপে: environment ρ (নাম → ঘর) আর store σ (ঘর → মান)। Assignment σ বদলায়, ঘোষণা ρ বদলায়; aliasing মানে ρ(x) = ρ(y).
  4. Static binding চালানোর আগে হয় আর বদলায় না; dynamic binding চলার সময় হয় বা বদলায়। CPython-ও নামের শ্রেণি (local, free, global) compile-এর সময় বাঁধে; Haat ঘরের নম্বরও বাঁধে।
  5. Overloading: এক নাম, অনেক সত্তা। Keyword, reserved word, contextual keyword আর predeclared নাম আলাদা; Haat-এ print keyword, Int শুধু নাম।

পরের পর্বে: একটি নাম-ব্যবহার কোন ঘোষণাকে বোঝায়, সেই নিয়মের নাম scope. পর্ব ১৫-এ static আর dynamic scoping: একই program দুই নিয়মে দুই রকম উত্তর দেবে, তা নিজে একটি ছোট interpreter-এ চালিয়ে দেখবেন, আর Haat-এর “ঘোষণার আগে ব্যবহার” নিয়মের আসল error-ও।

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

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