ഇംപെറേറ്റീവ് പ്രോഗ്രാമിംഗ്

വിക്കിപീഡിയ, ഒരു സ്വതന്ത്ര വിജ്ഞാനകോശം.
(Imperative programming എന്ന താളിൽ നിന്നും തിരിച്ചുവിട്ടതു പ്രകാരം)
Jump to navigation Jump to search

കമ്പ്യൂട്ടർ ശാസ്ത്രത്തിൽ, ഇംപെറേറ്റീവ് പ്രോഗ്രാമിങ്(imperative programming) ഒരു പ്രോഗ്രാമിങ് മാതൃകയാണ്, ഒരു പ്രോഗ്രാമിന്റെ അവസ്ഥ മാറ്റുന്ന പ്രസ്താവനകൾ ഉപയോഗിക്കുന്നു. സ്വാഭാവികമായ ഭാഷകളിലുള്ള അവ്യക്തത മൂലം കമാൻഡുകൾ പ്രകടിപ്പിക്കുന്നതുപോലെ തന്നെ, ഒരു കമ്പ്യൂട്ടർ നിർവഹണത്തിനായി ഒരു കമാൻഡ് ഉണ്ട്. പ്രോഗ്രാം എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് വിശദീകരിക്കുന്നതിൽ ഇംപെറേറ്റീവ് പ്രോഗ്രാമിംഗ് ഊന്നൽ നൽകുന്നു.

പ്രസ്താവന പ്രോഗ്രാമിന്(declarative programming) വിപരീതമായി ഈ പദം ഉപയോഗിക്കാറുണ്ട്, പ്രോഗ്രാമിന്റെ ഫലം എങ്ങനെ നേടാം എന്ന് വ്യക്തമാക്കാതെ പ്രോഗ്രാമിന് വേണ്ടി എന്തെല്ലാം ചെയ്യണം എന്നാണ് ഇവിടെ ഊന്നിപ്പറയുന്നത്.

ഇംപെറേറ്റീവ് പ്രോഗ്രാമിംഗും, പ്രോസീജറൽ പ്രോഗ്രാമിംഗും[തിരുത്തുക]

പ്രൊസീജറൽ പ്രോഗ്രാമിംഗ് എന്നത് പ്രോഗ്രാമുകൾ ഒന്നോ അതിലധികമോ നടപടിക്രമങ്ങളിൽ നിർമ്മിക്കപ്പെടുന്ന ഒരു പ്രോഗ്രാമിംഗ് രീതിയാണ് ഇത് (സബ്റൂട്ടീനുകൾ അല്ലെങ്കിൽ ഫങ്ഷനുകൾ എന്നും വിളിക്കുന്നു). പദങ്ങൾ പലപ്പോഴും പര്യായങ്ങളായി ഉപയോഗിക്കുന്നു, എന്നാൽ നടപടിക്രമങ്ങൾ ഉപയോഗപ്പെടുത്തുന്നു, നിർദ്ദിഷ്ട പ്രോഗ്രാമുകൾ എങ്ങനെയാണ് പ്രദർശിപ്പിക്കപ്പെടുന്നത്, അവ എങ്ങനെയാണ് നിർമ്മിക്കുന്നതെന്നതിനെ സംബന്ധിച്ച് നാടകീയമായ ഒരു പ്രഭാവമുണ്ട്. ക്രമാനുഗതമായ പ്രോഗ്രാമിംഗ്, അതിൽ സ്ഥാന മാറ്റങ്ങളിലുള്ളത് നടപടിക്രമങ്ങളിലേക്ക് പ്രാദേശിക വൽക്കരിച്ചിരിക്കുന്നു അല്ലെങ്കിൽ നടപടിക്രമങ്ങളിൽ നിന്നും വ്യക്തമായ വാദങ്ങളിൽ നിന്നും റിട്ടേണുകൾ പരിമിതപ്പെടുത്തിയിരിക്കുന്നു, ഇത് ഘടനാപരമായ പ്രോഗ്രാമിംഗിന്റെ ഒരു രൂപമാണ്. 1960 കളിൽ, നിർമ്മിത പരിപാടികളുടെ മൊത്തത്തിലുള്ള നിലവാരം മെച്ചപ്പെടുത്തുന്നതിനുള്ള സാങ്കേതിക വിദ്യയായി ഘടനാപരമായ പ്രോഗ്രാമിങ്, മോഡുലാർ പ്രോഗ്രാമിംഗ് എന്നിവ പ്രോത്സാഹിപ്പിച്ചു. ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് പ്രോഗ്രാമിങ്ങിന്റെ പിന്നിലെ ആശയങ്ങൾ ഈ സമീപനം വിപുലീകരിക്കാൻ ശ്രമിക്കുന്നു.

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

