I worked on Khan Academy's partnership with NASA from July 2013 to its launch on 27th May 2014 (which included the briefest mention by Obama at the Whitehouse science fair). My role was primarily to build all the interactive content, which involved learning a lot of about basic orbital mechanics and ellipses. I also helped with the overall planning of the lessons and some of the exercises (which was mainly done by Brit Cruise).
- Interactive diagrams that allow users to click and drag elements to see the effects of their changes.
- Programs used to generate gifs for animations.
- Two simple games that allow users to try landing a rover on Mars.
I've written about some of the programs I particularly enjoyed making in a lot more detail below.
The NASA tutorial is split into two sections (plus an introduction video), which are in turn split into four lessons each.
Measuring the universe
Measuring the Universe takes a historical perspective on how our understanding of the solar system developed. Many of the programs in this section deal with orbits. I tried to make these as accurate as I reasonably could, which meant having to learn a lot about ellipses.
The section is split into four lessons:
- Modeling the solar system is about the development of the heliocentric model of the universe and lunar eclipses.
- Measuring the solar system explains how to calculate the size of the Earth, moon and sun from relatively simple observations.
- Orbital mechanics 1 is about pi, circles, ellipses and Kepler's first law.
- Spectroscopy is about the different types of electromagnetic radiation.
Exploring the universe
Despite its name, Exploring the universe is about how humanity has tried to learn about Mars. It starts with some ancient observations, before moving on to describe the satellites and rovers sent to Mars, ending with the Curiosity mission: how it was planned and what it has achieved.
- Mars: Modern exploration is about the satellites and rovers sent to Mars before Curiosity and some of their discoveries.
- Mars: Ancient observations is about observations and speculations about Mars before the space age.
- Curiosity rover: mission briefing is about the capabilities of the Curiosity rover and how it got to Mars.
- Curiosity rover: discoveries is about some of the results from the Curiosity rover.
Below I've described some of the programs I made for the NASA lessons in more detail. This probably more for my own interest than another else's.
Curiosity rover: mission briefing
My favourite program from the NASA lessons was this game, in which you have to land the Curiosity rover on Mars. It was based on this video, and also I recommend watching this video which shows just how crazy the landing was.
As games go, this one is pretty basic: you choose the value for eight parameters, press Start Entry and hope for the best. I'm surprised so many people did enjoyed the game and spent so long trying to optimise their landing. But I guess games are always a welcome break from learning.
The game uses a pretty basic physics simulation, but I did a lot of research so it's hopefully quite accurate. I tried to tweak the simulation to give the same results for parameters such as speed and temperatures at various points. I read a lot of papers and even got to ask a NASA engineer some questions, so I could get the masses and tolerances of the various components, such as the heat shield, the parachute and the fuel are correct. I'm sure the game is a lot more forgiving than reality, but otherwise it would have been very difficult.
Overall, I'm pretty pleased with how this game turned out. I'm no designer, but I think it looks pretty good, in a simplistic sort of way. I'm pleased with scorch marks that appear as the landing module enters the atmosphere. At the time, the screen size was limited to 400 x 400 pixels, so I had to fit a lot into a small space, which turned out OK. One thing that could be improved is to give better feedback to why a particular set of parameters failed (other than: you crashed).
Are you Santa Claus?
This is like Christmas morning!
Please keep making education software, even if it's only games or simple simulators (perhaps even better). I really haven't had this much fun with science since I was a kid at MOSI in Chicago, and to be fair, I had a pretty good physics professor. :)
The distance between Earth and Mars
Unsurprisingly, many of the programs in the NASA lessons involved orbits. This program shows the orbits of Earth and Mars, recording the date when they line up with the sun (an opposition). It also plots the distance between Earth and Mars over time. I wanted it to give the correct dates for all the oppositions I had data (about 120 years worth). If the planets had perfectly circular orbits this would have been easy, but because they are slightly elliptical (especially Mars' orbit), the speed of their orbits varies over time.
This meant I had to make a simple simulation. However, using Euler's forward method, which is the simplest method, causes the orbit to drift, even when using very small steps. Even more complex methods drift a fair bit over one hundred years. So instead, I used Euler's forward method with 20 small steps, figured out the change in angle this would cause, then applied this change in angle around the ellipse. This way, I could ensure the planet would never leave the elliptical path I'd set, and I could get the planets' positions around the ellipse accurately enough that the oppositions were correctly predicted for all the values I had.
Features of Mars
This program lets users spin a model of Mars and points to some of its features. I'd not done much with projections before this project, so it was interesting to figure out how to convert a rectilinear image of the surface of Mars into a spherical map.
The hardest part of this program was not the projection, but the fact that I was not (at that time) able to upload images to the Khan Academy coding environment, and the environment prevents you from using external images. So I wrote a Python program to convert the image I had into a 2D array of integers representing the pixel colours. Then my program had to load this uncompressed image data and convert the integers back into R, G, B colour values.
Several people have requested that I make it rotate in two dimensions, which should be possible if I can only work out how. Others have also asked to be able to zoom in, which is not possible without improving the resolution of the image, which would slow down the program too much.