ടൈപ്പ് സിസ്റ്റം

കമ്പ്യൂട്ടർ പ്രോഗ്രാമിംഗിൽ, ഓരോ പദത്തിനും അതിന്റെ സ്വഭാവം എന്താണെന്ന് അറിയിക്കുന്ന സംവിധാനമാണ് **ടൈപ്പ് സിസ്റ്റം**. (ഉദാഹരണത്തിന്, പൂർണ്ണസംഖ്യ(integer), ഫ്ലോട്ടിങ്ങ് പോയിന്റ്, സ്ട്രിംഗ്) ഒരു സംഖ്യയാണോ അല്ലെങ്കിൽ വാക്കുകളുടെയും അക്ഷരങ്ങളുടെയും കൂട്ടമായ വാക്ക് (സ്ട്രിംഗ്) ആണോ എന്ന് ടൈപ്പ് സിസ്റ്റം ഉപയോഗിച്ച് വ്യക്തമായി തിരിച്ചറിയാൻ കഴിയും. അത് കൊണ്ട് തന്നെ പ്രോഗ്രാമിൽ പിശകുകൾ ഒഴിവാക്കുകയും ഫലപ്രദമായി പ്രവർത്തിക്കുകയും ചെയ്യുന്നു. പ്രോഗ്രാമിംഗിൽ, ഓരോ മൂല്യത്തിനും ഒരു ടൈപ്പ് സിസ്റ്റം അതിന്റെ സ്വഭാവം നിർണ്ണയിക്കുന്നു. ഉദാഹരണത്തിന്, `x = 10` ഒരു ഇന്റിജർ (പൂർണ്ണസംഖ്യ) ആണെന്നും `name = "Subin"` ഒരു സ്ട്രിങ് (വാക്ക്) ആണെന്നും ടൈപ്പ് സിസ്റ്റം തിരിച്ചറിയുന്നു. ടൈപ്പ് സിസ്റ്റം മൂല്യങ്ങളുടെ സ്വഭാവം ശരിയായി തിരിച്ചറിയുന്നതിനാൽ, പ്രോഗ്രാമിൽ തെറ്റായ ഗണിത ക്രിയകൾ ചെയ്യുന്നതോ, അയോഗ്യമായ പ്രവർത്തനങ്ങൾ നടത്തുന്നതോ ഒഴിവാക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു സംഖ്യയുമായും ഒരു വാക്കുമായും കൂട്ടിച്ചേർക്കാൻ ശ്രമിച്ചാൽ (e.g., `10 + "Subin"`), ടൈപ്പ് സിസ്റ്റം ഇത് പിശകാണെന്ന് കാണിച്ചു നൽകും. ഇത് പ്രോഗ്രാമിന്റെ കൃത്യതയും വിശ്വാസ്യതയും ഉറപ്പാക്കുന്നു. സാധാരണ ഭാഷയിൽ പറഞ്ഞാൽ, പദങ്ങൾ ഒരു കമ്പ്യൂട്ടർ പ്രോഗ്രാമിന്റെ ഭാഗങ്ങളാണ്, അതായത് നിലവിലുള്ള ഡാറ്റ (വേരിയബിളുകൾ), കണക്കുകൾ അല്ലെങ്കിൽ പ്രവർത്തനങ്ങൾ (എക്സ്പ്രഷനുകൾ), ഒരു പ്രത്യേക ജോലി ചെയ്യുന്ന കോഡ് കഷണങ്ങൾ (ഫംഗ്‌ഷനുകൾ), അല്ലെങ്കിൽ പ്രോഗ്രാമിന്റെ വലിയ ഭാഗങ്ങൾ (മൊഡ്യൂളുകൾ) എന്നിവ. ഒരു ടൈപ്പ് സിസ്റ്റം, കമ്പ്യൂട്ടർ പ്രോഗ്രാമിംഗിൽ, വേരിയബിളുകൾ (അഥവാ പദങ്ങൾ) എന്തെല്ലാം മൂല്യങ്ങൾ സ്വീകരിക്കാനാവുമെന്ന് തീരുമാനിക്കുന്ന ഒരു നിയമം അല്ലെങ്കിൽ മാനദണ്ഡമാണ്. ഇത് പ്രോഗ്രാമിന് തകരാറുകൾ ഒഴിവാക്കാനും, തെറ്റായ മൂല്യങ്ങൾ പ്രോഗ്രാമിൽ പ്രവേശിപ്പിക്കപ്പെടാത്തതിനായി സഹായിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു പ്രോഗ്രാമിൽ "സ്ട്രിംഗ്" (വാക്കുകൾ) എന്ന പദം ഉപയോഗിക്കുമ്പോൾ, ടൈപ്പ് സിസ്റ്റം അത് ഒരു വാക്കായിരിക്കും എന്ന് നിർണ്ണയിക്കും, അതിന്റെ ചുറ്റുപാടിൽ മറ്റേതെങ്കിലും തരം (പൂർണ്ണസംഖ്യ, ഫ്ലോട്ടിംഗ് പോയിന്റ്) മൂല്യങ്ങൾ അനുവദിക്കുന്നില്ല. കമ്പ്യൂട്ടർ പ്രോഗ്രാമിംഗിൽ, ഡാറ്റാ ടൈപ്പുകൾ (ഉദാ: "സ്ട്രിംഗ്", "അറേ ഓഫ് ഫ്ലോട്ട്", "ഫംഗ്ഷൻ റിട്ടേണിംഗ് ബൂളിയൻ") ഉപയോഗിക്കുമ്പോൾ അവയ്ക്ക് പ്രത്യേകം നിയമങ്ങളും നിർവ്വചനങ്ങളും ഉണ്ടാക്കുന്നു. ഈ നിയമങ്ങൾ, ഡാറ്റാ ടൈപ്പ് എങ്ങനെ പ്രവർത്തിക്കണമെന്നും, എങ്ങനെ ഉപയോഗിക്കാമെന്നും വ്യക്തമാക്കുന്നു.  ഇതിന്റെ സഹായത്തോടെ, പ്രോഗ്രാമർക്ക് ഈ ഡാറ്റാ ടൈപ്പുകൾ അനുസരിച്ച് പ്രോഗ്രാമുകൾ എഴുതാം, ഉദാഹരണത്തിന് "സ്ട്രിംഗ്" ഉപയോഗിച്ച് വാക്കുകൾ കൈകാര്യം ചെയ്യാനും "ഫ്ലോട്ട്" ഉപയോഗിച്ച് സംഖ്യകൾ കൈകാര്യം ചെയ്യാനും സാധിക്കും.

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

