Mastering Code Quality: Review & Refactor SC Guide

ඉතින් කොහොමද යාලුවනේ? ඔන්න අදත් ආවා අලුත් Software Engineering මාතෘකාවක් අරගෙන. ඔයාලා දන්නවා ඇති අපි Software develop කරද්දි Code ලියන එක විතරක් නෙවෙයි වැදගත් වෙන්නෙ කියලා. අපි ලියන Code එක කොච්චර හොඳට තියෙනවද, අනිත් අයට තේරුම් ගන්න පුලුවන්ද, future එකේදි වෙනස් කරන්න ලේසිද කියන දේත් ගොඩක් වැදගත්. මොකද වැඩේ ඉවර කරලා දානවා වගේම, ඒක maintain කරන එකත් ගොඩක් අමාරු දෙයක්. අද අපි කතා කරන්නේ ඒ වගේ වැදගත් මාතෘකා දෙකක් ගැන. ඒ තමයි "Code Review" සහ "Refactoring". මේ දෙක අපේ Programming ජීවිතේට කොච්චර වැදගත්ද කියලා අපි ගැඹුරින්ම බලමු.

ඇයි මේ Code Review එකක් කරන්න ඕනෙ?

හිතන්නකෝ ඔයා තනියම Application එකක් හැදුවා කියලා. හැදුවට පස්සෙ ඒක release කරනවා. හැබැයි මාස දෙකක් යද්දි ලොකු Bug එකක් එනවා. එතකොට ඔයාට තේරෙනවා හදිස්සියේ Release නොකර, කවුරුහරි කෙනෙක්ට මේ Code එක review කරන්න දුන්නා නම් මේ Bug එක කලින්ම අල්ලගන්න තිබ්බා කියලා. ඒ වගේම, කණ්ඩායමක් විදිහට වැඩ කරද්දි, අපි හැමෝම එකම Codebase එකේ වැඩ කරනවනේ. එතකොට එක් කෙනෙක් ලියන Code එක අනිත් කෙනාට තේරෙන්න ඕනේ. ඒ වගේ වෙලාවට තමයි Code Review කියන එක අපිට ගොඩක් උදව් වෙන්නෙ.

Code Review කියන්නේ සරලවම කිව්වොත්, ඔයා ලියපු Code එක අනිත් Developer කෙනෙක්ට පෙන්නලා, එයාගෙන් ඒකේ තියෙන අඩුපාඩු, වැරදි, වැඩිදියුණු කරන්න පුලුවන් දේවල් ගැන අදහස් ගන්න එක. මේක පුලුවන් Systematically විදිහට කරන්න. ඒ කියන්නෙ Pull Request එකක් හරහා Code එක Merge කරන්න කලින් review කරන එක. එහෙමත් නැත්නම් Pair Programming වගේ Technique වලින් දෙන්නෙක් එකට Code කරලා එතනදිම review කරන එක.

මේකෙන් මොනවද වෙන්නෙ කියලා බලමු:

• වැරදි අඩුවෙනවා (Reduced Bugs): Code එකේ තියෙන Logic වැරදි, Syntax වැරදි වගේ දේවල් කලින්ම අඳුරගන්න පුලුවන්.
• හොඳ Code Quality එකක් (Improved Code Quality): එකිනෙකාගේ අදහස් හුවමාරු කරගෙන Best Practices අනුව Code ලියන්න පුරුදු වෙනවා.
• දැනුම බෙදාගැනීම (Knowledge Sharing): කණ්ඩායමේ හැමෝටම Project එකේ Codebase එක ගැන හොඳ අවබෝධයක් ලැබෙනවා. අලුත් කෙනෙක් ආවොත් එයාට ඉක්මනටම Project එකට හුරු වෙන්න පුලුවන්.
• Consistency එකක් (Consistency): හැමෝම එකම Style guide එකක්, එකම Pattern එකක් පාවිච්චි කරන්න පෙළඹෙනවා.
• Security වැඩිවෙනවා (Enhanced Security): Security Vulnerabilities තියෙනවා නම් ඒවත් කලින්ම අඳුරගන්න පුලුවන්.

ඉතින්, Code Review කියන්නේ අපේ Team එකක Productivity එක වැඩි කරන, Bug අඩුවෙන් තියෙන, Quality Code එකක් ලියන්න උදව් වෙන අත්‍යවශ්‍ය දෙයක්.

හොඳ Code එකකට තියෙන්න ඕන ගතිගුණ මොනවද?

හරි, දැන් අපි Review එකක වැදගත්කම ගැන කතා කළා. එතකොට අපි Code Review කරද්දි, නැත්නම් Code ලියද්දි මොනවද බලන්න ඕනේ? හොඳ Code එකක් කියන්නේ මොකක්ද? පහත ගතිගුණ හොඳ Code එකකට අනිවාර්යයෙන්ම තියෙන්න ඕනේ.

• Maintainability (පහසුවෙන් නඩත්තු කිරීම): අනාගතයේදී Code එක වෙනස් කරන්න, අලුත් Features එකතු කරන්න, Bug fix කරන්න පහසු වෙන්න ඕනේ. Module wise, Component wise Code organize කරලා තියෙන්න ඕනේ.
• Scalability (පරිමාණය කළ හැකි වීම): Project එක ලොකු වෙද්දි, User base එක වැඩි වෙද්දි, Code එක ඒකට අනුව Adjust කරන්න පුලුවන් වෙන්න ඕනේ. Monolithic Architecture එකක හැදුවොත් අමාරුයි. Microservices වගේ Architectural patterns වලින් scalability වැඩි කරගන්න පුලුවන්.
• Efficiency (කාර්යක්ෂමතාව): Code එක ඉක්මනට වැඩ කරන්න ඕනේ. Memory, CPU usage අඩු වෙන්න ඕනේ. Algorithms, Data Structures තෝරද්දි මේ ගැන අවධානය යොමු කරන්න ඕනේ. O(n) vs O(1) or O(log n) complexities ගැන දැනගන්න එක වැදගත්.
• KISS - Keep It Simple, Stupid (සරලව තබාගන්න): ඕනාවට වඩා සංකීර්ණ Logic, Patterns පාවිච්චි නොකර සරලව ගැටලුවට විසඳුම් දෙන්න බලන්න.
• Testability (පරීක්ෂා කිරීමට පහසු වීම): Code එකට Unit Tests, Integration Tests ලියන්න පහසු වෙන්න ඕනේ. TDD (Test-Driven Development) වගේ approaches පාවිච්චි කරනවා නම් Code එක auto Testable වෙනවා.

DRY - Don't Repeat Yourself (නැවත නැවත නොකිරීම): එකම Logic එක තැන් කීපයක ලියනවා වෙනුවට, Function එකක්, Class එකක් හෝ Module එකක් විදිහට හදලා Reuse කරන්න ඕනේ.

// Bad Example (Repeating logic)
let rect1Area = width1 * height1;
let rect2Area = width2 * height2;

// Good Example (DRY principle)
function calculateRectangleArea(width, height) {
    return width * height;
}
let rect1Area = calculateRectangleArea(width1, height1);
let rect2Area = calculateRectangleArea(width2, height2);

Readability (කියවීමට පහසු වීම): Code එකක් ලියන්නේ පරිගණකයට විතරක් නෙවෙයි, අනිත් Developer කෙනෙක්ටත් කියවන්න. Variable Naming, Function Naming, Indentation, Spacing වගේ දේවල් හොඳට තියෙන්න ඕනේ.

// Bad Example
let x = 10;
// Good Example
let userAge = 10; // Much clearer!

මේ ගතිගුණ ගැන අවධානය යොමු කරලා Code ලියනවා නම්, ඒක ඔයාටත් Team එකටත් ලොකු සහනයක් වේවි.

Refactor කරනවා කියන්නෙ මොකක්ද?

හරි, දැන් අපි Review කරද්දි, 'අයියෝ මේ Code එකනම් හරියට නෑ, මේක වෙනස් කරන්න ඕනේ' කියලා හිතෙන වෙලාවල් තියෙනවා. එතනට තමයි Refactoring එන්නෙ.

Refactoring කියන්නේ, Application එකක පිටතින් පෙනෙන හැසිරීම (External Behavior) වෙනස් නොකර, ඒකේ අභ්‍යන්තර ව්‍යුහය (Internal Structure) වැඩිදියුණු කරන ක්‍රියාවලිය. සරලව කිව්වොත්, Bug එකක් Fix කරනවා වගේ නෙවෙයි. අලුත් Feature එකක් එකතු කරනවා වගේ නෙවෙයි. මේකෙන් වෙන්නෙ පවතින Code එක Clean කරන එක, Readability වැඩි කරන එක, Maintainability වැඩි කරන එක.

උදාහරණයක් විදිහට, ඔයාගේ ගෙදර හොඳට තියෙනවා. හැබැයි සමහර දේවල් අවිධිමත් විදිහට තියෙනවා නම්, ඔයා ඒවා පිළිවෙලකට දානවා. ඒකෙන් ගෙදර පිටතින් වෙනස් වෙන්නේ නෑ. හැබැයි ඇතුල හොඳට organize වෙනවා. Refactoring කියන්නේ ඒ වගේ දෙයක්.

මොකටද අපි Refactor කරන්නෙ?

• Code Design එක වැඩිදියුණු කරන්න (Improve Code Design): කැතට තියෙන Code එකක් හොඳ Design Pattern වලට අනුව හදන්න පුලුවන්.
• Code එක තේරුම් ගන්න ලේසි කරන්න (Make Code Easier to Understand): හොඳ Naming Conventions, Functions break down කිරීම වගේ දේවල් වලින් Code එක තේරුම් ගන්න පහසු වෙනවා.
• Bug හොයාගන්න ලේසි කරන්න (Find Bugs More Easily): Clean Code එකක Bug හොයාගන්න එක ලේසියි.
• Programming Speed එක වැඩි කරන්න (Increase Programming Speed): Clean Code එකක අලුත් Features එකතු කරන එක, Bug Fix කරන එක ගොඩක් වේගවත් වෙනවා.

වැදගත් දෙයක් මතක තියාගන්න: Refactoring කරද්දි, Application එකේ Functionality එක වෙනස් වෙන්න බෑ. Tests පස්සෙ Pass වෙන්න ඕනේ.

ප්‍රායෝගිකව Refactor කරමු: පොඩි Tips ටිකක්!

කතාව ඇති. අපි බලමු එහෙනම් Refactoring කරද්දි මොනවද අපිට කරන්න පුලුවන් කියලා.

• නැවත නැවත එන Code අයින් කරන්න (Remove Duplicate Code):DRY principle එක මෙතනදි වැදගත්. එකම Logic එකක් තැන් කීපයක තිබ්බොත්, ඒක වෙනස් කරන්න ඕනේ නම් හැම තැනකම වෙනස් කරන්න වෙනවා. Function එකක් හරි, Class එකක් හරි හදලා ඒක Reuse කරන්න.
• Error Handling (Error හැසිරවීම):Proper Error Handling එකක් තියෙන්න ඕනේ. Invalid Inputs, Network issues වගේ දේවල් වලට Program එක Crash වෙන්නේ නැතුව, User friendly විදිහට Error message පෙන්වන්න පුලුවන් වෙන්න ඕනේ.
• Design Patterns පාවිච්චි කරන්න (Use Design Patterns):Singleton, Factory, Observer වගේ Design Patterns තියෙනවා. මේවා පාවිච්චි කිරීමෙන් Standard, Maintainable Code එකක් ලියන්න පුලුවන්.
• Automated Tools පාවිච්චි කරන්න (Use Automated Tools):
  • Linters (ESLint, Prettier): Code Style, Potential Errors වගේ දේවල් Check කරන්න උදව් වෙනවා.
  • Static Analysis Tools: Code එක Run නොකරම Bug, Security issues හොයාගන්න උදව් වෙනවා.
  • IDEs (VS Code, IntelliJ IDEA): මේවායේ built-in Refactoring features තියෙනවා (Rename, Extract Method, etc.). මේවා පාවිච්චි කරන්න.

Comments දාද්දි පරිස්සමෙන් (Comments Wisely):Code එකෙන් තේරෙන්නේ නැති Logic එකකට විතරක් Comment දාන්න. Code එක කියෙව්වම තේරෙන දේකට Comments දාන්න ඕනේ නෑ. හොඳ Code එකක් කියන්නේ තමන්ටම Comment කරගන්න පුලුවන් Code එකක්.

// Bad Example (Redundant comment)
// this function adds two numbers
function add(a, b) {
    return a + b; // return the sum
}

// Good Example (Self-documenting code, no comment needed)
function add(firstNumber, secondNumber) {
    return firstNumber + secondNumber;
}

