ട്രാൻസിലേറ്റർ (കമ്പ്യൂട്ടിംഗ്)

ഒരു ട്രാൻസിലേറ്റർ അല്ലെങ്കിൽ പ്രോഗ്രാമിംഗ് ലാങ്വേജ് പ്രോസസ്സർ എന്നത് ഒരു കമ്പ്യൂട്ടർ പ്രോഗ്രാമാണ്, അത് മനുഷ്യന് സൗകര്യപ്രദമായ രൂപത്തിൽ എഴുതിയ പ്രോഗ്രാമിംഗ് നിർദ്ദേശങ്ങളെ കമ്പ്യൂട്ടറുകൾ മനസ്സിലാക്കുകയും പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്ന മെഷീൻ ലാംഗ്വേജ് കോഡുകളാക്കി മാറ്റുന്നു. കംപൈലർ, അസംബ്ലർ, അല്ലെങ്കിൽ ഇൻ്റർപ്രെറ്റർ എന്നിവയെ സൂചിപ്പിക്കാൻ കഴിയുന്ന ഒരു പൊതു പദമാണിത് - ഒരു കമ്പ്യൂട്ടർ ഭാഷയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് കോഡ് പരിവർത്തനം ചെയ്യുന്ന എന്തിനെയും അങ്ങനെ വിളിക്കാൻ സാധിക്കും. കോഡ് ട്രാൻസിലേഷനിൽ വ്യത്യസ്ത തരം അല്ലെങ്കിൽ പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ തലങ്ങൾ തമ്മിൽ പരിവർത്തനം ചെയ്യുന്നത് ഉൾപ്പെടുന്നു. സി++ അല്ലെങ്കിൽ ജാവ പോലുള്ള ഉന്നത-തല  ഭാഷകൾ പരസ്പരം വിവർത്തനം ചെയ്യാനോ ബൈറ്റ്കോഡ് പോലെയുള്ള ഇൻ്റർമീഡിയറ്റ് ഫോമുകളിലേക്ക് (ഇന്റർമീഡിയറ്റ് ഫോം എന്നത് ഒരു പ്രോഗ്രാമിന്റെ ഇടനില രൂപമാണ്, ഇത് കമ്പൈലർ സോഴ്‌സ് കോഡിൽ നിന്ന് സൃഷ്ടിച്ച് പിന്നീട് ഒരു പ്രത്യേക മെഷീൻ കോഡിലേക്ക് മാറ്റുന്നു. ഉദാഹരണം ജാവ പ്രോഗ്രാമിംഗ് ഭാഷ ഉപയോഗിക്കുമ്പോൾ:
 സോഴ്‌സ് കോഡ് ആദ്യം ബൈറ്റ്കോഡാക്കി മാറ്റപ്പെടുന്നു (ഇന്റർമീഡിയറ്റ് ഫോം)
 JVM (Java Virtual Machine) ഈ ബൈറ്റ്കോഡ് വായിച്ച് അത് ഫൈനൽ മെഷീൻ കോഡായി മാറ്റി പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു.)

