Echa Pa’Lante, CS50 2019

David J. Malan

7 min readAug 25, 2019

CS50’s team began this summer, as we have past, with Summer50, a week-long retreat a few hours from Harvard during which we plan for the coming year, bond, and even compete in a Gordon Ramsay-inspired cooking competition. (The red team won this year.)

Summer50 2019

To guide each summer and, in turn, year, we decree a theme of sorts. That for this year is echa pa’lante, which perhaps translates best, from Spanish, as “move forward.” Indeed, just as CS50’s own demographics change, not to mention the world around us, so must the course itself evolve. I was surprised, in fact, when a colleague, some years ago now, asked why I kept tinkering with the course. I suppose it wasn’t, and still isn’t, yet finished!


In preparation for the coming year, I started reflecting this past spring on what the course’s overarching objectives have been and should be. Although they’ve long been in my head in some form, I’m not sure I’d ever actually written them down, at least in one place. You’d think, after twelve years, they’d be in the syllabus. Well they now are! Undoubtedly, like everything, a work in progress. But at the moment, among the educational objectives of CS50 are to

  • inspire students to explore unfamiliar waters, without fear of failure;
  • create an intensive, shared experience, accessible to all students; and
  • build community among students.

Among the course’s learning objectives for students are that they learn to

  1. think more methodically;
  2. program procedurally;
  3. represent and process information;
  4. communicate succinctly and precisely;
  5. solve problems efficiently;
  6. recognize patterns among problems;
  7. decompose problems into parts and compose solutions thereto;
  8. operate at multiple levels of abstraction;
  9. separate design from implementation details;
  10. infer from first principles how systems work;
  11. assess the correctness, design, and style of code;
  12. teach themselves new languages;
  13. identify threats to privacy and security;
  14. read documentation, drawing conclusions from specifications;
  15. test solutions to problems, find faults, and identify corner cases;
  16. describe symptoms of problems precisely and ask questions clearly; and
  17. identify and quantify tradeoffs among resources, particularly time and space.

I daresay most everything else in the syllabus is but an implementation detail!

Perhaps the most important objective, though, is that students ultimately learn something that we didn’t teach them, as is so often manifest at the end-of-term CS50 Fair at which students present their final projects.

CS50 Fair 2018

Beyond codifying what the course has long taught, though, this summer was an opportunity to rethink how the course teaches it. Indeed, we (metaphorically) took the course apart, discarded some parts, upgraded others, and ultimately built what shall be Fall 2019.

Coming Fall 2019

At least one of us may have also watched (all of) The Crown.


In the spirit of moving forward, here’s what’s new for Fall 2019 of CS50 at Harvard University.


Lectures will now be on Mondays, 3pm–5pm, still in Sanders Theatre. (And still open to the public.) Students will be expected to attend (only) the course’s first eight lectures in person, unless simultaneously enrolled in another course that meets at the same time, in which case, as always, they can watch online.

Previously were lectures on Friday mornings. Not only was that timing less than popular among sleepy students (and perhaps one instructor), it also proved structurally suboptimal, since sections could not be scheduled (realistically) until Sunday or Monday, thereby costing the course at least one potential support day. Better to allocate that weekend, we decided, at the end of a 7-day cycle so that students could use it to work on a week’s problem set after having had opportunities for lecture and section (and optionally office hours).


Each lecture will now be followed immediately by (dinner and then) supersection, 7:30pm–8:45pm, an optional opportunity for students to review the day’s lecture and ask additional questions. Led by CS50’s own Brian Yu ’19, those supersections will be Zoom-based so that students can tune in from their room (or anywhere else that a webcam and microphone allow). Students with conflicts will be able to watch recordings thereafter.

Recordings of supersections will be included in CS50x 2020. (And we might host some live ones as well throughout the year!)


To help students prepare for each week’s section, each lecture (and supersection) will be followed by a short, open-book, take-home quiz, due before section. Each quiz will ask students not to regurgitate material but to apply concepts from the week’s lecture to problems not yet encountered, the aim not so much to assess but to teach further, much like (longer) quizzes past.


