computational-thinking

My latest app project: 5K Race Timer

I happened to attend a meeting a little more than a month ago for the committee that organizes the Dragon Run. This is one of the school’s biggest events and requires quite a group of people to make happen. One of the biggest challenges that the group faces is the timing of the race and management of this data for the 120+ runners that participate in the official event.

The scheme used in previous years has been a very well thought out system of spotters with pencil and paper lists and a race timer placed at the finish line. When runners register, they give an estimated time for their run, which places them in a few different speed categories. Each spotter has a list of runner numbers from each category so that they are searching for particular runner numbers throughout the time span of the race. When a runner crosses, the spotter records the time on their sheet. This time is then later fed into a spreadsheet that gives everyone’s time. These results are then collated and printed to give the results list after the race.

I’m trying not to be a hammer looking for a nail here, but this seemed like a perfect opportunity to try to use the power of the computer to reduce some of the mental and paper load of this task. My learning obsession with Python web apps and even more recent desire to learn about databases quickly helped me see some easy ways to do this. These were the main points that I wanted as part of the UI:

Upon seeing a runner approach the finish line, the spotter should be able to send a ‘stop’ command at the moment that runner crosses the line. Calculating the finish time relative to the start of the race and recording that information is screaming for a computer solution. This capitalizes on the human spotter’s ability for to recognize a runner’s number by sight, leaving the rest of the work to the program to do.
We would need a simple interface for starting the race and stopping individual runners with a button press.
A non-trivial number of runners register on the day of the race. There needs to be a way to manually add runners to the database easily.
Mistakes also come up in recording times and entering data. Editing a runner’s information, including finish time, is a necessity.
Manually entering all the runners into the database before the race? Heck no. The organizers use a spreadsheet to record all of the registration information, which is a CSV file asking to be made and inputted to the database automatically.
Creating a list of runners based on category and ranked according to race finish time is another exhausting task when done purely by spreadsheet. This process in the program should make the most of SQL queries and Python/Bottle template features to generate the race results automatically.
To properly see if this system would work, I’d need a way of showing numbers passing by similar to what actually happens during a race. I put together a Javascript simulator to do this using Raphael that can be found here. This was especially important in testing the system with my student volunteers.

The organizers agreed to let me run my software as a beta test to see if it would work for future years. More insight and conversation led to the idea of a mobile application to be used to enter runner numbers. I agreed that this would be an easier way to locate runners than looking down a list, but had no idea how to do this. I did research and figured out the jQuery Mobile would be the way to do it. This was a difficult learning process having never done this sort of thing before. I battled with the “ghost click” problem for a while until discovering that the ‘touchend’ event was an easy fix.

~~Here’s the software as used on race day:~~

Running code at http://timekeeper.evanweinberg.org
Try the mobile app on your mobile device at http://timekeeper.evanweinberg.org/mobile/
Code source at Github is here.

UPDATE Mar. 2016: I’ve taken down the site to save some memory on my server. Write me if you are interested in the details.

The system worked really well, but ran into some of the same challenges that the pencil-and-paper spotters have been battling since the event’s inception. It’s really hard to simultaneously grab the numbers of a group of 4-5 runners that all come in at once. The system that my students devised for identifying who was going to enter a particular runner approaching the finish line broke down in two specific instances of this, and we missed runners. Luckily pencil and paper picked up the ones we missed. Definitely still in beta. The process of generating results lists and recording times overall worked quite smoothly, and I’m really happy with how it turned out.

Notes:

Bottle, Twitter Bootstrap, jQuery Mobile, and vanilla Javascript were all in play.
I learned at the race that there are already software packages out there. Now that I’ve done a quick search, it seems that while there is a lot of software out there, the ease of running it through a web interface (and snagging runners through a mobile interface) is a relatively young feature. This project was about me learning to do some new things, and in the end it cost me (and the school) nothing other than time.
I learned a lot about user centered design through this project. Usability was a necessity, so I had to start from there and work backwards to build the code needed to make it happen. I really like thinking this way,

Rethinking the headache of reassessments with Python

One of the challenges I’ve faced in doing reassessments since starting Standards Based Grading (SBG) is dealing with the mechanics of delivering those reassessments. Though others have come up with brilliant ways of making these happen, the design problem I see is this:

The printer is a walk down the hall from my classroom, requires an ID swipe, and possibly the use of a paper cutter (in the case of multiple students being assessed).
We are a 1:1 laptop school. Students also tend to have mobile devices on them most of the time.
I want to deliver reassessments quickly so I can grade them and get them back to students immediately. Minutes later is good, same day is not great, and next day is pointless.
The time required to generate a reassessment is non-zero, so there needs to be a way to scale for times when many students want to reassess at the same time. The end of the semester is quickly approaching, and I want things to run much more smoothly this semester in comparison to last.

