The In-Class Small Coding Assignment as Formative Assessment

In computer science (CS) education, the in-class small coding assignment (SCA) is commonly underutilized as merely a way for students to practice CS concepts and programming syntax immediately after instruction, similar to a practice problem set given in mathematics class. Transforming the SCA into an effective tool for formative assessment will require a fundamental change in both teacher perspective and instructional goals.

Computer lab has a long history in CS education. Functioning as both the time and space for students to complete assignments or make progress on their own projects–because prior to the personal computer, workstations were only accessible through well-funded institutions–computer lab developed into an exclusive club where those interested in computing could find each other and develop a shared identity marked by suffering: late nights with error messages and cold pizza that turned into early mornings with error messages and multiple cups of coffee. Napping at a computer or under a desk was common. Today, with the democratization of CS education through CSforAll initiatives, computer labs are no longer the domain of the select few, but entire classrooms of students, now increasingly younger and more diverse, led by an assortment of teachers, many inexperienced in CS, both struggling and persisting to learn and teach CS respectively. Computer lab as a physical space for likeminded individuals will never be the same.

However, computer lab as a time for programming still exists (though instead of a time for suffering, the current version has now been wisely renamed a time for persisting). Persistence time takes the form of the in-class small coding assignment (SCA), a post-lesson activity where students write and debug fully-functioning short programs that employ lesson content, with assistance from the teacher or from peers. Here is a brief example of functional requirements (fancy industry jargon for “directions”) for an SCA that might be given after a lesson on numeric input:

Write a program that asks a user to type in temperature highs from the past seven days, and then returns the average temperature.

A student, given those functional requirements, would then proceed to write a program line-by-line, and test it and debug it error-by-error, using the CS concepts and language syntax presented in the earlier lesson. That the entire process serves as a model for what CS professionals do makes it an appealing and practical instructional tool.

As an instructional tool, there are two primary assumptions that guide the widespread usage of the SCA in CS ed:

  1. A fully-functioning program is evidence of student understanding. After all, they’ve taken lesson content and applied it successfully. Application of knowledge shows understanding.
  2. Since error messages eventually lead to a fully-functioning program via debugging, and assumption #1, error messages can be considered formative feedback.

Unfortunately, these assumptions are wrong. Simply providing time for students to mimic what CS professionals do, forgets the fact that CS professionals already understand. Any keen CS instructor who has taught for any period of time begins to suspect a divide between CS doing and understanding. And now a spate of very recent research supports this suspicion.

Direct research on the divide between doing and understanding by Salac and Franklin (2020) found use of Scratch blocks in completed projects by young students (aged 7-12) could not be correlated with student performance on student assessments on the same block usage. In other words, students could use coding blocks without understanding them; completed projects could not be used as evidence of understanding.

Research into effective CS teaching strategies, like subgoal worked examples (Margulieux, Morrison, and Decker, 2020), and the TIPP&SEE method (Salac, Thomas, Butler, Sanchez, and Franklin, 2020), also revealed the need to scaffold understanding by further decomposing encounters with CS concepts, ones previously assumed to already be cognitively accessible to new learners, into even smaller pieces to teach students how and in what order to develop their understanding. The common thread in all this research: the need to teach to finer grain and ordered understanding of CS concepts to new students, because they do not understand even though they have been required to use those concepts.

Application of my Assessment Design Checklist (ADC) reveals similar shortcomings of the in-class SCA. The learning target of the SCA is often conflated with simply completing the assignment without any errors. Or, more accurately, the learning target is simply presented by the instructor as completion of the assignment without any errors, with little or no emphasis placed on being able to explain new CS concepts used in the project. The focus on fixing errors and debugging by student and teacher alike further contributes to that misplaced focus on doing rather than understanding. Even presenting the SCA as a set of “functional” requirements emphasizes the doing rather than the understanding!

The second question in my ADC asks whether the in-class small coding assignment is based on domain knowledge–specifically whether it uses current pedagogical content knowledge. It does not. Integration of a type of reverse TIPP&SEE or subgoal labeling would provide scaffolding to guide student thinking and design strategy for the assignment. This guided design is key to helping students understand details of the code they use and how a program can be planned for in advance (based on understanding), rather than developed through error-checking (based on doing).

The current state of math education serves as a model for the development of the SCA into an effective tool for formative assessment. Having helped my current 7th grader with her Common Core math homework since 3rd or 4th grade, I have been struck by how frequently she has been asked to explain her solution in writing. I have been pleasantly surprised at the conceptual understanding she has demonstrated and how much more complete her mathematics education is in comparison to my rote mathematics education in the 80’s, where doing (problem sets and exams) was assumed to be evidence of understanding. But now? Understanding is evidence of understanding!

So, just as math teachers ask for explanations of understanding, CS teachers must do the same. Some recommendations:

  1. The SCA should be presented not as a set of functional requirements, but decomposed into a set of step-wise design requirements that scaffold the decision-making process that students need to use to translate requirements to code.
  2. Teachers, when assisting students, should no longer settle for helping students debug their code. Instead, teachers need to debug errors in students’ conceptual understanding. This can be done casually during code debugging by asking students questions, but also formally by asking students to submit along with their fully functioning code a written explanation of how their code works and how it was designed.

The recommendations above should turn the in-class SCA into a formidable tool for formative assessment, while also giving additional support to students new to CS. The idea of persistence as an essential disposition in CS, an idea birthed in the crucible of the computer lab, should decrease in necessity as CS Education matures, more is discovered about CS pedagogy, and teachers teach for understanding and not for doing.

References

Margulieux, L. E., Morrison, B. B., & Decker, A. (2020). Reducing withdrawal and failure rates in introductory programming with subgoal labeled worked examples. International Journal of STEM Education, 7(1), Article 19. https://doi.org/10.1186/s40594-020-00222-7

Salac, J., & Franklin, D. (2020). If They Build It, Will They Understand It? Exploring the Relationship between Student Code and Performance. Proceedings of the 2020 ACM Conference on Innovation and Technology in Computer Science Education, 473–479. https://doi.org/10.1145/3341525.3387379 

Salac, J., Thomas, C., Butler, C., Sanchez, A., & Franklin, D. (2020). TIPP&SEE: A Learning Strategy to Guide Students through Use–>Modify Scratch Activities. Proceedings of the 51st ACM Technical Symposium on Computer Science Education, 79-85. https://doi.org/10.1145/3328778.3366821 

One thought on “The In-Class Small Coding Assignment as Formative Assessment

Add yours

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Blog at WordPress.com.

Up ↑

Create your website with WordPress.com
Get started
%d bloggers like this: