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

Scripting আর dynamic ভাষা — duck typing, eval আর reflection

Scripting and Dynamic Languages — Dynamic Typing, Duck Typing, Late Binding, Reflection, eval and Monkey Patching

Taught in Bangla, this lesson explains dynamic languages, where types and names are resolved at run time. One error, total + " taka", is rejected by Haat before running, raises TypeError in Python and silently concatenates in JavaScript. Duck-typed orders give 2126 in Python and JavaScript, a stepper walks Python attribute lookup through instance, class, MRO and descriptors, and a safe evaluator replaces eval with parsing. It covers reflection, monkey patching and CPython 3.14's BINARY_OP_ADD_INT specialization.

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

  • Dynamic typing, strong ও weak typing আলাদা করা, আর একটি type ভুল কোন ভাষায় কখন ধরা পড়ে তা অনুমান ও যাচাই করা
  • Duck typing আর late binding দিয়ে একটি বাস্তব হিসাব লেখা, আর তার সুবিধা ও ঝুঁকি বিচার করা
  • Python-এ o.x লিখলে চলার সময় কোন ক্রমে খোঁজা হয় (instance, class, MRO, descriptor) তা ধাপে ধাপে বের করা
  • eval-এর নিরাপত্তা-ঝুঁকি বুঝে নিরাপদ বিকল্প, অর্থাৎ parse করে নিজের ছোট interpreter দিয়ে হিসাব, তৈরি করা
  • Reflection, monkey patching আর dynamic ভাষার গতির খরচ, আর এই বিষয়ে AI-এর দাবি যাচাইয়ের উপায় জানা

১ · Scripting আর dynamic ভাষা — কী, কেন আর কোথা থেকে

বাজারঘরের অফিসে প্রতিদিন সকালে একটি ছোট কাজ: আগের দিনের অর্ডারের CSV ফাইল খোলা, ঢাকার অর্ডারগুলো আলাদা করা, মোট বের করা, আর হিসাবরক্ষককে একটি মেইল পাঠানো। এই কাজের জন্য কেউ C-তে বড় program লেখেন না। কেউ দশ লাইনের একটি Python বা shell script লেখেন, একবার চালিয়ে দেখেন, একটু বদলান, আবার চালান। এই “লিখি, চালাই, বদলাই” চক্রই scripting-এর প্রাণ।

দুই রকম রান্নার কথা ভাবুন। বিয়েবাড়ির বাবুর্চি আগে থেকে পুরো তালিকা বানান: কত কেজি চাল, কোন হাঁড়ি, কে কখন কী করবে; শুরুর আগেই সব মেলানো হয়। বাড়ির রান্নাঘরে মা চেখে চেখে রাঁধেন: লবণ কম মনে হলে তখনই দেন, হাতের কাছে যে পাত্র আছে সেটিই নেন। প্রথমটি static ভাষার মতো (আগে যাচাই, পরে কাজ), দ্বিতীয়টি dynamic ভাষার মতো (কাজ করতে করতে সিদ্ধান্ত)। দুটিতেই ভালো রান্না হয়; ঝুঁকি আর গতি আলাদা জায়গায়।

সংজ্ঞা ১২.১ — dynamic ভাষা আর scripting ভাষা

Dynamic ভাষা বলতে এমন ভাষা বোঝায়, যেখানে অনেক binding সিদ্ধান্ত চালানোর আগে (static বা compile time) নয়, চলার সময় (dynamic বা run time) নেওয়া হয়: একটি variable-এ কোন type-এর মান থাকবে, o.total নামে কোন function চলবে, একটি object-এ কোন কোন field আছে, এমনকি কোন কোড চলবে (eval). Scripting ভাষা একটি ব্যবহারের নাম, কঠিন সংজ্ঞা নয়: যে ভাষা ছোট program দ্রুত লিখতে, অন্য program আর ফাইলকে জুড়ে কাজ করাতে (glue), আর আলাদা compile ধাপ ছাড়াই চালাতে সুবিধা দেয়। বাস্তবে বেশির ভাগ scripting ভাষা dynamic, কিন্তু দুটি শব্দ এক নয়।

আবার “interpreted” আর “dynamic” এক কথা নয়: পর্ব ০৪-এ (অনুবাদক) দেখেছেন, CPython আগে bytecode-এ compile করে তারপর চালায়, আর JavaScript engine JIT compiler ব্যবহার করে। Dynamic হওয়া ভাষার semantics-এর গুণ, বাস্তবায়ন কীভাবে করা হলো তার নয়।

ছোট ইতিহাস: shell থেকে browser পর্যন্ত

বিস্তারিত সময়রেখা আছে পর্ব ০২-এ (প্রোগ্রামিং ভাষার ইতিহাস আর পরিবার); এখানে শুধু scripting-এর ধারা। Unix-এর shell (Thompson shell ১৯৭১, পরে Bourne shell, যা ১৯৭৯ সালের Version 7 Unix-এর সঙ্গে ব্যাপকভাবে ছড়ায়) ছোট ছোট program-কে pipe দিয়ে জুড়ত। awk (১৯৭৭, Aho, Weinberger, Kernighan) লেখা ফাইলের সারি ধরে হিসাব সহজ করে। Larry Wall-এর Perl (১৯৮৭) এই দুইয়ের মাঝের জায়গা নেয়। John Ousterhout-এর Tcl (১৯৮৮-এর দিকে শুরু) একটি ছোট ভাষাকে বড় C program-এর ভেতরে বসানোর ধারণা জনপ্রিয় করে, আর ব্রাজিলের PUC-Rio-তে তৈরি Lua (১৯৯৩) সেই “ভেতরে বসানো” পথে আজ বহু game আর tool-এর script ভাষা। Python (১৯৯১, Guido van Rossum), JavaScript (১৯৯৫, Brendan Eich, Netscape), Ruby আর PHP (দুটিই ১৯৯৫-এর আশপাশে) এই ধারাকে মূলধারায় আনে।

কিন্তু dynamic ধারণাগুলো scripting-এর চেয়ে পুরোনো। LISP (১৯৫৮–৬০) থেকেই মান-এর সঙ্গে type-এর চিহ্ন, চলার সময় কোড বানিয়ে চালানো (eval), আর একটি লাইন লিখে সঙ্গে সঙ্গে ফল দেখার REPL (read–eval–print loop) এসেছে। Smalltalk (১৯৭০-এর দশক) প্রমাণ করে যে পুরো একটি পরিবেশ চলতে চলতে নিজের class বদলাতে পারে।

🏷️ Dynamic typing

Type থাকে মানের গায়ে, যাচাই হয় লাইন চলার সময়। অংশ ২।

strong বনাম weak

🦆 Duck typing

Type-এর নাম নয়, দরকারি method আছে কি না। অংশ ৩–৪।

late binding

🪞 Reflection আর eval

Program নিজেকে দেখে, আর লেখা থেকে কোড বানায়। অংশ ৫–৬।

শক্তি আর বিপদ

🩹 Monkey patching

চলন্ত program-এ function বদলানো, আর তার দাম। অংশ ৭–৮।

optimize করা কঠিন

মডিউল ২-এর সব পর্বে একই কাজ আলাদা ধাঁচে সমাধান হচ্ছে: বাজারঘরের অর্ডারের তালিকা; প্রতিটি লাইনে পণ্য, পরিমাণ আর একক দাম; অর্ডারের মোট ১০০০ টাকা বা বেশি হলে ১০% ছাড়; শুধু একটি জেলার অর্ডার রেখে সব যোগ। চারটি অর্ডার: ঢাকা (চাল 2 × 520), রাজশাহী (ডাল 3 × 120, তেল 1 × 180), ঢাকা (চিনি 4 × 150, চা 2 × 250), ঢাকা (লবণ 5 × 40). পর্ব ০৭ আর পর্ব ০৯-এ ঢাকার উত্তর এসেছে 2126; এখানে একই উত্তর আসবে, কিন্তু অর্ডারগুলো হবে আলাদা আকারের object, আর ভাষা চলার সময় দেখে নেবে কার কী আছে।

২ · Dynamic typing — type থাকে মানের গায়ে

Static ভাষায় type হলো নামের (বা expression-এর) গুণ: Haat-এ total: Int লিখলে compiler আগেই জানে, total-এ সবসময় একটি Int থাকবে। Dynamic ভাষায় নামের কোনো type নেই; type হলো মানের গুণ। Python-এ x = 1040-এর পর x = "Dhaka" সম্পূর্ণ বৈধ, কারণ x শুধু একটি লেবেল, যা এখন একটি string object-এর দিকে নির্দেশ করে। প্রতিটি মান নিজের সঙ্গে একটি type tag বহন করে, আর প্রতিটি operation চলার মুহূর্তে সেই tag দেখে সিদ্ধান্ত নেয়।

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

একটি বাজারঘরের লেবেল-function দিয়ে তুলনা করি। ১০০০ টাকা বা বেশি হলে “free delivery”, না হলে মোটের সঙ্গে “ taka” জুড়ে লেখা। কোডে একটি ভুল আছে: একটি সংখ্যার সঙ্গে একটি string যোগ। Haat-এ লেখা program আর কোর্সের Haat reference বাস্তবায়নের সত্যিকারের run (CPython 3.14.4-এ, haat.py check আর run দুটিতেই একই বার্তা, আর কোনো লাইন ছাপা হয়নি):

fn label(total: Int) -> Str {
    if total >= 1000 { return "free delivery"; }
    return total + " taka";
}
print(label(1040));
print(label(540));
~/haat $ python haat.py run label.haat
3:12: error: type mismatch: expected Str, found Int
3:20: error: type mismatch: expected Int, found Str

দুটি error-ই লাইন ৩-এর: কলাম ১২-তে total + … একটি Int দেয়, কিন্তু function-এর ফেরত type Str; কলাম ২০-তে +-এর বাঁ দিক Int, তাই ডান দিকও Int হওয়ার কথা, কিন্তু সেটি Str. সবচেয়ে গুরুত্বপূর্ণ কথা: label(1040) ভুল লাইনটি ছোঁয়ই না, তবু program-এর একটি লাইনও চলেনি। Haat-এর type checker পুরো program আগে পড়ে, তারপর চালাতে দেয়। একই কাজ Python 3.14 আর JavaScript-এ কী করে, নিচের stepper-এ ধাপে ধাপে দেখুন; Python আর JavaScript-এর আউটপুট সত্যিকারের run থেকে নেওয়া।

