# Perpendicular Lines and Coding a Tartan

Linear functions are at the heart of 8th grade math and Algebra I, and I enjoy finding those ways we engage with functions in real-life situations… including creative coding!

As we learn about slope, it’s an interesting challenge for students to explore what kind of line would be perpendicular to a given line, and I like to use that challenge to deepen their understanding of what slope is. We start with some lines and without showing them how, I challenge them to find a line that makes a perfect 90 degree angle to the given line.

We have a discussion about when this understanding would be important. Architects or designers might use the concept, for example, if they have to design right-angles that are not perfectly aligned to their grid. Video-game designers may use the concept if a shooter is facing an enemy, and you have to strafe at 90 degrees from the angle you expect their projectile to come from.

Or, you might use the idea of perpendicular lines to just make pretty art, which is what we did with this mini-project.

I reminded the students about Tartans and how groups in Scotland use a Tartan as part of their identity – whether region, occupation, clan, or something else.

https://www.scotlandshop.com/us/tartan-finder

My family and I hiked in Scotland this past summer and noticed tartans of the MacDonald and Campbell clans everywhere!

For math projects, I’ve written before about how much I like coding in Khan Academy’s Javascript interface, so here’s the pitch again: it’s great for mini-projects. It’s easy to push a sample project out to students, easy to debug and run, fun and engaging to color and animate, easy to save and share as long as you have a KA account.

We start by going over how to color the background and stroke and fill colors, and how to place points on the coordinate grid. We first discuss where (0,0) might be and then discover together it’s in the upper left (!) and I challenge students to place points in all four corners and in the center. This is what they end up with.

Then we add in the draw() loop and get the points moving.

That’s day 1. On day 2, we can introduce the project. Students have to make a personalized, unique Tartan with colors and stripe widths they choose. The tartan must have at least 8 lines on a colorful background. The lines must be perpendicular, but can’t be perfectly horizontal or vertical, or at a 45 degree angle. Lines must start at an edge.

It gives some interesting challenges as students figure out what coordinates would start a line at the edge they want, and then how to create slopes that are perpendicular. In an example video, I show how a slope of +4 in the x direction and +5 in the y direction is exactly perpendicular to a slope of -4 in the y direction and +5 in the x direction. Make one value negative, and swap x and y.

Perpendicular Lines video

My last class made some very nice tartans.

It’s a quick, 2 or 3 day mini project that gives students some context for slopes and intercepts and allows them to get a little creative.

Enjoy!

# VR and Empathy: A Journey

At my PBL school, students generally start a new venture project every quarter. This quarter, I’m facilitating a venture project class called “Virtual Reality, Real Feelings” – about the crossroads of VR and empathy. The purpose of this venture is to explore how VR technology can immerse someone in a world so much that it changes their perception of the world. The students will select an inquiry question and create a VR mini-game or experience designed to change someone’s perspective.

It’s a really ambitious project and I’m more than a little terrified. We’ve essentially got 8 weeks to pull this off.

As part of our school opening, we got quite a lot of grant money for new technology. I lobbied hard for VR equipment. I have noticed how this technology inspires curiosity, engagement, and wonder. Those emotions are powerful catalysts for learning and so I see tremendous potential for using VR as an educational tool. We secured 3 powerful gaming computers with Oculus Rift S headsets, and I also purchased 12 Oculus Quest headsets and 20 decent laptops to do software development. My class has 23 students, so we have enough computers for every kid to have one and students can share headsets with a partner.

We set up the Rift systems first, and set them up in our school gallery so students could play VR games after school such as Beat Saber. I believe in using the tech for fun, because again, emotions and curiosity. ðŸ™‚ It also builds a sense of community and a shared sense of taking care of the equipment and fairness.

Before the venture started, I had to get all of the Quests set up. We have a school account on the Oculus store, so I used that along with my own phone at home to charge, update, and install apps on all 12 of the Oculus Quests. It took 2 entire evenings to do.

I brought the Quests back to school, and as luck would have it, there was an empty cabinet that exactly fit 4 Quest boxes side by side on each shelf. We drilled a hole in the back and put powerstrips in the bottom, and zip-tied the chargers to the cabinet in bundles. Each Quest box, headset, and touch controllers are labeled with their corresponding numbers, using silver Sharpie. A couple of students helped me set up our charging cabinet and get the Quests on the school wifi. We got some containers of sanitizing wipes to clean the headsets off at the end of every class. We need to work hard to keep them clean and in good condition!

It is very helpful that when you want an app on all 12 Quests, it only needs to be bought once on the school account and then all headsets can install it. The Oculus Store, unlike Steam, does not limit you to play a game on one headset at a time. All 12 can be running the same experience. It makes the software part of the setup very affordable. However, it means we can’t play multiplayer experiences unless we get more Oculus accounts and pay for the apps again.

All of this happened the day before class started. We still don’t have the development laptops, so I’m having the students empathize and design in the meantime. This is an important part of the design cycle and it’s actually convenient that we don’t have the computers, so we can focus on doing our planning well.

For the first week, this is what we did.

Before the class: several students and I attended Colorado State University’s XR Symposium over a weekend, to connect with our local university and get some ideas and inspiration.

Day 1: We introduced the class with getting-to-know-you activities, a slide presentation about the history, technical specs, and impact of Virtual Realty. We discussed the XR Symposium, and we created a class charter.

The slide presentation I used is below. You are welcome to use any of the information if you want. Here’s the link to it:

Day 2: We reviewed the learnings from yesterday, and then I gave the students a sort-of scavenger hunt I created. I called it a Questival. The goal was for students to try out 10 different VR experiences, articles, or videos, and journal about what they learned along the way. I curated some experiences that would either evoke curiosity or emotion. The VR apps I included were:

