പ്രോട്ടോടൈപ്പ് അടിസ്ഥാനമാക്കിയുള്ള പ്രോഗ്രാമിംഗ്

പ്രോട്ടോടൈപ്പ് അധിഷ്ഠിത പ്രോഗ്രാമിംഗ് ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗാണ്, അതിൽ പ്രോട്ടോടൈപ്പുകളായി പ്രവർത്തിക്കുന്ന ഡെലിഗേഷൻ വഴി നിലവിലുള്ള ഒബ്ജക്റ്റുകൾ വീണ്ടും ഉപയോഗിക്കുന്ന പ്രക്രിയയിലൂടെ പുനരുപയോഗം (ഇൻഹെറിറ്റൻസ് എന്നറിയപ്പെടുന്നു) നടത്തുന്നു. ഈ മോഡലിനെ പ്രോട്ടോടൈപ്പ്, പ്രോട്ടോടൈപ്പ്-ഓറിയന്റഡ്, ക്ലാസ്ലെസ്സ് അല്ലെങ്കിൽ ഇൻസ്റ്റൻസ് ബേസ്ഡ് പ്രോഗ്രാമിംഗ് എന്നും പറയാം. പ്രോട്ടോടൈപ്പ് അടിസ്ഥാനമാക്കിയുള്ള പ്രോഗ്രാമിംഗിനെ പിന്തുണയ്ക്കുന്ന ഭാഷാ സവിശേഷതയാണ് ഡെലിഗേഷൻ.^[1]

prototype pattern  അല്ലെങ്കിൽ Software prototyping എന്നീ ലേഖനങ്ങളുമായി ആശയക്കുഴപ്പം ഒഴിവാക്കുക.  

പ്രോട്ടോടൈപ്പ് അടിസ്ഥാനമാക്കിയുള്ള പ്രോഗ്രാമിംഗ് സാധാരണയായി ഒബ്‌ജക്റ്റുകളുടെ പ്രോട്ടോടൈപ്പുകൾ ഉപയോഗിക്കുന്നു, അവയെ ക്ലോൺ ചെയ്യാനും വിപുലീകരിക്കാനും കഴിയും. ഉദാഹരണമായി, "ഫ്രൂട്ട്" (പഴം) എന്ന ഒബ്‌ജക്റ്റ് പൊതുവെ പഴത്തിന്റെ ഗുണങ്ങൾക്കും പ്രവർത്തനങ്ങൾക്കും പ്രതിനിധാനം ചെയ്യുന്നതാണ്. ഒരു "പഴം" വസ്തുവിൽ നിന്ന് "വാഴപ്പഴം" എന്ന പുതിയ വസ്തുവിനെ ക്ലോൺ ചെയ്താൽ, "വാഴപ്പഴം" അതിന്റെ പ്രത്യേക സവിശേഷതകൾ ചേർക്കാം.

പ്രോട്ടോട്ടൈപ്പ് അടിസ്ഥാനത്തിലുള്ള പ്രോഗ്രാമിങ്ങും ക്ലാസ് അടിസ്ഥാനത്തിലുള്ള പ്രോഗ്രാമിങ്ങും എങ്ങനെ വ്യത്യാസപ്പെടുന്നു എന്ന് നോക്കാം. ഉദാഹരണത്തിന്: പ്രോട്ടോടൈപ്പ് ഉപയോഗിച്ച് ഒരു ഒബ്‌ജക്റ്റ് മറ്റൊരു ഒബ്‌ജക്റ്റ് ക്ലോൺ ചെയ്യുന്നതിനെയാണ് പ്രോട്ടോടൈപ്പ് അടിസ്ഥാനമാക്കിയുള്ള പ്രോഗ്രാമിംഗ് എന്നു പറയുന്നത്. ഈ രീതിയിൽ ക്ലാസുകൾ ഇല്ല. ഓരോ ഒബ്‌ജക്റ്റ് മറ്റൊരു ഒബ്‌ജക്റ്റിന്റെ പ്രോട്ടോടൈപ്പ് ആയി പ്രവർത്തിക്കുന്നു.

// "ഫ്രൂട്ട്" പ്രോട്ടോടൈപ്പ് നിർവ്വചിക്കാം
let fruit = {
  type: "Fruit",
  getType: function() {
    return this.type;
  }
};

// "ബാനാന" ഒബ്‌ജക്റ്റ് "ഫ്രൂട്ട്" പ്രോട്ടോടൈപ്പിൽ നിന്ന് ക്ലോൺ ചെയ്യുന്നു
let banana = Object.create(fruit);
banana.type = "Banana"; // ഒബജക്ടിന്റെ ടൈപ്പ് മാറ്റുന്നു

console.log(banana.getType()); // Output: Banana

"ഫ്രൂട്ട്" ഒരു പ്രോട്ടോടൈപ്പ് ആണ്. "ബാനാന" ഈ പ്രോട്ടോടൈപ്പ് ഉപയോഗിച്ച് സൃഷ്ടിക്കപ്പെട്ട ഒരു ഒബ്‌ജക്റ്റ് ആണ്. ഇൻഹെറിറ്റൻസ് (inheritance) ഇതിൽ പ്രോട്ടോടൈപ്പ് വഴി നടക്കുന്നു.

ക്ലാസ് അടിസ്ഥാനമായ പ്രോഗ്രാമിംഗ് (Class-based) ക്ലാസ് ഉപയോഗിച്ച് ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്ടിക്കാൻ, ഞങ്ങൾ ആദ്യം ഒരു ക്ലാസ് നിർവ്വചിച്ച്, ശേഷം ആ ക്ലാസ്സിന്റെ ഇൻസ്റ്റാൻസ് സൃഷ്ടിക്കുന്നു. ക്ലാസുകൾ പേരും പ്രവർത്തനവും (methods) നിശ്ചയിച്ചിരിക്കുന്നു. ഉദാഹരണം:

// "ഫ്രൂട്ട്" ക്ലാസ് നിർവ്വചിക്കാം
class Fruit {
  constructor() {
    this.type = "Fruit";
  }

  getType() {
    return this.type;
  }
}

// "ഫ്രൂട്ട്" ക്ലാസ്സിന്റെ ഒരു ഇൻസ്റ്റാൻസ് സൃഷ്ടിക്കുന്നു
let fruit = new Fruit();
console.log(fruit.getType()); // Output: Fruit

// "ബാനാന" ക്ലാസ്, "ഫ്രൂട്ട്" ക്ലാസ്സിനെ എക്സ്റ്റൻഡ് ചെയ്യുന്നു
class Banana extends Fruit {
  constructor() {
    super(); // "ഫ്രൂട്ട്" ക്ലാസ്സ് കൊണ്ടുവരുന്നു
    this.type = "Banana";
  }
}

let banana = new Banana();
console.log(banana.getType()); // Output: Banana

"ഫ്രൂട്ട്" ഒരു ക്ലാസ് ആണ്. "ബാനാന" "ഫ്രൂട്ട്" ക്ലാസ്സിൽ നിന്നും വികസിപ്പിച്ച (extend) ഒരു ക്ലാസ് ആണ്. ഇൻഹെറിന്റൻസ് (inheritance) ക്ലാസുകൾ ഉപയോഗിച്ച് ആണ് നടക്കുന്നത്.

ആദ്യത്തെ പ്രോട്ടോടൈപ്പ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് ഭാഷ സെൽഫ് ആയിരുന്നു, 1980 കളുടെ മധ്യത്തിൽ ഡേവിഡ് ഉങ്കറും റാൻ‌ഡാൽ സ്മിത്തും ചേർന്ന് ഒബ്ജക്റ്റ്-ഓറിയെന്റഡ് ഭാഷാ രൂപകൽപ്പനയിലെ ഗവേഷണ വിഷയങ്ങൾക്കായി വികസിപ്പിച്ചെടുത്തു. 1990 കളുടെ അവസാനം മുതൽ ക്ലാസില്ലാത്ത മാതൃക കൂടുതൽ പ്രചാരം നേടി. നിലവിലെ ചില പ്രോട്ടോടൈപ്പ് അധിഷ്ഠിത ഭാഷകൾ ജാവാസ്ക്രിപ്റ്റ് (കൂടാതെ ജെസി‌ക്രിപ്റ്റ്, ഫ്ലാഷിന്റെ ആക്ഷൻ സ്ക്രിപ്റ്റ് 1.0 പോലുള്ള മറ്റ് ഇഗ്മാസ്ക്രിപ്റ്റ് നടപ്പാക്കലുകൾ), ലൂഅ, സെസിൽ, ന്യൂട്ടൺ‌സ്ക്രിപ്റ്റ്, അയോ, അയോക്ക്, മൂ(MOO), റിബോൾ(REBOL), എഎച്ച്കെ(AHK) എന്നിവയാണ്.