I experimented last fall with having students run problem generators on their computers for this purpose, but there was still too much friction in the system. Students forgot how to run a Python script, got errors when they entered their answers incorrectly, and had scripts with varying levels of errors in them (and their problems) depending on when they downloaded their file. I’ve moved to a web form (thanks Kelly!) for requesting reassessments the day before, which helps me plan ahead a bit, but I still find it takes more time than I think it should to put these together.

With my recent foray into web applications through the Bottle Python framework, I’ve finally been able to piece together a way to make this happen. Here’s the basic outline for how I think I see this coming together – I’m putting it in writing to help make it happen.

Phase 1 – Looking Good: Generate cleanly formatted web pages using a single page template for each quiz. Each page should be printable (if needed) and should allow for questions that either have images or are pure text. A function should connect a list of questions, standards, and answers to a dynamic URL. To ease grading, there should be a teacher mode that prints the answers on the page.
Phase 2 – Database-Mania: Creation of multiple databases for both users and questions. This will enable each course to have its own database of questions to be used, sorted by standard or tag. A user can log in and the quiz page for a particular day will automatically appear – no emailing links or PDFs, or picking up prints from the copier will be necessary. Instead of connecting to a list of questions (as in phase 1) the program will instead request that list of question numbers from a database, and then generate the pages for students to use.
Phase 3 – Randomization: This is the piece I figured out last fall, and it has a couple components. The first is my desire to want to pick the standard a student will be quizzed on, and then have the program choose a question (or questions) from a pool related to that particular standard. This makes reassessments all look different for different students. On top of this, I want some questions themselves to have randomized values so students can’t say ‘Oh, I know this one – the answer’s 3/5’. They won’t all be this way, and my experience doing this last fall helped me figure out which problems work best for this. With this, I would also have instant access to the answers with my special teacher mode.
Phase 4 – Sharing: Not sure when/if this will happen, but I want a student to be able to take a screenshot of their work for a particular problem, upload it, and start a conversation about it with me or other students through a URL. This will also require a new database that links users, questions, and their work to each other. Capturing the conversation around the content is the key here – not a computerized checker that assigns a numerical score to the student by measuring % wrong, numbers of standards completed, etc.

The bottom line is that I want to get to the conversation part of reassessment more quickly. I preach to my students time and time again that making mistakes and getting effective feedback is how you learn almost anything most efficiently. I can have a computer grade student work, but as others have repeatedly pointed out, work that can be graded by a computer is at the lower level of the continuum of understanding. I want to get past the right/wrong response (which is often all students care about) and get to the conversation that can happen along the way toward learning something new.

Today I tried my prototype of Phase 1 with students in my Geometry class. The pages all looked like this:

I had a number of students out for the AP Mandarin exam, so I had plenty of time to have conversations around the students that were there about their answers. It wasn’t the standard process of taking quiz papers from students, grading them on the spot, and then scrambling to get around to have conversations over the paper they had just written on. Instead I sat with each student and I had them show me what they did to get their answers. If they were correct, I sometimes chose to talk to them about it anyway, because I wanted to see how they did it. If they had a question wrong, it was easy to immediately talk to them about what they didn’t understand.

Though this wasn’t my goal at the beginning of the year, I’ve found that my technological and programming obsessions this year have focused on minimizing the paperwork side of this job and maximizing opportunities for students to get feedback on their work. I used to have students go up to the board and write out their work. Now I snap pictures on my phone and beam them to the projector through an Apple TV. I used to ask questions of the entire class on paper as an exit ticker, collect them, grade them, and give them back the next class. I’m now finding ways to do this all electronically, almost instantly, and without requiring students to log in to a third party website or use an arbitrary piece of hardware.

The central philosophy of computational thinking is the effort to utilize the strengths of computers to organize, iterate, and use patterns to solve problems. The more I push myself to identify my own weaknesses and inefficiencies, the more I am seeing how technology can make up for those negatives and help me focus on what I do best.

(Students) thinking like computer scientists

It generally isn’t too difficult to program a computer to do exactly what you want it to do. This requires, however, that you know exactly what you want it to do. In the course of doing this, you make certain assumptions because you think you know beforehand what you want.

You set the thermostat to be 68º because you think that will be warm enough. Then when you realize that it isn’t, you continue to turn it up, then down, and eventually settle on a temperature. This process requires you as a human to constantly sense your environment, evaluate the conditions, and change an input such as the heat turning on or off to improve them. This is a continuous process that requires constant input. While the computer can maintain room temperature pretty effectively, deciding whether the temperature is a good one or not is something that cannot be done without human input.

The difficulty is figuring out exactly what you want. I can’t necessarily say what temperature I want the house to be. I can easily say ‘I’m too warm’ or ‘I’m too cold’ at any given time. A really smart house would be able to take those simple inputs and figure out what temperature I want.

I had an idea for a project for exploring this a couple of years ago. I could try to tell the computer using levels of red, green, and blue exactly what I thought would define something that looks ‘green’ to me. In reality, that’s completely backwards. The way I recognize something as being green never has anything to do with RGB, or hue or saturation – I look at it and say ‘yes’ or ‘no’. Given enough data points of what is and is not green, the computer should be able to find the pattern itself.

With the things I’ve learned recently programming in Python, I was finally able to make this happen last night: a page with a randomly selected color presented on each load:

Sharing the website on Twitter, Facebook, and email last night, I was able to get friends, family, and students hammering the website with their own perceptions of what green does and does not look like. When I woke up this morning, there were 1,500 responses. By the time I left for school, there were more then 3,000, and tonight when my home router finally went offline (as it tends to do frequently here) there were more than 5,000. That’s plenty of data points to use.

I decided this was a perfect opportunity to get students finding their own patterns and rules for a classification problem like this. There was a clearly defined problem that was easy to communicate, and I had lots of real data data to use to check a theoretical rule against. I wrote a Python program that would take an arbitrary rule, apply it to the entire set of 3,000+ responses from the website, and compare its classifications of green/not green to that of the actual data set. A perfect rule for the data set would correctly predict the human data 100% of the time.

I was really impressed with how quickly the students got into it. I first had them go to the website and classify a string of colors as green or not green – some of them were instantly entranced b the unexpected therapeutic effect of clicking the buttons in response to the colors. I soon convinced them to move forward to the more active role of trying to figure out their own patterns. I pushed them to the http://www.colorpicker.com website to choose several colors that clearly were green, and others that were not, and try to identify a rule that described the RGB values for the green ones.

When they were ready, they started categorizing their examples and being explicit in the patterns they wanted to try. As they came up with their rules (e.g. green has the greatest level) we talked about writing that mathematically and symbolically – suddenly the students were quite naturally thinking about inequalities and how to write them correctly. (How often does that happen?) I showed them where I typed it into my Python script, and soon they were telling me what to type.

In the end, they figured out that the difference of the green compared to each of the other colors was the important element, something that I hadn’t tried when I was playing with it on my own earlier in the day. They really got into it. We had a spirited discussion about whether G+40>B or G>B+40 is correct for comparing the levels of green and blue.

In the end, their rule agreed with 93.1% of the human responses from the website, which beat my personal best of 92.66%. They clearly got a kick out of knowing that they had not only improved upon my answer, but that their logical thinking and mathematically defined rules did a good job of describing the thinking of thousands of people’s responses on this question. This was an abstract task, but they handled it beautifully, both a tribute to the simplicity of the task and to their own willingness to persist and figure it out. That’s perplexity as it is supposed to be.

Other notes:

One of the most powerful applications of computers in the classroom is getting students hands on real data – gobs of it. There is a visible level of satisfaction when students can talk about what they have done with thousands of data points that have meaning that they understand.
I happened upon the perceptron learning algorithm on Wikipedia and was even more excited to find that the article included Python code for the algorithm. I tweaked it to work with my data and had it train using just the first 20 responses to the website. Applying this rule to the checking script I used with the students, it correctly predicted 88% of the human responses. That impresses me to no end.
A relative suggested that I should have included a field on the front page for gender. While I think it may have cut down on the volume of responses, I am hitting myself for not thinking to do that sort of thing, just for analysis.
A student also indicated that there were many interesting bits of data that could be collected this way that interested her. First on the list was color-blindness. What does someone that is color blind see? Is it possible to use this concept to collect data that might help answer this question? This was something that was genuinely interesting to this student, and I’m intrigued and excited by the level of interest she expressed in this.
I plan to take a deeper look at this data soon enough – there are a lot of different aspects of it that interests me. Any suggestions?
Anyone that can help me apply other learning algorithms to this data gets a beer on me when we can meet in person.

Coding IS a super(edu)power

I’ve been really impressed by the Dan Meyer/Dave Major collaboration. If you don’t know what I’m talking about, you need to click on that link immediately. Seeing both Dan and Dave post on their respective blogs about the thought and rationale that goes into these activities is like a masters class in pedagogy, digital media, and user design.

The common thread that I really like about these tools is the clean and minimalist way they pose an idea, encourage a bit of play and intuition, and then get out of the way. Dan has talked about these ideas philosophically for a while, and seeing Dave make these happen is really exciting. They talk about this being the future of textbooks, but I am willing to wager that textbooks will get fidgety at displaying a task to a user atop a blank white screen. The trend has been so far in the other direction that I am skeptical, but I am hopeful that they will start to listen. These exercises are like a visit to the Museum of Modern Art. Textbooks and online learning otherwise tends to look either like a visit to Chuck-E-Cheese or the town library, over-thinking or under-thinking the power of aesthetics to creating a learning environment that is stimulating enough, but not distracting.

