Design a site like this with
Get started

How we’re teaching high schoolers to code, online

by Cameron Kleiman

When Christian and I decided we wanted to teach high schoolers about the novel programming language Julia, I knew we would need a certain amount of infrastructure in order to support our students. One particular interest of mine was making sure our solutions scaled. We opened the class to 50 students, with a target of 30. I wanted to make sure if we had 10, 30, or 50 students we could support them. So, a course website was in order.

Additionally, we recognized that not every student is going to have access to a programming environment, nor will they have the technical knowledge to set up one themselves. And that’s okay! Often, setting up a development environment can be more challenging than (and irrelevant to) the programming itself. We wanted to support these students by providing them with an opportunity to develop in the cloud, especially for students using devices like Chromebooks and iPads.

The technical details

Choosing a domain name

For the class domain, we wanted something short and fun that students could remember easily. After looking through a lot of options, we settled on because it captured a lot of the sentiment Christian and I shared about the class. Christian and I often express how much fun it is to code in Julia, and we wanted our students to share our appreciation for the language. At the end of the day, we were going to try to make class feel a bit like a party.

About the course website

For the course website, there was one obvious choice: Franklin.jl. I knew we would need a static-site generator, like Jekyll, Hugo, or Eleventy, but picking Franklin was just a matter of practicing what we preach. While Franklin’s not as featured as those other site generators, it does the job, and its built-in “basic” template was perfect for a stripped-down, professional course website. Additionally, consistent with Julia being a scientific programming language, Franklin has some nice built-in features, like LaTeX support.

To deploy the website, I chose GitHub Pages, as Franklin actually comes with a GitHub Actions workflow to automatically deploy to GitHub Pages whenever you commit new changes. This became incredibly handy because I could edit the live course website with a simple push from my laptop or by editing the files directly on You can see the course website and automatic deployments in the GitHub repository.

Jupyter notebooks and the code server

To actually teach the class, we decided on Jupyter notebooks, using Julia’s notebook package IJulia. Jupyter notebooks offer a unique combination of instruction and interactivity, so we could use them as both a teaching tool and a way for students to write their own code.

For the online development environment, The Littlest JupyterHub (TLJH) was a natural choice. JupyterHub is a platform that allows for automatic provisioning of Jupyter or JupyterLab environments over the internet. TLJH allowed us to run a single server for all the students needing to develop in the cloud, with minimal setup. (It also provided the platform on which I wrote this blog post 😊) I chose Amazon Web Services Elastic Compute Cloud to host the server, as I could quickly provision a server with the resources needed for our 35-50 students to have a place to develop on a moment’s notice, with the ability to resize if necessary. (Spoiler: it was necessary.)

Getting students set up for class

To get our students set up for class, we used the concept of a “Welcome form.” The class Welcome form contained survey questions to get a sense of our students’ programming experience and the resources needed for the code server, as well as a step by step guide for getting students set up with Julia and the other various tools used in the class. This allowed us to start programming on day 1 because all of the students were set up on the tools we had given them.

Establishing motivation for learning Julia

In order to teach a programming language, students need something to code. For this, we relied on Project Euler, a library of mathematics and programming problems. Christian and I are big fans of Euler already, having solved over 100 problems ourselves (regrettably, mostly without using Julia). The problems give our students a way to gain experience with Julia without us having to invent a large number of programming exercises.

What this allows us to do

Together, this allows us to create an interactive learning experience for our students. For each class, we distribute a Jupyter notebook containing some light instruction and empty code blocks for students to fill in on their own as we teach.

At the end of each class, we typically assign a few Euler problems for students to optionally try to tackle to gain more experience with Julia, and we offer students the ability to present their solutions at the beginning of next class. If they get it right, fantastic! The presenter just learned more about their own solution by having to explain it, and the students get to pick apart a solution to a problem. If they get it wrong, even better because everyone has the opportunity to debug as a class with our help.

The goal of teaching the class this way is to encourage students to be curious about the solutions to mathematical and programming problems, in an effort to have them play with the language on their own. We can give them the tools they need to be successful, and along the way, we’re there to support them however they need.

The bumps along the way

One modification to the infrastructure we had to make to the code server was to scale it for additional usage, after running out of memory and crashing it during class. The issue has to do with the number of students programming at one time on the JupyterHub server. However, because we’re using AWS, this is super easy. I can just take the instance down, change the instance type to have more memory and CPU before class, and bring it up within about 5 minutes. This costs more money, so I downscale it after class so students can code during the week.

Make no mistake, the server is expensive ($100 a month or so), but scaling it during class lets us avoid making it cost twice as much.

Putting it all together

The Jupyter notebooks, class website, and code server all serve important roles in how we’re teaching our students to code, online. With all these pieces of infrastructure, we think we can provide students a relaxed way to learn a new programming language, giving them the opportunity to learn how they want to learn. We try to keep class time chill and flexible to adjust to what students are most interested in or struggling to understand, and overall, we want to provide a safe space for students to be curious and talk about technical concepts.

It’s been a lot of fun, and through the process, Christian and I are learning just as much as our students. Teaching for ESP has been something special and has given me an opportunity to switch roles from a CS student to a CS teacher. I certainly have a new appreciation for MIT’s amazing CS professors and what they do.

One thought on “How we’re teaching high schoolers to code, online

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: