CS-128 Course Development
Bridging the Programming Gap: A Data-Driven Approach to CS Curriculum Reform
The Institutional Challenge
When I arrived at the University of Illinois in Fall 2020, I inherited both an opportunity and a challenge. The computer science department had identified a critical flaw in our introductory curriculum that was creating inequities and compromising educational outcomes. For several years, students would begin with CS 125, gaining their first programming experience, then move to a discrete structures course in their second semester. This created a problematic gap—students could go nine months without programming practice before encountering CS 225 (Data Structures) in their third semester. Programming is a skill that atrophies without practice, and our data structures instructors were spending the first month of their course providing remedial programming instruction.
The department’s initial solution had been to create CS 126, a second-semester programming course taken alongside discrete structures. This kept students programming and provided essential practice before CS 225. However, this fix contained a fundamental flaw that I was brought in to help address: CS 126 was restricted to computer science majors only. This restriction created cascading problems throughout our curriculum. With 80% of CS 125 students being non-majors—either pursuing minors or simply curious about computing—the majority of our students were excluded from this critical preparation. CS 125 had to somehow prepare these students to jump directly to CS 225, while simultaneously providing appropriate content for the majors who would continue to CS 126. Meanwhile, CS 225 struggled with a bimodal distribution of student preparation, unable to move forward with planned reforms to focus more on algorithms and data structures rather than programming fundamentals.
This structure created an inverted equity dynamic. Our CS programs are among the most competitive at the university, with Class of 2025 admission rates of just 7.4% for Computer Science and 17.4% for Computer Science + X programs—compared to the university’s overall 36.6% admission rate. The students who successfully navigated this highly selective process—the ones with the strongest academic preparation—were the ones given an additional semester of programming support. Meanwhile, non-majors, who often arrived with less prior programming experience, were required to leap directly into CS 225 without this extra foundation. In practice, we were providing the most support to those who arguably needed it least.
Reimagining the Solution
Working with colleagues across the department, I helped design and implement a comprehensive restructuring of our introductory sequence. The solution appeared simple on its surface: open the second-semester programming course to all students and require it as a prerequisite for CS 225 regardless of major. However, CS 126’s intensive design components—particularly its 6-to-1 mentor-guided code reviews—consumed unsustainable amounts of space and staff resources. Scaling these components to serve thousands rather than hundreds of students was impossible.
Our solution was to refactor the course into two components. CS 128 would contain all the scalable learning objectives around programming and computer science concepts, while CS 222 would preserve the design studio and code review experiences for CS majors as a one-credit add-on course. This allowed us to create a consistent pathway for all students while maintaining special experiences for majors without creating prerequisite barriers.
The restructuring created an opportunity to fundamentally reimagine how introductory programming is taught. Instead of merely scaling up existing methods, I built CS 128 around evidence-based pedagogical principles designed to better support and engage our diverse student population.
Leadership and Collaborative Development
The transformation of CS 128 demanded both extensive departmental collaboration and strategic leadership in curriculum coordination. In partnership with colleagues Geoffrey Challen, G. Carl Evans, Margaret Fleck, Michael Woodley, and Craig Zilles, we met regularly throughout the development process to ensure seamless alignment with the broader introductory sequence. This collaboration was vital for managing the cascade effects of curricular change—allowing CS 125 to remain focused on foundational concepts while enabling CS 225 to move beyond remedial programming instruction.
A cornerstone of the project was mentoring undergraduate students in curriculum development. Beginning in Fall 2020, I recruited and trained teams of undergraduate developers who played a central role in building both technical infrastructure and course content. Through this work, they gained hands-on experience in educational technology development while contributing systems that would ultimately support thousands of their peers. This mentorship model established a sustainable development pipeline and offered students distinctive professional growth opportunities in educational innovation.
Institutional Support and Grant Success
The CS 128 project benefited from sustained institutional support through the Strategic Instructional Innovations Program (SIIP). In 2020, our team received an initial $8,500 grant, Revising the CS Introductory Programming Sequence, which provided essential seed funding during the critical development phase. Building on that success, we secured a $10,000 renewal grant in 2021—evidence of the institution’s confidence in our approach and outcomes.
This multi-year funding allowed for systematic development and iteration rather than rushed implementation. The grants supported undergraduate student developers, infrastructure scaling through equipment purchases, and extended collaboration for cross-course coordination.
The Pedagogical Foundation
The CS 128 instructional platform was built on a fundamental insight about skill acquisition. Like learning to play piano or shoot basketballs, programming proficiency emerges from consistent, focused repetition. Malcolm Gladwell’s “10,000-hour rule” may oversimplify, but the core principle holds: students need many opportunities to practice, make mistakes, and refine their techniques. Traditional lecture-based instruction, where students passively absorb information for 150 minutes per week, fails to provide these essential repetitions.
Instead, CS 128 distributes learning across daily 20-30 minute interactive sessions. This approach respects what we know about attention spans—student focus begins to fade after about 10 minutes—while providing the frequent touchpoints necessary for skill development. Each daily lesson comprises multiple 5-10 minute video segments interspersed with programming exercises that students complete directly in their browsers. This creates a rhythm of exposition followed immediately by application, ensuring concepts are reinforced while still fresh.
The programming exercises embedded throughout lessons serve multiple pedagogical functions. They provide immediate application of newly introduced concepts, allowing students to test their understanding in real-time. The auto-grader offers instant feedback, but crucially, students receive unlimited submission attempts without penalty. This encourages experimentation and learning from mistakes rather than focusing on getting the “right answer” on the first try.
Structuring the Learning Experience
CS 128 follows a carefully orchestrated weekly rhythm designed to build skills progressively while maintaining engagement. The course employs four key components that work together to create a comprehensive learning environment: daily interactive lessons, hands-on recitation sections, machine problems (mini-projects), and regular assessments.
The current grading structure (as of Fall 2025) reflects our emphasis on multiple assessment modes: machine problems comprise 40% of the final grade, quizzes account for 40%, daily interactive lessons make up 15%, and recitation participation contributes 5%. This balanced approach ensures students are evaluated across different skill dimensions while maintaining some emphasis on proctored assessments.
Daily Lessons via CS128.org
The week begins with daily lessons that introduce new concepts through our interactive platform. These lessons follow a cumulative progression that builds complexity incrementally, with each day’s content developing from previous lessons through a multi-modal approach incorporating text, video explanations, and interactive walkthroughs. The lessons are designed to encourage daily practice rather than cramming; we’ve evolved from a hard Sunday 17:00 deadline to a 48-hour window after assignment, reinforcing the principle that programming skills develop through consistent, distributed practice.
Each daily lesson comprises multiple 5-10 minute video segments interspersed with programming exercises that students complete directly in their browsers. This creates a rhythm of exposition followed immediately by application, ensuring concepts are reinforced while still fresh. The programming exercises embedded throughout lessons serve multiple pedagogical functions, providing immediate application of newly introduced concepts and allowing students to test their understanding in real-time.
The auto-grader offers instant feedback, but crucially, students receive unlimited submission attempts without penalty. This encourages experimentation and learning from mistakes rather than focusing on getting the “right answer” on the first try.
Quizzes in the CBTF
Rather than relying on traditional high-stakes midterm exams, CS 128 uses bi-weekly quizzes that each contribute equally to the final grade. This structure reduces test anxiety while encouraging consistent engagement with the material, recognizing that programming skills cannot be crammed—they must be built gradually through regular practice.
During the pandemic, we developed a custom secure exam system integrated with PrairieLearn that enabled remote proctoring via Zoom. Since then, we have transitioned to the University’s Computer-Based Testing Facility (CBTF), which offers a more scalable proctored environment. Students have a four-day window to schedule their quiz at the CBTF, giving them flexibility in timing while preserving exam integrity.
Quizzes are delivered through PrairieLearn and completed in our custom VS Code workspace, providing students with the same familiar tools available in the containerized setup they use for Machine Problems. Within this environment, students write and submit complete programming solutions, facing real compilation errors and meeting syntax requirements just as they would on any other assignment. The problems are deliberately focused and scoped to fit the allotted time, with complexity comparable to the daily lesson activities students regularly practice.
To better evaluate students’ ability to compose programmatic solutions, beginning in Fall 2025 we introduced a combination of Parsons problems and full programming tasks. Parsons problems present pre-written code blocks that must be arranged into the correct order to form a working solution. This format emphasizes program structure, logic flow, and algorithmic reasoning without overwhelming students with syntax details. When paired with traditional programming problems, this blended approach offers a more comprehensive measure of student understanding, balancing conceptual mastery with the practical skills needed to independently implement code.
With the growing influence of AI tools, we have also increased the weight of proctored assessments. By Fall 2025, quizzes will represent 40% of the final grade, up from 25% in Spring 2025. This shift underscores the essential role of controlled evaluation in modern education: without secure assessments, we cannot reliably measure what students truly know. Quizzes remain the only setting in which we can be confident students are demonstrating their own knowledge and skills, making them a cornerstone of ensuring authentic programming competence.
Looking forward, quiz development will incorporate Machine Problem–based questions that ask students to explain and analyze functions they have previously implemented. This approach requires students who rely on AI-generated code to engage more deeply with the material, fostering genuine understanding rather than superficial completion. Planned formats include Parsons problems, where students reconstruct program logic by arranging code fragments; fix-it questions, where they make targeted modifications to existing solutions; and implementation problems, which should be straightforward for students who have mastered the underlying concepts.
Machine Problems (Mini-Projects)
Programming assignments in CS 128 are designed as substantial mini-projects that allow students to apply concepts learned throughout the week in more complex, integrated contexts. These assignments provide opportunities for students to engage in authentic programming tasks that mirror real-world development challenges.
Initially, we implemented two mechanisms to combat procrastination—a particular challenge in programming courses where students often underestimate implementation time. We required students to earn at least 10% of the assignment’s points by a mid-week checkpoint or forfeit them, and offered a 5% bonus for submissions 24 hours before the deadline. While these incentives successfully encouraged earlier starts, we recognized that the rigid one-week timeline didn’t account for the reality of student workloads.
Our first attempt at reform was to remove the checkpoints and bonuses while extending all assignment deadlines from one week to two weeks, hoping this would reduce student stress and promote better work distribution. Instead, we observed that many students’ submission patterns remained virtually unchanged: they simply delayed starting until the second week, effectively maintaining their original one-week work pattern. This revealed that students weren’t actually procrastinating—they were accurately assessing the time needed for each assignment.
This insight fundamentally changed our approach. Rather than impose artificial deadlines or uniform durations, we now carefully calibrate each assignment’s timeline to match its actual complexity. Straightforward assignments remain at one week, while more involved projects receive two weeks. This targeted scoping has proven far more effective than our original interventions, supporting students in developing proper time management skills while respecting the genuine complexity of programming assignments.
Our late submission policy has evolved significantly based on observed student patterns. Previously, students could submit assignments for full credit by the deadline, then receive 67% credit if submitted any time before the last day of instruction. This binary approach often led to procrastination and all-or-nothing submission patterns. We’ve now implemented a more gradual penalty system with grade caps: assignments submitted one day late are capped at 95%, two days late at 90%, three days late at 85%, and four or more days late at 70%, with no work accepted beyond the last day of instruction. Additionally, students receive two “No Questions Asked” late penalty waivers that can be applied to any Machine Problem throughout the semester, allowing them to earn up to 100% even when submitting up to the last day of instruction. This graduated approach maintains incentives for timely submission while providing realistic flexibility for students managing complex schedules, and the data suggests it better supports continuous engagement with course material rather than encouraging deadline-driven cramming.
Recitation Sections
Recitation brings students together for 75-minute in-person section meetings that go beyond technical instruction. In a course serving over 800 students, these sessions create smaller, collaborative environments where students can work together, ask questions, and receive immediate feedback from teaching assistants. Each recitation includes hands-on programming activities designed to reinforce course concepts in a supportive setting. On weeks when a new Machine Problem is released, recitation also features a brief introduction to the assignment, giving students an early opportunity to clarify expectations and ask questions.
As of Fall 2025, recitation accounts for 5% of the final grade, with emphasis placed on participation and engagement rather than performance. This structure supports the course’s commitment to inclusive learning by encouraging active involvement without the pressure of high-stakes assessment.
Technical Infrastructure as Pedagogical Enabler
CS 128’s technical infrastructure is built on a simple philosophy: programming skills grow through consistent practice and immediate feedback. Every system we design reinforces this principle while removing the traditional barriers that stand in the way of student learning.
Removing Barriers, Enabling Practice
Our browser-based programming playground removes the setup barriers that often derail new programmers. Students can write, compile, and test C++ code instantly—no compiler installations, no environment configuration. This frictionless start allows them to direct their energy toward understanding programming concepts rather than troubleshooting technical issues.
For larger course assignments, every student works in an identical containerized development environment accessible through VS Code. This consistency ensures code behaves the same across all machines, regardless of operating system or hardware. Standardization not only allows teaching assistants to focus on helping with concepts instead of platform-specific bugs, but also enables students to collaborate confidently in recitation, knowing their code will run identically on their peers’ systems.
Humanizing Support at Scale
The CS 128 Help Queue System (built in-house) ensures that students receive personalized assistance when they need it. By seamlessly managing both virtual and in-person office hours, the system maintains human connection regardless of modality.
We run in-person office hours on campus in the afternoons and extend support into the evenings with virtual office hours. This allows students debugging late at night to receive help from home, while those who prefer face-to-face interaction can attend sessions during the day.
Office hour attendance patterns vary significantly throughout the semester. Some sessions see high demand with lengthy queues, while others have minimal attendance. In Spring 2025, certain sessions frequently had more teaching staff available than students seeking help. When staff outnumber students, we implement round-robin auto-assignment to ensure efficient queue management and reduce student wait times.
Tools for Independent Problem-Solving
The autograding system offers students more than a simple pass/fail result—it highlights test failures and points them toward potential issues in their code. Integrated debugging tools within our development environment further support independent problem-solving. A visual debugger allows students to trace program execution step by step, while Address Sanitizer (ASan) detects memory errors and reports their source. By working with these professional-grade tools, students learn to diagnose and resolve problems on their own rather than depending on course staff intervention.
Data-Driven Continuous Improvement
Teaching at scale provides unique opportunities for data-driven pedagogical refinement. Our infrastructure generates data about student learning patterns that inform course improvement. When submission data reveals common struggles, we can provide additional resources or adjust our teaching approach. Our technical systems thus serve as both learning platforms and feedback mechanisms, ensuring the course continuously adapts to student needs.
Every week, I analyze comprehensive metrics on student performance and engagement. These analyses go beyond simple grade distributions to examine patterns that inform instructional decisions. For instance, I can track submission patterns to our auto-grader to understand how students approach problems. When I see many students making similar mistakes, it indicates a conceptual misunderstanding that needs addressing. When submission counts spike dramatically for particular exercises, it suggests inadequate scaffolding or unclear problem statements. This real-time feedback allows rapid iteration and improvement of course materials.
I also examine performance differences across student populations. How do transfer students perform compared to those who took CS 124 at Illinois? Are there systematic differences between majors and non-majors that suggest needed support structures? Do students who earned proficiency credit struggle with particular topics? These analyses help ensure that CS 128 serves all students effectively, not just those who fit a particular profile.
Office hour attendance patterns provide another valuable data source. By tracking when students seek help and what they ask about, we can identify topics that need reinforcement and optimize staff scheduling. The shift from deadline-concentrated attendance to distributed engagement throughout the week validates some of our recent policy changes.
Outcomes and Impact
The transformation from CS 126 to CS 128 has exceeded our initial goals. From Spring 2021’s pilot launch through Spring 2025, enrollment expanded from approximately 300 CS majors per semester to over 800 students across all disciplines, representing a fundamental shift in accessibility. This isn’t simply growth for growth’s sake—we’re providing essential computational education to future scientists, engineers, artists, and entrepreneurs who will need programming skills in their careers.
More importantly, we’ve eliminated the two-track system that created inequities in student preparation. All students now follow the same path to CS 225, which has finally been able to drop its month of remedial programming instruction and focus on algorithms and data structures as originally intended. This consistent preparation has improved outcomes in CS 225 and subsequent courses.
CS 128 Spring 2025 data demonstrates the success of this approach across diverse student populations. Overall, 87.23% of students earned A grades, with a course average of 93.74 and median of 95.46. The course now serves both majors (47.93%) and non-majors (52.07%) effectively, with non-majors comprising the majority of enrollment—a dramatic shift from the original CS 126 that served only CS majors.
Spring 2025 performance analysis reveals important patterns across different student groups. The final enrollment after all add-drops was 822 students who received final grades, with a gender distribution of 67.3% male and 32.7% female. Female students slightly outperformed male students, with 88.85% earning A grades (average 94.01, median 95.54) compared to 86.41% for male students (average 93.60, median 95.44). Majors achieved a 92.64% A rate with an average of 95.17 and median of 96.10, while non-majors earned A grades at an 82.24% rate with an average of 92.43 and median of 94.80—a gap that reflects preparation differences but demonstrates that non-majors can succeed in the course.
Multi-semester prerequisite pathway analysis reveals consistent patterns across CS 128’s evolution. In Spring 2025, students who earned CS 124 proficiency credit performed exceptionally well, with 90.32% earning A grades (average 93.67, median 97.23). Students who took CS 124 at Illinois performed similarly to the overall population with 88.09% A grades (average 94.03, median 95.48). However, students with transfer credit showed 56.52% A grades (average 84.28, median 90.65).
This pattern has proven remarkably consistent across multiple semesters, providing robust evidence for curriculum improvement opportunities. Fall 2024 data showed transfer students achieving 92.31% A grades (average 94.24, median 95.29) with a small sample (N=13), while Spring 2024 data with a larger sample (N=33) showed 54.55% A grades (average 81.64, median 92.95). Fall 2023 data with the largest transfer student sample (N=58) showed 67.24% A grades (average 88.33, median 95.01), providing a middle ground between the extremes.
The longitudinal data reveals that transfer student performance varies significantly by semester and sample size, but consistently trails other pathways. Meanwhile, proficiency credit students maintain remarkably consistent excellence across all semesters (94.48% to 96.71% A grades), and students who took CS 124 at Illinois show steady improvement over time (57.99% to 88.09% A grades from Fall 2023 to Spring 2025), suggesting continuous refinement of our prerequisite alignment.
This performance data provides valuable insights that guide targeted improvements to our curriculum and support systems. It allows us to systematically identify where transfer credits may not fully align with CS 124 expectations, creating opportunities for stronger articulation agreements and prerequisite alignment. Just as importantly, the information supports proactive outreach to transfer students, offering preparation resources and tailored support before challenges arise. In CS 128, the breadth of data collection opens new possibilities for evidence-based interventions that improve outcomes for all students while maintaining our commitment to universal access.
These insights extend beyond instructional alignment to broader questions of student persistence. Enrollment data, for example, sheds light on when and why students decide to leave the course. In Spring 2025, add-drop patterns revealed a 5.94% drop rate after the initial add-drop window (weeks 4–14), with 112 total drops across the semester. Early departures (weeks 1–3) were largely non-majors or students with unknown major status, 57% of which occurred in the very first week. Later in the term, the trend was even more pronounced: 96.2% of post-add-drop withdrawals came from non-majors, with majors representing only 3.8% of these departures.
Perhaps most surprisingly, Spring 2025 late drops data shows that 15 students earning A-level grades (90-100%) still chose to drop the course. The grade distribution at time of drop was bimodal: high-performing students (A-range) and struggling students (F sub-ranges), with relatively fewer drops in the B-D range. This pattern suggests different motivations for leaving—high achievers may have concerns about maintaining perfect GPAs, while low performers face genuine academic difficulties. The concentration of drops in Week 7 (before dynamic memory content) indicates a critical intervention point for retention efforts.
The evolution of CS 128 demonstrates the power of intentional curriculum design supported by robust technical infrastructure and data-driven decision-making. In just four years, the course has expanded access to high-quality programming education, eliminated inequities in prerequisite pathways, and supported both majors and non-majors in achieving meaningful success. The longitudinal performance data confirms that while most student groups are thriving, transfer students continue to face unique challenges that require targeted support. At the same time, enrollment and add-drop analyses highlight both the strength of student persistence and the need for proactive interventions at critical points in the semester. Taken together, these findings show that CS 128 is not only preparing students effectively for CS 225 and beyond, but also serving as a model for scalable, equitable, and evidence-based introductory computer science education. As we move forward, the course will continue to refine its alignment, expand its support systems, and remain committed to universal access—ensuring that every student has the opportunity to succeed in computer science.
Implications for Computer Science Education
The CS 128 transformation offers several transferable principles for institutions grappling with similar challenges in introductory computer science education. These insights extend beyond specific pedagogical techniques to address fundamental questions about curriculum design, resource allocation, and educational equity in computer science.
Rethinking Prerequisites as Equity Interventions
The most significant lesson from CS 128 concerns how prerequisite structures can inadvertently create or eliminate educational inequities. Traditional approaches to resource-constrained environments often restrict access to “value-added” courses to the students deemed most likely to succeed—typically those already possessing academic advantages. CS 128 demonstrates that inverting this logic can produce better outcomes for all students while advancing equity goals.
When courses are designed for universal access from the outset, they necessarily incorporate support structures and pedagogical approaches that benefit every learner. The scaffolding, practice opportunities, and feedback mechanisms that help underprepared students succeed simultaneously enhance the learning experience for well-prepared students. This challenges the common assumption that equity initiatives require trading off educational quality or rigor.
The Infrastructure-Pedagogy Symbiosis
CS 128’s technical infrastructure illustrates how educational technology can amplify pedagogical principles rather than merely digitizing traditional instruction. The browser-based programming environment, containerized development setup, and integrated assessment system weren’t created to replace human instruction but to enable more frequent, focused, and personalized learning interactions.
This symbiosis between infrastructure and pedagogy offers a blueprint for educational technology investments. Rather than pursuing technology for its own sake, institutions should identify pedagogical goals first, then develop or acquire technologies that make those goals achievable at scale. The most effective educational technologies remove barriers to learning rather than adding new layers of complexity.
Assessment in the Age of AI
CS 128’s evolution of assessment practices provides early insights into how computer science education must adapt to the widespread availability of AI coding assistants. The shift toward proctored assessments, Parsons problems, and explanation-based questions represents one approach to ensuring authentic learning in an AI-augmented world.
More broadly, this challenge forces reconsideration of what computer science students truly need to learn. If AI can generate syntactically correct code, then programming education must emphasize problem decomposition, algorithm selection, debugging skills, and the ability to evaluate and modify existing code. CS 128’s emphasis on understanding program behavior rather than merely producing correct output positions students for this AI-integrated future.
Institutional Change Through Data
Perhaps most importantly, CS 128 demonstrates how systematic data collection can drive institutional change that individual advocacy cannot achieve. When equity arguments are supported by robust longitudinal data showing differential outcomes across student populations, they become impossible to ignore or dismiss.
The course’s detailed tracking of performance patterns across demographic groups, prerequisite pathways, and semester timelines provides the evidence necessary to secure institutional support for equity initiatives. This data-driven approach to educational improvement offers a model for other institutions seeking to document and address educational inequities in computer science.
Looking Forward
The next phase of CS 128’s evolution will address several emerging challenges and opportunities in computer science education. Three areas warrant particular attention: developing more sophisticated interventions for struggling student populations, adapting pedagogy for AI-integrated programming workflows, and extending the universal access model.
Targeted Interventions and Early Warning Systems
Our longitudinal data collection has identified clear patterns in student struggles, but translating these insights into effective interventions remains a work in progress. The consistent performance gaps among transfer students, the concentration of drops in Week 7, and the bimodal pattern of high-achieving students leaving alongside struggling students all point to opportunities for more nuanced support systems.
Future development will focus on early warning systems that can identify at-risk students before they reach crisis points. Rather than waiting for students to seek help, we’re exploring proactive outreach based on engagement patterns, submission behaviors, and performance trends. The goal is to provide targeted resources—whether additional office hours, peer tutoring, or modified assignment sequences—before students become overwhelmed.
Pedagogical Adaptation for AI Integration
The rapid advancement of AI coding assistants fundamentally challenges traditional programming education. CS 128 must evolve beyond simply detecting AI use toward preparing students to work effectively with AI tools while developing authentic programming competence.
This evolution will likely involve restructuring assignments to emphasize skills that remain distinctly human: problem decomposition, algorithm evaluation, debugging complex systems, and making architectural decisions. Rather than prohibiting AI tools, future iterations may incorporate them explicitly, teaching students when and how to use AI assistance while maintaining the critical thinking skills that distinguish competent programmers from prompt engineers.
The shift will also require new assessment methods that can evaluate student understanding in AI-augmented environments. This may involve more sophisticated Parsons problems, real-time debugging challenges, and assessments that require students to critique and improve AI-generated code.
Research and Dissemination
The CS 128 model generates research questions that extend beyond our specific implementation. How do universal access principles apply to different institutional contexts? What are the long-term effects on student persistence and performance in subsequent courses? How do different demographic groups respond to various pedagogical interventions?
Ongoing collaboration with education researchers will help formalize these insights and develop replicable frameworks for other institutions. The goal is to transform CS 128 from a local success story into a catalyst for broader curricular reform in computer science education.
Building Sustainable Innovation
Perhaps most importantly, future development must ensure that innovation remains sustainable and institutionally embedded. The CS 128 model depends on continued institutional support, dedicated staff, and ongoing technical infrastructure development. As the course matures, establishing sustainable funding models, training pathways for new instructors, and governance structures for continued evolution becomes increasingly critical.
The ultimate measure of CS 128’s success will be its ability to inspire and support similar transformations at other institutions, creating a network of equity-focused computer science programs that collectively advance the democratization of computational education. This vision extends far beyond any single course or institution toward a fundamental reimagining of how computer science education can serve all students in an increasingly computational world.
For current course information, visit cs128.org