Sprints for CS1: Retakes, Reinforcement, and a 92 Percent Pass Rate

Each colored square is one week. Dark squares introduce a topic, outlined squares apply it, and bright squares are quest weeks, when students show what they can do on their own. Pick a quest and the dots show every week a student could take it. Quest A, the first, has five chances; the final quest has one. Select any week to see its lab.

Count the dots for each quest: five for A, four for B, three for C, two for D, and one for the final. Early topics get the most chances because everything later builds on them. Retakes sit in reinforcement weeks 5, 8, and 11 and in week 15, so a student who struggled with storing data in week 3 can show progress in week 15, after 12 more weeks of practice.

The five topics run from Storing and Manipulating Data through Controlling Flow and Process, Collections of Data, and Files & More to Advanced Concepts. Labs meet weekly (up to 30 students, one graduate and one or two undergraduate teaching assistants): two lab weeks introduce material, simple first and more abstract second (the Collatz lab has one loop and one if; the rock-paper-scissors lab has several of each), and the quest week is open work time. The paper argues that this cycle catches a misconception within three weeks, where revising a traditional course takes a month or longer.

The text says segments are retaken in “later reinforcement weeks,” while Table 1 lists the last retake window in week 15, a quest week, and lists no retake in week 14, the last reinforcement week. The demo follows Table 1.

This is a real lab from the course: a program that counts how many steps a number takes to fall to 1 when you halve even numbers and triple-and-add-one to odd ones. Six lines are blank. Pick an answer for each, press Run the autograder, and see how many of five checks pass. Wrong answers cost nothing but an attempt, and only your best attempt counts, which is the whole idea of the course’s quests.

Start with 6: it goes 6, 3, 10, 5, 16, 8, 4, 2, 1, which is eight steps, and the autograder expects the output 8. Try a wrong choice on purpose (odd_collatz(n) in the even branch, say) and read the result table: some inputs fail, some never finish, and the error names the problem. That feedback, before the grade is final, is what the retake system buys.

The menus allow 1,296 programs, and exactly two pass all five tests. The lab intends n // 2; n / 2 also passes, because Python’s true division makes n a float (6 / 2 is 3.0) and the loop still stops at 1.0, which equals 1. Output-only autograding cannot see the difference, which is one reason the course pairs every programming segment with a knowledge segment and a class review. The number of attempts follows the quest picked above: five for Quest A, one for the final.

The paper’s quests are not public, so the demo uses Lab 3 as a stand-in for a quest’s programming segment, which the paper describes in the same form (a partially finished program). The model behind the demo was checked against Python itself: every one of the 1,296 filled-in programs gives the same outcome in the page and in CPython (the same output, the same exception class, or no finish in either: 10,000 loop passes in the page, 0.1 seconds in Python) on all five test inputs. Best-of-k scoring is a monotone policy, so a student’s counted score can only rise across attempts; the paper does not report how many attempts students used.

Each dot is a pass rate: the share of students who earned an A, B, or C. Across both semesters, 92.56 percent passed. Students in the major passed at 95.83 percent and students from other majors at 90.90 percent. The studies the paper cites put typical first programming courses in the upper 70s.

A pass rate is passing students divided by all students. In Fall 2022, 53 of 54 majors passed: 53 ÷ 54 = 0.9815, or 98.15 percent. Spring 2023 had only 18 majors, so two students not passing moved that rate down to 88.88 percent. Small groups swing more, which is why the yearly row (69 of 72 majors) is the steadier number.

Switch to From the text’s counts to divide the counts the paper prints. Five cells match, including both Spring 2023 cells and the majors’ year. Four do not: the text gives Fall 2022 non-majors as 71 of 82 (86.59 percent) where the table prints 91.42, and the year totals inherit the difference. The non-major counts also add to 155, while the table header says 147.

The Wilson intervals (the page’s) show how much two semesters can say. The year’s pass rate sits between 86.3 and 93.9 percent on the text’s counts (206 of 227), or between 88.3 and 95.4 percent on the rebuilt counts (199 of 215); either way the lower bound clears the upper-70s range the paper cites. The literature range is a summary of other courses, not a measured control, so this comparison describes the gap without testing it. Spring 2023 majors (16 of 18) span 67 to 97 percent. The search below shows that one Fall 2022 non-major count rebuilds the whole table.

Students answered an anonymous, open-ended survey at the end of each semester. Three in five responded in the fall and about two in five in the spring. The most repeated point: retakes turned grade anxiety into what one student called “motivational stress.”

