Node.js සේවාවක් ලියන අතර, එකම object එකක් විවිධ function වලට යවා, හඬක් මෙන්ම අහඹු බග් එකක් හමුවීම සාමාන්යයයි. ප්රොඩක්ශන් වලදී "Cannot read property 'map' of undefined" වැනි දෝෂයක් හදිසි ලෙස පෙනෙන්නේ, ඔබේ කේතය කුමන කොටසෙන් අයිතිය ගත කරගෙන තිබේද යන්න නොදැනීම නිසාය.
මෙවැනි ගැටළුවලට විසඳුමක් ලෙස, Rust භාෂාවේ Ownership System එක අපිට හොඳ මාර්ගයක් සපයයි. මේ පද්ධතිය තුළ, දත්ත කුමකට අයත්ද, එය කීතරම් කාලයක් පවත්නාද, කවුරුන්ට කියවන්න/වෙනස් කරන්න පුළුවන්ද යන ප්රශ්න තුනට පිළිතුරු දෙනවා. ඒ පිළිතුරු සපයා, compiler එක මඟින් dangling pointer, use‑after‑free, data race වැනි ගැටළු ඉදිරියටම වැළැක්වීමේ හැකියාව ලැබේ.
Move Semantics – "දෙනවා" නීතිය JavaScript වලදී let b = a; කියන්නේ reference එකක් පිටපත් කිරීමයි. Rust එකේ, let b = a; කියන වරදක් ownership එක a වෙතින් b වෙත මාරු කරනවා. මාරු වීමෙන් පසු a භාවිතා කළ නොහැක, එය compile‑time error එකක් ලෙස පෙන්වයි. ඔබට දෙදෙනාටම එකම data එක අවශ්ය නම්, clone() කියා explicit copy එකක් කළ යුතුය – මෙයින් memory cost එක දෘශ්යමාන වේ.
Borrowing & Lifetimes – "උපහාර" නීතිය Rust හි & (immutable borrow) සහ &mut (mutable borrow) භාවිතා කර ownership එක නොතැරැව්වම data එකට ප්රවේශය ලබා දිය හැක. නීතිය මෙහි: එක data එකට එකවර immutable borrows කිසිවක් නොසීමා, හෝ mutable borrow එකක් පමණක් තිබිය හැක. එම නිසා multithreaded කේතයක data race එකක් සිදු වීමේ අවදානම compile‑time එකේම ඉවත් වේ.
Lifetimes – "කාල සීමා" නීතිය සෑම reference එකක්ම කාල සීමාවක් (lifetime) ගනී. බොහෝ විට compiler එක ඒවා ස්වයංක්රීයව ගණනය කරයි, නමුත් function එකකින් reference එකක් return කිරීමේදී, එම reference එකේ lifetime එක input variable එකකට සම්බන්ධ කර දීමට ඔබට annotation එකක් (උදා: 'a) ලියන්නට සිදු වේ. මෙය memory safety තහවුරු කරයි.
ශ්රී ලංකාවට ඇති වැදගත්කම
මෙම ownership concept එක ශ්රී ලංකාවේ තාක්ෂණික ශිෂ්යයන්ට, ඩිවෙලොපර්ලාට, ව්යාපාරිකයන්ට බොහෝ වාසියක් ගෙන දේ. පාසල්‑උසස් පාසල් තලයේ programming පාඨමාලාවල Rust එක ඇතුළත් කිරීමෙන්, memory safety සහ concurrency පිළිබඳ ගැඹුරු අවබෝධයක් ලබා ගත හැක. දේශීය start‑up සමාගම් Node.js මත පදනම් වූ back‑end පද්ධති අලුත් කර, Rust භාවිතයෙන් performance හා reliability වැඩි කර ගැනීමට හැකියාව ලැබේ. එමෙන්ම, ගෝලීය තරඟවල (උදා: Google Summer of Code, RustConf) සාර්ථකත්වය සඳහා මෙම නව paradigm එක ඉගෙන ගැනීම අත්යවශ්ය වේ.
අවසන් වශයෙන්, Rust හි ownership system එක JavaScript developers සඳහා “කොඩ් එකේ කුමන අයිතිය කවුරුන්ගෙන්ද?” යන ප්රශ්නයට තක්ෂණික, compile‑time පිළිතුරක් ලබා දේ. එය ඔබේ කේතය වඩාත් ආරක්ෂිත, වේගවත්, සහ multithreaded පරිසරයට සුදුසු කරයි.