TF-led sections will now be on Tuesdays and Wednesdays. By design will most every section now be hands-on, with students solving programming problems together, in preparation for the week’s problem set.


For additional help with problem sets, students will now be able to sign up, optionally, for one or more tutorials per week, Wednesdays through Saturdays. An amalgam of tutoring and office hours, tutorials will be led by the course’s TFs and CAs, with an approximate student:staff ratio of just 5:1.

Office Hours

An additional opportunity for one-on-one help with each problem set, course-wide office hours will now be held on Sundays, 3pm–5pm, in Widener Library, with the course’s entire staff on duty at once.

Problem Sets

Problem sets will now be due on Sundays at 11:59pm (so that students have ample time to sleep before Mondays’ 3pm lectures!). They will be scored along axes of correctness and style but no longer design. In years past would TFs spend upwards of 20 minutes per student providing written comments on code only for (too many) students to spend seconds, if any, reviewing the same. That time will now be reallocated, more optimally we hope, toward tutorials and (interactive) code reviews. The loss of signal in grading, too, seems insignificant: in anticipation of this change, we analyzed all of Fall 2018’s scores, running the numbers both with and without design factored in, and the impact was negligible.

Thanks to CS50’s own Brian Yu ’19 will the problem sets themselves be new and improved. Among this fall’s experiences will be:

  • A problem set on text readability, for which students write code that assesses the reading level of paragraphs of text. For instance, according to the Coleman-Liau index, J.K. Rowling’s Harry Potter is appropriate for a 5th- or 6th-grade reading level. (And PhD students, according to when I read them.)
  • A problem set on electoral algorithms, for which students write code that tabulates votes and decides simulated elections.
  • A problem set on Instagram-style filters, for which students write code that implements grayscale, sepia tones, reflections, and/or blurs.
  • A problem set on genetics, for which students write code that determines, CSI-style, whodunit based on DNA evidence.

All of these problem sets (and more) will be included in CS50x 2020.

Code Reviews

Students will now have weekly opportunities to sign up for reviews of their code, interactive discussions with TFs and CAs and small numbers of classmates. These code reviews will be Zoom-based so that students and staff can arrange for short sessions without any commutes.


The course’s first eight weeks will now culminate in an open-book, take-home test, similar in spirit to the (much shorter) weekly quizzes but designed to have students identify and synthesize themes across weeks.


Perhaps the most significant change for Fall 2019 is that the course will fork off in its final two weeks into multiple tracks, each with its own lectures and problem sets:

  • web programming with HTML, CSS, and JavaScript (plus Python and SQL), led by CS50’s own Brian Yu ’19
  • mobile app development for iOS with Swift or Android with Java, led by CS50’s own Tommy MacWilliam ’13, and
  • game development with Lua, led by CS50’s own Colton Ogden.

After the course’s eighth lecture, all students will watch their choice of lectures online (so that all three tracks can happen in parallel) and submit their own track’s problem sets. We suspect (but will not require) that most students will select a track that leads to their final project, thereby preparing them all the more for success than Thanksgiving break and the week of the CS50 Hackathon traditionally allow.

All three tracks will be included, along with CS50 AP, in CS50x 2020.


Of course, it wouldn’t be a new year without new-and-improved software as well. Thanks to CS50’s own Brian Yu ’19, Chad Sharp, Jelle van Assema, Kareem Zidane, and Rodrigo Daboin Sanchez ’20,

  • CS50 IDE has been rebuilt atop Kubernetes on Amazon AWS;
  • help50 has been re-written to make it easier for others to contribute helpers;
  • has been replaced with, which instead shows students raw manual pages but hides sections unlikely to be of interest and adds tooltips to explain syntax;
  • check50 and submit50 have been re-written to make it easier for others to write checks and install the tools locally;
  • has been re-written to be simpler and read-only, with students’ submissions now accessible at;
  • compare50 has been improved and documented to make it easier for us and others to compare submissions for similarities; and
  • CS50’s website has been re-implemented with CS50’s own Jekyll plugin.

All this, then, and more. Experience CS50 2019.




Harvard University’s introduction to the intellectual enterprises of computer science and the art of programming.