That’s a wrap on CS50x Puzzle Day 2025! This year, over 12,000 participants from 166 countries joined us for what one past participant perfectly described as “a great way to scratch your brain”! We’re thrilled by the turnout and can’t wait to celebrate some of the highlights—stories, stats, snapshots, and more—from this global adventure.

This year was a special one — we celebrated our tenth CS50x Puzzle Day! The event first started in 2016 as an extension of our on-campus Puzzle Day at Harvard (and Yale!) and, since then, it has become a worldwide tradition. Despite the name, Puzzle “Day” actually lasts all weekend — and a bit more, allowing plenty of time for friends, family, and colleagues to take on the “wonderful event that turns your brain inside out!”. We indeed spread it over a weekend that starts when the first time zone on Earth enters Friday and when the last time zone on Earth exits Monday. Just a few days ago, at precisely 00:00:00 on Friday, April 4, this year’s registrants received their puzzle packet— crafted by CS50’s brilliant alumni and friends at Meta: Laura Trutoiu, Zach Zagorski, Cameron Bates, Amy Qiu, Ryan Liu, Helen Chen, Kai Yuan Chi, and Jacqui Fashimpaur.

Results

This year, an impressive number of 12,707 participants registered for CS50x Puzzle Day 2025! We were especially excited to welcome 9,346 first-time participants, another 1,231 people returned for their second round, 451 participants came back for a third, and 587 puzzlers joined us for the fourth time or more. And a huge shoutout to a truly legendary group of 36 individuals who shared that they’ve taken part in every single CS50x Puzzle Day to date!

Among the registrants were

• 2,070 registrants from Pakistan
• 1,864 registrants from the United States
• 1,855 registrants from India
• 1,202 registrants from Iran
• 419 registrants from the United Kingdom
• 330 registrants from Canada
• 277 registrants from Brazil
• 200 registrants from Germany
• 191 registrants from Bangladesh
• 172 registrants from Ukraine

and so many others from other countries around the globe!

Here’s a quick glance of how all the team scores this year. Each team that provided correct answers to a majority (at least five) of the nine puzzles will be awarded a CS50x Puzzle Day 2025 certificate — if you’re among these teams, keep an eye out for an email from the CS50 Bot in the coming days! (Email puzzles@cs50.harvard.edu if it doesn’t seem to arrive, but do check your spam folder first!)

Our submission form tracked submissions from 2,269 teams and individuals (give or take!), and even more may have participated without ultimately submitting the solution form. Here’s a breakdown of how many teams scored correct answers on each puzzle:

Overall, 1,250 teams correctly found the solutions to all puzzles, including the meta puzzle itself. 1,980 teams correctly solved at least one puzzle!

We also invited teams to share their thoughts on the puzzles — and as you’ll see below, Bomb Squad emerged as the crowd favorite.

When it came to the easiest puzzle, though, one stood out above the rest — Around the World was the runaway winner!

And similarly clear winner for the hardest puzzle was Ticket to Ride.

Solutions

And here are the solutions themselves! Note that we accepted multiple solutions for some of the puzzles.

• Ticket to Ride accepted TRANSACT.
• Bomb Squad accepted OFFWHITE.
• Tangrams accepted CHILIDOG.
• Wavelength accepted INFRARED.
• The Blind Maze accepted CEREBRAL.
• Powers of Two accepted DISCOVER.
• Around the World accepted ISTANBUL.
• Banananagrams accepted EGGPLANT.
• Codenames accepted LOSTINPAIROFDICE and PARADISE and LOSTINPARADISE.

Not sure how to get to those answers? Check out the step-by-step walkthrough of puzzles below:

Memes

Now a CS50x Puzzle Day tradition, memes expressed both frustration and joy.

Participants’ Reflections

Considering joining us next year? Here’s what a few participants had to say:

• “A perfect blend of logic, creativity, childishness, and a dash of crazy.”
• “Chomp! Chomp! Chomp! Your brain needs to eat… so feed it!”
• “Unbelievably difficult yet extraordinarily satisfying.”
• “Do it!! The mental gymnastics and gyrations are absolutely worth it!!”
• “Come for the puzzles, stay for the friends and fun.”
• “Enjoy the games, and if you get stuck, try to find another way to solve the puzzles. Sometimes, the answer is easier than it seems.”
• “Had a great time teaming up with awesome people from different places — solving puzzles, laughing at dead-ends, and celebrating every breakthrough!”

Now to conclude, thank you to everyone around the world who took photos (and screenshots) of their teams solving puzzles!

Photos

Per the Harvard College Student Handbook, students at Harvard “must complete four General Education courses, one from each of the following four General Education categories: Aesthetics & Culture; Ethics & Civics; Histories, Societies, Individuals; and Science & Technology in Society. Three of these courses must be letter-graded. One may be taken pass/fail, with the permission of the instructor.”

On Tuesday, the Faculty of Arts and Sciences met and voted to amend that language as follows: “Beginning with the Class of 2029, all four courses must be letter-graded.” The faculty additionally voted that the Quantitative Reasoning with Data (QRD) requirement, which CS50 has long satisfied, even if taken SAT/UNS, now also “must be completed with a letter grade.” My remarks at Tuesday’s meeting, in opposition, below.

My sense is that this proposal and the next will sail through, but I’d like to offer some remarks on why they should not. In 2016, I happened to be on Faculty Council when it was decided to allow students to take one of their Gen Ed courses Pass/Fail or SAT/UNS. The overarching motivation then, and since, has been to empower students to explore academic areas beyond their own comfort zone, without fear of “failure,” whether failure means, literally, an E or, as many students might think, a B. It is meant to encourage them to explore unfamiliar waters, without a sense of “competition” from classmates with prior experience. And it works, if implemented well.

Indeed, in 2021, CS50 itself published a peer-reviewed study that examined a decade’s worth of the course’s experience with Pass/Fail and, in turn, SAT/UNS. For those unfamiliar, Pass/Fail is a grading basis that students can elect with an instructor’s permission; a PA is a D- or higher. SAT/UNS, meanwhile, is generally a course-wide grading basis. Students don’t have to opt into it; it’s simply a norm. A Satisfactory grade (or SAT) is a C- or higher. Tutorials and first-year seminars tend to be graded SAT/UNS. CS50, too, is SAT/UNS by default, but we do allow students to opt out of it and into a letter grade if required by their concentration. CS, though, does not require such: we allow students to take their first concentration course SAT/UNS. But not all concentrations do. Indeed, voting yay on today’s proposals would only further drive students away from a system that can be made to work. And, daresay, toward courses in General Education that students find more familiar and less challenging. That said, I’m here today not to advocate for CS50 but against, in our student handbook, even more letter grades. But I’d like to share how, within CS50, we’ve made it work.

In 2010, when we began to encourage students to take CS50 without a letter grade, the number of students electing to do so jumped from 2% to 10%. In 2017, when we made SAT/UNS the course’s default, that number rose further to 30%. We found that more women than men favored that basis. Moreover, the percentage of women in the course itself rose that year to 44%, a 29-year high. Among students who took the course SAT/UNS, 19% subsequently reported that their concentration would be or might now be CS. And among all students that year, 66% described themselves as among those “less comfortable” with computing, a 10-year high. These are successful educational outcomes, for General Education courses like CS50 and beyond.

Contrary to what one might think, too, students who took the course SAT/UNS did not spend less time on the course. In fact, SAT/UNS students spent slightly more time on the course. And by term’s end, their performance was only 6pp lower than that of their letter-graded classmates. And that delta practically disappears when you consider that the SAT/UNS students had less prior experience coming in.

Key to all of this is a course’s policy on grades. In CS50’s case, “Whether taking the course SAT/UNS or for a letter grade, you must still meet all expectations in order to be eligible for a satisfactory grade.” And those expectations include attending or watching all lectures, attending all sections, solving all problem sets, and submitting a final project. Allowing a student to take a course SAT/UNS, then, does not mean having to lower a bar.

That said, I personally think the bar for Pass in a Pass/Fail course is too low: it is, by definition in our own handbook, “unsatisfactory.” The definition of SAT, meanwhile, is “adequate and satisfactory comprehension of the course material and the skills needed to work with the course material,” which is already our bar for concentration credit. And, empirically, SAT/UNS students, in our own experience, are performing well above that bar anyway.

I would propose, then, that we narrow the scope of today’s changes so that, “Beginning with the Class of 2029, all four courses must be letter-graded or taken SAT/UNSAT, when available.” That small change in wording would preserve for all of us a framework, via SAT/UNS, within which faculty could still, in fact, encourage students to explore unfamiliar waters without lowering bars.

And that concludes CS50x Puzzle Day 2024! This year’s event brought more than 10,000 of registrants from 164 counties together to participate in a “fun mental workout,” a quote from one of last year’s participants! We are excited to share what we learned from this year’s event and share with you some of the numbers, stories, photos, and more!

This year, we celebrated the ninth CS50x Puzzle Day! The tradition commenced in 2016, when we decided to make our on-campus CS50 Puzzle Day at Harvard (and Yale!) available to CS50x students around the world. In fact, CS50x Puzzle Day is not just a “day” but a long weekend and a bit of solving puzzles with friends, colleagues, and family. We indeed spread it over a weekend that starts when the first time zone on Earth enters Friday and when the last time zone on Earth exits Monday. That way, everyone has a weekend, as well as a couple weekdays, to embark on the “brain scratching joyride” at school, work, or home. And just about 5 days ago, at 00:00:00 on Friday, April 5, all the registrants were invited to download a packet of puzzles, written by CS50’s friends at Meta: Amy Qiu, Helen Chen, James Wu, Ryan Liu, Zach Zagorski, and more.

Results

This year, 11,013 people registered for CS50x Puzzle Day 2024. We were delighted to welcome 7,959 who had never participated in CS50x Puzzle Day, 1,227 who had participated once before, 652 who had participated twice, and 855 who had participated three or more times. (A few participants didn’t answer the question, so their data isn’t reflected here.) And of course a very special group of 41 who stated they had participated in every prior CS50x Puzzle Day!

Among the registrants were:

• 2,103 registrants from the United States
• 1,610 registrants from India
• 1,076 registrants from Iran
• 666 registrants from Pakistan
• 438 registrants from Canada
• 382 registrants from the United Kingdom
• 286 registrants from Ukraine
• 276 registrants from Singapore
• 270 registrants from Brazil
• 192 registrants from Australia

Here’s a quick glance at how all teams scored this year. Each team that provided correct answers to a majority (at least five) of the nine puzzles was awarded a CS50x Puzzle Day 2024 certificate — if you’re among these teams, keep an eye out for an email from the CS50 Bot in the coming days! (Email puzzles@cs50.harvard.edu if it doesn’t seem to arrive, but do check your spam folder first!)

Our Google Form tracked submissions from 1,815 teams and individuals (give or take!), and even more may have participated without ultimately submitting the solution form. Here’s a breakdown of how many teams scored correct answers on each puzzle:

Overall, about 435 teams correctly found the solutions to all puzzles, including the metapuzzle itself. 1,528 teams correctly solved at least one puzzle!

We also asked teams to characterize some of the puzzles; as you can see from the below, Books was deemed the favorite of the lot.

There was a similarly clear winner for the hardest puzzle, with MapGPT taking that award.

But an even clearer winner emerged for the easiest puzzle, with The Round of Music running away with it:

Solutions

And here are the solutions themselves! Note that we accepted multiple solutions for some of the puzzles.

• The Round of Music accepted MAYCOMB.
• Zoo Pals Mystery Dinner accepted both SNOWPIERCER and WOUNDS.
• Room Decor accepted both OPEN SHORTEST PATH FIRST and OSPF.
• Roleplay accepted SERRANO.
• Books will accepted both ORION and RIGEL.
• MapGPT accepted ODYSSEY.
• Connect Four accepted TITANIC.
• Cycleword accepted GEORGE ORWELL.
• A Haunting Conclusion accepted SPLIT THE RENT.

Not sure how to get to those answers? Check out the step-by-step walkthrough of puzzles below:

Memes

