Prototype Pattern: জিরো থেকে না বানিয়ে ফটোকপি করো

বিয়ের কার্ডের দোকানের গল্প

ধরো রহিম দশম শ্রেণিতে পড়ে। তার বড়ো আপু ফাতেমা আপু-র বিয়ে হচ্ছে ডিসেম্বরে। ফাতেমা আপু বিয়ে করছেন তারিক ভাইয়া-কে, আর পুরো বাড়ি উত্তেজনায় উলটপালট। রহিমের আব্বা তাকে একটাই কাজ দিলেন: "বাজারে করিম চাচার প্রিন্টিং দোকানে যা। আমাদের ৫০০টা বিয়ের কার্ড লাগবে।"

রহিম দোকানে গেল। করিম চাচা বিশ বছর ধরে এই ছোট্ট প্রিন্টিং আর ফটোকপির দোকান চালাচ্ছেন। তাঁর ছেলে রুবেল কলেজের পরে সাহায্য করে। এখন একটু ভাবো — করিম চাচা কি প্রতিটা কার্ড আলাদা করে ডিজাইন করেন? ৫০০ বার কাগজ বাছেন? ৫০০ বার ফুলের বর্ডার আঁকেন? পরিবারের নাম, ভেন্যু, তারিখ — এগুলো ৫০০ বার টাইপ করেন?

অবশ্যই না! সেটা করতে মাসের পর মাস লেগে যেত। আর ৩৮৭ নম্বর কার্ডে গিয়ে নিশ্চিত "তারিক"-কে "তারেক" লিখে ফেলতেন।

বরং করিম চাচা একটা চালাক কাজ করেন:

1. তিনি একটা নিখুঁত sample কার্ড তৈরি করেন। রহিমের পুরো পরিবার সেটা মনোযোগ দিয়ে দেখে — নাম, তারিখ, ভেন্যু, "সানরাইজ গার্ডেন, ঢাকা"-র বানান, সবকিছু।
2. সবাই "হ্যাঁ, এটা পারফেক্ট!" বললে, তিনি শুধু সেই sample-এর কপি বানান। মেশিন বোরিং কাজটা করে দেয়।
3. কিছু বিশেষ কার্ডের জন্য — বরের পরিবারের জন্য, VIP অতিথিদের জন্য — রুবেল একটা কপি নিয়ে এক-দুটো ছোট জিনিস বদলে দেয়। হয়তো সোনালি বর্ডার। হয়তো উপরে হাতে লেখা নাম।

এটাই হলো Prototype pattern। তুমি প্রতিটা object শূন্য থেকে বানাও না। একটা নিখুঁতভাবে তৈরি object রেখে দাও — prototype, যেমন sample কার্ড — আর নতুন একটা দরকার হলে সেটার কপি বানাও। কপিতে ছোট পরিবর্তন দরকার হলে শুধু সেই অংশটুকু বদলাও।

একই আইডিয়া দোকানের কোণের ফটোকপি মেশিনেও আছে। রহিমের যখন একটা ভরা school form-এর দশটা কপি দরকার, সে দশ বার হাতে লেখে না। একটা ভরা form মেশিনে দেয়, মেশিন বিশ্বস্ত কপি দিয়ে দেয়। মেশিনকে form-টা বুঝতে হয় না। শুধু কপি করতে হয়।

রহিমের পুরো সকালটা এভাবে দেখো:

এই দোকানটা মাথায় রাখো। রহিম, করিম চাচা, রুবেল আর sample কার্ড পুরো article জুড়ে আমাদের সাথে থাকবে — আর হ্যাঁ, আমরা এই দোকানটা কোডেও লিখব।

Prototype pattern আসলে কী?

Prototype pattern হলো একটা creational design pattern। "Creational" মানে এটা object কীভাবে তৈরি হয় তা নিয়ে।

সহজ সংজ্ঞাটা হলো:

Prototype তোমাকে একটা বিদ্যমান object কপি করে (যাকে prototype বলা হয়) নতুন object তৈরি করতে দেয় — new দিয়ে শূন্য থেকে অনেক setup কোড লিখে বানানোর বদলে। কপি করার logic টা object-এর ভেতরেই থাকে, সাধারণত clone() নামের একটা method-এ।

তিনটা ছোট আইডিয়া আছে এখানে:

• Object নিজেই নিজেকে কপি করে। তুমি বাইরে দাঁড়িয়ে field by field কপি করো না। Object-কে বলো, "আমাকে তোমার একটা কপি দাও," আর সে কাজটা করে দেয়। Object নিজের private তথ্য জানে, তাই তার কপি সম্পূর্ণ হয়। করিম চাচা তাঁর কার্ড সবচেয়ে ভালো জানেন — রহিমকে জানতে হয় না কোন কাগজ বা কালি ব্যবহার হয়েছে।
• Caller-কে exact class জানতে হয় না। তুমি যদি কিছু সাধারণ Card হিসেবে ধরে রাখো, তুমি card.clone() ডাকতে পারবে আর সঠিক ধরনের কার্ড পাবে — এমনকি সেটা গোপনে একটা VipCard হলেও। রহিম শুধু বলে "এটা কপি করো", কখনো জিজ্ঞেস করে না "এটা offset print নাকি digital print?"
• Clone করার পরে adjust করা যায়। আগে clone করো, তারপর যে এক-দুটো field আলাদা সেগুলো বদলাও। যেমন রুবেলের সোনালি বর্ডার।

Pattern টাকে Clone-ও বলা হয়, কারণটা স্পষ্ট। এটা বিখ্যাত Design Patterns বইয়ের মূল ২৩টা pattern-এর একটা, Gang of Four (Gamma, Helm, Johnson আর Vlissides, ১৯৯৪) লিখেছিলেন।

কলেজ কর্নার: GoF-এর ভাষায়, Prototype class-based creation-এর বদলে object-based creation করে। তোমার কোড concrete constructor-এর উপর নির্ভর না করে clone() সহ একটা interface-এর উপর নির্ভর করে — এটা Dependency Inversion Principle মেনে চলে। এটা subclass explosion-ও কমায়: প্রতিটা configuration-এর জন্য আলাদা subclass না বানিয়ে, তুমি প্রতিটা configuration-এর জন্য একটা configured instance রাখো।

এটা কোন সমস্যা সমাধান করে

আগে ব্যথাটা অনুভব করা যাক। ধরো Prototype pattern নেই, আর আমাদের প্রথমটার মতো হুবহু একটা দ্বিতীয় কার্ড দরকার। "সহজ" উপায় হলো নতুন object বানিয়ে হাতে হাতে প্রতিটা field কপি করা:

// কষ্টের, হাতে কপি করার উপায় — এটা করো না!
const original = new WeddingCard("Fatima weds Tariq", "Dhaka", "12 Dec 2026");
 
const copy = new WeddingCard(
  original.coupleNames,  // field 1 কপি
  original.venue,        // field 2 কপি
  original.date          // field 3 কপি
);
// ...আর field 4, 5, 6... কোনোটা ভুলিনি তো!

তিনটা field-এর জন্য ঠিকঠাক লাগছে। কিন্তু বাস্তব object এত ছোট হয় না। দেখো কোথায় এই approach ভেঙে পড়ে:

1. Exact class জানতে হবে। new WeddingCard(...) লিখতে গেলে, তোমার কোড সেই specific class-এর সাথে আটকে গেল। যদি তুমি শুধু একটা variable Card হিসেবে ধরে থাকো, আর জানো না এটা WeddingCard নাকি BirthdayCard? তাহলে প্রতিটা type-এর জন্য বাজে if-else check লিখতে হবে।
2. Private field দেখা যায় না। অনেক object private field-এ গোপন internal state রাখে। বাইরের কোড সেগুলো পড়তে পারে না। তাই তোমার হাতে-বানানো কপি সবসময় অসম্পূর্ণ থাকবে — দুই পাতার form-এর শুধু সামনের পাতা ফটোকপি করার মতো।
3. Setup ব্যয়বহুল হতে পারে। হয়তো আসল object টা database call, network request বা ভারী calculation-এর মাধ্যমে তৈরি হয়েছিল। শূন্য থেকে দ্বিতীয়টা বানানো সেই পুরো খরচ আবার করে। খাবার টেবিলে থাকতে আবার কেন রান্না করবে?
4. একটা field ভুলে যাওয়া সহজ। কাল কেউ class-এ ৭ নম্বর field যোগ করল কিন্তু তোমার কপি কোড update করতে ভুলে গেল। এখন তোমার কপিগুলো চুপচাপ ভুল হয়ে যাচ্ছে। এই bug গুলো খুঁজে পাওয়া অনেক কঠিন।

শূন্য থেকে একটা সমৃদ্ধ object বানাতে সময় কোথায় যায়? মোটামুটি এরকম:

Cloning প্রায় সবটাই বাদ দিয়ে দেয়, কারণ load করা data আর computed field গুলো ইতিমধ্যে sample-এর ভেতরে বসে আছে। সিদ্ধান্তটা একটা ছবিতে দেখো:

Prototype pattern বলে: বাইরে থেকে কপি করা বন্ধ করো। class-এর ভেতরে একটা clone() method রাখো। Object নিজের সব field-এ — এমনকি private গুলোতেও — সম্পূর্ণ access পায়, তাই সে নিখুঁত কপি বানাতে পারে। Caller শুধু original.clone() বলে শেষ।

আর সাশ্রয়টা ছোট না। একটা কার্ড শূন্য থেকে তৈরি করতে যদি ভারী setup লাগে, cloning-এ শুধু একটা memory copy লাগে:

সংখ্যাগুলো তোমার program-এর উপর নির্ভর করে, কিন্তু এই chart-এর আকারটা খুব common: একবার বানাও, অনেকবার clone করো, অনেক সাশ্রয় করো।

কীভাবে কাজ করে, ধাপে ধাপে

এই হলো standard recipe। ছোট, আর যেকোনো ভাষায় follow করতে পারবে:

1. একটা common interface তৈরি করো একটা method দিয়ে: clone()। যে class কপিযোগ্য হতে চায় সে এই interface implement করে।
2. প্রতিটা class-এ একটা copy constructor (বা copy logic) লেখো। এই constructor একই class-এর আরেকটা object নিয়ে তার সব field কপি করে। child class-এ, inherited field গুলোও কপি হওয়ার জন্য আগে parent-এর copy logic ডাকো।
3. clone() implement করো new SameClass(this) return করতে। প্রতিটা class তার নিজের type-এ clone করে। তাই একটা plain Card variable দিয়ে VipCard clone করলেও আসল VipCard পাওয়া যায়।
4. প্রতিটা reference field-এর জন্য shallow বা deep সিদ্ধান্ত নাও। যদি একটা field আরেকটা object-এর দিকে point করে, তোমাকে বেছে নিতে হবে: সেই object share করবে (shallow) নাকি সেটাও কপি করবে (deep)? এটাই পুরো pattern-এর সবচেয়ে গুরুত্বপূর্ণ সিদ্ধান্ত। নিচের কোডে পরিষ্কার দেখব।
5. (Optional) একটা prototype registry তৈরি করো। এটা একটা ছোট catalogue — করিম চাচার counter-এর পেছনে sample কার্ডের তাকের মতো। নাম দিয়ে ready-made prototype register করো ("simple-card", "vip-card"), আর client registry-কে জিজ্ঞেস করে: "আমাকে vip-card-এর একটা তাজা কপি দাও।"

লক্ষ্য করো registry sample ধরে রাখে আর সবসময় clone return করে। তাকের sample গুলো কখনো দোকান ছেড়ে যায় না — ঠিক যেমন করিম চাচা তাঁর master কার্ড কাউকে দিয়ে দেন না।

Client আর prototype-এর মধ্যে কথোপকথন ছোট — এটাই সৌন্দর্য:

একটা sample কার্ডেরও একটা ছোট জীবন আছে। একবার তৈরি হয়, একবার approval পায়, তারপর সারাজীবন clone হতে থাকে:

