Parameters

A parameter is an input to a procedure. When you call the procedure, you supply an argument, the actual value, which the parameter receives. Parameters let a single procedure handle many different inputs instead of being locked to one fixed value.

This topic is part of Big Idea 3: Algorithms and Programming. You will learn how parameters generalize procedures and support abstraction.

In a definition like PROCEDURE greetUser(name), the word name is the parameter. It acts as a placeholder. When you call greetUser("Alex"), the argument "Alex" is passed in and stored in name for that run.

This is generalization: the same procedure works for any value you pass. Call it with "Sam" and it greets Sam; call it with "Maria" and it greets Maria. The body never changes, only the argument does.

A parameter is a special kind of variable that receives its value from the call. It is not a permanent store of every value ever passed; each call gives it a fresh value for that run.

Visual Inputs

Click to enlarge

The argument "Alex" is passed into the parameter name, and the procedure displays a greeting.

Follow the flow: the argument on the left is passed into the parameter slot inside the procedure, which then uses it in the body to produce output. On the exam, match each argument in the call to the parameter in the definition, in order.

• Parameter: the named input placeholder in a procedure definition.
• Argument: the actual value passed in when the procedure is called.
• Procedure call: running a procedure and supplying arguments.
• Reusable procedure: one procedure that works with different inputs.
• Generalization: writing code that handles many cases, not just one.
• Abstraction: using a procedure by name and inputs, hiding its detail.

Be ready to:

• Identify the parameter in a definition and the argument in a call.
• Trace what a procedure outputs for a given argument.
• Explain how parameters make a procedure reusable.
• Recognize that different calls can pass different arguments.

Questions often show a procedure called several times with different arguments and ask for the combined output. Match each argument to the parameter and trace carefully.

A reminder app uses a procedure with a parameter so it can remind about any task:

PROCEDURE remind(taskName)
{
    DISPLAY("Remember to complete " + taskName)
}

remind("math homework")
remind("science project")

The parameter is taskName. On the first call, the argument "math homework" is passed in, so the procedure displays "Remember to complete math homework". On the second call, the argument "science project" is passed in, so it displays "Remember to complete science project".

One procedure handles both reminders. That is the power of parameters: the body stays the same while the argument changes the result. Without a parameter, you would need a separate procedure for every task, which is exactly the repetition parameters help you avoid.

• Confusing parameter with argument. The parameter is the placeholder; the argument is the value passed in.
• Forgetting to pass an argument. A procedure that expects a value needs one in the call.
• Hard-coding values. Putting a fixed value in the body removes the flexibility a parameter provides.
• Too many unrelated parameters. Keep parameters focused and meaningful.
• Thinking parameters store all past values. Each call gives the parameter a fresh value.

If a procedure has a hard-coded value, ask whether that value should become a parameter. Turning it into an input lets the same procedure serve many cases, which strengthens the abstraction and generalization graders look for on the Create Performance Task.

Parameters send values into a procedure. Procedures can also send a value back out. In the next topic, Return Values, you will learn how RETURN passes a result to the caller and how that differs from DISPLAY.