ഒരു പുതിയ ഭാഷ പഠിച്ചു തുടങ്ങുമ്പോൾ വേഗത്തിൽ ഓടിത്തുടങ്ങാമെന്ന് നിങ്ങൾ പ്രതീക്ഷിക്കുന്നു, എന്നാൽ ആദ്യത്തെ ചുവടുവെപ്പിൽ തന്നെ നിങ്ങൾ തട്ടി വീഴുന്നുണ്ടെങ്കിൽ ആ അനുഭവം നിങ്ങൾക്ക് അറിയാമോ? Rust പഠിക്കാൻ ശ്രമിച്ചപ്പോൾ എനിക്കും അങ്ങനെയായിരുന്നു. എനിക്ക് കൃത്യമായി പ്രവർത്തിക്കുന്ന ഒരു JavaScript യൂട്ടിലിറ്റി ഉണ്ടായിരുന്നു — കുറച്ച് arrays പാഴ്സ് ചെയ്യാനും അവയിൽ മാറ്റം വരുത്താനും ഉപയോഗിക്കുന്ന ഒന്ന് — ഒരു കോഫി ബ്രേക്കിനിടയിൽ അത് Rust-ലേക്ക് മാറ്റിയെഴുതാം എന്ന് ഞാൻ കരുതി. ഞാൻ എന്റെ എഡിറ്റർ തുറന്നു, സ്വാഭാവികമായി തോന്നുന്ന രീതിയിൽ കോഡ് ടൈപ്പ് ചെയ്തു, കംപൈലർ റൺ ചെയ്തു. അത് തകർന്നുപോയി. Syntax errors കൊണ്ടല്ല. Missing semicolons കൊണ്ടുമല്ല. പകരം, ഞാൻ ഇതിനകം തന്നെ 'move' ചെയ്ത ഒരു മൂല്യം ഉപയോഗിക്കാൻ ശ്രമിച്ചു എന്നാണ് കംപൈലർ പറഞ്ഞത്. ഞാൻ സ്ക്രീനിലേക്ക് നോക്കി നിന്നു. Moved? ഞാൻ ഒന്നും മാറ്റുകയല്ല ചെയ്തത്. ഞാൻ അത് മറ്റൊരു വേരിയബിളിലേക്ക് അസൈൻ ചെയ്തു എന്ന് മാത്രം.
JavaScript-ന്റെ കംഫർട്ട് സോൺ
ഡാറ്റയെ ഒരു പൊതു വൈറ്റ്ബോർഡ് പോലെ കൈകാര്യം ചെയ്യാൻ JavaScript നിങ്ങളെ പഠിപ്പിക്കുന്നു. നിങ്ങൾ ഒരു object അല്ലെങ്കിൽ ഒരു array പ്രഖ്യാപിക്കുന്നു, അത് ഒരു function-ന് നൽകുന്നു, ആ function അതിൽ ഒരു property ചേർക്കുന്നു, എന്നിട്ട് അത് മറ്റൊരിടത്തേക്ക് കൈമാറുന്നു. Garbage collector ഒരു അദൃശ്യനായ തൂപ്പുകാരനെപ്പോലെ പശ്ചാത്തലത്തിൽ ഇരിക്കുന്നു, നിങ്ങൾ ഉപേക്ഷിക്കുന്നതെന്തും വൃത്തിയാക്കാൻ കാത്തിരിക്കുന്നു. "ഈ string-ന്റെ ഉടമസ്ഥൻ ആരാണ്?" എന്ന് നിങ്ങൾ ഒരിക്കലും ചോദിക്കില്ല. പകരം, "എനിക്ക് ഇത് വായിക്കാൻ കഴിയുമോ?" എന്നാണ് നിങ്ങൾ ചോദിക്കുന്നത്. ഉത്തരം 'അതെ' എന്നാണെങ്കിൽ, നിങ്ങൾ അത് ഉപയോഗിക്കുന്നു. നിങ്ങൾക്ക് മറ്റൊരു reference ആവശ്യമുണ്ടെങ്കിൽ, നിങ്ങൾ let b = a എന്ന് നൽകി മുന്നോട്ട് പോകുന്നു. രണ്ട് വേരിയബിളുകളും ഒരേ മെമ്മറി ഭാഗത്താണ് സൂചിപ്പിക്കുന്നത്, a അതിൽ മാറ്റം വരുത്തിയാൽ b-ക്കും ആ മാറ്റം ഉടൻ തന്നെ കാണാൻ കഴിയും. ഇത് സൗകര്യപ്രദമാണ്. ഇത് അല്പം കുഴപ്പമുണ്ടാക്കുന്നതാണെങ്കിലും, runtime വൃത്തിയാക്കൽ കൈകാര്യം ചെയ്യുന്നതുകൊണ്ട് ആ കുഴപ്പങ്ങൾ നിങ്ങളെ ബാധിക്കാറില്ല.
ആദ്യത്തെ കംപൈലർ ഷോക്ക്
Rust നിങ്ങളെ വിശ്വസിക്കുന്നില്ല. ഇത് കേൾക്കുമ്പോൾ കഠിനമായി തോന്നാം, പക്ഷേ നിങ്ങൾ ആദ്യം പഠിക്കുന്ന കാര്യമാണിത്. മൂന്ന് കർശനമായ നിയമങ്ങളുള്ള ഒരു ownership system-നെ അടിസ്ഥാനമാക്കിയാണ് ഈ ഭാഷ നിർമ്മിച്ചിരിക്കുന്നത്. ഒന്നാമതായി, ഓരോ value-യ്ക്കും കൃത്യമായി ഒരു ഉടമസ്ഥൻ മാത്രമേ ഉണ്ടാകൂ. രണ്ടാമതായി, ഒരു സമയത്ത് ഒരു ഉടമസ്ഥൻ മാത്രമേ ഉണ്ടാകൂ. മൂന്നാമതായി, ആ ഉടമസ്ഥൻ scope-ന് പുറത്തായിക്കഴിഞ്ഞാൽ, Rust ആ value-യെ സ്വയമേവ ഒഴിവാക്കുന്നു (drops). Garbage collector ഇല്ല. നിങ്ങൾ പ്രത്യേകം ആവശ്യപ്പെടാത്തിടത്തോളം പശ്ചാത്തലത്തിൽ reference counting-ഉം ഇല്ല. നിങ്ങളുടെ കോഡ് പ്രവർത്തിക്കുന്നതിന് മുമ്പ് തന്നെ കംപൈലർ നടപ്പിലാക്കുന്ന ഈ മൂന്ന് നിയമങ്ങൾ മാത്രം.
ആ JavaScript യൂട്ടിലിറ്റിയുടെ Rust പതിപ്പ് എഴുതിയപ്പോൾ, എനിക്ക് സ്വാഭാവികമെന്ന് തോന്നിയ രീതിയിലാണ് ഞാൻ ചെയ്തത്. ഞാൻ ഒരു vector നിർമ്മിച്ചു (ഇത് array-യ്ക്ക് പകരമായി Rust ഉപയോഗിക്കുന്നതാണ്), അത് രണ്ടാമതൊരു വേരിയബിളിലേക്ക് നൽകി. എന്നിട്ട് ആദ്യത്തേത് ഉപയോഗിക്കാൻ ശ്രമിച്ചു. കംപൈലർ അത് നിരസിച്ചു. JavaScript-ൽ let b = a എന്നത് reference കോപ്പി ചെയ്യുന്നു. എന്നാൽ Rust-ൽ, അത് ownership മാറ്റുന്നു. യഥാർത്ഥ വേരിയ