ഇംപെറേറ്റീവ് പ്രോഗ്രാമിന്റെ ന്യായവാദവും അടിസ്ഥാനവും[തിരുത്തുക]

മിക്കവാറും എല്ലാ കമ്പ്യൂട്ടറുകളുടെയും ഹാർഡ്വെയർ നടപ്പിലാക്കേണ്ടത് അനിവാര്യമാണ്(imperative). ഏതാണ്ട് എല്ലാ കമ്പ്യൂട്ടർ ഹാർഡ്വെയറുകളും മെഷീൻ കോഡ് നടപ്പിലാക്കാൻ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്, ഇത് കമ്പ്യൂട്ടറിനോടനുബന്ധിച്ചാണ്, അത് ഇംപെറേറ്റീവ് ശൈലിയിൽ എഴുതിയിരിക്കുന്നു. നിമ്ന തലത്തിൽ(low-level)നിന്നുള്ള വീക്ഷണത്തിൽ നിന്ന്, മെമ്മറി ഉള്ളടക്കം പ്രോഗ്രാം സ്റ്റേറ്റിനാൽ നിർവചിക്കപ്പെടുന്നു, കൂടാതെ കമ്പ്യൂട്ടറിന്റെ നൈസർഗ്ഗികമായ യന്ത്ര ഭാഷയിലും നിർദ്ദേശങ്ങൾ നൽകുന്നു. ഉയർന്ന തലത്തിലുള്ള നിർദ്ദിഷ്ട ഭാഷകൾ വേരിയബിളുകളും കൂടുതൽ സങ്കീർണ്ണമായ പ്രസ്താവനകളും ഉപയോഗിക്കുന്നു, പക്ഷേ ഇപ്പോഴും അതേ മാതൃക പിന്തുടരുന്നു. കാര്യനിർവ്വഹണമാർഗ്ഗങ്ങൾ, പ്രോസസ് ചെക്ക് ലിസ്റ്റുകൾ, കമ്പ്യൂട്ടർ പ്രോഗ്രാമുകൾ ഇല്ലാത്തപ്പോൾ, ഇംപെറേറ്റീവ് പ്രോഗ്രാമിങ് രീതിയിൽ സമാനമായ പരിചിതമായ ആശയങ്ങളാണിവ. ഓരോ ചുവടിലും നിർദ്ദേശങ്ങൾ അടങ്ങിയിട്ടുണ്ട്, ഭൗതിക ലോകം ഈ അവസ്ഥയെ നിലനിർത്തുന്നു. ഇംപെറേറ്റീവ് പ്രോഗ്രാമിംഗിന്റെ അടിസ്ഥാന ആശയങ്ങൾ മുതൽ രണ്ടും ആശയപരമായി സുപരിചിതങ്ങളാണ്, നേരിട്ട് ഹാർഡ്വെയർ തത്ത്വങ്ങളെ പ്രവർത്തനങ്ങളിലൂടെ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, മാത്രമല്ല മിക്ക കമ്പ്യൂട്ടർ ഭാഷകളും ഇംപെറേറ്റീവ് ശൈലിയിലാണ് തുടർന്നുപോരുന്നത്. അസൈൻമെന്റ് പ്രസ്താവനകൾ, ഇംപെറേറ്റീവ് ശൈലിയിൽ, മെമ്മറിയിൽ ലഭ്യമായിട്ടുള്ള വിവരങ്ങളിൽ ഒരു പ്രവർത്തനം നടത്തുകയും, പിന്നീട് ഉപയോഗത്തിനായി മെമ്മറിയിൽ സൂക്ഷിക്കുകയും ചെയ്യുന്നു. ഉയർന്ന തലത്തിലുള്ള ഇംപെറേറ്റീവ് ഭാഷകൾ കൂടാതെ, സങ്കീർണ്ണമായ എക്സ്പ്രഷനുകളുടെ വിലയിരുത്തൽ അനുവദിക്കുന്നു, അരിത്മെറ്റിക് പ്രവർത്തനവും ഫങ്ഷൻ മൂല്യനിർണ്ണയവും ചേർന്ന ഒരു സംഖ്യയും, കൂടാതെ മെമ്മറിയിലേക്കുള്ള തൽസമയ മൂല്യത്തിന്റെ അസൈൻമെന്റും ഉൾപ്പെടുന്നു. ലൂപ്പുചെയ്യുന്ന സ്റ്റേറ്റ്മെന്റുകൾ (വൈയിൽ ലൂപ്പ്(while loop), ഡു വൈൽ ലൂപ്പ്(do while loop), ഫോർ ലൂപ്പ്(for loop))ഒന്നിലധികം തവണ സ്റ്റേറ്റ്മെന്റിന്റെ ശ്രേണി എക്സിക്യൂട്ട് ചെയ്യാൻ അനുവദിക്കുന്നു. ലൂപ്പിന് ഒന്നുകിൽ മുൻനിർവചിച്ച തവണവരെ സ്റ്റേറ്റ്മെന്റ് എക്സിക്യൂട്ട് ചെയ്യാം അല്ലെങ്കിൽ ചില വ്യവസ്ഥകൾ മാറ്റുന്നതുവരെ അവ ആവർത്തിച്ചു നിർവ്വഹിക്കാൻ കഴിയും. ചില വ്യവസ്ഥകൾ പാലിക്കപ്പെട്ടിട്ടുണ്ടെങ്കിൽ മാത്രമേ വ്യവസ്ഥാപിത ബ്രാഞ്ചിംഗ് പ്രസ്താവനകൾ നടപ്പിലാക്കാൻ അനുമതിയുള്ളൂ. അല്ലെങ്കിൽ, പ്രസ്താവനകൾ ഒഴിവാക്കിയശേഷം, സ്റ്റേറ്റ്മെന്റ് അവയെ പിന്തുടരുകയും നിർവഹണ ശ്രേണി തുടർന്നുവരുകയും ചെയ്യുന്നു. ഒരു പ്രോഗ്രാമിന്റെ മറ്റൊരു ഭാഗം കൈമാറുന്ന നിർവഹണ ശ്രേണി നിരുപാധിക ബ്രാഞ്ചിംഗ് പ്രസ്താവനകൾ അനുവദിക്കുന്നു. ഇവിടെ ജമ്പ് ഉൾപ്പെടുന്നു(പല ഭാഷകളിലും ഗോടു(goto) എന്നു വിളിക്കുന്നു), സ്വിച്ചുപ്രോഗ്രാം, അതിന്റെ ഉപപ്രോഗ്രാം സബ്റൂട്ടീൻ, അല്ലെങ്കിൽ പ്രൊസീജർ കോൾ (കോൾ കഴിഞ്ഞാൽ ഇത് സാധാരണയായി അടുത്ത പ്രസ്താവനയിലേക്ക് മടങ്ങുന്നു). ഉയർന്ന നിലവാരമുള്ള പ്രോഗ്രാമിങ് ഭാഷകളുടെ തുടക്കത്തിൽ, ബ്ളോക്കിലെ ആമുഖം ഒരു കൂട്ടം സ്റ്റേറ്റ്മെൻറുകളും പ്രഖ്യാപനങ്ങളും ഒറ്റ പ്രസ്താവനയായി കണക്കാക്കിയിരുന്ന പ്രോഗ്രാമുകളുടെ നിർമ്മാണത്തെ സഹായിച്ചു. സബ്റൂട്ടീനുകളുടെ മുഖവുരയോടൊപ്പം, ലളിതമായ പ്രക്രിയാപരമായ ഘടനയിലേക്ക് ഹയറാജിക്കൽ സിദ്ധാന്തം അവതരിപ്പിക്കുന്നതിന് സങ്കീർണ ഘടനകളെ പ്രാപ്തമാക്കി. പല ഇംപെറേറ്റീവ് പ്രോഗ്രാമിങ് ഭാഷകളും (ഫോർട്രാൻ, ബേസിക്, സി എന്നിവ പോലുള്ളവ) അസംബ്ലിഭാഷയുടെ അമൂർത്തമാണ്.[1]

ഇംപെറേറ്റീവ്, ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് ഭാഷകളുടെ ചരിത്രം[തിരുത്തുക]

യഥാർത്ഥ കമ്പ്യൂട്ടറുകളിൽ ഉപയോഗിക്കുന്ന യന്ത്ര ഭാഷകളായിരുന്നു നേരത്തെ ഉപയോഗിച്ചിരുന്ന ഇംപെറേറ്റീവ് ഭാഷകൾ. ഈ ഭാഷകളിൽ, നിർദ്ദേശങ്ങൾ വളരെ ലളിതമായി ഉപയോഗിച്ചു, ഹാർഡ്വെയർ നടപ്പിലാക്കൽ എളുപ്പമാക്കി, പക്ഷേ സങ്കീർണ്ണമായ പ്രോഗ്രാമുകൾ സൃഷ്ടിക്കുന്നത് തടഞ്ഞു. സങ്കീർണ്ണമായ പ്രോഗ്രാമുകൾ സൃഷ്ടിക്കുന്നതിൽ മെഷീൻ കോഡ് നൽകിയ തടസ്സങ്ങൾ നീക്കം ചെയ്ത ആദ്യത്തെ പ്രധാന പ്രോഗ്രാമിങ് ഭാഷയാണ് ഫോർട്രാൻ 1954 ൽ ആരംഭിച്ച ഇന്റർനാഷണൽ ബിസിനസ് മെഷീനിൽ (ഐ.ബി.എം) ജോൺ ബാക്കസ് ആണ് ഫോർട്രാൻ വികസിപ്പിച്ചത്. ഫോർട്രാൻ ഒരു കംപൈൽഡ് ഭാഷയായിരുന്നു. ഇത് വേരിയബിളുകൾ, സങ്കീർണ്ണ എക്സ്പ്രഷനുകൾ, സബ് പ്രൊഗ്രാമുകൾ മുതലായ മറ്റ് പല സവിശേഷതകളും ഇപ്പോൾ ഇംപെറേറ്റീവ് ഭാഷകളിൽ സാധാരണമാണ്. അടുത്ത രണ്ടു ദശാബ്ദങ്ങളിൽ, മറ്റു പ്രമുഖ ഉന്നത നിലവാരമുള്ള പ്രോഗ്രാമിങ് ഭാഷകൾ വികസിപ്പിച്ചെടുക്കന്നതിന് സാക്ഷ്യം വഹിച്ചു. 1950 കളിലും 1960 കളിലും അൽഗോൾ(ALGOL) വികസിപ്പിച്ചെടുത്തു, ഗണിത അൽഗോരിതങ്ങൾ കൂടുതൽ എളുപ്പത്തിൽ പ്രകടിപ്പിക്കാൻ അനുവദിക്കുകയും ചില കമ്പ്യൂട്ടറുകളുടെ ഓപ്പറേറ്റിങ് സിസ്റ്റത്തിന്റെ ടാർഗെറ്റ് ഭാഷയായി ഉപയോഗിക്കുകയും ചെയ്തു. മംമ്പ്സ്(MUMPS) (1966) ഒരു ലോജിക്കൽ തീവ്രത അനിവാര്യമാംവിധം പരമകോടിയിലേക്ക് കൊണ്ടുവന്നിരുന്നു, ഏതെങ്കിലും പ്രസ്താവനകൾ ഇല്ലാതെ, പൂർണ്ണമായും കമാൻഡുകളുടെ അടിസ്ഥാനത്തിൽ, ഇഫും(IF), എൽസും(ELSE) എന്നിവ പരസ്പരം സ്വതന്ത്രമാക്കാതെ, ഒരു ഇന്ററെൻസിക് വേരിയബിൾ ടെസ്റ്റ്. കോബോൾ ($TEST.COBOL) (1960), ബേസിക് (1964) തുടങ്ങിയവ പ്രോഗ്രാമിങ് വാക്യഘടനയുടെ രൂപമാറ്റം ഉണ്ടാക്കാൻ ശ്രമിച്ചു. 1970 കളിൽ നിക്കോളസ് വിർത്ത് നിർമ്മിച്ച പാസ്കൽ, ബെല്ലിന്റെ ലബോറട്ടറികളിൽ ജോലി ചെയ്യുന്നതിനിടയിൽ ഡെന്നിസ് റിച്ചിയാണ് സി നിർമ്മിച്ചത്. വിർത്ത് മോഡുല-2 (Modula-2) ഉം ഒബ്രോൺ(Oberon) ഉം രൂപകൽപ്പന ചെയ്തു. അമേരിക്കൻ ഐക്യനാടുകളിലെ ഡിപ്പാർട്ട്മെന്റ് ഓഫ് ഡിഫൻസിന്റെ ആവശ്യകതകൾക്കായി ജീൻ ഇക്ബിയയും ഹണിവെലിനടുത്തുള്ള ഒരു സംഘവും 1978-ൽ ഭാഷാ ആവശ്യകതകൾ നിർവ്വഹിക്കുന്നതിന് 4 വർഷത്തെ പദ്ധതിക്കുശേഷം അഡ രൂപകൽപ്പന ചെയ്യാൻ തുടങ്ങി. 1983 ൽ ആണ് ആദ്യമായി പ്രസിദ്ധീകരിച്ചത്, 1995, 2005, 2012 എന്നീ വർഷങ്ങളിൽ പുനരവലോകനം നടത്തി.