Becoming Homeless: A Human Experience by the Stanford Virtual Human Interaction Lab. This experience only works on the PC-based headsets, not on the Quest. In a disappointing twist, I could get this app to work at my house but not on our school PC’s and I don’t know why. On the school Rift S machines, the app would show up on the monitor but we never could get it to display right in the headset. I tried for a couple of days, and eventually we just demoed it for the entire class, on a big smart monitor, by holding the headset and having a student use the touch controllers. It worked, but wasn’t as immersive as actually being in it. The point of this experience, however, could still be fulfilled. In this VR Empathy app, a couple of aspects make it really powerful and interesting. One is that the programming and game design is not that complicated. You point and click at objects, and simple things happen like a sound plays, or an animation runs. It is an app in the style that a student could easily create. The other powerful aspect is that it’s not just a video, it’s interactive. I wondered if the simple choices you had made it more powerful than just an immersive video. Does the act of having to choose which items to sell create more empathy than just watching someone else do it? Does it matter that you get to choose the color of your hands?

Traveling While Black is an anti-racism experience. It is not interactive, it’s an immersive video – but it has some touches that make it more powerful than just a video. The perspective of sitting in Ben’s Chili Bowl listening to a crowd having a conversation is a powerful one, and I liked how images were embedded into the scenery to make the stories come to life. It’s a very good storytelling experience and the students thought it was powerful. Especially the white students.

6×9: A Solitary Confinement Experience is one the students have to navigate to on YouTubeVR. I did have to go in and unblock it, since the content is flagged as “restricted”, so test it at school first before you try it with students. It is intense, but not inappropriate. I liked it because it’s an immersive animation rather than just a video made with a 360 camera. The models of the cell and furniture, the paint animations, etc are all created and not photographed. And again, it’s something the students could create, not technically challenging, but powerful storytelling anyway. It’s about the experience rather than the realism. Students had no idea this was something that happened in the US, and before I watched the video, I didn’t know it was so widespread. It opened our eyes to one of the ways the criminal justice system has overstepped its bounds.

Job Simulator was an experience I curated because it evokes emotions of surprise and joy, and it’s an example of good game design that’s specific to VR. You could not create the same experience on a flat computer screen and get the same emotions. In VR, you need to design your experience with caution about movement – otherwise you’ll make your users sick! Standing or teleporting experiences are fine. Anything that involves walking or flying needs to be approached with extreme caution or you run the risk that many, many people will not use your app because they get queasy. We also discussed that although people love realistic video games, a VR experience doesn’t have to be realistic to make you feel totally immersed in it. Low-poly graphics are sometimes just what you need. They highlight the interaction rather than the object itself.

These were some of the best VR apps and experiences I had found that really get at the empathy and VR connection. I put other articles and videos in the Questival worksheet, and students worked on this on and off for the entire week. Here’s the worksheet:

I got a lot of joy from watching the kids work on this and seeing their surprise, curiosity and engagement.

Day 3: We continued working on the Questival assignment, and I gave students the prompt of considering a curiosity question (or a few candidates) for their research project. As they explored different applications and uses of VR, I wanted them to hold in their minds the questions that were coming up they wanted to dig into more. They will take one of those questions and turn it into their solo research project. Some examples of curiosity questions:

What are haptics and where will they go in the future?

How is VR used in Military / Defense situations?

How can people explore identity or body image using VR?

What are the impacts of deforestation?

What is the history of 3D animation?

Can VR be used to eliminate racism?

How can we get people to accept and care for refugees from other countries?

The students came up with some great questions on their own and I’m excited to see where their explorations take them.

Day 4: Some students, because of absences or working slowly or not knowing what was expected, were still working on the questival. For students that were finished, I wanted them to start exploring creation tools in VR. They could use Tilt Brush, Medium, SculptrVR, or Sketchup to participate in a build challenge with the theme of: Halloween. We’ll review everyone’s halloween artwork on Monday and award a prize to the best halloween designs. Artwork made in any of these media can be imported into Unity and built into an app, and I have some students who are incredible artists – unlike me!

As we continue into the coming week, I just had a couple of observations about working with class sets of VR equipment.

- Space is such a tough problem to solve. One classroom with furniture in it is a tough space for a dozen groups of students working in VR. I generally had 6-7 VR users in the classroom and then others would use the public spaces outside of the classroom. This created some conflicts when students were noisy, or were perceived as being out of class/goofing off. I had some colleagues frustrated with me because they felt their classes were disturbed. So I need to set some clear boundaries and expectations for space that help the students work while not disturbing other classes. It’s a hard problem. VR takes a bigger footprint than a school desk.
- Overall, I am very, very pleased with how easy the Oculus Quest headsets are to use. The students were able to figure them out with very little instruction. They used the sanitizing wipes and our homemade charging station very responsibly, and the ratio of 1 headset per pair of students seems just about right. It’s easy for me to manage the apps on them as well. If I purchase an app, the students can load it on a headset with no intervention from me.
- We re-norm OFTEN about expectations when using VR equipment. I boil it down to 3 basic principles:
- Be Safe.
- Be Kind and Respectful.
- Take Care of the Equipment.

Being safe involves using the wrist straps and making sure your play area is secure and nobody walks through an active play area. Being kind and respectful involves honoring time limits and making sure everyone gets a turn. Taking care of the equipment means we always play on carpeted areas, we hand off equipment carefully, and we take care to power down, wipe, and plug in everything when done.

We discuss these several times a week. You really can’t do this too much.

This coming week, we’ll take a field trip to our local science and technology museum, work on our research projects, and start choosing themes for the student-made apps. After this week, I think our computers will be in and we can start learning how to create apps in Unity and animations in Tvori.

# Linear Functions and Missile Command: A coding mini-project

Hi everyone – if you’re still hanging in there with me, and I haven’t lost you due to my long absences from engaging with the blogging world, I’d love to share a little mini-project I did with my algebra class. I gotta say, I really enjoy doing coding mini-projects in math class. I like putting the projects together, the kids find them really engaging and fun, the problem-solving is interesting and surprising.