চিত্র ৭-এর loop টা মনোযোগ দিয়ে পড়ো। প্রতিটা clone() call Cloning-এর মধ্য দিয়ে যায় আর একটা CopyReady object তৈরি করে, কিন্তু sample নিজে সবসময় নিরাপদে SampleReady-তে ফিরে আসে। যদি কোনো clone কখনো sample নষ্ট করে দেয়, তোমার pattern ভেঙে গেছে — shallow copy section-এ দেখব ঠিক কীভাবে এই দুর্ঘটনা ঘটে।

TypeScript-এ বিয়ের কার্ডের দোকান: real কোড উদাহরণ

পুরো দোকানটা বানাই। Comment গুলো ধীরে ধীরে পড়ো — প্রতিটা ধাপ বুঝিয়ে দেওয়া হয়েছে।

// Step 1: the common interface. Anything copyable has clone().
interface CardPrototype {
  clone(): CardPrototype;
}
 
// A small nested object: the visual design of the card.
// This will help us understand shallow vs deep copy.
class Design {
  constructor(
    public borderColor: string,
    public font: string
  ) {}
 
  // The design knows how to copy itself too.
  clone(): Design {
    return new Design(this.borderColor, this.font);
  }
}
 
// Step 2 + 3: the concrete prototype with a copy constructor.
class WeddingCard implements CardPrototype {
  coupleNames: string;
  venue: string;
  date: string;
  design: Design; // reference field — careful here!
 
  constructor(coupleNames: string, venue: string, date: string, design: Design) {
    this.coupleNames = coupleNames;
    this.venue = venue;
    this.date = date;
    this.design = design;
  }
 
  // clone() builds a new WeddingCard from "this".
  clone(): WeddingCard {
    return new WeddingCard(
      this.coupleNames,      // string: copied by value, safe
      this.venue,            // string: safe
      this.date,             // string: safe
      this.design.clone()    // DEEP copy of the nested design!
    );
  }
 
  describe(): string {
    return `${this.coupleNames} | ${this.venue} | ${this.date} ` +
           `| border: ${this.design.borderColor}, font: ${this.design.font}`;
  }
}

এখন registry — counter-এর পেছনে sample কার্ডের তাক:

// Step 5: the prototype registry (the sample shelf).
class CardRegistry {
  private samples = new Map<string, CardPrototype>();
 
  register(name: string, sample: CardPrototype): void {
    this.samples.set(name, sample);
  }
 
  // Never hand out the sample itself — always a fresh clone!
  get(name: string): CardPrototype {
    const sample = this.samples.get(name);
    if (!sample) throw new Error(`No sample named "${name}"`);
    return sample.clone();
  }
}
 
// ---------- Client code: a day in the shop ----------
 
// করিম চাচা একটাই নিখুঁত sample তৈরি করেন।
const sample = new WeddingCard(
  "Fatima weds Tariq",
  "Sunrise Garden, Dhaka",
  "12 Dec 2026",
  new Design("maroon", "Devanagari Classic")
);
 
const registry = new CardRegistry();
registry.register("fatima-tariq", sample);
 
// রহিমের পরিবার কার্ড অর্ডার করে। প্রতিটা অর্ডার = একটা clone।
const card1 = registry.get("fatima-tariq") as WeddingCard;
const card2 = registry.get("fatima-tariq") as WeddingCard;
 
// একজন VIP অতিথি সোনালি বর্ডার চান। রুবেল শুধু কপিটা বদলায়।
card2.design.borderColor = "golden";
 
console.log("Card 1:", card1.describe());
console.log("Card 2:", card2.describe());
console.log("Sample:", sample.describe());

প্রত্যাশিত output:

Card 1: Fatima weds Tariq | Sunrise Garden, Dhaka | 12 Dec 2026 | border: maroon, font: Devanagari Classic
Card 2: Fatima weds Tariq | Sunrise Garden, Dhaka | 12 Dec 2026 | border: golden, font: Devanagari Classic
Sample: Fatima weds Tariq | Sunrise Garden, Dhaka | 12 Dec 2026 | border: maroon, font: Devanagari Classic

চমৎকার! Card 2 সোনালি বর্ডার পেল, কিন্তু Card 1 আর master sample maroon-ই রইল। প্রতিটা কপি স্বাধীন। করিম চাচার তাক নিরাপদ।

Shallow copy-এর ফাঁদ — live demo