ഒരു കംപൈലർ ഒരു മൂല്യത്തിന്റെ സ്റ്റാറ്റിക് ടൈപ്പ് ഉപയോഗിച്ച് സംഭരണത്തിനും പ്രവർത്തനങ്ങൾക്ക് ഉപയോഗിക്കുന്ന ആൽഗോരിതങ്ങളെയും ഒപ്റ്റിമൈസ് ചെയ്യാൻ കഴിയും. ഉദാഹരണമായി, നിരവധി സി കംപൈലറുകളിൽ ഫ്ലോട്ടിംഗ് പോയിന്റ് (float) ഡാറ്റാ ടൈപ്പ് 32 ബിറ്റിൽ പ്രതിനിധാനം ചെയ്യപ്പെടുന്നു, ഐട്രിപ്പിൾഇ 754-2008(IEEE 754-2008 എന്നത് കമ്പ്യൂട്ടറുകൾ ഫ്ലോട്ടിംഗ്-പോയിന്റ് നമ്പറുകൾ എങ്ങനെ പ്രതിനിധീകരിക്കുകയും കൈകാര്യം ചെയ്യുകയും ചെയ്യാമെന്ന് നിർവചിക്കുന്ന ഒരു മാനദണ്ഡമാണ്, ഇത് വ്യത്യസ്ത സിസ്റ്റങ്ങൾ തമ്മിൽ ഗണനകളിൽ സ്ഥിരത ഉറപ്പാക്കുന്നു. ഇത് സംഖ്യകൾ പ്രതിനിധീകരിക്കുന്നതിനുള്ള മാർഗങ്ങളും, റൗണ്ടിംഗ്, ഇൻഫിനിറ്റി പോലുള്ള പ്രത്യേക മൂല്യങ്ങൾ എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്നും വിശദീകരിക്കുന്നു.) സവിശേഷത അനുസരിച്ച് ഇത് ഒരു സിംഗിൾ-പ്രെസിഷൻ ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറായിരിക്കും. ഇതിനാൽ, കംപൈലർ ആ മൂല്യങ്ങൾക്ക് ഫ്ലോട്ടിംഗ്-പോയിന്റ് പ്രത്യേകമായ മൈക്രോപ്രോസസർ പ്രവർത്തനങ്ങൾ (ഫ്ലോട്ടിംഗ് പോയിന്റ് ഡാറ്റാ ടൈപ്പിൽ സംഖ്യകൾ കൂട്ടിച്ചേർക്കുക, ഗുണനം എന്നിവ) ഉപയോഗിക്കും.
## ടൈപ്പ് ചെക്കിംഗ്
ടൈപ്പ് പരിശോധിക്കൽ എന്നത്, ഡാറ്റയുടെ ടൈപ്പ് ശരിയാണോ എന്ന് ഉറപ്പാക്കുന്ന പ്രക്രിയയാണ്. ഇത് കമ്പൈൽ സമയത്ത് (static check) കോഡ് പ്രവർത്തിക്കുന്നതിന് മുമ്പ് പരിശോധിക്കാം, അല്ലെങ്കിൽ റൺടൈമിൽ (dynamic check) പ്രോഗ്രാം പ്രവർത്തിക്കുമ്പോൾ തന്നെ പരിശോധിക്കാം.