We started out the year as many algebra classes do, studying linear equation-solving and the properties of linear functions. Things have been going reasonably well, but I knew some students were irritated not knowing “when will we ever use this?” – It’s one of my ongoing pet peeves with the high school math curriculum, that the way it is expected to be learned and the way it shows up in standardized tests doesn’t really match how these concepts are used in real life. Including linear functions. These are SUPER useful in real life – in all kinds of situations where you have to make predictions involving a constant rate. But the kind of problem-solving you normally do with linear functions doesn’t always look like what we do in math class, converting functions to slope-intercept form or point-slope form, graphing on a 4-quadrant plane, etc.

I started by giving the students that basic speech. These concepts are incredibly useful, but in the real world they don’t often look like what we see in math class. So today we’ll explore one possible application of linear functions.

And I introduced them to the retro game of Missile Command.

We watched a YouTube video of someone playing the game (the screen captures were fetched from this video too):

The students were in awe. Back in the early 1980’s, we were in the end stages of the Cold War, and the threat of a nuclear apocalypse was a low-level stress always present in our lives. In the game, missiles rain down on your cities and your job is to shoot them down before they destroy your nation. You even get a little 8-bit mushroom cloud when a city is nuked. It really was a dark, terrifying video game and I remember feeling super tense while playing it. There’s no way to win. The missiles just fall down faster and faster until you lose all of your cities and the world ends.

The missiles always start at the top of the screen and rain down in a straight line. In the game, if you could predict where those missiles would land, you could prioritize which ones you needed to shoot down. As the game got faster, for example, it didn’t make sense to shoot down a missile heading for a city that was already destroyed. Focus on the ones heading for your still-standing cities.

We watched for a bit and some students insisted, “Those aren’t straight lines!” But they were, they just didn’t look straight when rendered in 8-bit. For example, these missiles below go down 2, over 1, down 2, over 1, down 2 once more, over 1, then down 1, over 1. Repeat the pattern – 2, 2, 2, 1. 2, 2, 2,1. The slope is a net -7/3. We could identify missiles with a slope of -5/2 (down 3, over 1, then down 2, over 1) and -8/3 (2, 3, 3. 2, 3, 3).

I made the students a little mini-game starter in Khan Academy. In this starter, the missile is at the top of the screen, and a house is at the bottom, but the missile doesn’t move. We did have to start with a little discussion about how the coordinate plane in many programming languages is different than the one we use in math class. Often, a computer game’s coordinate grid has (0,0) in the top left. X increases as you go right, which is what you’d expect. However, Y increases as you go DOWN the screen. It’s intuitive if you think of the way spreadsheet cells work, or the way you read text. Start in the top left, work over, then down.

The key is to change lines 31 and 32, which currently read:

x = x + 0;

y = y + 0;

If you modify the amount added to X and Y, the missile starts moving. The trick is to make the missile make a straight line and hit the house. If you hit the house, the screen turns red. Decimal amounts can be used.

Students found that if they tweaked the velocities such that the Y velocity is a *little* more than the x velocity, they can hit the house. For example, these combinations worked:

x = x + 10;

y = y + 12;

x = x + 0.5;

y = y + 0.6;

A y/x ratio of *about* 6/5 was ideal, and there was some wiggle room since the house has a hitbox about 20 pixels wide and tall.Â We made some predictions about other combinations before trying them.

Next, I challenged the students to move the starting location of the missile, on lines 2-3, and the starting location of the house, on line 6, and find a new y-x velocity pair that would let the missile hit the house. Some students, of course, thought of putting the house directly below the missile and using a y-velocity only, setting up a “no-slope” situation.

On line 8, there’s a line of code specifying “FrameRate”. This is the number of times the draw() function is called in one second. It’s 60 by default, so the missile will move 60 times each second. For the final challenge, students had to tweak the frameRate() and also the velocity so the missile would hit the house in *exactly* five seconds. Students got timers out and spent quite a while trying to get the missile to hit in exactly five seconds. Many figured out that if the missile moves roughly 80 pixels each second, it takes five seconds to get to the bottom of the screen… so it was a matter of finding combinations of frameRate * y-velocity that would equal about 80.

I just want to finish with a plug for Khan Academy’s computer programming interface, especially when it comes to little math mini-projects like these.

Khan Academy’s Computer Programming courses

Create a new Javascript Program

It’s my go-to resource when I want to create a quick little math activity. I don’t necessarily need my students to create a program from scratch all the time – often I’ll create a little starter program that needs fixed or modified. With this interface, I can save the program and push a link out to Google Classroom. Students click on the link, and then click “Spin-off” to get their own copy to modify. They can also see other students’ spin-offs, so if they get stuck, it’s helpful to see what someone else did. The program runs right away and needs no compiling time, so the students see the impacts of their changes instantly. The number scrubber and color picker make programming changes super easy and fun. The documentation tab is wonderful. If you’ve got students who are interested in taking the task beyond what you set up initially, just refer them to the documentation tab and there will be examples they can copy and paste.

It’s a fantastic coding environment for little activities like these, and I use it in math all the time!

# Unit Rates and Scratch

I’m back to teaching pre-algebra after a long time off – and the more things change, the more they stay the same! A key staple of middle school math is learning about rates – how they work, how to calculate unit rates, how to predict with rates, and different representations of rates – including tables, graphs, equations, and story problems. I love to make the connection between the story problem and the equation by doing a coding activity. For our final project on unit rates, I assigned the students a pair programming project in Scratch. The structure of the activity is really similar to what I’ve done in my 6th grade computer science classes.