1label(total):2  if total >= 1000:3    return "free delivery"4  return total + " taka"5print(label(1040))6print(label(540))
এই ধাপে
ভাষা
কখন
tag
  1. Haat: চালানোর আগেই। Type checker দেখে total নামের type Int, আর Int + Str-এর কোনো নিয়ম নেই। দুটি error, আর একটি লাইনও চলে না। ভুল লাইনটি কোনো test-এ না পৌঁছালেও ধরা পড়ত।
  2. Python: প্রথম call নিরাপদ। label(1040)-এ শর্ত সত্য, তাই লাইন ৪ চলেই না, আর “free delivery” ছাপা হয়। Python কোনো আপত্তি করেনি, কারণ ভুলটি এখনো “ঘটেনি”।
  3. Python: চলার মুহূর্তে ধরা। label(540)-এ লাইন ৪ চলে। + দুই মানের tag দেখে: int আর str. Python-এ এই জোড়ার কোনো নিয়ম নেই, তাই TypeError. প্রথম লাইনের আউটপুট আগেই ছাপা হয়ে গেছে।
  4. JavaScript: চুপচাপ রূপান্তর। একই জায়গায় JavaScript-এর + দেখে একটি দিক string, তাই 540-কে string বানিয়ে জুড়ে দেয়: “540 taka”. কোনো error নেই; ভুলটি থেকে যায়, শুধু আউটপুটে লুকিয়ে।
  5. তিন মুহূর্ত। Static ভাষা চালানোর আগে, strong dynamic ভাষা লাইনটি চলার সময়, আর weak dynamic ভাষা হয়তো কখনোই নয়। কোন test কোন লাইন ছোঁয়, dynamic ভাষায় সেটিই নিরাপত্তার সীমা।

নিয়মে লেখা: static rule বনাম dynamic rule

পার্থক্যটি দুই ধরনের নিয়মে স্পষ্ট। Static নিয়ম লেখা হয় typing judgment দিয়ে: Γ ⊢ e : τ পড়ুন “Γ (নাম থেকে type-এর তালিকা) জানা থাকলে expression e-এর type τ”। Dynamic নিয়ম লেখা হয় big-step evaluation দিয়ে: e ⇓ v পড়ুন “e চালালে মান v পাওয়া যায়”, আর এখানে প্রতিটি মান একটি tag সহ লেখা, যেমন Int(540) বা Str(" taka"). প্রতিটি নিয়মে দাগের ওপরে শর্ত (premise), নিচে সিদ্ধান্ত, ডানে নিয়মের নাম।

Γ ⊢ e1 : Int    Γ ⊢ e2 : Int
Γ ⊢ e1 + e2 : Int
(T-Add, Haat)
e1 ⇓ Int(n1)    e2 ⇓ Int(n2)
e1 + e2 ⇓ Int(n1 + n2)
(E-AddInt)
e1 ⇓ v1    e2 ⇓ v2    tag(v1), tag(v2)-এর কোনো নিয়ম নেই
e1 + e2 ⇓ TypeError
(E-AddErr, Python)

T-Add চালানোর আগে প্রয়োগ হয়, আর তার শর্ত না মিললে program-টি বাতিল। E-AddInt আর E-AddErr প্রয়োগ হয় প্রতিবার + চলার সময়, আর tag দেখে কোন নিয়ম খাটবে তা ঠিক হয়। তাই dynamic ভাষার interpreter-এ প্রতিটি operation-এর ভেতরে একটি লুকানো “if tag == …” থাকে। JavaScript-এ E-AddErr-এর বদলে একটি রূপান্তরের নিয়ম আছে: দুই দিককে প্রথমে primitive মানে আনা হয়, আর কোনো একটি string হলে দুটিকেই string বানিয়ে জোড়া হয়। এই নিয়মগুলোর পূর্ণ গাণিতিক রূপ আসবে পর্ব ৪০-এ (Operational semantics) আর পর্ব ৩৪-এ (Typing rule আর type judgment).

সংজ্ঞা ১২.২ — strong আর weak typing

এই দুটি শব্দের কোনো সর্বসম্মত গাণিতিক সংজ্ঞা নেই; বইভেদে অর্থ একটু আলাদা। এই কোর্সে: একটি ভাষা strong typed, যদি অমিল type-এর operation চুপচাপ রূপান্তর না করে error দেয় (Python-এর 540 + " taka"); weak typed, যদি নিজে থেকে রূপান্তর করে ফল বানায় (JavaScript-এর "1040" + 60 = "104060", C-এর অনেক implicit conversion). Static/dynamic প্রশ্ন হলো “কখন যাচাই”, strong/weak প্রশ্ন হলো “অমিল হলে কী”। তাই Python dynamic আর strong, C static কিন্তু তুলনামূলক weak, Haat static আর strong (কোনো implicit conversion নেই)।

JavaScript-এর রূপান্তরের পুরো তালিকা আর তার ফাঁদ আছে JavaScript কোর্সের পর্ব ০৬-এ (মান, টাইপ আর coercion-এর ফাঁদ); type system-এর শ্রেণিবিভাগ আসবে পর্ব ৩৩-এ (Type system — static, dynamic, strong আর weak typing). Dynamic typing মানে “type নেই” নয়; type আছে, শুধু যাচাই সরে গেছে চলার সময়ে।

৩ · Duck typing আর late binding — “পারলেই চলবে”

“যদি হাঁসের মতো হাঁটে আর হাঁসের মতো ডাকে, তবে সেটিকে হাঁস বলেই ধরা যায়।” এই প্রবাদ থেকে নাম duck typing. একটি function জানতে চায় না তার argument কোন class-এর; জানতে চায় শুধু, যে কাজগুলো সে করাবে, সেগুলো এই object পারে কি না। Java বা Haat-এর মতো static ভাষায় ভাবনাটি উল্টো: আগে type ঘোষণা (Order, বা একটি interface), তারপর ব্যবহার।

সংজ্ঞা ১২.৩ — duck typing আর late binding

Duck typing: একটি মান কোনো কাজে চলবে কি না, তা ঠিক হয় তার ঘোষিত type বা বংশ দেখে নয়, বরং ব্যবহারের মুহূর্তে দরকারি attribute বা method পাওয়া যায় কি না দেখে। Late binding: একটি নাম (o.total, একটি global function-এর নাম) কোন জিনিস বোঝায়, তা ঠিক হয় যত দেরিতে সম্ভব, অর্থাৎ প্রতিবার নামটি ব্যবহারের সময়, লেখার বা compile-এর সময় নয়।

Duck typing-এর static যমজ ভাইও আছে: structural typing, যেখানে compiler নিজে দেখে একটি type-এ দরকারি সব method আছে কি না (Go-র interface, TypeScript, Python-এর typing.Protocol-এর type checker). দুটির প্রশ্ন একই (“পারে কি?”), শুধু উত্তর খোঁজার সময় আলাদা: structural typing চালানোর আগে, duck typing চলার সময়। Python-এ এই তিন রূপ (ABC, duck typing, Protocol) পাশাপাশি আছে Python কোর্সের পর্ব ৩৫-এ.

এবার বাজারঘরের কাজ। তিন রকম অর্ডার: ওয়েবসাইট থেকে আসা WebOrder (লাইনের তালিকা আছে), ফোনে নেওয়া PhoneOrder (শুধু মোট টাকা), আর দোকানের কাউন্টারের একটি হাতে বানানো object. তাদের মধ্যে কোনো সাধারণ base class নেই। district_sum শুধু দুটি জিনিস চায়: .district আর .total(). তালিকায় একটি “ভাঙা” অর্ডারও আছে, সিলেটের, যার total নেই।

from types import SimpleNamespace; import inspect

def discounted(t): return t - t // 10 if t >= 1000 else t

class WebOrder:                          # lines kept as tuples
    def __init__(self, district, lines):
        self.district, self.lines = district, lines
    def total(self): return discounted(sum(q * u for _, q, u in self.lines))

class PhoneOrder:                        # no common base class with WebOrder
    def __init__(self, district, amount):
        self.district, self.amount = district, amount
    def total(self): return discounted(self.amount)

shop_order = SimpleNamespace(district="Dhaka", total=lambda: 200)
broken = SimpleNamespace(district="Sylhet")          # has no total()

orders = [WebOrder("Dhaka", [("rice", 2, 520)]),
          WebOrder("Rajshahi", [("lentil", 3, 120), ("oil", 1, 180)]),
          PhoneOrder("Dhaka", 4 * 150 + 2 * 250), shop_order, broken]

def district_sum(orders, d):             # needs only .district and .total()
    return sum(o.total() for o in orders if o.district == d)

print("Dhaka:", district_sum(orders, "Dhaka"))
try:
    print("Sylhet:", district_sum(orders, "Sylhet"))
except AttributeError as e:
    print("AttributeError:", e)

for o in orders[:3]:                     # reflection: ask the object itself
    print(type(o).__name__, hasattr(o, "total"), getattr(o, "district"))
print(inspect.signature(WebOrder.__init__))
setattr(broken, "total", lambda: 0)      # add a method while running
print("Sylhet now:", district_sum(orders, "Sylhet"))

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

Dhaka: 2126
AttributeError: 'types.SimpleNamespace' object has no attribute 'total'
WebOrder True Dhaka
WebOrder True Rajshahi
PhoneOrder True Dhaka
(self, district, lines)
Sylhet now: 0

ঢাকার মোট 2126, পর্ব ০৭ আর ০৯-এর সঙ্গে হুবহু: 936 (WebOrder) + 990 (PhoneOrder, 1100 থেকে ছাড়) + 200 (কাউন্টারের object). তিনটি object তিন আলাদা type, তবু একই o.total() লেখা প্রত্যেকের নিজের total চালিয়েছে; এটিই late binding. সবচেয়ে শিক্ষণীয় লাইন দ্বিতীয়টি: ভাঙা অর্ডারটি পুরো সময় তালিকায় ছিল, কিন্তু ঢাকার হিসাবে filter তাকে বাদ দিয়েছিল, তাই কেউ টের পায়নি। সিলেটের হিসাব চাওয়া মাত্র AttributeError. Static ভাষায় এই object তালিকায় ঢোকারই অনুমতি পেত না। শেষের লাইনগুলো reflection (অংশ ৫): object-কে জিজ্ঞেস করা “total আছে কি?” (hasattr), নাম string হিসেবে দিয়ে attribute পড়া (getattr), function-এর parameter তালিকা পড়া (inspect.signature), আর চলার সময় একটি method জুড়ে দেওয়া (setattr), যার পর সিলেটের হিসাব আর ভাঙে না।

Late binding-এর দুই মুখ

Late binding duck typing-কে সম্ভব করে, কিন্তু একই কারণে অবাক করা ফলও দেয়। Python-এ একটি loop-এর ভেতরে বানানো কয়েকটি closure সবাই loop variable-এর শেষ মান দেখে, কারণ নামটি খোঁজা হয় function ডাকার সময়, বানানোর সময় নয়; এই ফাঁদের বিস্তার আছে Python কোর্সের পর্ব ২০-এ. Haat-এর spec-ও closure-কে “by reference” ধরতে বলে, তবে Haat-এর while-এর প্রতিটি round একটি নতুন scope, তাই প্রতিটি round-এর closure নিজের variable পায়। Closure কীভাবে environment ধরে রাখে, তার পূর্ণ আলোচনা পর্ব ১৭-এ (Closure — lexical environment ধরে রাখা function).