Now a CS50x Puzzle Day tradition, memes expressed both frustration and joy.

Participants’ Reflections

Considering joining us next year? Here’s what a few participants had to say:

• “I haven’t been so excited about something for a long time, it’s like a childlike joy!”
• “Your brains will melt, in the best possible way!!”
• “CS50x Puzzle Day was a terrific challenge. Frustrating at times, but when the answers came it was so satisfying. I loved it!”

Or, as one person put it more succinctly:

• “Just do it”

Now to conclude, thank you to everyone around the world who took photos (and screenshots) of their teams solving puzzles!

Photos

Quack. Ready Player 50 is a wrap! Ready Player 50 brought together participants from over 116 countries. Read on for our reflection (and a few fun photos and memes!) on the event, a collaboration with the AI security company Lakera and an adaptation of their famous prompt-injection game, Gandalf. If you participated this past weekend, we’ll share more secrets here than the CS50 Duck did!

As background, Ready Player 50 brought over 10,000 participants to https://gandalf.lakera.ai/cs50, where they competed to get the CS50 Duck to reveal its secret password through seven increasingly difficult levels. At each level, participants entered a “prompt” to the CS50 Duck (who is, in fact, a large language model, or LLM!) to try to bypass its various defenses and trick the duck into revealing its password. In all levels except level one, that is. In that level, you might recall, the CS50 Duck was defenseless!

Participation

Over 5,000 people registered for Ready Player 50 and over 10,000 participated at https://gandalf.lakera.ai/cs50. At the end of the event, approximately 3,100 players submitted their answers. Among the submissions were:

• 830 from the United States
• 471 from India
• 153 from the United Kingdom
• 138 from Canada
• 97 from Singapore
• 79 from Brazil
• 79 from Germany
• 65 from Pakistan
• 47 from Poland
• 46 from Iran

Results

Of the 3,139 participants who submitted their answers to us, 2,945 participants passed all 7 levels! That’s a whopping 94%. Happy to say, too, that 3,104 participants (or 99%) solved at least 2 levels! If you’re curious to see a walkthrough of some of the (many!) potential solutions, watch our solution walkthrough with Natalie and Max from Lakera.

Along the way we took a souvenir photo with those who attended live.

And special thanks to Sophie Anderson for the event’s artwork! Check out her artwork at Sophie’s storefront.

Feedback

Glad to say that, among those who submitted, 61% claimed to have “loved” Ready Player 50! Another 34% claimed to have liked it. The CS50 Duck would be proud.

We also asked participants about their favorite level, which turned out to be level 6 by a wide margin!

Conclusion

Want to try your hand at Ready Player 50? The fun lives on at https://gandalf.lakera.ai/cs50, so don’t be afraid to test your mettle against the CS50 Duck’s defenses! And for those who participated during the weekend event, conquering all 7 levels, CS50 Certificates were awarded, stamped by the CS50 Duck!

What’s next? Besides being ridiculously fun, Ready Player 50 was the perfect prelude to our newest course: “CS50’s Introduction to Cybersecurity”, available for free at https://cs50.harvard.edu/cybersecurity. If you liked Ready Player 50, you’re going to love diving deeper into the world of cybersecurity with us.

See the below for some photos and memes from participants!

Photos

Of particular note were the photos of players around the world coming together to player Ready Player 50!

Memes

The memes shed some light on the humorous side of cybersecurity!

That’s all for this year! This year’s event brought together thousands of registrants from 156 countries. We’re excited to reflect on all we’ve learned from this year’s event and to share some of the stories we’ve heard over the past few days.

This year, we celebrate the eighth CS50x Puzzle Day! The tradition commenced in 2016, when we decided to make our on-campus CS50 Puzzle Day at Harvard (and Yale!) available to CS50x students around the world. Calling CS50x Puzzle Day a “day” is something of a misnomer: we instead spread it over a weekend that starts when the first time zone on Earth enters Friday and when the last time zone on Earth exits Monday. That way, everyone has both a weekend, as well as a couple weekdays, to participate at home, school, or work. At 00:00:00 on Friday, March 31, 2023, students around the world were invited to download a packet of puzzles, written by our friends at Meta: Amy Qiu, Cameron Bates, James Wu, and Zach Zagorski:

We encouraged participants to form teams of 2–4, whether in-person or online. We were delighted to see teamwork alive and well in the world!

Participation

This year, 11,637 people registered for CS50x Puzzle Day 2023. We welcomed 7,627 who had never participated in CS50x Puzzle Day, 2,188 who had participated once before, 692 who had participated twice, and 828 who had participated three or more times. (A few participants didn’t answer the question, so their data isn’t reflected here.) A small group of 43 stated they had participated in every prior CS50x Puzzle Day!

Among the registrants were:

• 2,210 registrants from the United States;
• 2,027 registrants from India;
• 829 registrants from Iran;
• 489 registrants from Canada;
• 456 registrants from the United Kingdom;
• 405 registrants from Ukraine;
• 199 registrants from Germany;
• 185 registrants from Brazil;
• 137 registrants from Australia; and
• 119 registrants from Egypt.

Results

Here’s how all teams scored this year. Each team that provided correct answers to a majority (at least five) of the nine puzzles was awarded a CS50x Puzzle Day 2023 certificate — if you’re among these teams, keep an eye out for an email from the CS50 Bot in the upcoming days! Email puzzles@cs50.harvard.edu if it doesn’t seem to arrive, but do check your spam folder first!

Our Google Form tracked submissions from 1,627 teams and individuals (give or take!), and even more may have participated without ultimately submitting the solution form. Here’s a breakdown of how many teams scored correct answers on each puzzle:

Overall, about 862 teams correctly found all solutions to the puzzles, including the metapuzzle itself, which is quite a bit more than usual. We suspect this is the result of this year’s system, which informed participants of whether answers were right, as well as the introduction of hints throughout the event. As in 2019, this year’s certificates thus acknowledge winners’ scores as being “among the highest,” rather than singling out teams who solved all 9 puzzles.

We also asked teams to characterize some of the puzzles; as you can see from the below, Pixelated was far-and-away deemed the easiest of the lot:

