What Is A Parameter In Block Code?

A parameter in block code is a special kind of variable used to pass data into a custom function or procedure, allowing the function to be more flexible and reusable.

When you define a function in a block-based programming environment like Scratch or MakeCode, you can add "slots" or "gaps" to its block. These slots are the parameters. When you use that function elsewhere in your code, you place a value (known as an argument) into the parameter slot. The function then uses that value to perform its task.

The concept of parameters

To understand parameters, consider a simple programming task: drawing a square.

• Without parameters: If you create a draw square function without parameters, you have to hardcode the side length inside the function. If you wanted to draw a square with a different size, you'd have to edit the original function or create a new one.
• With parameters: By adding a side length parameter to the draw square function, you make the block flexible. Now, when you call the function, you can provide different numbers for the side length parameter, such as 100, 50, or 25, to draw squares of various sizes without changing the function's core logic.

Parameters vs. arguments: What's the difference?

While the terms are often used interchangeably, there is a clear distinction between parameters and arguments:

• Parameter: This is the variable defined in the function's block header when you create it. It's a placeholder for a value.
• Argument: This is the actual value that you pass to the function when you call it.

Using the draw square example:

• The side length is the parameter.
• The 100 that you enter into the side length slot is the argument.

Creating and using parameters in block code

The process of creating and using parameters is straightforward across most block-based platforms, though the specific visuals may differ:

1. Define a new function: You start by creating a "My Block" or a new function.
2. Add an input: The block editor will provide an option to "add an input" or "add a parameter".
3. Name the parameter: You give the parameter a descriptive name, like steps, degrees, or message. This name is used as a local variable within the function's code.
4. Incorporate the parameter: You then drag and drop the named parameter variable into the logic of the function. For example, you would place the steps parameter into the "move" block.
5. Use the function: When you use your new function block in your main program, it will have the input slot, ready for an argument.

The scope of a parameter

An important characteristic of a parameter is its scope, or the part of the code where it can be used.

• Local to the function: A parameter is a local variable, meaning its existence is limited to the function it was created in. This is a key safety feature, as it prevents variables from one function from accidentally interfering with those in another.
• Initialized by the caller: Unlike a regular local variable, a parameter's value is not set within the function itself. Instead, it is initialized with the value of the argument provided by the code that called the function.

The purpose and benefits of parameters

Parameters are a fundamental concept in programming that bring several major benefits to block coding projects:

• Code reuse and efficiency: Without parameters, you would have to duplicate blocks of code for every slight variation of a task. Parameters allow a single function to handle a wide range of inputs.
• Modularity and organization: By encapsulating a specific task within a single function, parameters allow you to break down complex problems into smaller, manageable, and more readable chunks. This makes it easier to debug, understand, and share code.
• Clarity and readability: A well-named function with clearly defined parameters makes its purpose immediately obvious to anyone reading the code. For example, a draw square (side length) block is more intuitive than a block that has no visible inputs.
• Abstraction: Parameters allow you to use a function without needing to know its internal details. You only need to know what kind of data the function expects and what it will do with that data.

Examples in action

MakeCode: In MakeCode for the micro:bit, a function to display a name might be defined as function showName(name: string). The name is the parameter of type string. When you call the function with showName("Super Coder"), the argument "Super Coder" is passed to the name parameter.

Scratch: In Scratch, when you create a "My Block," you can add a "number or text" input. If you create a draw a square with size (size) block, size is the parameter. When you use this block, you'll see a gap to insert a number, which is the argument. The (size) parameter is then used inside the block's code, for example, in the "move (size) steps" block.