1980 കളിൽ ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് പ്രോഗ്രാമിങ്ങിന്റെ വളർച്ച അതിവേഗം വർദ്ധിച്ചു. ഈ ഭാഷകൾ ഇംപെറേറ്റീവ് ശൈലിയാണ് അവലംബിച്ചിട്ടുള്ളത്, എന്നാൽ വസ്തുക്കളെ പിന്തുണയ്ക്കുന്നതിനുള്ള സവിശേഷതകൾ കൂടി ചേർത്തു. ഇരുപതാം നൂറ്റാണ്ടിലെ അവസാന രണ്ടു ദശാബ്ദങ്ങൾ അത്തരം പല ഭാഷകളുടെയും വികസനം കണ്ടു. സ്മോൾടോക്ക്-80, യഥാർത്ഥത്തിൽ 1969 ൽ അലൻ കേ ആണ് ആവിഷ്കരിച്ചത്, 1980 ൽ അത് സെറോക്സ് പാലോ ആൾട്ടോ ഗവേഷണ കേന്ദ്രം (PARC) പുറത്തിറക്കി. മറ്റൊരു ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് ഭാഷയായ സിമുലയിൽ നിന്നാണ് (1960 ൽ വികസിപ്പിച്ച ഈ ഭാഷയാണ് ലോകത്തിലെ ആദ്യ ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് പ്രോഗ്രാമിങ് ഭാഷയായി കണക്കാക്കുന്നത്) ഈ ആശയം രൂപം കൊണ്ടത്-ബ്യാൻ സ്ട്രൗസ്ട്രെപ് സി++ സൃഷ്ടിച്ചു, സി അടിസ്ഥാനമാക്കിയുള്ള ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് ഭാഷയാണ് സി++. 1979 ൽ സി + ന്റെ രൂപകല്പന ആരംഭിച്ചു. ആദ്യ നിർവഹണം 1983 ൽ പൂർത്തിയായി. 1980 കളിലും 1990 കളിലും ശ്രദ്ധേയമായ ഇംപെറേറ്റീവ് ഭാഷകൾ, ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് ആശയങ്ങൾ എന്നിവ നടപ്പിലാക്കി, പേൾ ആയിരുന്നു, 1987 ൽ ലാറി വാൾ പുറത്തിറക്കിയത്; വോൾഫാം ഭാഷ, 1988 ൽ വൂൾഫ്രാം റിസർച്ച് പുറത്തിറക്കി; പൈത്തൺ, 1990 ൽ ഗൈഡോ വാൻ റോസ്സം ആണ് പുറത്തിറക്കിയത്;

അവലംബം[തിരുത്തുക]

  1. Bruce Eckel (2006). Thinking in Java. Pearson Education. p. 24. ISBN 978-0-13-187248-6.