Though there was a bit more of a split on which might be considered the hardest, with Problematic and Metaverse Hospital basically tied for that award:

And perhaps showing that its viral status in 2022 was no fluke, Catewordle, a puzzle based on the popular word game, was deemed the favorite, with Game Room close behind!

Solutions

And here are the solutions themselves!

Souvenir Photo

Memes

Now a CS50x Puzzle Day tradition, memes expressed both frustration and joy.

Participants’ Reflections

Considering joining us next year? Here’s what a few participants had to say:

• “Solving CS50’s puzzle is the definition of euphoria, the feeling when it clicks!”
• “I love the way that the different styles of puzzles make me think in different ways. When I get tired of one, I just switch to another and keep going!”
• “Anyone can do it and it is a lot of fun! Let’s team up next year! 😎”

Or, as one person put it more succinctly,

• “my brain hurts but it was fun”

Now to conclude, thank you to everyone around the world who took photos (and screenshots) of their teams solving puzzles!

David J. Malan

Each year, upwards of 1,000 educators in computer science gather in some city for the Technical Symposium on Computer Science Education, aka SIGCSE, organized by ACM’s Special Interest Group on Computer Science Education, which “addresses problems common among educators working to develop, implement and/or evaluate computing programs, curricula, and courses.” This year, everyone gathered in Toronto, Canada, where CS50’s team co-authored two workshops, one panel, one paper, one birds (bird?) of a feather, and one lightning talk. Among the workshops was Providing Students with Standardized, Cloud-Based Programming Environments at Term’s Start (for Free), in which we presented CS50’s own experience with the same with students at Harvard College, Harvard Extension School, Yale University, and beyond, ultimately introducing attendees hands-on to GitHub Codespaces, which underlies code.cs50.io, CS50’s own adaptation thereof:

For CS50 at Harvard, we have long provided students with a standardized programming environment, to avoid start-of-term technical difficulties that might otherwise arise if students had to install and configure compilers, interpreters, and debuggers on their own Macs and PCs. (For many students, “hello, world” is challenge enough on day 0, without also encountering “command not found” at the same time!) We originally provided students with shell accounts on a university-managed cluster of systems. We then transitioned to a cloud-based equivalent so as to manage the systems ourselves, root access and all. We transitioned thereafter to client-side virtual machines, to scale to more students and enable GUI-based assignments. We have since transitioned to web-based environments, complete with code tabs, terminal windows, and file explorers, initially implemented atop AWS Cloud9 and now, most recently, GitHub Codespaces, an implementation of Visual Studio (VS) Code in the cloud, free for teachers and students alike. In this workshop, we’ll discuss the pedagogical and technological advantages and disadvantages of every approach and focus most of our time, hands-on, on using and configuring GitHub Codespaces itself for teaching and learning. Along the way, attendees will learn how to create their own Docker images and “devcontainers” for their own classes and any languages they teach. Attendees will learn what is possible educationally by writing their own VS Code extensions as well. And how, at term’s end, to “offboard” students to VS Code itself on their own Macs and PCs, so as to continue programming independent of Codespaces.

In this post, a summary of the workshop itself! And for the curious, the workshop’s slides.

Overview of potential solutions for standardized programming environments

As of 2007, CS50 still provided students with accounts on a cluster of Linux systems to which they could SSH. On that cluster, they had access to their own NFS-mounted home directories, inside of which they could run commands like gcc, gdb, et al. Back in 1996, when I took CS50 myself, we would (insecurely!) telnet to something similar!

Because the university administered the cluster (for courses other than ours as well), we did not have root access, so we couldn’t easily install or update software for CS50 alone. Invariably, too, students would encounter technical difficulties outside of business hours, 9 AM to 5 PM, which we ourselves could not fix. (And students’ own programming hours were more like 5 PM to 9 AM!) And so, in 2008, we re-created this cluster ourselves in the cloud, using Amazon EC2, which had debuted two years prior:

In the cloud, we had precisely the root access we’d sought, but we soon found system administration a full-time job of its own (and a distraction from teaching), with any technical difficulties now up to us to solve.

We eventually transitioned in 2012 to client-side virtual machines, whereby students would download and install a “CS50 Appliance” (running Linux) on their own Macs and PCs instead. Not only did this approach eliminate our cloud-based stressor, it also allowed us to scale to tens of thousands of students via edX, where CS50 became a massive open online course (MOOC). And, because the appliance included Xfce, it even enabled GUI-based problem sets. The appliance, though, was not without its own tech-support headaches. At one point, because of a bug in VirtualBox, simply closing the lid of one’s laptop with the appliance still running could “brick” it. And Windows updates would often break students’ virtual network adapters.

Fortunately, by 2015, web-based integrated development environments (IDEs) had become viable, thanks to cloud computing, improved internet speeds, and advances in JavaScript. And we replaced the CS50 Appliance with CS50 IDE, a browser-based programming environment built atop Cloud9, then an Amsterdam-based startup, later AWS Cloud9. The IDE offered a tabbed code editor, a graphical file explorer, and, most important pedagogically, a terminal window, all of which were connected to per-student Docker containers in the cloud. The IDE effectively provided each student with their own server in the cloud, to which they even had root access. A catch, though, was that we ourselves had to maintain those containers, and so we found ourselves system administrators again.

We have since transitioned to GitHub Codespaces, though, atop which we’ve built code.cs50.io, which effectively provides each student with their own installation of Visual Studio Code (VS Code) in the cloud, complete with a tabbed code editor, a file explorer, and a terminal window, all connected to their own Docker container, otherwise known as a “codespace.” Those codespaces, though, are administered by GitHub atop Azure, which has freed us to focus all the more on teaching itself. And, thanks to a VS Code API, we now spend more time developing pedagogically motivated extensions for VS Code itself than on DevOps more generally.

Client-side and server-side alternatives to Codespaces abound, though none with quite the same extensibility and support model. Over the years, we ourselves have not just tried but have actually used and/or liked (👍) several of the below.

Client-Side