ഒരുപാട് നിയന്ത്രണങ്ങളോടെയുള്ള ഭാഷകളിൽ ഡാറ്റയുടെ ടൈപ്പ് മാറ്റം യാന്ത്രികമായി നടക്കില്ലെങ്കിൽ അതിനെ സ്ട്രോംഗ്‌ലി ടൈപ്ഡ്(strongly typed) എന്നു വിളിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു നമ്പർ സ്ട്രിംഗ് ആക്കാൻ കഴിയും എന്നു പറഞ്ഞ് എളുപ്പത്തിൽ മാറ്റം നടക്കില്ല. വീക്ലി ടൈപ്ഡ്(weakly typed) ഭാഷകളിൽ ടൈപ്പ് പരിവർത്തനങ്ങൾ കൂടുതൽ ഇളവുകളോടെ, കുറച്ചു നിയന്ത്രണങ്ങൾ മാത്രമുണ്ടാകും. ഇത് ചിലപ്പോൾ ദോഷകരമായ പിഴവുകൾക്ക് കാരണമാകും, എന്നാൽ സുഗമമായ പ്രോഗ്രാമിംഗ് അനുഭവവം നൽകുന്നു.

മേൽ പറഞ്ഞ പദങ്ങൾ (സ്ട്രോംഗ്‌ലി ടൈപ്ഡ്, വീക്ലി ടൈപ്ഡ്) കൃത്യമായ അർത്ഥത്തിൽ അല്ല, പൊതുവായി ഉപയോഗിക്കപ്പെടുന്നതാണ്. ഒരു ഭാഷ ടൈപ്പ് ചട്ടങ്ങൾ എത്ര കർശനമായി പാലിക്കുന്നു എന്ന് ഇത് സൂചിപ്പിക്കാനാണ് ഇവയുടെ ഉപയോഗം. എന്നാൽ, വ്യത്യസ്ത സാഹചര്യങ്ങളിൽ ഇവയ്ക്ക് ഇളവുകൾ ഉണ്ടാകും.
### സ്റ്റാറ്റിക് ടൈപ്പ് ചെക്കിംഗ്
സ്റ്റാറ്റിക് ടൈപ്പ് ചെക്കിംഗ് ഒരു പ്രോഗ്രാമിന്റെ കോഡ് എവിടെയെങ്കിലും തെറ്റായി ടൈപ്പുകൾ ഉപയോഗിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കുന്ന പ്രക്രിയയാണ്. ഇത് പ്രോഗ്രാമിന്റെ പ്രവർത്തനത്തിലെ സുരക്ഷ ഉറപ്പാക്കാൻ സഹായിക്കുന്നു. ടൈപ്പ് സുരക്ഷയുള്ള ഭാഷകളിൽ, കമ്പൈലർ പ്രോഗ്രാമിന്റെ ടൈപ്പ് ശരിയാണെന്ന് ഉറപ്പിക്കുമ്പോൾ, പ്രോഗ്രാമിന്റെ പ്രവർത്തനത്തിൽ അധിക പരിശോധനകൾ ആവശ്യമില്ലാതാകും, പ്രോഗ്രാം കൂടുതൽ കാര്യക്ഷമമായി പ്രവർത്തിക്കും, അതിനാൽ അത് വേഗത്തിൽ പ്രവർത്തിക്കുകയും ഓപ്പറേറ്റിങ് സിസ്റ്റത്തിൽ മെമ്മറി എളുപ്പത്തിൽ ഉപയോഗിക്കുകയും ചെയ്യും. റൺടൈം സമയത്ത് ടൈപ്പ് പരിശോധനകൾ നടത്തേണ്ടതില്ല, അതുകൊണ്ട് ആ പ്രോഗ്രാമിനെ ചെറുതാക്കി (കുറഞ്ഞ വോളിയം) പ്രവർത്തിപ്പിക്കാൻ സാധിക്കും.

