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

Module, package আর namespace — বড় program ভাগ করা

Modules, Packages and Namespaces — Splitting a Large Program

Taught in Bangla, this lesson splits large programs into modules with interfaces and information hiding. It steps through Python's import and sys.modules and builds a module by hand, contrasts the JavaScript module pattern, CommonJS and ES modules, and explains C headers and static or extern linkage. Real Clang 22.1.8 runs show a duplicate-symbol link error, a silent C type mismatch and C++ name mangling, and in-page Python finds load order and an import cycle by DFS. It sketches an import design for Haat.

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

  • Module, package, namespace আর qualified name-এর পার্থক্য, আর information hiding কেন বড় program-এর মূল নীতি
  • Python-এর import ধাপে ধাপে: sys.modules cache, finder, loader, module-এর namespace dict, আর circular import কেন ভাঙে
  • JavaScript-এর module pattern, CommonJS আর ES module-এর মূল পার্থক্য (মানের কপি বনাম live binding)
  • C-র translation unit, header, static আর extern linkage, separate বনাম independent compilation, আর C++-এর name mangling সত্যিকারের Clang আউটপুটে
  • Module-এর dependency graph-এ DFS দিয়ে load order আর cycle বের করা, আর Haat-এর জন্য একটি import ব্যবস্থার নকশা

১ · কেন module: বড় program-কে ঘরে ভাগ করা

পর্ব ১৪-এ (নাম, variable আর binding) দেখেছেন, একটি নাম কোনো একটি জিনিসের সঙ্গে বাঁধা থাকে। পর্ব ১৫-এ (Scope — static বনাম dynamic scoping) দেখেছেন, একটি function বা block-এর ভেতরে কোন নাম দেখা যায়। এই পর্বে প্রশ্নটি আরও বড় মাপের: হাজার হাজার লাইনের program, অনেকজন প্রোগ্রামার, অনেকগুলো ফাইল। কে কোন নাম দেখবে, কে কোনটি দেখবে না, আর একটি ফাইল বদলালে বাকিদের কী হবে?

বাজারঘরের অফিসটি ভাবুন। হিসাব বিভাগ, ডেলিভারি বিভাগ আর গুদাম আলাদা ঘরে বসে। প্রতিটি ঘরের দরজায় একটি জানালা আছে: “এখানে বিল জমা দিন”, “এখানে ডেলিভারির ঠিকানা দিন”। ভেতরে তারা খাতা কীভাবে রাখে, কোন ক্যালকুলেটর ব্যবহার করে, তা অন্য বিভাগের জানার দরকার নেই। হিসাব বিভাগ যদি কাল থেকে খাতার বদলে কম্পিউটারে হিসাব রাখে, ডেলিভারি বিভাগ টেরও পাবে না, কারণ জানালাটি একই আছে। আর দুই বিভাগেই “রহিম” নামে একজন থাকলেও গোলমাল হয় না: “হিসাবের রহিম” আর “ডেলিভারির রহিম”। Module ঠিক এই ব্যবস্থা: জানালা হলো interface, ভেতরের খাতা হলো implementation, আর “হিসাবের রহিম” হলো qualified name.

Module থেকে তিনটি আলাদা লাভ পাওয়া যায়, আর প্রতিটির জন্য ভাষার আলাদা ব্যবস্থা লাগে:

  1. নামের সংঘাত এড়ানো (namespace): দুই দলের লেখা কোডে একই নাম, যেমন discount, থাকলেও যেন একটি অন্যটিকে ঢেকে না দেয়।
  2. লুকানো (information hiding আর visibility): module-এর ভেতরের সহায়ক function আর data বাইরে থেকে ছোঁয়া যাবে না, যাতে ভেতরটা নিশ্চিন্তে বদলানো যায়।
  3. আলাদা করে অনুবাদ (separate compilation): একটি ফাইল বদলালে পুরো program আবার compile না করে শুধু সেই অংশটুকু, আর তৈরি অংশগুলো পরে জোড়া।

David Parnas ১৯৭২ সালে Communications of the ACM-এ “On the Criteria To Be Used in Decomposing Systems into Modules” প্রবন্ধে একটি ছোট program (KWIC index, শব্দের সূচি বানানোর program) দুইভাবে ভাগ করে তুলনা করেন। প্রথম ভাগ কাজের ধাপ ধরে: পড়া, ঘোরানো, সাজানো, ছাপা। দ্বিতীয় ভাগ “কোন নকশা-সিদ্ধান্ত পরে বদলাতে পারে” ধরে, আর প্রতিটি সিদ্ধান্ত একটি module-এর ভেতরে লুকানো। তাঁর যুক্তি ছিল, দ্বিতীয় ভাগে একটি সিদ্ধান্ত বদলালে সাধারণত একটিমাত্র module বদলাতে হয়। এই নীতিই আজ information hiding নামে পরিচিত, আর পরের দশকের ভাষাগুলো (Modula-2, Ada-র package) একে ভাষার ব্যাকরণে তুলে আনে। নকশার দিক থেকে coupling আর cohesion-এর আলোচনা আছে সফটওয়্যার ইঞ্জিনিয়ারিং কোর্সের পর্ব ২৫-এ.

এই কোর্সের প্রশ্ন একটু আলাদা: ভাষা আর compiler এই তিনটি লাভ কীভাবে বাস্তবায়ন করে? উত্তর ভাষাভেদে খুব আলাদা, আর সেই পার্থক্যই এই পর্বের বিষয়। Python-এ module একটি চলমান object, C-তে module বলে ভাষার কিছুই নেই (আছে শুধু ফাইল আর linker), আর C++ নামের ভেতরেই namespace আর type লিখে দেয়।

২ · Namespace আর qualified name

পর্ব ১৪-এর ভাষায়, একটি environment হলো নাম থেকে জিনিসের একটি টেবিল। একটি namespace হলো এমনই একটি নামযুক্ত টেবিল, যাকে বাইরে থেকে তার নিজের নাম দিয়ে ডাকা যায়। Namespace-এর ভেতরের একটি নাম বাইরে থেকে লিখতে হলে আগে namespace-এর নাম, তারপর একটি বিভাজক চিহ্ন, তারপর ভেতরের নাম। এই পুরো লেখাটিকে বলে qualified name. বিভাজক ভাষাভেদে আলাদা:

ভাষাNamespace-এর এককQualified name
Python 3প্রতিটি module (ফাইল) আর package (ফোল্ডার)shop.pricing.price
C++20namespace bazar { … }, class, আর C++20-এর modulebazar::delivery::cost
Java 21package (package bazar.pricing;) আর class; Java 9 থেকে module-ওbazar.pricing.Price.of(…)
JavaScript (ES2025)প্রতিটি module ফাইলের নিজের scope; import * as pricing একটি namespace object দেয়pricing.price(…)
C17ভাষায় কোনো namespace নেই; সব global নাম এক জায়গায়। প্রচলিত উপায় নামের আগে উপসর্গbazar_delivery_cost(…) (শুধু একটি লম্বা নাম)
Haat v1একটিই ফাইল, একটিই top level; module নেইনেই (অংশ ৯-এ নকশা করবেন)

C-র সারিটি লক্ষ করুন। C-তে সব ফাইলের global function একটি বড় namespace ভাগ করে, তাই বড় C লাইব্রেরি নিজের সব নামের আগে একটি উপসর্গ বসায়, যেমন SQLite-এর প্রায় সব function sqlite3_ দিয়ে শুরু। এটি প্রথা, ভাষার নিয়ম নয়; compiler কিছু যাচাই করে না।

একটি qualified name পড়ার নিয়ম সরল: প্রথম অংশটি সাধারণ নামের মতো চারপাশের scope-এ খোঁজা হয়, তারপর প্রতিটি পরের অংশ খোঁজা হয় শুধু আগের অংশের ভেতরে। bazar::delivery::cost-এ delivery খোঁজা হয় শুধু bazar-এর ভেতরে, পুরো program-এ নয়। Python-এ shop.pricing.price-ও একই রকম, শুধু পার্থক্য হলো C++ এই খোঁজা সারে compile-এর সময়, আর Python চলার সময় প্রতিটি ডট-এ একটি attribute পড়ে। Compile-এর সময়ের খোঁজাটি অংশ ৬-এর stepper-এ ধাপে ধাপে দেখবেন।

সংজ্ঞা ১৮.১ — namespace আর qualified lookup

একটি namespace N হলো নাম থেকে সত্তার একটি টেবিল: N = {x ↦ d1, y ↦ d2, …}, যেখানে কোনো সত্তা d নিজেও একটি namespace হতে পারে। Qualified name a::b::c-এর মান:

lookup(a::b::c) = (ρ(a))(b)(c)

এখানে ρ হলো যেখানে নামটি লেখা হয়েছে সেখানকার সাধারণ environment (পর্ব ১৪-এর সংজ্ঞা ১৪.১), আর N(b) মানে “namespace N-এর টেবিলে b”. কোনো ধাপে নাম না পেলে error; কোনো ধাপের ফল namespace না হলে (যেমন price::x, যেখানে price একটি function) সেটিও error.

এই সংজ্ঞা থেকে একটি দরকারি সিদ্ধান্ত আসে: দুটি namespace-এ একই নাম থাকলেও কোনো সংঘাত হয় না, কারণ qualified lookup-এর প্রতিটি ধাপ একটি নির্দিষ্ট টেবিলে আটকানো। সংঘাত তখনই হয়, যখন কেউ দুটি namespace-এর নাম একটি টেবিলে ঢেলে দেয়: C++-এ দুটি using namespace, Python-এ দুটি from x import *, বা C-তে দুটি ফাইলের global নাম। অংশ ৫ আর অংশ ৯-এ এর দুটি সত্যিকারের error দেখবেন।

৩ · Python-এর import: module একটি চলমান object

Python-এ একটি module চলার সময় একটি সাধারণ object, যার ভেতরে একটি dict থাকে: সেই dict-ই module-এর global namespace. import pricing লিখলে CPython মোটামুটি পাঁচটি কাজ করে (CPython 3.3 থেকে এই ব্যবস্থা importlib-এ লেখা):

  1. Cache দেখা: sys.modules নামের একটি dict-এ "pricing" আগে থেকে আছে কি না।
  2. খোঁজা: না থাকলে sys.meta_path-এর finder-গুলোকে একে একে জিজ্ঞেস করা। সাধারণ CPython-এ এরা তিনটি: built-in module, frozen module আর sys.path-এর ফোল্ডারগুলোয় ফাইল খোঁজার PathFinder.
  3. তৈরি: loader একটি খালি module object বানায় আর body চালানোর আগেই তাকে sys.modules-এ রাখে।
  4. চালানো: module-এর bytecode (দরকার হলে .py থেকে compile করে, __pycache__-এ রেখে) চালানো হয়, আর সেই চালানোর global namespace হলো module-এর dict.
  5. বাঁধা: যে ফাইল import করেছে, তার namespace-এ pricing নামটি module object-এর সঙ্গে বাঁধা হয়।
1import pricing2import pricing3from pricing import price
এই ধাপের পরে
কাজ
sys.modules
pricing-এর dict
__main__-এর নাম
  1. Cache দেখা। প্রথম লাইনে CPython আগে sys.modules dict-এ "pricing" খোঁজে। প্রথমবার নেই, তাই খোঁজাখুঁজি শুরু।
  2. Finder. Built-in আর frozen module-এর তালিকায় pricing নেই। PathFinder sys.path-এর ফোল্ডারগুলো একে একে দেখে, আর চলতি ফোল্ডারে pricing.py পায়। ফল একটি “spec”: কোথায় পাওয়া গেল, কোন loader চালাবে।
  3. খালি module, আগেই cache-এ। Loader একটি খালি module object বানিয়ে sys.modules["pricing"]-এ রাখে, body চালানোর আগেই। এই ক্রমটিই পরে circular import-কে সম্ভব (আর বিপজ্জনক) করে।
  4. Body চলে। pricing.py-এর লাইনগুলো চলে, আর প্রতিটি top-level assignment বা def module-এর dict-এ একটি নাম যোগ করে। Body-র print এখনই ছাপে “pricing loaded”.
  5. নাম বাঁধা। এবার __main__-এর namespace-এ pricing নামটি module object-এর সঙ্গে বাঁধা হলো। import আসলে একটি assignment-এর মতো binding.
  6. দ্বিতীয় import: শুধু cache. লাইন ২-এ sys.modules-এ pricing পাওয়া গেল, তাই body আর চলে না, কিছু ছাপাও হয় না। শুধু নামটি আবার বাঁধা হয়।
  7. from … import. লাইন ৩ module-টি cache থেকে নেয়, তার dict থেকে price পড়ে, আর __main__-এ একটি নতুন নাম price বাঁধে, যা একই function object-এর alias. Module-এর নাম pricing এতে বদলায় না।

এবার এই ব্যবস্থা নিজের হাতে চালিয়ে দেখি। নিচের কোড কোনো ফাইল ছাড়াই একটি module বানায়: types.ModuleType দিয়ে object, sys.modules-এ রাখা, তারপর একটি string-এর কোড সেই module-এর dict-এ চালানো। তারপর সাধারণ import লিখলে Python কোনো ফাইল খোঁজে না, কারণ cache-এ পেয়ে যায়।

import sys, types
src = '''
print("  ...running the body of shop_pricing")
RATE = 10
def _cut(p):            # leading _ : "private" by convention
    return p * RATE // 100
def price(qty, unit):
    p = qty * unit
    return p - _cut(p) if p >= 1000 else p
'''
# what 'import' does, by hand: 1) module object 2) cache 3) run body
mod = types.ModuleType("shop_pricing")
sys.modules["shop_pricing"] = mod      # cached BEFORE the body runs
exec(src, mod.__dict__)                # globals of the body = module dict

import shop_pricing                    # cache hit: body does not run again
import shop_pricing as sp
print("same object?", shop_pricing is mod, sp is mod)
print("names:", [k for k in vars(mod) if not k.startswith("__")])
print("price(2, 520) =", shop_pricing.price(2, 520))

from shop_pricing import price         # binds a NEW name to the function
shop_pricing.RATE = 20                 # change the module's namespace
print("after RATE=20:", price(2, 520), shop_pricing.price(2, 520))
price = lambda q, u: 0                 # rebinds only OUR name
print("module still has:", shop_pricing.price(2, 520))

import math
print("math cached?", "math" in sys.modules, math.floor(9.5))

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

  ...running the body of shop_pricing
same object? True True
names: ['RATE', '_cut', 'price']
price(2, 520) = 936
after RATE=20: 832 832
module still has: 832
math cached? True 9

“running the body” মাত্র একবার ছাপা হয়েছে, যদিও module-টি দুবার import করা হলো: দুটি import-ই sys.modules-এ একই object পেয়েছে (same object? True True). as sp শুধু ভিন্ন নামে একই object বাঁধে। Module-এর namespace সত্যিই একটি সাধারণ dict: vars(mod)-এ RATE, _cut, price. এরপর আসল শিক্ষা: from shop_pricing import price-এর পরে module-এর RATE 20 করলে আমাদের price-ও 832 দিল (1040 − 208), কারণ function-টি তার global নামগুলো পড়ে নিজের module-এর dict থেকে, চলার সময়। কিন্তু আমাদের নাম price-কে অন্য function-এ বাঁধলে module-এর price বদলায় না: এটি শুধু আমাদের namespace-এর rebinding. শেষ লাইনে দেখা গেল math-ও cache-এ ছিল। Python-এর দিক থেকে module, package আর __name__ == "__main__"-এর ব্যবহারিক আলোচনা আছে Python কোর্সের পর্ব ২২-এ.

Python-এর “private” শুধু প্রথা: _cut-এর সামনের _ কোনো নিষেধ নয়; shop_pricing._cut(500) বাইরে থেকে দিব্যি চলে। _ শুধু দুটি জায়গায় আচরণ বদলায়: from shop_pricing import * এমন নাম আনে না, আর module-এ __all__ তালিকা থাকলে * শুধু সেই তালিকার নাম আনে। Module-স্তরে Python-এ সত্যিকারের লুকানো নেই; ভাষাটি প্রোগ্রামারের ভদ্রতার ওপর ভরসা করে।

৪ · JavaScript: module pattern, CommonJS আর ES module

JavaScript-এর গল্পটি আলাদা, কারণ ভাষাটি প্রায় বিশ বছর কোনো module ব্যবস্থা ছাড়াই চলেছে। Browser-এ সব <script> একটি global namespace ভাগ করত। প্রোগ্রামাররা তাই closure দিয়ে নিজেরাই module বানাতেন: একটি function লিখে সঙ্গে সঙ্গে ডাকা (IIFE), যার local variable বাইরে থেকে দেখা যায় না, আর শুধু একটি object ফেরত দেওয়া। এর নাম module pattern. পর্ব ১৭-এ (Closure) দেখেছেন, ফেরত দেওয়া method-গুলো কেন সেই local variable-গুলো দেখতে পায়।

পরে এল দুটি আসল ব্যবস্থা। CommonJS (২০০৯-এর দিকে সার্ভারের JavaScript-এর জন্য, পরে Node.js-এ): require("x") একটি সাধারণ function, যা চলার সময় ফাইল খুঁজে চালায়, ফল cache-এ রাখে, আর module.exports object ফেরত দেয়। আর ES module (ECMAScript 2015): import/export ব্যাকরণের অংশ, তাই চালানোর আগেই module-গুলোর গ্রাফ তৈরি হয়। নিচের কোডের প্রথম অংশ module pattern, দ্বিতীয় অংশ CommonJS-ধাঁচের একটি ছোট require-এর অনুকরণ (আসল Node.js-এর নয়, তবে একই ভাবনা):

// 1) module pattern: an IIFE hides its locals; only the returned object is public
const pricing = (function () {
  const RATE = 10;                         // private
  function cut(p) { return p * RATE / 100; } // private
  return { price(q, u) { const p = q * u; return p >= 1000 ? p - cut(p) : p; } };
})();
const delivery = (function () {
  function cut(t) { return t >= 1000 ? 60 : 0; } // same name, no clash
  return { cost(t) { return 60 - cut(t); } };
})();
const p = pricing.price(2, 520);
console.log("total:", p + delivery.cost(p));
console.log("pricing.cut is", typeof pricing.cut, "| RATE is", typeof RATE);

// 2) a tiny require() with a cache, like CommonJS
const defs = { counter: (exports) => {
  let count = 0;
  exports.count = count;                   // a COPY of the value
  exports.getCount = () => count;          // reads the live variable
  exports.inc = () => { count += 1; };
}};
const cache = {};
function require(name) {
  if (cache[name]) return cache[name];     // second call: cached object
  const exports = {}; cache[name] = exports;
  defs[name](exports);                     // run the body once
  return exports;
}
const a = require("counter"), b = require("counter");
a.inc(); a.inc();
console.log("same object:", a === b, "| copy:", b.count, "| live:", b.getCount());

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

total: 996
pricing.cut is undefined | RATE is undefined
same object: true | copy: 0 | live: 2

৯৩৬ + ৬০ = ৯৯৬, বাজারঘরের চেনা উত্তর। দুটি IIFE-তেই cut নামে function আছে, কিন্তু সংঘাত নেই: প্রতিটি নিজের function scope-এ বন্দি, বাইরে থেকে typeof বলছে undefined. এখানে লুকানো Python-এর মতো প্রথা নয়, সত্যিকারের: closure-এর বাইরে থেকে RATE-এ পৌঁছানোর কোনো পথ নেই। দ্বিতীয় অংশে require দুবার ডাকলেও body একবার চলেছে আর একই object ফিরেছে (Python-এর sys.modules-এর মতো)। আর exports.count = count রপ্তানির মুহূর্তের মানের একটি কপি, তাই দুবার inc-এর পরেও 0; অন্যদিকে getCount আসল variable পড়ে, তাই 2.

শেষ লাইনটিই CommonJS আর ES module-এর সবচেয়ে বেশি জিজ্ঞাসিত পার্থক্যের ছোট রূপ। CommonJS-এ const { count } = require("./counter") একটি সাধারণ property পড়া, তাই আপনি রপ্তানির সেই মুহূর্তের মান পান। ES module-এ import { count } from "./counter.js" একটি live binding: রপ্তানিকারী module পরে count বদলালে আমদানিকারী নতুন মানটিই দেখে, কিন্তু নিজে count = 5 লিখতে পারে না (TypeError). ES module-এর আরও দুটি গুরুত্বপূর্ণ বৈশিষ্ট্য: import-এর তালিকা ব্যাকরণে স্থির, তাই bundler চালানোর আগেই বুঝতে পারে কোন export কেউ ব্যবহার করে না আর বাদ দিতে পারে (“tree shaking”); আর প্রতিটি module নিজে থেকেই strict mode-এ চলে। ব্যবহারিক খুঁটিনাটি, যেমন browser-এ type="module" আর Node-এ .mjs, আছে JavaScript কোর্সের পর্ব ৪৫-এ.

৫ · C: header, translation unit আর linkage

C-তে “module” শব্দটি ভাষার মানে নেই। আছে তিনটি আলাদা জিনিস, যারা মিলে module-এর কাজ চালায়:

  • Translation unit: একটি .c ফাইল আর তার ভেতরে #include হওয়া সব লেখা। Compiler একবারে ঠিক একটি translation unit দেখে, অন্যগুলোর কিছুই জানে না। ফল একটি object file.
  • Header file: .h ফাইল, যেখানে function-এর ঘোষণা (prototype) থাকে। #include একে হুবহু লেখা হিসেবে ঢুকিয়ে দেয় (preprocessor-এর কাজ, C কোর্সের পর্ব ০৩)। এটিই module-এর “জানালা”, কিন্তু শুধু প্রথা হিসেবে।
  • Linkage: ফাইলের বাইরে (top level-এ) ঘোষিত একটি নাম অন্য ফাইল থেকে দেখা যাবে কি না। সাধারণ function আর global variable-এর external linkage, অর্থাৎ সবাই দেখে; সামনে static লিখলে internal linkage, অর্থাৎ শুধু নিজের ফাইল। C-তে লুকানোর একমাত্র ভাষাগত উপায় এই static.

বাজারঘরের হিসাব দুটি ফাইলে ভাগ করি। দুই ফাইলেই একটি সহায়ক function আছে, দুটির নামই discount, আর দুটিই static:

/* bazar.h: the public interface of two modules */
int price(int qty, int unit);
int delivery(int total);

/* pricing.c */
#include "bazar.h"
static int discount(int p) { return p / 10; }  /* hidden */
int price(int qty, int unit) {
    int p = qty * unit;
    return p >= 1000 ? p - discount(p) : p;
}

/* delivery.c */
#include "bazar.h"
static int discount(int t) { return t >= 1000 ? 60 : 0; }  /* same name, own file */
int delivery(int total) { return 60 - discount(total); }

প্রতিটি ফাইল আলাদা করে compile করে object file-এর symbol table দেখি। Zig 0.17.1-এর ভেতরের Clang 22.1.8 দিয়ে Linux-এর ELF object বানিয়ে, একটি ছোট Python ELF reader (syms.py, ৩০ লাইন) দিয়ে পড়া হয়েছে (সত্যিকারের run):

~/mod $ zig cc -c -O0 --target=x86_64-linux-musl pricing.c
~/mod $ python syms.py pricing.o
SYMBOL      BIND    TYPE    SECTION  SIZE
discount    LOCAL   FUNC    .text    20
price       GLOBAL  FUNC    .text    74
~/mod $ python syms.py delivery.o
SYMBOL      BIND    TYPE    SECTION  SIZE
discount    LOCAL   FUNC    .text    28
delivery    GLOBAL  FUNC    .text    34
~/mod $ zig cc main.c pricing.c delivery.c -o bazar && ./bazar
996

দুটি discount-ই LOCAL: object file-এ নাম আছে (debugger-এর সুবিধার জন্য), কিন্তু linker অন্য ফাইলের সঙ্গে মেলানোর সময় এদের দেখে না। price আর delivery GLOBAL: এরাই module-এর জানালা। (একটি খেয়াল: -O1-এ compiler ছোট static function-টিকে ডাকার জায়গায় বসিয়ে দেয় আর symbol-টি পুরো মুছে যায়; ফাইলের বাইরে কেউ দেখে না বলেই এটি নিরাপদ।) এবার দুই ফাইল থেকেই static মুছে দিলে:

~/mod $ zig cc --target=x86_64-linux-musl main.c pricing.c delivery.c -o bazar
ld.lld: error: duplicate symbol: discount
>>> defined at pricing.c:2
>>>            …/pricing.o:(discount)
>>> defined at delivery.c:2
>>>            …/delivery.o:(.text+0x0)

দুটি ফাইলই আলাদাভাবে ঠিকঠাক compile হয়েছে; সমস্যা ধরা পড়ল শুধু link-এর সময়, যখন linker একটি বড় global namespace-এ সব GLOBAL symbol ঢালল। পর্ব ১৪-এর binding time-এর ভাষায়: C-তে একটি function-এর নাম থেকে তার সংজ্ঞার binding হয় link time-এ। Symbol আর relocation-এর পুরো কাজ পর্ব ৭৪-এ (Linking আর loading).

Separate বনাম independent compilation

পাঠ্যবইয়ে (যেমন Sebesta-র বইতে) দুটি শব্দ আলাদা করা হয়। Separate compilation: প্রতিটি অংশ আলাদা সময়ে compile হয়, কিন্তু compiler অন্য অংশের interface-এর তথ্য পায় আর type মেলায়। Ada আর Java এমন: Java compiler একটি class compile করার সময় অন্য class-এর .class ফাইল পড়ে method-এর স্বাক্ষর যাচাই করে। Independent compilation: প্রতিটি অংশ অন্যদের কিছু না জেনে compile হয়, আর জোড়ার সময় শুধু নাম মেলানো হয়। C এই দলে। ফলটা কেমন বিপজ্জনক, সত্যিকারের run-এ দেখুন। delivery.c-তে int delivery(int total), কিন্তু main.c header ব্যবহার না করে নিজে ভুল ঘোষণা লিখেছে:

#include <stdio.h>
double delivery(double total);   /* wrong: no shared header */
int main(void) { printf("%f\n", delivery(936.0)); return 0; }
~/mm $ zig cc -Wall -Wextra --target=x86_64-linux-musl main.c delivery.c -o bad
~/mm $ echo $?
0
~/mm $ zig c++ -Wall -Wextra --target=x86_64-linux-musl main.cpp delivery.cpp -o badpp
ld.lld: error: undefined symbol: delivery(double)
>>> referenced by main.cpp:3
>>>               …/main.o:(main)
>>> did you mean: delivery(int)
>>> defined in: …/delivery.o

C-তে -Wall -Wextra দিয়েও একটি warning নেই, link সফল। কারণ প্রতিটি translation unit একা নিজের কাছে ঠিক, আর linker শুধু delivery নামটি মিলিয়েছে, type নয়। এই program চালালে আচরণ undefined (একজন double পাঠাবে আর double ফেরত আশা করবে, অন্যজন int); তাই আমরা এটি চালাইনি। প্রতিরোধের উপায় সরল: প্রতিটি .c ফাইল নিজের header নিজেও #include করবে, তাহলে compiler ঘোষণা আর সংজ্ঞার অমিল নিজেই ধরবে। একই দুটি ফাইল C++ হিসেবে compile করলে link error এল, আর linker এমনকি ঠিক function-টির পরামর্শও দিল। কীভাবে? উত্তর পরের অংশে।

৬ · C++: namespace আর name mangling

C++-এর namespace আর function overloading (পর্ব ১৪) linker-এর জন্য একটি সমস্যা তৈরি করে। Linker C-র যুগের যন্ত্র: সে শুধু একটি সমতল নাম চেনে, namespace বা type নয়। তাহলে bazar::delivery::cost(int) আর bazar::delivery::cost(int, bool), একই নামের দুটি function, linker কীভাবে আলাদা চিনবে? সমাধান হলো name mangling: compiler namespace, নাম আর parameter-এর type সবকিছু একটি লম্বা symbol-এর ভেতরে লিখে দেয়।

namespace bazar {
namespace delivery {
int cost(int total) { return total >= 1000 ? 0 : 60; }
int cost(int total, bool express) { return cost(total) + (express ? 40 : 0); }
}
int cost(int qty, int unit) { return qty * unit; }
}
extern "C" int c_cost(int total) { return bazar::delivery::cost(total); }
~/mod $ zig c++ -S -O0 --target=x86_64-linux-gnu mangle.cpp -o mangle.s
~/mod $ grep globl mangle.s
	.globl	_ZN5bazar8delivery4costEi
	.globl	_ZN5bazar8delivery4costEib
	.globl	_ZN5bazar4costEii
	.globl	c_cost

সত্যিকারের run (Clang 22.1.8; লাইনের শেষের মন্তব্য বাদ)। চারটি function, চারটি আলাদা symbol. এই নামগুলো Itanium C++ ABI-এর নিয়মে তৈরি, যা Linux আর macOS-এ GCC আর Clang দুজনেই মানে (Windows-এ MSVC-র নিজের আলাদা নিয়ম আছে)। _ZN5bazar8delivery4costEib ভেঙে পড়ুন:

অংশমানে
_Z“এটি একটি mangled C++ নাম” (C-র নাম এভাবে শুরু হতে পারে না, কারণ _ আর বড় হাতের অক্ষরে শুরু নাম বাস্তবায়নের জন্য সংরক্ষিত)
N … Enested নাম শুরু … শেষ
5bazar৫ অক্ষরের নাম “bazar”
8delivery৮ অক্ষরের নাম “delivery”
4cost৪ অক্ষরের নাম “cost”
i, bparameter-এর type: int, bool

ফেরতের type নামে নেই, শুধু parameter-এর type: সাধারণ function-এর overload ফেরতের type দিয়ে আলাদা করা যায় না, তাই দরকারও নেই। এখন অংশ ৫-এর রহস্য পরিষ্কার: C++-এ ভুল ঘোষণা double delivery(double)-এর symbol _Z8deliveryd, আর সংজ্ঞার symbol _Z8deliveryi. নাম মেলেনি, তাই undefined symbol; lld নামগুলো উল্টো দিকে ভেঙে (demangle করে) মানুষের পড়ার মতো করে দেখিয়েছে। Type-এর অমিল linker-এর কাছে নামের অমিল হয়ে ধরা পড়ল। আর extern "C" লিখলে mangling বন্ধ: c_cost সমতল নাম পায়, যাতে C বা অন্য ভাষা (Python-এর ctypes, Rust-এর FFI) একে ডাকতে পারে।

নিচের stepper-এ একটি qualified call-এর পুরো পথ দেখুন: compiler-এর নাম খোঁজা থেকে linker-এর symbol মেলানো পর্যন্ত।

