I laughed so hard that bacon came out my nose.

I then drew a struggle bus.

A student then scanned it into Illustrator and put our class motto on it.

T-shirts were then made and worn regularly.

Click for pdf. You may need to download if your browser doesn’t support certain web fonts.

]]> http://shawncornally.com/wordpress/?feed=rss2&p=3765 4 http://shawncornally.com/wordpress/?p=3763 http://shawncornally.com/wordpress/?p=3763#comments Wed, 15 May 2013 15:52:58 +0000 Shawn Cornally http://shawncornally.com/wordpress/?p=3763 You administer a valid summative exam. It had every standard on it with an even keel attempt at assessing the student’s ability.

The student gets a 18/28.

The student is immediately driven into the depths of despair over their ‘D’

You then tell them the test has been curved down to 22-points.

The student is now happy with their ‘B’ and never asks another question about the course material again.

You ask me what crazy looks like, and I’ll tell you this story every time.

I’m not sure how much more blunt I can be about the conditioning we’ve got going on here with our most advanced students.

That’s in fact my entire job over there, and what a sweet job it is: Find problems that Iowa’s teachers are dealing with; fix them.

Sooooo, we’d like to invite any of you who are so inclined to hang out in St. Joeseph, MO June 20 & 21 of 2013. The event has been postponed; we’ll be running smaller events locally during the school year next year. We’ll be hosted by the ineffable Sean Nash as we tear up the greater Kansas City area. And by “tear up” I suppose I mean “talk about how to teach trig identities in a way that doesn’t totally suck.”

What is bacon-wrapped lessons? It’s a 2-day collaboration extravaganza! You know how you just want to sit down and talk through with other teachers how to best introduce the reproductive system (or protein synthesis, or arrays, or whatever)? Well, THAT’S WHAT THIS IS. Except with kick ass instructional coaches, and food, and bacon, and beer, and a website that collects all the lessons so everyone can use them later!

Win win win win win!

Attend!

I try to be honest with my students. When I hear their lamentations of the meaninglessness of their experiences in school, I admit the parallels between school and prison. They’re quick to say, “You get it!”

That said, I’m in year 2 of hopefully more than that in my teaching career. And, at this stage, I’m still waging the battle from quantity of courses to quality of content.

Today a huge chunk of my physics students were absent. Students started asking for another shark tank. We’ve had a couple of these opportunities for my students explicitly direct the curriculum this semester. They help me provide meaningful learning experiences. So I can dig that.

So I started listing the themes I’m hoping we’ll get to learning about in the remaining 3 weeks before our seniors high-tail it out of here. [You know: particle/nuclear physics, quantum mechanics, relativity, waves and oscillators.]

If I had to guess, students’ minds were sparking ideas and questions as I was listing these topics. But passivity is bred in learners early on; it dies hard. Curiosity is quenched early on; it’s hard to rekindle.

But then I didn’t know what to say. So I went ahead with giving notes on finding equivalent resistance. AND doing sample problems on the board. ::facepalm::

I suppose all we needed was boat loads of wait time, and a facilitated brainstorming session on what projects to try. How do you help students use their voice in class? I think part of the solution is to run with their ideas. [Speaking of that, ask me in two weeks about a students' recreation of Young's double slit experiment.]

What do you do with your students to make awkward days meaningful? What gives you the determination to let students lead the learning?

A discussion of what it means to be exponential (which colloquially is beyond misunderstood and bordering on abused) led to a discussion of what it means to grow because you’re growing.

Does gravity work this way? They asked. Thankfully not. You don’t fall faster because you’re getting faster (that’d be some free energy). You certainly do gain speed, but it’s not exponentially gaining.

“So what does?” I asked. “Money!” They all say, because that’s the only example anyone can ever think of.

Until that awesome kid in the back of the room says, “Chicken Wings!”

What?

Oh, right. Because the more wings you eat, the slower you go. Like:

We added the coefficient (b) on the -t later, because at first it’s not motivated, unless someone brings up the fact that [wings/minute] can’t be equal to [wings], but, hey, don’t be that guy–at first.

This of course quickly devolved into thinking of other foods that have this same dying exponential behavior.

We postulated that Ghost Chiles would behave the same way, which of course ended up with Ghost Chile salsa making an appearance the next day.¹