ട്യൂറിംഗ്-കംപ്ലീറ്റ് ഭാഷകളിൽ(ട്യൂറിംഗ്-കംപ്ലീറ്റ് ഭാഷകൾ അഥവാ, പ്രോഗ്രാമുകൾക്ക് എത്ര സങ്കീർണ്ണമാണെങ്കിലും പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ കഴിയുന്ന ഭാഷകൾ ആണ്. ഇത്തരം ഭാഷകളിൽ വിവിധ രീതിയിൽ പ്രവർത്തിക്കാനും, പ്രോഗ്രാമുകൾ സൃഷ്ടിക്കാനും സാധിക്കും.) സ്റ്റാറ്റിക് ടൈപ്പ് ചെക്കിംഗ് സൂക്ഷ്മമായിരിക്കുകകൊണ്ട് പല തെറ്റുകൾ കണ്ടെത്തിയാലും എല്ലാ തെറ്റുകളും നിരസിക്കാനാവില്ല. പ്രോഗ്രാമിന്റെ ടൈപ്പ് പരിമിതികളുമായി അനുയോജ്യമായിരിക്കുമെന്ന് ഉറപ്പുവരുത്തുന്നവയ്ക്ക് സ്റ്റാറ്റിക് ടൈപ്പ് ചെക്കിംഗ് പ്രായോഗികമായി ഉപയോഗപ്രദമാണ്, എന്നാൽ പ്രോഗ്രാമിന്റെ പ്രവർത്തനം മുഴുവൻ പരിശോധിക്കുകയില്ല, പ്രത്യേകിച്ച് റൺടൈം പിശകുകൾ ഉണ്ടാകുന്നുവെങ്കിൽ. പ്രോഗ്രാമിന്റെ എല്ലാ ഭാഗങ്ങളും ശരിയാണോ എന്ന് പൂർണ്ണമായും ഉറപ്പാക്കാനാകുന്ന ഒരു ആൽഗോരിതം ഇല്ല. അതിനാൽ, ശരിയായ ടൈപ്പുകളുള്ള പ്രോഗ്രാമുകൾ പോലും റൺടൈം പിശകുകൾ നേരിടാൻ സാധ്യതയുള്ളതാണ്. ഉദാഹരണത്തിന്, താഴെ കൊടുത്തിരിക്കുന്ന കോഡ് അടങ്ങുന്ന ഒരു പ്രോഗ്രാം പരിഗണിക്കുക
:`if <complex test> then <do something> else <signal that there is a type error>`

ഉദാഹരണത്തിന്, പ്രോഗ്രാമിന്റെ പ്രവർത്തന സമയത്ത് എപ്പോഴും സത്യമാകും(true) എന്ന് പറയുന്നു, എന്നാൽ എങ്കിലും പ്രോഗ്രാമിൽ അത് എപ്പോഴും പരിശോധിക്കേണ്ടതാണ്. ചില ഭാഗങ്ങൾ പ്രോഗ്രാമിൽ ഒരിക്കലും ഉപയോഗിക്കപ്പെടുന്നില്ലെങ്കിൽ, ടൈപ്പ് ചെക്കർ അവിടെയുള്ള പിശകുകൾ കണ്ടെത്താൻ പ്രയാസപ്പെടും. ഉദാഹരണത്തിന്, ഒരു "if-else" ഭാഗം ഉണ്ടെങ്കിൽ, അതിൽ "else" ഭാഗം ഒരിക്കലും പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, ടൈപ്പ് ചെക്കർ അത് എളുപ്പത്തിൽ കണ്ടുപിടിക്കില്ല. ഇതുകൊണ്ട്, 100% ടെസ്റ്റുകൾ നടത്തി, കോഡ് മുഴുവനും പരിശോധിച്ചാലും, ഈ പ്രശ്നങ്ങൾ(type error) കണ്ടുപിടിക്കാൻ പറ്റില്ല. കാരണം, ഓരോ ഭാഗത്തിന്റെ എവിടെ, എങ്ങനെ ഉപയോഗിക്കപ്പെടുന്നു എന്നും, അവയുടെ ഇടയിൽ എന്തു മാറ്റം നടക്കും എന്നും ആലോചിച്ച് പരിശോധിക്കേണ്ടതുണ്ട്.

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

ചില പ്രോഗ്രാമിംഗ് ഭാഷകൾക്ക് ജനറൽ ടൈപ്പ് ചെക്കിംഗ് ഒഴിവാക്കാനുള്ള വഴികൾ ഉണ്ട്. ചിലപ്പോൾ പ്രോഗ്രാമർക്ക് സ്റ്റാറ്റിക്ക് ചെക്കിംഗ് (നിശ്ചിത ടൈപ്പ് മാത്രം ഉപയോഗിക്കാൻ സാധിക്കുന്നത്) ഇല്ലാതാക്കി ഡൈനാമിക് ടൈപ്പ് (വിവിധ തരം ടൈപ്പുകൾ ഉപയോഗിക്കാൻ കഴിയുന്നത്) പരീക്ഷണങ്ങൾ നടത്താം. ഉദാഹരണത്തിന്, സി# ഭാഷയിൽ സാധാരണയായി മാറ്റങ്ങൾ (variables) ഒരു നിശ്ചിത ടൈപ്പോടെ ഉപയോഗിക്കുന്നു. ഇതിന്റെ അർത്ഥം ഒരു പ്രത്യേക ടൈപ്പ് (specific type) മുൻകൂട്ടി നിശ്ചയിച്ചിരിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു സംഖ്യ (number) അല്ലെങ്കിൽ ടെക്സ്റ്റ് മാത്രം ഉപയോഗിക്കാം, അതിൽ മാറ്റം വരുത്താൻ കഴിയില്ല. എന്നാൽ സി# 4.0-ൽ ഡൈനാമിക് എന്ന ഒരു പുതിയ ആശയം അവതരിപ്പിച്ചു, അത് ഉപയോഗിച്ച് ടൈപ്പ് എതാണെന്ന് റൺടൈമിൽ (പ്രോഗ്രാം പ്രവർത്തിക്കുമ്പോൾ) പരിശോധന നടത്താവുന്നതാണ്. ഇതിലൂടെ പ്രോഗ്രാമർമാർക്ക് മാറ്റങ്ങൾക്കായി കൂടുതൽ സ്വാതന്ത്യം ലഭിക്കുന്നു. ചില പ്രോഗ്രാമിംഗ് ഭാഷകൾ, ഉദാഹരണത്തിന് സി, ടൈപ്പ് സുരക്ഷയുടെ പരിധി തകർത്ത് കോഡ് എഴുതാൻ സാധ്യമാക്കുന്നു. സിയിൽ, വ്യത്യസ്തമായ തരത്തിലുള്ള മൂല്യങ്ങൾ ഒരേ വലിപ്പത്തിൽ എളുപ്പം പരിവർത്തനം ചെയ്ത് ഉപയോഗിക്കാം ഉദാഹരണത്തിന്, ഒരു ഇന്റിജർ (integer) ഫ്ളോട്ട് (float) ആയി മാറിയാൽ, അവയുടെ സൈസ് ഒരേ പോലെ ആയിരിക്കാം അതായത്, ഇത് രണ്ടും സാധാരണമായ രീതിയിൽ 4 ബൈറ്റ് മാത്രം ഉപയോഗിക്കും ഇത് ടൈപ്പിന്റെ ആശയത്തെ അവഗണിക്കുന്നു. ഇത് ചിലപ്പോഴൊക്കെ പിശകുകൾ അല്ലെങ്കിൽ അനിഷ്ട ഫലങ്ങൾ ഉണ്ടാക്കാം.

## അവലംബം