- The background knowledge. We have a discussion about a specific situation involving rates – I chose “toilet paper math”, because what is a more confounding consumer decision than buying toilet paper? I picked a couple of examples of toilet paper packages from the weekly grocery ad and put them into a Google Doc for the kids here. https://docs.google.com/document/d/1zM4wwf2GDSEEaB31IWDeJPTqibtPsG1zLN_XA_k35uM/edit We had a class discussion about what clues on the package might help me figure out what toilet paper to buy. One class mentioned that I could figure out the number of squares / sheets of toilet paper in each package, and another class wanted to go by the number of square feet in the package. Together, we wrote a Scratch program that would help me figure out what toilet paper to buy. For the class example, I showed them how to use the “ask” block to get input, the “set” block to set variables to values, and operators to do math. We created variables for the price of the toilet paper, the number of square feet in the package, and the number of square feet you can get for a dollar. The main character would then report out the square feet per dollar unit rate to help us figure out our purchasing decision. Our class program is here: https://scratch.mit.edu/projects/291422012/editor
- The norms before the worktime launch. I explained to the students that when I was an engineer, we often used a protocol called “Pair Programming” to solve problems. As an adult, this meant I prairie-dogged my head up above the cubicle walls and shouted to my friend Jerry: “Jerry! Can you help me solve a coding problem? I can’t figure it out.” Then I would type at the computer while Jerry stood behind me and read over my shoulder, and we talked together about what the code did – line by line. It was really helpful to have a partner talk it over with me. I explained that in middle school, we can also use Pair Programming and some of the norms are pretty much the same. Then I showed the Code.org pair programming video on YouTube.

https://www.youtube.com/watch?v=vgkahOzFH2Q After the video, we went over the do’s and don’t’s. - I gave the students a choice of word problems having to do with Unit Rates, and their task was to solve one of them with a partner using the Pair Programming protocol. The choices are in this document: https://docs.google.com/document/d/1h8r2z0o2FtOr8N4IjqGaiNrhn_DGAJLIyNREeg9iR0g/editÂ I change up the celebrities in the document every so often. Students love Marshmello and also Ariana Grande this year and I got some cute programs with these characters.I swear the Pair Programming video is magic. Students for the most part peacefully navigate partner work after watching and processing the video. I only had a couple of groups that had any trouble at all. This activity took a whole class period for most classes, and a little longer for one group. All of the students were engaged and trying hard, and most groups enjoyed the creative storytelling part of the project. I wish I had introduced Scratch sooner in this year’s math cohort, but we had a lot of manual math to do and so we’re just now starting to automate things. Now that the kids are on board with it, I can’t wait for the next project.Here are a few example programs the students made for the word problems.

Marshmello’s road trip: https://scratch.mit.edu/projects/293136380/editor/

Hagrid’s Animals (these students modified the prompt a little bit, but I really enjoyed how theirs turned out and they had fun with the creative storytelling): https://scratch.mit.edu/projects/292456078/editor/

Ariana’s Carpet (this group of kids decided to include their favorite K-Pop star and I’m embarrassed to say I don’t know who this guy is): https://scratch.mit.edu/projects/293139904/editor/I really believe in computer programming as a modeling tool for math expressions. Students love the instant feedback and the creative storytelling, and I love that they can test many inputs and it is a check on their number sense. Often I see students modify their model when they try plugging in a few numbers and then they say “Wait a minute! That gas mileage doesn’t make sense!”

Other programming languages work just as well. I’ve had older middle schoolers do a similar task in Processing and it really stretches their brains!

# Pre-calc, Trig, Physics, and Planetary Motion – a coding project

I mentioned earlier that I get the privilege of teaching pre-calc for the first time this year. As a capstone project for our unit on trig, I created a project on planetary motion. It had been on my radar since we studied conic sections and learned about how planetary motion is a real-world example of an ellipse. I browsed around for some examples of planetary motion simulators, and found this one written in Python.

https://fiftyexamples.readthedocs.io/en/latest/gravity.html

The link above uses real-world values for masses of planets and the value of big G, but I thought the students would enjoy “playing God” and creating their own planets and velocities and creating the big G constant for their little universe. In the process we would learn about the physics of planetary motion and about how trigonometric functions can be used to model periodic motion in a coordinate plane. Yay math!

My pre-calc students have not yet had high school physics, so I had the opportunity to set the groundwork for some basic mechanics. I know I gained a lot by watching these little videos from Crash Course and PBS. I had the students watch them both, and we processed them afterward.

After this first video, the main mind-blowing concepts were: a) centrifugal force is kind of a “fake force”, it’s just the balancing force to centripetal force that pulls you inward, b) in a circular path, your velocity is tangent to the circle, and c) students knew that force could be described by the equation: F=ma, but after the video we talked about a special version of the formula that describes circular motion, F=mvÂ²/r.

Together we wrote, earlier in the unit, a basic computer program on Khan Academy that made a little planet orbit around a bigger sun using trig functions to find the x and y coordinates. Fun but not an accurate planetary model. I’m not sure if the computer program playback will work here, but here’s the basic model.

## animate

Made using: Khan Academy Computer Science

Since we had briefly learned about Kepler’s laws during our unit on ellipses, I told the kids I wanted the model to change so it actually modeled planetary motion – faster when close to the planet, slower when farther away, making an ellipse with the “sun” at one focus. And to do that, we’d have to learn a little about how planets exert force on each other and how that impacts their motion. So we watched the next video.

So from this video, we learned many more mind-blowing things. Among them, there is ANOTHER formula for force: F=GMm/rÂ². These formulas are all related to each other. We would now modify our computer simulation to show how they all work.

Ok so here are the basics of programming an animation. This structure is common to pretty much all game programming as well. You have setup code and then an animation loop, that runs over and over again. Most of the time, the animation loop runs around 60x per second.

In the setup code, we initialize all of our variables. In the animation loop, we’ll calculate all of the forces and accelerations and velocities and positions, and once everything is updated, we’ll re-draw the scene. You always re-draw the whole scene from the objects in the “back” (such as the background) to the objects in the “front” (such as the moving planets). For simplicity, my model doesn’t take into account the planet’s effect on the sun… just the sun’s effect on the planet.

Step 1: In the animation loop, draw the background and the sun. In the Khan Academy programming environment, (200,200) is the center of the canvas since the canvas is a 400×400 grid. This code places a circle, 40 pixels in diameter, right at the center. The fill() and background() commands are used for colors.

var draw = function() {

background(0,0,0); fill(164, 244, 245); ellipse(200,200,40,40); };

Step 2: In the setup code, create variables for the sun’s mass and the planet’s mass. I just told the kids to make up numbers, one a LOT bigger than the other, like 100 times bigger or more. I just made these up on the fly. The units are totally fake. Just have fun making up weird numbers.

var smass = 34782; var pmass = 7.2;