The survey asked about three areas: whether assignments met their learning objectives, how engaged students stayed, and how they linked engagement to success. It recorded no majors or grades, so its themes cannot be tied to the pass rates above, and the paper reports no counts per theme. The authors name the anonymous, anecdotal nature of this feedback as a limitation, along with possible after-effects of the COVID-19 pandemic.

• Across Fall 2022 and Spring 2023, 92.56 percent of 219 students passed the redesigned course.
• Majors passed at 95.83 percent and non-majors at 90.90 percent over the year.
• Students said retakes lowered the pressure of grades and that applying each topic to real problems helped.
• The teaching team could fix a misunderstanding within three weeks, where revising a course usually takes a month or more.
• In the second semester, students understood a tricky Python rule (how slices count positions) better after only small changes to how it was taught.

• High pass rates. 92.56 percent of 219 students passed (A to C) across two offerings; majors 95.83 percent (n = 72), non-majors 90.90 percent (n = 147); literature values for CS1 sit in the upper 70s, with media-computation courses near 90 percent.
• Fast correction. Whole-class review after each quest addresses misconceptions within three weeks; the authors credit this turnaround and the lowered pressure to learn each topic once, in one way, for the results.
• Slicing improved. Comprehension of Python’s half-open slices improved in the second cohort with minimal changes to the presentation.
• Student response. Themes: retakes reduced grade pressure, reinforcement lectures built mental models of execution, several instructors with different styles helped, and the material applied beyond the course.
• Next steps. Pre and post assessments, longitudinal tracking into later courses, and trials at other institutions.

A first programming course often decides whether a student stays in computing. This course gave every student several chances to show what they had learned, and it fixed confusion while the topic was still fresh. Almost everyone passed, including the students who were not computing majors. The design asks for no special software: a schedule, a set of retakeable quests, and a habit of reviewing mistakes together.

The paper moves an idea from industry into the classroom: software teams work in short sprints with frequent review, and this course does the same with teaching. The cost sits with the instructors (writing several versions of each quest, grading retakes, and holding small-group sessions), and the payoff is a course in which an early stumble no longer decides the grade. The labs are public, so another department can start from the same materials.

The design is portable and the evidence so far is descriptive: one institution, two offerings, no comparison section, and pass rates that depend on grading policy, which the redesign itself changed. The authors call for pre and post measures, longitudinal tracking, and multi-site trials. A controlled comparison, per-student attempt logs, and DFW counts before and after the redesign would let the next study separate the effect of retakes from the effect of the sprint structure.

Notes from building this page

• One count rebuilds Table 2. The text’s counts reproduce five cells (Fall majors, all three Spring cells, and year majors). Holding those, a search over every Fall 2022 non-major count k of n with n up to 1,000 finds exactly one pair that reproduces the other four printed cells: 64 of 70 (91.43, printed 91.42). It implies 143 non-majors and 215 students for the year, four fewer than the headers’ 147 and 219 in each case. The text’s 71 of 82 implies 155 and 227.
• Mixed rounding. No count fits if every cell is rounded, or if every cell is cut, to two decimals: 98.15 (53/54) is rounded, while 88.88 (16/18), 91.42 (64/70), and 90.90 (130/143) are cut. Table 2 appears to mix the two.
• 219 or 218. Table 2’s 219 equals the survey’s enrollments (129 + 90). The lab repository’s README reports 218 students across the year.
• “Significantly higher.” The paper calls 92.56 percent significantly higher than the upper-70s literature values without a test; the intervals above describe the gap, but the literature figures come from other courses and grading policies.
• DFW. The abstract reports a reduction in D, F, and withdrawal grades; the body reports pass rates only, with no earlier DFW rate for comparison. Withdrawals are not identified in Table 2.
• Retake weeks. The text places retakes in reinforcement weeks; Table 1 places the last window in week 15 (a quest week) and none in week 14. The week 11 lab is printed without its number (Lab 8).
• Lab 3 starter. The public main.py leaves the odd function’s return line flush left, so completing the header also requires indenting it; the demo shows the indented form.
• Title and byline. The PDF title page reads “Introducing an Agile Constructivist Pedagogy” and lists three authors; the ASEE PEER record reads “Introducing Agile Constructivist Pedagogy” and lists two.

Try this in class

1. Split a unit into three parts: one day you show a new idea, one day the class uses it together on a real problem, and one day each student tries a short quiz alone.
2. Review the most common mistakes with the whole class before starting the next idea, then offer a retake of the quiz in a later week and keep each student’s best score.
3. At the end, divide the number of students who passed by the number enrolled, and compare your rate with the 92.56 percent in Who passed.