3.12 Calling Procedures

A procedure is a named group of instructions you can run again and again by calling it, instead of rewriting the same code. When you call a procedure, you pass in arguments that fill its parameters, the program runs the procedure's statements, and then control returns to the line right after the call. For AP Computer Science Principles, track how arguments map to parameters, what the procedure changes, and where the program continues after the call.

Why This Matters for the AP Computer Science Principles Exam

Calling procedures shows up a lot in the multiple-choice section, where you trace pseudocode and figure out what a procedure call produces or changes. You need to know how arguments map to parameters, how flow of control jumps into a procedure and comes back, and how RETURN sends a value back to where the procedure was called.

This topic also supports the Create performance task. Using procedures with parameters is one of the clearest ways to manage complexity in your own program, and writing and calling your own procedure is something you will reuse all over Unit 3. Getting comfortable with calls now makes topics like writing procedures, using libraries, and building simulations much easier.

more resources to help you study

practice multiple choiceFRQ practice & scoringcheatsheetsscore calculator

Key Takeaways

• A procedure is a named group of instructions that may take parameters and may return a value. Different languages call it a method or a function.
• Parameters are the input variables in a procedure's definition. Arguments are the actual values you pass when you call it.
• Arguments match parameters by position: the first argument fills the first parameter, the second fills the second, and so on.
• Calling a procedure pauses the normal top-to-bottom flow, runs the procedure's statements, then returns control to the line right after the call.
• RETURN(expression) sends a value back to the call site and ends the procedure early; use result ← procName(arg1, arg2, ...) to store that returned value.
• A procedure can take zero or more arguments, so not every procedure needs parameters.

How AP Pseudocode Represents Procedures

The exam reference sheet uses specific notation for defining and calling procedures. You do not have to memorize a real language's syntax, but you do need to read this notation fluently.

To define a procedure:

</>Code
PROCEDURE procName(parameter1, parameter2, ...)
{
    <block of statements>
}

To define a procedure that sends back a value:

</>Code
PROCEDURE procName(parameter1, parameter2, ...)
{
    <block of statements>
    RETURN(expression)
}

To call a procedure:

</>Code
procName(arg1, arg2, ...)

To call a procedure and store what it returns:

</>Code
result ← procName(arg1, arg2, ...)

When the call runs, arg1 is assigned to parameter1, arg2 is assigned to parameter2, and so on. The reference sheet also gives you DISPLAY(expression) to show a value followed by a space, and INPUT() to accept a value from the user and return it.

Parts of a Procedure

Here is a simple program that sums two numbers without a procedure:

</>Code
first_number = 5
second_number = 7
sum_value = first_number + second_number
print (sum_value)

If you wanted to sum several different pairs of numbers, you would have to rewrite these lines over and over. A procedure fixes that. Here is the same idea written as a function in Python:

</>Code
def summing_machine(first_number, second_number):
  print (first_number + second_number)

The names inside the parentheses, first_number and second_number, are the parameters. Parameters are the input variables a procedure uses to do its job. A procedure does not always need parameters; some take zero arguments.

When you call a procedure, the program runs the lines inside it as if they were written out at that spot. After it finishes, the program goes back to reading code in order from the line right after the call. The actual values you pass in when calling are the arguments:

</>Code
def summing_machine(first_number, second_number):
  print (first_number + second_number)

summing_machine(5, 7)
# In this example, 5 and 7 are the arguments.

Here 5 is assigned to first_number and 7 is assigned to second_number, matching by position.

Returning a Value

Sometimes you want a procedure to hand back a result instead of just displaying it. A return statement does that. It returns the value of an expression to the point where the procedure was called, and you can store or reuse that value:

</>Code
def summing_machine(first_number, second_number):
  value = first_number + second_number
  return (value)

answer = summing_machine(5, 7)
print (answer)

# You can manipulate the returned value too.
print (answer + 1)

In AP Pseudocode, you assign that returned value to a variable with the arrow operator, like answer ← summing_machine(5, 7). A RETURN statement also ends the procedure immediately, so any statements after it inside the procedure do not run.

How to Use This on the AP Computer Science Principles Exam

Code Tracing

Most procedure-call questions ask you to determine the result or effect of a call. Work through them in order:

• Match each argument to its parameter by position.
• Run the procedure's statements using those values.
• If you hit a RETURN, stop running the procedure and send that value back.
• Continue from the line right after the original call.

Display vs Return

Watch the difference between displaying and returning. DISPLAY(expression) shows a value as output but does not give the call a value you can store. RETURN(expression) gives the call a value you can assign with result ← procName(...) or use in a larger expression. A question may show a procedure that returns a value but never stores or displays it, which means nothing actually appears as output.

Create Performance Task

When you build your own program, writing a procedure with at least one parameter is a strong way to manage complexity and reuse code. Make sure you can explain in plain language what your procedure does and how its parameters change its behavior, since being able to describe how a procedure works is part of showing you understand your own code.

Common Misconceptions

• Parameters and arguments are not the same thing. Parameters are the placeholder variables in the definition; arguments are the real values you pass in when you call.
• Argument order matters. Values fill parameters by position, so swapping the order of arguments can change the result.
• RETURN and DISPLAY are different. RETURN sends a value back to the caller; DISPLAY just shows output on the screen. A returned value is lost if you do not store or use it.
• Calling a procedure does not skip the rest of your program. Control returns to the line right after the call once the procedure finishes.
• A procedure does not have to take parameters. Procedures can take zero or more arguments.
• Code after a RETURN inside the same procedure does not run, because RETURN ends the procedure right away.

Related AP Computer Science Principles Guides

• 3.1 Variables and Assignments
• Big Idea 3: Algorithms and Programming
• 3.18 Undecidable Problems
• 3.17 Algorithmic Efficiency
• 3.2 Data Abstraction
• 3.10 Lists