Coding homework has been part of university computer science for over 70 years. The first programming exercises assigned to students were written by hand on paper at Cambridge University in the early 1950s. Today, students at the same university and thousands of others get their code graded by AI-assisted platforms in seconds. The format has changed beyond recognition.
The basic idea, that students learn to program by doing it themselves, has not.This is the story of how coding homework became what it is today. The dates and people behind it are real and verifiable. The shifts that mattered most for students happened at predictable points in the timeline, and each one changed what a coding assignment looks like.
Where Coding Homework Actually Started: Cambridge, 1951
The first known programming exercises assigned as homework were written by Maurice Wilkes, David Wheeler, and Stanley Gill at the University of Cambridge in the early 1950s. The three of them had built EDSAC, one of the first practical stored-program computers in the world, and they needed a way to teach students how to use it.
In 1951, Wilkes, Wheeler, and Gill published The Preparation of Programs for an Electronic Digital Computer. It was the first textbook on computer programming ever published. The book was based on a private 1950 internal report from the Cambridge Mathematical Laboratory and was put out by Addison-Wesley in Cambridge, Massachusetts. Students at Cambridge used it as the basis for their first programming coursework.
What Coding Homework Looked Like in 1951
Coding homework in 1951 looked nothing like the modern version. Students wrote their programs by hand on paper. The handwritten code was then keyed onto punched paper tape by trained operators. The tape was loaded into EDSAC, which ran the program in batch mode. If something failed, the student waited for the next available run slot, sometimes a full day later, then debugged on paper and tried again.
A typical first assignment was to compute a small numerical result using the EDSAC subroutine library, which by 1951 had grown to 87 reusable subroutines covering basic arithmetic, trigonometry, matrix operations, and printing. Students had to plan their entire program before submission because there was no live editing and no instant feedback. The discipline this forced is the reason early CS graduates were known for writing such careful code.
How Coding Became Its Own Subject: 1962 to 1968
Through the 1950s, programming was taught inside math and engineering departments, not as a subject of its own. That changed in 1962, when Purdue University established the first dedicated Department of Computer Science in the United States. The department was approved by the Purdue Board of Trustees on October 24, 1962, with Samuel D. Conte as the founding head and an initial class of 24 master’s and doctoral students.
Stanford and Carnegie Mellon followed soon after, both founding their CS departments in 1965. Once these departments existed, coding stopped being a side activity inside a math course and became a graded subject in its own right. Programming exercises started appearing in course gradebooks as separate components, with their own deadlines and weight in the final mark.
The 1968 ACM Curriculum That Standardized Coding Homework
In March 1968, the Association for Computing Machinery published Curriculum 68: Recommendations for Academic Programs in Computer Science. The document was the first formal CS curriculum recommendation for US universities. It described 22 courses across the new field, listed prerequisites, and gave detailed outlines for each.
Curriculum 68 explicitly required programming exercises as part of CS coursework. From this point forward, every major US university built its computer science program around the ACM template, which meant coding homework was now a required component of every CS degree. The 1978 update, Curriculum 78, refined the structure further. By the end of the 1970s, programming exercises were as standard a part of a CS degree as written assignments were of an English degree.
How the Problem Set Format Was Invented
Through the 1970s, coding homework was usually a single program assigned weekly. The format started shifting in the early 1980s at universities like Carnegie Mellon and MIT, where instructors began adopting a different structure borrowed from physics and math courses: the problem set.
A problem set contained 4 to 6 separate programming questions of escalating difficulty, packaged into a single deliverable. The first question was usually short and tested a basic concept. The last was longer and asked the student to combine multiple concepts. This structure rewarded students who knew how to break a complex topic into smaller pieces, which is the actual skill professional programmers use every day.
The problem set format spread through the 1980s and 1990s and became the dominant homework structure across major US programs. Today, courses like MIT 6.0001, Harvard CS50, and Stanford CS106A all use it. A student picking up a CS50 problem set in 2026 is using a format that took shape in CS classrooms in the early 1980s.
How Personal Computers Changed Coding Homework Forever
Before the mid-1980s, coding homework was done in computer labs on shared mainframes or minicomputers. Students had to book time slots, sometimes overnight, to get a chance to compile and run their code. The hardware was limited, so assignments stayed small.
The IBM PC arrived in 1981. The Apple Macintosh followed in 1984. By the late 1980s, personal computers were affordable on most US campuses and increasingly common in dorm rooms. The change for coding homework was massive. Students now compiled and ran code at any hour without waiting for a lab booking. That single shift changed what professors expected.
Assignments Got Longer Because the Hardware Stopped Being the Bottleneck
Once students had their own machines, professors started assigning bigger projects. A coding assignment in 1975 was typically a 30-line program that ran on the campus mainframe. A coding assignment in 1995 was a 300-line program with multiple files, possibly using a windowing library or a database. The difficulty did not just rise: the entire scope of what coding homework covered expanded.
This is the era when modern coding homework took its current shape. Multi-file programs. Independent debugging. Student-owned development environments. Professors expecting students to manage their own dependencies and toolchains. All of it happened because the lab booking sheet stopped being a limiting factor in the late 1980s.
The Autograder Revolution: 1995 to Today
The single biggest change to coding homework in the past 30 years was the rise of automated grading. Before automated grading systems existed, coding homework was graded by hand. A teaching assistant printed a student’s code, ran it on a few test inputs, and assigned partial credit by reading through the logic. This took an enormous amount of time, which is why class sizes in CS were limited and why coding homework deadlines had long grading windows.
The First Autograders Were Built at Universities, Not Companies
The first widely used automated grading systems for coding homework were built inside universities. ASSYST, developed at the University of Liverpool in the United Kingdom by David Jackson and Michelle Usher, was published in 1997 at the SIGCSE Technical Symposium and is one of the most cited early automated assessment tools. Other early systems like BOSS at the University of Warwick and CourseMarker at the University of Nottingham followed in the late 1990s. Web-CAT, developed at Virginia Tech by Stephen Edwards in the early 2000s, added support for testing rubrics, not just output checking. Each of these systems was built by professors who had run out of time grading homework by hand and needed something better.
These early autograders did one thing well: they checked whether a student’s code produced the correct output for a given input. They did not check code style, design choices, or whether the student had used the techniques taught in class. Those parts still required a human grader. But for raw correctness, the autograder did the work of 10 TAs in a single batch run.
Gradescope and the AI-Assisted Grading Era
Gradescope was founded in 2014 at UC Berkeley by Arjun Singh, Sergey Karayev, Pieter Abbeel, and Ibrahim Awwal. The four of them had been teaching assistants for large CS classes at Berkeley and built the first version, originally called Pandagrader, to handle their own grading workload. The tool grouped similar student answers together so a TA graded many submissions in one pass instead of one at a time.
Gradescope was acquired by Turnitin in October 2018. By 2020, it was used by over 25,000 educators worldwide. By 2025, the platform had grown to over 140,000 instructors at more than 2,600 institutions, serving 3.2 million students. The grading approach was no longer one TA reading one submission. It was a system that processed thousands of code submissions per hour and routed the unusual ones to human graders.
By the late 1990s and into the 2000s, autograders had grown into a standard part of CS coursework, and many of the rules that students get judged on today were locked in during this period. The same details that mattered then still matter now. Autograder-Safe Code: A Simple Checklist for Students covers the technical pitfalls that the modern autograder catches, most of which trace directly back to design choices made in the late 1990s and 2000s.
How Online Courses and the Pandemic Reshaped Coding Homework
Two events in the past 15 years pushed coding homework into the form it takes today. The first was the rise of massive open online courses, or MOOCs. The second was the pandemic in 2020.
The Stanford AI Course That Changed Online Coding Homework
In the fall of 2011, Stanford ran an online version of CS221, its introductory artificial intelligence course, taught by Sebastian Thrun and Peter Norvig. The course was offered free and open to the public. Over 160,000 people enrolled. It was the first time a single coding course had reached that scale.
The course needed an autograder built for 160,000 student submissions, and the team built one. The infrastructure they built later spun out as Udacity, one of the major online learning platforms, and the homework patterns they invented (small, frequent, autograded, with immediate feedback) became the template for online CS courses everywhere. Most modern coding homework, even at traditional universities, uses these patterns now.
The Pandemic Pushed Every CS Course Online
Between March 2020 and September 2021, in-person computer labs at most US universities were closed for safety reasons. CS courses had to operate fully online, which meant every coding assignment had to be submitted, graded, and returned without anyone walking into a physical classroom. The platforms that supported this work, especially Gradescope, GitHub Classroom, and Canvas, saw their user numbers grow several times over in a span of months.
The pandemic ended, but most of the changes did not. Universities kept the autograding tools and the online submission workflows because they were genuinely faster and more consistent than the older paper-based methods. Today, automated grading is the default approach for introductory CS courses at most major US universities, and tools like Gradescope, GitHub Classroom, and Canvas have become standard infrastructure for how coding homework is delivered, submitted, and graded.
The Coding Homework Timeline at a Glance
The full sweep of coding homework history compresses into nine moments that mattered. Each one changed what a student saw when they sat down to start an assignment.
| Year | Milestone | Why it mattered for students |
| 1951 | First programming textbook published at Cambridge | Programming becomes something universities formally teach, not just a research activity |
| 1962 | Purdue founds the first US Computer Science department | Coding becomes a graded subject of its own, separate from math or engineering |
| 1968 | ACM publishes Curriculum 68 | Programming exercises become a standard course requirement across US universities |
| 1980s | Personal computers reach campuses | Coding homework moves from booked lab time to dorm rooms, getting longer and more complex |
| 1997 | ASSYST autograder published at SIGCSE | Output gets checked by software, raising the bar on correctness |
| 2011 | Stanford CS221 reaches 160,000 online students | Autograder-based homework patterns scale to massive enrollment |
| 2014 | Gradescope launches at UC Berkeley | AI-assisted grading enters mainstream university CS courses |
| 2020 | Pandemic accelerates remote autograding adoption | Most introductory CS courses now use automated grading by default |
Why This History Matters for Students Today
Coding homework as a format is the result of 70 years of decisions made by professors, university committees, and software developers. The reason a problem set has 5 questions of increasing difficulty is because Carnegie Mellon and similar programs adopted that format from physics and math in the early 1980s. The reason the autograder rejects code with a missing newline is because output diffing was the cheapest correctness check the first systems in the late 1990s ran. The reason CS50 looks the way it does is because Curriculum 68 told universities to build coding into core CS coursework.
None of this is random. The format on the screen tonight has a real history, and most of the rules that feel arbitrary to a student became rules for specific reasons that made sense at the time. Knowing the history makes the homework less mysterious. It also makes one thing clear: every generation of CS students has had to adapt to the tools and formats of their era. The students of 1955 wrote code on paper for batch jobs. The students of 1985 booked lab slots. The students of 2026 work with autograders that compare their submission against hidden test cases in milliseconds.
Each generation has thought their version was the hardest. Each generation has been right and wrong at the same time. The hard part has changed, but the underlying skill has not. Programming gets learned by writing programs and running into things that do not work, then fixing them. The history of coding homework is really the history of universities figuring out how to give students that experience at scale.
The story of coding homework is, in the end, the story of how computer science learned to teach itself. Students who want personalized one-on-one coding homework help can find expert support at MyCodingPal. The history is interesting on its own, and knowing it makes the homework on your screen tonight feel a little less random.
Frequently Asked Questions
When was the first coding homework assigned in a university?
The first coding homework on record was assigned to students at the University of Cambridge in the early 1950s, working with the EDSAC computer. The 1951 textbook by Maurice Wilkes, David Wheeler, and Stanley Gill, titled The Preparation of Programs for an Electronic Digital Computer, was the basis for those early assignments. It was the first programming textbook ever published.
When did computer science become a separate university subject?
Purdue University founded the first standalone Computer Science department in the United States on October 24, 1962. Stanford and Carnegie Mellon followed in 1965. Before this, programming was taught inside math, engineering, or electrical engineering departments. The creation of these dedicated departments is what made coding homework a graded subject in its own right.
When did autograders become common in CS courses?
Autograders started appearing in the mid to late 1990s. ASSYST, developed at the University of Liverpool, was published at the SIGCSE conference in 1997. Other early systems like BOSS at Warwick and CourseMarker at Nottingham followed soon after. The big shift to AI-assisted grading happened in 2014 when Gradescope was founded at UC Berkeley. Today, automated grading is the standard approach in most introductory CS courses at major US universities.
Has coding homework always been done on computers?
No, the first coding homework was written by hand on paper. Students at Cambridge in the 1950s wrote their programs out, handed them to operators who keyed the code onto punched paper tape, and waited for batch runs on EDSAC. This stayed common into the 1960s and 1970s. Coding homework only fully moved to live, on-screen development after personal computers became affordable on campus in the late 1980s.
Why do CS courses use problem sets instead of single assignments?
The problem set format, with 4 to 6 questions of increasing difficulty packaged together, was adopted in CS courses in the early 1980s. Universities like Carnegie Mellon and MIT were among the early adopters, borrowing the format from physics and math courses. The reason it stuck is that it teaches students to break a hard topic into smaller, sequential steps, which is the exact skill professional programmers use to build real systems.