এখন পুরো article-এর সবচেয়ে গুরুত্বপূর্ণ অংশ। যদি clone() অলস হয়ে design share করত কপি না করে? এটাকে বলে shallow copy:

// একটা ভুল clone — design-এর shallow copy।
clone(): WeddingCard {
  return new WeddingCard(
    this.coupleNames,
    this.venue,
    this.date,
    this.design        // ⚠️ একই Design object SHARED!
  );
}

এই version দিয়ে, একই client কোড চালাও:

Card 1: ... | border: golden, font: Devanagari Classic   ← বদলে গেছে!
Card 2: ... | border: golden, font: Devanagari Classic
Sample: ... | border: golden, font: Devanagari Classic   ← master-ও বদলে গেছে!

বিপর্যয়! রুবেল Card 2-এর বর্ডার বদলাল, কিন্তু Card 1 আর master sample-ও সোনালি হয়ে গেল। একটু ভাবো — করিম চাচার মুখের অবস্থা কী হবে: এক অতিথি সোনালি চাইলেন, আর এখন দোকানের প্রতিটা ভবিষ্যৎ কার্ড সোনালি প্রিন্ট হচ্ছে। কেন হলো? কারণ তিনটা কার্ডই memory-তে একই single Design object-এর দিকে point করছিল। আমরা কার্ড ফটোকপি করলাম কিন্তু সব কপি একটাই share করা design sheet-এ staple করে দিলাম।

এই ছবিটা দেখায় উভয় ক্ষেত্রে memory-তে কী বসে আছে:

সহজ কথায় নিয়মটা হলো:

• Shallow copy = শুধু উপরের বাক্স কপি করো। ভেতরের nested object গুলো তখনও share। দ্রুত, কিন্তু mutable nested object-এর জন্য ঝুঁকিপূর্ণ।
• Deep copy = বাক্স আর তার ভেতরের সব কিছু, একদম নিচ পর্যন্ত কপি করো। Clone সম্পূর্ণ স্বাধীন হয়ে যায়।

একটা ভালো clone() সাধারণত মিশ্রণ: সহজ মান সরাসরি কপি করো, immutable জিনিস share করো, আর যে mutable object সত্যিই এই object-এর নিজের তা deep-copy করো। Field by field সিদ্ধান্ত নাও, আর প্রতিটা সিদ্ধান্তের জন্য একটা ছোট comment লেখো।

কলেজ কর্নার — copy semantics ঠিকমতো: আমরা যাকে সহজে "deep copy" বলি সেটা আসলে object graph traversal-এর একটা প্রশ্ন। একটা পূর্ণ deep copy হলো reachable graph-এর উপর একটা recursive walk, আর তিনটা কঠিন case আসে। (১) Cycles: যদি A, B-কে point করে আর B আবার A-কে, naive recursion কখনো শেষ হয় না; Python-এর copy.deepcopy-এর মতো বাস্তব implementation একটা memo dictionary রাখে যেটা ইতিমধ্যে কপি করা id-গুলো তাদের copy-তে map করে। (২) Aliasing: যদি দুটো field একই object-কে point করে, একটা সঠিক deep copy-কে সেই sharing clone-এর ভেতরে preserve করতে হবে। (৩) Identity vs equality: একটা সঠিক deep copy-র পরে, clone == original সত্য হতে পারে (সমান মান) কিন্তু clone is original মিথ্যা (আলাদা identity) — আর এটা recursively ধরে রাখতে হবে। JavaScript-এর structuredClone cycle handle করে কিন্তু function আর class method কপি করতে পারে না। Trust করার আগে তোমার language-এর default জানো।

Python-এ একই আইডিয়া

Python-এ Prototype খুব সুন্দর, কারণ standard library-তে copy module তৈরিই আছে উভয় ধরনের copy সহ।

import copy
 
class Design:
    def __init__(self, border_color: str, font: str):
        self.border_color = border_color
        self.font = font
 
class WeddingCard:
    def __init__(self, couple, venue, date, design: Design):
        self.couple = couple
        self.venue = venue
        self.date = date
        self.design = design
 
    def clone(self) -> "WeddingCard":
        # deepcopy walks the whole object and copies
        # every nested mutable object too.
        return copy.deepcopy(self)
 