Being a committed Twitter follower, I of course interrupted their workflow with suggestions. I was looking for an easy way to collect student responses to a question along the lines of Activeprompt, but for tasks that are not about finding a location. I had posed a question to my Geometry class and was really excited about greasing the rails for gathering student responses and putting them in one place. This is the same idea as what Dan/Dave had done, but with a bit less of a framework pushing it in a direction.

Dave’s suggestion was, well, intimidating:

I had been playing around with web2py, Django, Laravel, and other template frameworks that said they would make things easy for me, but it just didn’t click how they would do this. I have done lots of small Python projects, but the prospect of making a website seemed downright unlikely. I spent three hours putting together this gem using the CSS I had learned from CodeAcademy:

I was not proud of this, but it was the best I thought I could do.

Through the power of Twitter, I was able to actually have a conversation with Dave and learn how he put his own work together. He uses frameworks such as Raphael.js and Sinatra in a way that does just enough to achieve the design goal. I learned that he wasn’t doing everything from scratch. He took what he needed from what he knew about these different tools and constructing precisely what he envisioned for his application. I prefer Python to Ruby because, well, I don’t know Ruby. I found Bottle which works beautifully as a small and simple set of tools for building a web application in Python, just as Dave had done with his tools.

Using Bottle and continuing to learn how it works, I made this yesterday.

I shared it with Dave, and he revealed another of his design secrets: Bootstrap. Again, dumbstruck by the fact this sort of tool exists, but also that I hadn’t considered that it might. This led me to clean up my previous submission and reconsider what might be possible. With a bit more tinkering, I turned this into what I had envisioned: a flexible tool for collecting and sharing student responses to a question

I was just tickled pink. Dave had shown me his prototype for what he made in response to my prompt – I was blown away by it, as with the rest of his work. Today, however, I proudly used my web app with two of my classes and was happy to see that it worked as designed.

The point behind writing about this is not to brag about my abilities – I don’t believe there is anything to brag about here. Learning to code has gotten a good mix of press lately on both the positive and negative side. It is not necessarily something to be learned on its own, for its own sake.

I do want to emphasize the following:

My comfort with coding is developed enough at this point that I could take my idea for how to do something in the classroom using programming and piece it together so that it could work. I got to this point by messing around and leaving failed projects and broken code behind. This is how I learn, and it has not been a straight line journey.
If I was not in the classroom on a regular basis, I doubt I would have these ideas for what I could do with coding if I had the time to focus on it completely. In other words, if I ditched the classroom to code full time (which I am not planning to do) I would run out of things to code.
Twitter and the internet have been essential to my figuring out how to do this. Chatting virtually with Dave, as an example, was how I learned there was a better way than the approach I was taking. There are no other people in my real world circles who would have introduced me to the tools that I’ve learned about from Dave and other people in the twitterverse. Face to face contact is important, but it’s even better getting virtual face time with people that have the expertise and experience to do the things I want to learn to do.
I have been writing code and learning to code from the perspective of trying to do a specific and well defined task. This is probably the most effective and authentic learning situation around. We should be looking for ways to get students to experience this same process, but not by pushing coding for its own sake. As with any technology, the use needs to be defined and demanded by the task.
The really big innovations in ed-tech will come from within because that’s where the problems are experienced by real people every day. Outsiders might visit and see a way to help based on a quick scan of what they perceive as a need. I’m not saying outsiders won’t or can’t generate good ideas or resources. I just think that tools need to be designed with the users in mind. The best way to do this is to give teachers the time, resources, and the support to build those tools themselves if they want to learn how.

You can check out my code at Github here. Let me know if you want to give it a shot or if you have suggestions. This experiment is far from over.

Building a need for algebraic reasoning – how can computers help?

I hear this all the time, and it drives me up a wall.

I haven’t solved for x in years, and I’m doing just fine.

Few people realize that while they aren’t using algebraic properties in their daily lives, they use the analog concept of finding missing values all the time. You won’t win this argument with most people though. It just doesn’t seem like algebra.

As math teachers, we also get annoyed when students are able to do this with nothing in between:

Certainly in a Calculus class, this should not surprise us – at that level we would expect an ability to eyeball the solution. At the other end of the post elementary math progression, however, when we are teaching two step equations for the first time, our response might be this: “Yes, you got that one, but I could give you one that has negative numbers or (GASP!) decimals or fractions in it. Then what would you do? This is why it’s important that you pay attention to this lesson. You have to do it this other way in order to get credit.”