Finally, this ends up exactly where you’d expect it to end up:

MAN v. FOOD

The most ridiculous crapulent fall-of-the-empire-esque differential-equation-y show on the TV!

The students pulled a bunch of episodes off Youtube, because Travel Channel’s MvF website really sucks,² and we got to work analyzing which challenges behaved according to what exponential behavior.

The best one we found was Memphis’ Sasquatch Burger:

Have fun with that.

The students graphed his completion as a function of time. They then fit a natural exponential function to it and worked back for the parameters on the diff eq.

We talked heavily about the units on the coefficients in the equations, which was awesome, because it turns out that students rarely work with anything but super-science-y units. ([burger] and [Hz] don’t often go together)

What’s most valuable to me is that the students created math where once there was none.

They’re getting practice being analytical in situations where they shouldn’t need to, but can, elucidating things that weren’t known before. That’s what math is, it’s not about getting 15 year-olds to struggle through the quadratic formula by sitting them in front ever-increasingly trite computer animations and “prompts” in order to get even the least analytical to memorize an algorithm for 20 minutes; its about finding out Adam Richman’s critical burger mass from a Diff Eq.

I’VENEVERSEENAMANEATSOMANYCHICKENWINGS

1. Ghost Chile salsa intake had the general behavior of a huge slow down and the a really fast acceleration is people realized the only way to make it through was to power through then end and then barf. Here’s some scoville/chile stuff I’ve done.

2. Seriously travel channel? When I google “Man v food memphis” all I want to know is what the challenge was and if he completed it. A graph would have been nice, too.

That chart is probably obvious to most of us, especially those of us in the Math Ed Twitterblogopinosphere.

But here’s where things gets stupid:

These numbers alone aren’t an open and shut case against teaching complex math to most high school students. But they do suggest that what we teach today has little relationship to the broad demands of the job market, and that we should at least be conscious of the possibility that we’re putting educational road blocks in front of students without a practical application for them.

So there’s a case against teaching complex math to most high schoolers? Ok. I guess, but shouldn’t it be:

There’s a case against CRAPPILY teaching complex math to high schoolers.

A good case, btw.

The adverb there is really important. What that graph really means is that the way people were taught math disables them from ever actually using it.

Jobs are not about performing a specified task perfectly 100% of the time. Those days are mostly gone (and perhaps never existed). The real question is, if those people who report never using advanced math were actually taught when it was valuable in vivo and with the ability to engage their community in a math-demanding solution, could they be providing innovative solutions to their employers?

Hell yes.

Again, it’s not about doing a “math problem” when you’re given one; it’s about framing and attacking an analytical problem where previously no one even suspected an issue. Like, oh, say, school scheduling, UPS truck packing, stock market crash preventing, third world country debt issues, fresh water, um FRESH WATER, any and all software development, etc… Did I mention the loss of fresh water? Fresh water.

You know something is really really crazywaders when you go to their website and feel lulled by their corporate concern for the every man.

FIJI Water is just such a company.

I played #anyqs with my University of Iowa pre-service students today, and here’s what we came up with.

1. How much petrol does it take to make a bottle, pump the water, and ship it to Iowa?
2. How can they possible have a renewable and impermeable aquifer?
   
3. Can the chemistry data (mg/L of silica, Mg, CO3, etc…) be verified?
4. How much more expensive is FIJI Water than Iowa City tap water?
5. Can you simulate FIJI Water’s “mouth feel” (eww) by adding the right amount of the molecules they list on the back?
6. Where the hell is Fiji?
7. How many trees does FIJI Water need to plant to offset the hubongo amount of CO2 they out put in shipping costs?

Welcome to Explore Planets.

The code allows you to fly the camera around a world filled with primary-color lighted spheres. The mouse is your pitch/yaw, and the up/down keys are your thrusters.

You are encouraged to get the code at the bottom of the linked page, that’s what my students will be doing. In fact, run it in Processing as a Java application, instead of through Javascript (you’ll get a way better frame rate and sphere smoothing)

I run it very similarly to how I would a Science Open Inquiry:

1. Here’s something to play with. (This code)
2. Try to get this easy task done. (turn the ship faster, mabes)
3. Now ask a way better question. (How can we add gravity!)
4. Answer that question. (werkwerkwerkwerk)
5. Report to the people who would care about the answer. (Weeeee!)

Programming Specifics:

This code uses 3D transformation matrices, which is my attempt to prove to students that their time spent in Algebra II with matrices was at least not totally wasted. That said, why we don’t just introduce programming, vectors, and building games at that point is well beyond me.

The game does a lot with adding, subtracting, and the various kinds of multiplication vectors/matrices can do. If you’re using it with your students, make the following statement:

SOME MATRICES ARE VECTORS, AND VECTORS MAKE YOU NOT STUPID.

Let’s stop pretending that there’s any other common reason for teaching this crap, and just teach them to avoid planetoids, ok? Ok. I hate Algebra II.

Also, there’s some pretty fancy 3D matrix rotation stuff, a lot of which I lifted and modified from The Internet. Thanks, Al.

1. As 4-year schools push remediation courses (like whatever-the-bananagrams “college algebra” means) down onto online “institutions” and community colleges, do they realize they’re asking for a disruption of their other course offerings as well?
2. As more colleges, with their attractive open schedules and other freedoms, offer these remediation courses, high schoolers are choosing them in increasing numbers above similar offerings from their draconian high school environments.
3. The sum of human knowledge is increasing so rapidly that the concept of a liberal arts education must be redefined.
4. College degrees still provide a better investment return than any other type of income investment.

Worst of all, programming can come across as arbitrary and fickle. Those of us that learned to program in Java probably remember thinking thoughts like “public? static? wtf? I just want to draw a two circles and a cylinder.”

Objects and Object-Oriented Programming (OOP) are even more mystical. When you’re first learning to program, especially if you’re self-taught, you read all sorts of stuff online about how OOP (Object-Oriented Programming) is so awesome, and how you won’t get a job unless you’re an OOP titan.

Most people learn to script (procedural program) first, they write a program that goes line-by-line from top to bottom and ends with an output that changes based on a few small initial conditions (someone hit the radio button for “Wacky Walrus” instead of “Lugubrious Langoustine,” so, like, show a walrus in a coffee shop)

I consider Procedural-to-OOP a threshold that is quite similar to the Newtonian Threshold in physics. You just don’t know how bonkers your practices are until you know, which is not very heartening if you’re on the novice side of the fence. (“What do you mean there are no forces? It’s moving” is similar to “What do you mean it runs the method on line 22 again? We passed that.”)

So, how to get teenagers to buy into the idea of objects. Well, after 5 years, I know a lot of ways not to do it.

1. It doesn’t work to teach procedural programming first. That is, scripting is addicting, and there’s no end to the number of if’s and else’s students will nest in order to achieve something that would have been much easier with objects.
2. It really doesn’t work to use PHP or other web based back-end languages. I’m not saying it’s bad to use OO-PHP, but it is awkward, the added layer of storing all the information on a server and trucking it back and forth is annoying and has tons of overhead. Ruby is better in this respect, but not by much.
3. Let students copy your code and just change little pieces. This sounds like an awesome idea at first, until you give them an assessment that requires them to come up with fields and methods for a class they’ve never thought about before. Then, just like so many other times in assessment, you realize how pale and sad the culture of school really is.

Ok, so what does work?

Presenting the need for objects right away: I try to show them how keeping track of information about similar ideas in a procedural way gets super annoying.

For instance, I once had a student program a game of Connect Four. He had a variables list a mile long: BlackX1, BlackY1, BlackX2, BlackY2, RedX1, RedY1, RedX2, and on, and on, where as all of those could have just been instantiations of a player class. He was training a computer to play Connect Four, but he was doing all of the thinking in trying to create a variable naming scheme that was easy to remember. Not good.

ASIDE: That last sentiment was the part that took me forever to understand. Oh, and by “forever” I mean “by the time my brain was actually ready for the abstraction,” which most of our students’ aren’t.

ASIDEASIDE: Sad for math: we teach beautiful, unifying concepts to brains that mostly max out at memorizing algorithms.

ASIDEASIDEASIDE: the best advice you can give a math student who’s honestly struggling is, “take a year off and go get some experience building stuff. Come back, and we’ll start with algebra again.”

When I was trying to learn how to OOP, all I wanted was for someone to lay out why it was so much better, and show me an example of objects and classes that was complex enough to show power, but not so syntactically bonkers that I couldn’t follow it.

