Easiest courses in Computer Sciences

Reviewers describe the class as having a heavy workload with significant reading and difficult exams, though one notes the instructor curves grades to historical averages.[1, 2]

Historical reviews of Earlence Fernandes, Rahul Chatterjee: Workload varies by instructor, with some describing simple, fun homework and others citing unnecessarily hard coding assignments. Exams are often open-book, but one review warns that OS security topics can be extremely difficult and heavily weighted.[1, 2, +3]

Historical reviews of Matthew Sinclair, Mikko Lipasti, Parmesh Ramanathan: Reviewers characterize the workload as intense, citing long group projects, dense online lectures, and difficult exams that require significant outside effort and preparation.[1, 2, 3]

Exams are described as impossible or very difficult with low averages, while homework is considered useful and constitutes the majority of the grade.[1, 2, 3]

The workload is high, but assignments are useful and interesting, with extensions and extra credit available to lighten the burden.[1]

Reviewers describe the workload as excessive, with heavy weekly homework and four exams. The course is considered difficult, featuring hard proofs and exams that are hard to finish.[1, 2, 3]

Historical reviews of Paul Barford, Suman Banerjee: Workload includes multiple quizzes and programming assignments, with some reviewers noting a lighter load while others emphasize the need for extensive textbook reading and careful note-taking.[1, 2, 3]

The course relies on an online textbook, with some reviewers finding lectures and labs unhelpful. Workload includes homework due Monday through Thursday and weekly Friday quizzes, which some find annoying but manageable due to open-book formats.[1, 2, +2]

Assignments are graded harshly, and the course is notoriously difficult, requiring significant preparation to keep up with the rigorous material.[1, 2]

Students report the course is time-consuming with confusing exams, unfair quiz conditions, and projects that are overly difficult compared to lecture content.[1, 2, +2]

Exams are frequently described as tough, lengthy, or unfair, with some noting a lack of partial credit. Projects vary, but the overall workload is considered fairly light due to few coding assignments.[1, 2, +3]

Weekly projects constitute nearly half the grade and require significant time investment, while exams are multiple-choice and carry less weight.[1, 2, 3]

Historical reviews of Michael Gleicher, Perry Kivolowitz: Projects require substantial time, often 30 to 50 hours, and the material is challenging, particularly for those lacking prior C++ or OpenGL experience.[1, 2, 3]

Sinclair enforces strict deadlines and requires diligent self-study. Wadle’s lectures are criticized as unhelpful or confusing, requiring heavy independent work.[1, 2, +8]

Historical reviews of Louis Oliphant, Michael Swift: Projects require significant time investment, and exams are considered difficult. Students must infer answers not explicitly covered in lectures, requiring independent problem-solving skills.[1, 2, 3]

Historical reviews of Kangwook Lee, Pedro Morgado, Yu Hen Hu: The course is consistently described as difficult with a heavy workload, including extensive homework, group projects, and dense theoretical content requiring strong math backgrounds.[1, 2, +2]

The course features weekly long programming assignments or cumulative tests, with one reviewer noting that exams can be tough and require office hour support.[1, 2]

Historical reviews of Colin Dewey: The course features weekly Jupyter notebooks and homework that require significant time investment. Reviews indicate the work is hard but prepares students well for exams, with many assignments providing substantial code scaffolding.[1, 2, +5]

Homework is challenging and time-consuming, but attending discussion sessions and collaborating with groups makes the class much easier to manage.[1, 2]

Workload varies significantly based on group partners, with projects ranging from minimal to excessive time commitments, while exams are generally considered manageable.[1, 2]

The course is extremely difficult with long, challenging homework assignments that can take up to 20 hours, requiring substantial independent study time.[1, 2, 3]

Reviewers describe the workload as manageable with relative homework, but note a large volume of material and a tough class environment requiring strong math preparation.[1, 2, 3]

The course includes five graded homeworks, two midterms, and a final. While some find exams manageable with lecture notes, others report they are unexpectedly difficult or narrowly focused.[1, 2, 3]

The course involves six cumulative programming projects, each requiring approximately 20 hours, which some students find tedious, vague, or overly complicated.[1, 2]

The course is dense and challenging. Homework is feasible but requires reading the textbook, as lectures may not fully explain concepts. Exams often draw directly from the book and previous tests.[1, 2, +8]

Reviewers describe the course as difficult, citing tough exams, lengthy proofs, and time-consuming homework as the main challenges.[1, 2, +4]

Historical reviews of Justin Hsu, Kaiser Pister: Programming projects are reported as difficult and time-intensive under Justin Hsu, while Kaiser Pister's homework is criticized as unstructured and tightly scheduled.[1, 2, 3]

Projects are lengthy and require early starts, while bi-weekly quizzes and dense course materials add to the workload and preparation demands.[1, 2, 3]

The course is considered very difficult, with hard assignments that require significant study time, though group work is permitted. Exams are reported as easier than homework, although one student found the final exam unexpectedly difficult despite its stated format.[1, 2, +2]

Reviewers describe the workload as heavy, with time-consuming homework and brutal exams. The course requires deep knowledge of in-depth proofs, making it challenging for non-elite math majors.[1]