• Android Studio
• Apache NetBeans
• Arduino IDE
• Eclipse IDE
• IDLE
• IntelliJ IDEA
• Notepad++
• PyCharm
• Sublime Text
• Visual Studio
• Visual Studio Code 👍
• Xcode
• …

Server-Side

• AWS Cloud9, via AWS Educate 👍
• Codeanywhere
• CodeGrade
• CodePen
• Coder, also self-hostable
• CodeSandbox
• Coding Rooms
• Codio
• Ed 👍
• GitHub Codespaces 👍
• Gitpod
• Glitch
• Google Colab 👍
• Gradescope 👍
• Koding, self-hostable
• Jupyter Notebook, self-hostable
• Replit 👍
• …

Customizing Codespaces by writing one’s own Dockerfile

The codespaces that code.cs50.io creates for students are based on an image, cs50/codespace, that we ourselves maintain via a Dockerfile. That image inherits from another image, cs50/cli, which we also maintain via a Dockerfile for cli50, which is essentially a headless version of the same.

Collectively, those Dockerfiles pre-install software that students might need for CS50 itself, including clang for compiling, gdb for debugging, and cowsay for cowsaying. Within the Dockerfiles, for instance, are instructions like these:

RUN apt update && apt install --no-install-recommends --yes clang gdb cowsay

Anytime we push changes to those Dockerfiles to GitHub, a GitHub Action rebuilds our images, thereafter pushing them to Docker Hub as well as to GitHub’s own Container registry.

If you have Docker installed on your own computer, in fact, you can try out cs50/cli itself with:

docker run --interactive -tty cs50/cli

Or, more succinctly:

docker run -it cs50/cli

We also pre-install (after compiling from source) other software for students with more-complicated instructions like these, rather than expect them to copy/paste (and troubleshoot!) the same:

RUN cd /tmp && \
    curl https://www.python.org/ftp/python/3.11.2/Python-3.11.2.tgz --output Python-3.11.2.tgz && \
    tar xzf Python-3.11.2.tgz && \
    rm --force Python-3.11.2.tgz && \
    cd Python-3.11.2 && \
    ./configure && \
    make && \
    make install && \
    cd .. && \
    rm --force --recursive Python-3.11.2 && \
    ln --relative --symbolic /usr/local/bin/pip3 /usr/local/bin/pip && \
    ln --relative --symbolic /usr/local/bin/python3 /usr/local/bin/python && \
    pip3 install --upgrade pip

Of course, it’s not necessary to use CS50’s own Dockerfiles, or even code.cs50.io, in order to use Codespaces yourself. Students and teachers alike can apply to be verified for benefits at https://education.github.com/discount_requests/application to use Codespaces (and more) for free.

Once verified, create a new (private) repository at https://github.com/new, and be sure to Add a README file (or any other file) so that the new repository isn’t bare. Then, visit the new repository’s Code tab (whose URL should be of the form https://github.com/{OWNER}/{REPO}), click the green <> Code button, click the Codespaces tab beneath it, and Create codespace on main. Within a few seconds, you should see VS Code, connected to a codespace running GitHub’s default image, based on this Dockerfile (because you didn’t supply your own).

Of course, that image might not have everything you want:

$ cowsay
bash: cowsay: command not found

And so you’re welcome to create your own Dockerfile too! Return to your repository’s Code tab, click Add file, click Create new file beneath it, and create a new file called Dockerfile with lines like these:

FROM ubuntu:latest

RUN apt update && apt install --yes git python3-pip
RUN pip install cowsay

Or push the same to the repository using git in the usual way.

Then, via similar steps, create a file called .devcontainer.json (with the leading dot) with lines like these, so that GitHub knows to build an image using your Dockerfile:

{
  "build": { "dockerfile": "Dockerfile" }
}

Then, one more time, return to your repository’s Code tab, click the green <> Code button again, and click the + button to Create a codespace on main again, this time using your own Dockerfile. That codespace might take longer to build, because it isn’t yet cached by GitHub. But you should eventually see VS Code atop a codespace running your very own image, which you can confirm with a command like:

# cowsay hello, world
  ____________
| hello, world |
  ============
            \
             \
               ^__^
               (oo)\_______
               (__)\       )\/\
                   ||----w |
                   ||     ||

Rather than create a new codespace each time you edit your Dockerfile (or .devcontainer.json), you can edit the copy of the same within an existing codespace and then Rebuild Container via VS Code’s command palette to see the changes more quickly. But for the changes to persist for future codespaces, too, you should commit them to actual GitHub repository.

Within an existing codespace, meanwhile, you can modify VS Code’s Settings and Themes in the usual way, via the activity bar’s gear icon, and even install Extensions.

Customizing Codespaces further by defining one’s own .devcontainer.json

You can alternatively customize settings, themes, and extensions for VS Code in .devcontainer.json itself. And you can even specify a Docker image that’s already been built and pushed to a registry, a la CS50’s own. For instance, the below would prescribe that a codespace be built using Docker Hub’s official image for Python. (No need for a Dockerfile.) And it would pre-install Microsoft’s Python extension and GitHub CLI, the latter of which happens to be installable as a feature (available among others) so that you needn’t resort to your own Dockerfile just to install it. The below would also activate VS Code’s GitHub Dark Default theme, which CS50 itself uses.

{
  "image": "python:latest",
  "extensions": [
    "ms-python.python"
  ],
  "features": {
    "ghcr.io/devcontainers/features/github-cli:1": {}
  },
  "settings": {
    "workbench.colorTheme": "GitHub Dark Default"
  }
}

Quite a bit more can be configured via .devcontainer.json as well, so much so that there’s a formal specification for such. In our own JSON, not only do we prescribe our own Docker image and simplify VS Code’s interface for students via settings, we also forward several TCP ports, set environment variables, and even run a postCreateCommand.

Readying Codespaces for one’s own class

CS50’s own adaptation of Codespaces at code.cs50.io essentially automates creation of repositories and codespaces for students. But much of the same can be achieved via GitHub Classroom, too, which uses GitHub’s own APIs similarly.