Here’s my attempt (Processing). Let’s make some hack-and-slash fighters that have at in a battle ring. The battle ring known as the COMMAND LINE:

broot sven = new broot("Sven");
broot glenn = new broot("Glenn");

void setup(){
println("Sven: ");
println("Strength: "+sven.strength);
println("Health: "+sven.health);
println("Defense: "+sven.defense);
println("Armor: "+sven.armor);
println("Luck: "+sven.luck);
println("------");
println("Glenn: ");
println("Strength: "+glenn.strength);
println("Health: "+glenn.health);
println("Defense: "+glenn.defense);
println("Armor: "+glenn.armor);
println("Luck: "+glenn.luck);
println("------");
}

void draw(){
if(sven.health>0 && glenn.health>0){
sven.attack(glenn);
glenn.attack(sven);
println("Sven's Health: "+sven.health);
println("Glenn's Health: "+glenn.health);
println("------");
}
}

Notice that we created two objects (Sven and Glenn) who are of the broot class. We made that up. Processing didn’t know what a broot was until we created the class file, which looks like this:

class broot{
int strength;
int health;
int defense;
int armor;
int luck;
String name;

//constructor
broot(String Name){
strength = (int) random(100);
health = (int) random(100, 500);
defense = (int) random(100);
armor = (int) random(50);
luck = (int) random(10);
name = Name;
}

//methods
void attack(broot otherGuy){
if(!otherGuy.defend()){
int pain = strength - otherGuy.armor;
otherGuy.sufferInjury(pain);
println(name+" hit "+otherGuy.name+" for "+pain+" damage.");
}
else println(name+" missed!");
}

boolean defend(){
int dieRoll = (int) random(100);
if(dieRoll>defense+luck){
return false;
}
else{
return true;
}
}

void sufferInjury(int damage){
health -= damage;
}
}

So, we created the idea of a broot, each broot we make has the following attributes: strength, defense, armor, luck, health, and a name. We could have done something like:

svenStrength;

glennStrength;

svenHealth;

and so on,

but that kind of variable naming repetition is exactly what OOP is allowing us to get around. We’re creating a die from which we can cut as many broot as we want, and there’s the rub. After our program runs, it creates two broots (Sven and Glenn), and each has their own strength, defense, and all the rest.

We access those by specifying which broot we care about. If I want to use Sven’s defense I just code:
sven.defense
Which is totally separate from Glenn’s defense.

Constructors:

Constructors gave me fits when I was learning OOP. Here’s the low down. At the very beginning when I wrote:

broot sven = new broot("Sven");

We’re activating (calling) the broot() constructor. We’re saying, “Make a variable named ‘sven‘ and store in it all the fields (like strength, health, defense) that make a broot.”

In our case, it literally randomizes the broot, as you can see in the broot() constructor; the only thing we have to do is supply a name.

After that, the main program prints out the initial stats of each broot, and then sets them to pounding on each other.

Methods:

After checking to see if either Sven or Glenn have been exhausted (health less than 0), we then run the most OOP code in the whole program:

sven.attack(glenn);

glenn.attack(sven);

If this doesn’t make sense, then OOP is still eluding you.

They’re both the same class, so they both have the ability (method/function) to attack, but the object you say first (before the full stop) implies whose attack method you’ll run. The object you put in the parenthesis is the object who will be given to the attack method as otherGuy in the line:

void attack(broot otherGuy){

So I’m allowed to give Sven’s attack function another broot, in this case the only other broot in the program, Glenn. Conceivably, I could say:

sven.attack(sven);

But that’s silly.

There are plenty of other method calls in the program, but the big idea is that we specify the object whose method we want to use. We separate that information with a full stop, and we supply any information the method may need to do its job as an argument. In super general:

object.method(argument);

Big Idea:

Both Sven and Glenn are broots. They each have a strength, defense, and everything else that are separate variables from each other, even though they’re created from the same template code (a “class”). In this way, we don’t have to have fifty variables just to describe 5 broots.

The variables sven and glenn contain within them the ability to look up information (health, luck, etc…) and to run their methods (e.g. attack()) just by using a full stop, and those information and methods are not shared. They’re copied into separate pieces of memory, much like making a distinct copy that can then be fiddled with; that fiddling doesn’t affect the other copies made from the template in the same way.