Computer Science · 9th Grade · Programming with Purpose · Weeks 19-27

Function Design and Reusability

Students will focus on designing functions that are truly reusable across different projects.

• Common Core State Standards
• CSTA: 3A-AP-17
• CSTA: 3A-AP-18

About This Topic

Writing a function that technically works is different from writing a function that can be reliably used across different programs and contexts. Reusable functions have clear, specific purposes, well-named parameters, predictable outputs, and no hidden dependencies on global state. For 9th graders, learning to evaluate and improve function design is a step toward the kind of modular thinking described in CSTA 3A-AP-17 and 3A-AP-18.

A reusable function is like a well-designed tool: it does what its name says, works consistently regardless of who uses it, and does not break other things when you pick it up. A function that reads from a specific hardcoded file, modifies a global variable, or produces different outputs for identical inputs is not reusable even if the code inside it works. Students often discover these hidden dependencies only when they try to use a function in a new context.

Critiquing existing functions is one of the most effective active learning strategies for this topic. When students evaluate someone else's function for reusability, they apply design principles without the defensiveness of reviewing their own work, and they encounter a wider variety of design decisions than they would generate individually.

Key Questions

1. Analyze what makes a function truly reusable across different projects.
2. Design a function with clear inputs and outputs for maximum reusability.
3. Critique existing functions for their reusability and modularity.

Learning Objectives

• Analyze existing functions to identify specific characteristics that hinder or promote reusability.
• Design a function that accepts parameters for all variable data, producing predictable outputs.
• Critique a given function's design, proposing specific modifications to improve its modularity and reusability.
• Compare and contrast a highly reusable function with one that has hidden dependencies or side effects.

Before You Start

Defining and Calling Functions

Why: Students must be able to create and use basic functions before they can focus on designing them for reusability.

Understanding Variables and Scope

Why: Comprehending how variables exist and are accessed within different parts of a program is crucial for identifying and avoiding dependencies and side effects.

Key Vocabulary

Modularity	The degree to which a system's components may be separated and recombined. In programming, this often refers to breaking down a large program into smaller, independent functions.
Parameter	A variable listed inside the parentheses in a function definition. It acts as a placeholder for a value that will be passed into the function when it is called.
Argument	The actual value that is sent to a function when it is called. This value is assigned to the corresponding parameter within the function.
Side Effect	Any change that a function makes to the state outside of its local environment. This can include modifying global variables or performing input/output operations.
Dependency	A relationship where a function relies on external factors or specific conditions to operate correctly, such as global variables or specific file structures.

Watch Out for These Misconceptions

Common Misconception

A function is reusable if it has been used in more than one place in the same program.

What to Teach Instead

True reusability means the function can be moved to a completely different program and work correctly without modification. Using a function twice in the same codebase that shares global variables or specific file paths is not genuine reusability. Testing this by attempting to copy a function into a clean file reveals hidden dependencies immediately.

Common Misconception

More parameters make a function more flexible and therefore more reusable.

What to Teach Instead

Too many parameters make a function hard to call correctly and understand. A function with many parameters often has too broad a purpose. The goal is functions that do one thing well, with only the parameters required for that specific task. Code critique activities help students find the right balance.

Common Misconception

Functions with no return value are less useful than functions that return something.

What to Teach Instead

Functions that perform actions, such as writing to a file, updating a UI element, or sorting a list in place, do not need to return values to be useful and reusable. What matters is that the function's behavior is clear and consistent. Discussion activities where students classify functions by their type of output build comfort with both patterns.

Active Learning Ideas

Code Critique: Reusability Audit

Each student receives a function (drawn from a shared pool) and evaluates it against a four-criteria rubric: specific purpose, clear parameter names, predictable output, and no global dependencies. Students annotate directly on printed code, then share one finding with the class.

30 min·Individual

Redesign Workshop: From Brittle to Reusable

Groups receive a function that works but is not reusable (hardcoded filenames, global variable use, inconsistent return behavior). They redesign it for reusability, documenting the changes they made and why. Groups present before and after versions with an explanation of each design decision.

45 min·Small Groups

Think-Pair-Share: Function Portability Test

Students describe a function they wrote, then their partner tries to describe a new context where that function could be used without modification. If the partner cannot find one, the pair identifies what would need to change to make the function portable.

20 min·Pairs

Gallery Walk: Good and Bad Function Design

Post eight function examples, four with strong reusability and four with specific reusability problems. Students label each as reusable or not reusable with a one-sentence justification and a suggested fix for the problematic ones.

30 min·Small Groups

Real-World Connections

• Software developers at Google design core libraries, like those for data manipulation or user interface elements, to be highly reusable across many different applications, from Android apps to web services.
• Game engine developers create reusable function modules for physics, rendering, and AI that are used by hundreds of game development teams worldwide to build diverse gaming experiences.
• Embedded systems engineers for automotive companies design functions for engine control or sensor reading that must be robust and reusable across different vehicle models and configurations.

Assessment Ideas

Peer Assessment

Provide students with two functions: one designed for reusability and one with hidden dependencies. Ask students to work in pairs to identify the strengths and weaknesses of each function regarding reusability, then write one sentence explaining which function is more reusable and why.

Quick Check

Present a function that performs a common task but relies on a global variable. Ask students to rewrite the function to accept the necessary information as a parameter, explaining in one sentence why this change improves reusability.

Discussion Prompt

Pose the question: 'Imagine you are building a library of functions for other students to use. What are the top three principles you would follow to ensure your functions are easy for them to understand and reuse in their own projects?' Facilitate a brief class discussion to share ideas.

Frequently Asked Questions

What makes a function's name contribute to its reusability?

A clear, specific function name tells the caller exactly what to expect without reading the implementation. Names like 'process_data' are vague; 'calculate_letter_grade(score, scale)' communicates purpose, inputs, and the expected output type. Good naming is the first layer of documentation and makes functions easier to discover and use correctly.

What is a global variable, and why do global dependencies hurt reusability?

A global variable is accessible from anywhere in a program. A function that reads or writes a global variable is secretly dependent on the state of the entire program, making it impossible to use safely in a different context. Functions that receive all their needed data through parameters can be safely transplanted to any codebase.

How does critiquing other students' functions improve function design skills?

When students evaluate someone else's function against a reusability checklist, they apply design principles to real code without the cognitive load of simultaneously writing that code. They also see a wider range of design decisions than they would encounter in their own work. The practice of articulating what is wrong and why improves the precision of their own future design choices.

Should functions always be kept short?

Shorter functions are often more reusable, but length is a symptom, not the core issue. A function that handles one clear task might be 20 lines. A function that handles three tasks might be 10 lines but still violates the single-responsibility principle. Focus on whether the function has a single, clear purpose rather than counting lines.