Late binding-এর আরেকটি রূপ আপনি পর্ব ০৮-এ দেখেছেন: dynamic dispatch. পার্থক্য মাত্রায়। C++ বা Java-য় compiler আগেই জানে total নামে একটি method আছে, শুধু কোন class-এর সংস্করণ চলবে তা চলার সময় ঠিক হয়, vtable-এর একটি নির্দিষ্ট ঘর থেকে। Python বা JavaScript-এ এমনকি method টি আছে কি না, সেটিও চলার সময়ের প্রশ্ন; তাই vtable-এর ঘর নম্বর নয়, প্রতিবার নাম ধরে খোঁজ।

৪ · চলার সময় নাম খোঁজা — Python-এর object model আর JavaScript-এর property

“প্রতিবার নাম ধরে খোঁজ” কথাটির ভেতরে ঢুকি। CPython-এ প্রায় প্রতিটি সাধারণ object-এর একটি __dict__ থাকে: নাম থেকে মান-এর একটি dictionary. Object-টি জানে সে কোন class-এর (__class__), আর class নিজেও একটি object, যার নিজের __dict__ আর base class-এর তালিকা আছে। o.total লেখা মানে এই dictionary-গুলোর একটি নির্দিষ্ট ক্রমে খোঁজ।

ছবি ১২.১ — Python-এ একটি অর্ডার object আর তার পেছনের class-গুলো

প্রতিটি বাক্স একটি dictionary; তির ধরে খোঁজ চলে।

Python object model: instance dict, class Order, base Record, object, then AttributeError o (instance) district: "Dhaka" lines: [...] __class__ Order (class) __init__: function total: function __bases__ Record (base) currency: "BDT" object __repr__ … না পেলে AttributeError patch
ছবি ১২.১ — o.district পাওয়া যায় ওপরের বাক্সেই; o.total নেই instance-এ, তাই খোঁজ নামে Order-এ; o.currency আরও এক ধাপ নিচে Record-এ। এই সারি (Order → Record → object) হলো MRO. বাঁয়ের লাল দাগ: class-এর dictionary চলার সময়ও বদলানো যায় (monkey patch, অংশ ৭), আর পরের খোঁজ নতুন জিনিসটিই পায়।

খোঁজের নিয়মে একটি সূক্ষ্মতা আছে। Python প্রথমে class-এর সারিতে দেখে নামটি একটি data descriptor কি না (যেমন @property, যার পড়া আর লেখা দুই নিয়মই class ঠিক করে)। যদি হয়, সেটিই জেতে, instance-এর dictionary-তে একই নাম থাকলেও। না হলে instance-এর __dict__, তারপর class-এর সারির সাধারণ জিনিস (function পেলে তাকে object-এর সঙ্গে বেঁধে “bound method” বানানো হয়)। কোথাও না পেলে class-এ __getattr__ থাকলে সেটি ডাকা হয়, নইলে AttributeError. নিচের stepper-এ ছয়টি খোঁজ; প্রতিটি ফল CPython 3.14.4-এ চালিয়ে মেলানো।

  1. o.__dict__district, linesধাপ ১
  2. Order__init__, totalধাপ ২
  3. Recordcurrencyধাপ ৩
  4. object__repr__ …ধাপ ৪
  5. শেষAttributeErrorনা পেলে
o = Order("Dhaka", [("rice", 2, 520)])শুরু
o.__dict__: district, lines
MRO: Order → Record → object
data descriptor: নেই
o.districtinstance-এ
data descriptor?  না
o.__dict__-এ?     হ্যাঁ
ফল: 'Dhaka'
o.total()class-এ
o.__dict__-এ?  না
Order-এ?       হ্যাঁ, function
→ o-র সঙ্গে bound method
1040 ≥ 1000 → 936
o.currencybase class-এ
o.__dict__ না, Order না
Record-এ হ্যাঁ
ফল: 'BDT'
o.total = lambda: 0ছায়া
o.__dict__-এ নতুন: total
o.total()      → 0
Order.total(o) → 936
del o.total পরে → 936
o.phoneকোথাও নেই
চার জায়গার কোথাও নেই
__getattr__-ও নেই
AttributeError: 'Order'
object has no attribute
'phone'
  1. সারিটি। Instance-এর নিজের dictionary, তারপর MRO ধরে Order, Record, object. Class-গুলোতে কোনো @property নেই, তাই data descriptor-এর আগাম জয়ের প্রশ্ন এখানে ওঠে না।
  2. নিজের ঘরে। district constructor-এ self.district = … দিয়ে instance-এর dictionary-তে বসেছে। এক ধাপেই পাওয়া: “Dhaka”.
  3. Class-এ, bound method হয়ে। total instance-এ নেই, Order-এ আছে। Python function-টিকে o-র সঙ্গে বেঁধে দেয়, যাতে self = o. চালালে 2 × 520 = 1040, ছাড় দিয়ে 936.
  4. এক ধাপ ওপরে। currency শুধু Record-এ আছে। খোঁজ প্রথম মিলেই থামে; এটিই inheritance-এর পুরো রহস্য, শুধু dictionary-র সারি।
  5. Instance ছায়া ফেলে। o.total = lambda: 0 class বদলায় না, instance-এর dictionary-তে নতুন ঘর বানায়। এখন o.total() 0, কিন্তু Order.total(o) এখনো 936, আর অন্য সব Order আগের মতো। ঘরটি মুছলে আবার 936.
  6. না পাওয়া। কোথাও phone নেই, __getattr__-ও নেই, তাই AttributeError. লক্ষ করুন, এই ভুলও শুধু এই লাইন চলার সময় ধরা পড়ে; JavaScript হলে ফল হতো undefined, error নয়।

JavaScript-এ একই কাজ object আর prototype chain দিয়ে (বিস্তারিত পর্ব ০৮-এর prototype অংশে আর JavaScript কোর্সের পর্ব ২৫-এ)। তবে JavaScript আরও এক ধাপ dynamic: property-র নাম নিজেই একটি চলার সময়ের মান হতে পারে, o[field], যেখানে field একটি string variable. নিচে বাজারঘরের অর্ডারগুলো তিন আকারের সাধারণ object, কোনো class নেই। কোডটি নিজে object-কে জিজ্ঞেস করে কার কী আছে।

"use strict";
const discounted = t => (t >= 1000 ? t - Math.trunc(t / 10) : t);
// three shapes of order, no class, no shared type
const orders = [
  { district: "Dhaka", lines: [["rice", 2, 520]] },
  { district: "Rajshahi", lines: [["lentil", 3, 120], ["oil", 1, 180]] },
  { district: "Dhaka", amount: 1100 },
  { district: "Dhaka", total() { return 200; } },
];
function totalOf(o) {                     // ask the object what it has
  if (typeof o.total === "function") return o.total();
  if ("amount" in o) return discounted(o.amount);
  return discounted(o.lines.reduce((s, [, q, u]) => s + q * u, 0));
}
const field = "district";                 // property name chosen at run time
const districtSum = (os, d) =>
  os.filter(o => o[field] === d).reduce((s, o) => s + totalOf(o), 0);
console.log("Dhaka:", districtSum(orders, "Dhaka"));

console.log(JSON.stringify(Object.keys(orders[2])), Reflect.has(orders[3], "total"));
orders[1].total = () => 0;                // add a property while running
console.log("Rajshahi:", districtSum(orders, "Rajshahi"));

// weak dynamic typing: + quietly converts instead of failing
const label = t => (t >= 1000 ? "free delivery" : t + " taka");
console.log(label(1040), "|", label(540), "|", typeof (540 + " taka"));
console.log("1040" * 1, "1040" + 60, "1040" - 60);

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

Dhaka: 2126
["district","amount"] true
Rajshahi: 0
free delivery | 540 taka | string
1040 104060 980

দ্বিতীয় ভাষা, একই 2126. totalOf একটি ছোট “duck test”: total নামে function আছে? amount আছে? না হলে লাইনের তালিকা ধরে হিসাব। Object.keys আর Reflect.has JavaScript-এর reflection: object-এর নিজের নামগুলো পড়া, আর একটি নাম আছে কি না প্রশ্ন করা। রাজশাহীর অর্ডারে চলার সময় total জুড়ে দিতেই তার হিসাব 540 থেকে 0 হয়ে গেল; কোনো class বদলাতে হয়নি। শেষ দুই লাইন weak typing: 540 + " taka" একটি string, error নয়; আর "1040" + 60 জোড়া লাগিয়ে 104060, অথচ "1040" - 60 সংখ্যায় রূপান্তর করে 980.

৫ · Reflection আর introspection — program নিজেকে দেখে

আয়নার সামনে দাঁড়িয়ে নিজের জামার বোতাম দেখা আর ঠিক করা: এটিই reflection-এর ছবি। সাধারণ program ডেটা নিয়ে কাজ করে; reflective program নিজের গঠন (class, function, field, এমনকি কোড) ডেটা হিসেবে পড়ে, আর কখনো বদলায়ও।

সংজ্ঞা ১২.৪ — introspection আর reflection

Introspection: চলমান program নিজের গঠন সম্পর্কে প্রশ্ন করতে পারে: এই object-এর type কী, কোন কোন attribute আছে, এই function কয়টি parameter নেয়। Reflection: তার চেয়ে এক ধাপ বেশি, প্রশ্নের উত্তর দিয়ে কাজ করা আর গঠন বদলানো: নাম string হিসেবে দিয়ে method ডাকা, নতুন attribute বা class তৈরি, আচরণ বদলানো। (অনেক বই দুটি শব্দ প্রায় একই অর্থে ব্যবহার করে।)

কাজPython 3.14JavaScriptJava 21
type জানাtype(o)typeof, o.constructoro.getClass()
নামগুলোর তালিকাdir(o), vars(o)Object.keys(o)getDeclaredFields()
নাম দিয়ে পড়াgetattr(o, "x")o["x"], Reflect.getField.get
নাম দিয়ে লেখাsetattr(o, "x", v)o["x"] = vField.set
function-এর parameterinspect.signature(f)f.length (শুধু সংখ্যা)Method.getParameters()
নতুন method যোগসরাসরি সম্ভবসরাসরি সম্ভবসাধারণ reflection-এ নয়

শেষ সারিটি লক্ষ করুন: Java-তে reflection আছে, কিন্তু চলার সময় একটি loaded class-এ নতুন method জোড়া সাধারণ API দিয়ে যায় না (bytecode বানানোর আলাদা library বা agent লাগে)। Java static ভাষা, তবু reflection দিয়ে আংশিক dynamic আচরণ পায়; Python আর JavaScript-এ গঠন বদলানো রোজকার কাজ।

Reflection কোথায় কাজে লাগে

  • Serialization: json.dumps বা ORM একটি object-এর field-গুলো নাম ধরে পড়ে ডাটাবেস বা JSON বানায়, প্রতিটি class-এর জন্য আলাদা কোড ছাড়াই।
  • Test framework: pytest “test_ দিয়ে শুরু হওয়া সব function” খুঁজে চালায়; এটি module-এর নামের তালিকার introspection.
  • Plugin আর configuration: config ফাইলে লেখা নাম ("discount": "festive") থেকে getattr(rules, name) দিয়ে function বেছে নেওয়া, eval ছাড়াই (অংশ ৬)।