I’ve had this conversation, and it has always made me feel ridiculous. It’s an arbitrary and crappy argument. It might be a valid one if standardized (or your own) tests of algebraic concepts are involved, but using tests as a motivation for doing anything makes the whole enterprise feel cheap, even when doing so needs to happen.

The bigger issue is that it perpetuates the reputation of math teachers and mathematicians as protectors of a sacred bag of secrets that nobody outside of a math classroom will need. It also presents a problem of artificiality. If I can suddenly make something harder by adding fractions or decimals, does doing so make it any easier for me to assess whether my students know what they are doing in solving an equation? I think we haven’t done a great job of building in the need for algebra, especially in light of what computers can do. I’ve never had a student sarcastic and comfortable enough with me to do this, but bear with me. The theoretical argument in the back of my mind to what I said in response to the student I described earlier is this:

Really teach? With that college degree of yours, you could make up a question that I can’t use my knowledge of arithmetic to solve? Impressive. I guess that even though I did everything my previous teachers told me to do – memorize multiplication tables, learn to add fractions with like/unlike denominators, draw lots of pie charts demonstrating equivalent fractions, AND draw lots of connect-the-dot dinosaurs as reviews of plotting in the coordinate plane, I still need you. Glad to be here. Oh, your tie is crooked. At least I can still help you out with that.

Furthermore, I wonder about the challenge of motivating algebra given that Wolfram Alpha, CAS, and even the lowly TI-83 solver can solve equations without breaking a sweat.

I’m not teaching introductory algebra right now, but the thinking I’ve done on how computers put the thinking back into process has me wondering how motivating the need for Algebra could be different, and better given how easy it is to compute these days. The most basic way that people interact with numbers is through tables and graphs – is it possible to motivate algebra through this familiar idea? Can we use the computer to compute a bunch of stuff, and see what it tells us?

Some food for thought:

This is precisely the sort of thing we are looking for when we are solving an equation, but it’s rare that we think about it this way. It’s also something that most people outside of a classroom will do with a table of values in a newspaper or a website, for example. It is typically for more practical reasons (predicting value of a stock, figuring out when a bus will arrive at our location from a schedule that doesn’t have every stop, etc) than simply finding ‘x’ as we ask students to do in the classroom. Is this algebra? Staring at a table of values is tedious, but I know people that would rather do this than solve an equation or do anything that smells like school math.

Again, in our adult lives, we make estimations from given information from a table or graph from time to time, but few adults actually call this algebra. Is it obvious to an adult that changing the interval in the right way would allow the exact answer to be found? Is it obvious to a student? It’s a subtle point here, but I think it’s the sort of reasoning we want our students to be capable of doing. Is that type of understanding something inherently important in algebraic reasoning? How’s that going for us now?

We know there are algorithmic ways to solve this one, but I’ve already said here and in previous posts that I want to get away from mathematical thinking as a bag of algorithms. How good of an answer to this can we get from a table? I don’t know about you, but I have yet to feel like I’ve taught well the idea of an irrational number in a good, intuitive way that doesn’t result in students memorizing tricks. I think this hints at this concept in ways that is inaccessible without using computers. Even on a calculator, it’s difficult to focus in on solutions as smoothly as I think can be done with a table of rapidly computed values.

I’m not suggesting that we shouldn’t teach properties of numbers and inverse operations in the context of solving equations algebraically. I think we need to do a better job of selling the idea of algebra as being an enhancement of what we already have built in to our brains. We estimate what time we need to cross the street to not get hit by a truck but also to minimize our time waiting. We know that if the high is 68 degrees at 3 PM, that it will probably be a nice temperature outside at one-o-clock. This way of feeling our way to a solution through intuition, however, is not the optimal way to solve problems, especially when our intuition is wrong. There needs to be a better way.

Our students (and many adults) often don’t know how to create tools to help them solve the problems they face. They choose to do things that are tedious because they don’t know a better way, and the math skills they have developed previously are disconnected and seem irrelevant as a result. We do understand the idea of computation, but we often aren’t good at doing it ourselves. If nothing else, it’s pushing people to become more confident that they know what they are looking at when we see a bunch of numbers together.

Computational modeling & projectile motion, EPISODE IV

I’ve always wondered how I might assess student understanding of projectile motion separately from the algebra. I’ve tried in the past to do this, but since my presentation always started with algebra, it was really hard to separate the two. In my last three posts about this, I’ve detailed my computational approach this time. A review:

We used Tracker to manually follow a ball tossed in the air. It generated graphs of position vs. time for both x and y components of position. We recognized these models as constant velocity (horizontal) and constant acceleration particle models (vertical).
We matched graphical models to a given projectile motion problem and visually identified solutions. We saw the limitations of this method – a major one being the difficulty finding the final answer accurately from a graph. This included a standards quiz on adapting a Geogebra model to solve a traditional projectile motion problem.
We looked at how to create a table of values using the algebraic models. We identified key points in the motion of the projectile (maximum height, range of the projectile) directly from the tables or graphs of position and velocity versus time. This was followed with the following assessment
We looked at using goal seek in the spreadsheet to find these values more accurately than was possible from reading the tables.

After this, I gave a quiz to assess their abilities – the same set of questions, but asked first using a table…

… and then using a graph:

The following data describes a can of soup thrown from a window of a building.

How long is the can in the air?

What is the maximum height of the can?

How high above the ground is the window?

Is the can thrown horizontally? Explain your answer.

How far from the base of the building does the can hit the ground?

What is the speed of the can just before it hits the ground?</li

I was really happy with the results class wide. They really understood what they were looking at and answered the questions correctly. They have also been pretty good at using goal seek to find these values fairly easily.

I did a lesson that last day on solving the problems algebraically. It felt really strange going through the process – students already knew how to set up a problem solution in the spreadsheet, and there really wasn’t much that we gained from obtaining an algebraic solution by hand, at least in my presentation. Admittedly, I could have swung too far in the opposite direction selling the computational methods and not enough driving the need for algebra.

The real need for algebra, however, comes from exploring general cases and identifying the existence of solutions to a problem. I realized that these really deep questions are not typical of high school physics treatments of projectile motion. This is part of the reason physics gets the reputation of a subject full of ‘plug and chug’ problems and equations that need to be memorized – there aren’t enough problems that demand students match their understanding of how the equations describe real objects that move around to actual objects that are moving around.

I’m not giving a unit assessment this time – the students are demonstrating their proficiency at the standards for this unit by answering the questions in this handout:
Projectile Motion – Assessment Questions

These are problems that are not pulled directly out of the textbook – they all require the students to figure out what information they need for building and adapting their computer models to solve them. Today they got to work going outside, making measurements, and helping each other start the modeling process. This is the sort of problem solving I’ve always wanted students to see as a natural application of learning, but it has never happened so easily as it did today. I will have to see how it turns out, of course, when they submit their responses, but I am really looking forward to getting a chance to do so.

A computational approach to modeling projectile motion, part 3.

I’ve been really excited about how this progression is going with my physics class – today the information really started to click, and I think they are seeing the power of letting the computer do the work.

Here’s what we did last time:

In a fit of rage, Mr. Weinberg throws a Physics textbook while standing in the sand box outside the classroom. By coincidence, the book enters the classroom window exactly when it reaches its maximum height and starts to fall back down.

Is it appropriate to neglect air resistance in analyzing this situation? Justify your answer.
We want to use this problem to estimate the height of the classroom window above the ground. Identify any measurements you would take in order to solve this problem. (No, you may not measure the height of the classroom window above the ground.)
Use your spreadsheet to find the height of the window as accurately as you can.

Note: This activity got the students using the spreadsheet they put together last time to figure out the maximum height of the object. They immediately recognized that they needed some combination of dimensions, an angle, and a launch speed of the book.

These tables of values are easy to read, but we want to come up with a more efficient way to get the information we need to solve a problem.

The table below represents a particular projectile. Identify as much about its movement as you can. How high does it go? How far does it go? When does it get there? That’s the kind of thing we’re interested in here.

Note that at this point the students are spending time staring at tables of equations. This is clearly not an efficient way to solve a problem, but it’s one that they understand, even the weakest students. They can estimate the maximum height by looking at the table of y-values, but the tedium of doing so is annoying, and this is what I want. I try to model this table of values with the spreadsheet they put together with them telling me what to do. Every time I change a value for initial speed or initial height, the location of the maximum changes. It’s never in the same place.

Eventually, someone notices the key to finding the maximum isn’t with the y-position function. It’s with the vertical velocity. When does the y-component equal zero?

This is where the true power of doing this on the spreadsheet comes alive. We look at the table of values, but quickly see that we don’t need a whole table. We go from this:

…to this:

Clearly this t-value is wrong. Students can adjust the value of the time in that cell until the velocity in the cell below is zero. A weak student will get how to do this – they are involved in the process. The tedium of doing this will prompt the question – is there a better way? Is this when we finally switch to an algebraic approach? No, not yet. This is where we introduce the Goal Seek tool.

The spreadsheet will do the adjustment process for us and find the answer we are looking for. With this answer in hand, we can then move on to posing other questions, and using goal seek to find the values we are looking for.

The process of answering a projectile motion question (how far does it go? how high does it go?) through a spreadsheet then becomes a process of posing the right questions:

This is the type of reasoning we want the students to understand within the projectile motion model. Whether your tool of choice for answering these questions is the graph, equations, or a table of values, posing these questions is the meat and potatoes of this entire unit in my opinion.

The next step is to then introduce algebraic manipulation as an even more general way to answer these questions, including in cases where we don’t have numbers, but are seeking general expressions.

Today I had a student answer the following questions using the goal seek method with the numerical models I’ve described above:

A ball is thrown horizontally from a window at 5 m/s. It lands on the ground 2.5 seconds later. How far does the ball travel before hitting the ground? How high is the window?

He solved it before anyone else. This is a student that has struggled to do any sort of algebraic manipulation all year. There’s something to this, folks. This is the opening to the fourth class of this unit, and we are now solving the same level questions as the non-AP students did a year ago with an algebraic approach and roughly the same amount of instruction time. Some things to keep in mind:

My students are consistently using units in all of their answers. It is always like pulling teeth trying to get them to include units – not so much at the moment.
They are spending their time figuring out the right questions to ask, not which equation to ‘plug’ into to get an answer.
They immediately see what information is missing in their model at the beginning of a problem. They read the questions carefully to see what they need.
The table of values gives them an estimate they can use for the problem. They have an idea of what the number should be from the table, and then goal seek improves the accuracy of the number.
At the end of the problem, students have all of the initial information filled out to describe all of the parts of the problem. They can check that the horizontal range, maximum height, and other waypoints of the path match the given constraints of the problem. This step of checking the answer is a built-in feature to the process of matching a model – not an extra step that I have to demand at the end. If it doesn’t match all of the given constraints, it is obvious.

I am looking for push back – is there anything I am missing in this approach? I get that deriving formulas is not going to come easily this way, but I think with a computer algebra system, it’s not far away.

A computational approach to modeling projectile motion, continued.

Here is the activity I am looking at for tomorrow in Physics. The focus is on applying the ideas of projectile motion (constant velocity model in x, constant acceleration model in y) to a numerical model, and using that model to answer a question. In my last post, I detailed how I showed my students how to use a Geogebra model to solve projectile motion.

Let me know what I’m missing, or if something offends you.

A student is at one end of a basketball court. He wants to throw a basketball into the hoop at the opposite end.

What information do you need to model this situation using the Geogebra model? Write down [______] = on your paper for any values you need to know to solve it using the model, and Mr. Weinberg will give you any information he has.
Find a possible model in Geogebra that works for solving this problem.
At what minimum speed he could throw the ball in order to get the ball into the hoop?

We are going to start the process today of constructing our model for projectile motion in the absence of air resistance. We discussed the following in the last class:

Velocity is constant in the horizontal direction. (Constant velocity model)

$latex x(t) = x_{0} + v t$

Acceleration is constant in the vertical direction (Constant acceleration model)

$latex v(t) = v_{0} + a t$
$latex x(t)=x_{0}+v t +frac{1}{2}a t^2 $

The magnitude of the acceleration is the acceleration due to gravity. The direction is downwards.

Consider the following situation of a ball rolling off of a 10.0 meter high platform. We are neglecting air resistance in order for our models to work.

Some questions:

At what point will the ball’s movement follow the models we described above?
Let’s set x=0 and y = 0 at the point at the bottom of the platform. What will be the y coordinate of the ball when the ball hits the ground? What are the components of velocity at the moment the ball becomes a projectile?
How long do you think it will take for the ball to hit the ground? Make a guess that is too high, and a guess that is too low. Use units in your answer.
How far do you think the ball will travel horizontally before it hits the ground? Again, make high and low guesses.

Let’s model this information in a spreadsheet. The table of values is nothing more than repeated calculations of the algebraic models from the previous page. You will construct this yourself in a bit. NBD.

Estimate the time when the ball hits the ground. What information from the table did you use?
Find the maximum horizontal distance the ball travels before hitting the ground.

Here are the four sets of position/velocity graphs for the above situation. I’ll let you figure out which is which. Confirm your answer from above using the graphs. Let me know if any of your numbers change after looking at the graphs.

Now I want you to recreate my template. Work to follow the guidelines for description and labels as I have in mine. All the tables should use the information in the top rows of the table to make all calculations.

Once your table is generating the values above, use your table to find the maximum height, the total time in the air, and the distance in the x-direction for a soccer ball kicked from the ground at 30° above the horizontal.

I’ll be circulating to help you get there, but I’m not giving you my spreadsheet. You can piece this together using what you know.

Next steps (not for this lesson):

The table of values really isn’t necessary – it’s more for us to get our bearings. A single cell can hold the algebraic model and calculate position/velocity from a single value for time. Goal seek is our friend for getting better solutions here.
With goal seek, we are really solving an equation. We can see how the equation comes from the model itself when we ask for one value under different conditions. The usefulness of the equation is that we CAN get a more exact solution and perhaps have a more general solution, but this last part is a hazy one. So far, our computer solution works for many cases.