1namespace bazar {2namespace delivery {3  int cost(int total);4  int cost(int total, bool express);5} }6int fee = bazar::delivery::cost(1040, true);
এই ধাপে
খোঁজা হচ্ছে
কোথায়
ফল
  1. Qualified name চেনা। Parser লাইন ৬-এ bazar::delivery::cost পড়ে: :: দিয়ে জোড়া তিনটি অংশ। সংজ্ঞা ১৮.১-এর ভাষায় lookup = (ρ(bazar))(delivery)(cost).
  2. প্রথম অংশ সাধারণ খোঁজায়। bazar খোঁজা হয় চারপাশের scope-এ, এখানে global namespace-এ। পাওয়া গেল লাইন ১-এর namespace.
  3. দ্বিতীয় অংশ শুধু ভেতরে। delivery খোঁজা হয় শুধু bazar-এর টেবিলে। অন্য কোথাও delivery নামে কিছু থাকলেও তা বিবেচনায় আসে না। পাওয়া গেল লাইন ২-এর namespace.
  4. শেষ অংশ: একটি overload set. bazar::delivery-তে cost নামে দুটি function (লাইন ৩ আর ৪)। নাম খোঁজা এখানে শেষ, কিন্তু কোনটি ডাকা হবে, তা এখনো ঠিক হয়নি। (বাইরের bazar::cost(int, int) এই set-এ নেই।)
  5. Overload বাছাই। Argument দুটির type int আর bool. এক argument-এর cost বাদ, দুই argument-এর cost(int, bool) হুবহু মেলে। এই সিদ্ধান্ত compile time-এর।
  6. Symbol আর link. Compiler call-টি লেখে _ZN5bazar8delivery4costEib নামের symbol-এ (জায়গার অভাবে দুই লাইনে, আসলে একটি নাম)। Linker mangle.o-তে ঠিক এই নামের GLOBAL FUNC খুঁজে পায় আর ঠিকানা বসায়। Namespace আর type সবই এখন একটি সমতল নামের ভেতরে।

C++-এর namespace আর header নিয়ে ব্যবহারিক নিয়ম (using, anonymous namespace, include guard) আছে C++ কোর্সের পর্ব ১১-এ. Template-এর প্রতিটি সংস্করণও আলাদা mangled নাম পায়; সেটি পর্ব ৩৭-এ (Generics-এর বাস্তবায়ন) monomorphization-এর সঙ্গে আসবে, আর function call-এর পুরো চুক্তি (ABI) পর্ব ৭১-এ।

৭ · দৃশ্যমানতা: public, private আর export

Namespace নামের সংঘাত থামায়; দৃশ্যমানতা (visibility) ঠিক করে কোন নাম module-এর বাইরে যাবে। এটি পর্ব ০৮-এর (Object-oriented ভাষার ধারণা) encapsulation-এর module-স্তরের রূপ। ভাষাগুলো দুটি মৌলিক প্রশ্নে আলাদা: কিছু না লিখলে নামটি দেখা যায় কি না (default), আর নিষেধটি কে প্রয়োগ করে (compiler, runtime, নাকি শুধু প্রথা)। এই শব্দগুলোর সাধারণ নাম access modifier.

ভাষাকিছু না লিখলেলুকানো / প্রকাশকে প্রয়োগ করে
C17top-level নাম সবাই দেখেstatic দিয়ে লুকানোcompiler আর linker
C++20C-র মতো; module-এ শুধু export করা নাম বাইরেanonymous namespace, static, exportcompiler আর linker
Java 21package-private: শুধু একই packagepublic, protected, private; module-এ exportscompiler আর JVM
Python 3.14সবকিছু বাইরে থেকে পাওয়া যায়_name আর __all__, শুধু প্রথা আর import *-এপ্রোগ্রামারের ভদ্রতা
JavaScript (ES module)module-এর ভেতরেই থাকেexport দিয়ে প্রকাশভাষা (module scope)
Rustprivate (নিজের module আর তার ভেতরের module)pub, pub(crate)compiler

টেবিলের সবচেয়ে বড় নকশা-প্রশ্ন হলো default. C আর Python-এ ভুলে গেলে নামটি বাইরে চলে যায়; JavaScript-এর ES module আর Rust-এ ভুলে গেলে নামটি ভেতরে থাকে। দ্বিতীয়টি নিরাপদ, কারণ প্রকাশ করা একটি সচেতন সিদ্ধান্ত হয়ে দাঁড়ায়, আর একবার প্রকাশিত নাম অন্যরা ব্যবহার শুরু করলে তা ফিরিয়ে নেওয়া কঠিন। Java দুটি স্তরে কাজ করে: class আর member-এর জন্য access modifier (Java কোর্সের পর্ব ১৭), আর Java 9 (২০১৭) থেকে module system, যেখানে module-info.java-তে exports bazar.pricing; না লিখলে একটি package-এর public class-ও অন্য module থেকে ব্যবহার করা যায় না (উদাহরণ, এখানে চালানো হয়নি)। অর্থাৎ “public” শব্দটির অর্থও স্তরভেদে আলাদা।

একই শব্দ, ভিন্ন অর্থ: Python-এও “name mangling” শব্দটি আছে, কিন্তু অন্য অর্থে। Class-এর ভেতরে __total (দুটি underscore দিয়ে শুরু) লিখলে compiler নামটিকে _Order__total-এ বদলে দেয়, যাতে subclass-এর একই নামের attribute-এর সঙ্গে দুর্ঘটনাবশত সংঘাত না হয়। এটিও লুকানো নয়: বদলানো নাম জানলে বাইরে থেকে পড়া যায়।

৮ · Dependency graph আর import cycle

কোন module কোনটিকে import করে, তা আঁকলে একটি directed graph পাওয়া যায়: dependency graph. A থেকে B-তে তীর মানে “A চালানোর আগে B তৈরি থাকতে হবে”। নিচে বাজারঘরের একটি কাল্পনিক program-এর module (অংশ ৯-এর Haat নকশার জন্যও এই গ্রাফ ব্যবহার করব):

ছবি ১৮.১ — বাজারঘরের module-গুলোর dependency graph

কালো তীর: “import করে”। লাল ড্যাশ তীর: কেউ tax-এ একটি নতুন import যোগ করেছে, আর তাতে একটি cycle তৈরি হলো।

Module dependency graph: main imports orders and report; report imports orders; orders imports pricing and delivery; delivery imports pricing; pricing imports tax; a red dashed edge from tax back to orders creates the cycle orders, pricing, tax main orders report pricing delivery tax import করে নতুন import cycle = orders + দুটি হলুদ
ছবি ১৮.১ — লাল তীর ছাড়া গ্রাফটি একটি DAG (directed acyclic graph), তাই এমন একটি ক্রম আছে যেখানে প্রতিটি module তার সব dependency-র পরে আসে: tax, pricing, delivery, orders, report, main. লাল তীর যোগ হলে orders → pricing → tax → orders একটি চক্র (হলুদ দুটি আর orders), আর এমন কোনো ক্রম আর সম্ভব নয়।

গ্রাফটি DAG হলে module লোড করার একটি বৈধ ক্রম হলো topological sort; এটি পাওয়া যায় depth-first search চালিয়ে, প্রতিটি module-কে তার সব dependency শেষ হওয়ার পরে তালিকায় যোগ করে। আর DFS একই সঙ্গে cycle-ও ধরে: প্রতিটি module-এর তিনটি রং ধরা হয়। সাদা = এখনো দেখা হয়নি, ধূসর = “লোড হচ্ছে” (DFS-এর পথে আছে), কালো = শেষ। কোনো ধূসর module-এ আবার পৌঁছানো মানে আমরা নিজের পথের একটি আগের module-এ ফিরে এসেছি: একটি cycle. Graph-এর দিক থেকে DFS আর topological sort-এর পূর্ণ আলোচনা আছে DSA কোর্সের পর্ব ৪১ আর পর্ব ৪২-এ.

# Haat extension: which file imports which (import "x.haat";)
deps = {"main": ["orders", "report"], "orders": ["pricing", "delivery"],
        "delivery": ["pricing"], "pricing": ["tax"],
        "report": ["orders"], "tax": []}
WHITE, GREY, BLACK = "white", "grey", "black"

def load_order(deps, root):
    color = {m: WHITE for m in deps}
    order, path = [], []
    def visit(m):
        color[m] = GREY; path.append(m)          # m is "being loaded"
        for d in deps[m]:
            if color[d] == GREY:                 # back edge: a cycle
                cyc = path[path.index(d):] + [d]
                raise ValueError("import cycle: " + " -> ".join(cyc))
            if color[d] == WHITE:
                visit(d)
        color[m] = BLACK; path.pop()
        order.append(m)                          # all its imports are done
    visit(root)
    return order

print("load order:", load_order(deps, "main"))
deps["tax"] = ["orders"]                         # someone adds one import
try:
    load_order(deps, "main")
except ValueError as e:
    print("error:", e)

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

load order: ['tax', 'pricing', 'delivery', 'orders', 'report', 'main']
error: import cycle: orders -> pricing -> tax -> orders

প্রথম run-এ গ্রাফটি DAG, তাই একটি বৈধ load order এল: tax সবার আগে, কারণ তার কোনো dependency নেই, আর main সবার শেষে। delivery যখন pricing-এ পৌঁছায়, pricing তখন কালো, তাই আবার যাওয়া হয় না: প্রতিটি module একবারই লোড হয় (Python-এর cache-এর মতো)। দ্বিতীয় run-এ tax যখন orders-এ পৌঁছায়, orders ধূসর, অর্থাৎ এখনো লোড হচ্ছে; path-এর সেই অংশটুকুই cycle. পুরো কাজ O(n + m), যেখানে n module আর m import-এর সংখ্যা।

1main     -> orders, report2orders   -> pricing, delivery3delivery -> pricing4pricing  -> tax5report   -> orders6tax      -> (নেই; ধাপ ১০-এ orders)
এই ধাপের পরে
এখন
path
load order
  1. শুরু main থেকে। main ধূসর হলো আর path-এ ঢুকল। তার প্রথম dependency orders, যা সাদা।
  2. orders. orders ধূসর, path এখন main › orders. প্রথম dependency pricing, সাদা।
  3. pricing. pricing ধূসর, path তিন ধাপ লম্বা। তার একমাত্র dependency tax, সাদা।
  4. tax: পাতা। tax-এর কোনো import নেই, তাই সঙ্গে সঙ্গে কালো, আর load order-এর প্রথম সদস্য। Path থেকেও বেরিয়ে গেল।
  5. pricing শেষ। pricing-এর সব dependency কালো, তাই সে-ও কালো আর তালিকায় দ্বিতীয়।
  6. delivery: কালোকে আর ছোঁয়া নয়। orders-এর দ্বিতীয় dependency delivery; তার dependency pricing আগেই কালো, তাই আবার যাওয়া হয় না। delivery কালো, তালিকায় তৃতীয়।
  7. orders শেষ। দুটি dependency-ই কালো, তাই orders কালো, তালিকায় চতুর্থ। Path-এ এখন শুধু main.
  8. report. main-এর দ্বিতীয় dependency report; তার dependency orders কালো। report কালো, তালিকায় পঞ্চম।
  9. main শেষ। সব module কালো। Load order: tax, pricing, delivery, orders, report, main. প্রতিটি module তার সব dependency-র পরে।
  10. নতুন import: tax → orders. আবার DFS: main › orders › pricing › tax পর্যন্ত একই পথ। এবার tax-এর dependency orders, আর orders ধূসর, এখনো path-এ। Path-এর orders থেকে শেষ পর্যন্ত অংশটুকু, তারপর orders: এটিই cycle.