sample = WeddingCard(
    "Fatima weds Tariq",
    "Sunrise Garden, Dhaka",
    "12 Dec 2026",
    Design("maroon", "Devanagari Classic"),
)
 
vip_card = sample.clone()
vip_card.design.border_color = "golden"
 
print(sample.design.border_color)    # maroon  ← master নিরাপদ!
print(vip_card.design.border_color)  # golden

Python-এর copy module থেকে মনে রাখার দুটো function:

• copy.copy(x) → shallow copy (শুধু উপরের level)।
• copy.deepcopy(x) → deep copy (সবকিছু, recursively; এটা নিজেদের দিকে point করা object-ও handle করে, কলেজ কর্নারে দেখা memo dictionary-র কারণে)।

তুমি class-এ __copy__ আর __deepcopy__ method লিখে copying customize করতে পারো — এটাই Python-এর Prototype pattern-এর official hook। ব্যবহার করো যখন কিছু field share করতে হবে (একটা logger, একটা cache) deep copy-এর সময়ও।

বাস্তব software-এ যেখানে দেখা যায়

এই pattern শুধু পাঠ্যবইয়ের গল্প না। প্রতিদিনই এটার সাথে দেখা হয়:

• JavaScript-এর structuredClone()। আধুনিক browser আর Node.js (17+)-এ একটা built-in deep copy function আছে। এটা Date, Map, Set, typed array, এমনকি circular reference সহ object-ও সঠিকভাবে কপি করে — যেটা পুরনো JSON.parse(JSON.stringify(x)) কৌশল নষ্ট করে দেয়। যখন একটা web app undo history রাখে state snapshot করে, এটা Prototype করছে।
• Python-এর copy.deepcopy()। ডেটা science (tweak করার আগে model configuration কপি করা) থেকে game পর্যন্ত সর্বত্র ব্যবহার হয়। python-patterns repository-তে registry/dispatcher সহ একটা পরিষ্কার Prototype উদাহরণ আছে।
• Game development — object spawn করা। একটা game প্রতিটা enemy শূন্য থেকে বানায় না। একটা পুরোপুরি তৈরি enemy template রাখে (model, sound, default health) আর নতুন enemy আসলে clone করে। Unity-র Instantiate(prefab) ঠিক এই আইডিয়া: prefab হলো prototype, আর game প্রতি সেকেন্ডে ষাটবার clone করতে পারে।
• Document আর graphics editor। Presentation software-এ "Duplicate slide", Photoshop-এ "duplicate layer", আঁকা shape copy-paste — প্রতিটা duplicate একটা configured object-এর clone। লক্ষ্য করো duplicated slide স্বাধীন: edit করলে আসলটা বদলায় না। কেউ তোমার জন্য একটা সাবধানী deep copy implement করেছে।
• Java-র Cloneable / copy constructor। Java-তে language-এর শুরু থেকেই cloning আছে। iluwatar/java-design-patterns repository-তে একটা পরিষ্কার আধুনিক Prototype উদাহরণ আছে যেটা দশ মিনিটে পড়তে পারবে।
• JS object system নিজেই। JavaScript আক্ষরিক অর্থে একটা prototype-based ভাষা: object গুলো prototype chain-এর মাধ্যমে অন্য object থেকে inherit করে, আর Object.create(proto) একটা বিদ্যমান object-এর উপর ভিত্তি করে নতুন object বানায়। নামটা coincidence না — language design একই আইডিয়া ধার করেছিল।

কখন ব্যবহার করব আর কখন না

যদি একটা ছবি দিয়ে সিদ্ধান্ত নিতে চাও, তোমার case এই map-এ রাখো। Prototype উপর-ডানের কোণে সবচেয়ে ভালো — ব্যয়বহুল object, অনেক কপি দরকার:

ছাত্রছাত্রীরা যে সাধারণ ভুলগুলো করে

আত্মীয় pattern গুলোর সাথে তুলনা

Prototype পাঁচটা classic creational pattern-এর একটা। এর পাশে আত্মীয়রা কীভাবে দাঁড়ায়:

Gang of Four বইয়ের একটা মজার তথ্য: design প্রায়ই Factory Method দিয়ে শুরু হয় (সহজ, কিন্তু subclass লাগে) আর আরো flexibility দরকার হলে Abstract Factory বা Prototype-এর দিকে বাড়ে।

এক নজরে পুরো landscape review করতে, এই mind map দেখো:

দ্রুত revision বক্স

+-------------------------------------------------------------+
|                  PROTOTYPE PATTERN — REVISION               |
+-------------------------------------------------------------+
| Idea       : Make new objects by COPYING a sample object    |
| Nickname   : Clone ("the xerox pattern")                    |
| Key method : clone() — lives INSIDE the object              |
| Story      : One perfect wedding card -> 500 copies         |
|                                                             |
| Steps      : 1. Interface with clone()                      |
|              2. Copy constructor in each class              |
|              3. clone() returns new SameClass(this)         |
|              4. Decide SHALLOW vs DEEP per field            |
|              5. Optional: registry of named samples         |
|                                                             |
| Shallow    : top level only, nested objects SHARED  ⚠️      |
| Deep       : nested objects copied too, fully independent ✅ |
|                                                             |
| Use when   : creation is costly; many similar objects;      |
|              cannot depend on concrete classes              |
| Avoid when : tiny cheap objects; live connections/handles   |
| Real world : structuredClone(), copy.deepcopy(),            |
|              game prefabs, "duplicate slide"                |
+-------------------------------------------------------------+

নিজে করে দেখো

নিজে নিজে এই কাজগুলো করে দেখো। সহজ থেকে একটু কঠিনের দিকে যাচ্ছে — রহিম-লেভেল থেকে রুবেল-লেভেল।

1. স্কুল ID কার্ড মেশিন। একটা StudentIdCard class তৈরি করো name, className, rollNumber, আর একটা nested SchoolInfo object সহ (স্কুলের নাম, ঠিকানা, principal-এর নাম)। ১,২০০ ছাত্রছাত্রী একই school info share করে, কিন্তু প্রতিটা কার্ডে ভিন্ন নাম আর roll নম্বর। clone() implement করো যাতে SchoolInfo share হয় (shallow — এটা প্রতি ছাত্রের জন্য বদলায় না) কিন্তু বাকিটা কপি হয়। তারপর এক বাক্যে বলো কেন এখানে share করাটাই সঠিক ছিল।

2. Bug ধরো। একটা TiffinBox class লেখো যাতে compartments array আছে যেমন roti, sabzi, pickle। একটা ভুল shallow clone() implement করো, box clone করো, কপির pickle "sweet"-এ বদলাও, আর bug টা দেখাতে দুটো box print করো। তারপর array-এর proper deep copy দিয়ে clone() ঠিক করো আর corrected output দেখাও।

3. Mehendi design registry। একটা DesignRegistry তৈরি করো যেটা তিনটা prototype mehendi pattern ("bridal", "simple", "arabic") store করে, প্রতিটায় একটা nested Pricing object। Client registry.get("bridal") ডাকে আর সবসময় স্বাধীন clone পাবে। একটা test দিয়ে prove করো: "bridal"-এর দুটো clone নাও, একটার দাম বাড়াও, আর assert করো অন্য clone আর registry-র master অপরিবর্তিত।

4. কলেজ কর্নারের challenge। দুটো card object বানাও যেগুলো পরস্পরকে point করে (card A-এর field partnerCard হলো B, আর B-এর হলো A)। একটা naive recursive deep copy লেখো আর দেখো এটা চিরকাল recurse করে। তারপর object identity দিয়ে key করা একটা memo map দিয়ে ঠিক করো — copy.deepcopy-এর মতো একই কৌশল। লিখে রাখো কেন memo shared reference-ও সঠিকভাবে preserve করে।

যদি তুমি এই article-এ ফিরে না তাকিয়ে ৩ নম্বর কাজ শেষ করতে পারো, তুমি Prototype সত্যিই বুঝে ফেলেছ। বেশ হয়েছে — একটু বিশ্রাম নাও। করিম চাচা তোমাকে চা দিতেন।