My point is motivating the algebra as a more efficient way to solve certain kinds of problems, but not all of them. I think there needs to be more on the ‘demand’ side of choosing an algebraic approach. Tradition is not a satisfying reason to choose one, though there are many – providing a need for algebra, and then feeding that need seems more natural than starting from algebra for a more arbitrary reason.

Struggling (and succeeding) with models in physics

Today we moved into exploring projectile motion in my non-AP physics class. Exhibit A:

I launched a single marble and asked them to tell me what angle for a given setting of the launched would lead to a maximum distance. They came up with a few possibilities, and we tried them all. The maximum ended up around 35 degrees. (Those that know the actual answer from theory with no air resistance might find this curious. I certainly did.)

I had the students load the latest version of Tracker on their computers. While this was going on, I showed them how to use the program to step frame-by-frame through one of the included videos of a ball being thrown in front of a black background:

Students called out that the x-position vs. t graph was a straight line with constant slope – perfect for the constant velocity model. When we looked at the y-position vs t, they again recognized this as a possible constant acceleration situation. Not much of a stretch here at all. I demonstrated (quickly) how the dynamic particle model in Tracker lets you simulate a particle on top of the video based on the mass and forces acting on it. I asked them to tell me how to match the particle – they shouted out different values for position and velocity components until eventually they matched. We then stepped through the frames of the video to watch the actual ball and the simulated ball move in sync with each other.

I did one more demo and added an air resistance force to the dynamic model and asked how it would change the simulated ball. They were right on describing it, even giving me an ‘ooh!’ when the model changed on screen as they expected.

I then gave them my Projectile Motion Simulator in Geogebra. I told them that it had the characteristics they described from the graphs – constant velocity in x, constant acceleration of gravity in y. Their task was to answer the following question by adjusting the model:

A soccer ball is kicked from the ground at 25 degrees from the horizontal. How far and how high does the ball travel? How long is it in the air?

They quickly figured out how it works and identified that information was missing. Once I gave them the speed of the ball, they answered the three questions and checked with each other on the answers.

I then asked them to use the Geogebra model to simulate the launcher and the marble from the beginning of the class. I asked them to match the computer model to what the launcher actually did. My favorite part of the lesson was that they started asking for measuring devices themselves. One asked for a stopwatch, but ended up not needing it. They worked together to figure out unknown information, and then got the model to do a pretty good job of predicting the landing location. I then changed the angle of the launcher and asked them to predict where the marble would land. Here is the result:
[wpvideo ZPhs5x2s]

Nothing in this lesson is particularly noteworthy. I probably talked a bit too much, and could have had them go through the steps of creating the model in Tracker. That’s something I will do in future classes. When I do things on the computer with students, the issues of getting programs installed always takes longer than I want it to, and it gets away from the fundamental process that I wanted them to see and have a part of – experiencing the creation of a computer model, and then actually matching that model to something in the real world.

My assertions:

Matching a model (mathematical, physical, numerical, graphical, algebraic) to observations is a challenge that is understood with minimal explanation. Make a look like b using tool c.
The hand waving involved in getting students to experiment with a computer model is minimized when that model is being made to match actual observations or data. While I can make a computer model do all sorts of unrealistic things, a model that is unrealistic wont match anything that students actually see or measure.
Students in this activity realized what values and measurements they need, and then went and made them. This is the real power of having these computer tools available.
While the focus in the final modeling activity was not an algebraic analysis of how projectile motion works mathematically, it did require them to recognize which factors are at play. It required them to look at their computed answer and see how it compared with observations. These two steps (identifying given information, checking answer) are the ones I have always had the most difficulty getting students to be explicit about. Using the computer model focuses the problem on these two tasks in a way that hand calculations have never really pushed students to do. That’s certainly my failure, but it’s hard to deny how engaged and naturally this evolved during today’s lesson.

The homework assignment after the class was to solve a number of projectile motion problems using the Geogebra model to focus them on the last bullet point. If they know the answers based on a model they have applied in a few different situations, it will hopefully make more intuitive sense later on when we do apply more abstract algebraic models.

Algebra is very much not dead. It just doesn’t make sense anymore to treat algebraic methods as the most rigorous way to solve a problem, or as a simple way to introduce a topic. It has to start somewhere real and concrete. Computers have a lot of potential for developing the intuition for how a concept works without the high bar for entry (and uphill battle for engagement) that algebra often carries as baggage.

What do I have wrong here? Computational thinking obsession continues

Another installment of my Hong Kong presentation titled ‘Why Computational Thinking matters.’ This is where my head is these days in figuring out how computers relate to what we do in class. My view is that activities like the one I describe in the video is more active than the way we (and I include myself in this group) usually attack word problems as part of our sequence.

[wpvideo IkQx3la4]

Help me flesh this out. I think there’s a lot here.

« Prev 1 … 4 5 6 7 8 Next »