Once verified for benefits, a teacher can create an organization on GitHub and then, via GitHub Global Campus, click a green button at https://education.github.com/globalcampus/teacher to Upgrade to GitHub Team that organization. A teacher can then create a New classroom at https://classroom.github.com/classrooms using the same. Within that organization can a teacher then create any number of template repositories, each of which can have its own .devcontainer.json (and, optionally, Dockerfile) along with any starter code. Each of those templates can then be used for a New assignment within Classroom. Students can then “accept” each assignment via an invitation URL, which will create within the teacher’s organization a repository based on that template just for that student (to which they can push). And via that repository’s green button can the student create their own codespace for it.

Contact

Email sysadmins@cs50.harvard.edu with questions!

Appendix

• CS50’s adaptation of GitHub Codespaces is at code.cs50.io.
• CS50’s Dockerfile for cs50/codespace (which code.cs50.io uses) is at https://github.com/cs50/codespace/blob/main/Dockerfile. CS50’s Dockerfile for cs50/cli (which cli50 uses, and from which cs50/codespace descends) is at https://github.com/cs50/cli/blob/main/Dockerfile.
• CS50’s .devcontainer.json (which code.cs50.io uses) is at https://github.com/cs50/codespace/blob/main/.devcontainer.json.

Acknowledgements

Special thanks to CS50’s own Bernie Longboy, Carter Zenke, Charlie Liu, Doug Lloyd, and Rongxin Liu as well as GitHub’s own Matthew Dyson and Per Hammer for their help with this workshop!

And our thanks to Amazon, GitHub, and Microsoft for their support of this work. At the time of writing, Malan is also consulting part-time for GitHub as a Professor in Residence.

And we’re a wrap! As the clock strikes midnight in the last time zone on Earth, we can look back on CS50x Puzzle Day 2022. This year’s event brought thousands of registrants from 88 countries together to “enjoy not having a clue when you have a ton of ’em” (among our favorite quotes online!). We’re excited to reflect on all we’ve learned from this year’s event and to share some of the stories we’ve heard over the past few days!

This year is far from CS50x Puzzle Day’s first incarnation — it is, in fact, the sixth annual CS50x Puzzle Day! The first event commenced in 2016, when we decided to make our on-campus Puzzle Day at Harvard (and Yale!) available to CS50x students around the world. Calling CS50x Puzzle Day a “day” is something of a white lie: instead of confining the event to a few hours, we spread it over an entire weekend that starts when the first time zone on Earth enters Friday and when the last time zone on Earth exits Monday. That way, everyone has both a weekend and a couple weekdays to participate (e.g., at school or work). When all is said and done, that’s about five calendar days of puzzling! At 00:00:00 on Friday, 1 April 2022, students around the world were invited to download a packet of puzzles, written by our friends at Meta: Cameron Bates, James Wu, and Zach Zagorski.

As usual, we encouraged participants to form teams of 2–4. As COVID-19 restrictions ease in some parts of the world, some teams gathered in person while following their local health guidelines. 😷 Others chose to continue collaborating over the internet, using platforms like Zoom, WhatsApp, and Discord to connect across countries and time zones. Whether you gathered in-person or online, we were delighted to see teamwork alive and well in the world!

Participation

It’s hard to believe, but 12,051 people registered for CS50x Puzzle Day 2022. We welcomed 10,173 who had never participated in C50x Puzzle Day, 1,047 who had participated once before, 464 who had participated twice, and 344 who had participated three or more times. A small group of 31 had participated in every CS50x Puzzle Day!

Among the registrants were:

• 2,710 registrants from India
• 1,880 registrants from the United States
• 1,151 registrants from Iran
• 406 registrants from Canada
• 379 registrants from the UK
• 275 registrants from Singapore
• 239 registrants from Nigeria
• 201 registrants from Brazil
• 200 registrants from Egypt
• 185 registrants from Pakistan

We were especially happy to see 136 participants from Ukraine, all of whom have been in our thoughts these past several weeks.

Results

Here’s how all teams scored this year. Each team that provided correct answers to a majority (at least five) of the nine puzzles was awarded a CS50x Puzzle Day 2022 certificate — if you’re among these teams, keep an eye out for an email from the CS50 Bot in the upcoming days! (Email puzzles@cs50.harvard.edu if it doesn’t seem to arrive, but do check your spam folder first!)

Our Google Form tracked submissions from 1,459 teams and individuals, and even more may have participated without ultimately submitting the solution form. Here’s a breakdown of how many teams scored correct answers on each puzzle:

Overall, about 100 teams correctly found all solutions to the puzzles, including the metapuzzle itself:

If we take a look at the individual puzzles themselves, we see that #4 was most widely regarded as the “easiest”, followed by If At First You Don’t Succeed. Note that “easiest” doesn’t necessarily mean “easy”!

Running away with the title of “hardest puzzle” was MAPS, with 330 votes, followed by Harry Potter and the Off-by-One Error, with 239 votes.

And among participants’ favorites were Puzzling Pyrotechnics and Portholes.

Solutions

And here are the solutions themselves!

Memes

Now something of a CS50x Puzzle Day tradition, memes expressed both frustration and joy, particularly around this year’s metapuzzle!

Participants’ Reflections

As part of the submission form, we asked participants to share their thoughts on this year’s CS50x Puzzle Day. Happy to share that the results were quite positive, if not skewing a bit in the “hard” direction!

Considering joining us next year? Here’s what a few participants had to say:

• “You should join! It’s a very fun and thrilling, especially if you’re doing it with friends!”
• “The best experience ever.”
• “my brain is steaming”
• “A fantastic challenge in creativity, and teamwork.”
• “Do not worry if you do not find an answer, in the end, it brings a lot of laughter along with a brainstorming :)”

If teamwork, laughter, and brain steaming sound like your idea of fun, we hope to see you next year. Of course, if you do decide to join, you might find yourself among those leaving more succinct comments:

• “It’s HARD!”

“Hard fun”, we might like to say :)

Now to conclude, thank you to everyone around the world who took photos (and screenshots) of their teams solving puzzles!

“At Tuesday’s Faculty of Arts and Sciences meeting, Harvard faculty ̶a̶r̶e̶ [were] set to vote on two controversial proposals — one that would allow students to pursue double concentrations and another that would replace shopping week with previous-term registration.”
— The Harvard Crimson