দাম তিন রকম। প্রথমত, নাম string-এ চলে গেলে IDE-র “rename”, type checker আর পাঠক কেউ আর ধরতে পারে না কোথায় কোন method ব্যবহার হচ্ছে। দ্বিতীয়ত, encapsulation-এর দেয়াল ভাঙে: Java-তে setAccessible(true) দিয়ে private field ছোঁয়া যায় (module system অনুমতি দিলে)। তৃতীয়ত, compiler-এর optimization কঠিন হয় (অংশ ৮)। Python-এর descriptor, metaclass আর inspect-এর পূর্ণ ব্যবহার আছে Python কোর্সের পর্ব ৩৮-এ (metaprogramming); ভাষার স্তরে metaprogramming, macro আর compile-time reflection আসবে পর্ব ৭৮-এ (Metaprogramming — macro, template আর reflection).

Haat-এ কোনো reflection নেই, আর সেটি সচেতন সিদ্ধান্ত: Haat-এর type checker চায় প্রতিটি নাম আগে থেকে জানা থাকুক। কিন্তু একটি মজার সত্য আছে: Haat-এর interpreter নিজে (পর্ব ৫৬-এ লিখবেন) Haat program-কে একটি AST ডেটা হিসেবে হাতে নেয়, পড়ে, আর চালায়। একটি ভাষার reflection যা করে, তার বাস্তবায়ন সবসময় তা করে; reflection মানে সেই ক্ষমতার কিছুটা program-এর নিজের হাতে তুলে দেওয়া।

৬ · eval আর exec — লেখা থেকে কোড, আর তার বিপদ

Reflection-এর সবচেয়ে শক্তিশালী রূপ হলো একটি string-কে কোড হিসেবে চালানো। Python-এ eval("2 * 520") ফেরত দেয় 1040; exec পুরো statement-এর ব্লক চালায়; JavaScript-এ eval আর new Function(...). এই ধারণার শিকড় LISP-এ: John McCarthy-র ১৯৬০ সালের গবেষণাপত্রে eval একটি function, যা LISP-এ লেখা যেকোনো LISP expression-এর মান বের করে। LISP-এ কোড আর ডেটা একই গঠনের (তালিকা), তাই program সহজেই program বানাতে পারে; এই গুণের নাম homoiconicity.

সংজ্ঞা ১২.৫ — eval আর code injection

eval: চলার সময় একটি string (বা কোডের গঠন) নিয়ে তাকে ভাষার পূর্ণ ক্ষমতা সহ parse, compile আর চালানো। অর্থাৎ এক program-এর ভেতরে পুরো একটি compiler আর interpreter হাতের কাছে। Code injection: যখন বাইরের কেউ এমন লেখা ঢোকাতে পারে, যা শেষে eval বা সমতুল্য কিছুতে পৌঁছায়; তখন তিনি আপনার program-এর অধিকার নিয়ে নিজের কোড চালাতে পারেন।

নিয়ম, ব্যতিক্রম ছাড়া: ব্যবহারকারী, ফাইল, নেটওয়ার্ক বা ডাটাবেস থেকে আসা কোনো লেখা কখনো eval/exec/new Function-এ দেবেন না। eval(text, {"__builtins__": {}})-এর মতো “খাঁচা” নিরাপদ নয়; Python-এর documentation নিজেই এভাবে নিরাপত্তা পাওয়া যায় না বলে সতর্ক করে। ঝুঁকি আর প্রতিরক্ষার পূর্ণ আলোচনা সাইবার সিকিউরিটি কোর্সের পর্ব ৩৯-এ (Injection প্রতিরক্ষা) আর Python কোর্সের পর্ব ৫৪-এ (নিরাপদ Python).

তাহলে বাজারঘরের সমস্যাটি কীভাবে সমাধান হবে? ব্যবসার লোকেরা ছাড়ের নিয়ম একটি config ফাইলে লিখতে চান, যেমন t - t / 10, যাতে প্রতিবার programmer লাগে না। এখানেই এই কোর্সের মূল বিষয় কাজে লাগে: string-কে চালানো নয়, আগে parse করা, তারপর শুধু অনুমোদিত গঠনগুলো নিজে চালানো। অর্থাৎ একটি ছোট, নিরাপদ interpreter. নিচের stepper আগে দুই পথ পাশাপাশি দেখায়।

1rule = "t - t / 10"2eval(text, {"t": 1040})3tree = ast.parse(text,4        mode="eval")5run(tree, {"t": 1040})
এই ধাপে
text
ভেতরে
  1. শুধু লেখা। config থেকে পড়া rule এখনো শুধু অক্ষরের সারি। কোনটি নাম, কোনটি operator, তা কেউ এখনো ঠিক করেনি।
  2. eval: পুরো compiler. eval লেখাটিকে CPython bytecode-এ compile করে চালায় (CPython 3.14.4-এর dis-এ দেখা নির্দেশগুলো ডানে)। ফল 936.0: Python-এর / float দেয়, তাই Haat-এর নিয়মের সঙ্গে মিলল না।
  3. eval: ঢোকানো কোড চলে। কেউ config বদলে লিখল print('this code ran!') or t. eval এটিকেও বৈধ Python হিসেবে চালায়: print সত্যিই ডাকা হলো, তারপর 1040. এখানে নিরীহ print; একই পথে ফাইল পড়া বা মোছাও সম্ভব হতো।
  4. Parse: শুধু গঠন। ast.parse লেখাটিকে একটি AST-এ সাজায়, কিন্তু কিছুই চালায় না। এখন program-টি একটি গাছ, যা আমরা নিজে পড়ব।
  5. নিজের interpreter. run গাছের প্রতিটি node দেখে: Name হলে env থেকে মান, Div হলে Haat-এর মতো শূন্যের দিকে ভাগ, Sub হলে বিয়োগ। 1040 / 10 = 104, 1040 − 104 = 936, এবার পূর্ণসংখ্যা।
  6. অজানা মানেই না। ক্ষতিকর লেখার AST-এর মূল একটি BoolOp (or), যা অনুমোদিত তালিকায় নেই। run সঙ্গে সঙ্গে থামে; ভেতরের print-এর Call node পর্যন্ত পৌঁছানোই হয় না। “যা জানি শুধু তাই চলবে” (allowlist), “যা খারাপ তা আটকাব” (blocklist) নয়।

এবার তিনটি পথ একসঙ্গে, সত্যিকারের কোডে: eval, ast.literal_eval (শুধু সংখ্যা, string, list, dict-এর মতো literal বোঝে, কোনো নাম বা call নয়), আর নিজের ছোট interpreter, যা Python-এর match দিয়ে AST-এর node ধরে ধরে হিসাব করে।

import ast

rule = "t - t / 10"                        # a discount rule read from a config file
bad = "print('this code ran!') or t"       # someone edited the config

# 1) eval: the string becomes code, with all of Python's power
print("eval rule:", eval(rule, {"t": 1040}))   # Python's / is float division
print("eval bad :", eval(bad, {"t": 1040}))    # the call really ran

# 2) ast.literal_eval: only literals, never names or calls
print("literal  :", ast.literal_eval("[1040, 1100, 200]"))
try:
    ast.literal_eval(rule)
except ValueError as e:
    print("literal_eval refused:", str(e).split(":")[0])