Step 3: We need to place a planet. We’ll create variables for the planet’s x and y positions and draw a smaller circle at that position. I recommended to the students that they place the planet so that it is directly above, below, or to the left or right of the sun. In other words, the x or y coordinate is the same as the sun’s, but the other coordinate is different. My planet starts out 170 pixels ABOVE the sun (because the y axis is upside down).

Setup code:

var px = 200; var py = 30;

Animation loop (at the end of the var draw function, before the last curly brace)

fill(153, 242, 126); ellipse(px, py, 10, 10);

Step 4: You’ll need to calculate how far away you are from the sun at any time in order to correctly calculate the force. So make a variable to store this distance, and then re-calculate the distance every frame. Normally you would use the distance formula, sqrt((x2 – x1)Â² + (y2 – y1)Â²)Â however Khan’s math library has a function called “dist” that simply takes the parameters x1, y1, x2, y2 and returns the distance between them.

Setup code:

`var pdist;`

Animation loop (before you draw the planet. I added a comment above this to show where we are doing all of the math)

```
//MATH
pdist = dist(px, py, 200, 200);
```

Step 5: Now we have *almost* all of the information needed to calculate the force on our planet. We know the masses of the two planets and we know how far away they are at any time. We do NOT know big G, our gravitational constant. For now we’re going to make up a number. It’ll be wildly wrong. We will fix it in a bit. We’ll calculate force using our wrong constant for now. The students enjoyed thinking about how when you create your own universe you get to decide things like how big the universal gravitational constant is.

Setup code:

```
var G = 10; // just make something up
var pforce;
```

Animation loop (after you calculate distance but before you draw the planet)

```
pforce = G * smass * pmass / (pdist * pdist);
```

Step 6: Now we need to explore the relationship between position, velocity, acceleration, and time. We already have variables for the planet’s x and y position. We will need to break velocity and acceleration down the same way. Velocity is how much the planet’s position changes with each time interval. Acceleration is how much the *velocity* changes with each time interval. If our object starts at the top of the circular path, it begins with a fairly large x-velocity and a zero y-velocity. As it moves around the circle clockwise, the x-velocity and y-velocity change so that by the time it gets around 90 degrees, the x-velocity has slowed to zero and the y-velocity is at a maximum. And the cycle repeats around the circle. A periodic function!

So after position is established we will give our planet a starting velocity. Since my planet started at the “top” of its circular path, I will give it an x-velocity but no y-velocity. A student that put their planet to the side would give their planet a y-velocity but no x-velocity.Â When you run this code now, you will see the planet move in a straight line tangent to its circular path. It follows Newton’s first law – no force, no change in velocity. Bye!

Setup code:

var vx = 4; var vy = 0;

Animation loop (put this code right before you draw the planet):

px = px + vx; py = py + vy;

Step 7: We need to calculate the acceleration in the x- and y- direction every frame. This is where the trig comes in. This step really consists of three substeps. First, we need to find the angle of rotation between the planet and sun. Second, we find the x- and y- components of the acceleration. Third, we add the acceleration to the velocity (remember acceleration is the change in velocity every frame). For the first substep, we can calculate the angle of rotation easily – the planet’s position is a certain y-distance and a certain x-distance away from the planet, so if we use inverse-tangent, we can find the angle. Khan’s math library has a function “atan2” that calculates an angle given the y-distance and x-distance. Note the sun is at (200,200) so that’s why those numbers are hard-coded. Substep 1:

Startup code:

`var ptheta;`

In animation loop:

`ptheta = atan2(200-py, 200-px);`

Substep 2. Calculate acceleration components. Here we use our original force formula: F = ma. We calculated force, we know mass, so acceleration is easy – just Force / mass. Then we have to multiply that acceleration times sin(theta) for the y-component and times cos(theta) for the x-component. These use the definitions of sin and cos as you relate them to a unit circle. The code!

Setup code:

var ax; var ay;

Animation Loop (after you calculate ptheta):

ax = (pforce / pmass) * cos(ptheta); ay = (pforce / pmass) * sin(ptheta);

Substep 3. This part is easy. Add the acceleration to the velocity every frame. Do this before you re-calculate position in the animation loop.

vx = vx + ax; vy = vy + ay;

You’ll run your code. The planet will either fly off into the unknown or crash into the sun. I encouraged the kids to play with the value of G, but sometimes the animation runs so quickly that it’s hard to even tell if you should dial up G or dial it down. So we had to come up with a better way to find a universal gravitational constant that would make our little solar system dance instead of fall apart.

Here’s where our other formulas for Force come in. For uniform circular motion, the centripetal force that keeps a body in a stable circular path is:Â F=mvÂ²/r.Â For planetary motion, the force affecting the planet and sun can be modeled as:Â F=GMm/rÂ².Â Â We know all of the variables in both equations EXCEPT a value for G that makes the orbit stable. So set one equal to the other and solve for G. I used some contrived numbers in my model and all of my students had different contrived numbers. Mine were:

M = 34782

m = 7.2

r = 170 (since my planet started at y = 30 and my sun was at y=200 and the x-coordinates were the same)

v = 4 (I just made up a velocity of 4 pixels per frame)

When I solved for G, I got a value of 0.078. So I modified my program and plugged in this value for G and guess what happened? Uniform circular motion and the feeling that I AM GOD of my own little universe.

You can make tiny changes to the planet’s initial velocity, for example change it to 2 instead of 4, and see the planet travel in an elliptical comet-like path instead of a circular path.

Here is the entire working program.

## PLANETS

Made using: Khan Academy Computer Science

When I taught this lesson, we went through the steps as a class just as I went through them in this blog, discussing them along the way. For a final product, the students will write an essay (!) describing their understanding of the physics of planetary motion. I will also give them a brief quiz. I have not yet written a rubric but will share it when I do.

I really enjoyed working on this little coding project and was so pleased that I could connect periodic functions and the physics of motion. If you make any modifications or try this with your students, please let me know.

# Trig and MLK Week Continued