Shopping week (aka shopping period) is a week-long opportunity at Harvard College at the start of each term for on-campus students to attend any and all classes before actually deciding which courses to take starting the next week. Shopping period is how I myself found my way to CS50 as a student and, in turn, computer science more generally. It has been recommended that shopping period be replaced with previous-term registration instead.

The vote on that recommendation was postponed until May to allow time for further discussion. (The vote on double concentrations passed.) My remarks at today’s meeting, below.

Thank you. My name is David Malan, I’m co-chair of our computer science curriculum committee, and for the past 15 years I’ve taught CS50. And I can say, first hand, that shopping period makes planning, hiring, training so challenging for us each year administratively.

But shopping period is one of Harvard’s most impactful traditions educationally. It is not just an add-drop period in which to fine-tune decisions, it is an educational mandate from us to explore, a dedicated time to experience what courses are like, to discover yourself academically. And that culture of exploration, that uncertainty, that chaos changes students’ trajectories in college, if not beyond.

Most every year, I myself start CS50 by telling students about a government concentrator years ago who decided just to shop CS50, just to explore some unfamiliar waters, because that’s what you do in that first week of term. That’s the default, that’s the norm. And it was transformational. He went on to concentrate in CS, do a PhD, and even ended up teaching that same course. (For clarity, that was me.) From a student of ours this past fall, “I took my favorite class at Harvard[, a] Gen Ed called Faith and Authenticity because a friend invited me during shopping week and I loved the first lecture.” From another, “My secondary is my secondary because of shopping week.”

Shopping period is one of those distinctly Harvard traditions that so very characterizes students’ experience here. I daresay there hasn’t been a Crimson Key tour at Harvard that doesn’t mention shopping period as one of the College’s defining characteristics. And that should tell us something about our values.

With all respect for all of the time and effort that’s been put into today’s documents, I would urge us to consider what is more important: the administrative downsides of shopping period (which, I will note, we have somehow been managing for decades) or the educational upsides thereof. For me, shopping period changes students’ lives, period. Videos, websites… here we are on Zoom, it’s just not the same. We should preserve this tradition, find another way forward, and vote nay.

Related

• http://harry-lewis.blogspot.com/2021/12/harvard-loses-piece-of-its-souland-then.html
• http://mybiasedcoin.blogspot.com/2021/09/harvard-shopping-period-here-we-go-again.html

CS50 is Harvard University’s introduction to the intellectual enterprises of computer science and the art of programming, a course that can be taken both on campus and off. The course is unusual, perhaps, for its “production value,” which is part of its pedagogy, so that students watching videos asynchronously online feel no less a part of the classroom than students on campus. With all students now off campus, though, and all classes online, the course has aspired to optimize students’ synchronous experiences via Zoom as well. In this post, a look at the hardware and software with which we have experimented on campus for students afar, including links so that others might adopt a solution like ours in whole or in part.

Back in 2015, Harvard Business School launched HBX Live, “a virtual classroom designed to reproduce the intimacy and synchronous interaction of HBS’s famed case method in a digital environment…. With HBX Live, no matter where participants are located, they can log in concurrently and join real-time, case-based sessions with Harvard Business School faculty who teach from the HBX Live Studio, located in the Boston-based facility of public broadcaster WGBH…. In the custom-designed studio, a high-resolution video wall mimics the amphitheater-style seating of an HBS classroom, with up to 60 participants displayed on individual screens simultaneously,” per the below, with enough room for an instructor to roam and interact with each of the screens (and cameras above them).

With so many of our own courses online via Harvard Extension School as well as edX, we immediately wanted to recreate that sort of classroom in Cambridge so that we, too, could not only capture the feel of live lectures for on-campus instructors and off-campus students but also preserve the interactivity thereof. (We were already using Zoom for TA-led sections, smaller-scale classes for Extension students that followed lectures each week.) Unfortunately, larger-than-life video walls are rather expensive (not to mention quite big!), and each panel required its own dedicated PC, with signals routed from each to a production booth nearby. That booth, in turn, was staffed by multiple people. The net effect seemed amazing, but the classroom’s complexity and cost were high.

And so our vision for virtual lectures simmered for some time, with CS50’s own lectures in Sanders Theatre remaining largely asynchronous for students online, with most watching recordings thereof afterward. Students could watch live via Facebook or YouTube, though neither platform allowed students to ask or answer questions in real time, except via chat. Not quite the same as being, or feeling like, an actual attendee.

But in 2018, some colleagues and I began to teach cohorts of students in the Harvard Business Analytics Program, a “cross-disciplinary curriculum to help students not just analyze data but understand it, translate it, and incorporate it into strategy at the top levels of their organizations.” With only one HBX Live Studio on (well, technically off) campus at that point, the program opted to use Zoom for synchronous classes, with 30–60 students in attendance at each (more than the typical 20 in TA-led sections).

We were reluctant, though, to teach those classes from a laptop or desktop alone, with that many students confined to (25 or 49) tiny tiles on our screen. And we preferred not to teach while seated at desks. I, for one, find that I exude more energy while standing, ideally inspiring (if not perspiring) all the more too.

Version 1

And so we aspired to approximate, with Zoom, the feel of a virtual classroom. Within a small conference room, we installed a rectangular table, at one end of which would be me and a laptop (and an optional iPad), at the other end of which would be a (now discontinued) 65" Samsung TV, atop which would be a Sony α7S camera behind a (now discontinued) Listec teleprompter, per the below.

Behind me would be a green screen (so that we could superimpose me against slides or code using an Ultimatte 12, without overwhelming students’ screens with Zoom’s own screen-sharing feature), lit from above with LED lights, with some additional hardware off to the side to allow a (single) colleague to help control all of it, per the below.

On the TV would be most of our students, still in tile form but larger than they’d be on a laptop or desktop. And on the teleprompter would be the tile of any student asking or answering a question so that my eye line would meet theirs (because of the camera behind the teleprompter itself), creating the feel of a one-on-one interaction. Indeed, among my own misgivings with video conferencing in general is just how often we all seem to be looking at each other’s forehead, chin, or beyond, by nature of webcams’ positions, a constant reminder of technology standing between us. Both the TV and teleprompter, meanwhile, would be controlled via Zoom running on a colleague’s laptop off to the side, with my own laptop controlling whatever would be behind me via the green screen or shared via Zoom.

For the technically curious, a wiring diagram of everything, below.

Overall, this first version worked great. Each of our 90-minute classes felt more like an actual class than would have, say, me alone at my desk. And, because of the teleprompter and the camera’s distance from me, eye contact with students was better than usual. The result was more energy and intimacy than a simpler setup might have allowed.

Even so, I could see no more than 49 students at once, with any additional students off-screen (unless we manually paged back and forth via Zoom). And much as I preferred to be standing, my legs wanted to move, just as I would to interact with that many students in an actual classroom. Indeed, fixed to the end of the table as I was, I found myself channeling energy elsewhere, as by tapping my foot and frequently leaning on the table itself. Admittedly odd symptoms, but seems the energy had to go somewhere!

Version 2

When COVID-19 struck, we, at first, began teaching from home. And even once Harvard had established protocols for being on campus, we could no longer safely use our conference-room setup, with two people together (e.g., me and a colleague) in such a small room. We could have relocated some of the hardware to an adjacent room, running wires between each, so as to isolate everyone. But we decided instead to solve more problems at once.

We first relocated to another room altogether, one with sufficient airflow and filtration so that I could teach unmasked, with any colleagues isolated in separate rooms. We then introduced two additional TVs so that I could see more students at once across a total of three, roughly arranged in a semicircle, allowing me a few feet to roam, with a small table in front for my laptop. Below the TVs were two smaller displays: a confidence monitor on which I could see myself, just to ensure I wasn’t walking out of frame, and a (now discontinued) vertical monitor on which I could see Zoom’s Participants window full-screened, to see at a glance whose hands might be up. Behind me was a white backdrop, lit from above by LED lights, with a pair of speakers on the floor from which to hear students’ voices behind me (with my back between them and my lavalier mic, preventing a feedback loop). Atop the middle TV was that same Sony camera, toward which I would look whenever interacting with a particular student, who’d be pinned by a colleague on that screen.

The end result was that each virtual class began to feel, and was, all the more like an actual class.

An artist’s renditions of all of this, below.

Improvements

Not everything worked so well at first, though. We originally experimented with having a camera atop each of the TVs so that we could pin participants on any of the three, thereby varying my glance and stance whenever students asked or answered questions. Because the backdrop was entirely white, though, switching among cameras (at similar focal lengths) yielded awkward jump cuts, with my own position seemingly jumping in space. So we eventually simplified with just one.

Connected to each TV initially, too, was an Intel NUC Mini PC running Zoom, one per TV, with all three PCs remotely controlled by a colleague via Chrome Remote Desktop using a ultrawide monitor, with each TV mirrored on one third of the monitor. That particular design quickly proved suboptimal, as students would sometimes appear in duplicate across the TVs, since none of the PCs knew which students the others were showing. And it was unwieldy to control manually (and remotely!) so many PCs at once, so as to pin participants as needed.

Thanks to our friends in Harvard Business School’s MBA program, though, we then discovered Zoom Rooms, an alternative to the Zoom Client with which most of us are familiar, typically used in conference rooms with multiple, wall-mounted screens. Not only does Zoom Rooms coordinate as many as three screens at once using a single PC, its UI can be controlled via Controller software on an iPad (or other tablet). Without disturbing what’s on any of the TVs (as by moving a mouse, clicking buttons, or opening menus), potentially distracting an instructor, a colleague behind the scenes can “pin” to a particular screen whomever an instructor has called on, as in the below. And the participant can be pinned predictably to a particular screen (e.g., that with the camera atop it), on which the instructor can then focus to meet the student’s eye line.

Demonstration

A live demonstration, below, of all those improvements.

Version 3

We have since iterated on the design further, angling the TVs outward more so as to open up more room to walk. (Tape on the floor reminds me just how far I can roam.) And we have replaced the white backdrop with a (wider) green screen, thereby allowing us to superimpose me again atop code or slides, as in the below. We deliberately keep some of the LED lights above and below in frame so as to orient students in an otherwise virtual space.

We also reintroduced two additional cameras, again totaling three, this time at different focal lengths so that we could capture, from different angles, physical demonstrations like the below. While we could digitize demonstrations like these, I’ll admit I prefer the physicality and simplicity of real-world objects. Drawing with a marker on a whiteboard (and erasing with my hand!) is still faster than any touchscreen I’ve used.

We have also added Zoom’s Chat window to the vertical monitor, so that we can not only see whose hand is raised but also who’s asked or answered a question via chat. We find it helpful to use high contrast mode in Windows so that names, hands, and messages stand out at a glance.

An artist’s rendition of this latest setup, below.

And for the technically curious, a wiring diagram this setup, below.

Limitations

With all that said, the setup is indeed just an approximation of an actual classroom, with some downsides still. Whereas the Zoom Client supports as many as 49 tiles per screen (totaling 147 across three), Zoom Rooms initially supported only 25 (totaling 75). Not a deal-breaker at the time, since that many students were unlikely to participate on camera in a particular class, but a regression nonetheless that has since been redressed, with 49 (totaling 147) now possible.

Zoom’s chat, too, is primitive, with discussions unthreaded and pop-ups often distracting. And breakout groups are all too isolating, with the process of changing rooms (or, as an instructor, keeping an eye on them all) clunky. And the larger a class is, the more time-consuming it is for a colleague to find and pin a particular student when called upon.

All quite fixable (we hope!) in software. Indeed, we’re hoping we ourselves might be able to leverage Zoom SDKs or Zoom Apps next to solve some of those problems ourselves.

Acknowledgements

Special thanks to CS50’s own Ian Sexton, Tara Kavanaugh, Andrew Markham, Rongxin Liu, and Arturo Real, who figured all of this out! And to Harvard Division of Continuing Education, Harvard University Information Technology, and Harvard Business School for so much support and inspiration. And to so many students who opted into these demos!