3.13 Developing Procedures

6 min read

3.13 Developing Procedures - Syntax Terrors
Developing vs. Calling a Procedure
- Key Points
- JavaScript
- Python
What is Procedural Abstraction?
- Key Points
- JavaScript
- Python
Solving Problems with Procedures
- Key Points
- JavaScript
- Python
Modularity
- Key Points
- JavaScript
- Python
Code Reuse and Readability
- Key Points
- JavaScript
- Python
Return Statements
- Key Points
- JavaScript
- Python
Flexibility and Maintenance
- Key Points
- JavaScript
- Python
Try It Yourself: Write and Call a Procedure
- Key Points
- Try It Yourself (JavaScript)
- Try It Yourself (Python)

3.13 Developing Procedures - Syntax Terrors

JavaScript Developing Procedures Homework Python Developing Procedures Homework

Developing vs. Calling a Procedure

Key Points

Developing a procedure means writing the code for what it does.
Calling a procedure means using it in your program.
You must develop (define) a procedure before you can call it.

JavaScript


// Developing (defining) the procedure
function double(num) {
    console.log(num * 2);
}
// Calling the procedure
double(5);

Developing a procedure is when you write the function itself, including its name, parameters, and instructions.

Example: function double(num) { console.log(num * 2); }

Calling a procedure is when you use its name to make it run.

Example: double(5);

Python


# Developing (defining) the procedure
def double(num):
    print(num * 2)
# Calling the procedure
double(5)

Developing a procedure is when you write the function, including its name, parameters, and instructions.

Example: def double(num): print(num * 2)

Calling a procedure is when you use its name to make it run.

Example: double(5)

What is Procedural Abstraction?

Key Points

Procedures are a special form of abstraction
You can use a procedure without knowing its inner details
Built-in procedures like print() are common examples

JavaScript


// You can use built-in procedures like console.log()
console.log("Hello, world!");

In JavaScript, console.log() is a built-in procedure.
You use it to print messages, without needing to know how it works inside.
This is procedural abstraction: you use the procedure, but don’t need to see its code.

Python


# You can use built-in procedures like print()
print("Hello, world!")

In Python, print() is a built-in procedure.
You use it to display messages, without needing to know how it works inside.
This is procedural abstraction: you use the procedure, but don’t need to see its code.

Solving Problems with Procedures

Key Points

Break big problems into smaller sub-problems
Solve each sub-problem with a procedure
Combine procedures to solve the whole problem

JavaScript


// Example: Choose-your-own-adventure game
function displayChoice(choice) {
    console.log("You chose: " + choice);
}

function trackProgress(step) {
    // ...code to track progress
}

// Combine procedures to build the game
displayChoice("forest");
trackProgress(1);

In JavaScript, you can break a big problem (like a game) into smaller pieces.

Write a procedure for each sub-problem (like displaying choices or tracking progress).
Call these procedures to build your program.

This makes your code easier to manage and understand.

Python


# Example: Choose-your-own-adventure game
def display_choice(choice):
    print("You chose:", choice)

def track_progress(step):
    # ...code to track progress
    pass

# Combine procedures to build the game
display_choice("forest")
track_progress(1)

In Python, you can break a big problem (like a game) into smaller pieces.

Write a procedure for each sub-problem (like displaying choices or tracking progress).
Call these procedures to build your program.

This makes your code easier to manage and understand.

Modularity

Key Points

Divide your program into separate sub-programs
Each procedure solves a specific part of the problem
Modularity makes code easier to read and maintain

JavaScript


function add(a, b) {
    return a + b;
}

function print_sum(a, b) {
    console.log(add(a, b));
}

print_sum(7, 5);
print_sum(8, 2);
print_sum(9, 3);

In JavaScript, modularity means dividing your code into small, reusable procedures.

add() does the calculation.
print_sum() prints the result.
Call these procedures as needed.

This keeps your code organized and easy to update.

Python


def add(a, b):
    return a + b

def print_sum(a, b):
    print(add(a, b))

print_sum(7, 5)
print_sum(8, 2)
print_sum(9, 3)

In Python, modularity means dividing your code into small, reusable procedures.

add() does the calculation.
print_sum() prints the result.
Call these procedures as needed.

This keeps your code organized and easy to update.

Code Reuse and Readability

Key Points

Procedures can be reused with different inputs
Parameters make procedures flexible
Procedures simplify and clarify your code

JavaScript


function summingMachine(first, second) {
    let sum = first + second;
    console.log(sum);
}

summingMachine(5, 7);
summingMachine(8, 2);
summingMachine(9, 3);

In JavaScript, you can reuse procedures by calling them with different inputs.

Parameters let you use the same procedure for many cases.
Your code is shorter and easier to read.

This is especially helpful in large programs.

Python


def summing_machine(first, second):
    sum_value = first + second
    print(sum_value)

summing_machine(5, 7)
summing_machine(8, 2)
summing_machine(9, 3)

In Python, you can reuse procedures by calling them with different inputs.

Parameters let you use the same procedure for many cases.
Your code is shorter and easier to read.

This is especially helpful in large programs.

Return Statements

Key Points

Use return to send a value back
Return ends the procedure immediately
You can return from anywhere inside the procedure

JavaScript


function multiply(a, b) {
    if (a === 0 || b === 0) {
        return 0;
    }
    return a * b;
}
console.log(multiply(3, 4)); // 12
console.log(multiply(0, 5)); // 0

In JavaScript, return sends a value back and ends the procedure.

You can use return anywhere in your function.
After return, the function stops and goes back to where it was called.

This lets you control what your procedure gives back.

Python


def multiply(a, b):
    if a == 0 or b == 0:
        return 0
    return a * b

print(multiply(3, 4))  # 12
print(multiply(0, 5))  # 0

In Python, return sends a value back and ends the procedure.

You can use return anywhere in your function.
After return, the function stops and goes back to where it was called.

This lets you control what your procedure gives back.

Flexibility and Maintenance

Key Points

Procedural abstraction lets you change code in one place
You can fix or improve a procedure without changing the whole program
Updates apply everywhere the procedure is used

JavaScript


function greet(name) {
    return "Hello, " + name + "!";
}
// If you want to change the greeting, update the function once

In JavaScript, if you need to fix or improve a procedure, you only change it in one place.

All calls to the procedure use the updated version.
This makes your code easier to maintain and update.

Procedural abstraction helps keep your programs flexible.

Python


def greet(name):
    return "Hello, " + name + "!"
# If you want to change the greeting, update the function once

In Python, if you need to fix or improve a procedure, you only change it in one place.

All calls to the procedure use the updated version.
This makes your code easier to maintain and update.

Procedural abstraction helps keep your programs flexible.

Computer Science Principles

3.13 Developing Procedures