Just blogging to report on my two big initiatives for the week: finishing up a mini-project on trigonometry using the micro:bit accelerometers, and a week on anti-racism in my sixth-grade advisory.

The mini-project finished up SO well. We started last week by assembling micro:bit inclinometers and programming them to report out the angle measured by using trig ratios. This week, we took measurements with them and did the math. The students measured the height of a neighboring building by standing exactly 800 centimeters away and sighting the roofline with their micro:bit devices. It’s been a cold week so we rushed inside to do the math, and the kids calculated a building height of around 39 feet. We probably got in the ballpark.

One commenter on my blog suggested we try another method, sighting an object from a distance, then backing up a known distance and taking another reading. This ended up being a cool application of a system of equations. Great suggestion!

Even though learning to solve systems of equations feels like drudgery at first, it’s one of the more useful algebra concepts I have learned. In my decade as an engineer, I modeled many situations involving systems.

The kids did a great job and seemed to enjoy the challenge of the activity.

The other day, I blogged about the very strange situation involving the Catholic school teens in DC mocking other protesters near the Lincoln Memorial. With the MLK holiday coinciding with that weekend, I really felt the need to do a lesson series on racism in my advisory class. They are sixth-graders, and I decided to survey them first – I’m glad I did. Only one of the kids had even heard of the incident with the protestors, which I found fascinating. What we perceive as going viral doesn’t reach all age groups equally. I decided to leave the incident off the lesson plan and focus on basic, age-appropriate lessons on racism.

We started with a few circle prompts about times they have ever seen someone treated unfairly because of their race, skin color, or religion. I asked them about their perceptions of bullying at our small school. Almost all the students feel that at our school, bullying is not really so much the issue. Some students can be rude or insensitive, but they understood the difference between rudeness and bullying.

I talked about how it’s healthy that in our lifetime, it’s not socially acceptable to be outwardly racist. People in our community tend to call each other out on it. Racism tends to take the shape of the many small ways in which your life is made a little easier or a little harder because of your race. We read through the list created by Peggy McIntosh in the Invisible Knapsack. Some of the students were able to chime in with ways in which privilege tends to show up at school – for example, if a girl hears “you’re pretty smart! Girls can be smart can’t they?” or if you get in trouble with the principal and a little voice makes you wonder if it’s because of the way you look.

Today, we started watching “A Class Divided“, the story of Jane Elliott’s brown eyes / blue eyes discrimination experiment in her third-grade classroom. The kids find it fascinating. It’s a very good and comprehensive introduction to what discrimination is and what it does to people. As a sixth-grade lesson, I think it’s a solid foundation to build on. I’m interested to debrief with the kids tomorrow to get their thoughts on it. By the end of class today, they were begging me to try the experiment at my school – to bring collars and let them try it. I think they’re intrigued at the idea of lording it over their classmates, but also wondering if the collars would make them the same nasty people that the third-graders became when they were empowered over their lower-class friends.

Jane Elliott is a nationally-known advocate for racism education now, and I told the students I have seen her do this experiment on adults and it’s still just as powerful. She can make adults cry. (I won’t show that video to the kids because there is swearing… but man!)

At some point, one of my students raised his hand and said “Donald Trump is racist.”Â I sat in it for a moment and then said “Yes. He is.” Other kids wanted to chime in. I allowed a few comments. I ended with “He says racist things. It’s not OK.” And I moved on. I have heard arguments that Trump says the things he says to provoke crowds, or build his “message”. If you say racist things to provoke or build your message… you are a racist. I would never allow one of my students to say the things the president says. That behavior needs to be named.

It’s not a ton of lessons, but the students have been engaged and receptive, and I think it got us off to a good start when it comes to understanding these themes.

# Trig and Physics and micro:bits

This year I am teaching pre-calculus for the first time, and I am committed to doing projects with my students as much as possible. Last semester we created a parabolic trough solar oven and made holiday cookies for students. This semester I decided to start with a unit on trigonometry, and I happened upon an interesting project via Twitter that showed someone sighting a distant object and using a micro:bit’s accelerometer to calculate tilt and thus how tall the object was. What a cool application of computing and trig. I decided to try and create the project for my class.

I decided to spend some time actually creating the thing. I started by attaching the micro:bit to a cardstock tube. The tube could be used to sight the top of a tree or building. We would try to keep the micro:bit on the same side and simply adjust the tilt until an object was sighted through the tube.

I played with different programming languages and decided to use Python, because it had a robust library of math functions. I started with a simple program to just fetch the accelerometer readings when you push a button.

I found that if the tube is held level, the “x” reading was close to 0, the “y” reading was close to a maximum of 1024, and the “z” was close to 0. If I held the tube pointing straight up (90 degrees), “x” was -1024 and “y” was close to 0. “z” remained close to 0.Â So as you tilt the micro:bit, the “x” accelerometer goes from 0 to -1024 while the “y” accelerometer mirrors it and goes from 1024 to 0.

I did a little searching to figure out how to convert accelerometer readings into an angle of inclination. There are a lot of different formulas out there – probably all correct. One source I found had a very simple equation:

So basically the angle of inclination is the inverse sine of the ratio of the “x” accelerometer to 1g.Â I had a hard time visualizing why the ratio x/1g would be equivalent to an opposite / hypotenuse, but it started to make sense when I realized the forces at work are really similar to the kinds of forces on an object that slides down an inclined plane.

In the diagram, the parallel force is analogous to the reading on the “x” accelerometer. The perpendicular force or “normal” force is analogous to the reading on the “y” accelerometer. Fgrav is basically 1024, the reading you get when there is a full 1g on an accelerometer.

This triangle is similar to the triangle made by the inclined plane. I made a little sketch that maybe shows this more clearly?

So basically the formula above, the simple inverse-sine operation, works because your angle of inclination is congruent to the angle opposite the “x” acceleration vector. You can find that angle by finding inverse-sine of “x” to “force of gravity”, 1024.

I wrote another Python program that did this math and reported out the angle, and it seems to be reasonably accurate.

Once you know the angle, if you know how far away you are from your object, its height can be found this way.

tan(theta) = height / distance

distance * tan(theta) = height

Easy peasy! This assumes you’re sighting from the ground. We may find we have to adjust for eye height. We can do that. Time to create the student-facing activity.

I put together this packet for the students. My class is super tiny so the kids can go through it as one group. For a larger class I would make groups and do lots of catch and release.

Here’s how it went.

______________________________

We watched the video on the biltmore stick. Students gave me hypotheses around why it worked, and we talked about potential sources of error.

I told the students that with modern technology, we should be able to make a decent height-finding tool. I introduced the micro:bits to them and told them about some of the features. They’re the first kids in my school to use the micro:bits, and they were ENCHANTED by them. You turn them on and they show messages and images, they play a game, and then they tell you to get coding. How fun! The students had a zillion questions about what else the micro:bits can do and how they worked. After the excitement faded just a little, we talked about accelerometers and how they worked, and the students started working through the packet.

I hoped they would be able to struggle through most of it up until they had to write their procedure in Python, but of course that isn’t how it went. We ran up against several big conceptual roadblocks.

- The idea of the x, y, and z-axis accelerometers BLEW THEIR MINDS. It was really tough to visualize which axis was which, and the students twisted and turned the micro:bits every which way. They had a very tough time being systematic about turning the micro:bit on just one axis to narrow down which accelerometers were changing. I hoped they would be able to sort out which axis was which on their own. They could not, and they got frustrated really quickly. I broke down. I just told them which axis was which and what the max and min values were. I have to admit this has been a struggle for me as well. Visualizing the three accelerometers is a challenge and I probably would have felt the same way in this activity.
- The accelerometers are really sensitive. One moment you set the micro:bit level and get a reading of 0. Another moment the micro:bit seems to be in the same position but your reading is -92. Another moment it’s 16. The text scrolls slowly so you don’t really appreciate what those readings look like in the moment. It was hard, then, to ferret out what the max and min values were. They floated around.
- I really thought with their geometry background the students would visualize the similar triangles really quickly. They did not. Looking back, I remember feeling frustrated and like my mind was a little blown when I learned about forces on an inclined plane. So I should have been ready for this. But the whole idea that a force of 1g directed toward the ground could be broken up into the x and y components on the accelerometers, and that they didn’t add up but rather made legs of a right triangle… WHOA. There was yelling. There was almost crying. Emotions were high. Eventually they did seem to understand but I am going to have to do some good formative assessment next class to see what they actually got.

I have a TINY class, only 5 students, and so the yelling and the emotion was totally manageable, but I am SO glad I did not go through this with a bigger class. I would have done a lot more pre-work on gravity, inclined plane forces, and similar triangles.

Today, after all of our drama, the students wrote programs to calculate the angle of inclination and strapped the micro:bits to paper tubes. Next class, we’ll go outside and take measurements. One of my students found an alternate method of measuring the angle that was something similar to this.

It seems to use a distance-formula calculation instead of the force of gravity and it’s interesting how it uses all three axes. I’ll let her try it and see if her results are similar.

I’ll take some pictures of the results of the experiment and hope I get to do this again with a future group! I feel like with better pedagogy this would be a really great activity!

# Micro:Bit Curriculum

This spring, I tried something I’ve never done before – I tried my hand at curriculum writing! I had a great opportunity to work with Launch CS to create a 10-lesson curriculum for the BBC micro:bit. It’s not perfect, no product ever is, but I did end up happy with what came out of the effort. The package is aligned to CSTA standards and covers a variety of them in ways that are not typical of most coding curricula. There are a ton of lesson packages out there that introduce algorithms and programming, and I did include these but also worked to introduce networking, data, and the design cycle. The curriculum is intended for students in grades 5-8.

The highlights are:

- Events, Variables, Conditionals, and Looping (via mini-projects and pair programming using the micro:bit)
- Data modeling and analysis using micro:bit, electronics, and spreadsheets
- Networking using videos, a computer and the micro:bit radio feature
- Design Cycle via a micro:bit “Shark Tank” style project

The curriculum can be downloaded for free here, or on the micro:bit teaching resources page.Â I’m excited to see people using it and hope you find it useful and fun for your students!

I would have loved to see teachers at the CSTA conference, but alas, duties for my new job interfered this year. It’s on my bucket list to attendÂ – hopefully next year.

Until then let me know if the micro:bit resources are helpful!

Edited later because I neglected to give credit where credit is due. Grant Smith and Cheri Bortleson are amazing to work with – they gave thoughtful feedback and edits, and they formatted the curriculum beautifully with lovely graphics and a consistent theme. I can share this proudly because they did such a nice job with the vision and final project! Thank you Grant, Cheri and LaunchCS!

# The Computer Take-Apart (revisited).

A few years ago, I wrote this post about my struggles to have middle-schoolers do a computer take-apart and meet the high expectations I had in mind for them. I am happy to report I didn’t quit doing computer take-aparts. I did try to learn from those hard lessons and continue improving on it. Hardware Week now runs pretty smoothly and kids report it’s their favorite unit. I do this set of lessons in my 7th/8th grade Computer Science Explorations class. It’s a great one for the week right before spring break, or whenever you need a little something different to mix things up.

Prior to the lesson, I ask parents if they have any old computers they have been wanting to get rid of but didn’t want to hassle with recycling them. I have a small budget I can use for hardware recycling, so I have workplace services come and take the computers away for recycling when the take-apart is done. I accept laptops as well as desktops, and it’s fun when I have a mix of both. I stock up on tools, especially small phillips screwdrivers, flathead screwdrivers, a few small Torx screwdrivers, some pliers and a few wire cutters.

First, we learn about the basic structure of computers (I also relate this structure to micro:bits, since my CS students learn to program them in Python). We do several card sorts in which I give students a sheet with pictures and descriptions of computer hardware, and they have to sort them into categories: input, output, processing, storage. Sometimes I include Power in one of the categories. Although pieces of hardware like the battery and fan don’t have anything to do with the flow of information, they are visible inside a computer and really important to its operation. You can find the card sort at the link below!

Lesson1Activity1wIllustrations

Next, I have the students watch a movie and fill out an organizer with it. The movie is wonderful – it’s called Lifting the Lid and although it’s from the early 2000’s, the information is still relevant and it’s very entertaining and informative. The movie is expensive to buy, but I was able to reserve it from our public library. I had to get it from Prospector as it was at a local university.

Here’s the link for the movie. The instructor’s guide, linked on the same page, is the organizer I used. I circled the most important questions for the students to fill out, and paused the movie at certain points to work with the kids on filling out the organizer.

We then have a quick safety and procedure talk about the computer take-apart. I have learned to keep the rules really short and simple.

- If you have a laptop, take the battery out first and bring it directly to me. Don’t take anything else apart until the battery is out.
- Wash your hands well afterward to avoid getting lead in your eyes, nose, and mouth.
- Do not break any screens.
- Many computers are meant to be taken apart. Look for the places where the computer has seams, screws, levers or tabs.
- As you remove pieces, label them. Each group will get a sheet of labels and some tape. Sometimes you may find more than one piece in a category.

I give each group a sheet with labels of computer parts, plus a couple of blank labels in case they find things that aren’t on the originals.

I circulate around as the groups are taking their computers apart and help them identify parts as they remove them. Sometimes they’re tricky even for me! When opening laptops, sometimes the easiest way to access the motherboard is to take the keyboard apart and come in through the top – which of course kids love and requires a little extra time cleaning up at the end because keys get all over the floor.

When the computers are dissected, we begin a group show -and- tell for their computers. I put prompts up on the board and ask groups to hold up a part that matches the prompt. We go around the room and every group explains what they’re holding. They rotate group members for each part. Example prompts:

- Hold up something that stores data.
- Hold up your CPU.
- Hold up something that is for input.
- Hold up something that is for output.
- Hold up something that’s used for cooling your computer.
- Hold up something used to power the computer.
- Hold up something used to connect to a network.
- Hold up the motherboard.

At the end, I do allow kids to take home a souvenir as long as it’s not a hard drive, solid-state drive, or a battery. I keep those and make sure they get recycled properly. We spend quite a bit of time placing parts in big moving boxes, which I tape up and label for recycling.

I could do a formal assessment. I choose not to. The show-and-tell is a helpful wrap-up and taking a computer part home is something the kids really enjoy as a reward for cleaning up well. I had a student tell me the other day that he took his motherboard home, set it in a frame, filled it with resin and hung it on a wall!

It has ended up being a fun set of lessons that are also great for learning. I’m glad I didn’t give up on it.

# Looking back and looking ahead to 2018

The start of a new calendar year is a traditional time of reflection and anticipation. I’ve been an inconsistent blogger this year, which wasn’t intentional, but if I had to clear some things off my plate, this was an easy sacrifice. It’s been a full year. Along with constantly learning and changing in my job, I have two daughters who are in 9th and 5th grade and a busy husband too. When my children were little, I thought to myself “It will be so nice when they’re older. They won’t need us as much!” While it’s true that we can leave the house without calling a babysitter now, it is NOT true that your kids need you less. They need you more! You need to be more present, for everything from driving to emotional support to helping them make sense of the world. It’s been a joy being with the girls as they grow into interesting, independent people – but it definitely keeps you moving.

The job has been interesting as well. I don’t always know what to expect next, but here are some highlights from 2017 and what I expect from 2018.

**The CS for All and #csk8 movement.**

“Coding” is gaining more traction in my suburban public school district, and this year for the first time we started some high level discussions on how to introduce computer science as a core subject for every learner. Several colleagues and I have been working on suggested paths for a K-12 computer science sequence.Â We are looking for sites to pilot ideas over the next couple of years and investigating grants for professional development offered by Colorado’s Department of Education. It feels like a painfully slow process, but there is definite progress here and I’m excited to see where it goes.**micro:bits**.

I started using these cute little devices in both my required 6th-grade class and in the elective upper-middle-school class. The younger kids learned cs concepts using the block-based MakeCode environment, and the older kids learned using the text-based Python environment. It’s such an interesting tradeoff. I didn’t feel that we covered as much material as I had in previous years, but I perceived that the kids were VERY engaged in their learning and took their learning in divergent paths. Introducing the micro:bits meant that some kids did not learn as much about coding structures such as variables and boolean expressions. But they learned more about the design cycle, and got really excited about testing and iteration. They generated questions themselves like “will it still work if I’m on the opposite side of the room? Will it work if I push the buttons at the same time? Will it work if I shake and push at the same time?” And then they answered their own questions and improved on their designs, on their own. I love the excitement. I want to keep that. And I also want the kids to be well prepared for high school work and to understand important concepts in computer programming, so having it both ways is hard!**Virtual Reality**.

I have a nice gaming system with an Oculus Rift controller in my classroom, and we have a variety of VR devices in the media center. Kids have access to technology at school that they don’t necessarily have at home, and so it gives them something exciting to use at school that they are very curious about. I’ve integrated a VR unit in my upper-level CS class, and our building tech coordinator and I teach a quarterly enrichment class called VR Exploration. We work with the kids to make 3-D models in Blender and little exploration worlds in Unity. We’ve had a few students that have gone above and beyond with their work in VR and that’s been fun to see. Toward the end of this semester, we received a $5000 grant to expand our VR program and so now we’re faced with the question of: how do we grow the program? We have some thinking to do about how we make this a more inclusive and interesting and cross-disciplinary experience for kids.**Engineering for Others**.

Our media specialist runs a pretty awesome after-school program called**Engineering Brightness**, and I love the premise of engineering with a purpose – to help others and to help students have empathy for the human experience. I’ve been working on the technical side of the program for quite some time and incorporated a lot of the engineering ideas into my Electronics elective, and this semester for the first time we were able to produce some finished products and send solar lights out to residents of Puerto Rico who were still living without electricity. It was a fantastic experience and I definitely hope to keep the project and improve on it this coming semester.Those are the main things cooking for 2018! What’s coming up for you?

## Recent Comments