Python-এ cycle: অর্ধেক তৈরি module

Python import cycle-কে নিষেধ করে না, কিন্তু অংশ ৩-এর ধাপ ৩ মনে করুন: module body চালানোর আগেই sys.modules-এ রাখা হয়। তাই cycle-এর মাঝখানে দ্বিতীয় module প্রথমটিকে cache-এ পায়, কিন্তু অর্ধেক ভরা অবস্থায়। নিচের কোড ব্রাউজারের Python-এর নিজস্ব ফাইল-ব্যবস্থায় দুটি আসল ফাইল লিখে import করে:

import sys, os, tempfile
d = tempfile.mkdtemp(); sys.path.insert(0, d)
sys.dont_write_bytecode = True     # always read the .py files
def write(name, text):
    with open(os.path.join(d, name), "w") as f: f.write(text)

write("orders.py", '''print("orders: start")
from pricing import price          # orders needs pricing ...
TAX = 5
def total(q, u): return price(q, u)
print("orders: done")''')
write("pricing.py", '''print("pricing: start")
import sys
o = sys.modules["orders"]
print("  orders cached?", o is not None, "| has TAX yet?", hasattr(o, "TAX"))
from orders import TAX             # ... and pricing needs orders
def price(q, u): return q * u + TAX''')
try:
    import orders
except ImportError as e:
    print("ImportError:", str(e).rsplit(" (", 1)[0])
print("left in cache:", [m for m in ("orders", "pricing") if m in sys.modules])

write("pricing.py", '''print("pricing: start")
import orders                      # bind the module object only
def price(q, u): return q * u + orders.TAX   # read TAX at call time''')
import orders
print("total:", orders.total(2, 520))

আসল আউটপুট (ব্রাউজারের Python; error-এর শেষের ফাইল-পথ কেটে দেওয়া হয়েছে):

orders: start
pricing: start
  orders cached? True | has TAX yet? False
ImportError: cannot import name 'TAX' from partially initialized module 'orders' (most likely due to a circular import)
left in cache: []
orders: start
pricing: start
orders: done
total: 1045

ক্রমটি দেখুন: orders শুরু হলো, তার দ্বিতীয় লাইনেই pricing-এর import, pricing শুরু হয়ে orders-কে cache-এ পেল (True), কিন্তু TAX = 5 লাইন তখনো চলেনি (False). তাই from orders import TAX ভাঙল, আর CPython নিজেই কারণ অনুমান করে বলল “most likely due to a circular import”. ব্যর্থ import-এর পরে দুটি module-ই cache থেকে সরানো হয়েছে ([]), যাতে অর্ধেক তৈরি module কেউ ভুলে ব্যবহার না করে। দ্বিতীয় চেষ্টায় pricing শুধু import orders করে, অর্থাৎ module object-টি বাঁধে, আর orders.TAX পড়ে price ডাকার সময়, যখন orders পুরো তৈরি: 1040 + 5 = 1045. এটি একটি কাজ-চালানো সমাধান; ভালো সমাধান সাধারণত ভাগ করা জিনিসটি (এখানে TAX) একটি তৃতীয় module-এ সরানো, যাতে cycle-টিই না থাকে। এই ধরনের error-এর নাম circular import.

ভাষাগুলো cycle নিয়ে আলাদা নীতি নিয়েছে। Python অনুমতি দেয়, কিন্তু ক্রমের দায় প্রোগ্রামারের। Go-র compiler import cycle পেলে program-টিই compile করে না (import cycle not allowed). ES module cycle-এর অনুমতি দেয় আর live binding-এর কারণে অনেক ক্ষেত্রে ঠিকঠাক চলে, কিন্তু আগে লোড হওয়া module-এর top-level কোড পরেরটির নাম তখনো না পেলে ReferenceError পেতে পারে। কোনটি ভালো, তা ভাবনার প্রশ্ন ৪-এ।

৯ · Haat-এর বর্ধিত রূপ: import নকশা করা

Haat v1-এর spec-এ module নেই: একটি program একটি ফাইল। লিখে দেখা যাক কী হয় (সত্যিকারের run, কোর্সের Haat reference বাস্তবায়নে):

~/haat $ cat imp.haat
import "pricing.haat";
print(price(2, 520));
~/haat $ python haat.py check imp.haat
1:7: error: expected ';' after expression
~/haat $ python haat.py check dot.haat        # print(pricing.price(2, 520));
1:14: error: unexpected character '.'

import Haat-এ keyword নয়, তাই parser একে একটি সাধারণ নাম ধরে expression statement ভেবেছে, তারপর ;-এর বদলে একটি string পেয়ে থেমেছে (error-এর অবস্থান আগের token-এর ঠিক পরে, reference-এর নকশা-সিদ্ধান্ত ২৪)। আর . Haat-এর কোনো token-ই নয়। এবার একটি import ব্যবস্থার নকশা করি। নিচের সবকিছু Haat-এর বর্ধিত রূপ: v1-এর অংশ নয়, reference বাস্তবায়নে নেই, এই কোর্সে একটি নকশা-অনুশীলন।

প্রথম চেষ্টা: C-র মতো লেখা জোড়া

সবচেয়ে সহজ নকশা C-র #include: import-এর জায়গায় অন্য ফাইলের লেখা হুবহু বসিয়ে দেওয়া। বাজারঘরের pricing.haat আর delivery.haat দুটিতেই একটি সহায়ক discount function আছে (অংশ ৫-এর C ফাইলের মতো)। তিনটি ফাইল জোড়া দিয়ে reference-এ চালালে (সত্যিকারের run):

~/haat $ cat pricing.haat delivery.haat main.haat > pasted.haat
~/haat $ python haat.py check pasted.haat
7:4: error: 'discount' is already declared in this scope

লাইন ৭ হলো delivery.haat-এর প্রথম লাইন: একই top-level scope-এ দ্বিতীয় discount (reference-এর নকশা-সিদ্ধান্ত ১৫)। লেখা জোড়া দিলে সব ফাইলের নাম একটি টেবিলে ঢালা হয়, আর সংঘাত অনিবার্য। একটি discount-এর নাম বদলে দিলে একই জোড়া program 996 ছাপে, কিন্তু প্রতিটি সংঘাত হাতে খুঁজে নাম বদলানোই সেই সমস্যা, যা module মেটাতে এসেছে।

দ্বিতীয় নকশা: প্রতিটি ফাইল একটি namespace

// pricing.haat
fn discount(p: Int) -> Int { return p / 10; }      // private
pub fn price(qty: Int, unit: Int) -> Int {
    let p = qty * unit;
    if p >= 1000 { return p - discount(p); }
    return p;
}
// main.haat
import "pricing.haat" as pricing;
import "delivery.haat" as delivery;
let p = pricing.price(2, 520);
print(p + delivery.cost(p));

নকশার সিদ্ধান্তগুলো, প্রতিটির পেছনে এই পর্বের একটি শিক্ষা:

  1. নতুন token আর keyword: import, as, pub keyword, আর . একটি নতুন token. Qualified name pricing.price parser-এ একটি নতুন AST node, ধরুন Qualified(module, name).
  2. প্রতিটি ফাইলের নিজের top-level টেবিল: দুটি discount আলাদা টেবিলে, তাই সংঘাত নেই (সংজ্ঞা ১৮.১)।
  3. Default private, pub দিয়ে প্রকাশ: অংশ ৭-এর নিরাপদ default. pricing.discount লিখলে resolver error দেবে।
  4. সব binding compile time-এ: Haat v1 যেমন global নামকে ঘর নম্বরে বাঁধে (পর্ব ১৪-এর LOAD_GLOBAL 1), তেমনি pricing.price-কে resolver (module নম্বর, global ঘর) জোড়ায় বাঁধবে; bytecode-এ ধরুন LOAD_MODGLOBAL m g-এর মতো একটি নতুন নির্দেশ। Python-এর মতো চলার সময় dict-এ খোঁজা নয়।
  5. Load order আর cycle: চালানোর আগে DFS দিয়ে topological order (অংশ ৮-এর কোড); প্রতিটি ফাইলের top-level কোড সেই ক্রমে একবার চলে। Cycle পেলে Go-র মতো static error, যেমন import cycle: orders -> pricing -> tax -> orders. কারণ: Haat-এর নিয়মে top-level variable ব্যবহারের আগে ঘোষিত হতে হয় (নকশা-সিদ্ধান্ত ১৬ আর ১৮), আর cycle থাকলে এই নিয়ম ফাইলের সীমানা পেরিয়ে নিশ্চিত করা যায় না।

অনুশীলন ১-এ এই resolver-এর মূল অংশটি নিজে লিখবেন। Name resolution-এর পুরো বাস্তবায়ন (symbol table, scope-এর stack) পর্ব ৫১-এ আসবে; এই নকশা সেখানে সহজেই যোগ করা যায়, কারণ পরিবর্তনটি মূলত “একটির বদলে কয়েকটি top-level টেবিল”।

আরও গভীরে: Module-কে সবচেয়ে গুরুত্ব দিয়ে নকশা করেছে ML পরিবার। Standard ML-এ একটি structure হলো module, একটি signature হলো তার interface-এর type, আর একটি functor হলো এমন “function” যা একটি module নিয়ে আরেকটি module বানায় (যেমন যেকোনো ক্রম-সম্পর্ক থেকে একটি sorted-set module). David MacQueen ১৯৮০-এর দশকের মাঝামাঝি এই ব্যবস্থা প্রস্তাব করেন, আর ১৯৯০ সালের Standard ML-এর আনুষ্ঠানিক সংজ্ঞায় এটি ভাষার অংশ। OCaml এই ধারা বয়ে চলেছে, আর গবেষণায় প্রশ্নটি এখনো খোলা: module কি নিজেও একটি সাধারণ মান হতে পারে (first-class module), আর পরস্পর-নির্ভর (recursive) module-এর type-নিয়ম কেমন হবে।

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

  • C-তে ফাইলের বাইরে static লিখলে কী হয়? Internal linkage: নামটি শুধু সেই translation unit-এ দেখা যায়, object file-এ LOCAL symbol.
  • Name mangling কেন লাগে? Linker শুধু সমতল নাম চেনে; overload আর namespace আলাদা রাখতে C++ নাম, namespace আর parameter-এর type symbol-এ লিখে দেয়।
  • Separate আর independent compilation-এর পার্থক্য? Separate-এ compiler অন্য অংশের interface দেখে type মেলায় (Java, Ada); independent-এ মেলায় না (C).
  • Python-এ একই module দুবার import করলে body কতবার চলে? একবার; দ্বিতীয়বার sys.modules cache থেকে একই object আসে।
  • Import cycle কীভাবে ধরবেন? Dependency graph-এ DFS; ধূসর (চলমান) module-এ আবার পৌঁছানো মানে back edge, অর্থাৎ cycle.

১০ · AI-এর যুগে module আর namespace

Module-এর প্রশ্নে AI assistant-এর উত্তর প্রায়ই এক ভাষার নিয়ম অন্য ভাষায় চাপায়: Python-এর import-এর বর্ণনা JavaScript-এ, বা Node-এর পুরোনো আচরণ আজকের ES module-এ। বারবার দেখা ভুলগুলো:

AI-এর ভুলকীভাবে ধরবেন
“Python-এ _name private, বাইরে থেকে পাওয়া যায় না”বাইরে থেকে module._name ডেকে চালানো
CommonJS আর ES module-এর import-কে একই রকম কপি বা একই রকম live বলারপ্তানিকারী পরে মান বদলায়, এমন দুই ফাইলের ছোট পরীক্ষা নিজে চালানো
Circular import-এর “সমাধান” হিসেবে import-কে function-এর ভেতরে সরানো, কারণ না বুঝে; বা এমন কোড যা ক্রম বদলালে ভাঙেঅর্ধেক তৈরি module-এর ধারণা দিয়ে প্রতিটি লাইনের ক্রম trace করা, আর দুই ক্রমেই চালানো
নিজে বানানো mangled নাম, বা একটি compiler-এর নিয়ম সব platform-এ চাপানো (Itanium বনাম MSVC)-S দিয়ে আসল symbol দেখা, link error-এর demangled বার্তা পড়া
C-র header-এ variable-এর সংজ্ঞা (int rate = 10;) রাখার পরামর্শদুটি .c ফাইলে include করে link করা; duplicate symbol আসে কি না দেখা
অস্তিত্বহীন compiler flag বা package manager-এর option বানানোTool-এর নিজের documentation আর --help-এ খোঁজা, তারপর চালানো

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

আমি প্রোগ্রামিং ভাষার module ব্যবস্থা শিখছি। Python 3.14, Node.js-এর CommonJS, JavaScript-এর ES module আর C17-এ নিচের প্রশ্নগুলোর উত্তর আলাদা করে দাও: ক) একই module দুবার import করলে তার top-level কোড কতবার চলে, খ) রপ্তানিকারী module পরে একটি variable বদলালে আমদানিকারী নতুন মান দেখে কি না, গ) দুটি module একে অপরকে import করলে কী ঘটে, ঘ) একটি নাম module-এর বাইরে লুকানোর উপায় কী আর কে তা প্রয়োগ করে। ১. প্রতিটি উত্তরের পাশে লেখো, এটি ভাষার specification-এর নিয়ম নাকি একটি নির্দিষ্ট tool বা runtime-এর আচরণ। ২. প্রতিটি দাবির জন্য দুই বা তিন ফাইলের একটি ছোট পরীক্ষা দাও, যা আমি নিজে চালাতে পারব। ৩. এক ভাষার নিয়ম অন্য ভাষায় চাপাবে না; যেখানে নিশ্চিত নও, স্পষ্ট বলো। ৪. কোনো আউটপুট অনুমান করে লিখবে না; কোনগুলো আমাকে চালিয়ে দেখতে হবে, আলাদা করে বলো।

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

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

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

প্র ০১Parnas কেন বললেন module ভাগ করা উচিত “কাজের ধাপ” ধরে নয়, “বদলাতে পারে এমন সিদ্ধান্ত” ধরে?

Parnas-এর ১৯৭২ সালের প্রবন্ধের KWIC program-টি ছোট: কিছু লাইন পড়া, প্রতিটি লাইনের শব্দগুলো ঘুরিয়ে সব সম্ভাব্য ক্রম বানানো, সেগুলো বর্ণানুক্রমে সাজানো, আর ছাপা। সে সময়ের স্বাভাবিক ভাগ ছিল flowchart-এর ধাপ ধরে: Input module, Circular Shift module, Alphabetize module, Output module. প্রতিটি ধাপ পরেরটিকে একটি বড় ভাগ করা data structure দেয়, যেমন মেমরিতে লাইনগুলো কীভাবে সাজানো।

Parnas দেখালেন, এই ভাগে একটি সাধারণ পরিবর্তন, ধরুন লাইনগুলো মেমরিতে রাখার ধরন বদলানো (সব একসঙ্গে, নাকি প্রয়োজনমতো পড়া), প্রায় সব module-কে ছোঁয়, কারণ সবাই সেই ভাগ করা ধরন জানে। দ্বিতীয় ভাগে তিনি প্রতিটি module-কে একটি “গোপন কথা” দিলেন: Line Storage module জানে লাইন কীভাবে রাখা, বাকিরা শুধু তার function ডাকে (যেমন “লাইন r-এর শব্দ w-এর অক্ষর c কী”)। তখন সেই রাখার ধরন বদলালে একটিমাত্র module বদলায়।

এই পর্বের ভাষায়, ভাগ করা data structure হলো external linkage-ওয়ালা একটি global, যা সবাই দেখে; Parnas-এর পরামর্শ হলো সেটিকে static করে শুধু function-গুলো প্রকাশ করা। অংশ ৫-এ discount-কে static রাখা ঠিক এই নীতি: delivery বিভাগ যদি কাল থেকে ছাড়ের নিয়ম বদলায়, pricing-এর কিছু যায় আসে না। আর অংশ ৯-এর Haat নকশায় default private রাখা একই নীতির ভাষাগত প্রয়োগ।

একটি বাস্তব দাম আছে, Parnas নিজেও তা স্বীকার করেছিলেন: লুকানো ভাগে প্রতিটি কাজে বেশি function call লাগে, তাই সরাসরি বাস্তবায়ন ধীর হতে পারে। আজকের compiler এই দামের বড় অংশ ফেরত দেয়: static function inline করে দেয় (অংশ ৫-এর -O1-এ symbol-টি মুছে যাওয়া মনে করুন), আর link-time optimization একাধিক ফাইলের সীমানা পেরিয়েও তা করতে পারে (পর্ব ৬৭)। অর্থাৎ নকশার পরিচ্ছন্নতা আর গতির দ্বন্দ্ব অনেকটাই compiler মিটিয়েছে।

মূল উপলব্ধি: module-এর সীমানা টানতে হয় ভবিষ্যতের পরিবর্তন ধরে, বর্তমানের কাজের ধাপ ধরে নয়; ভাষার static, pub বা export সেই সীমানাকে compiler-এর প্রয়োগযোগ্য নিয়মে পরিণত করে।

প্র ০২C-র header ব্যবস্থার দাম কী, আর C++20-এর module কী বদলাতে চায়?

C-র #include একটি লেখা-জোড়ার যন্ত্র, ভাষার module নয়। এর তিনটি পরিচিত দাম আছে। প্রথম, নিরাপত্তা: অংশ ৫-এ দেখেছেন, ঘোষণা আর সংজ্ঞা আলাদা ফাইলে থাকায় অমিল নীরবে link হয়ে যায়; একমাত্র রক্ষাকবচ প্রথা (নিজের header নিজে include করা)। দ্বিতীয়, header-এর ভেতরে লেখা macro সেই ফাইলের পরের সব কোডে ছড়িয়ে পড়ে; একটি header-এর #define max … অন্য লাইব্রেরির max নামের function ভেঙে দিতে পারে। macro কোনো namespace মানে না। তৃতীয়, গতি: প্রতিটি translation unit তার সব header নতুন করে পড়ে আর parse করে।

তৃতীয় দামটি C++-এ বিশাল। শুধু #include <iostream> আর একটি খালি main-এর ফাইল এই পর্বের Clang 22.1.8-এ (Zig-এর সঙ্গে আসা libc++ দিয়ে) -E-এর পরে প্রায় ৬৮,৭০০ লাইন হলো (সত্যিকারের run; অন্য compiler বা লাইব্রেরিতে সংখ্যা আলাদা), আর template-ভরা header বলে সেগুলো প্রতিটি .cpp ফাইলে আবার পুরো parse হয়। শত শত ফাইলের project-এ একই header হাজারবার পড়া হয়। Precompiled header আর “unity build”-এর মতো কৌশল এই দাম কমানোর জোড়াতালি।

C++20-এর module এই সমস্যার মূলে যায়। export module bazar.pricing; দিয়ে লেখা একটি module একবার compile হয়ে একটি binary interface ফাইল তৈরি করে; import bazar.pricing; সেই ফাইল পড়ে, লেখা নয়। Macro module-এর বাইরে যায় না, আর শুধু export করা নাম দেখা যায় (অংশ ৭-এর টেবিল)। অর্থাৎ C++ এতদিনে “separate compilation”-এর কঠোর অর্থের কাছে আসছে, যেখানে compiler interface-এর তথ্য পায়।

তবে বাস্তবায়ন সহজ হয়নি। Module-এর interface আগে compile না হলে তার ব্যবহারকারী compile করা যায় না, তাই build system-কে আগে থেকে dependency graph জানতে হয় (অংশ ৮-এর topological order); আগে প্রতিটি .cpp সম্পূর্ণ স্বাধীনভাবে, সমান্তরালে compile করা যেত। Compiler আর build tool-গুলোর সমর্থন কয়েক বছর ধরে ধীরে পরিণত হচ্ছে, আর অনেক বড় project এখনো header-এই আছে। পুরোনো আর নতুন ব্যবস্থা একসঙ্গে চালানোর (header unit) নিয়মও জটিল।

মূল উপলব্ধি: লেখা জোড়া দেওয়া সবচেয়ে সরল module-ব্যবস্থা, কিন্তু এর দাম নিরাপত্তা, macro-দূষণ আর compile-এর সময়ে দিতে হয়; সত্যিকারের module সেই দাম কমায়, বিনিময়ে build-কে dependency-র ক্রম মানতে বাধ্য করে।

প্র ০৩ES module-এর import কেন ব্যাকরণে স্থির রাখা হলো, যেখানে CommonJS-এর require একটি সাধারণ function?

CommonJS-এর require চলার সময়ের একটি function call: তাকে if-এর ভেতরে ডাকা যায়, string জোড়া দিয়ে নাম বানানো যায় (require("./lang/" + code)), আর ফল একটি সাধারণ object. এটি নমনীয়, আর সার্ভারে ফাইল পড়া দ্রুত বলে synchronous লোডিং সমস্যা ছিল না। কিন্তু এর একটি গভীর অসুবিধা: program না চালিয়ে বলা যায় না কোন module কোনটির ওপর নির্ভর করে। পর্ব ১৪-এর ভাষায়, dependency-র binding হয় run time-এ।

