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

একাধিক paradigm — কোন কাজে কোন ধরন বেছে নেবেন

Multi-Paradigm Programming — Mixing Styles, Measuring Them and Choosing the Right One for the Problem

Taught in Bangla, this lesson shows that most major languages mix paradigms. The same Dhaka order total is written in imperative, object-oriented and functional styles in Python and JavaScript and as a SQL query run in the page, all giving 2126, and a small Python ast pass counts mutation points in each. A decision path matches styles to tasks, a loop is refactored into a pipeline with each step checked by a differential test, and it covers mixing traps such as loop closures and a lost this.

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

  • Multi-paradigm ভাষার সংজ্ঞা দেওয়া, আর বাস্তব ভাষাগুলো কোন কোন ধাঁচ কতটা সমর্থন করে তা version ধরে বলা
  • একই কাজ imperative, object-oriented, functional আর SQL-এ লিখে সত্যিকারের run-এ উত্তর মেলানো
  • Python-এর ast দিয়ে একটি ছোট analysis pass লিখে mutation point গোনা, আর এমন মাপের সীমা বোঝা
  • সমস্যার ধরন দেখে ধাঁচ বেছে নেওয়া, আর loop থেকে pipeline-এ refactoring প্রমাণ ও differential test দিয়ে নিরাপদে করা
  • Haat-এর paradigm চেনা, আর ধাঁচ মেশানোর পরিচিত ফাঁদ (loop-এ closure, method থেকে this হারানো) ধরে ফেলা

১ · এক ভাষা, অনেক ধাঁচ — multi-paradigm মানে কী

বাজারঘরের রান্নাঘরে একজন বাবুর্চি একই দুপুরে তিন রকম কাজ করেন। ভাত রাঁধেন ধাপে ধাপে: চাল ধোয়া, পানি মাপা, চুলা জ্বালানো, ঢাকনা দেওয়া। মশলার জন্য তাঁর একটি নির্দিষ্ট ব্লেন্ডার আছে, যার নিজের সেটিং আর বোতাম। আর সালাদের জন্য একটি তালিকা মানেন: “যত শসা আছে, সব ধুয়ে, কেটে, লবণ দিয়ে মেশাও।” কেউ তাঁকে বলে না “আপনি শুধু ধাপে ধাপে রাঁধবেন”। কাজ যেমন, পদ্ধতি তেমন।

প্রোগ্রামিংয়েও তাই। এই মডিউলের আগের পর্বগুলোতে একেকটি programming paradigm আলাদা করে দেখেছেন, প্রতিবার একই বাজারঘরের কাজ দিয়ে। এক লাইনে মনে করিয়ে দিই:

পর্বধাঁচমূল প্রশ্নহিসাবের একক
০৭Imperative/proceduralকোন ক্রমে কোন অবস্থা বদলাব?assignment আর loop
০৮Object-orientedকোন জিনিস কোন দায়িত্ব নেবে?object আর method
০৯Functionalকোন মান থেকে কোন মান?pure function
১০Logicকোন তথ্য আর নিয়ম সত্য?fact, rule, query
১১Concurrentকোন কাজ একসঙ্গে চলবে, কীভাবে কথা বলবে?thread, actor, channel
১২Scripting/dynamicচলার সময় কতটা নমনীয় হব?dynamic type, reflection

প্রতিটি ধাঁচের ভেতরের প্রক্রিয়া নিজ নিজ পর্বে আছে; এই পর্বে প্রশ্ন একটাই: এতগুলো ধাঁচ যখন একই ভাষায় পাওয়া যায়, কখন কোনটি নেবেন, আর মেশালে কী সাবধানতা লাগে।

সংজ্ঞা ১৩.১ — multi-paradigm ভাষা

একটি ভাষা multi-paradigm, যদি সেটি একাধিক paradigm-এর মূল প্রক্রিয়া (mechanism) ভাষার স্তরেই দেয়, যাতে একই program-এ সেগুলো স্বাভাবিকভাবে মেশানো যায়। যেমন বদলানো যায় এমন variable আর loop (imperative), class বা prototype আর dynamic dispatch (object-oriented), first-class function আর closure (functional). একটি paradigm “অনুকরণ করা যায়” বললে যথেষ্ট নয়: C-তে struct আর function pointer দিয়ে object বানানো যায়, কিন্তু ভাষা নিজে class বা closure দেয় না, তাই C-কে সাধারণত procedural ভাষাই বলা হয়।

সংজ্ঞাটি একটি মাত্রার কথা বলে, হ্যাঁ-না নয়। Haskell-এ সব হিসাব pure, তবু IO type দিয়ে ধাপে ধাপে লেখা যায়; Java-য় সব কোড class-এর ভেতরে, তবু Java 8 (২০১৪) থেকে lambda আর stream আছে। তাই প্রশ্নটি “এটি কি multi-paradigm?” নয়, বরং “কোন ধাঁচ এখানে সস্তা আর স্বাভাবিক, কোনটি দামি আর অস্বস্তিকর?” এই চিন্তাটি পর্ব ০৬-এর নকশা-আপসের সঙ্গে সরাসরি যুক্ত: একই কাজ অনেকভাবে লেখা গেলে writability বাড়ে, কিন্তু অন্যের কোড পড়া কঠিন হতে পারে।

একটি paradigm-কে যন্ত্রপাতির বাক্স ভাবুন, ভাষাকে মিস্ত্রির কর্মশালা। পুরোনো দিনের কর্মশালায় হয়তো একটিই বাক্স ছিল: শুধু করাত আর হাতুড়ি (FORTRAN-এর imperative জগৎ)। আজকের কর্মশালায় চারটি বাক্স পাশাপাশি। ভালো মিস্ত্রি সব বাক্স খোলেন না; কাজ দেখে ঠিক বাক্সটি খোলেন, আর এক কাজের মাঝপথে বাক্স বদলালে আগের যন্ত্র গুছিয়ে রাখেন।

২ · বাস্তব ভাষাগুলো কী কী মেশায়

নিচের ছবিটি মোটা দাগের একটি মানচিত্র। ভরাট বিন্দু মানে ধাঁচটি ভাষার প্রধান বা খুব স্বাভাবিক পথ; ফাঁপা বৃত্ত মানে ভাষা সেটি দেয়, কিন্তু সেটি ভাষার কেন্দ্রে নয় বা কিছু সীমাবদ্ধতা আছে। এটি লেখকের মূল্যায়ন, কোনো মানদণ্ডের তালিকা নয়; তার নিচের টেবিলে প্রতিটি দাবির পেছনের নির্দিষ্ট বৈশিষ্ট্য আর version দেওয়া আছে।

ছবি ১৩.১ — কোন ভাষা কোন ধাঁচ দেয়

● প্রধান বা খুব স্বাভাবিক · ○ আছে, তবে কেন্দ্রে নয় · ফাঁকা = ভাষা নিজে দেয় না

Paradigm map: which languages offer imperative, object-oriented, functional and declarative styles ImpOOFnDecl CC++JavaPythonJavaScriptRustScalaKotlinHaskellSQL, PrologHaat v1 Decl = declarative (SQL, logic) Haat v1-এ class নেই
ছবি ১৩.১ — বেশির ভাগ মূলধারার ভাষা অন্তত দুটি কলামে বিন্দু পায়; একটি কলামে থাকা ভাষা (C, Haskell, SQL, Prolog) নিজের ধাঁচে বিশেষ গভীর। Haat v1 ইচ্ছা করেই ছোট: imperative কেন্দ্র, সঙ্গে first-class function আর closure.
ভাষা (version)কোন প্রক্রিয়া কোন ধাঁচ দেয়
C (C17)loop, assignment, function; function pointer আছে, কিন্তু closure বা class নেই
C++ (C++20)procedural, class আর virtual function, template দিয়ে generic programming, C++11 থেকে lambda; Bjarne Stroustrup নিজেই একে multi-paradigm ভাষা বলেন
Java (Java 21)class-কেন্দ্রিক; Java 8 (২০১৪) থেকে lambda আর stream, Java 16 থেকে record, Java 21-এ switch-এ pattern matching
Python (3.14)loop আর বদলানো যায় এমন list, class আর multiple inheritance, lambda, comprehension আর functools; Python 3.5 (২০১৫) থেকে async/await
JavaScript (ECMAScript 2025)prototype-ভিত্তিক object (ES2015-এর class তার ওপরের লেখা), first-class function আর closure শুরু থেকেই, ES2017 থেকে async/await
Rust (1.x stable)বদলানো যায় এমন variable (mut) আর loop; closure, iterator, enum আর pattern matching; class inheritance নেই, তার বদলে trait
Scala (Scala 3)প্রতিটি মান একটি object আর প্রতিটি function-ও একটি object; OO আর functional-কে এক কাঠামোতে মেলানোর লক্ষ্যে Martin Odersky-র নকশা (প্রথম প্রকাশ ২০০৪ সালের দিকে)
Kotlinclass আর interface, lambda, data class আর extension function; Kotlin 1.0 ২০১৬ সালে

দুটি সূক্ষ্ম কথা। প্রথমত, “functional সমর্থন” মানে সব ভাষায় একই জিনিস নয়: Python-এ lambda-র দেহ একটি expression মাত্র, আর CPython tail call optimize করে না (পর্ব ০৯-এ ৩০০০ উপাদানের foldr-এ RecursionError দেখেছেন); Scala বা Haskell-এ এই সীমা নেই। দ্বিতীয়ত, ধাঁচের তালিকায় concurrency-র মডেলও যোগ হয়: Go-র channel, Erlang-এর actor, Python ও JavaScript-এর async/await. এগুলো পর্ব ১১-এর বিষয়।

৩ · একই কাজ তিন ধাঁচে — Python আর JavaScript-এ সত্যিকারের run

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

এবার তিনটি সংস্করণ এক ফাইলে, ব্রাউজারের Python-এ (Pyodide). প্রতিটি সংস্করণ নিজের ধাঁচের “স্বাভাবিক” রূপে লেখা, কৃত্রিমভাবে ছোট বা বড় করা নয়:

from functools import reduce
ORDERS = [("Dhaka", [(2, 520)]), ("Rajshahi", [(3, 120), (1, 180)]),
          ("Dhaka", [(4, 150), (2, 250)]), ("Dhaka", [(5, 40)])]

def total_imperative(orders, wanted):        # 1) state + commands
    s = 0
    for district, lines in orders:
        if district == wanted:
            t = 0
            for qty, unit in lines:
                t = t + qty * unit
            if t >= 1000:
                t = t - t // 10
            s = s + t
    return s

class Order:                                 # 2) objects own data + behaviour
    def __init__(self, district, lines):
        self.district, self.lines = district, lines
    def total(self):
        t = sum(q * u for q, u in self.lines)
        return t - t // 10 if t >= 1000 else t
class Shop:
    def __init__(self, orders): self.orders = [Order(d, ls) for d, ls in orders]
    def total_for(self, wanted):
        return sum(o.total() for o in self.orders if o.district == wanted)