ලොකු Functions පොඩි කෑලි වලට කඩන්න (Break Down Large Functions):Single Responsibility Principle (SRP) කියන එක මතක තියාගන්න. එක Function එකක් එකම වැඩක් විතරක් කරන්න ඕනේ. ලොකු Function එකක් කෑලි කඩද්දි, Code එක කියවන්න පහසු වෙනවා වගේම Test කරන්නත් ලේසියි.

// Bad Example (A large function doing too many things)
function processOrder(order) {
    // Validate order
    if (!order.items || order.items.length === 0) {
        throw new Error("Order must have items.");
    }
    // Calculate total price
    let total = 0;
    order.items.forEach(item => {
        total += item.price * item.quantity;
    });
    // Apply discount
    if (order.customerType === 'premium') {
        total *= 0.9; // 10% discount
    }
    // Save order to database
    saveOrderToDB(order, total);
    // Send confirmation email
    sendConfirmationEmail(order.customerEmail, total);
    return total;
}

// Good Example (Refactored into smaller, single-responsibility functions)
function validateOrder(order) {
    if (!order.items || order.items.length === 0) {
        throw new Error("Order must have items.");
    }
    // ... more validation rules
}

function calculateOrderTotal(order) {
    let total = 0;
    order.items.forEach(item => {
        total += item.price * item.quantity;
    });
    return total;
}

function applyDiscount(total, customerType) {
    if (customerType === 'premium') {
        return total * 0.9;
    }
    return total;
}

function processOrder(order) {
    validateOrder(order);
    let total = calculateOrderTotal(order);
    total = applyDiscount(total, order.customerType);
    saveOrderToDB(order, total);
    sendConfirmationEmail(order.customerEmail, total);
    return total;
}

නොතේරෙන Variables/Functions වලට හොඳ නම් දෙන්න (Meaningful Names for Variables/Functions):

// Bad Example
function calc(a, b) {
    return a * b;
}
let x = 10, y = 5;
let z = calc(x, y); // What is 'a', 'b', 'x', 'y'? What does 'calc' do?

// Good Example
function calculateRectangleArea(width, height) {
    return width * height;
}
let rectangleWidth = 10;
let rectangleHeight = 5;
let rectangleArea = calculateRectangleArea(rectangleWidth, rectangleHeight); // Clear now!

Refactoring කියන්නේ එක පාරින්ම ඉවර කරන්න පුලුවන් දෙයක් නෙවෙයි. මේක Project එකක් Develop කරද්දි නිතරම කරන්න ඕන දෙයක්. Little by little Refactor කරන එක ගොඩක් හොඳයි.

අවසාන වශයෙන්...

ඉතින් යාලුවනේ, අද අපි කතා කළේ Software Engineering වල ගොඩක් වැදගත් අංශ දෙකක් ගැන. ඒ තමයි Code Review සහ Refactoring. මතක තියාගන්න, හොඳ Software එකක් කියන්නේ වැඩ කරන Software එකක් විතරක් නෙවෙයි. ඒක Maintain කරන්න පුලුවන්, Bug නැති, Scale කරන්න පුලුවන්, Clean Code වලින් හදපු එකක් වෙන්න ඕනේ. Code Review හරහා අපිට Team එකක් විදිහට Quality එක වැඩි කරගන්න පුලුවන්. Refactoring වලින් අපිට පවතින Code එක තවත් හොඳ තත්ත්වෙකට ගේන්න පුලුවන්.

මේ Concepts ඔයාලගේ දෛනික Programming වැඩ වලට එකතු කරගන්න. පොඩි පොඩි දේවලින් පටන් ගන්න. Variable Names හරිගස්සන එකෙන් පටන් අරන්, ලොකු Functions කඩනකම් ඔයාට මේ දේවල් practice කරන්න පුලුවන්.

ඔයාලත් මේ ගැන මොනවද හිතන්නෙ? ඔයාලගේ Project වල Refactoring කරලා තියෙනවද? Code Review වලින් මොනවද ලැබිලා තියෙන්නේ? පහල Comment Section එකේ ඔයාලගේ අදහස් අපිත් එක්ක බෙදාගන්න. මේ වගේ තවත් Software Engineering Tips අරගෙන අපි ඉක්මනටම හම්බවෙමු. හැමෝටම ජය වේවා!