കംപൈൽ ചെയ്യാനോ കഴിയും. ബൈറ്റ്കോഡ് അല്ലെങ്കിൽ സമാനമായ ഇൻ്റർമീഡിയറ്റ് കോഡ് നിർവ്വഹണത്തിനായുള്ള നിമ്ന-തലത്തിൽ(low-level) മെഷീൻ കോഡിലേക്ക് വിവർത്തനം ചെയ്യാൻ കഴിയും. അസംബ്ലി ഭാഷ അല്ലെങ്കിൽ മെഷീൻ കോഡ് പോലുള്ള ഹാർഡ്‌വെയറിനോട് ചേർന്നുള്ള കോഡുമായി പ്രവർത്തിക്കുന്നത് നിമ്ന തലത്തിലുള്ള ട്രാൻസിലേഷനിൽ ഉൾപ്പെടുന്നു.  വ്യത്യസ്‌ത ഹാർഡ്‌വെയർ പ്ലാറ്റ്‌ഫോമുകൾക്കായി സോഫ്‌റ്റ്‌വെയർ അഡാപ്റ്റുചെയ്യുമ്പോൾ വിവിധ തരം അസംബ്ലി ഭാഷകൾക്കിടയിൽ വിവർത്തനം ചെയ്യേണ്ടത് ആവശ്യമാണ്. അതുപോലെ, ഒരു സിപിയു നേരിട്ട് നടപ്പിലാക്കുന്ന ബൈനറി നിർദ്ദേശങ്ങൾ അടങ്ങുന്ന മെഷീൻ കോഡിന്, മറ്റൊരു ആർക്കിടെക്ചറുള്ള മറ്റൊരു സിസ്റ്റത്തിൽ കാര്യക്ഷമമായി പ്രവർത്തിക്കുന്നതിന് പരിവർത്തനമോ ഒപ്റ്റിമൈസേഷനോ ആവശ്യമായി വന്നേക്കാം. ഈ പ്രക്രിയ വിവിധ കമ്പ്യൂട്ടിംഗ് പരിതസ്ഥിതികളിലുടനീളം മികച്ച പ്രകടനം ഉറപ്പാക്കുന്നു. സോഫ്റ്റ്‌വെയറും ഹാർഡ്‌വെയറും കമ്പ്യൂട്ടിംഗിലെ വ്യത്യസ്ത തലത്തിലുള്ള അബ്സ്ട്രാക്ഷനെ(അബ്സ്ട്രാക്ഷൻ എന്നാൽ അനാവശ്യമായ ഭാഗങ്ങൾ അവഗണിക്കുമ്പോൾ എന്തെങ്കിലും പ്രധാന വിശദാംശങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. പ്രോഗ്രാമിംഗിൽ, ഉപയോക്താവിന് പ്രസക്തമായത് മാത്രം കാണിച്ചുകൊണ്ട് സങ്കീർണ്ണമായ സിസ്റ്റങ്ങളെ ഇത് ലളിതമാക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾ ഒരു കാർ ഓടിക്കുമ്പോൾ, സ്റ്റിയറിംഗ് വീലും പെഡലുകളും എങ്ങനെ ഉപയോഗിക്കണമെന്ന് മാത്രമേ നിങ്ങൾ അറിയേണ്ടതുള്ളൂ, എഞ്ചിൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നല്ല. അതുപോലെ, കോഡിംഗിൽ, അബ്സ്ട്രാക്ഷൻ സങ്കീർണ്ണമായ ആന്തരിക പ്രവർത്തനങ്ങളെ മറയ്ക്കുകയും ഉപയോഗിക്കുന്നതിന് ലളിതമായ ഒരു ഇൻ്റർഫേസ് കാണിക്കുകയും ചെയ്യുന്നു.) പ്രതിനിധീകരിക്കുന്നു. മനുഷ്യർക്ക് ഉപയോഗിക്കാൻ എളുപ്പമുള്ള ഉന്നത തല(high-level) ഭാഷകളിലാണ് സോഫ്‌റ്റ്‌വെയർ എഴുതിയിരിക്കുന്നത്, അതേസമയം ഹാർഡ്‌വെയറിന്റെ ഭൗതിക ഭാഗങ്ങളുമായി അവ എങ്ങനെ ബന്ധിപ്പിക്കുന്നു എന്നതിന്റെ നിമ്ന തല വിവരണങ്ങൾ(description) ഉപയോഗിക്കുന്നു. ട്രാൻസ്ലേറ്റർ കമ്പ്യൂട്ടിംഗ് ഈ അബ്സ്ട്രാറ്റ് തലങ്ങൾ തമ്മിലുള്ള പരിവർത്തനം സുഗമമാക്കുന്നു. മൊത്തത്തിൽ, സോഫ്‌റ്റ്‌വെയറും ഹാർഡ്‌വെയറും തമ്മിലുള്ള വിടവ് നികത്തുന്നതിൽ ട്രാൻസിലേറ്റർ കമ്പ്യൂട്ടിംഗ് നിർണായക പങ്ക് വഹിക്കുന്നു, ഓരോ പ്ലാറ്റ്‌ഫോമിൻ്റെയും തനതായ സവിശേഷതകളും ശക്തികളും പരമാവധി പ്രയോജനപ്പെടുത്താൻ ഡെവലപ്പർമാരെ അനുവദിക്കുക എന്നാണ് ഇതിനർത്ഥം. വേഗത്തിൽ പ്രവർത്തിക്കുന്ന, കുറഞ്ഞ പവർ ഉപയോഗിക്കുന്ന, അവർ നിർമ്മിക്കുന്ന ആപ്പിൻ്റെയോ പ്രോഗ്രാമിൻ്റെയോ ആവശ്യങ്ങൾ നിറവേറ്റുന്ന സോഫ്‌റ്റ്‌വെയർ സൃഷ്‌ടിക്കാൻ ഇത് അവരെ സഹായിക്കുന്നു.
പ്രോഗ്രാമിംഗ് ഭാഷാ പ്രോസസ്സറുകൾ
ഒരു കമ്പൈലറോ ഇൻ്റർപ്രെറ്ററോ ഉപയോഗിക്കുന്നുണ്ടോ എന്നതിനെ ആശ്രയിച്ച് സോഫ്റ്റ്‌വെയർ വികസന പ്രക്രിയ ഗണ്യമായി വ്യത്യാസപ്പെടുന്നു. കംപൈലറുകൾ എക്‌സിക്യൂഷന് മുമ്പ് മുഴുവൻ സോഴ്‌സ് കോഡും മെഷീൻ കോഡിലേക്ക് വിവർത്തനം ചെയ്യുന്നു, ഇത് വേഗതയേറിയ റൺടൈമിന് കാരണമാകുന്നു, പക്ഷേ കംപൈൽ ചെയ്തതിന് ശേഷം വലിയ പിശകുകൾ പരിഹരിക്കാൻ ഡെവലപ്പർമാർ ആവശ്യപ്പെടുന്നു. നേരെമറിച്ച്, ഇന്റർപ്രെട്ടേഴ്സ് കോഡ് വരി വരിയായി വിവർത്തനം ചെയ്യുകയും നടപ്പിലാക്കുകയും ചെയ്യുന്നു, ഇത് മൂലം ഡീബഗ്ഗിംഗ് ഉടനടി നടക്കുന്നു, പക്ഷേ കോഡ് എക്സിക്യൂഷൻ മന്ദഗതിയിലാക്കാൻ സാധ്യതയുണ്ട്. പ്രോഗ്രാമിംഗ്, ഡീബഗ്ഗിംഗ്, എക്സിക്യൂഷൻ എന്നിങ്ങനെ മൂന്ന് പ്രധാന ഘട്ടങ്ങളിൽ ട്രാൻസിലേറ്റർ സോഫ്റ്റ്വയർ വികസന പ്രക്രിയയെ സ്വാധീനിക്കുന്നു. പ്രോഗ്രാമിംഗ് സമയത്ത്, കംപൈലറുകൾക്ക് പരിശോധനയ്ക്ക് മുമ്പ് പൂർണ്ണമായ കോഡ് എഴുതേണ്ടതുണ്ട്, അതേസമയം ഇന്റർപ്രെട്ടേഴ്സ് ചെറിയ കഷണങ്ങളായി പരീക്ഷിക്കാൻ അനുവദിക്കുന്നു. ഡീബഗ്ഗിംഗിൽ, കംപൈലറുകൾ പൂർണ്ണ കംപൈലേഷനു ശേഷം പിശകുകൾ റിപ്പോർട്ട് ചെയ്യുന്നു, അതേസമയം ഇന്റർപ്രെട്ടേഴ്സ് എക്സിക്യൂഷൻ സമയത്ത് പ്രശ്നങ്ങൾ വരി വരിയായി ഹൈലൈറ്റ് ചെയ്യുന്നു. കോഡ് എത്ര വേഗത്തിൽ പ്രവർത്തിക്കുന്നു, എത്ര വേഗത്തിലാണ് നിങ്ങൾക്ക് എറർ ഫീഡ്‌ബാക്ക് (കോഡിലെ തെറ്റുകളെക്കുറിച്ച് ലഭിക്കുന്ന വിവരമാണ് എറർ ഫീഡ്‌ബാക്ക്, എന്താണ് തെറ്റ്, എവിടെയാണ് സംഭവിച്ചത്, ഇത് മൂലം വേഗത്തിൽ തെറ്റുകൾ പരിഹരിക്കാനാകും.) ലഭിക്കുന്നത്, ഭാഷ പിന്തുണയ്ക്കുന്ന ഫീച്ചറുകൾ, പ്രോഗ്രാമിന് വ്യത്യസ്ത പ്ലാറ്റ്‌ഫോമുകളിൽ പ്രവർത്തിക്കാൻ കഴിയുമോ തുടങ്ങിയ കാര്യങ്ങളെ ട്രാൻസിലേറ്റർ പരിശോധിക്കുന്നു. കോഡ് വിവർത്തനം ചെയ്യാൻ ഉപയോഗിക്കുന്ന പൊതുവായ ഉപകരണങ്ങൾ കമ്പൈലറുകൾ, ഇൻ്റർപ്രെട്ടറുകൾ, അസംബ്ലറുകൾ എന്നിവയാണ്.
കംപൈലേഴ്സ്
കംപൈലർ സോഫ്‌റ്റ്‌വെയർ സോഴ്‌സ് കോഡുമായി സംവദിക്കുന്നത് ഒരു ഉന്നത തല(high-level) പ്രോഗ്രാമിംഗ് ഭാഷയിൽ നിന്ന് കമ്പ്യൂട്ടറിൻ്റെ സെൻട്രൽ പ്രോസസ്സിംഗ് യൂണിറ്റിന് (സിപിയു) പിന്നീട് എക്‌സിക്യൂട്ട് ചെയ്യാവുന്ന ഒബ്‌ജക്റ്റ് കോഡാക്കി മാറ്റുന്നതിലൂടെയാണ്. കംപൈലർ സൃഷ്ടിച്ച ഒബ്‌ജക്റ്റ് കോഡിൽ കമ്പ്യൂട്ടറിന് പ്രോസസ്സ് ചെയ്യാൻ കഴിയുന്ന മെഷീൻ റീഡബിൾ കോഡ് അടങ്ങിയിരിക്കുന്നു. കമ്പ്യൂട്ടിംഗ് പ്രക്രിയയുടെ ഈ ഘട്ടം കംപൈലേഷൻ എന്നറിയപ്പെടുന്നു. ഒരു കംപൈലർ മുഴുവൻ സോഴ്സ് കോഡും മെഷീൻ കോഡിലേക്ക് വിവർത്തനം ചെയ്യുന്നു, അതിന് ശേഷം എക്സിക്യൂട്ടബിൾ ഫയൽ(എക്സിക്യൂട്ടബിൾ ഫയൽ എന്ന് അർത്ഥമാക്കുന്നത് ഒരു പ്രോഗ്രാം നേരിട്ട് കമ്പ്യൂട്ടറിൽ പ്രവർത്തിക്കാനായി തയ്യാറാക്കിയ ഫയലാണ്. ഇത് കൈകാര്യം ചെയ്യാൻ കമ്പ്യൂട്ടറിന് വ്യത്യസ്തമായ വിവർത്തനം ആവശ്യമില്ല, പ്രവർത്തനത്തിന് തയ്യാറാകുമ്പോൾ മാത്രം പ്രവർത്തിക്കും. ഒരു എക്സിക്യൂട്ടബിൾ ഫയലിന്റെ ഉദാഹരണം വിൻഡോസിൽ `.exe` ഫയലുകൾ ആണ്, ഉദാ: `notepad.exe`.  ലിനക്സിൽ, അത് `.out` അല്ലെങ്കിൽ `.bin` ഫയലായി വരാം, ഉദാ: `program.out`. ഈ ഫയലുകൾ ക്ലിക്കുകയോ കമാൻഡ് ഉപയോഗിച്ച് റൺ ചെയ്യുകയോ ചെയ്യുമ്പോൾ, പ്രോഗ്രാം പ്രവർത്തനം ആരംഭിക്കും.) സൃഷ്ടിക്കുന്നു. ഇത് ട്രാസിലേഷനെയും എക്സിക്യൂഷനേയും വേർതിരിക്കുന്നു, കാരണം പ്രോഗ്രാം പിന്നീട് എക്സിക്യൂട്ടബിളിൽ നിന്ന് നേരിട്ട് പ്രവർത്തിക്കുന്നു. കമ്പൈലേഷൻ കഴിഞ്ഞ്, സോഴ്‌സ് കോഡിൽ നിന്നുള്ള പുതിയ ഓബ്ജക്റ്റ് കോഡ് പ്രത്യേകമായി സേവ് ചെയ്യുന്നു. പ്രോഗ്രാം പ്രവർത്തിക്കാൻ പിന്നീട് സോഴ്‌സ് കോഡ് ആവശ്യമില്ല. കമ്പൈലർ ഉപയോഗിക്കുന്ന പ്രോഗ്രാമുകളിൽ, വിവർത്തന പ്രക്രിയ ഒരിക്കൽ മാത്രം നടക്കുന്നു. ഇത് പ്രോഗ്രാം പല തവണ വേഗത്തിൽ പ്രവർത്തിക്കാൻ സഹായിക്കുന്ന എഫിഷ്യന്റ് കോഡ് സൃഷ്ടിക്കുന്നു. 

ഉന്നത തല കോഡ് ഒരു കമ്പൈലർ ഉപയോഗിച്ച് വിവർത്തനം ചെയ്യുമ്പോൾ ചില വ്യക്തമായ ഗുണങ്ങൾ ഉണ്ട്.  
 കോഡ് ഒരിക്കൽ വിവർത്തനം ചെയ്താൽ, അതിനെ വേഗത്തിൽ നിരവധി തവണ പ്രവർത്തിക്കാൻ സാധിക്കും.  
 വിവർത്തന സമയത്ത് പിശകുകൾ കണ്ടെത്താനും ശരിയാക്കാനും കഴിയും.  
പ്രോഗ്രാം പ്രവർത്തന സമയത്ത് കമ്പൈലർ ആവശ്യമില്ല, അതിനാൽ പ്രോഗ്രാമിന്റെ പ്രകടനം മെച്ചപ്പെടുന്നു.
കമ്പൈലർ ഉപയോഗിക്കുന്നത് കോഡ് മോഷണത്തിൽ നിന്ന് സംരക്ഷിക്കുകയും അനധികൃതമായി പ്രവേശിച്ച് വ്യക്തികൾ സോഴ്‌സ് കോഡ് ഉപയോഗിക്കുന്നത് തടയുകയും ചെയ്യുന്നതിന് ഇത് കൂടുതൽ അനുയോജ്യമാണ്. കമ്പൈലർ സോഴ്‌സ് കോഡ് മെഷീൻ കോഡിലേക്ക് മാറ്റുന്നതുകൊണ്ട്, യഥാർത്ഥ കോഡ് മറ്റുള്ളവർക്ക് കാണാനോ മാറ്റുവാനോ കഴിയില്ല. ഇത് പ്രോഗ്രാമിന്റെ സുരക്ഷയും സ്വാതന്ത്ര്യവും ഉറപ്പാക്കുന്നു.

അവലംബം