def discounted(t): return t - t // 10 if t >= 1000 else t   # 3) pure functions
def order_total(o): return discounted(sum(q * u for q, u in o[1]))
def total_functional(orders, wanted):
    kept = filter(lambda o: o[0] == wanted, orders)
    return reduce(lambda acc, t: acc + t, map(order_total, kept), 0)

for d in ("Dhaka", "Rajshahi", "Sylhet"):
    print(f"{d:8}", total_imperative(ORDERS, d), Shop(ORDERS).total_for(d), total_functional(ORDERS, d))

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

Dhaka    2126 2126 2126
Rajshahi 540 540 540
Sylhet   0 0 0

তিন ধাঁচ, প্রতিটি জেলায় একই উত্তর: ঢাকা 2126, রাজশাহী 540, আর যে জেলার অর্ডার নেই (সিলেট) সেখানে 0. শেষ লাইনটি জরুরি একটি প্রান্তের পরীক্ষা: reduce-এ শুরুর মান 0 না দিলে ফাঁকা তালিকায় TypeError আসত। তিনটি কোড একই অঙ্ক করে, কিন্তু “অবস্থা” রাখে তিন জায়গায়: imperative সংস্করণ রাখে s আর t নামের দুটি বদলানো variable-এ, object সংস্করণ রাখে প্রতিটি Order-এর field-এ (যা তৈরির পর আর বদলায় না), আর functional সংস্করণ কোথাও রাখে না, প্রতিটি ধাপ নতুন মান দেয়।

একটি অবাক করা মিল আছে: Python-এর filter আর map lazy iterator ফেরত দেয়, আর sum(... for ...)-ও একটি generator. তাই তিনটি সংস্করণই আসলে অর্ডারগুলো একই ক্রমে, একটি একটি করে ছোঁয়। পার্থক্য কাজের ক্রমে নয়, কে কী মনে রাখে তাতে। নিচে চারটি অর্ডার ধরে তিনটি পাশাপাশি চালান:

1s = 0; for d, lines in orders:2  if d == w: … s = s + t3Shop(ORDERS).total_for(w)4  o.total() if district == w5reduce(add, map(…), 0)
এই ধাপে
imperative
object
functional
  1. শুরু। Imperative সংস্করণ একটি খাতা খোলে: s = 0. Object সংস্করণ আগে চারটি Order object বানায়, প্রতিটিতে জেলা আর লাইন। Functional সংস্করণ কিছু বানায় না; শুধু তিনটি ধাপের একটি শিকল জোড়ে, আর reduce-এর accumulator শুরু হয় 0 থেকে।
  2. প্রথম অর্ডার, ঢাকা। Imperative: t = 2 × 520 = 1040 ≥ 1000, তাই t = 1040 − 104 = 936, আর s = 936. Object: o1.total() নিজের লাইন থেকে একই 936 দেয়। Functional: filter অর্ডারটি রাখে, map 936 বানায়, reduce নতুন accumulator 936 ফেরত দেয়।
  3. দ্বিতীয় অর্ডার, রাজশাহী। তিনটিই এটি বাদ দেয়, কিন্তু তিন ভাষায়: if-এর শর্ত মিথ্যা, generator-এর if o.district == w মিথ্যা বলে total() ডাকাই হয় না, আর filter-এ ✗. সবখানে মোট 936.
  4. তৃতীয় অর্ডার, ঢাকা। 4 × 150 + 2 × 250 = 1100 ≥ 1000, তাই 990. তিনটিতেই মোট 936 + 990 = 1926.
  5. চতুর্থ অর্ডার, ঢাকা। 5 × 40 = 200, ছাড় নেই। মোট 1926 + 200 = 2126, তিন জায়গাতেই।
  6. ফল আর পার্থক্য। তিনটি সংস্করণ 2126 ছাপে। পার্থক্য অবস্থায়: imperative সংস্করণে s তিনবার বদলেছে (আর t প্রতিটি অর্ডারে কয়েকবার), object-গুলোর field তৈরির পর একবারও বদলায়নি, আর functional শিকলে কোনো নাম নতুন মান পায়নি; প্রতিটি accumulator একটি নতুন মান।

এবার একই তিন ধাঁচ JavaScript-এ (ECMAScript 2025, আপনার ব্রাউজারে)। JavaScript-এর class আসলে prototype-এর ওপরের লেখা (পর্ব ০৮), আর array-র filter/map Python-এর মতো lazy নয়: প্রতিটি ধাপ একটি নতুন array বানায়। শেষে একটি ছোট পরীক্ষা: দুই ধাঁচ মিললে কী হয়, যখন একটি method-কে সাধারণ function মান হিসেবে তুলে নেওয়া হয়।

"use strict";
const ORDERS = [["Dhaka", [[2, 520]]], ["Rajshahi", [[3, 120], [1, 180]]],
                ["Dhaka", [[4, 150], [2, 250]]], ["Dhaka", [[5, 40]]]];
const disc = t => (t >= 1000 ? t - Math.trunc(t / 10) : t);

function imperative(orders, wanted) {          // 1) loop + state
  let s = 0;
  for (const [d, lines] of orders) {
    if (d !== wanted) continue;
    let t = 0;
    for (const [q, u] of lines) t += q * u;
    s += disc(t);
  }
  return s;
}
class Order {                                  // 2) class (prototype underneath)
  constructor(d, lines) { this.d = d; this.lines = lines; }
  total() { return disc(this.lines.reduce((a, [q, u]) => a + q * u, 0)); }
}
const objects = ORDERS.map(([d, ls]) => new Order(d, ls));
const viaObjects = w => objects.filter(o => o.d === w).reduce((a, o) => a + o.total(), 0);
const functional = w => ORDERS                 // 3) pipeline of pure functions
  .filter(([d]) => d === w)
  .map(([, lines]) => disc(lines.reduce((a, [q, u]) => a + q * u, 0)))
  .reduce((a, t) => a + t, 0);

for (const w of ["Dhaka", "Rajshahi"])
  console.log(w, imperative(ORDERS, w), viaObjects(w), functional(w));

// when styles meet: a method used as a plain function value loses "this"
const loose = objects[0].total;
try { loose(); } catch (e) { console.log(e.constructor.name + ":", e.message); }
console.log("bound:", loose.bind(objects[0])());

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

Dhaka 2126 2126 2126
Rajshahi 540 540 540
TypeError: Cannot read properties of undefined (reading 'lines')
bound: 936

দুই ভাষা, তিন ধাঁচ, একই 2126 আর 540. শেষ দুই লাইন একটি পরিচিত “সীমানার” সমস্যা। Functional ধাঁচে function একটি সাধারণ মান, যা যেকোনো জায়গায় পাঠানো যায়; OO ধাঁচে method-এর অর্থ নির্ভর করে কোন object থেকে ডাকা হলো তার ওপর (this). objects[0].total-কে আলাদা করে তুলে নিলে সে তার object হারায়: strict mode-এ this হয় undefined, আর this.lines পড়তে গিয়ে TypeError. bind দিয়ে object-টি স্থায়ীভাবে জুড়ে দিলে আবার 936. Python-এ একই কাজ (f = order.total) নিজে থেকেই একটি “bound method” বানায়, তাই এই ফাঁদ নেই: এক ভাষার নিয়ম অন্য ভাষায় খাটে না।

৪ · মেপে তুলনা — লাইন আর mutation point গোনার একটি analysis pass

“Functional কোড বেশি পরিষ্কার” বা “OOP বেশি গোছানো” ধরনের কথা প্রায়ই শোনা যায়, কিন্তু মাপ ছাড়া এগুলো রুচির কথা। দুটি জিনিস অন্তত সৎভাবে গোনা যায়: কোডের লাইন, আর কোডের কত জায়গায় আগে থেকে থাকা কোনো অবস্থা বদলায়। দ্বিতীয়টি গুরুত্বপূর্ণ, কারণ প্রতিটি বদলের জায়গা একটি প্রশ্ন তোলে: “এই লাইনের আগে আর পরে মানটি কী?” যত কম এমন জায়গা, তত কম প্রশ্ন।

সংজ্ঞা ১৩.২ — mutation point (এই পর্বের মাপ)

Python কোডের একটি mutation point এমন একটি জায়গা, যেখানে (ক) আগে থেকে বাঁধা (bound) একটি নামকে আবার নতুন মান দেওয়া হয় (s = s + t); বা (খ) augmented assignment হয় (s += x); বা (গ) কোনো object-এর field বা ঘরে লেখা হয় (x.f = …, x[i] = …); বা (ঘ) পরিচিত বদলকারী method ডাকা হয় (append, pop, update …)। একটি নামের প্রথম বাঁধা, আর for-এর loop variable-এর প্রতি ঘোরার নতুন মান, গোনা হয় না।

এই সংজ্ঞাটি একটি ছোট AST-ভিত্তিক analysis pass হিসেবে লেখা যায়: Python-এর নিজের parser কোডকে AST বানায়, আর একটি visitor গাছের প্রতিটি assignment আর call দেখে নিয়ম মেলায়। Compiler-এর semantic analysis ঠিক এই ধাঁচে চলে (মডিউল ৯-এ Haat-এর জন্য নিজে লিখবেন)। Pass-টি তিনটি ছোট নমুনায় চালান, যেখানে প্রতিটি অর্ডার আগে থেকেই (জেলা, মোট) জোড়া:

import ast

class MutationCounter(ast.NodeVisitor):      # a tiny analysis pass over the AST
    MUTATORS = {"append", "extend", "insert", "pop", "remove", "update", "clear"}
    def __init__(self): self.bound, self.points = set(), []
    def visit_Assign(self, node):
        for t in node.targets: self.store(t, node.lineno)
        self.generic_visit(node)
    def visit_AugAssign(self, node):          # s += x always changes s
        self.points.append((node.lineno, ast.unparse(node.target))); self.generic_visit(node)
    def visit_For(self, node):                # loop variable: a new value each round, not counted
        self.store(node.target, node.lineno); self.generic_visit(node)
    def visit_Call(self, node):
        f = node.func
        if isinstance(f, ast.Attribute) and f.attr in self.MUTATORS:
            self.points.append((node.lineno, ast.unparse(f)))
        self.generic_visit(node)
    def store(self, t, line):
        if isinstance(t, ast.Tuple):
            for e in t.elts: self.store(e, line)
        elif isinstance(t, ast.Name) and t.id not in self.bound:
            self.bound.add(t.id)               # first binding: not a mutation
        else:
            self.points.append((line, ast.unparse(t)))   # re-binding, x.f = .., x[i] = ..

STYLES = {
 "imperative": "s = 0\nfor d, t in orders:\n    if d == wanted:\n        if t >= 1000:\n            t = t - t // 10\n        s = s + t",
 "with list":  "kept = []\nfor d, t in orders:\n    if d == wanted:\n        kept.append(disc(t))\ns = sum(kept)",
 "functional": "s = sum(map(disc, (t for d, t in orders if d == wanted)))",
}
for name, src in STYLES.items():
    c = MutationCounter(); c.visit(ast.parse(src))
    print(f"{name:10} lines={len(src.splitlines())} mutations={len(c.points)}", c.points)

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

imperative lines=6 mutations=2 [(5, 't'), (6, 's')]
with list  lines=5 mutations=1 [(4, 'kept.append')]
functional lines=1 mutations=0 []

Imperative নমুনায় দুটি বদলের জায়গা: লাইন ৫-এ loop variable t-কে ছাড়ের মান দেওয়া, আর লাইন ৬-এ s. মাঝের নমুনায় s আর বদলায় না, কিন্তু একটি list ধাপে ধাপে বাড়ে (kept.append). Functional নমুনায় শূন্য। visit_For কেন দরকার, খেয়াল করুন: সেটি না থাকলে t loop-এ প্রথমবার বাঁধা হতো না, আর লাইন ৫-এর t = …-কে pass ভুল করে “প্রথম বাঁধা” ধরত। ছোট একটি analysis-এও প্রতিটি ভাষা-নিয়ম (এখানে loop variable কোথায় বাঁধা হয়) ঠিকভাবে মডেল না করলে ফল ভুল হয়।

একই pass আমার যন্ত্রে অংশ ৩-এর পূর্ণ program-এর তিনটি অংশে চালানো হয়েছে (সত্যিকারের run, CPython 3.14.4; লাইন মানে ফাঁকা নয় এমন লাইন, def/class লাইনসহ):

ধাঁচ (অংশ ৩-এর কোড)লাইনMutation pointকোথায়
Imperative (total_imperative)113t দুবার, s একবার
Object-oriented (Order, Shop)103self.district, self.lines, self.orders
Functional (৩টি function)50—

টেবিলটি যতটা বলে, তার চেয়ে বেশি বলে না। Object সংস্করণের তিনটি “mutation” আসলে constructor-এর ভেতরে নতুন object-এর field-এ প্রথম মান বসানো; তৈরির পর কেউ এগুলো বদলায় না। আমাদের সরল pass এই পার্থক্য দেখতে পায় না, কারণ সে জানে না self একটি সদ্য-তৈরি object. সত্যিকারের analysis tool এই কারণেই ভাষার অর্থ (semantics) অনেক বেশি জানে। আর লাইন সংখ্যা গতি বা সঠিকতার মাপ নয়: পাঁচ লাইনের functional কোড ভুল হতে পারে, এগারো লাইনের loop পড়তে সহজ হতে পারে। এখানে কোনো গতির তুলনা দেওয়া হয়নি, কারণ এত ছোট ডেটায় তা অর্থহীন; গতির প্রশ্ন নিজের যন্ত্রে, নিজের ডেটায় মাপতে হয়।

৫ · Declarative ধাঁচ — SQL-এ একই হিসাব

তিনটি ধাঁচেই আপনি বলে দিয়েছেন কীভাবে হিসাব হবে: কোন ক্রমে অর্ডার ছোঁয়া হবে, কোথায় যোগ জমবে। Declarative ধাঁচ আরও এক ধাপ পিছিয়ে আসে: শুধু বলে কী চাই, আর পথ খুঁজে নেয় ভাষার বাস্তবায়ন। সবচেয়ে সফল উদাহরণ SQL. নিচের editor-এ একটি সত্যিকারের SQLite database (sql.js, WebAssembly-তে) আপনার ব্রাউজারেই চলে; প্রতিটি লাইন একটি সারি (অর্ডার নম্বর, জেলা, পণ্য, পরিমাণ, একক দাম)।

WITH totals AS (                 -- each order's total
  SELECT order_id, district, SUM(qty * unit) AS t
  FROM lines
  GROUP BY order_id, district
)
SELECT district,
       SUM(CASE WHEN t >= 1000 THEN t - t / 10 ELSE t END) AS total
FROM totals
GROUP BY district
ORDER BY district;

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

district  total
Dhaka     2126
Rajshahi  540

চতুর্থবার একই 2126, আর রাজশাহী 540. Query-তে কোনো loop নেই, কোনো variable বদলায় না, কোন সারি আগে পড়া হবে তাও বলা নেই। WITH দিয়ে নাম দেওয়া মাঝের ফল (প্রতিটি অর্ডারের মোট), GROUP BY দিয়ে জেলাভিত্তিক যোগ, আর CASE দিয়ে ছাড়ের নিয়ম। SQLite-এ দুটি integer-এর / দশমিক ফেলে দেয়, তাই t / 10 Haat-এর মতোই পূর্ণসংখ্যা দেয় (মোট অঋণাত্মক বলে Python-এর //-এর সঙ্গেও মেলে)। ঢাকা ছাড়া অন্য কিছু চাইলে শুধু WHERE district = 'Dhaka' যোগ করুন, editor-এ চালিয়ে দেখুন।

তাহলে “কীভাবে” কে ঠিক করে? Database-এর query optimizer. আমার যন্ত্রে একই query-র সামনে EXPLAIN QUERY PLAN লিখে চালানো হয়েছে (সত্যিকারের run, Python-এর sqlite3 module, SQLite 3.50.4); ফলের মূল লাইনগুলো:

CO-ROUTINE totals
SCAN lines
USE TEMP B-TREE FOR GROUP BY
SCAN totals
USE TEMP B-TREE FOR GROUP BY

SQLite নিজে সিদ্ধান্ত নিয়েছে: পুরো lines টেবিল একবার পড়বে (SCAN), গ্রুপ করার জন্য একটি অস্থায়ী B-tree বানাবে, আর totals-কে আলাদা টেবিলে না রেখে coroutine হিসেবে টুকরো টুকরো দেবে। (order_id, district)-এর ওপর একটি index বানালে একই query বদল ছাড়াই অন্য plan পেতে পারে; imperative loop-এ এমন বদল নিজেকে হাতে লিখতে হতো। SQL-এর GROUP BY-এর বিস্তারিত আছে DBMS ও SQL কোর্সের পর্ব ১৮-এ, CTE-র পর্ব ২৫-এ, আর optimizer কীভাবে plan বাছে তা সেই কোর্সের পর্ব ৪৩-এ.

Declarative ধাঁচের আরেক রূপ নিয়মকে ডেটা বানানো। বাজারঘরের ছাড়ের নিয়ম যদি বছরে কয়েকবার বদলায় (“ঈদে ১৫%”, “নতুন গ্রাহকের প্রথম অর্ডারে ৫০ টাকা”), তবে প্রতিবার if-এর শিকল বদলানোর চেয়ে নিয়মগুলো একটি টেবিলে রাখা আর একটি ছোট “নিয়ম চালক” দিয়ে মেলানো ভালো। পর্ব ১০ (Logic programming) এই ধারণার চূড়ান্ত রূপ দেখায়: তথ্য আর নিয়ম লিখলে ভাষা নিজেই unification আর backtracking দিয়ে উত্তর খোঁজে।

৬ · কোন কাজে কোন ধাঁচ — সিদ্ধান্তের পথ

কোনো আইন নেই, কিন্তু একটি কার্যকর অভ্যাস আছে: ধাঁচ বাছার আগে সমস্যাটির আকার নিয়ে কয়েকটি প্রশ্ন করা। Peter Van Roy আর Seif Haridi-র বই Concepts, Techniques, and Models of Computer Programming (২০০৪) একটি নীতি দেয়, যাকে তাঁরা “rule of least expressiveness” বলেন: একটি অংশের জন্য সেই হিসাবের মডেল বেছে নিন, যা সবচেয়ে কম ক্ষমতাসম্পন্ন অথচ program-টি স্বাভাবিক রাখে। অর্থাৎ বদলানো অবস্থা দরকার না হলে নেবেন না; concurrency দরকার না হলে আনবেন না। নিচের পথটি বাজারঘরের উদাহরণ দিয়ে এই নীতি প্রয়োগ করে:

  1. রূপান্তর?তালিকা → ফলfunctional
  2. বদলানো অবস্থা?সময় ধরেobject / imperative
  3. নিয়ম?শর্তের তালিকাdeclarative
  4. অপেক্ষা?I/Oasync / actor
  5. মেশানোসীমানাপরিষ্কার চুক্তি
দৈনিক বিক্রির রিপোর্টইনপুট থেকে নতুন মান
orders → filter(জেলা)
  → map(মোট, ছাড়) → sum
কোনো অবস্থা বদলায় না
প্রতিটি ধাপ আলাদা test করা যায়
ডেলিভারি রাইডারের simulationঅবস্থা সময়ের সঙ্গে বদলায়
rider.location
rider.load, rider.status
tick() প্রতি মিনিটে
  অবস্থা বদলায়
অনেক রাইডার → অনেক object
ছাড় আর ডেলিভারির নিয়মনিয়ম ডেটা, চালক আলাদা
মোট ≥ 1000 → ১০% ছাড়
ঢাকা, মোট < 1000
  → ডেলিভারি 60
SQL / নিয়মের টেবিল
/ Datalog
payment আর SMS-এর জন্য অপেক্ষাCPU নয়, নেটওয়ার্কের অপেক্ষা
await pay(order)
await send_sms(phone)
# অপেক্ষার সময়
# অন্য অর্ডার চলে
async/await বা actor
পুরো বাজারঘর systemপ্রতিটি অংশ নিজের ধাঁচে
async handler (অপেক্ষা)
 → pure হিসাব (মোট, ছাড়)
 → SQL query (রিপোর্ট)
 → Rider object (অবস্থা)
সীমানায়: immutable ডেটা
  1. প্রশ্ন ১ — এটি কি ইনপুট থেকে আউটপুটের রূপান্তর? দৈনিক রিপোর্ট, CSV থেকে সারাংশ, compiler-এর একটি pass: ইনপুট পড়ে নতুন মান বানানো। এখানে functional pipeline স্বাভাবিক, কারণ কোনো অবস্থা টিকিয়ে রাখার দরকার নেই, আর প্রতিটি ধাপ আলাদা করে test করা যায়।
  2. প্রশ্ন ২ — অনেকগুলো জিনিসের অবস্থা কি সময়ের সঙ্গে বদলায়? রাইডারের অবস্থান, cart-এ পণ্য, গুদামের মজুত। এখানে অবস্থাই সমস্যার অংশ, লুকানোর চেষ্টা কৃত্রিম। Object প্রতিটি জিনিসের অবস্থা আর নিয়ম একসঙ্গে রাখে; ছোট আর গতি-সংবেদনশীল অংশে সরল imperative loop প্রায়ই সবচেয়ে পরিষ্কার।
  3. প্রশ্ন ৩ — সমস্যাটি কি নিয়ম আর শর্তের তালিকা? ছাড়, ডেলিভারি চার্জ, অনুমতি (কে কোন রিপোর্ট দেখতে পারবে)। নিয়মগুলো ডেটা হিসেবে রাখুন (SQL, নিয়মের টেবিল, Datalog), যাতে নিয়ম বদলালে কোড না বদলায়, আর একটি নিয়ম-চালক সব মেলায়।
  4. প্রশ্ন ৪ — সময় কি বেশির ভাগ অপেক্ষায় যায়? Payment gateway, SMS, database-এর উত্তর। CPU এখানে প্রায় বসে থাকে, তাই অনেক thread-এর বদলে async/await বা actor অনেক অপেক্ষা একসঙ্গে সামলায়। এর ভেতরের যন্ত্র পর্ব ১১ আর পর্ব ৩১-এ (Generator, coroutine আর async/await).
  5. মেশানো — সীমানা ঠিক করা। বাস্তব system-এ চারটি প্রশ্নের উত্তরই “হ্যাঁ”, তবে আলাদা অংশে। তাই কৌশল: অপেক্ষার বাইরের স্তর async, ভেতরের হিসাব pure, রিপোর্ট SQL, আর সত্যিকারের বদলানো অবস্থা কয়েকটি object-এ সীমাবদ্ধ। অংশগুলোর মাঝে immutable ডেটা পাঠালে এক অংশের বদল অন্য অংশকে অবাক করে না।
সমস্যার ধরনমানানসই ধাঁচসতর্কতা
ডেটার রূপান্তর, রিপোর্ট, compiler passFunctional pipelineখুব লম্বা শিকল পড়া কঠিন; মাঝের ধাপে নাম দিন
Simulation, GUI, খেলা, cartObject-oriented বা imperativeবদলানো অবস্থা কয়েকটি জায়গায় সীমাবদ্ধ রাখুন
নিয়ম, অনুমতি, queryDeclarative (SQL, Datalog, নিয়মের টেবিল)optimizer-এর plan দেখে নিন; সব নিয়ম টেবিলে ধরে না
অনেক নেটওয়ার্ক অপেক্ষাasync/await, actorCPU-ভারী কাজ async-এ দ্রুত হয় না
Hardware-এর কাছের, গতি-সংবেদনশীল loopImperative (C, Rust)উচ্চ-স্তরের ধাঁচও optimizer পেরিয়ে প্রায়ই একই কোডে নামে (অংশ ৮)

৭ · Refactoring — loop থেকে pipeline, প্রতিটি ধাপ যাচাই করে

পুরোনো কোড প্রায়ই এক ধাঁচে লেখা, আর আপনি চান অন্য ধাঁচে নিতে। Refactoring মানে বাইরের আচরণ একই রেখে ভেতরের গঠন বদলানো। শর্তটি কঠিন: “একই আচরণ” প্রতিটি ইনপুটের জন্য, শুধু উদাহরণের জন্য নয়। তাই কাজটি ছোট ছোট ধাপে, আর প্রতিটি ধাপের পর একটি differential test: পুরোনো আর নতুন সংস্করণ একই ইনপুটে চালিয়ে ফল মেলানো। নিচে বাজারঘরের loop থেকে pipeline-এর পথ, সঙ্গে একটি “AI-এর প্রস্তাব” যা দেখতে ঠিক, কিন্তু ঠিক নয়:

  1. v0এক loop২ বদল
  2. v1pure function১ বদল
  3. v2sum(…)০ বদল
  4. AIপ্রতি লাইনে ছাড়ভুল
  5. যাচাই2001 ইনপুটdifferential
v0 — শুরুDhaka = 2126
s = 0
for d, lines in orders:
    if d == w:
        t = 0
        for q, u in lines:
            t = t + q * u
        s = s + disc(t)
return s
v1 — pure function বের করাDhaka = 2126
def order_total(lines):
    return disc(sum(
        q * u for q, u in lines))
s = 0
for d, lines in orders:
    if d == w:
        s = s + order_total(lines)
return s
v2 — loop থেকে filter + map + sumDhaka = 2126
return sum(order_total(ls)
           for d, ls in orders if d == w)
AI-এর “আরও ছোট” প্রস্তাবDhaka = 2236
return sum(disc(q * u)
           for d, ls in orders if d == w
           for q, u in ls)
Differential test, seed 13v0-এর সঙ্গে তুলনা
v1: 2001/2001 agree
v2: 2001/2001 agree
ai: 953/2001 agree
  1. v0 — এক loop-এ সব। ৯ লাইন (def লাইনসহ), অংশ ৪-এর pass অনুযায়ী ২টি mutation point: t = t + q * u আর s = s + disc(t). ঢাকার উত্তর 2126. এটিই “সত্যের উৎস”; বাকি সব সংস্করণ এর সঙ্গে মেলানো হবে।
  2. v1 — একটি pure function বের করা। অর্ডারের মোট আর ছাড় একটি আলাদা function order_total-এ গেল, যা শুধু argument পড়ে আর কিছু বদলায় না। Loop এখন ৬ লাইন, ১টি mutation point (s). ভেতরের loop-এর সঙ্গে t-এর বদলও গেল।
  3. v2 — loop থেকে sum. বাকি loop-টি আসলে “শর্ত মানা অর্ডারের order_total যোগ”; পর্ব ০৯-এর উপপাদ্য ৯.১ বলে accumulator-এর loop একটি foldl, আর যোগের foldl মানে sum. ফল ২ লাইন, ০টি mutation point, উত্তর একই 2126.
  4. AI-এর প্রস্তাব। দেখতে আরও ছোট আর “বেশি functional”, কিন্তু ছাড় দিচ্ছে প্রতিটি লাইনে, অর্ডারের মোটে নয়। ঢাকার উত্তর 2236: চিনি 600 আর চা 500 আলাদাভাবে ১০০০-এর নিচে, তাই 1100 টাকার অর্ডারটি ছাড় পায় না। নিয়মটি ভেঙেছে কারণ disc(a + b) ≠ disc(a) + disc(b): ছাড়ের function যোগের ওপর ভাগ হয় না।
  5. Differential test. একটি ফাঁকা তালিকা আর ২০০০টি random অর্ডার-তালিকায় (seed 13) v1 আর v2 প্রতিটিতে v0-এর সঙ্গে মেলে। AI-এর সংস্করণ মেলে মাত্র ৯৫৩টিতে। হাতে দেখা একটি উদাহরণে ভুলটি ধরা না-ও পড়তে পারত (যেমন সব অর্ডারে একটি করে লাইন থাকলে); random পরীক্ষা সেটি দ্রুত ধরে।

Stepper-এর শেষ ধাপের সংখ্যাগুলো নিচের program থেকে। নিজে চালিয়ে দেখুন, seed বদলে দেখুন, বা নিজের একটি refactor যোগ করুন:

import random

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

def v0(orders, w):                     # start: one loop does everything
    s = 0
    for d, lines in orders:
        if d == w:
            t = 0
            for q, u in lines:
                t = t + q * u
            s = s + disc(t)
    return s
def order_total(lines): return disc(sum(q * u for q, u in lines))
def v1(orders, w):                     # step 1: extract a pure function
    s = 0
    for d, lines in orders:
        if d == w:
            s = s + order_total(lines)
    return s
def v2(orders, w):                     # step 2: the loop becomes a sum of a filter + map
    return sum(order_total(ls) for d, ls in orders if d == w)
def ai(orders, w):                     # an "AI refactor": discount per line, not per order
    return sum(disc(q * u) for d, ls in orders if d == w for q, u in ls)

random.seed(13)
rand_order = lambda: (random.choice(["Dhaka", "Khulna"]),
                      [(random.randint(1, 5), random.randint(1, 600)) for _ in range(random.randint(0, 3))])
tests = [[]] + [[rand_order() for _ in range(random.randint(0, 8))] for _ in range(2000)]
for f in (v1, v2, ai):
    bad = [o for o in tests if f(o, "Dhaka") != v0(o, "Dhaka")]
    print(f"{f.__name__}: {len(tests) - len(bad)}/{len(tests)} agree", end="")
    small = min(bad, key=lambda o: len(str(o)), default=None)
    print(f"; smallest mismatch {small}: {v0(small, 'Dhaka')} vs {f(small, 'Dhaka')}" if bad else "")

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

v1: 2001/2001 agree
v2: 2001/2001 agree
ai: 953/2001 agree; smallest mismatch [('Dhaka', [(5, 428), (4, 26)])]: 2020 vs 2030

v1 আর v2 প্রতিটি ইনপুটে মিলেছে; পরীক্ষা প্রমাণ নয়, তবে v2-এর পেছনে একটি প্রমাণও আছে (নিচে)। AI-এর সংস্করণের সবচেয়ে ছোট অমিল একটি মাত্র অর্ডার: 5 × 428 = 2140 আর 4 × 26 = 104. ঠিক নিয়মে মোট 2244 থেকে ছাড়ের পর 2020; AI-এর নিয়মে শুধু 2140-এর লাইন ছাড় পায় (1926), সঙ্গে 104, মোট 2030. ছোট অমিল খুঁজে দেখানো (min দিয়ে) ভুল বোঝার কাজ সহজ করে; property-based testing tool এই কাজ নিজে থেকে করে, যাকে বলে shrinking (Software Testing কোর্সের পর্ব ৫৮)। Refactoring-এর সাধারণ কৌশল আর code smell-এর তালিকা আছে Software Engineering কোর্সের পর্ব ৪২-এ.

কোন বদল নিরাপদ, তা প্রমাণ দিয়ে জানা

Pipeline-এ ধাপের ক্রম বদলানো একটি সাধারণ refactor: যেমন আগে map, পরে filter, নাকি উল্টো। নিচের সূত্রটি বলে কখন উল্টানো যায় (এখানে f আর p pure, আর p ∘ f মানে “আগে f, তারপর p”):

উপপাদ্য ১৩.১ — filter আর map-এর স্থান বদল

যেকোনো pure function f, pure শর্ত p আর সসীম তালিকা xs-এর জন্য filter p (map f xs) = map f (filter (p ∘ f) xs). অর্থাৎ “বদলে তারপর ছাঁকা” আর “বদলানো মান দেখে আগে ছাঁকা, তারপর বদলানো” একই তালিকা দেয়।

প্রমাণ structural induction দিয়ে, ঠিক পর্ব ০৯-এর map fusion-এর মতো; সেটি অনুশীলন ৪-এ আপনার কাজ। ব্যবহারিক মানে: বাজারঘরে জেলা দিয়ে ছাঁকা আর মোট হিসাব করা উল্টানো যায়, কারণ “জেলা” মোট হিসাবে বদলায় না; তাই আগে ছেঁকে নিলে রাজশাহীর মোট হিসাবই করতে হয় না। কিন্তু f যদি pure না হয় (যেমন প্রতিটি অর্ডারে একটি log ছাপে), তাহলে দুই দিকে ছাপার সংখ্যা আলাদা, আর সূত্রটি ভেঙে যায়। AI-এর ভুলটি ছিল আরেক জাতের: সে যে সূত্র ব্যবহার করেছে (disc(a + b) = disc(a) + disc(b)) সেটি এই ডেটাতেই মিথ্যা।

৮ · Haat-এর paradigm আর ধাঁচ মেশানোর ফাঁদ

কোর্সের নিজের ভাষা Haat কোন ধাঁচের? Spec v1 দেখলেই উত্তর: var, assignment, while আর print আছে, তাই Haat মূলত imperative; সঙ্গে function first-class, anonymous function আর closure আছে, যা বাইরের variable “by reference” ধরে রাখে। Class, inheritance বা pattern matching নেই; type static আর সব function-এর type লিখতে হয়। অর্থাৎ Haat একটি ছোট multi-paradigm ভাষা: imperative কেন্দ্র, functional হাতিয়ার। Object-এর অনেক কাজ closure দিয়েই হয়, কারণ closure-ও “ডেটা আর আচরণ একসঙ্গে” (পর্ব ০৮ আর ০৯-এ এই দ্বৈততা দেখেছেন)। নিচের program দুই ধাঁচ মেশায়:

// বাজারঘর: Haat-এ দুই ধাঁচ একসঙ্গে
fn line(qty: Int, unit: Int) -> Int { return qty * unit; }
// object-এর মতো closure: নিয়মটি নিজের rate আর limit মনে রাখে
fn policy(rate: Int, limit: Int) -> (Int) -> Int {
    return fn(t: Int) -> Int {
        if t >= limit { return t - t * rate / 100; }
        return t;
    };
}
// imperative অংশ: একটি var-এ ধাপে ধাপে যোগ
fn district_total(wanted: Str, apply: (Int) -> Int) -> Int {
    var sum = 0;
    if "Dhaka" == wanted { sum = sum + apply(line(2, 520)); }
    if "Rajshahi" == wanted { sum = sum + apply(line(3, 120) + line(1, 180)); }
    if "Dhaka" == wanted { sum = sum + apply(line(4, 150) + line(2, 250)); }
    if "Dhaka" == wanted { sum = sum + apply(line(5, 40)); }
    return sum;
}
print(district_total("Dhaka", policy(10, 1000)));
print(district_total("Rajshahi", policy(10, 1000)));
print(district_total("Dhaka", policy(0, 0)));
// loop-এর ভেতরে তৈরি closure কোন variable ধরে?
var i = 0;
var own = fn() -> Int { return -1; };
var shared = fn() -> Int { return -1; };
while i < 3 {
    let j = i;
    if i == 0 {
        own = fn() -> Int { return j; };
        shared = fn() -> Int { return i; };
    }
    i = i + 1;
}
print(own());
print(shared());

সত্যিকারের run, কোর্সের Haat reference বাস্তবায়নে (CPython 3.14.4); check সব type মিলিয়ে ok বলে, আর tree-walking interpreter ও bytecode VM হুবহু একই আউটপুট দেয়:

~/haat $ python haat.py check mixed.haat
ok
~/haat $ python haat.py run mixed.haat
2126
540
2340
0
3
~/haat $ python haat.py vm mixed.haat
2126
540
2340
0
3

প্রথম তিন লাইন বাজারঘরের হিসাব। policy(10, 1000) একটি closure, যা object-এর মতো নিজের rate আর limit ধরে রাখে; district_total তাকে না জেনেই ডাকে, ঠিক পর্ব ০৮-এর polymorphism-এর মতো। ঢাকা 2126, রাজশাহী 540, আর “কোনো ছাড় নেই” নিয়ম (policy(0, 0)) দিলে ঢাকার কাঁচা মোট 1040 + 1100 + 200 = 2340. ভেতরে sum একটি সাধারণ imperative accumulator: এক function-এর ভেতরে সীমাবদ্ধ বদলানো অবস্থা, যা বাইরে থেকে দেখা যায় না, তাই district_total বাইরে থেকে pure.

শেষ দুই লাইন একটি ক্লাসিক ফাঁদ, যা ঠিক তখনই আসে যখন imperative ধাঁচের বদলানো loop variable আর functional ধাঁচের closure দেখা হয়। Haat reference-এর নকশা-সিদ্ধান্ত ১৪ বলে: while-এর দেহ প্রতি ঘোরায় একটি নতুন scope, তাই প্রথম ঘোরার let j সেই ঘোরার নিজস্ব variable, যা পরে কেউ বদলায় না; own() তাই 0. কিন্তু i loop-এর বাইরের একটিমাত্র var, আর closure তাকে by reference ধরে; loop শেষে i = 3, তাই shared() 3. Closure “মান” নয়, “variable” ধরে।

ভাষাকোড (তিনটি closure, তারপর সবগুলো ডাকা)সত্যিকারের ফল
Python 3.14[lambda: i for i in range(3)][2, 2, 2]
Python 3.14[lambda i=i: i for i in range(3)][0, 1, 2]
JavaScript (Node 24)for (var i = 0; i < 3; i++) → () => i[3, 3, 3]
JavaScript (Node 24)for (let k = 0; k < 3; k++) → () => k[0, 1, 2]
Haat v1loop-এর বাইরের var i বনাম ভেতরের let j3 বনাম 0

Python-এ comprehension-এর i একটিই variable, তাই সব closure শেষ মান 2 দেখে; একে বলে late binding (নাম ব্যবহারের মুহূর্তে খোঁজা, পর্ব ১২-এর সেই একই ধারণা), আর default argument i=i তৈরির মুহূর্তের মান কপি করে সমাধান দেয় (বিস্তার Python কোর্সের পর্ব ২০-এ)। JavaScript-এ var পুরো function-এর একটি variable (৩, ৩, ৩), কিন্তু ES2015-এর let loop-এর প্রতি ঘোরায় নতুন binding দেয় (০, ১, ২; বিস্তার JavaScript কোর্সের পর্ব ২২-এ)। ভাষার নকশাকারীরা এই ফাঁদ চেনেন বলেই বদলেছেন: C# 5 (২০১২) foreach-এর variable প্রতি ঘোরায় নতুন করেছে, আর Go 1.22 (২০২৪) for loop-এর variable-এর জন্য একই কাজ করেছে।

Compiler-এর চোখে: সব ধাঁচ শেষে একই IR

ধাঁচ মূলত source code-এর গুণ। Compiler-এর ভেতরে সবকিছু কয়েকটি সরল জিনিসে নামে। Object হয় একটি record আর method-এর জন্য একটি vtable (পর্ব ০৮-এর অংশ ৮)। Closure হয় একটি record (ধরা variable-গুলো) আর একটি code pointer; এই রূপান্তরকে বলে closure conversion, যা Haat interpreter-এ পর্ব ৫৭-এ বানাবেন। Loop, if আর comprehension সব হয় basic block আর jump দিয়ে তৈরি একটি control flow graph (পর্ব ৬২)। Python-এর comprehension নিজেই একটি loop-এ নামে, আর উচ্চ-স্তরের অনেক গঠনকে ছোট core-এ নামানোর কৌশল (desugaring) পর্ব ৫৫-এর বিষয়।

তাহলে ধাঁচের “দাম” কোথায়? দাম আসে তখন, যখন optimizer উচ্চ-স্তরের গঠনের ভেতর দেখতে পারে না: একটি indirect call (function pointer, virtual method, closure call) যার লক্ষ্য compile time-এ অজানা, বা প্রতিটি closure-এর জন্য heap-এ নতুন object. Inlining (পর্ব ৬৭) এই দেয়াল ভাঙে: map-এ পাঠানো closure-এর লক্ষ্য জানা থাকলে compiler দেহটি সরাসরি loop-এ বসায়, আর pipeline একটি সাধারণ loop হয়ে যায়। C++-এর “zero-overhead principle” (Stroustrup-এর ভাষায়, যা ব্যবহার করেন না তার দাম দিতে হয় না, আর যা ব্যবহার করেন তা হাতে এর চেয়ে ভালো লেখা যেত না) আর Rust-এর iterator এই লক্ষ্যে নকশা করা; এমন zero-cost abstraction optimizer চালু থাকলে প্রায়ই হাতে লেখা loop-এর মতো কোড দেয়, তবে প্রতিটি ক্ষেত্রে তা নিশ্চিত নয়; নিশ্চিত হতে হলে compiler-এর আসল আউটপুট দেখতে হয় (পর্ব ৬৮-এ LLVM IR পড়বেন)।

আরও গভীরে: Multi-paradigm ভাষার বাস্তবায়নে একটি paradigm-কে অন্যটির ওপর বসানো হয়। Java 8-এর lambda আলাদা anonymous class হিসেবে compile হয় না; javac একটি invokedynamic instruction বসায়, আর চলার সময় LambdaMetafactory functional interface-এর object বানায়, যাতে JVM পরে কৌশল বদলাতে পারে। Kotlin-এর inline function-এ পাঠানো lambda-র দেহ call-এর জায়গায় কপি হয়, তাই কোনো closure object-ই তৈরি হয় না। আর Scala-য় প্রতিটি function একটি object, যার apply method আছে: OO আর functional জগৎ এক ধারণায় মিলেছে।

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

  • Multi-paradigm ভাষা কী, দুটি উদাহরণ দিন। যে ভাষা একাধিক paradigm-এর মূল প্রক্রিয়া ভাষার স্তরেই দেয়; যেমন C++ (procedural, OO, generic, lambda) আর Python (imperative, class, functional হাতিয়ার)।
  • Imperative আর declarative-এর পার্থক্য? Imperative বলে কীভাবে, ধাপে ধাপে অবস্থা বদলে; declarative বলে কী চাই, পথ ঠিক করে বাস্তবায়ন (যেমন SQL-এর optimizer).
  • কোন সমস্যায় কোন paradigm? ডেটার রূপান্তরে functional, বদলানো অবস্থার simulation-এ OO, নিয়ম আর query-তে declarative, I/O অপেক্ষায় async বা actor.
  • Python-এ [lambda: i for i in range(3)] সব কেন 2 দেয়? Closure variable ধরে, মান নয়; সব lambda একই i দেখে, যার শেষ মান 2.
  • Loop থেকে map/filter-এ refactor কীভাবে যাচাই করবেন? ফাঁকা আর প্রান্তের ইনপুটসহ random ডেটায় পুরোনো আর নতুন সংস্করণের differential test, আর সম্ভব হলে সমতার প্রমাণ।

৯ · AI-এর যুগে ধাঁচ বেছে নেওয়া আর বদলানো

AI assistant-কে “এই কোডটা functional করে দাও” বা “OOP দিয়ে লেখো” বললে সে দ্রুত সুন্দর কোড দেয়। সমস্যা হলো, ধাঁচ বদলানো একটি refactoring, আর refactoring-এর একমাত্র শর্ত আচরণ না বদলানো। অংশ ৭-এর AI-এর প্রস্তাব ঠিক এখানেই ব্যর্থ হয়েছিল। এই বিষয়ে AI-এর বারবার দেখা ভুল:

AI-এর ভুলকীভাবে ধরবেন
ধাঁচ বদলাতে গিয়ে অর্থ বদলানো: ছাড় প্রতি লাইনে, filter-এর আগে-পরে ভুল, শুরুর মান বাদপুরোনো আর নতুন সংস্করণের differential test, ফাঁকা তালিকা আর প্রান্তের মানসহ
এক ভাষার নিয়ম সবখানে চাপানো: “closure সবসময় মান কপি করে”, “method মানে bound method”, “map সবসময় lazy”নির্দিষ্ট ভাষা আর version-এ ছোট program চালিয়ে দেখা (উপরের loop-closure টেবিলের মতো)
ভাষার বৈশিষ্ট্যের version আর সাল ভুল বলা (কোন Java-তে record, কোন Python-এ async)ভাষার নিজের documentation বা release note মিলিয়ে দেখা
“Functional সবসময় ধীর” বা “OOP সবসময় পরিষ্কার” ধরনের সাধারণ দাবি, মাপ ছাড়ানিজের ডেটায় মাপা; compiler-এর আসল আউটপুট (dis, -S, -emit-llvm) দেখা
সমস্যার আকার না দেখে এক ধাঁচে সব লেখা: অবস্থাভরা simulation-কে জোর করে pure, বা সরল রিপোর্টে class-এর পাহাড়অংশ ৬-এর চারটি প্রশ্ন নিজে করা; বদলানো অবস্থা কোথায় কোথায়, mutation point গুনে দেখা
SQL query-কে “সবচেয়ে দ্রুত” বলা, plan না দেখেEXPLAIN QUERY PLAN বা নিজের database-এর সমতুল্য দেখা

AI-কে ভালোভাবে কাজে লাগানোর উপায়: শুধু নতুন কোড নয়, সমতার যুক্তি আর পরীক্ষাও চাওয়া, তারপর নিজে চালিয়ে মেলানো।

আমি multi-paradigm programming শিখছি। নিচের Python loop-টি দুইভাবে আবার লিখে দাও: (ক) map/filter/sum দিয়ে functional ধাঁচে, (খ) একটি ছোট class দিয়ে object-oriented ধাঁচে। শুধু standard library. s = 0 for district, lines in orders: if district == wanted: t = 0 for qty, unit in lines: t = t + qty * unit if t >= 1000: t = t - t // 10 s = s + t ১. ছাড় অর্ডারের মোটে, প্রতিটি লাইনে নয় — তোমার দুই সংস্করণে এটি কোথায় রক্ষা পেয়েছে দেখাও। ২. প্রতিটি সংস্করণে কোন কোন জায়গায় অবস্থা বদলায়, তালিকা করো। ৩. পুরোনো loop আর দুই নতুন সংস্করণের ফল মেলানোর একটি differential test লেখো: seed ঠিক করা random ডেটা, ফাঁকা তালিকা, শুধু অন্য জেলার অর্ডার, আর ঠিক 1000 টাকার অর্ডার। ৪. কোনো ভাষার নিয়ম বললে ভাষা আর version উল্লেখ করো। ৫. কোনো আউটপুট অনুমান করে লিখবে না; কোনটি আমাকে চালিয়ে দেখতে হবে, আলাদা করে বলো।

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

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

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

প্র ০১প্রায় সব মূলধারার ভাষা কেন সময়ের সঙ্গে multi-paradigm হয়ে গেল?

ইতিহাস দেখলে একটি স্পষ্ট ধারা চোখে পড়ে: ধারণাগুলো জন্মায় “বিশুদ্ধ” ভাষায়, তারপর মূলধারার ভাষায় ঢোকে। Closure আর higher-order function এসেছে LISP আর Scheme থেকে; list comprehension Haskell-এর মতো ভাষা থেকে Python 2.0 (২০০০, PEP 202)-এ; type inference ML থেকে। C# 3.0 (২০০৭) LINQ দিয়ে query আর lambda আনে; C++11 lambda আনে; Java 8 (২০১৪) lambda আর stream আনে। পর্ব ০২-এর পারিবারিক গাছে এই “ধারণার ভ্রমণ” বিস্তারিত।

কারণ কয়েকটি। প্রথমত, বাস্তব সফটওয়্যার এক আকারের সমস্যা নয়: একই program-এ রিপোর্ট (রূপান্তর), cart (অবস্থা) আর নেটওয়ার্ক (অপেক্ষা) থাকে, আর অংশ ৬ দেখিয়েছে প্রতিটির স্বাভাবিক ধাঁচ আলাদা। দ্বিতীয়ত, হার্ডওয়্যার বদলেছে: ২০০০-এর দশকের মাঝামাঝি থেকে একক core-এর গতি বৃদ্ধি ধীর হয়ে বহু-core প্রসেসর সাধারণ হয়, আর বদলানো অবস্থা ভাগাভাগি না করা functional ধাঁচ parallel কাজে নিরাপদ বলে আকর্ষণীয় হয়। তৃতীয়ত, ভাষার ecosystem: লাখো লাইনের পুরোনো কোড আর library ফেলে নতুন ভাষায় যাওয়া ব্যয়বহুল, তাই পুরোনো ভাষাই নতুন ধারণা গ্রহণ করে।

এর দামও আছে। একই কাজ পাঁচভাবে লেখা গেলে একটি দলের কোড পাঁচ রকম হয়, নতুন সদস্যের শেখার বোঝা বাড়ে, আর বৈশিষ্ট্যগুলোর পারস্পরিক প্রতিক্রিয়া (feature interaction) নতুন ফাঁদ তৈরি করে, যেমন অংশ ৮-এর loop-closure. পর্ব ০৬-এ একে বলেছেন feature multiplicity, যা readability-র শত্রু হতে পারে। তাই বহু দল একটি style guide দিয়ে ঠিক করে কোন বৈশিষ্ট্য কোথায় চলবে। কিছু ভাষা উল্টো পথও নিয়েছে: Go শুরু থেকে ইচ্ছা করে ছোট থেকেছে, আর generic যোগ করেছে অনেক বছর পরে (Go 1.18, ২০২২), দীর্ঘ বিতর্কের পর।

মূল উপলব্ধি: Multi-paradigm হওয়া একটি সুবিধা আর একটি দায়িত্ব। ভাষা বিকল্প দেয়; কোন বিকল্প কোথায় নেবেন, সেই শৃঙ্খলা আসে প্রোগ্রামার আর দলের কাছ থেকে।

প্র ০২Paradigm কি আসলে আলাদা আলাদা “জগৎ”, নাকি কয়েকটি ধারণার যোগফল?

পাঠ্যবইয়ে paradigm প্রায়ই চারটি আলাদা বাক্সে আসে: imperative, OO, functional, logic. Peter Van Roy আর Seif Haridi তাঁদের ২০০৪ সালের বই Concepts, Techniques, and Models of Computer Programming-এ একটি ভিন্ন দৃষ্টি দেন, যা Oz ভাষা আর Mozart ব্যবস্থার ওপর দাঁড়ানো। তাঁদের মতে প্রতিটি paradigm একটি ছোট “kernel language”-এর ওপর দাঁড়ানো, আর একটি paradigm থেকে আরেকটিতে যাওয়া মানে kernel-এ একটি নতুন ধারণা যোগ করা।

যেমন, শুধু মান, function আর closure থাকলে আপনি একটি functional ভাষা পান। তাতে “named state” (বদলানো যায় এমন cell) যোগ করলে imperative আর object-ভিত্তিক ধাঁচ সম্ভব হয়। তাতে thread যোগ করলে shared-state concurrency, আর state ছাড়া শুধু dataflow variable যোগ করলে deterministic concurrency, যেখানে race condition হয় না। Van Roy পরে (২০০৯ সালের একটি লেখায়) এই চিন্তা থেকে কয়েক ডজন paradigm-এর একটি মানচিত্র আঁকেন, যেখানে প্রতিটি paradigm কয়েকটি ধারণার একটি সমষ্টি।

এই দৃষ্টির ব্যবহারিক লাভ দুটি। প্রথমত, multi-paradigm ভাষা আর রহস্যময় থাকে না: Python মানে “closure + named state + class + generator + …” ধারণার একটি নির্দিষ্ট সমষ্টি। দ্বিতীয়ত, ধাঁচ বাছাইয়ের প্রশ্ন বদলে যায়: “কোন বাক্স?” না জিজ্ঞেস করে জিজ্ঞেস করুন “এই অংশে আমার কোন ধারণা সত্যিই দরকার?” বদলানো অবস্থা দরকার না হলে নিলেন না, আর সেই অংশটি সহজে যুক্তি দেওয়া যায় এমন রইল। অংশ ৬-এর “rule of least expressiveness” এই চিন্তারই নীতি।

Haat-এর চোখেও দেখুন: Haat-এর kernel-এ মান, function, closure আর named state (var) আছে, কিন্তু thread বা class নেই। অংশ ৮-এ closure দিয়েই object-এর মতো কাজ হলো, কারণ “closure + state” দিয়ে object বানানো যায়; Scheme-এর ঐতিহ্যে এটি পরিচিত কৌশল। কোর্সের পরের মডিউলগুলোতে Haat-এ নতুন ধারণা (record, array) যোগ হলে এই সমষ্টি বড় হবে।

মূল উপলব্ধি: Paradigm শেখার দ্রুত পথ হলো তার মূল ধারণাগুলো আলাদা করে চেনা। তখন যেকোনো নতুন ভাষা একটি পরিচিত ধারণা-সমষ্টি হয়ে দেখা দেয়।

প্র ০৩SQL কেন সবচেয়ে সফল declarative ভাষা, আর “কী চাই” বলার সুবিধা কোথায় শেষ হয়?

১৯৭০ সালে Edgar F. Codd relational model প্রস্তাব করেন: ডেটা টেবিলে (relation), আর প্রশ্ন গণিতের ভাষায়, কোন পথে খুঁজতে হবে তা না বলে। ১৯৭৪ সালে Donald Chamberlin আর Raymond Boyce SEQUEL নামে একটি ভাষা প্রকাশ করেন, যা পরে SQL নাম পায়। কিন্তু ধারণাটিকে বাস্তব করে তোলে query optimizer: ১৯৭৯ সালে Patricia Selinger ও সহকর্মীদের System R গবেষণাপত্র দেখায়, কীভাবে খরচ অনুমান করে join-এর ক্রম আর index বাছাই করা যায়। অনেকের মতে এটিই declarative ভাষা কার্যকর হওয়ার প্রথম বড় প্রমাণ।

সুবিধাটি অংশ ৫-এ দেখেছেন: query-তে কোনো loop নেই, তাই database নিজে ঠিক করে কোন index ব্যবহার করবে, কোন টেবিল আগে পড়বে। ডেটা ১০ হাজার থেকে ১০ কোটি সারিতে গেলে বা নতুন index যোগ হলে একই query নতুন plan পায়, কোড না বদলেই। Imperative loop-এ এই সিদ্ধান্তগুলো প্রোগ্রামারের হাতে লেখা থাকত, আর পরিস্থিতি বদলালে আবার লিখতে হতো। এটি compiler optimization-এর মতোই: “কী” আর “কীভাবে” আলাদা থাকলে “কীভাবে” অংশটি স্বয়ংক্রিয়ভাবে উন্নত করা যায়।

সীমাও আছে। প্রথমত, optimizer অনুমানের ওপর চলে; পরিসংখ্যান পুরোনো হলে বা query জটিল হলে খারাপ plan বাছতে পারে, আর তখন প্রোগ্রামারকে plan পড়ে index বা query বদলাতে হয়, অর্থাৎ “কীভাবে” ফিরে আসে। দ্বিতীয়ত, কিছু কাজ নিখাদ declarative রূপে লেখা কঠিন: ধাপে ধাপে অবস্থা বদলানো workflow, বা গ্রাফে পুনরাবৃত্ত খোঁজ। SQL:1999 মানদণ্ড recursive CTE যোগ করেছে, আর অনেক database-এ procedural extension (stored procedure) আছে: SQL নিজেও সময়ের সঙ্গে খানিকটা multi-paradigm হয়েছে।

প্রোগ্রামিং ভাষার দিক থেকে শিক্ষাটি বড়: Datalog (পর্ব ১০-এ পরিচয়) একই চিন্তা নিয়মে নিয়ে যায়, আর আজ কিছু program analysis tool কোডের তথ্য Datalog-এর নিয়মে লিখে বিশ্লেষণ চালায়; এর তাত্ত্বিক দিক আসবে পর্ব ৬৪-এ (Dataflow analysis).

মূল উপলব্ধি: Declarative ধাঁচের শক্তি আসে একটি বুদ্ধিমান বাস্তবায়ন থেকে। “কী চাই” বলার স্বাধীনতা ততটাই ভালো, যতটা ভালো optimizer; তাই plan পড়তে জানা declarative প্রোগ্রামারেরও জরুরি দক্ষতা।

প্র ০৪ধাঁচ মেশালে কোন জাতের bug জন্মায়, আর ভাষাগুলো সেগুলো কমাতে কী করেছে?

প্রতিটি paradigm নিজের ভেতরে সংগত। Bug জন্মায় সীমানায়, যেখানে এক ধাঁচের অনুমান অন্য ধাঁচের প্রক্রিয়ার সঙ্গে মেলে না। তিনটি পরিচিত উদাহরণ এই পর্বেই দেখেছেন।

প্রথম, closure আর বদলানো variable: functional ধাঁচ ধরে নেয় একটি নাম একটি মান, কিন্তু imperative loop সেই নামকে বারবার বদলায়। ফল Python-এর [2, 2, 2] আর JavaScript-এর var-এ [3, 3, 3]. ভাষাগুলো এখানে নিয়ম বদলেছে: ES2015-এর let প্রতি ঘোরায় নতুন binding দেয়, C# 5 foreach-এর আচরণ বদলায়, আর Go 1.22 loop variable প্রতি ঘোরায় নতুন করে, যদিও এতে পুরোনো কোডের সঙ্গে সামঞ্জস্যের প্রশ্ন ছিল। Haat-এর নকশা-সিদ্ধান্ত ১৪-ও প্রতি ঘোরায় নতুন scope দেয়, তবে loop-এর বাইরের var ধরলে সে শেয়ারড থাকে, যা অংশ ৮-এ দেখেছেন।

দ্বিতীয়, method আর function মান: OO-তে method-এর অর্থ object-এর সঙ্গে বাঁধা, functional-এ function স্বাধীন মান। JavaScript-এ method তুলে নিলে this হারায়; arrow function আর bind এর উত্তর। Python প্রতিবার attribute পড়ার সময় একটি bound method বানিয়ে সমস্যাটি এড়ায়, আর C++-এ member function pointer একটি আলাদা type, যা object ছাড়া ডাকাই যায় না।

তৃতীয়, laziness আর side effect: Python-এর map lazy, তাই তার ভেতরের function কখন চলবে তা নির্ভর করে কে কখন মান চাইবে; side effect থাকলে তার ক্রম অপ্রত্যাশিত। আর C++-এ reference দিয়ে ধরা closure যদি variable-এর জীবনকালের বেশি টিকে থাকে, তাহলে dangling reference তৈরি হয়, যা undefined behavior; Rust এখানে borrow checker দিয়ে compile time-এই আটকায় (পর্ব ৭৬)।

মূল উপলব্ধি: ধাঁচ মেশানোর সবচেয়ে বড় ঝুঁকি দুই ধাঁচের অনুমানের সংঘর্ষ। সীমানাগুলো চিনে সেখানে immutable ডেটা আর স্পষ্ট নিয়ম রাখলে, আর প্রতিটি দাবি নির্দিষ্ট ভাষায় চালিয়ে দেখলে, বেশির ভাগ এমন bug আগেই ধরা পড়ে।

প্র ০৫উচ্চ-স্তরের ধাঁচ কি সবসময় গতির দাম দেয়? “zero-cost abstraction” কথাটির সত্য আর সীমা কী?

একটি সাধারণ বিশ্বাস: loop দ্রুত, map/filter/closure ধীর, কারণ প্রতিটি closure একটি function call আর হয়তো একটি heap object. CPython-এর মতো interpreter-এ এর কিছুটা সত্য, কারণ সেখানে প্রতিটি call-এর একটি নির্দিষ্ট খরচ আছে আর interpreter আগে থেকে closure-এর ভেতর দেখে না। কিন্তু optimizing compiler-এর জগতে ছবিটি আলাদা।

Bjarne Stroustrup C++-এর নকশায় “zero-overhead principle” রেখেছেন: যা ব্যবহার করেন না তার জন্য কোনো দাম নয়, আর যা ব্যবহার করেন তা হাতে লিখলে এর চেয়ে ভালো হতো না। এটি সম্ভব হয় কারণ compiler সব ধাঁচকে একই IR-এ নামায় (অংশ ৮), তারপর inlining দিয়ে closure-এর দেহ সরাসরি call-এর জায়গায় বসায়, আর loop optimization (পর্ব ৬৬) বাকি কাজ করে। Rust-এর iterator শিকল এই নীতির একটি পরিচিত উদাহরণ: optimizer চালু থাকলে iter().filter().map().sum() প্রায়ই হাতে লেখা loop-এর মতো machine code-এ নামে বলে Rust-এর documentation আর সম্প্রদায় উল্লেখ করে।

কিন্তু “zero-cost” একটি লক্ষ্য, প্রতিশ্রুতি নয়। Optimizer বন্ধ থাকলে (debug build) শিকলটি ধীর হতে পারে। Closure যদি একটি dynamic পথে আসে (virtual call, function pointer, Java-র interface) আর compiler তার লক্ষ্য জানতে না পারে, inlining হয় না। JIT-ভিত্তিক ভাষায় (Java, JavaScript) ফল নির্ভর করে চলার সময়ের profile-এর ওপর (পর্ব ৬১)। আর গতির বাইরে অন্য দামও থাকে: template বা generic-এর প্রতিটি রূপে নতুন কোড তৈরি হলে (monomorphization, পর্ব ৩৭) binary বড় হয় আর compile সময় বাড়ে।

তাই সৎ উত্তর হলো: “নির্ভর করে, আর মেপে দেখুন।” পরিমাপের দুটি উপায় এই কোর্সে শিখবেন: নিজের যন্ত্রে নিজের ডেটায় সময় মাপা (একটি যন্ত্রের মাপ সবার নিয়ম নয়), আর compiler-এর আসল আউটপুট পড়া, যেমন clang -O2 -S বা -emit-llvm (পর্ব ৬৮)। দুটির কোনোটি ছাড়া “এটি দ্রুত” দাবি শুধু অনুমান।

মূল উপলব্ধি: ধাঁচ source code-এর গুণ, গতি তৈরি হয় compiler আর runtime-এ। উচ্চ-স্তরের ধাঁচ তখনই সস্তা, যখন বাস্তবায়ন তার ভেতর দেখতে পায়; তা হচ্ছে কি না, আসল আউটপুট বলে দেয়।

অনুশীলন

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

  1. বাস্তবায়ন — Haat-এ নিয়ম জোড়া লাগানো: অংশ ৮-এর mixed.haat-এর policy আর district_total ব্যবহার করে একটি higher-order function best(a, b) লিখুন, যা দুটি নিয়ম নিয়ে একটি নতুন নিয়ম ফেরত দেয়: প্রতিটি মোটে দুটি নিয়মের মধ্যে যেটি গ্রাহকের জন্য কম দাম দেয়। eid = best(policy(10, 1000), policy(5, 150)) দিয়ে ঢাকা আর রাজশাহীর মোট, আর eid(1040) বের করুন। এটি কোন paradigm-এর কোন প্রক্রিয়া ব্যবহার করে?
    fn best(a: (Int) -> Int, b: (Int) -> Int) -> (Int) -> Int {
        return fn(t: Int) -> Int {
            let x = a(t);
            let y = b(t);
            if x < y { return x; }
            return y;
        };
    }
    let eid = best(policy(10, 1000), policy(5, 150));
    print(district_total("Dhaka", eid));
    print(district_total("Rajshahi", eid));
    print(eid(1040));

    Reference-এর run আর vm দুটিতেই আউটপুট: 2116, 513, 936. ঢাকার অর্ডারে: 1040-এ প্রথম নিয়ম 936, দ্বিতীয় 988, কম 936; 1100-এ 990 বনাম 1045, কম 990; 200-এ প্রথম নিয়ম প্রযোজ্য নয় (200), দ্বিতীয় 190; যোগ 936 + 990 + 190 = 2116. রাজশাহীর 540-এ প্রথম নিয়মে 540, দ্বিতীয়তে 540 − 27 = 513. best একটি higher-order function (function নেয়, function দেয়) আর ফেরত মানটি closure, যা a আর b ধরে রাখে: functional ধাঁচ। কিন্তু ব্যবহারে এটি OO-র “strategy” নকশার মতো: district_total জানে না কোন নিয়ম পেল, শুধু ডাকে। একই কাজ Python-এ একটি Policy class আর apply method দিয়েও হতো; closure-এ সেটি এক function-এ।

  2. ভুল খুঁজুন: একজন বললেন, “loop-টি ছোট করে sum(disc(q * u) for d, ls in orders if d == w for q, u in ls) লিখেছি; এটা তো একই হিসাব, শুধু functional.” (disc(t) মানে t ≥ 1000 হলে t − t // 10, নইলে t.) চারটি অর্ডারের ডেটায় (ঢাকা 2 × 520; রাজশাহী 3 × 120, 1 × 180; ঢাকা 4 × 150, 2 × 250; ঢাকা 5 × 40) ঢাকার জন্য দুই সংস্করণ কত দেয়? ভুলটি গাণিতিকভাবে কোথায়, আর কোন পরীক্ষা এটি দ্রুত ধরত?

    Python 3.14-এ চালানো ফল: আসল loop 2126, নতুন সংস্করণ 2236. লাইন ধরে হিসাব: 1040 → 936 (লাইন নিজেই ১০০০-এর ওপর), 600 → 600, 500 → 500, 200 → 200; যোগ 2236. আসল নিয়মে তৃতীয় অর্ডারের মোট 1100 ছাড় পায় (990), তাই 2126. ভুলটি একটি অনুমিত সূত্রে: disc(a + b) = disc(a) + disc(b). এটি মিথ্যা, কারণ disc একটি সীমা-নির্ভর (threshold) function: 600 আর 500 আলাদাভাবে সীমার নিচে, একসঙ্গে ওপরে। একই কারণে উল্টো ভুলও হয়, যখন সব লাইন একত্র করে ছাড় দেওয়া হয় অথচ নিয়ম প্রতি লাইনের। ধরার উপায়: পুরোনো আর নতুন সংস্করণের differential test, যেখানে ইনপুটে একাধিক লাইনের অর্ডার আছে। অংশ ৭-এর পরীক্ষা ২০০১টি ইনপুটের মাত্র ৯৫৩টিতে মিল পেয়েছিল। শুধু এক লাইনের অর্ডার দিয়ে পরীক্ষা করলে ভুলটি লুকিয়ে থাকত, তাই random ডেটার “আকার”ও (কয়টি লাইন) বৈচিত্র্যময় রাখা জরুরি।

  3. আউটপুট অনুমান করুন: (ক) Python 3.14-এ fs = [lambda: i * 10 for i in range(3)], তারপর print([f() for f in fs]). (খ) JavaScript-এ const a = []; for (var i = 0; i < 3; i++) a.push(() => i * 10); আর একই কোড let দিয়ে, প্রতিবার a.map(f => f()). (গ) অংশ ৮-এর mixed.haat-এ if i == 0-এর বদলে if i == 2 লিখলে own() আর shared() কী ছাপবে?

    (ক) [20, 20, 20]. তিনটি lambda একই i ধরে, যা comprehension শেষে 2; প্রতিটি 2 × 10 = 20 দেয়। lambda i=i: i * 10 লিখলে [0, 10, 20].

    (খ) var-এ [30, 30, 30]: function-জুড়ে একটি i, loop শেষে 3 (শেষ শর্ত পরীক্ষায় 3 < 3 মিথ্যা হয়ে থামে, তাই 2 নয়)। let-এ [0, 10, 20]: প্রতি ঘোরায় নতুন binding. Python-এর 20 আর JavaScript-এর 30-এর পার্থক্য খেয়াল করুন: Python-এর range শেষ মান 2-তেই থামে, C-ধাঁচের for variable-কে 3 পর্যন্ত বাড়িয়ে তারপর শর্ত পরীক্ষা করে।

    (গ) Reference-এ চালানো ফল: 2 আর 3. শেষ ঘোরায় (i = 2) তৈরি own সেই ঘোরার let j ধরে, যার মান 2; shared বাইরের var i ধরে, যা loop শেষে 3. তাই ক্রম বদলালেও shared() সবসময় 3: সে মান নয়, variable দেখে।

  4. প্রমাণ: সংজ্ঞা map f [] = [], map f (x:xs) = f x : map f xs; filter p [] = [], filter p (x:xs) = (p x হলে x : filter p xs, নইলে filter p xs) ধরে উপপাদ্য ১৩.১ প্রমাণ করুন: pure f আর p-এর জন্য filter p (map f xs) = map f (filter (p ∘ f) xs). কোথায় purity লাগল?

    xs-এর ওপর structural induction.

    1. ভিত্তি, xs = []: বাঁ দিক filter p (map f []) = filter p [] = []. ডান দিক map f (filter (p ∘ f) []) = map f [] = []. সমান।
    2. ধাপ: ধরি xs-এর জন্য দাবিটি সত্য (induction hypothesis). x:xs নিন। বাঁ দিক: filter p (map f (x:xs)) = filter p (f x : map f xs).
    3. ক্ষেত্র ১, p (f x) সত্য: বাঁ দিক = f x : filter p (map f xs). ডান দিক: (p ∘ f) x = p (f x) সত্য, তাই filter (p ∘ f) (x:xs) = x : filter (p ∘ f) xs, আর map করলে f x : map f (filter (p ∘ f) xs). Hypothesis দিয়ে দুই দিকের লেজ সমান, তাই দুই দিক সমান।
    4. ক্ষেত্র ২, p (f x) মিথ্যা: বাঁ দিক = filter p (map f xs); ডান দিক = map f (filter (p ∘ f) xs). Hypothesis অনুযায়ী সমান। ∎

    Purity লেগেছে দুই জায়গায়। ধাপ ৩-এ বাঁ দিকে f x একবার হিসাব হয়ে p পরীক্ষা করে, ডান দিকে f x দুবার (একবার p-এর ভেতরে, একবার map-এ); f pure না হলে দুই হিসাব আলাদা মান দিতে পারত, বা side effect দুবার ঘটত। আর “p (f x) সত্য” দুই দিকে একই ধরে নেওয়াও purity-র ওপর দাঁড়ানো। এই প্রমাণ অংশ ৭-এর অনুশীলনকে ন্যায্য করে: জেলা দিয়ে ছাঁকা আগে করলে ফল বদলায় না, কারণ মোট হিসাব জেলা বদলায় না আর সবকিছু pure.

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

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

ক্রমএকটি imperative loop-কে functional pipeline-এ নিরাপদে বদলানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. পুরোনো loop-কে “সত্যের উৎস” হিসেবে রেখে ফাঁকা, প্রান্তের আর random ইনপুট তৈরি করা
  2. Loop-এর ভেতরের হিসাব একটি pure function-এ বের করা
  3. বাকি accumulator loop-কে filter, map আর sum-এ বদলানো
  4. পুরোনো আর নতুন সংস্করণ সব ইনপুটে চালিয়ে মেলানো (differential test)
  5. পড়ার সুবিধা আর গতি নিজের ডেটায় মেপে সিদ্ধান্ত নেওয়া

“Multi-paradigm ভাষা” সম্পর্কে কোন কথাটি সবচেয়ে সঠিক?

  • যে ভাষায় কোনো paradigm অনুকরণ করা যায়, যেমন C (struct আর function pointer দিয়ে object)
  • যে ভাষা একাধিক paradigm-এর মূল প্রক্রিয়া (যেমন class, closure, বদলানো variable) ভাষার স্তরেই দেয়
  • যে ভাষা প্রতিটি paradigm সমান দক্ষতায় আর সমান খরচে দেয়
  • শুধু ২০১০-এর পরে তৈরি ভাষা, কারণ পুরোনো ভাষায় নতুন ধাঁচ যোগ করা যায় না

Python 3.14-এ fs = [lambda: i for i in range(3)] লিখে print([f() for f in fs]) চালালে কী ছাপা হয়?

  • [0, 1, 2]
  • [3, 3, 3]
  • [2, 2, 2]
  • NameError, কারণ i comprehension-এর বাইরে নেই

JavaScript-এ strict mode-এ class Order { constructor(l) { this.lines = l; } total() { return this.lines.length; } }, তারপর const f = new Order([1, 2]).total; f(); চালালে কী হয়?

  • TypeError, কারণ this হয় undefined
  • 2, কারণ method সবসময় নিজের object মনে রাখে
  • global object-এর lines পড়া হয়, ফল undefined
  • Syntax error, কারণ method-কে variable-এ রাখা যায় না

বাজারঘরের ছাড়ের নিয়ম বছরে কয়েকবার বদলায় (“মোট ≥ 1000 হলে ১০%”, “ঈদে ১৫%”, “ঢাকায় মোট < 1000 হলে ডেলিভারি 60”). কোন পদ্ধতি সবচেয়ে মানানসই?

  • প্রতিটি নিয়মের জন্য কোডে একটি নতুন if শাখা যোগ করা
  • সব হিসাব async/await দিয়ে লেখা
  • প্রতিটি নিয়মের জন্য একটি subclass বানিয়ে inheritance-এর গাছ তৈরি করা
  • নিয়মগুলো ডেটা হিসেবে (টেবিল বা query) রেখে একটি নিয়ম-চালক দিয়ে মেলানো

নিয়ম: “অর্ডারের মোট ≥ 1000 হলে মোট থেকে ১০% ছাড়”। একটি অর্ডারে দুটি লাইন: 600 আর 500 টাকা। কেউ লিখল sum(disc(x) for x in lines), যেখানে disc একটি সংখ্যায় নিয়মটি প্রয়োগ করে। ফল কত, আর সঠিক ফল কত?

  • দুটিই 990
  • ভুল সংস্করণ 1100, সঠিক 990
  • ভুল সংস্করণ 990, সঠিক 1100
  • ভুল সংস্করণ 990, সঠিক 990, শুধু লেখা আলাদা

Haat-এ (closure বাইরের variable by reference ধরে, আর while-এর দেহ প্রতি ঘোরায় নতুন scope) নিচের program কী ছাপে?
var i = 0; var a = fn() -> Int { return -1; }; var b = fn() -> Int { return -1; };
while i < 3 { let j = i; if i == 0 { a = fn() -> Int { return j; }; b = fn() -> Int { return i; }; } i = i + 1; }
print(a()); print(b());

  • 0 আর 0
  • 3 আর 3
  • 0 আর 3
  • Type error, কারণ var-এ function বসানো যায় না

SQL query SELECT district, SUM(t) FROM totals GROUP BY district কেন declarative ধাঁচের উদাহরণ?

  • এটি বলে কী ফল চাই, আর কোন ক্রমে বা কোন পথে হিসাব হবে তা database-এর optimizer ঠিক করে
  • এখানে প্রতিটি সারি একটি object, আর SUM একটি method
  • এটি একটি loop, যা প্রতি সারিতে একটি accumulator বদলায়
  • এটি সবসময় হাতে লেখা loop-এর চেয়ে দ্রুত চলে

শব্দকোষ

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

মনে রাখুন

  1. Multi-paradigm: ভাষা নিজেই একাধিক paradigm-এর প্রক্রিয়া দেয়; Python, JavaScript, C++, Java, Rust, Scala, Kotlin সবাই। প্রশ্ন “কোন ধাঁচ এখানে সস্তা আর স্বাভাবিক”, হ্যাঁ-না নয়।
  2. একই কাজ, একই উত্তর: বাজারঘরের ঢাকা 2126 imperative, OO, functional আর SQL-এ; পার্থক্য কে কোথায় অবস্থা রাখে তাতে। Mutation point গুনে মাপা যায় (৩, ৩, ০), তবে মাপের সীমা জেনে।
  3. সমস্যা দেখে ধাঁচ: রূপান্তরে functional, বদলানো অবস্থায় OO বা imperative, নিয়মে declarative, অপেক্ষায় async; সবচেয়ে কম ক্ষমতার যথেষ্ট মডেল বাছুন, আর সীমানায় immutable ডেটা।
  4. নিরাপদ refactoring: ছোট ধাপ, pure function বের করা, তারপর pipeline; প্রতিটি ধাপে differential test, আর সম্ভব হলে প্রমাণ (filter আর map-এর স্থান বদল)। disc(a + b) ≠ disc(a) + disc(b).
  5. মেশানোর ফাঁদ: closure variable ধরে, মান নয় (Python [2, 2, 2], JS var বনাম let, Haat 3 বনাম 0); method তুলে নিলে JavaScript-এ this হারায়। Compiler সব ধাঁচ একই IR-এ নামায়; গতির দাবি মেপে দেখুন।

পরের পর্বে: মডিউল ২ এখানেই শেষ। এই পর্বে বারবার প্রশ্ন উঠেছে “closure কোন variable ধরে”, “loop variable কোথায় বাঁধা”। পর্ব ১৪ থেকে মডিউল ৩ এর গোড়ায় যাবে: নাম, variable আর binding, আর একটি নাম কখন কোন জিনিসের সঙ্গে বাঁধা হয়।

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

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