කෝඩ් කරන්න පටන් ගත්තම අපිට හැමෝම කියන්නේ “Clean Code” ගැනනේ. “SOLID Principles” පාවිච්චි කරන්න, හැමදේම “Perfect” වෙන්න ඕනේ කියලා අපි හැමතිස්සෙම හිතනවා. හැබැයි තනියම වැඩක් කරන කෙනෙක්ට (Solo Developer) මේ හැමදේම අකුරටම කරන්න ගියාම වෙන්නේ පට්ටම මහන්සියක් දැනෙන එකයි, නැත්නම් වැඩේ එපා වෙන එකයි.
අපි හුඟක් වෙලාවට අමතක කරන දෙයක් තමයි, සොෆ්ට්වෙයාර් එකක් කියන්නේ ජීවමාන දෙයක් මිසක් කෞතුකාගාරයක තියන්න හදන පිළිමයක් නෙවෙයි කියලා. ඉතින් අද අපි කතා කරමු “Perfect” වෙන්නම දඟලන්නේ නැතුව, “හොඳටම ඇති” (Good Enough) මට්ටමට වැඩේ කරගන්නේ කොහොමද සහ ඒකෙන් ඔයාගේ ජීවිතේ කොහොමද ලේසි වෙන්නේ කියලා!
1. මොකක්ද මේ “හොඳටම ඇති” කියන්නේ?
බය වෙන්න එපා, “හොඳටම ඇති” කියන්නේ බාල වැඩක් කරනවා හෝ වැරදි කෝඩ් ලියනවා කියන එක නෙවෙයි! ඒක හරිම සියුම් කලාවක්. ඒකෙන් අදහස් කරන්නේ මේ කරුණු ටිකයි:
- වැඩේ හරියට වෙනවා: පාවිච්චි කරන කෙනාට ඕන දේ කිසිම අවුලක් නැතුව වෙනවා. බග්ස් නැහැ කියලා 100% සහතික වෙන්න බැරි වුණත්, ඇප් එක සාර්ථකව රන් වෙනවා.
- ආරක්ෂාව තියෙනවා: ඇප් එක ස්ථාවරයි, දත්ත ආරක්ෂිතයි. ප්රධාන දොරවල් සේරම වහලා තියෙන්නේ, ඒ නිසා කිසිම බයකුත් නැහැ.
- ඔළුව පටලවන්නේ නැහැ: ඕනෑවට වඩා සංකීර්ණ abstractions (Patterns) දාලා වැඩේ අනාගෙන නැහැ. කවුරු හරි පස්සේ වෙලාවක බැලුවොත් “ආ මේක මෙහෙමයි වෙන්නේ” කියලා තේරෙන මට්ටමට සරලයි.
සරලවම කිව්වොත්, ඇප් එක සුපිරියටම හදනකම් අවුරුදු ගාණක් බලන් ඉන්නේ නැතුව, මිනිස්සුන්ට පාවිච්චි කරන්න පුළුවන් මට්ටමට ආපු ගමන් ඒක එළියට දාන එකයි මෙතන වෙන්නේ! මතක තබා ගන්න, “කෝඩ් එකක් කියන්නේ ඔයා නඩත්තු කරන්න ඕන වගකීමක් (Liability), ඒක ඔයාගේ අයිතිවාසිකමක් (Asset) නෙවෙයි.” ලියන කෝඩ් පේළි ගාණ අඩු වෙන තරමට ඔයාගේ ඔළුවට තියෙන බරත් අඩුයි.
2. වැඩේ ඕනෑවට වඩා සංකීර්ණ කළොත් (Over-engineering) මොකද වෙන්නේ?
සමහර දක්ෂ ඩෙවලොපර්ලාට හිතෙනවා ලියන හැම පේළියක්ම ලෝකේ හොඳම එක වෙන්න ඕනේ කියලා. හැබැයි එහෙම හිතන්න ගියොත් ඔයා නොදැනුවත්වම ඔයාටම බරක් පටවා ගන්නවා:
- කාලය නාස්ති වීම (Analysis Paralysis): පොඩි feature එකක් කරන්නත් දවස් ගාණක් “මේකට පාවිච්චි කරන්නේ මොන framework එකද?” කියලා හිත හිත ඉන්න වෙනවා. අන්තිමට බැලුවම වැඩේ කෙරිලත් නැහැ, කාලෙත් ඉවරයි.
- නඩත්තු කරන්න අමාරු වීම: තනියම වැඩ කරන කොට “පස්සේ කාලෙක ඕන වෙයි” කියලා හිතලා ලොකු ලොකු architecture හදන්න ගියොත්, මාස හයකට පස්සේ ඒ කෝඩ් එක බලද්දී ඔයාටම ඒක තේරුම් ගන්න බැරි වේවි.
- වැඩේ ඉවර කරන්න බැරි වීම: සොෆ්ට්වෙයාර් එකක් 90% ක් ඉවර කරන එක ලේසියි. හැබැයි අර ඉතිරි 10% “Perfect” කරන්න යන මහන්සිය මුල් 90% ට වඩා වැඩියි. මේක නිසා ගොඩක් අය හොඳ ප්රොජෙක්ට් අතරමග නතර කරනවා.
- ඇත්තටම ඕන නැති දේට වියදම් කිරීම: ඔයාගේ ඇප් එකට යූසර්ලා 10ක් එද්දී මිලියනයක් එයි කියලා හිතලා සර්වර් සෙට් කරන්න ගියොත්, වැඩේ ලස්සන වුණාට ඔයාගේ පසුම්බිය හිස් වේවි!
3. වැඩේ ගොඩ දාගන්න “මැද මාවත”
වැඩේ අනාගන්නේ නැතුව, ඒ වගේම ඕනෑවට වඩා මහන්සි නොවී ඉන්න මේ ප්රායෝගික දේවල් මතක තියාගන්න:
- දැන් ඕන දේ විතරක් කරන්න (YAGNI): “You Ain’t Gonna Need It” කියන එකේ තේරුම තමයි දැන් අවශ්ය නැති දේවල් පස්සට තියන්න කියන එකයි. “පස්සේ කාලෙක මේක ඕන වෙයි” කියලා හිතලා දැන්ම අමතර කෝඩ් ලියන්න එපා.
- මිනිස්සුන්ට දෙන්න (Validation First): ඔයා හදන දේ මිනිස්සු පාවිච්චි කරයිද කියලා දන්නේ නැතුව මාස ගණන් කෝඩ් කරලා වැඩක් නැහැ. පුළුවන් ඉක්මනට පාවිච්චි කරන්න දීලා බලන්න (MVP). යූසර්ලා කැමති නම් විතරක් ඒක තව දියුණු කරන්න.
- ඕන වෙලාවට හදන්න (Just-in-Time Refactoring): කෝඩ් එකේ පොඩි අවුලක් තිබුණට කමක් නැහැ ඒක වැඩ කරනවා නම්. ඔයා ඒක හදන්න ඕනේ ඇත්තටම අලුත් feature එකක් දාද්දී ඒ කෝඩ් එක බාධාවක් වෙනවා නම් විතරයි. නැත්නම් ඒක “හොඳටම ඇති”!
4. හිත නිදහස් කරගමු (The Mindset Shift)
අපි හැමතිස්සෙම “Perfect” වෙන්න උත්සාහ කරන්නේ නැති වුණාම හිතට පොඩි වරදකාරී හැඟීමක් එන්න පුළුවන්. “මම බාල වැඩක් කරනවාද?” කියලා හිතෙන්න පුළුවන්. ඒක අමතක කරලා මේ ටික හිතන්න:
- එළියට දාන එක තමයි ලොකුම ජයග්රහණය: ලෝකේ තියෙන ලස්සනම කෝඩ් එක වුණත් කාටවත් පාවිච්චි කරන්න බැරි නම් ඒක මළ පොතක් වගෙයි. “Shipping is a feature” කියලා කියමනක් තියෙනවා—ඒ කියන්නේ ඇප් එක නියමිත වෙලාවට එළියට දාන එකත් ඔයාගේ දක්ෂතාවයක්.
- වැදගත් වෙන්නේ වටිනාකමයි: ඔයාගේ කෝඩ් එකේ ලස්සන බලන්නේ ඔයා විතරයි. යූසර් බලන්නේ “මේකෙන් මගේ ප්රශ්නය විසඳෙනවාද?” කියලා විතරයි.
- මොළයට නිදහස (Cognitive Load): හැමතිස්සෙම පරිපූර්ණ වෙන්න දඟලන්නේ නැති වුණාම ඔයාගේ මොළයට ලැබෙන ඉඩ ගොඩක් වැඩියි. ඒ ඉඩ පාවිච්චි කරලා අලුත් අදහස් හිතන්න ඔයාට පුළුවන්.
5. ඔයාට ප්රායෝගික උපදෙස් ටිකක්
- “Done” කියන්නේ මොකක්ද කියලා ලියන්න: වැඩක් පටන් ගන්න කලින් “මෙන්න මේ ටික වුණොත් මේ වැඩේ ඉවරයි” කියලා ලැයිස්තුවක් හදාගන්න. ඒ ටික වුණාම නවතින්න.
- වැදගත් දේට විතරක් ටෙස්ට් (Tests) ලියන්න: ඇප් එකේ හැම පොඩි බටන් එකකටම ටෙස්ට් ලිය ලිය කාලේ කන්න එපා. යූසර්ට පේන්න තියෙන වැදගත්ම “Core Logic” එකට විතරක් ටෙස්ට් ලියන්න.
- සරලව කියවන්න පුළුවන් වෙන්න ලියන්න: කවුරු හරි පණ්ඩිතයෙක්ට වුණත් ඔයාගේ කෝඩ් එක කියවද්දී තේරෙනවා නම්, ඒක තමයි ලෝකේ හොඳම කෝඩ් එක. සංකීර්ණ දේවල් දාන්නේ නැතුව සරලව ලියන්න.
- Boring Technology පාවිච්චි කරන්න: හැමදාම එන අලුත් අලුත් frameworks පස්සේ දුවන්නේ නැතුව, ඔයා හොඳට දන්න ස්ථාවර තාක්ෂණය පාවිච්චි කරන්න. එතකොට ඔයාට තියෙන්නේ ප්රශ්නය විසඳන්න විතරයි, ටූල්ස් ඉගෙන ගන්න නෙවෙයි.
අවසාන අදහස
හැමදාම “Perfect” වෙන්න දඟලන්න එපා. ඔයා තනියම වැඩ කරන කෙනෙක් නම්, ඔයාගේ ලොකුම සතුරා තමයි ඔයාගේම “Perfectionism” එක. ඒක ඔයාව අඩපණ කරන්න පුළුවන්. ඉතින් කරන්න තියෙන දේ “හොඳටම ඇති” මට්ටමට කරන්න, ඉතිරි ටික යූසර්ලා එන්න එන්න ලස්සනට හදාගන්න ඔයාට ඕන තරම් කාලය ලැබේවී!
උපුටා ගැනීම : Nelaka Withanage