രൂപകൽപ്പനയും നടപ്പാക്കലും

ജാവാസ്ക്രിപ്റ്റിലെ പ്രോട്ടോടൈപ്പൽ ഇൻഹെറിറ്റൻസിനെ ഡഗ്ലസ് ക്രോക്ക്ഫോർഡ് ഇപ്രകാരം വിവരിക്കുന്നു:

നിങ്ങൾ പ്രോട്ടോടൈപ്പ് ഒബ്‌ജക്റ്റുകൾ നിർമ്മിക്കുന്നു, തുടർന്ന്… പുതിയ ഉദാഹരണങ്ങൾ സൃഷ്ടിക്കുക. ഒബ്‌ജക്റ്റുകൾ ജാവാസ്ക്രിപ്റ്റിൽ മാറ്റാവുന്നവയാണ്, അതിനാൽ നമുക്ക് പുതിയ സംഭവങ്ങൾ വർദ്ധിപ്പിക്കാനും പുതിയ ഫീൽഡുകളും രീതികളും നൽകാനും കഴിയും. ഇവയ്‌ക്ക് പിന്നീട് പുതിയ ഒബ്‌ജക്റ്റുകളുടെ പ്രോട്ടോടൈപ്പുകളായി പ്രവർത്തിക്കാനാകും. സമാനമായ ഒബ്‌ജക്റ്റുകൾ നിർമ്മിക്കാൻ നമ്മൾക്ക് ക്ലാസുകൾ ആവശ്യമില്ല… ഒബ്‌ജക്റ്റുകൾ ഒബ്‌ജക്റ്റുകളിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നു. അതിനേക്കാൾ കൂടുതൽ വസ്തുനിഷ്ഠമായത് മറ്റെന്താണ്?^[2]

പ്രോട്ടോടൈപ്പ് അധിഷ്ഠിത പ്രോഗ്രാമിംഗിന്റെ വക്താക്കൾ വാദിക്കുന്നത് ചില ഉദാഹരണങ്ങളുടെ പെരുമാറ്റത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ ഇത് പ്രോഗ്രാമറെ പ്രോത്സാഹിപ്പിക്കുന്നുവെന്നും പിന്നീട് ഈ വസ്തുക്കളെ ആർക്കൈറ്റിപാൽ വസ്‌തുക്കളായി തരംതിരിക്കുന്നതിനെക്കുറിച്ച് ആശങ്കാകുലരാണെന്നും പിന്നീട് ക്ലാസുകൾക്ക് സമാനമായ രീതിയിൽ ഇത് ഉപയോഗിക്കുമെന്നും വാദിക്കുന്നു.^[3]പല പ്രോട്ടോടൈപ്പ് അധിഷ്ഠിത സിസ്റ്റങ്ങളും റൺ-ടൈമിൽ പ്രോട്ടോടൈപ്പുകളിൽ മാറ്റം വരുത്താൻ പ്രോത്സാഹിപ്പിക്കുന്നു, അതേസമയം വളരെ കുറച്ച് ക്ലാസ് അധിഷ്ഠിത ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് സിസ്റ്റങ്ങൾ (ഡൈനാമിക് ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് സിസ്റ്റം, കോമൺ ലിസ്പ്, ഡയലാൻ, ഒബ്ജക്ടീവ്-സി, പേൾ, പൈത്തൺ, റൂബി , അല്ലെങ്കിൽ സ്മോൾടോക്ക്) ഒരു പ്രോഗ്രാം നടപ്പിലാക്കുമ്പോൾ ക്ലാസുകൾ മാറ്റാൻ അനുവദിക്കുന്നു.