Reading AP CS Principles, Take 3
One of the problematic issues I am observing as I talk to people about the CS Principles AP (CSP) is that CSP is trying to be too many things to too many people. To understand this problem, you may need some background.
As best I understand it, the broad goal of the AP CS Principles course is to encourage more people and a wider variety of people to consider computing. It achieves this goal by providing a broader perspective on computing than AP CS A, which is really a programming class, and by allowing students to explore areas of interest.
The AP CSP exam approaches this goal with three main components. There is
the standard multiple-choice component that you would expect to see in any
AP exam. That component is graded by computer. There is a programming
component, called Create
. Create differs from the programming
components on the more traditional AP CS exam in multiple ways. First,
students can write programs about more or less whatever they want and
in whatever language their teacher chose [1]. Second, students complete
the programming assignment in class, rather than during a fixed time for
the AP. Third, the primary focus in grading the exam is not the program
code [2], but rather a series of short essays about various issues the
code is supposed to represent: some algorithms, a use of abstraction,
the development process, and so on and so forth. The third component is
an essay (well, really a series of answers to prompts) about an innovation
that involves computing. The essay includes reflections on positive and
negative impacts of the technology and a reflection on issues pertaining
to security, privacy, or storage [3]. That essay is also accompanied
by an artifact
(image, digital collage, video, animation, audio,
etc.) that demonstrates that the student can represent the innovation
with more than just text. As a board member of SIGCAS [4], I particularly
appreciate that students are asked to reflect on technology. What else?
Oh, the essay, like the code, is written in class, rather than in the
traditional locked in a room for four hours
AP testing.
That sounds good, doesn’t it? Students do two moderate-sized projects, one
of which shows that they understand what computing is and how it impacts
society, the other of which shows that they understand computational
thinking and can put it into practice through a computational artifact.
But I started this musing by noting that I found Principles problematic
because it tries to address too many audiences. Let’s consider what
I see as the primary conflicts. CS Principles is an AP class, which
means that it should require college-level work. At the same time,
it’s intended to be accessible to a wide variety of teachers, not just
to CS and math faculty. Further complicating matters are issues of
the haves
and the have nots
. Some schools that already had some CS
(such as AP CS A) are treating this as more of an introductory course for
9th and 10th graders. Schools that didn’t have CS before are less sure
where in the curriculum it should be, but are often putting it much later.
I’m not sure that a typical 9th grader should be earning college credit,
but there’s certainly an undercurrent that the course should also be
accessible to 9th graders.
How else does this conflict come into play? Primarily in the rubrics that are used to assess the exams and the notes that help readers interpret those rubrics [5].
While I have a high-school student, I don’t teach high-school students. So I can only speak from the perspective of a college faculty member at a relatively elite college. Here’s what I’d want out of CSP in order to award academic credit for the course [6].
Some of my expectations are general and belong to both of the two special tasks.
A college student cites any work that is not their own and that is part of what they submit. They cite ideas and facts they have taken from written sources; images, sounds, videos, and animations that they have used but not created; and code that they have copied [7]. At Grinnell, students who use materials that others prepared and do not cite those materials have been academically dishonest and are reported to our Committee on Academic Standing [8]. That should not be surprising; someone who writes an AP Lit or AP US History paper and does not cite their sources will get a 0 on the task for plagiarism. The same should hold for CSP. Fortunately, my reading of the CSP Guidelines suggests that plagiarism leads to a 0 on the task.
AP Computer Science Principles Policy on Plagiarism
A student who fails to acknowledge (i.e., through citation, through attribution, by reference, and/or through acknowledgment in a bibliographic entry) the source or author of any and all information or evidence taken from the work of someone else will receive a score of 0 on that performance task.
To the best of their ability, teachers will ensure that students understand ethical use and acknowledgment of the ideas and work of others as well as the consequences of plagiarism. The student’s individual voice should be clearly evident, and the ideas of others must be acknowledged, attributed, and/or cited. A computational artifact without acknowledgment of the media used in the creation of the computational artifact, and program code segment(s) written by someone else used in a program without appropriate acknowledgment, are all considered plagiarized work.
The College Board. 2017. Course and Exam Description: AP Computer Science Principles, Including the Curriculum Framework, Updated Fall 2017. Available online at https://secure-media.collegeboard.org/digitalServices/pdf/ap/ap-computer-science-principles-course-and-exam-description.pdf.
On an untimed writing task, such as Explore and Create, a college student
uses correct grammar, spelling, and punctuation [9]. I am a bit concerned that
there is no rubric item for grammar and punctuation in either open task.
That concern might be alleviated by a similar disclaimer. Submissions
that do not meet reasonable standards for grammar, spelling, and punctuation
will receive a zero for …..
A college student knows how to follow instructions [12]. If they are asked to write five short essays and they instead write one long essay, they do not expect to receive full credit [14].
Those are the general criteria I’d set. Now, let’s move on to the Explore task.
College students can create nontrivial artifacts, such as infographics, videos, or presentations. In creating such artifacts, college students incorporate (and cite) material from elsewhere, but do so in their own original creations.
CSP is about computing, not about the use of computing tools. While the artifact demonstrates that the student can use tools, the more important aspects are that the student understands the role of computing in the innovation they describe and can represent it clearly.
College students are able to describe clearly the role of computing in an innovation intended as an illustration of computing. If they are unable to do so, they know enough to pick another innovation.
College students studying computing in this style of course should understand that computing artifacts carry both benefits and risks and should be able to explain some of those benefits and risks. While I do not expect deep understanding of the principles and practices of STS [15], I do expect that students can think about these issues. I would, however, accept a wide variety of issues as reasonable risks, such as consequences that increase disparities in non-obvious ways.
College students can form more complex arguments. Not just this object
can be hacked
. Not just this can be hacked and hacking reveals this
kind of information
. But rather this object can be hacked, which reveals
this kind of information, which leads to this impact on this person or
thing
. The samples online do not require that last step.
College students studying computing should be able to demonstrate that
they understand about fundamental types and that most complex data are one
of these fundamental types. Hence, a student would not just write this
innovation uses locations
, but rather this innovation uses locations,
which are typically stored as a pair of real numbers representing
latitude and longitude
. Similarly, a student should not just write
The iPhone uses apps as data
but rather the iPhone uses apps, which
consist of sequences of binary numbers that represent (a) instructions
to the phone and (b) information, such as images or constants, that will
be used as part of the app
.
What about the Create criteria? Here are a few things I’d choose.
College students who finish a CS class should be able to explain what an algorithm is.
College students who finish a CS class with a programming aspect should be able to write a nontrivial program that uses functions/subroutines, loops (or recursion or a loop-like structure such as map), and conditionals.
College students who finish a CS class with a programming component should be able to use a functional abstraction. That is, they are able to write a function that abstracts away details, making it easier for people to develop other parts of the program.
College students who finish a CS class with a programming component
should be able to develop a non-trivial data abstraction, such as a
compound type [16]. If the student has chosen a language that does
not support compound types, students should still be able to describe
compound types they would use if possible. For example, I’m keeping
track of the angle and speed of the cat. Ideally, I would have a single
velocity object that combines those two into one.
A college student who finishes a CS class with a programming component knows how to write readable code. That includes giving functions and variables clear and meaningful names, including comments when appropriate, and formatting the code. I know that this criterion is too hard to grade. But I think that the examples posted online should show good style so as to encourage others to use good style [17].
[1] I’m pretty sure that you can find AP CS courses that use each of the following languages: Scratch, Alice, C, C#, Snap!, Racket, JavaScript, Python, C, AppInventor, and StarLogo. I know I’ve missed some.
[2] After all, you can’t expect most readers to know this wide variety of possible languages.
[3] No, I don’t know how the storage
got added.
[4] Special interest group on Computers and Society.
[5] I will admit that I do not understand the subtle difference between the rubric and the notes that indicate how it is applied; I would classify the latter as part of the rubric, but ETS does not.
[6] Grinnell currently gives generic science credit for CSP. We will revisit that decision after the new examples and rubric notes are posted this fall. Since Principles is in its infancy, I expect that we will be checking our decision every year or two for the next five or more years.
[7] I would prefer that a student also cites generated code. However, citing generated code is a bit complex, even for some college students.
[8] And, I assume, at most schools.
[9] I’m not sure what would be appropriate for students with disabilities; it would depend on their IEP [10]. I might also make an exception for an ESL [11] high-school student. But once they reach college, I expect students to follow standards of American English writing.
[10] Individualized Education Program.
[11] English as a Second Language.
[12] College students don’t always choose to follow instructions, but they know how to follow them, and they tend to do so on examinations.
[14] Well, the best students can make five separate essays blend into one seamless essay. But they still make the parts clear and make them stand alone.
[15] Science and Technology Studies.
[16] I would require that they need to be able to develop a compound object or structure. However, I’m not sure if that’s possible in every language that CSP permits.
[17] The high-scoring example currently posted online is something that I would not accept from a student. Seeing it as a high-scoring example makes me want to discount the CSP AP altogether.
Version 1.0 released 2017-06-16.
Version 1.0.1 of 2018-02-25.