# 3) our own tiny interpreter: parse, then walk an allowed set of nodes
OPS = {ast.Add: lambda a, b: a + b, ast.Sub: lambda a, b: a - b,
       ast.Mult: lambda a, b: a * b,   # / below truncates toward zero, as in Haat
       ast.Div: lambda a, b: abs(a) // abs(b) * (1 if (a < 0) == (b < 0) else -1)}
def run(node, env):
    match node:
        case ast.Expression(body=b): return run(b, env)
        case ast.Constant(value=int(v)): return v
        case ast.Name(id=n) if n in env: return env[n]
        case ast.BinOp(left=l, op=op, right=r) if type(op) in OPS:
            return OPS[type(op)](run(l, env), run(r, env))
    raise ValueError(f"not allowed: {type(node).__name__}")

tree = ast.parse(rule, mode="eval")
print("own rule :", [run(tree, {"t": t}) for t in (1040, 1100)])
print("(0-7)/2  :", run(ast.parse("(0 - 7) / 2", mode="eval"), {}), "(Haat/C), Python // gives", -7 // 2)
try:
    run(ast.parse(bad, mode="eval"), {"t": 1040})
except ValueError as e:
    print("refused:", e)

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

eval rule: 936.0
this code ran!
eval bad : 1040
literal  : [1040, 1100, 200]
literal_eval refused: malformed node or string on line 1
own rule : [936, 990]
(0-7)/2  : -3 (Haat/C), Python // gives -4
refused: not allowed: BoolOp

প্রথম দুই লাইন eval-এর দুই সমস্যা একসঙ্গে দেখায়: ভাষার নিয়ম (936.0, float) আপনার চাওয়া নিয়ম নয়, আর ঢোকানো কোড (this code ran!) সত্যিই চলেছে। literal_eval ডেটার জন্য চমৎকার (তালিকাটি পড়ল), কিন্তু নিয়মটি নয়, কারণ তাতে নাম t আছে। নিজের interpreter দুটিই পারে: নিয়ম থেকে 936 আর 990 (পর্ব ০৯-এর ঢাকার দুই অর্ডারের ছাড়-পরবর্তী মোট), আর ভাগ Haat আর C-এর মতো শূন্যের দিকে (−3), Python-এর //-এর মতো নিচের দিকে (−4) নয়। ক্ষতিকর লেখা প্রথম অচেনা node-এই প্রত্যাখ্যাত। এই ২০ লাইনের run আসলে একটি tree-walking interpreter, ঠিক যে ধরনের জিনিস পর্ব ৫৬-এ Haat-এর জন্য পূর্ণ আকারে লিখবেন।

JavaScript-এর জগতেও একই নিয়ম: JSON পড়তে JSON.parse, কখনো eval নয়। Browser-এর Content Security Policy ডিফল্টে eval বন্ধ রাখতে পারে ('unsafe-eval' অনুমতি না দিলে)। তবু eval-এর বৈধ জায়গা আছে: REPL, notebook, আর সেই tool যেখানে ব্যবহারকারী নিজেই নিজের যন্ত্রে নিজের কোড চালান। প্রশ্ন সবসময় একটিই: লেখাটি কার, আর সে কী চালানোর অধিকার রাখে?

৭ · Monkey patching — চলন্ত program-এ জোড়াতালি

ছবি ১২.১-এর লাল দাগটি এবার। Python বা JavaScript-এ module আর class নিজেও সাধারণ object, যাদের dictionary চলার সময় বদলানো যায়। অন্যের লেখা module-এর একটি function বা class-এর একটি method চলার সময় অন্য কিছু দিয়ে বদলে দেওয়াকে বলে monkey patching. নামের উৎস নিয়ে একটি প্রচলিত গল্প হলো “guerrilla patch” থেকে “gorilla”, সেখান থেকে “monkey”; গল্পটি নিশ্চিতভাবে যাচাই করা কঠিন, তবে শব্দটি Python আর Ruby সম্প্রদায়ে বহুদিন ধরে চলছে।

সবচেয়ে বৈধ আর প্রচলিত ব্যবহার test-এ: পেমেন্ট সার্ভারে সত্যিকারের অনুরোধ না পাঠিয়ে একটি নকল function বসানো (unittest.mock.patch, pytest-এর monkeypatch). এর পূর্ণ কৌশল আর ফাঁদ আছে Software Testing কোর্সের পর্ব ২৪-এ. এখানে আমাদের প্রশ্ন ভাষার: patch কেন কাজ করে, আর কখন করে না? উত্তর late binding-এ। নিচের stepper-এ একটি module shop, যার order_total ভেতরে discounted ডাকে।

1def discounted(t): # A2def order_total(lines):3  return discounted(...)4from shop import discounted5shop.discounted = B6shop.discounted = A
এই ধাপে
shop.discounted
import করা নাম
ঢাকার total()
  1. শুরু। shop module-এর dictionary-তে discounted নামে ছাড়ের function A. order_total-এর ভেতরে নামটি লেখা আছে, function-টি নয়। ঢাকার তিন অর্ডারে মোট 936 + 990 + 200 = 2126.
  2. নাম কপি। অন্য module-এ from shop import discounted একটি নতুন নাম বানায়, যা এই মুহূর্তের object A-কে নির্দেশ করে (নিচের কোডে একই কাজ করে from_import = shop.discounted). কপি হলো object-এর reference, shop-এর ঘরের সঙ্গে কোনো সংযোগ নয়।
  3. Patch. shop-এর dictionary-তে discounted এখন B (ছাড় নেই)। order_total প্রতিটি call-এ নামটি নতুন করে খোঁজে (LOAD_GLOBAL), তাই B পায়: 1040 + 1100 + 200 = 2340. কিন্তু import করা নাম এখনো A, তাই সেটি দিয়ে 1040-এর ফল 936.
  4. ফেরানো। সংরক্ষিত A আবার বসানো হলো, মোট আবার 2126. Patch সবসময় ফেরাতে হয়, নইলে পরের test বা কোড অদ্ভুত আচরণ পায়। শিক্ষা: নামটি যেখানে খোঁজা হয়, সেখানে patch করুন।

এই চারটি ধাপ নিচের কোডে সত্যিই চলে, সঙ্গে আরও একটি জিনিস: CPython-এর dis দিয়ে দেখা, ভেতরে কোন নাম খোঁজা হয় আর একই a + b চলতে চলতে কীভাবে বদলায় (অংশ ৮-এর ভিত্তি)। Module-টি স্মৃতিতে বানাতে এখানে exec ব্যবহার হয়েছে একটি স্থির, নিজের লেখা কোডের ওপর; বাইরের লেখার ওপর কখনো নয়।

import dis, types

shop = types.ModuleType("shop")          # a small module, built in memory
exec("""
def discounted(t): return t - t // 10 if t >= 1000 else t
def order_total(lines): return discounted(sum(q * u for q, u in lines))
""", shop.__dict__)                       # fixed text we wrote ourselves
DHAKA = [[(2, 520)], [(4, 150), (2, 250)], [(5, 40)]]
total = lambda: sum(shop.order_total(o) for o in DHAKA)
from_import = shop.discounted            # like: from shop import discounted

print("before patch:", total())
saved = shop.discounted
shop.discounted = lambda t: t            # monkey patch: no discount
print("after patch :", total(), "| old name still:", from_import(1040))
shop.discounted = saved                  # always undo a patch
print("restored    :", total())

def add(a, b): return a + b
print([i.opname for i in dis.get_instructions(add)
       if "BINARY" in i.opname])
for _ in range(100): add(2, 3)           # warm up with Int only
print([i.opname for i in dis.get_instructions(add, adaptive=True)
       if "BINARY" in i.opname])
print(add("60", " taka"), add([1], [2]))  # same code, other types
for _ in range(100): add("60", " taka")  # now Str only
print([i.opname for i in dis.get_instructions(add, adaptive=True)
       if "BINARY" in i.opname])
print([i.argval for i in dis.get_instructions(shop.order_total)
       if i.opname == "LOAD_GLOBAL"])          # names looked up at every call

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

before patch: 2126
after patch : 2340 | old name still: 936
restored    : 2126
['BINARY_OP']
['BINARY_OP_ADD_INT']
60 taka [1, 2]
['BINARY_OP_ADD_UNICODE']
['discounted', 'sum']

প্রথম তিন লাইন stepper-এর সঙ্গে হুবহু: 2126, patch-এর পর 2340 অথচ পুরোনো নাম এখনো 936, ফেরানোর পর 2126. শেষ লাইন কারণটি দেখায়: order_total-এর bytecode-এ discounted আর sum দুটিই LOAD_GLOBAL, অর্থাৎ প্রতি call-এ module-এর dictionary থেকে খোঁজা। মাঝের চার লাইন অংশ ৮-এর গল্প: add-এর a + b compile হয় একটি সাধারণ BINARY_OP-এ, যা জানে না a আর b কী। ১০০ বার Int দিয়ে ডাকার পর CPython 3.14 নিজেই নির্দেশটিকে BINARY_OP_ADD_INT-এ বদলে নিয়েছে। তারপর একই function string আর list জুড়েছে (dynamic typing!), আর string দিয়ে বারবার ডাকার পর নির্দেশটি হয়েছে BINARY_OP_ADD_UNICODE. কত বার ডাকার পর ঠিক কখন বদলায়, তা CPython-এর ভেতরের খুঁটিনাটি, version-ভেদে বদলাতে পারে; ভাষার নিয়ম নয়।

Monkey patching-এর দাম

Test-এর বাইরে, চালু program-এ অন্যের কোড patch করা প্রায়ই সমস্যা ডাকে। দুটি library একই জিনিস দুইভাবে patch করলে যে পরে load হয় সে জেতে, আর ভুলটি দেখা দেয় সম্পূর্ণ অন্য জায়গায়। Built-in বদলালে ভবিষ্যতের ভাষার সঙ্গে সংঘর্ষ হয়: ভাবনার প্রশ্ন ০৫-এ JavaScript-এর একটি বাস্তব ঘটনা দেখবেন। আর কোড পড়ে কেউ আর বলতে পারেন না order_total আসলে কী করবে, কারণ উত্তর নির্ভর করে কোন module আগে কী বসিয়েছে তার ওপর।

৮ · Dynamism-এর দাম — compiler কেন সহজে optimize করতে পারে না

C compiler a + b দেখে, যেখানে a আর b দুটিই long, আর একটি মাত্র machine instruction লেখে। Python-এর compiler একই লেখা দেখে কিছুই নিশ্চিত জানে না: a আর b int, float, string, list, নাকি এমন একটি object, যার __add__ একটি ডাটাবেস query চালায়? এমনকি len নামটিও কেউ patch করে থাকতে পারে। তাই প্রতিটি সাধারণ কাজের ভেতরে কয়েক ধাপের প্রশ্ন লুকিয়ে থাকে।

লেখাstatic ভাষায় (C, Haat-এর compiler)dynamic ভাষায় চলার সময় (CPython)
a + btype আগে জানা; একটি যোগের নির্দেশদুই মানের tag দেখা, ঠিক __add__ খোঁজা, int হলে overflow-হীন বড় সংখ্যার যোগ, নতুন object বানানো
o.totalfield-এর offset বা vtable-এর ঘর আগে জানাdictionary-র সারি ধরে খোঁজা (অংশ ৪), descriptor থাকলে তা ডাকা
discounted(t)কোন function, তা link-এর সময় স্থির; inline করা যায়প্রতিবার LOAD_GLOBAL; patch হলে অন্য function

তাই একই হিসাব প্রায়ই dynamic ভাষায় ধীর চলে; কত গুণ, তা কাজ আর বাস্তবায়নভেদে এত আলাদা যে নিজের যন্ত্রে মাপাই একমাত্র উত্তর। বাস্তব engine দুটি পর্যবেক্ষণ থেকে গতি ফিরিয়ে আনে:

  1. সম্ভব বনাম বাস্তব: a + b-এ যেকোনো type আসতে পারে, কিন্তু একটি নির্দিষ্ট জায়গায় বাস্তবে প্রায় সবসময় একই type আসে। এই পর্যবেক্ষণের ওপর দাঁড়ানো inline cache (পর্ব ০৮-এর “আরও গভীরে” বাক্সে দেখেছেন) আর CPython-এর specializing interpreter, যা উপরের run-এ BINARY_OP-কে BINARY_OP_ADD_INT বানিয়েছে (PEP 659, CPython 3.11 থেকে)।
  2. অনুমান করে চালানো, ভুল হলে ফেরা: JIT compiler “এখানে সবসময় Int আসে” ধরে নিয়ে দ্রুত machine code বানায়, আর সামনে একটি ছোট পাহারা (guard) বসায়। অনুমান ভাঙলে, যেমন হঠাৎ একটি string এল, deoptimization: দ্রুত কোড ফেলে সাধারণ পথে ফেরা। উপরের run-এ int থেকে string-এ যাওয়ার পর নির্দেশ বদলানো তারই ছোট রূপ। পুরো কৌশল আসবে পর্ব ৬১-এ (JIT compilation — profiling, tracing আর deoptimization).

তৃতীয় পথ হলো ভাষায় type ফিরিয়ে আনা, কিন্তু ঐচ্ছিকভাবে। Python-এর type hint (PEP 484, Python 3.5) আর TypeScript (২০১২) একটি dynamic ভাষার ওপর static checker বসায়; এই ধারণার তাত্ত্বিক নাম gradual typing (Siek আর Taha, ২০০৬)। লক্ষ করুন, CPython চলার সময় type hint যাচাই করে না এবং সেগুলো দিয়ে কোডও দ্রুত করে না; hint কাজে লাগায় mypy-র মতো আলাদা tool. বিস্তার Python কোর্সের পর্ব ৪০-এ, আর তত্ত্ব পর্ব ৩৯-এ (উন্নত type — gradual, linear, dependent আর refinement type).

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন সাধারণ।
১. Static আর dynamic typing-এর পার্থক্য এক লাইনে? Static-এ type নামের গুণ, যাচাই চালানোর আগে; dynamic-এ type মানের গুণ, যাচাই operation চলার সময়।
২. Dynamic মানেই কি weak? না। Python dynamic কিন্তু strong (1 + "a" TypeError); C static কিন্তু অনেক implicit conversion করে।
৩. Duck typing আর structural typing-এর পার্থক্য? প্রশ্ন একই (“দরকারি method আছে?”), duck typing চলার সময় যাচাই করে, structural typing compile-এর সময়।
৪. eval-এর নিরাপদ বিকল্প? ডেটার জন্য JSON বা ast.literal_eval; সূত্রের জন্য parse করে allowlist-ভিত্তিক নিজের evaluator.
৫. Monkey patch কাজ না করার সাধারণ কারণ? Patch করা হয়েছে মূল module-এ, অথচ কোড from … import দিয়ে নামটির নিজের কপি রেখেছে; নামটি যেখানে খোঁজা হয় সেখানে patch করতে হয়।

আরও গভীরে: Dynamic ভাষাকে দ্রুত করার সবচেয়ে চমকপ্রদ কৌশলগুলোর একটি PyPy-র meta-tracing (Bolz, Cuni, Fijałkowski আর Rigo, ২০০৯-এর গবেষণাপত্র): ভাষার interpreter RPython নামের Python-এর একটি সীমিত রূপে লেখা হয়, আর একটি সাধারণ tracing JIT সেই interpreter-কেই চলার সময় trace করে, ফলে প্রতিটি নতুন ভাষার জন্য আলাদা JIT লিখতে হয় না। অন্য প্রান্তে Mike Pall-এর LuaJIT (২০০৫ থেকে) দেখিয়েছে, ছোট আর সরল একটি dynamic ভাষা হাতে লেখা tracing JIT দিয়ে অনেক কাজে C-এর কাছাকাছি গতি পেতে পারে। দুটির মূল ধারণা একই: যা সম্ভব তা নয়, যা বাস্তবে ঘটছে তার জন্য কোড বানানো।

৯ · AI-এর যুগে scripting আর dynamic ভাষা

AI assistant সবচেয়ে বেশি কোড লেখে Python আর JavaScript-এ, আর ঠিক এই ভাষাগুলোতে ভুল সবচেয়ে দেরিতে ধরা পড়ে। কোড দেখতে ঠিক, প্রথম test পাস করে, আর ভাঙা শাখাটি অপেক্ষা করে সেই দিনের জন্য, যেদিন সিলেটের অর্ডার আসবে। এই বিষয়ে AI-এর বারবার দেখা ভুল:

AI-এর ভুলকীভাবে ধরবেন
Config বা ব্যবহারকারীর সূত্র হিসাব করতে eval বসানো, সঙ্গে “__builtins__ খালি করলেই নিরাপদ” দাবিনিয়ম: বাইরের লেখা কখনো eval নয়; parse + allowlist বা JSON চাওয়া, আর ক্ষতিকর ইনপুট দিয়ে test
এক ভাষার নিয়ম অন্য ভাষায় চাপানো: “JavaScript-এর মতো Python-ও "5" + 2 করে দেয়”, বা “Python-এর type hint চলার সময় যাচাই হয়”দুই ভাষায় ছোট কোড চালিয়ে দেখা; ভাষা আর version ধরে documentation
Test-এ ভুল জায়গায় patch: মূল module-এ patch, অথচ কোড from … import করেছে; test সবুজ, কিন্তু কিছুই পরীক্ষা হয়নিPatch-এর ভেতরে ইচ্ছা করে ভুল মান দিয়ে দেখা test লাল হয় কি না
Duck typing ধরে নিয়ে কিছু object-এ দরকারি method না থাকা, যা শুধু বিরল শাখায় চলেপ্রতিটি শাখা ছোঁয়া test (coverage), আর mypy বা TypeScript-এর মতো static checker
CPython-এর ভেতরের খুঁটিনাটি (bytecode নাম, কত call-এর পর specialization) ভাষার স্থায়ী নিয়ম হিসেবে বলা, বা ভুল bytecode বানিয়ে দেখানোনিজের version-এ dis চালিয়ে মেলানো; version লিখে রাখা

AI-কে ভালোভাবে কাজে লাগানোর উপায়: কোড চাওয়ার সঙ্গে ঝুঁকির তালিকা আর যাচাইয়ের test চাওয়া, তারপর নিজে চালিয়ে মেলানো।

আমি Python 3.14-এ একটি অনলাইন দোকানের ছাড়ের নিয়ম config ফাইল থেকে পড়তে চাই। নিয়ম দেখতে এমন: "t - t / 10 if t >= 1000 else t", যেখানে t অর্ডারের মোট (পূর্ণসংখ্যা, টাকায়)। ১. eval বা exec ব্যবহার করবে না। ast.parse দিয়ে parse করে শুধু অনুমোদিত node (সংখ্যা, নাম t, + - * /, তুলনা, if-else expression) চালায় এমন একটি ছোট evaluator লেখো। ২. / যেন C-এর মতো শূন্যের দিকে কাটে, আর শূন্য দিয়ে ভাগে একটি পরিষ্কার error দেয়। ৩. অনুমোদিত নয় এমন যেকোনো node-এ (call, attribute, ** ইত্যাদি) ValueError দাও; কোন node, তা বার্তায় লেখো। ৪. test লেখো: 1040, 540, 1100, 200-এর ফল; একটি ক্ষতিকর নিয়ম (একটি function call); ঋণাত্মক ভাগ। ৫. কোনো আউটপুট অনুমান করে লিখবে না; কোন কোড আমাকে চালিয়ে দেখতে হবে, আলাদা করে বলো।

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

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

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

প্র ০১John Ousterhout ১৯৯৮ সালে ভাষাকে “system programming” আর “scripting” দুই দলে ভাগ করেছিলেন। সেই ভাগ আজ কতটা টেকে?

Tcl-এর স্রষ্টা John Ousterhout ১৯৯৮ সালে IEEE Computer পত্রিকায় “Scripting: Higher Level Programming for the 21st Century” নামে একটি প্রবন্ধ লেখেন। তাঁর যুক্তি ছিল, ভাষা দুই ধরনের কাজের জন্য: C, C++ বা Java-র মতো system programming ভাষা দিয়ে data structure আর algorithm শূন্য থেকে গড়া হয়, যেখানে strong static typing আর গতি জরুরি। Tcl, Perl বা Visual Basic-এর মতো scripting ভাষা দিয়ে আগে থেকে তৈরি বড় উপাদান (component) জোড়া হয়, যেখানে typeless বা dynamic ধাঁচ জোড়ার কাজকে দ্রুত করে। তিনি বললেন, ভবিষ্যতে বেশির ভাগ নতুন কোড হবে জোড়ার কোড, তাই scripting-এর গুরুত্ব বাড়বে। এই ভাগ অনেক সময় “Ousterhout-এর dichotomy” নামে উদ্ধৃত হয়।

ভবিষ্যদ্বাণীর একটি অংশ মিলে গেছে: আজকের অনেক কাজ সত্যিই জোড়ার কাজ। Machine learning-এর বেশির ভাগ কোড Python-এ লেখা, কিন্তু ভারী হিসাব চলে C, C++ বা GPU-র কোডে লেখা library-তে; Python সেখানে glue. Web-এ JavaScript browser-এর API জোড়ে, আর shell script এখনো server চালানো আর deploy-এর মেরুদণ্ড।

কিন্তু ভাগটি যত পরিষ্কার ভাবা হয়েছিল, ততটা থাকেনি। এক দিকে “scripting” ভাষায় লক্ষ লক্ষ লাইনের বড় system তৈরি হয়েছে, আর সেই আকারে পৌঁছে তারা type ফিরিয়ে এনেছে: TypeScript, Python-এর type hint আর mypy. অন্য দিকে static ভাষা scripting-এর আরাম নিয়েছে: type inference (Kotlin-এর val, Rust-এর let, Java 10-এর var), REPL (Java 9-এর jshell), আর একটি ফাইল সরাসরি চালানো (Java 11 থেকে java Hello.java).

আজ তাই প্রশ্নটি “কোন দলের ভাষা” নয়, বরং একটি বিশেষ কাজে কোন binding কখন হওয়া উচিত: বড়, বহু মানুষের, দীর্ঘজীবী কোডে বেশি static নিশ্চয়তা; ছোট, একবারের, অন্বেষণের কাজে বেশি dynamic নমনীয়তা। একই ভাষায় দুটিই সম্ভব হচ্ছে।

মূল উপলব্ধি: “Scripting ভাষা” একটি ব্যবহারের ধরন, ভাষার স্থায়ী জাত নয়। Static আর dynamic দুই দিকের ভাষাই একে অপরের সুবিধা ধার করছে, আর আপনার কাজ হলো প্রকল্পের আকার আর আয়ু দেখে কতটুকু নিশ্চয়তা চাই তা ঠিক করা।

প্র ০২LISP-এর eval ইতিহাসে একটি বড় আবিষ্কার, অথচ আজ নিরাপত্তা-নির্দেশিকা বলে eval এড়িয়ে চলুন। এই দুই অবস্থান কীভাবে মেলে?

১৯৬০ সালে Communications of the ACM-এ John McCarthy-র “Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I” প্রকাশিত হয়। সেখানে তিনি দেখান, LISP-এর একটি ছোট অংশ দিয়েই একটি eval function লেখা যায়, যা যেকোনো LISP expression-এর মান বের করে। তাত্ত্বিক দিক থেকে এটি ছিল Turing-এর universal machine-এর ভাষাগত রূপ: একটি program, যা অন্য যেকোনো program চালাতে পারে। প্রচলিত বিবরণ অনুযায়ী McCarthy এটিকে প্রথমে তাত্ত্বিক বর্ণনা হিসেবে দেখেছিলেন, আর তাঁর ছাত্র Steve Russell সেটিকে হাতে machine code-এ অনুবাদ করে প্রথম LISP interpreter বানান।

এর প্রভাব বিশাল। কোড আর ডেটা একই তালিকা-গঠনে থাকায় LISP program সহজেই কোড বানায়, বদলায় আর চালায়; সেখান থেকেই macro, REPL আর নিজের ভাষার ভেতরে নিজের interpreter লেখার ঐতিহ্য। এই কোর্সের Haat interpreter-ও সেই ধারার উত্তরসূরি।

তাহলে সমস্যা কোথায়? সমস্যা eval-এর ধারণায় নয়, তার ইনপুট কোথা থেকে আসে তাতে। McCarthy-র eval চালাত programmer-এর নিজের লেখা expression. ইন্টারনেটের যুগে program-এর ইনপুট আসে অচেনা মানুষের কাছ থেকে, আর eval-এ পৌঁছানো একটি লেখা মানে সেই মানুষের হাতে আপনার program-এর সব ক্ষমতা। এ ছাড়া eval static বিশ্লেষণকে অন্ধ করে: compiler, linter বা security scanner জানতে পারে না string-এর ভেতরে কী কোড আছে। তাই Content Security Policy-র মতো ব্যবস্থা browser-এ eval বন্ধ রাখার সুযোগ দেয়।

আধুনিক সমাধান দুই ধারণা আলাদা করা: কোডকে ডেটা হিসেবে দেখা (parse করে AST, যা অংশ ৬-এ করেছেন) রাখুন, কিন্তু অচেনা ডেটাকে কোডের ক্ষমতা দেওয়া বাদ দিন। Lisp-এর macro-ও এই অর্থে নিরাপদ, কারণ সেগুলো compile-এর সময় programmer-এর নিজের কোডে চলে।

মূল উপলব্ধি: eval একটি সম্পূর্ণ interpreter-এর দরজা। দরজাটি নিজের জন্য খোলা রাখা শক্তি, অচেনার জন্য খোলা রাখা বিপদ; নিরাপদ পথ হলো parse করে শুধু জানা গঠন চালানো।

প্র ০৩Dynamic ভাষা যদি স্বভাবতই এত তথ্য চলার সময় পর্যন্ত লুকিয়ে রাখে, তবে আধুনিক JavaScript engine কীভাবে এত দ্রুত চলে?

উত্তরের শিকড় Smalltalk আর Self-এর গবেষণায়। ১৯৮৪ সালে Deutsch আর Schiffman Smalltalk-80-এ দেখান, প্রতিটি method call-এর জায়গায় শেষবার দেখা class মনে রাখলে (inline cache) বেশির ভাগ খোঁজ এড়ানো যায়। ১৯৮০-এর শেষ আর ১৯৯০-এর শুরুতে Stanford-এ Self ভাষার দল (David Ungar, Craig Chambers, Urs Hölzle প্রমুখ) আরও এগোয়: একই আকারের object-গুলোর জন্য ভাগ করা “map”, চলার সময় সংগ্রহ করা type-এর তথ্য দিয়ে বিশেষায়িত machine code, আর অনুমান ভুল হলে deoptimization করে debugger-এ বোঝা যায় এমন অবস্থায় ফেরা।

এই দলের কয়েকজনের হাত ধরে ধারণাগুলো Java-র HotSpot JVM-এ যায়, আর ২০০৮ সালে Google Chrome-এর সঙ্গে আসা V8 JavaScript engine সেগুলোকে browser-এ নিয়ে আসে। V8-এ “hidden class” (Self-এর map-এর উত্তরসূরি) ঠিক অংশ ৪-এর সমস্যার সমাধান: একই ক্রমে একই property পাওয়া object-গুলো একটি hidden class ভাগ করে, তাই o.district খোঁজা dictionary-র খোঁজ না হয়ে একটি নির্দিষ্ট offset থেকে পড়া হয়ে যায়, যতক্ষণ আকার বদলায় না।

আজকের engine-গুলো স্তরে স্তরে কাজ করে: প্রথমে একটি interpreter দ্রুত শুরু করে আর type-এর তথ্য জমায়; বারবার চলা কোড এক বা একাধিক optimizing compiler-এ যায়, যারা জমানো তথ্য ধরে অনুমান করে; অনুমান ভাঙলে কোড বাতিল। স্তরের সংখ্যা আর নাম engine-ভেদে আলাদা।

এর একটি ব্যবহারিক ফল আছে: “dynamic” কোডকে স্থির আকারে লিখলে engine খুশি থাকে। Constructor-এ সব property একই ক্রমে বসানো, একটি function-এ একই ধরনের argument পাঠানো, চলার সময় object-এর আকার বারবার না বদলানো: এগুলো নিয়ম নয়, কিন্তু engine-এর অনুমানকে সত্য রাখে। আর এখানেই অংশ ৩-এর duck typing-এর একটি সূক্ষ্ম খরচ: একই লাইনে খুব ভিন্ন আকারের object এলে cache কাজে আসে না।

মূল উপলব্ধি: Dynamic ভাষার গতি আসে “সম্ভব সবকিছু”-র বদলে “বাস্তবে যা ঘটছে” তার জন্য কোড বানানো থেকে, আর ভুল হলে নিরাপদে ফেরার ক্ষমতা থেকে। পর্ব ৬১-এ এই কৌশল বিস্তারিত দেখবেন।

প্র ০৪Python আর JavaScript-এর সম্প্রদায় dynamic typing বেছে নিয়েও পরে কেন type hint আর TypeScript-এর দিকে ফিরল? Gradual typing কী আপস করে?

ছোট script-এ dynamic typing আরামদায়ক: type লেখার ঝামেলা নেই, REPL-এ চেষ্টা করে দেখা যায়। কিন্তু কোড যখন লক্ষ লাইনে আর দলের মানুষ শতজনে পৌঁছায়, তখন একটি function কী নেয় আর কী ফেরত দেয় তা জানার একমাত্র উপায় হয়ে দাঁড়ায় কোড পড়া বা চালিয়ে দেখা। অংশ ২-এর stepper-এর মতো ভুল তখন বিরল শাখায় লুকিয়ে থাকে, আর refactor করার সময় কেউ নিশ্চিত হতে পারেন না একটি নাম বদলালে কী কী ভাঙবে।

তাত্ত্বিক ভিত্তি দেন Jeremy Siek আর Walid Taha, ২০০৬ সালের “Gradual Typing for Functional Languages” গবেষণাপত্রে: একটি ভাষায় type লেখা আর না-লেখা অংশ পাশাপাশি থাকতে পারে, মাঝখানে একটি বিশেষ “অজানা” type (প্রায়ই ? বা Any) দিয়ে। Type লেখা অংশ চালানোর আগেই যাচাই হয়, আর দুই জগতের সীমানায় চলার সময় যাচাই বসানো যায়, যাতে ভুল ঠিক সীমানাতেই ধরা পড়ে।

বাস্তব ভাষাগুলো এই আদর্শের হালকা রূপ নিয়েছে। Microsoft-এর TypeScript (২০১২) JavaScript-এর ওপর একটি static checker, যা compile-এর পর type মুছে সাধারণ JavaScript বানায়; চলার সময় কোনো যাচাই থাকে না। Python-এ PEP 484 (Python 3.5, ২০১৫) type hint-এর মান ঠিক করে, কিন্তু CPython চলার সময় সেগুলো উপেক্ষা করে; যাচাই করে mypy বা অন্য checker. এই হালকা রূপকে অনেকে “optional typing” বলেন: পুরোনো কোড একটুও না বদলে চলে, ধীরে ধীরে type যোগ করা যায়, কিন্তু checker-এর কাছে মিথ্যা বলা Any থাকলে চলার সময় ভুল আসতেই পারে।

আপসটি তাই স্পষ্ট: সীমানায় চলার সময় যাচাই রাখলে নিশ্চয়তা বাড়ে কিন্তু গতি কমে (প্রতিটি সীমানা পার হতে পরীক্ষা); না রাখলে গতি অক্ষত, কিন্তু type শুধু একটি প্রতিশ্রুতি, প্রমাণ নয়।

মূল উপলব্ধি: Static আর dynamic typing একটি সুইচ নয়, একটি ঢাল। Gradual typing আপনাকে কোডের প্রতিটি অংশে ঠিক করতে দেয় কতটা নিশ্চয়তা চান, কিন্তু checker যা যাচাই করে না, তাকে প্রমাণ ভাববেন না।

প্র ০৫বড় ecosystem-এ monkey patching কী ক্ষতি করতে পারে? JavaScript-এর Array.prototype.flat-এর নামকরণ আর Ruby-র refinement থেকে কী শেখা যায়?

JavaScript-এ built-in prototype-ও সাধারণ object, তাই যেকোনো library Array.prototype-এ নতুন method জুড়তে পারে। ২০০০-এর দশকে অনেক জনপ্রিয় library ঠিক তাই করত, যাতে সব array-তে সুবিধাজনক method পাওয়া যায়। সমস্যা দেখা দেয় যখন ভাষা নিজে একই নামের method আনতে চায়। ২০১৮ সালে TC39 (JavaScript-এর মান নির্ধারণকারী কমিটি) array সমতল করার একটি method-এর নাম flatten রাখার প্রস্তাব করে। তখন দেখা যায়, পুরোনো MooTools library নিজের একটি flatten এমনভাবে বসাত যে নতুন built-in এলে সেই library ব্যবহার করা কিছু পুরোনো website ভেঙে যেত। “Web-কে ভাঙা যাবে না” নীতির কারণে ভাষাকেই পিছু হটতে হয়, আর method-টির নাম হয় flat. ঘটনাটি মজা করে “SmooshGate” নামে পরিচিত, কারণ একটি ঠাট্টার প্রস্তাব ছিল নাম smoosh রাখার।

শিক্ষাটি গভীর: একটি global জিনিস patch করা মানে সবার সঙ্গে একটি অলিখিত চুক্তি করা, যার দাম পরে ভাষার নকশাকারীরাও দেন। Ruby-তে একই সমস্যা আরও প্রকট ছিল, কারণ Ruby-তে যেকোনো class আবার খুলে (open class) method যোগ করা খুব স্বাভাবিক, আর Rails-এর মতো framework core class-এ অনেক সুবিধা জুড়েছে। সমস্যা কমাতে Ruby “refinement” আনে (Ruby 2.0-তে পরীক্ষামূলক, পরে স্থায়ী): একটি বদল শুধু সেই ফাইলে বা module-এ কার্যকর, যেখানে using দিয়ে চাওয়া হয়েছে। অর্থাৎ monkey patch-কে lexical scope-এ বাঁধা, ঠিক যেমন পর্ব ১৫-এ static scope নামের অর্থকে লেখার জায়গায় বাঁধে।

Python-এর সংস্কৃতি অন্য পথ নিয়েছে: built-in type (int, list) সাধারণ কোড থেকে patch করাই যায় না, আর অন্যের module patch করা মূলত test-এ, with-ব্লকের ভেতরে সীমিত সময়ের জন্য, যা শেষে নিজে থেকে ফেরে। তিন ভাষার তিন উত্তর একই প্রশ্নের: নমনীয়তা কতটুকু, আর তার প্রভাব কতদূর ছড়াবে।

মূল উপলব্ধি: Monkey patch-এর আসল দাম তার পরিধি। প্রভাব যত ছোট জায়গায় আর যত কম সময়ে সীমিত, তত নিরাপদ; global আর স্থায়ী patch পুরো ecosystem-এর ভবিষ্যৎকে আটকে দিতে পারে।

অনুশীলন

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

  1. বাস্তবায়ন — নিরাপদ evaluator বাড়ানো: অংশ ৬-এর run-এ তুলনা (>=, <, ==, শুধু একটি তুলনা, শিকল নয়) আর a if c else b যোগ করুন, যাতে পুরো নিয়ম t - t / 10 if t >= 1000 else t চলে। শর্তের মান Bool না হলে Haat-এর মতো প্রত্যাখ্যান করুন। 1040, 540, 1100, 200-এ ফল কত, আর ঢাকার তিন অর্ডারের (1040, 1100, 200) যোগ কত? 0 < t < 5000, t ** 2 আর t if t else 0-এ কী হবে?
    CMP = {ast.GtE: lambda a, b: a >= b, ast.Lt: lambda a, b: a < b,
           ast.Eq: lambda a, b: a == b}
    # inside run(), two new cases:
            case ast.Compare(left=l, ops=[op], comparators=[r]) if type(op) in CMP:
                return CMP[type(op)](run(l, env), run(r, env))
            case ast.IfExp(test=c, body=a, orelse=b):
                cond = run(c, env)
                if type(cond) is not bool: raise ValueError("condition must be Bool")
                return run(a, env) if cond else run(b, env)

    Python 3.14.4-এ চালানো ফল: [936, 540, 990, 200], যোগ 2126, তারপর 0 < t < 5000 -> not allowed: Compare, t ** 2 -> not allowed: BinOp, t if t else 0 -> condition must be Bool. Pattern ops=[op] শুধু এক-operator তুলনা ধরে, তাই শিকল-তুলনা Compare node হয়েও কোনো case-এ মেলে না আর শেষের raise-এ পৌঁছায়; Haat-এর “comparison operators cannot be chained” নিয়মের সঙ্গে মিল। ** একটি BinOp, কিন্তু তার op (Pow) OPS-এ নেই। শেষটি Python-এ বৈধ (০ ছাড়া সব int “সত্য”), কিন্তু Haat-এ if-এর শর্ত Bool হতেই হবে, তাই আমাদের evaluator-ও প্রত্যাখ্যান করে। লক্ষ করুন, a if c else b-এ শুধু একটি শাখা চলে: এটি short-circuit, যা অংশ ২-এর stepper-এর সঙ্গে মিলিয়ে ভাবুন।

  2. ভুল খুঁজুন: shop.py-তে def discounted(t): …; checkout.py-তে from shop import discounted আর def pay(t): return discounted(t). একজন test লিখলেন with mock.patch("shop.discounted", lambda t: t): print(checkout.pay(1040)), আশা করলেন 1040 (ছাড় নেই)। কী ছাপা হয়, কেন, আর ঠিক কীভাবে লিখবেন?

    সত্যিকারের run (Python 3.14.4, unittest.mock): patched shop.discounted: 936. Patch কাজ করেনি, কারণ checkout import-এর মুহূর্তে নিজের module-এ discounted নামে একটি নতুন নাম বানিয়ে আসল function-টি বেঁধে রেখেছে। pay চলার সময় LOAD_GLOBAL discounted খোঁজে checkout-এর dictionary-তে, shop-এর নয়; patch বদলেছে শুধু shop-এর ঘর। ঠিক রূপ: mock.patch("checkout.discounted", lambda t: t), যার ফল 1040, আর with-ব্লক শেষে নিজে থেকে ফিরিয়ে দেওয়ায় পরে আবার 936. নিয়ম: নামটি যে module-এ খোঁজা হয়, সেখানে patch করুন, যেখানে সংজ্ঞায়িত সেখানে নয়। বিকল্প: checkout-এ import shop লিখে shop.discounted(t) ডাকা; তখন মূল module-এ patch-ও কাজ করত। এই ভুল সবচেয়ে বিপজ্জনক কারণ test সবুজ থাকে, অথচ যা পরীক্ষা করার কথা তা হয়নি।

  3. আউটপুট অনুমান করুন: Python 3.14-এ print("5" * 2, "5" + str(2), True + True) আর "5" + 2; JavaScript-এ console.log("5" * 2, "5" + 2, "5" - 2, [1, 2] + [3], true + true). কোনটি strong, কোনটি weak typing দেখায়?

    Python-এ চালানো ফল: 55 52 2, আর "5" + 2-এ TypeError: can only concatenate str (not "int") to str. "5" * 2 হলো string-এর পুনরাবৃত্তি (একটি নির্দিষ্ট, ঘোষিত নিয়ম), রূপান্তর নয়; str(2) স্পষ্ট রূপান্তর; True + True = 2, কারণ Python-এ bool হলো int-এর subclass, তাই এটিও রূপান্তর নয়, subtype. কিন্তু str + int-এর কোনো নিয়ম নেই, তাই error: strong typing.

    Node.js-এ চালানো ফল: 10 52 3 1,23 2. * আর - সংখ্যায় রূপান্তর করে (10, 3), + একটি দিক string হলেই জোড়া লাগায় ("52"), দুটি array-কে আগে string বানিয়ে ("1,2" আর "3") জোড়ে ("1,23"), আর true + true = 2. একই লেখা "5" + 2 দুই ভাষায় দুই আচরণ: Python-এ error, JavaScript-এ "52". দুটিই dynamic ভাষা; পার্থক্য strong বনাম weak.

  4. খোঁজের ক্রম trace করুন:
    class Order:
        def __init__(self, amount): self.amount = amount
        @property
        def total(self): return self.amount - self.amount // 10 if self.amount >= 1000 else self.amount
        def label(self): return "web"
    o = Order(1040)
    o.__dict__["total"] = 0
    o.__dict__["label"] = lambda: "phone"
    print(o.total, o.label())
    o.total = 5
    প্রথম print কী ছাপে, শেষ লাইনে কী হয়, আর কেন total আর label আলাদা আচরণ করে?

    Python 3.14.4-এ চালানো ফল: 936 phone, তারপর শেষ লাইনে AttributeError: property 'total' of 'Order' object has no setter.

    1. o.total: প্রথমে class-এর সারিতে খোঁজ, পাওয়া গেল একটি property, যা data descriptor (পড়া আর লেখা দুটিই নিয়ন্ত্রণ করে)। Data descriptor instance-এর dictionary-র আগে জেতে, তাই o.__dict__["total"] = 0 উপেক্ষিত; property চলে, 1040 − 104 = 936.
    2. o.label: class-এর সারিতে একটি সাধারণ function, যা non-data descriptor. সেটি instance-এর dictionary-র পরে আসে, তাই instance-এর lambda জেতে: “phone”. (Order.label(o) লিখলে এখনো “web”.)
    3. o.total = 5: লেখার সময়ও data descriptor আগে দেখা হয়; property-র setter নেই, তাই AttributeError.

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

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

ক্রমPython-এ o.x পড়ার সময় (সাধারণ class, __getattribute__ বদলানো হয়নি) খোঁজের ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. type(o)-এর MRO-তে x খোঁজা, আর সেটি data descriptor হলে তার পড়ার নিয়ম চালানো
  2. না হলে o-র নিজের __dict__-এ x খোঁজা
  3. না পেলে MRO-তে পাওয়া জিনিসটি ব্যবহার (function হলে bound method বানানো)
  4. কোথাও না পেলে class-এ __getattr__ থাকলে সেটি ডাকা
  5. তাতেও না হলে AttributeError

Python 3.14-এ def label(t): যার দেহ if t >= 1000: return "free delivery" আর তারপর return t + " taka". print(label(1040)); print(label(540)) চালালে কী হয়?

  • কিছুই ছাপা হয় না, চালানোর আগেই TypeError
  • “free delivery” ছাপা হয়, তারপর দ্বিতীয় call-এ TypeError
  • “free delivery” আর “540 taka” দুটিই ছাপা হয়
  • কিছুই ছাপা হয় না, কারণ function-টি বাতিল হয়

নিচের কোন জোড়া সঠিকভাবে “static/dynamic” আর “strong/weak” প্রশ্নের পার্থক্য বলে?

  • Dynamic আর weak একই কথা
  • Static ভাষায় কখনো implicit conversion থাকে না
  • Static মানে compiled, dynamic মানে interpreted
  • Static/dynamic = “কখন যাচাই”, strong/weak = “অমিল হলে error না রূপান্তর”

একটি web app ব্যবহারকারীর লেখা সূত্র (যেমন t - t / 10) হিসাব করে। কোন পদ্ধতি সবচেয়ে নিরাপদ?

  • লেখাটি parse করে AST বানানো, তারপর শুধু অনুমোদিত node-গুলো নিজের evaluator দিয়ে হিসাব করা
  • eval(text, {"__builtins__": {}})
  • লেখায় “import” বা “os” শব্দ থাকলে আটকে দিয়ে বাকিটা eval করা
  • ast.literal_eval(text) দিয়ে হিসাব করা

checkout.py-তে from shop import discounted আর def pay(t): return discounted(t). Test-এ mock.patch("shop.discounted", lambda t: t)-এর ভেতরে checkout.pay(1040) কী দেয় (মূল discounted 1040-কে 936 করে)?

  • 1040, কারণ patch সব জায়গায় কাজ করে
  • AttributeError, কারণ shop-এ patch করা যায় না
  • 936, কারণ checkout নিজের module-এ নামটির আলাদা বাঁধন রেখেছে
  • 0

CPython 3.14-এ def add(a, b): return a + b-কে বারবার int দিয়ে ডাকার পর dis.get_instructions(add, adaptive=True)-এ BINARY_OP_ADD_INT দেখা যায়। এর সবচেয়ে সঠিক ব্যাখ্যা কোনটি?

  • add এখন শুধু int নেয়; string দিলে TypeError
  • CPython বাস্তবে আসা type দেখে নির্দেশটিকে বিশেষায়িত করেছে; অন্য type এলে সাধারণ পথে ফিরে আবার মানিয়ে নিতে পারে
  • CPython compile-এর সময় type inference করে int বের করেছে
  • add-কে ফাইলে native machine code হিসেবে compile করে রাখা হয়েছে

Python-এ duck typing আর static structural typing (যেমন Go-র interface বা TypeScript)-এর মূল পার্থক্য কী?

  • Duck typing-এ inheritance বাধ্যতামূলক, structural typing-এ নয়
  • Duck typing নাম দেখে, structural typing গঠন দেখে
  • Structural typing-এ object থাকে না
  • প্রশ্ন একই, কিন্তু duck typing চলার সময় যাচাই করে, structural typing চালানোর আগে

শব্দকোষ

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

মনে রাখুন

  1. Dynamic মানে দেরিতে binding: type, নামের অর্থ, object-এর গঠন, এমনকি কোড চলার সময় ঠিক হয়। Scripting একটি ব্যবহারের ধরন; dynamic হওয়া semantics-এর গুণ, interpreted হওয়া বাস্তবায়নের।
  2. তিন মুহূর্ত: Haat চালানোর আগে প্রত্যাখ্যান করে, Python (dynamic, strong) লাইন চলার সময় TypeError দেয়, JavaScript (dynamic, weak) চুপচাপ রূপান্তর করে।
  3. Duck typing আর late binding: সাধারণ class ছাড়াই তিন আকারের অর্ডারে ঢাকার মোট 2126; ভাঙা object ধরা পড়ে শুধু তার শাখা চললে। Python-এর খোঁজ: data descriptor → instance → class-এর MRO → __getattr__ → AttributeError.
  4. eval নয়, parse: বাইরের লেখা কখনো eval নয়; JSON/literal_eval ডেটার জন্য, আর সূত্রের জন্য AST-এর ওপর allowlist-ভিত্তিক নিজের interpreter.
  5. Patch আর গতির দাম: নাম যেখানে খোঁজা হয় সেখানে patch, আর সবসময় ফেরানো। Dynamism compiler-এর জ্ঞান কমায়; engine ফেরত পায় বাস্তবের type দেখে বিশেষায়ন, inline cache আর JIT দিয়ে।

পরের পর্বে: Imperative, OOP, functional, logic, concurrent আর dynamic: ছয়টি ধাঁচ দেখা হলো। পর্ব ১৩-এ একই বাজারঘরের কাজ তিন ধাঁচে পাশাপাশি লিখে মাপবেন, আর শিখবেন কোন সমস্যায় কোন paradigm বেছে নেবেন।

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

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