In AP Computer Science Principles, a student-developed procedure is a named function you write yourself (not a built-in or library call) that takes parameters and performs a specific task, demonstrating procedural abstraction by breaking a program into smaller, reusable subproblems.
A student-developed procedure is exactly what it sounds like, a procedure YOU wrote. Not DISPLAY, not RANDOM, not a block that came with your programming environment. It has a name, it usually takes one or more parameters, and it does one job inside your program. On the exam reference sheet, this looks like PROCEDURE procName(parameter1, parameter2, ...) { <block of statements> }, optionally with a RETURN(expression) to send a value back.
The reason College Board cares about the "student-developed" part is procedural abstraction. Per EK AAP-3.B.1, a procedure gives a name to a process so it can be used knowing only what it does, not how. When you write your own procedure, you're proving you can take a big problem, split it into subproblems (EK AAP-3.B.2), and solve each one in its own modular chunk (modularity, EK AAP-3.B.3). A good student-developed procedure also generalizes. If you'd otherwise copy-paste the same code three times with small changes, a parameter lets one procedure handle all three cases (EK AAP-3.B.4).
This term lives in Topic 3.13 (Developing Procedures) in Unit 3: Algorithms and Programming, under two learning objectives. AP Comp Sci P 3.13.A asks you to explain how procedural abstraction manages complexity, and AP Comp Sci P 3.13.B asks you to actually develop procedural abstractions by writing procedures. The student-developed procedure is where those two objectives collide with the graded part of the course. Your Create Performance Task program must contain one, and the written response portion of the exam asks you to explain and modify it. If your program only uses built-in blocks, you have nothing to write about and you lose points you could have locked in months before exam day.
Keep studying AP® Computer Science Principles Unit 3
Procedural Abstraction (Unit 3)
A student-developed procedure is procedural abstraction made concrete. The abstraction is the idea (name a process, hide the details); your procedure is the proof you can do it. The 2023 scoring criteria literally title the relevant rubric row "Procedural Abstraction."
Parameters (Unit 3)
A procedure with no parameters barely counts on the exam. The scoring criteria require at least one parameter that has an effect on the procedure's functionality, because parameters are what make a procedure general instead of a one-off block of code.
Create Performance Task (Units 1-5)
Your Create PT program must include a student-developed procedure, and you copy it into your Personalized Project Reference. The written response questions on exam day are built around that exact procedure, so writing a clean one in March pays off in May.
Sequencing, Selection, and Iteration (Unit 3)
Inside the procedure is where you show off Topics 3.8-3.10. A strong student-developed procedure contains an algorithm using selection (if statements) and iteration (loops), which is what the rest of the Create rubric checks for.
This term shows up most directly in the Create Performance Task and its written response. The 2023 scoring criteria for the Procedural Abstraction row (worth 1 point) require two program code segments, one showing a student-developed procedure with at least one parameter that has an effect on the procedure's functionality, and one showing where that procedure is called. You then have to explain in writing how the procedure works and how it manages complexity. Common pitfalls that cost the point are submitting a built-in or teacher-provided procedure, writing a procedure with no parameters, or having a parameter that exists but never actually changes what the procedure does. On the multiple-choice section, you won't see the phrase "student-developed procedure" as often, but you will trace and write procedures in exam pseudocode, including calls like result ← procName(arg1, arg2) from the reference sheet.
A built-in procedure (like DISPLAY, INPUT, or RANDOM) comes with the language or environment, and someone else wrote it. A student-developed procedure is one you define yourself with the PROCEDURE keyword (or its block equivalent). The Create Task rubric only gives credit for the student-developed kind, so calling RANDOM inside your code does not satisfy the procedural abstraction requirement, but writing your own procedure that uses RANDOM can.
A student-developed procedure is a function you wrote yourself, with a name, a block of statements, and usually parameters, as opposed to a built-in procedure provided by the language.
It demonstrates procedural abstraction (EK AAP-3.B.1), meaning the procedure can be used knowing what it does without knowing how it does it.
The Create Performance Task requires a student-developed procedure with at least one parameter that actually affects its functionality, plus a code segment showing where you call it.
Breaking a program into procedures is called modularity (EK AAP-3.B.3), and it lets you solve a big problem by solving smaller subproblems one at a time.
On the exam reference sheet, you define a procedure with PROCEDURE procName(parameter1, parameter2, ...) and can return a value with RETURN(expression).
A parameter that never changes the procedure's behavior does not count, so make sure your parameter actually controls something inside the procedure.
It's a procedure (function) that you wrote yourself as part of your program, with a name and a block of statements, rather than a built-in command. It's the centerpiece of Topic 3.13 and the procedural abstraction requirement of the Create Performance Task.
Yes. The 2023 Create Task scoring criteria require at least one parameter that has an effect on the procedure's functionality. A procedure with zero parameters, or a parameter that's never used, will not earn the procedural abstraction point.
No. Built-in procedures like RANDOM, DISPLAY, or INPUT were written by someone else, so they don't count. You can use built-ins inside your own procedure, but the procedure you submit must be one you defined yourself.
Procedural abstraction is the concept of naming a process so it can be used without knowing its internals (EK AAP-3.B.1). A student-developed procedure is your concrete implementation of that concept. The procedure is the evidence; the abstraction is the idea being demonstrated.
No. The exam reference sheet shows both forms, a procedure that just runs a block of statements and a procedure that ends with RETURN(expression). Either works, as long as the procedure has a parameter that affects what it does and it's called somewhere in your program.
Connect this key term to the AP exam workflow: review the course, practice questions, and check related study tools.
Review units, study guides, and course resources.
Check this vocabulary in multiple-choice context.
Apply key concepts in written AP responses.
Estimate the exam score you are working toward.
Review the highest-yield facts before practice.
Put the full course together before test day.