Wednesday, February 5, 2020

Mentally Prepping Students for Exams

When it comes to high-stakes assessments, I feel the biggest part of my job is to prepare my students mentally, as opposed to mathematically. I know, there's a lot of overlap, in fact it probably is mostly overlap. But I think that without that affective aspect of preparation, it really doesn't matter how good they are at mathing.

It's stressful writing these things, and the biggest stress-busting window of opportunity is only open before the exam. As in sportsball games, a great deal of the result is really determined during practice and preparation. Since I teach high school students, that part is my job too. It's not enough that I do a good job teaching stuff, or that I spend a period or two reviewing stuff - I have to accompany them on their mental preparation as well.

What I want to do BEFORE the exam is to actively, in a structured and gradually empowering way, help them:
  • practice retrieving information
  • organize all that math info in their minds to enable retrieval
  • know what to expect on the day of the exam
  • become fluid with certain types of questions that are likely to be on the exam (note -  if I'm the author of the exam I probably give a lot away here - if anyone's paying attention it can pay off for them big time)
  • try questions that they've never seen before but for which they nevertheless have all the tools they need
  • come up with strategies to handle questions like the aforementioned
  • practice pacing themselves
  • develop independence and confidence
There are, of course, some kids who don't need me to do this, who always do well and don't even need to spend much time studying, but my instincts, and my results, tell me that those students are in the minority. Most either don't know how to digest and use large amounts of info, or aren't motivated to spend the time preparing. They're my students too, and I refuse to simply shrug my shoulders and write them off as not having what it takes. If it's motivation they're lacking, that's also my job.

And if there are students whose only preparation takes place during class with me, I at least want to make sure that time counts for SOMETHING.

What I did this year: Outside of class

Review VoiceThreads: Review started outside of class. I didn't want to spend class time going over the basics, so for that I made review VoiceThreads. Here's a sample for the optimization unit.

These asynchronous reviews covered the procedures, examples, vocabulary, notation, and summarized all the stuff they've seen before, which is theoretically already in their notes. Some kids will have already looked that over, or won't even need to, but again, they're in the minority, so for the rest, I do this. This way, the kids who are ready to practice don't have to sit and listen to me blather endlessly during class, but the kids who need the refresher have it there. Do they all do it? Nope. But it's there for those who are motivated and who need it. Am I doing too much? That's another blog post. Also no. These are kids and this is a hard course.

Sidenote: For the reviews on functions, my voicethreads gradually form a sequence as the year goes on, because I keep adding to each one as we study new functions. I use a structure I call the Wheel of Functions. Here's the most recent one, with 4 functions in it:

It's a kind of scaffolding that I think makes it easier to see connections, to get the big picture, and compare the properties of different functions. This hits the organizing of large amounts of info, which helps with the retrieval practice.

Review Packages: It's not enough to consume of course - math is about doing, so the next thing they get is review packages, which are made up of actual exam questions. I realize this is what most people do. (Organizing a decade or so of these questions and keeping track of which ones I've used...that's a whole other thing...) These are to be handed in, so everyone has to at least try these questions. I give a mark, but it's based on 3 things only: Handing it in on time, trying every question, and showing all reasoning for each question. So even if you're not ready to correctly do these questions, you can get a good "mark" because you're starting to prepare yourself. Does everyone do this? Pretty much. It's either a wake-up call to start working (in a shock-therapy kind of way) or it's a good indication of where to focus one's attention. At the very least it hits the knowing-what-to-expect benchmark.

During class: Snappers, Zingers, and Deep Dives

A combination of quick-to-answer and not-so-quick questions that everybody gets to try:

Snappers: You have to walk before you can run. I start a class with 4-5 easy questions (Eg which function needs 2 templates OR Simplify the rule y = 10 + 3^2x OR write this as a constraint) that they can answer in 1-2 minutes, then send me their answer by private message, and if they don't know the answer, then that's what they pm me. Once I've heard from all, we immediately go over it, then if needed we do another one just like it, immediately. End result: retrieval practice, exposure to the very least of what's expected, motivation - they are super motivated and capable to get it right the second time, encouragement, practice with pacing, also sets up next day's review. Also - hopefully this causes some to take to those review voicethreads if they haven't already!

Zingers: When it's closer to exam time, fewer questions. Same structure as snappers but these take a little more time. These questions may just take longer because there are more steps, or they may use some of the ideas we went over in the snappers. Again, if needed, do another one right away. End results: Exposure to next level, more pacing practice, more fluidity, also communicates subtly that maybe they should pay attention to the exact things I'm reviewing now because there's probably a good reason I'm focusing on it...

Deeper dive: These I weave in between the snappers and the zingers.This is where we really get into it:
  1. Revealing hidden layers - like that fact that in this course, we end up solving systems of equations very often, even though it's not actually part of the course. We solve a system to:
    • express a vector as a linear combination of other vectors
    • to find two missing parameters of a function
    • to find the coordinates of the vertices of a polygon of constraints. It's everywhere.
  2. Reviewing certain types of multi-step questions that typically show up, like piecewise functions. We took another look at actual test questions that they've already done, along with the full solutions, and if time, give them another one to try right then and there.
  3. Trying those questions they've never seen before, and for which they have all the tools
  4. Going over strategies to deal with those questions they've never seen before, to identify the tools they need to mobilize
Overall: Variety Really Matters

I try really hard to fit as much variety in the voicethreads, review packages, snappers, zingers, and deep dives as possible so that by the time the exam happens, their brains have truly been stretched and warmed up for the race. Those that did it all are really ready, and those that did only the minimum have at least a chance.

Today they wrote their exam, and tomorrow they write the second.

Fingers fervently crossed.

Exponent Mindfulness

In preparation for our exponential/logarithmic function unit, I decided to try something I called  Exponent Mindfulness. Mindfulness because that's an initiative the team I work with has been working on, and exponents because being able to not only evaluate expressions involving them, but recognising numbers as powers, is the key to this whole unit. After all, working exponents out backwards is what logs are all about.

First we spent a week on Exponent Boot Camp, in which I review WHAT the exponent properties are, and also WHY they are, including negative exponents, rational exponents, and rational bases with positive and negative exponents. That covered the first part - evaluating expressions with all kinds of bases and exponents.

On this day, however, it was all about going the other way, developing those exponent lenses. After warming up with a few evaluation examples, I put 16 on the board and asked how can we write this number as a power? The answers I got were as expected:

Then I asked - that's it right? No other possibilities? Waited and asked about the possibility of a negative exponent. Here's where things got interesting. Even though everyone was fine moments ago with how to figure out a fraction to a negative exponent, the idea that you can get 16 from a negative exponent suddenly seemed to be mind bending. (It's always more fun to give your students the answer and ask them to come up with the question.)

Anyway, so I showed them this:

We spent a few minutes working out each of these, just to re-convince everyone that these were in fact all equal to 16.

Back to 16, and I asked again, "That's it now, right? No other possibilities?"

My students know me well enough to know that answer to that. So we moved on to rational exponents:
I got a few really great answers added here, like 65536^(1/4) and 1048576^(1/5).

Me: So that's it right?
Students: Nope, that's never it is it?

So now that we all knew that there were in fact infinitely many ways to express a number as a power,  I asked everyone to write a power on the board that equals 81, specifying that you can't use one that's already there. That went really well. Definitely you should do this again next year Future Audrey.

Tuesday, October 8, 2019

Marrying Zoom to VNPS

I've been very keen to adapt Peter Liljedahl's vnps to my live online classroom (which is in Zoom), and I've come up against a lot of obstacles, but today it felt like it's finally taking hold.

The fantasy, or the ideal situation for a vnps class session (which I experienced and fell hard for at OAME 2019):

  • The students are put into random groups of 3 and stationed at whiteboards around the room.
  • The teacher gives each group of 3 one problem to work out on the whiteboard.
  • Only one person in each group writes on the whiteboard, and does not speak, and the other 2 speak and do not write.
  • Once they're done, they call the teacher over, who gives feedback and another question for them to do, but this time the roles shift.
The benefits are astounding, and for a much more complete list see Peter Liljedahl's or anyone's writing about #vnps (vertical non-permanent surfaces). For example, students feel safe in their group because it doesn't fall on any single person to know what to do. They also feel safe within the room due to the low-level hum of talkers talking, which is somewhat noisy but not chaotic. They're more physically active than if they were working things out sitting down. The nature of the whiteboards and pens makes it easy to write/discuss/change their minds about what to do. The teacher can see all of them quickly and deliver just-in-time feedback.

The reality of my online environment:

I meet my students at the same time everyday, but not in the same physical space as any of them. They're scattered all over Quebec, mostly in the computer rooms of their schools, most of which are in somewhat remote parts of the province. Some of them are completely alone in their school when they're with me, and some of them are with other students at their school. Others are home schooled.

Anyway, in my Zoom setting, there are BIG challenges to this. Not all of the students are in the same room with other students. Even if they are, they have to leave their computer (and hence the Zoom room) to go to the whiteboard in their actual room, so we might not be able to see/hear each other anymore. And how do I see their work and give feedback?

At first I had to check with all the schools to see if everyone had access to a whiteboard. Most but not all did. Then I had to think of how they'll show me their work. I had thought of Rocketbook or Twitter dm, but today the answer turned out to be SO MUCH easier. They just turned on their webcams and aimed them at their whiteboards!

I cannot express how exciting it was to see my students gathered around the problem, talking, erasing, checking back with me. I know f2f teachers are probably thinking - we call that Tuesday. Or everyday.

There is still an issue with communication between me and them when they're at the board - at one school all the students could keep their headsets on while at the board, but others couldn't.

At any rate, for those students who are not alone in their school, who do have a whiteboard and webcam, things are moving. Next - to find the closest approximation for students who are alone in their setting and/or don't have access to a whiteboard or a webcam. For now, they've been using the Zoom whiteboard, which means struggling to write legibly with the pen tool, typing their wonderful math thoughts in the chat tool, all the while sitting in front of a computer screen - in other words getting virtually none of the benefit.

But this was a truly awesome start.

Tuesday, August 13, 2019

Day 11: More Diagramming

I had my first meeting yesterday with the wonderful Mr. Chow, and holy wow you guys you need to talk to Jay. Not only did he answer my questions, and fix things that needed fixing (in my head and in my CL) but he helped me move ahead in my diagramming - this is not to say that what you're about to see is officially sanctioned by him, only that he gave some encouragement on an idea I had. If there is a mistake in it (which I already know there is) it's mine.

So here's where I am now in my diagramming. I've added the possible data types that could fill the first and last fields in a script. Since those possible data types depend on which component is involved, I've made a slideshow, with each slide corresponding to a specific type of component, eg note, input, or graph. The possibilities for the source data type of an input component are not the same as those for a graph, for example.

This is meant to help get a sense of how the CL is structured, but not go into much detail (yet) about what individual terms like "initialLatex"mean. For example, I don't yet know what "initialLatex" actually does, only that it's something that would go into the field I've labelled "Sink Data Type", so that tells me it's something to do with a component into which something is being injected. (Maybe it's something that is to be displayed in an input to prompt students? No idea.) This at least helps me not get overwhelmed when I'm reading someone else's script.

The mistake is in the "To put a script into the gearbox of" part. I'd previously felt pretty sure that the script always goes into the gearbox of whatever component is the sink. But, for example, in the cardsort (last slide), according to this sample from Jocelyn's collection, the script is in the gearbox of the actual title of the screen. So I need to think on that for a bit. Also I need to add "title" as a component.

Also, I haven't worked in yet how to show that once you've selected a certain data type for your sink, your choices for the source data type are further filtered down, because they must match. For example, if your sink data type is "number", your source data type can't be "content", but it could be "numericValue". 

Day 10: First Attempt at a How-To-Computation-Layer Diagram

I created and shared my first attempt at a CL diagram on twitter, and Jay Chow (thank heaven for Jay Chow y'all) replied:
It turns out that it's not quite accurate to say that third example defines a variable. I had misinterpreted this example from the CL doc:

I had thought that the variable m was being defined in this line, but after checking out the "try it" I realized that m had been defined within the graph, so it wasn't accurate to say that it was defined right here.

So for now I'm sticking with the ones that I know are good:

So now....I tried making up random CL things to see if they worked. Got something to work yay! I'm still not sure of when we need variables and when we don't but I think for now I'll just assume we always do and keep defining them. They need to be defined in the same place as the script that's referring to them. It's still in draft mode but here is where I'm playing around.

Monday, August 5, 2019

Day 9: Maybe I Should Just Stick to Dragging and Dropping

I'm still watching the first of Jay chow's webinars. One thing I know for sure is that having the ability to pause & re-watch is huge. (Hello flipclass.)

I'm trying to get my head around that example on screen 16:

It's easy enough to get it to automatically graph whatever rule the student types in, but I wonder:

How could I get it to only graph once the submit button is pressed? It doesn't seem to fit the When-otherwise scenario. Taking Jay's advice on writing it out in english first: When input2 is submitted then inject input2 into the graph otherwise do nothing. For the do nothing - just make the otherwise part "Type in the equation of the line that goes through these points."  I tried typing "when" and seeing what the error code told me. It said it was expecting otherwise, but then when I put that in it said it wasn't expecting that...

Went back to trying exactly what Jay was doing with the T variable, and I got it to work. Unpacking the whole variable idea again. We needed T in the graph so that as it increased in value (which is done by moving the T slider to the right), the domain of the function f being graphed got wider, so the curve appears slowly from left to right. Clear, very clear. And we needed to connect that T value with the CL by calling a variable by the same name, so that however much that variable T is in the CL, that's how much T in the graph is. So in effect, changing the value of the variable T is equivalent to moving the T slider. And if we want to increase the value of the T variable in the CL, we make it equal to the number of seconds since the submit button was pressed. Got it.

Tracing the path of T - it starts having a value on submit, which gets sent to the graph, then overrides the value of T on the slider.

Jay says: "The basic structure of CL is we create something (the sink) FROM something (the source)."  This is a good way to think of it.

Screen 20: Noticing something that has happened before. I am certain I've typed exactly what Jay typed but I'm getting these brackets (I've highlighted in grey) immediately after the timeSincePress

It doesn't seem to be a problem though, and the error was due to me mistyping timeSincePressed - shouldn't have had the -ed at the end.

I tried to make the second "when" include the current coordinates but it didn't work. Sigh.

Back to Jocelyn's collection. I'm going through it again from the beginning, one by one, to see if I can recreate them.

On example 2, the correct script was simpleFunction(table1.cellContent(1,2),"x") which also works without the x at the end. But I don't get why we don't have to put .latex anywhere like we did for example 1. The only difference between this one and example 1 was that there are 3 functions to type instead of 1, so we're using a table this time.

Maybe it IS better if I just drag and drop other peoples' stuff....

Friday, August 2, 2019


Next, I'm going to look at Jay Chow's Webinar 1 and the accompanying Desmos activities. Audrey's on a roll, baby!

I've decided that, for now, I'll abandon my so-far strategy of looking at the DA in preview mode and trying to unpack the CL before peeking at it, and instead I'm going to just watch Jay's webinar and let him unroll these things. He's a really great CL-er and he's made a lot of webinars, so he knows what he's doing.

Comment on how he is doing the webinar: First there are some screens for us to interact with, after which I see that Jay is using the screens of a DA as a presentation in and of itself - he's sharing his screen (and of course he has turned on the Anonymizer to make a safe environment), and clicking through the DA screens. I like that. Imma do that!

Screens 1-4:
We are asked to input something and nothing happens as a result. I think I see where this is going. 

At 9:38, Jay makes the case for using CL by contrasting activities without CL and with CL. (we just did 4 screens without and immediately felt the need for CL - Also this reminds me of how Christopher Danielson (@trianglemancsd) presented CL last year at the Desmos Fellows weekend (cohort 3). He said - I'm going to make you unhappy, then I'll show you something that will make you happy.)

When your students type in the input it's a static entity
Action buttons don't work
Things don't work together

The first example we are trying to add CL to is one in which we want the student to input an expression that evaluates to 4, hit the submit button, then get feedback. The feedback will depend on whether or not it's correct.

Around screen 14, I see Jay using the snapshots feature, also while he is sharing his screen. I've never used that feature, so it's nice to see it in action.

Aha at 25:01 I was wondering why the input expression hadn't been evaluating as it usually does - because it's been disabled with the built-in disableEvaluation, behind the input component. The full script is disableEvaluation: true. And that's why the gearbox for the input component is green, that's the script in there.

37:35 I see the effect of the ${} - it turns static text into dynamic text. No variable needed. Jay recommends we write out in english what we want to do BEFORE we write any script. Very good idea.

Next example screen 16: Students see a graph with 2 points on it and they are to type the equation of a line that goes through those two points, submit, and get feedback.

At around 47:00 Jay is using someone's suggestion to do two things - put the typed equation into the expresion list on the graph, and then graph it. I thought that as soon as an equation is in the expression list, it's automatically graphed? Why do we need to ask it to graph it? This turns out to be that we want the graph to be revealed slowly, as a result of additional interaction from the student. See "Whoah" below.

Also, I see a lot of auto-complete happening as letters are typed - very helpful.

To make a function, use the built-in function thingy? In the graph gear, the sink is indeed function: ("f") but the name f has already been typed into one of the graph boxes. Needed to label the input and use latex as source type.

At 52:04 script at this point is
function("f"): input2.latex
but there is an error message:
Sink "function" expects a function but got a string.
So input2 is currently being interpreted as a string, even though the source data type is latex. I'm not sure why that is happening. But based on examples I've seen from Jocelyn's collection, I bet it needs simpleFunction maybe? Yup.

Now it's:
function("f"): simpleFunction(input2.latex)
Jay: "I'm gonna make that function from the this case it's gonna look for x"

So I'm noticing a new level here - in input2.latex, we still have the syntax sourcelabel.sourcedatatype but it's in brackets that go with the built-in function called simpleFunction. And we need this built-in because otherwise the source (called input2, which remember is the equation typed in by the student) will be interpreted as a string (text), and the graph sink doesn't accept that type of data.

This made me go back to the CL doc and look up Graph. Question - what do the subheadings "Sources" and "Sinks" mean here? That these are all the types possible when the graph is a source? Or all the types possible for the graph's sources when the graph is a sink? 

Back to Jay. Next step is to stop it from graphing until submit has been clicked, so we'll need to use that input2.submitted thing. Last time we used that, it was part of a when-otherwise structure.


So it's not at all like last time. It's that as soon as the student clicks submit, the curve is slowly revealed as the seconds tick by. To do this:
1. A variable T (for time) had to be introduced into the graph, and its values restricted to x < T , which means that as you move the T slider, the graph is slowly revealed from left to right. (This was later tweaked to x < T - 10 to make the graph start showing at -10 instead of starting at the origin.)
2. To link the CL to the T in the graph, a variable T had to be defined in the CL. The variable was defined in one of the familiar ways like this:
number("T"): timeSinceSubmit 
which kind of makes the submit button a source for the variable T. As soon as that button is pressed, a timer is started at 0, so there's now a variable T whose value is 0, and as the timer continues, the value of T increases. This makes the line start graphing on the left, and slowly be completed. So a student doesn't know right away if they're right, but they can pretty much predict, and even change their answer if they want.

I HAVE BEEN WONDERING WHAT THE HECK THAT TIME-SINCE-SUBMIT WAS ALL ABOUT FOR OVER A YEAR!!! It makes animation happen as soon as a student clicks the submit button wut!!!

Stopping at 58:00 because I need to step outside and look at how this learning has unfolded so far. My ultimate goal is to help others learn this, so I need to figure out what worked for me.

How I’ve learned so far:

Read, looked at examples, re-read, tried things, and re-re-read, all the while documenting observations and questions on my blog. Some of the questions got answered in the same day, in which case I wrote the answer in italics next to the question. Those that didn’t, I bolded (thanks for that idea @geonz.) Some of those bolded questions I remembered on later days and went back and answered, but others I picked up later after deliberately re-reading my posts. The bigger ones, I just put a note on “answered in later post” and put that whole thing in a subsequent post.

Next I watched Jay Chow's webinar. As I watched, many questions were answered, (what are ${} for ? – it changes something from static text to dynamic text, just like objects in GeoGebra) and many observations were confirmed (when you select latex in an input it automatically displays the math expression properly and evaluates it without any need for CL – also found out how to turn it off!).

But here's what I noticed about how I learn:

I needed to have already asked those questions or observed those things in order for them to have meaning for me as I watched the webinar.

That probably makes me...human.