ES module (ECMAScript 2015) উল্টো সিদ্ধান্ত নেয়: import আর export statement শুধু module-এর top level-এ, আর উৎস একটি string literal. ফলে dependency-র binding compile time-এ সরে আসে। এর তিনটি বড় লাভ। প্রথম, browser-এ প্রতিটি ফাইল network থেকে আনতে হয়; আগে থেকে গ্রাফ জানলে সব ফাইল সমান্তরালে আনা যায়, তারপর চালানো (অংশ ৮-এর topological order-এর ভাবনা)। দ্বিতীয়, bundler কোন export কেউ ব্যবহার করে না তা নিশ্চিত জেনে বাদ দিতে পারে (tree shaking). তৃতীয়, live binding সম্ভব হয়, কারণ import করা নামটি linker-এর মতো রপ্তানিকারীর আসল binding-এর সঙ্গে আগে থেকেই জোড়া।

নমনীয়তা পুরো হারায়নি: import("./x.js") (dynamic import) একটি Promise ফেরত দেয় আর চলার সময় যেকোনো জায়গায় ডাকা যায়, কিন্তু সেটি আলাদা, স্পষ্ট চিহ্নিত একটি পথ। ES module-এর top-level await-ও (ECMAScript 2022) এই গ্রাফ-জানা নকশার ওপর দাঁড়িয়ে।

রূপান্তরের দামও বড় ছিল। Node.js-এ বহু বছর ধরে CommonJS-এর বিশাল package-সমাজ ছিল, তাই দুই ব্যবস্থা একসঙ্গে চালানোর নিয়ম (.mjs/.cjs, package.json-এর "type" ক্ষেত্র, ES module থেকে CommonJS import করা) জটিল হয়েছে; খুঁটিনাটি Node-এর version-ভেদে বদলেছে, তাই নির্দিষ্ট version-এর documentation দেখে নেওয়াই নিরাপদ। এটি পর্ব ০৬-এর backward compatibility-র আপসের একটি স্পষ্ট উদাহরণ।

মূল উপলব্ধি: dependency-কে ব্যাকরণে স্থির করা মানে তার binding time-কে run থেকে compile-এ সরানো; এতে নমনীয়তা কমে, কিন্তু tool আর runtime চালানোর আগেই পুরো গ্রাফ নিয়ে কাজ করতে পারে।

প্র ০৪Import cycle-কে ভাষার নিয়মে নিষেধ করা ভালো, নাকি অনুমতি দেওয়া?

Go নিষেধ করেছে: compiler package-গুলোর import graph-এ cycle পেলে import cycle not allowed error দেয়, program তৈরিই হয় না। OCaml-ও সাধারণভাবে ফাইল-স্তরের module-এ পরস্পর-নির্ভরতা মানে না; compile করার ক্রম dependency মেনে হতে হয়। Java 9-এর module system-এও module-গুলোর requires সম্পর্কে cycle নিষেধ। এর লাভ: load order সবসময় সুনির্দিষ্ট (একটি topological order আছেই), প্রতিটি module-এর initialization তার সব dependency তৈরি হওয়ার পরে চলে, আর build system সহজেই বলতে পারে কোনটি আগে compile হবে।

Python আর JavaScript অনুমতি দেয়। লাভ নমনীয়তা: দুটি module যেগুলোর একে অপরের function দরকার, সেগুলো সহজে লেখা যায়, যতক্ষণ top-level কোড অন্যটির নাম খুব তাড়াতাড়ি না চায়। দাম আপনি অংশ ৮-এ দেখেছেন: আচরণ নির্ভর করে কোন module আগে import হলো তার ওপর। একই কোড একটি প্রবেশপথ দিয়ে চললে কাজ করে, অন্যটি দিয়ে চললে partially initialized module error দেয়। এই ধরনের bug খুঁজে পাওয়া কঠিন, কারণ এটি কোনো একটি ফাইলের ভুল নয়, পুরো গ্রাফের।

Java-র class-স্তরে আবার cycle সাধারণ ঘটনা: Order class Customer-কে চেনে আর Customer তার Order-দের চেনে। Java এটি সামলায় কারণ class lazily লোড হয়, প্রথম ব্যবহারের সময়, আর compiler একসঙ্গে একাধিক ফাইল দেখে type মেলাতে পারে। তবু static initializer-এর মধ্যে cycle থাকলে একটি class অন্যটির static field-কে তখনো default মান (০ বা null) অবস্থায় দেখতে পারে: Python-এর অর্ধেক তৈরি module-এর জাভা-সংস্করণ।

নকশাকারের প্রশ্নটি তাই: cycle কি নকশার একটি দুর্বলতার লক্ষণ, নাকি স্বাভাবিক? Software engineering-এর দিক থেকে প্রায়ই বলা হয়, module-এর স্তরে cycle মানে দুটি module আসলে একটি, বা তাদের ভাগ করা অংশটি তৃতীয় module-এ যাওয়া উচিত (Acyclic Dependencies Principle নামে পরিচিত)। Haat-এর নকশায় আমরা Go-র পথ নিয়েছি, কারণ Haat-এর use-before-declaration নিয়ম (নকশা-সিদ্ধান্ত ১৬, ১৮) cycle থাকলে ফাইলের সীমানা পেরিয়ে নিশ্চিত করা যায় না।

মূল উপলব্ধি: cycle নিষেধ করলে initialization-এর ক্রম সুনির্দিষ্ট আর error স্পষ্ট হয়; অনুমতি দিলে নমনীয়তা বাড়ে, কিন্তু আচরণ import-এর ক্রমের ওপর নির্ভর করে, যা একটি গোপন, গ্রাফ-জোড়া নির্ভরতা।

প্র ০৫Name mangling-এর নিয়ম বদলালে কেন পুরো ecosystem কাঁপে? ABI-র স্থিতিশীলতা কেন এত দামি?

অংশ ৬-এ দেখেছেন, C++-এ একটি function-এর পরিচয় তার mangled নাম। একটি compile করা লাইব্রেরি (.so বা .dll) আর তার ব্যবহারকারী program সাধারণত আলাদা সময়ে, কখনো আলাদা compiler-এ তৈরি হয়। দুজনকে মেলাতে হলে তিনটি জিনিস হুবহু মিলতে হবে: symbol-এর নাম (mangling), argument কোথায় যাবে (calling convention), আর object-এর মেমরি-বিন্যাস। এই তিনের চুক্তিই ABI (পর্ব ৭১)। Source code এক থাকলেও এর যেকোনোটি বদলালে পুরোনো binary নতুন লাইব্রেরির সঙ্গে আর মেলে না।

একটি বাস্তব উদাহরণ: C++11 standard std::string-এর কিছু নিয়ম কড়া করেছিল, যা GCC-র লাইব্রেরির পুরোনো বাস্তবায়নের (copy-on-write) সঙ্গে মেলে না। GCC 5 (২০১৫) নতুন বাস্তবায়ন আনে, কিন্তু পুরোনো binary ভাঙা এড়াতে দুটিকেই রাখে: নতুনটি থাকে std::__cxx11 নামের একটি inline namespace-এ, আর যেহেতু namespace mangled নামের অংশ, নতুন আর পুরোনো string নেওয়া function-এর symbol আলাদা হয়ে যায়। ফলে দুই ধরনের কোড একসঙ্গে link করলে বিভ্রান্তিকর undefined symbol error দেখা দিতে পারত, আর অনেক distribution-কে পুরো package-সংগ্রহ নতুন করে build করতে হয়েছিল। এখানে namespace আর mangling ইচ্ছে করে ABI-র সংস্করণ চিহ্নিত করার যন্ত্র হিসেবে ব্যবহৃত হয়েছে।

এই কারণেই অনেক লাইব্রেরি বাইরের দুনিয়ার জন্য C ABI দেয় (extern "C", অংশ ৬-এর c_cost): C-র নাম mangled নয়, আর platform-এর C ABI দশকের পর দশক স্থির। Python-এর extension, Rust-এর FFI, বা অন্য যেকোনো ভাষা থেকে ডাকতে হলে এই সমতল নামই ভরসা। Rust নিজের ABI ইচ্ছে করে স্থির রাখেনি, যাতে compiler struct-এর বিন্যাস আর mangling নিজের মতো উন্নত করতে পারে; বাইরের জন্য extern "C" আর #[repr(C)].

Windows-এ MSVC-র mangling আর ABI Itanium নিয়ম থেকে পুরো আলাদা, তাই সাধারণভাবে MSVC আর GCC-তে তৈরি C++ object একসঙ্গে link হয় না। এই পর্বের Clang run-এ --target=x86_64-linux-gnu দেওয়া হয়েছিল বলেই Itanium নাম এসেছে; অন্য target-এ নাম অন্যরকম হতে পারে।

মূল উপলব্ধি: mangled নাম একটি function-এর binary পরিচয়, তাই এর নিয়ম ABI-র অংশ; ABI বদলানো মানে পুরোনো সব binary-র সঙ্গে চুক্তি ভাঙা, আর সেজন্য ভাষাগুলো স্থির, সরল C ABI-কে সাধারণ মিলনস্থল হিসেবে রাখে।

অনুশীলন

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

  1. বাস্তবায়ন — Haat-এর module resolver (বর্ধিত রূপ): প্রতিটি Haat ফাইলকে একটি dict হিসেবে ধরুন: সে কোন module import করে (imports), কোন নাম pub (pub), আর কোন qualified name ব্যবহার করে (uses, যেমন "pricing.price"). একটি Python function check(mods, root) লিখুন, যা DFS দিয়ে load order দেবে আর তিন ধরনের error খুঁজবে: import cycle, যে module import করা হয়নি তার নাম ব্যবহার, আর private নাম ব্যবহার। নিচের ইনপুটে চালান:
    mods = {
      "main":     {"imports": ["orders"], "pub": [],
                   "uses": ["orders.total", "pricing.price"]},
      "orders":   {"imports": ["pricing", "delivery"], "pub": ["total"],
                   "uses": ["pricing.price", "delivery.cost", "pricing.cut"]},
      "pricing":  {"imports": [], "pub": ["price"], "uses": []},
      "delivery": {"imports": [], "pub": ["cost"], "uses": []},
    }
    def check(mods, root):
        color, order, errors = {m: "white" for m in mods}, [], []
        def visit(m, path):
            color[m] = "grey"
            for d in mods[m]["imports"]:
                if d not in mods: errors.append(f"{m}: cannot find module '{d}'")
                elif color[d] == "grey":
                    stack = path + [m]
                    cyc = stack[stack.index(d):] + [d]
                    errors.append("import cycle: " + " -> ".join(cyc))
                elif color[d] == "white": visit(d, path + [m])
            for q in mods[m]["uses"]:                 # qualified name m.f
                mod, name = q.split(".")
                if mod not in mods[m]["imports"]:
                    errors.append(f"{m}: '{mod}' is not imported here")
                elif name not in mods[mod]["pub"]:
                    errors.append(f"{m}: '{name}' is not public in '{mod}'")
            color[m] = "black"; order.append(m)
        visit(root, [])
        return order, errors
    order, errors = check(mods, "main")
    print("load order:", order)
    for e in errors: print("error:", e)

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

    load order: ['pricing', 'delivery', 'orders', 'main']
    error: orders: 'cut' is not public in 'pricing'
    error: main: 'pricing' is not imported here

    দ্বিতীয় error-টি গুরুত্বপূর্ণ: main পরোক্ষভাবে (orders-এর মাধ্যমে) pricing-এর ওপর নির্ভর করে, কিন্তু নিজে import করেনি, তাই pricing.price তার namespace-এ নেই। এটি Java আর Rust-এর মতো নিয়ম: যে নাম ব্যবহার করবেন, তার module নিজে import করুন। (Python-এ আবার import shop.pricing-এর পরে shop package object-এ pricing attribute বসে যায়, তাই নিয়ম আলাদা।) pricing-এর imports-এ "orders" যোগ করে আবার চালালে প্রথম লাইনে আসে error: import cycle: orders -> pricing -> orders (সত্যিকারের run). পূর্ণ resolver-এ uses আসবে AST-এর Qualified node থেকে, আর প্রতিটি সঠিক ব্যবহার একটি (module, global ঘর) জোড়ায় বাঁধা হবে।

  2. ভুল খুঁজুন — header-এ variable: একজন প্রোগ্রামার ছাড়ের হার সব ফাইলে ভাগ করতে চেয়ে এই তিনটি ফাইল লিখেছেন। zig cc main.c pricing.c (Linux target) কী বলবে, কেন, আর সঠিক রূপ কী?
    /* config.h */
    int rate = 10;
    int discount(int p);
    
    /* pricing.c */
    #include "config.h"
    int discount(int p) { return p * rate / 100; }
    
    /* main.c */
    #include <stdio.h>
    #include "config.h"
    int main(void) { printf("%d", 1040 - discount(1040)); putchar(10); return 0; }

    আসল ফল (Clang 22.1.8, lld; পথ ছোট করা):

    ld.lld: error: duplicate symbol: rate
    >>> defined at config.h:2 (./config.h:2)
    >>>            …/main.o:(rate)
    >>> defined at config.h:2 (./config.h:2)
    >>>            …/pricing.o:(.data+0x0)

    #include লেখা হুবহু জোড়ে, তাই দুটি translation unit-এই int rate = 10;, অর্থাৎ দুটি সংজ্ঞা, দুটিই external linkage-এর। Linker একটি নামের দুটি সংজ্ঞা মেনে নেয় না। সমাধান: header-এ শুধু ঘোষণা extern int rate;, আর ঠিক একটি .c ফাইলে (এখানে pricing.c) সংজ্ঞা int rate = 10;. এভাবে বদলে চালালে program 936 ছাপে (সত্যিকারের run). নিয়মটি মনে রাখার উপায়: header-এ যা থাকে, তা প্রতিটি ফাইলে কপি হয়, তাই header-এ শুধু এমন জিনিস রাখুন যা বহুবার থাকলেও ক্ষতি নেই (ঘোষণা, type, macro).

  3. আউটপুট অনুমান করুন: একই ফোল্ডারে দুটি ফাইল। python m.py কী ছাপবে, আর কেন?
    # counter.py
    print("loading counter")
    count = 0
    def inc():
        global count
        count += 1
    
    # m.py
    import counter
    import counter
    from counter import count
    counter.inc(); counter.inc()
    print(count, counter.count)

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

    loading counter
    0 2
    1. প্রথম import counter: cache-এ নেই, তাই body চলে, “loading counter” ছাপা হয়, count = 0.
    2. দ্বিতীয় import counter: sys.modules-এ আছে, body আর চলে না, কিছু ছাপা হয় না।
    3. from counter import count: m-এর namespace-এ count নামটি সেই মুহূর্তের object-এ, অর্থাৎ int 0-তে বাঁধা।
    4. inc দুবার: global count মানে counter module-এর dict-এর count; সেটি দুবার rebind হয়ে 2. m-এর count এখনো পুরোনো 0-তে বাঁধা।

    এটি Python-এর from … import আর ES module-এর live binding-এর পার্থক্যের ঠিক কেন্দ্রবিন্দু: Python-এ এটি একটি সাধারণ নতুন binding (CommonJS-এর কপির মতো), JavaScript-এর ES module-এ একই ধাঁচের কোড 2 দেখাত।

  4. Trace — mangle আর demangle: Itanium C++ ABI-এর নিয়মে (ক) bazar::tax::vat(int)-এর mangled নাম লিখুন। (খ) _ZN5bazar7billing5totalEiib কোন function-এর symbol? (গ) একই নামের bazar::tax::vat(long) যোগ করলে দুটির symbol কি আলাদা হবে?

    (ক) _Z + N + 5bazar + 3tax + 3vat + E + i = _ZN5bazar3tax3vatEi.

    (খ) N … E-এর ভেতরে 5bazar, 7billing, 5total, তারপর parameter i, i, b: bazar::billing::total(int, int, bool).

    যাচাই (সত্যিকারের run, Clang 22.1.8, -S --target=x86_64-linux-gnu), এই দুটি function-এর সংজ্ঞা লিখে:

    	.globl	_ZN5bazar3tax3vatEi
    	.globl	_ZN5bazar7billing5totalEiib

    (গ) হ্যাঁ। long-এর কোড l, তাই নতুনটি _ZN5bazar3tax3vatEl; দুটি আলাদা symbol, linker-এর কোনো সমস্যা নেই। কিন্তু যদি শুধু ফেরতের type আলাদা হতো (long vat(int) বনাম int vat(int)), তাহলে C++ সেটি overload হিসেবে মানেই না, compile error; আর mangled নামেও সাধারণ function-এর ফেরতের type থাকে না।

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

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

ক্রমPython-এ একটি module প্রথমবার import pricing করার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. sys.modules-এ "pricing" আছে কি না দেখা
  2. finder দিয়ে sys.path-এর ফোল্ডারে pricing.py খোঁজা
  3. খালি module object বানিয়ে sys.modules-এ রাখা
  4. module-এর body চালানো, তার dict-এ নাম তৈরি
  5. import করা ফাইলের namespace-এ pricing নামটি বাঁধা

C17-এ একটি ফাইলের top level-এ static int discount(int p) { … } লেখা আছে। এর প্রভাব কী?

  • Function-টি program শুরু থেকে শেষ পর্যন্ত মেমরিতে থাকে, অন্য function-এর মতো নয়
  • নামটি শুধু এই translation unit-এ দেখা যায় (internal linkage)
  • Compiler একে সবসময় inline করবে, তাই কোনো symbol থাকবে না
  • নামটি সব ফাইল থেকে দেখা যায় (external linkage)

Python 3-এ a.py আর b.py দুটিই import config করে, আর main.py প্রথমে import a, তারপর import b করে। config.py-এর top-level কোড কতবার চলবে?

  • একবার
  • দুবার, প্রতিটি import-এর জন্য একবার
  • একবারও না, import শুধু নাম বাঁধে
  • অনির্দিষ্ট, OS-এর ওপর নির্ভর করে

Itanium C++ ABI (Linux-এ GCC/Clang)-এর symbol _ZN5bazar8delivery4costEib কোন function-কে বোঝায়?

  • int bazar::delivery::cost(), যা bool ফেরত দেয়
  • bazar::cost(delivery, bool)
  • bazar::delivery::cost(int, bool)
  • একটি C function, যার নাম আক্ষরিক অর্থে এটিই

delivery.c-তে int delivery(int t), কিন্তু main.c-তে ভুল ঘোষণা double delivery(double t);. একই দুটি ফাইল C আর C++ হিসেবে আলাদাভাবে compile-link করলে কী হয়?

  • দুই ভাষাতেই compile-এর সময় type error
  • দুই ভাষাতেই link সফল
  • C-তে link error, C++-এ link সফল
  • C-তে link সফল (কিন্তু চালানো undefined behavior), C++-এ undefined symbol link error

Module-এর dependency graph-এ সাদা/ধূসর/কালো রং দিয়ে DFS চালানোর সময় একটি ধূসর module-এ আবার পৌঁছানো মানে কী?

  • Module-টি আগেই লোড হয়ে গেছে, এড়িয়ে যাওয়া যায়
  • একটি import cycle পাওয়া গেছে
  • Module-টি খুঁজে পাওয়া যায়নি
  • Module-টি load order-এ যোগ করার সময় হয়েছে

JavaScript-এ const pricing = (function () { const RATE = 10; function cut(p) { return p * RATE / 100; } return { price(p) { return p - cut(p); } }; })(); এর পরে typeof pricing.cut কী দেবে?

  • "function"
  • ReferenceError
  • "undefined"
  • "object"

শব্দকোষ

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

মনে রাখুন

  1. Module তিনটি কাজ করে: namespace দিয়ে নামের সংঘাত থামায়, visibility দিয়ে ভেতরটা লুকায় (information hiding), আর আলাদা করে অনুবাদ সম্ভব করে।
  2. Qualified name a::b::c: প্রথম অংশ চারপাশের scope-এ, পরের প্রতিটি অংশ শুধু আগের অংশের ভেতরে খোঁজা হয়।
  3. Python-এর import: sys.modules cache → finder → খালি module cache-এ → body চলে → নাম বাঁধা। Body একবারই চলে; cache-এ আগে রাখা হয় বলে cycle-এ অর্ধেক তৈরি module দেখা যায়।
  4. C-তে module নেই: translation unit, header-এর লেখা জোড়া, আর linkage (static = internal). Linker শুধু নাম মেলায়, type নয় (independent compilation); C++ name mangling নামে namespace আর parameter-এর type লিখে দেয়।
  5. Dependency graph-এ DFS: কালো হওয়ার ক্রমই load order, ধূসরে ফেরা মানে import cycle. Haat-এর বর্ধিত নকশায়: প্রতিটি ফাইল একটি namespace, default private, cycle হলে static error.

পরের পর্বে: একটি function-এর argument কখন হিসাব হয়, ডাকার আগে নাকি প্রয়োজনের মুহূর্তে? পর্ব ১৯-এ evaluation strategy: call-by-value, call-by-name আর call-by-need, thunk দিয়ে নিজে বানিয়ে, আর Haat-এর &&-এর ভেতরে লুকানো আলস্য।

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

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