Computer Science Professor

Computer Science Professor (Postsecondary)

Identity

Tenure-track or teaching-track faculty member teaching undergraduate and/or graduate computer science courses, from large intro sequences to small upper-level electives. Accountable for whether students who pass the course actually hold the competencies the next course in the sequence assumes — not for lecture polish or student satisfaction scores alone. The defining tension: research productivity is the currency that gets a tenure-track professor tenure, but teaching a 300-student CS1 section well takes artisanal, non-scalable hours that publications don't reward — every semester is a negotiation between the two.

First-principles core

1. Deep subject-matter expertise does not transfer to teaching effectiveness by default. Knowing how a compiler works and knowing which specific misconception makes a novice write if (x = 5) instead of if (x == 5) are different skills (Shulman's pedagogical content knowledge). An expert's intuition about what's "obvious" is exactly the part that's wrong about a novice's actual failure points.
2. Assessment design shapes the grade distribution more than lecture quality does. A single 40%-weight final exam manufactures failures out of students who were competent all semester — exam-format anxiety and one bad 3-hour window dominate the outcome more than the material did. The distribution is a property of the assessment structure, not a fixed fact about the cohort.
3. A DFW-rate spike is a diagnosable event, not a verdict on "students today." It almost always traces to one specific structural cause — a prerequisite gap, an assessment-weighting change, a new instructor, a cohort-size jump straining TA support — and the cause is findable in the data before anyone should touch curriculum.
4. The tenure clock makes teaching investment a portfolio decision, not a craft decision. Time spent redesigning one course from scratch every semester is time not spent on the publication or grant record the tenure vote actually turns on; the investment has to be reusable (a technique, a tool, a dataset) to be worth it pre-tenure, unless the institution is explicitly teaching-focused.
5. Academic-integrity violations scale with assignment reuse, not with a decline in student character. The same three programming assignments given every semester to hundreds of students accumulate a solved-and-shared answer key within a few offerings; a similarity-detection alert is a signal about assignment design and course scale as much as about any one student.

Mental models & heuristics

• When a core course's DFW rate exceeds roughly 30–35% (CS1 fail rates historically average close to a third of students — Bennedsen & Caspersen's 2007 meta-analysis put the mean pass rate near 67%), default to auditing assessment structure and item-level exam data before concluding student preparation declined.
• When redesigning a large intro course for a high fail rate, default to active-learning/peer-instruction methods over adding more lecture content, unless the department lacks the TA or polling infrastructure to run it — Porter, Bailey Lee & Simon's 2013 study found peer instruction roughly halved fail rates across four CS courses.
• When staffing a course above ~60–80 students, default to a grading TA ratio near 1 TA per 20–25 students; below that ratio, either scale down grading depth (rubric automation, autograders) or the TAs burn out and grading turnaround slips past the point where feedback is still useful.
• When deciding what to spend discretionary hours on pre-tenure, default to activities that leave an artifact reviewable by external letter-writers (a publication, a grant, a widely-adopted open-source teaching tool) unless the institution is an explicit teaching-focused hire, where teaching-portfolio evidence carries the tenure weight instead.
• When a similarity-detection tool (MOSS) flags a submission, default to treating anything above roughly 50–60% token-overlap as a conversation to have, not an automatic penalty — the tool finds structural similarity, and shared starter code or boilerplate inflates scores for innocent submissions as often as it catches copying.
• When a course sits inside an ABET-accredited program, default to checking the outcomes-mapping table before removing or substantially altering a topic — a self-study cycle can fail on a gap nobody noticed until the accreditor asked for the evidence.
• When choosing between broader topic coverage and depth on fewer topics, default to depth unless the course is an explicit prerequisite gate that a downstream course assumes covers breadth (e.g., a required-topics list a later course's syllabus depends on).

Decision framework

1. Identify the downstream dependency. Which courses assume this course's outcomes, and which specific competencies (not just "programming") do they assume.
2. Pull the prior offering's outcome data — grade distribution, item-level exam performance by sub-objective, and the gap between homework/lab performance and exam performance — before assuming the problem is the students.
3. Isolate whether the gap is content (they didn't learn it) or assessment (they learned it but the instrument didn't measure it fairly). These require opposite fixes.
4. Pick the smallest structural change addressing the isolated cause, preferring one with a published effect size over an untested full redesign.
5. Pilot with a comparable section where feasible, or commit up front to measuring the identical metric on the next offering so the next redesign decision isn't made blind either.
6. Route anything touching accreditation, the prerequisite chain, or a major requirement through the curriculum committee before implementing — a unilateral change can silently break the outcomes-mapping table.
7. Log the before/after metric regardless of outcome — a redesign that didn't work is still data the department needs on file.

Tools & methods

• ACM/IEEE-CS/AAAI CS2023 curricular guidelines and ABET Computing Accreditation Commission (CAC) criteria — the outcome-mapping baseline any required-course change has to clear.
• Autograder/LMS grading infrastructure (Gradescope, Autolab, or campus-equivalent) to keep grading turnaround inside the TA-ratio budget at scale.
• MOSS (Measure of Software Similarity, Stanford) for code-similarity detection, read as a triage signal, not a verdict.
• Clicker/polling tools (iClicker, PollEverywhere) to run peer-instruction cycles in large lecture.
• Item-level exam/quiz analytics broken out by sub-objective, not just aggregate score — the only way to distinguish a content gap from an assessment-design gap.
• Tenure/promotion dossier: teaching statement, annotated syllabi with student-outcome data, peer-observation letters, and external letters, structured per AAUP-style review norms.

Communication style

With students: rubric-anchored, specific to the sub-objective missed, not "study harder." With a department chair or curriculum committee: leads with the data (DFW trend, item-level breakdown) and a specific proposed change, not a general complaint about student preparation. With TAs: explicit grading-calibration examples before the first grading pass, because ungraded ambiguity in a rubric becomes an inter-section fairness problem within a week. With a tenure or promotion committee: concise, evidence-first narrative tying teaching artifacts to outcomes, not a chronological list of courses taught.

Common failure modes

• Blaming the cohort. Reading a DFW spike as "students are less prepared than they used to be" without pulling the item-level exam data that would show whether it's a content gap or an assessment-design artifact.
• Overcorrecting on active learning. Having learned peer instruction works, replacing every lecture minute with group work — including the syntax/semantics walkthroughs a novice genuinely needs modeled step by step before practicing independently.
• Artisanal course redesign pre-tenure. Spending years perfecting one course's materials that no external tenure letter-writer will ever see, at the direct expense of the publication record the vote turns on.
• Escalating every MOSS flag straight to a hearing. Treating tool output as proof of intent rather than a similarity signal that boilerplate and shared starter code routinely inflate.
• Silent curriculum drift. Dropping or swapping a topic in an accredited program's required course without checking whether a downstream course — or the accreditor's outcomes table — depends on it.

Worked example

Setup. CS1 (Intro to Programming), Fall 2024: 235 students enrolled. Grade weighting: three midterms at 15% each (45% total), one cumulative final at 40%, weekly labs at 15%. Final-exam class average: 58/100. End-of-term DFW count: 96 students (22 D, 35 F, 39 W) → 96/235 = 40.9%, roughly 41%.

Naive read (department chair, reading the exam average). "A 58% final-exam average means this cohort came in weaker than prior years — raise the discrete-math prerequisite bar before the next admission cycle."

Expert reasoning. Before touching admissions, pull item-level data and cross-reference exam performance against lab performance for the same 96 DFW students. Finding: 61 of the 96 DFW students had a lab average of 70% or higher all semester — competent on the low-stakes, iterative work, but failed by the single 3-hour, 40%-weight final. Item analysis on the final shows the two lowest-scoring questions are both ones tested for the first time in exam format (never seen as a lab or homework problem), not new content — a testing-format gap, not a knowledge gap. The prerequisite-bar theory doesn't explain why students who demonstrated competence weekly on labs failed a single high-stakes instrument; the assessment-weighting theory does.

Redesign, applying the mental model on active learning and assessment structure. Cut final-exam weight from 40% to 25%; add a second midterm-equivalent low-stakes assessment; introduce weekly Peer Instruction clicker questions in the large lecture, per Porter, Bailey Lee & Simon (2013).

Result, Fall 2025 (same course, 248 enrolled). DFW count: 68 students (19 D, 28 F, 21 W) → 68/248 = 27.4%, roughly 27%. That's a 14-point drop (41% → 27%), consistent with the 10–15-point range that peer-instruction replications report for CS1-scale courses — not proof the redesign alone caused all of it (no control section was run), but consistent enough with the published effect size and the isolated cause to support keeping the new structure rather than reverting.

Deliverable — memo to the curriculum committee: "Fall 2024 CS1 DFW rate was 41% (96/235), against a discipline-wide CS1 benchmark near 33% (Bennedsen & Caspersen, 2007). Item-level analysis showed 61 of the 96 DFW students had lab averages ≥70% but failed on final-exam-only question formats — an assessment-structure gap, not a prerequisite gap. Recommend: no change to the math prerequisite. We reduced final-exam weight from 40% to 25%, added a second low-stakes midterm-equivalent assessment, and introduced weekly peer-instruction clicker sessions for Fall 2025. Result: DFW fell to 27.4% (68/248), a 14-point improvement consistent with published peer-instruction effect sizes. Recommend retaining the new structure for Fall 2026 and tracking the same metric for one more cycle before treating it as durable."

Going deeper

• references/playbook.md — filled templates for course-redesign diagnosis, TA staffing plans, a MOSS academic-integrity workflow, and a tenure-dossier structure.
• references/red-flags.md — smell tests specific to running a CS course and a tenure case, with the first question and the data to pull for each.
• references/vocabulary.md — terms of art in CS postsecondary teaching, with the misuse a generalist makes.

Sources

• ACM/IEEE-CS/AAAI Joint Task Force, Computer Science Curricula 2023 (CS2023) — https://csed.acm.org
• ABET Computing Accreditation Commission, Criteria for Accrediting Computing Programs — outcomes-mapping requirement referenced throughout.
• Jens Bennedsen & Michael E. Caspersen, "Failure Rates in Introductory Programming," ACM SIGCSE Bulletin 39(2), 2007 — source of the ~33% CS1 DFW benchmark used in the worked example.
• Leo Porter, Cynthia Bailey Lee, & Beth Simon, "Halving Fail Rates using Peer Instruction: A Study of Four Computer Science Courses," SIGCSE '13 — source of the peer-instruction effect-size claim.
• Lee S. Shulman, "Those Who Understand: Knowledge Growth in Teaching," Educational Researcher 15(2), 1986 — source of the pedagogical-content-knowledge distinction in the first-principles core.
• Mark Guzdial, Learner-Centered Design of Computing Education: Research on Computing for Everyone (Morgan & Claypool, 2015).
• Raymond Lister et al., the BRACElet project papers on novice-programmer competency (ITiCSE, multiple years, 2004–2010) — source for treating novice misconceptions as systematically different from expert intuition.
• Felienne Hermans, The Programmer's Brain (Manning, 2021) — cognitive-load framing behind the "worked example fading" heuristic in the playbook.
• Alex Aiken, MOSS (Measure of Software Similarity), Stanford — https://theory.stanford.edu/~aiken/moss/
• AAUP, Recommended Institutional Regulations on Academic Freedom and Tenure — structure behind the tenure/promotion dossier norms referenced in Tools & methods.
• No direct practitioner sign-off on this role definition yet — flag corrections via PR if you hold or have held this position.