Part 1: Hypotenuse Function Using Incremental Development
In this task, we are required to create a function hypotenuse(a, b) that calculates
the length of the hypotenuse of a right-angled triangle, given the lengths of the two legs.
We use incremental development, a process that involves building and testing the
function in small steps to reduce the complexity of debugging.
Stage 1: Define the Function Skeleton
We begin by writing a basic function with placeholders:
def hypotenuse(a, b):
pass
At this stage, the function accepts two inputs but performs no calculations. This sets up
the input structure for further development.
Stage 2: Square Each Side
Next, we compute the square of each leg:
def hypotenuse(a, b):
a_squared = a ** 2
b_squared = b ** 2
print(a_squared, b_squared)
Test input:
hypotenuse(3, 4)
Output:
9 16
This confirms that the squaring step works correctly.
Stage 3: Add the Squared Values
We then add the two squared values:
def hypotenuse(a, b):
a_squared = a ** 2
b_squared = b ** 2
sum_squares = a_squared + b_squared
print(sum_squares)
Test input:
hypotenuse(3, 4)
Output:
25
Now we verify that the function correctly calculates the sum of the squares.
Stage 4: Calculate the Hypotenuse
We finalize the function by computing the square root of the sum of squares:
import math
def hypotenuse(a, b):
return math.sqrt(a ** 2 + b ** 2)
This is the final, optimized function.
Test Outputs
print(hypotenuse(3, 4))
print(hypotenuse(5, 12))
print(hypotenuse(8, 15))
These results are consistent with known Pythagorean triples, confirming the function
works correctly.
Conclusion:
Using incremental development simplifies troubleshooting and ensures each stage of
logic is validated. This approach leads to robust and maintainable code, especially in
applications where accuracy is essential.
Part 2: Custom Function Using Incremental Development – Compound Interest
Calculator
To build my programming portfolio and showcase my incremental development skills, I
created a custom function that calculates compound interest. The function demonstrates
a real-world financial computation that’s useful in personal finance apps or educational
tools. The formula used is:
t
A=P×(1+r )
Where:
A is the future value
P is the principal amount
r is the annual interest rate (decimal)
t is the time in years
Stage 1: Define the Function Structure
We begin by defining the function with parameters but no logic yet.
def compound_interest(p, r, t):
pass
This establishes the structure of the function. No output is expected at this point — it’s
just the starting point for development.
Stage 2: Implement Basic Formula
Next, we compute the compound interest using the standard formula. At this stage, we
simply print the result to verify the output.
def compound_interest(p, r, t):
amount = p * ((1 + r) ** t)
print(amount)
Test Input:
compound_interest(1000, 0.05, 2)
Output:
1102.5
This confirms the formula is being applied correctly.
Stage 3: Finalize and Return Result
Instead of printing, the function should return a properly rounded result for practical use:
def compound_interest(p, r, t):
return round(p * ((1 + r) ** t), 2)
Function Testing with Different Inputs
print(compound_interest(1000, 0.05, 2))
print(compound_interest(1500, 0.04, 3))
print(compound_interest(2000, 0.03, 5))
These test cases cover various principal amounts, interest rates, and time spans, and
confirm the function behaves as expected.
Technical Explanation
Each stage of development isolated and tested a logical component:
Stage 1 defined the input interface.
Stage 2 implemented and verified the mathematical logic.
Stage 3 optimized the function to return a clean, formatted result.
This mirrors professional software development practices, where features are added
incrementally and tested immediately to catch bugs early and ensure correctness.
Reference:
Downey, A. (2015). Think Python: How to Think Like a Computer Scientist. Green Tea
Press. https://greenteapress.com/thinkpython2/thinkpython2.pdf
