lab02

Author: muhdharis

docs/labs/lab-02.md

@@ -547,201 +547,7 @@ def calculate_net_salary(base_salary, overtime_hours):
 salary = calculate_net_salary(5000, 10)
 print(f"Net salary: RM{salary:.2f}")
 ```
-print(f"Final price: RM{final_price:.2f}")
-```
-
-Now try changing `return` to `print` in the function. What happens? You'll get an error because you can't subtract `None` from a number!
-
-## Factorization: Don't Repeat Yourself
-
-Factorization is the process of taking repeated code and extracting it into a reusable function. This is one of the most important principles in programming.
-
-### Identifying Repetition
-
-Look for these signs that indicate you need factorization:
-1. You're copy-pasting code blocks
-2. The same calculation appears multiple times
-3. Only the values change, but the logic stays the same
-
-Copy this example into your `exercise.py`:
-
-```python
-# Calculating areas without factorization
-pi = 3.14159
-
-# Circle 1
-radius1 = 5
-area1 = pi * radius1 * radius1
-print(f"Circle 1 (radius {radius1}): Area = {area1:.2f}")
-
-# Circle 2
-radius2 = 10
-area2 = pi * radius2 * radius2
-print(f"Circle 2 (radius {radius2}): Area = {area2:.2f}")
-
-# Circle 3
-radius3 = 7
-area3 = pi * radius3 * radius3
-print(f"Circle 3 (radius {radius3}): Area = {area3:.2f}")
-```
-
-Run this code. Notice how `pi * radius * radius` appears three times? This is a perfect candidate for factorization.
-
-### Refactoring with Functions
-
-Refactoring means improving code structure without changing what it does. Replace the code above with this factorized version:
-
-```python
-def calculate_circle_area(radius):
-    pi = 3.14159
-    area = pi * radius * radius
-    return area
-
-# Now the calculation is defined once and reused
-area1 = calculate_circle_area(5)
-print(f"Circle 1 (radius 5): Area = {area1:.2f}")
-
-area2 = calculate_circle_area(10)
-print(f"Circle 2 (radius 10): Area = {area2:.2f}")
-
-area3 = calculate_circle_area(7)
-print(f"Circle 3 (radius 7): Area = {area3:.2f}")
-```
-
-The benefits are immediate:
-- If you need to calculate 100 circles, you just call the function 100 times
-- If you need a more precise value of pi (3.14159265), you change only one line
-- The code is shorter and easier to read
-
-## Single Responsibility Principle
-
-Each function should have **one** clear job. When a function tries to do too many things, it becomes difficult to understand, test, and modify.
-
-### Recognizing Multiple Responsibilities
-
-A function has multiple responsibilities if it:
-- Gets input AND processes it AND displays output
-- Performs multiple unrelated calculations
-- Makes decisions AND displays results
-
-Try this example:
-
-```python
-def process_student():
-    # Responsibility 1: Getting input
-    name = input("Enter student name: ")
-    score = int(input("Enter score: "))
-    
-    # Responsibility 2: Making decision
-    if score >= 50:
-        status = "Pass"
-    else:
-        status = "Fail"
-    
-    # Responsibility 3: Displaying output
-    print(f"Student: {name}")
-    print(f"Score: {score}")
-    print(f"Status: {status}")
-
-# Run the function
-process_student()
-```
-
-This function does three completely different jobs. What if you want to change how pass/fail is determined but keep the same input method? You'd have to dig through all the code.
-
-### Splitting Responsibilities
-
-A better approach is to split this into three focused functions:
-
-```python
-def get_student_data():
-    name = input("Enter student name: ")
-    score = int(input("Enter score: "))
-    return name, score
-
-def determine_status(score):
-    if score >= 50:
-        return "Pass"
-    else:
-        return "Fail"
-
-def display_results(name, score, status):
-    print(f"Student: {name}")
-    print(f"Score: {score}")
-    print(f"Status: {status}")
 
-# Use them together
-student_name, student_score = get_student_data()
-student_status = determine_status(student_score)
-display_results(student_name, student_score, student_status)
-```
-
-Now each function has one clear purpose:
-- `get_student_data()` only handles input
-- `determine_status()` only makes the pass/fail decision
-- `display_results()` only shows information
-
-If the passing grade changes to 60, you only modify `determine_status()`. The other functions remain untouched.
-
-::: tip THE 5-WORD TEST
-If you can't describe what a function does in 5 words or less, it probably does too much and should be split.
-:::
-
-## Decomposition: Breaking Down Complex Problems
-
-Decomposition is the art of breaking a large, complex task into smaller, manageable functions. Instead of writing one massive function that does everything, you create several small functions that each handle one piece of the puzzle.
-
-### Why Decompose?
-
-Consider calculating an employee's monthly salary:
-1. Base salary
-2. Add allowances (transport, meal)
-3. Add overtime pay
-4. Subtract EPF (11%)
-5. Subtract SOCSO (2%)
-6. Calculate net salary
-
-Writing this as one long calculation is error-prone and hard to understand. Instead, decompose it into steps.
-
-### Step-by-Step Decomposition
-
-Create separate functions for each calculation step:
-
-```python
-def calculate_allowances():
-    transport = 200.00
-    meal = 150.00
-    return transport + meal
-
-def calculate_overtime(base_salary, overtime_hours):
-    hourly_rate = base_salary / 160  # Assuming 160 working hours per month
-    overtime_rate = hourly_rate * 1.5  # 1.5x for overtime
-    return overtime_hours * overtime_rate
-
-def calculate_epf(gross_salary):
-    return gross_salary * 0.11
-
-def calculate_socso(gross_salary):
-    return gross_salary * 0.02
-
-def calculate_net_salary(base_salary, overtime_hours):
-    # Step 1: Calculate gross salary
-    allowances = calculate_allowances()
-    overtime = calculate_overtime(base_salary, overtime_hours)
-    gross = base_salary + allowances + overtime
-    
-    # Step 2: Calculate deductions
-    epf = calculate_epf(gross)
-    socso = calculate_socso(gross)
-    
-    # Step 3: Calculate net
-    net = gross - epf - socso
-    return net
-
-# Use it
-salary = calculate_net_salary(5000, 10)
-print(f"Net salary: RM{salary:.2f}")
-```
 
 Each function is simple and focused. If EPF rate changes, you only modify `calculate_epf()`. If overtime rules change, you only modify `calculate_overtime()`.