computational-thinking

Two Lane Road and Collaborative Data Collection

I love doing three act problems. This fact should surprise nobody that regularly reads my blog.

In tasks that involve prediction or measurement from a range of sources, I see lots of tables of values made by students that stay in the notebook. I have always wanted to get that data in the hands of the rest of the students to use, or not use, as they see fit. In one of my previous iterations, I pasted the data into a shared Google spreadsheet that students could then paste into a Desmos graph, again, if they felt doing so would be helpful. This was incredibly rich source of material for conversations between students. Still, that extra step of having to paste from one collaborative document (Google) to a non-collaborative one (Desmos Calculator) was one more step than I felt was needed.

Of course, you’re now screaming at the screen. “Calling out Desmos for being non-collaborative is entirely off base, Evan” , you say. I agree to an extent. Their own activities share data collected by individual students, and on the teacher side, the Activity Builder does the same thing for letting teachers see student data all in one place. They do this incredibly well. Students also get to see each others answers when teachers let them. What doesn’t happen right now is students seeing each other’s graphs, tables, and lists of expressions.

This, along with a desire to play with the Desmos API, is why I created DataTogether (Github repository here), a hacky way to make Desmos data collaborative. The page is written in React, and uses Firebase to do the realtime data connection.

Dan Meyer tweeted shortly after that these changes might be somewhere in the pipeline already:

@emwdx On the one hand, I admire your industry. On the other, I'm mad that we make this so difficult. Promise to make this unnecessary soon.

— Dan Meyer (@ddmeyer) November 1, 2016

This is probably why I may not be adding a lot of code comments to my code in the near future.

I did my Two Lane Road 3-act with a small group of students this morning on account of tenth graders being out for the PSAT. After the standard Act 1 conversation, and a really great conversation about agreements between groups on collecting data from the video, the students began collecting data on the red and blue cars.

The students were efficiently able to collect data together on separate computers after profuse apologies for the limitations of my code:

I then had each student use the tools within Desmos to construct a linear model from the data. The fact that two computers were looking at the same data, but in different Desmos windows, paid significant dividends when two students on the same team created their models in different ways. One student made a regression. Another created a line that went through one set of points perfectly, but missed another. Math class conversation gold right there.

I exported both of their data through the console (code shown below) and pasted it into Desmos. I then put together a simulation of the red and blue car so that the teams could see what their car looked like in simulation.

You can check out the Desmos graph here.

This allowed us to make a prediction directly off of their models that looked like the original video.

We ran out of time in the end to do much more than sharing predictions and watching the third act, but I’m pretty pleased with how things went overall. My paper handouts with three printed color frames of the video went unused. I think

A big shout-out of thanks to everyone for helping test the data collection tool I shared earlier.

Here’s a screenshot of our age vs. teaching years data:

The data can be downloaded from the DataTogether page, loading data set 3DR9, and then by going to the console and entering the code below:

ptString = "";
myComponent.state.groupData.forEach(function(pt){ptString=ptString+pt.x+" \t "+pt.y+" \n "});

This string can then be pasted right into the Desmos expression list if you want to play with it.

Numbas and Randomized Assessment

At the beginning of my summer vacation, I shared the results of a project I had created to fill a need of mine to generate randomized questions. I subsequently got a link from Andrew Knauft (@aknauft) about another project called Numbas that had similar goals. The project is out of Newcastle University and the team is quite interested in getting more use and feedback on the site.

You can find out more at http://www.numbas.org.uk/. The actual question editor site is at https://numbas.mathcentre.ac.uk/.

I’ve used the site for a couple of weeks now for generating assessments for my students. I feel pretty comfortable saying that you should be using it too, and in place of my own QuestionBuilder solution. I’ve taken the site down and am putting time into developing my own questions on Numbas. Why am I so excited about it?

It has all of the randomization capabilities of my site, along with robust variable browsing and grouping, conditions for variable constraints, and error management in the interface that I put on the back burner for another day. Numbas has these features right now
LaTEX formatting is built in along with some great simplification functions for cleaning up polynomial expressions.
Paper and online versions (including SCORM modules that work with learning management sites like Moodle) are generated right out of the box.
It’s easy to create, share, and copy questions that others have created and adapt them to your own uses.
Visualization libraries, including Geogebra and Viz.js, are built in and ready to go.
The code is open sourced and available to install locally if you want to do so.

I have never planned to be a one-person software company. I will gladly take the output of a team of creative folks that know what they are doing with code over my own pride, particularly when I am energized and focused on what my classroom activities will look like tomorrow. The site makes it easy to generate assessments that I can use with my students with a minimal amount of friction in the process.

I’ll get more into the details of how I’ve been using Numbas shortly. Check out what they’ve put together – I’m sure you’ll find a way to include it in part of your workflow this year.

QuestionBuilder: Create and Share Randomized Questions

I’ve written previously about my desire to write randomized questions for the purpose of assessment. The goal was never to make a worksheet generator – those exist on the web already. Instead, I wanted to make it easy to create assessment questions that are similar in form, but different enough from each other that the answers or procedures to solve them are not necessarily identical.

Since January, I’ve been working on a project called QuestionBuilder. It’s a web application that does the following:

Allows the creation of assessment questions that contain randomized elements, values, and structures.
Uses regular Javascript, HTML, and the KaTEX math rendering library to create and display the questions
Makes it easy to share questions you create with community members and build upon the work of others to make questions that work for you.

Here’s a video in which I convert a question from the June 2016 New York State Regents exam for Algebra 2 Common Core into a randomized question. Without all of my talking, this is a quick process.

I’ve put a number of questions on the site already to demonstrate what I’ve been using this to do. These range from simple algebra to physics questions. Some other folks I appreciate and respect have also added questions in their spare time.

For now, you’ll need to create an account and log in to see these questions in action. Go to http://question-builder.evanweinberg.org, make an account, and check out the project as it exists at this point.

My hope is to use some time this summer to continue working on it to make it more useful for the fall. I’ll also be making some other videos to show how to use the features I’ve added thus far. Feel free to contact me here, through Twitter (@emwdx), or by email (evan at evanweinberg.com) if you have questions or suggestions.

Problems vs. Exercises

My high school mathematics teacher, Mr. Davis, classified all learning tasks in our classroom into two categories: problems and exercises. The distinction between the two is pretty simple. Problems set up a non-routine mathematical conflict. Once that conflict is resolved once, problems cease to be problems – they become exercises. Exercises tend to develop content skills or application of knowledge – problems serve to develop one’s habits of mathematical practice and understanding.

I tend to give a mixture of the two types to my students. The immediate question in an assessment context is whether my students have a particular skill or can apply concepts. Sometimes this can be established by doing several problems of the same or similar type. This is usually the situation when students sign up for a reassessment on a learning standard. In cases where I believe my students have overfit their understanding to a particular question type, I might throw them a problem – a new task that requires higher levels of understanding. I might also give them a task that I know is similar to a question they had wrong last time, with a twist. What I have found over time is that there needs to be a difference between what I give them on a subsequent assessment, or I won’t get a good reading on their mastery level.

The difficulty I’ve established over the past few years learning to use SBG has been curating my own set of problems and exercises for assessment. I have textbooks, both electronic and hard copy, and I’ve noted down the locations of good problems in analog and digital forms. I’ve always felt the need to guard these and not share them with students so that they don’t become exercises. My sense is that good problems are hard to find. Good exercises, on the other hand, are all over the place. This also means that if I’ve given Student A a particular problem, that I have to find an entirely different one for Student B in case the two pool their resources. In other words, Student A’s problem then becomes Student B’s exercise. I haven’t found that students end up thinking that way, but I still feel weird about using the same problem multiple times.

What I’ve always wanted was a source of problems that somehow straddled the two categories. I want to be able to give Student A a specific problem that I carefully designed for assessing a particular standard, and student B a different manifestation of that same problem. This might mean different numbers, or a slight variation that still assesses the same thing. I don’t want to have to reinvent the problem every single time – there must be a way to avoid repeating that effort. By carefully designing a problem once, and letting, say, a computer make randomized changes to different instances of that problem, I’ve created a task I can use with different students. Even if I’m in the market for exercises, it would be nice to be able to create those quickly and efficiently too. Being able to share that initial effort with other teachers who also share a need would be a bonus.

I think I’ve made an initial stab at creating something to fit that need.

Exploring Functions (and Non-Functions) Interactively

Heeding Dan’s encouragement to step things up in his NCTM talk, I revisited an introduction to functions activity that I put together three years ago. The idea is to get students to make observations about inputs and outputs and use the ‘notice and wonder’ parlance from the Math Forum to prompt conversations about these ideas.

I rewrote the activity with some deliberate changes and webified it to make it easy to access and share – you can find it here:
http://emwdx.github.io/functions-exploration/index.html

The activity has a few elements that I want to highlight with the hope that you might consider (a) trying the activity with your students or (b) downloading the code for the activity, tweaking it, and then re-sharing it with your enhancements.

Students go through the modeling cycle multiple times.

The activity begs students to take a playful approach. Change the input value and watch the output. Predict what’s going to happen and see if your mental model is correct. Then do the next one, and the next.

Arithmetic isn’t necessarily a prerequisite.

Some students were actually more puzzled by the functions that took text inputs. They experimented nevertheless to figure out what was happening, and some noticed that the pattern worked for numbers too.

Controversy is built in.

Students working on Functions 5 and 6 saw nothing weird happening when they worked alone. When they then went to share their answers with classmates, the latter function started some really interesting interactions between students trying to figure out who was wrong.

Students of different levels all succeeded and all struggled at some point.

One student zipped through the arithmetic exercises and then got stuck figuring out Function 3 or 7. Some of the weaker students jumped around and got Functions 1 and 4 and 8, which is enough to get in the game of finding patterns and drawing conclusions. A higher level student experimented with Function 7 to find that there was a well defined range for the outputs – random, but with limitations.

The need for definitions came out of the activity, not the other way around.

Students felt the need to clearly define the behavior of Functions 6 and 7 as being different than the others in a fundamental way. Definitions for relations and functions weren’t huge cognitive jumps for students since there was a recently established context. It’s also important to notice that the definition for relations that aren’t functions has to be more than just the lack of a pattern. Function 6 helps with this.

Many of the CCSS standards for mathematical practice are embedded within.

…as are some of the high school standards for functions.

If you try this with students, let me know how it goes.

Technical Details:

If you want to try this yourself, you can download the code from Github here:
https://github.com/emwdx/functions-exploration/tree/gh-pages

I did this also as an attempt to whip together something using the React JS library which I’ve been learning recently. It makes for a really nice interface for building this type of interactivity into a webpage. There will be more, so stay tuned.

The React components for the eight functions are in lines 86-102 of the index.html file. The function definitions used by each component are defined toward the bottom of the code in that file. You could change these around using Javascript to make these functions fit with your vision of this activity for students. The file is self contained, so you share just the HTML file you change with students, the page will function correctly.

Happy coding!

Hosting Meteor JS Applications – My Process on Webfaction

There has been some interest expressed here and on Twitter for a description of the process of moving an application from the free meteor.com to my own server. I run my web applications (such as this blog) on Webfaction, which gives a lot of flexibility for setting up a number of different hosted services. I won’t say each step below is easy and as straightforward as it sounds, so feel free to add your difficulties to the comments below, and I’ll elaborate. Having the steps in one place will hopefully be as useful for you as it likely will be for me.

Note: Steps 1 – 3 in the list below are just for downloading data you may have collected in an online application onto your computer. If you don’t care about the online data, you can skip down to step 4.

I installed Mongo on my local machine from http://www.mongo.org
In a terminal on my local machine, I entered meteor mongo --url my-app.meteor.com to get the username, password, url, port, and database name from the *.meteor.com website. The result is a URL that contains the information you will need for the next step: (username:password@url:port/databasename)
save the data onto my local computer using mongodump --host hostname:port --db databasename -u username -p password -o ~/Desktop where the information from the last step replaces the username, password, etc.
To create a packaged version of the app that runs on my computer, go to the Meteor project directory, and type meteor build --architecture os.linux.x86_64 ./ . This assumes that the server that will be running your project is a Linux machine…but this assumption is probably a good one for most hosting services.
Create a free account on mLab (http://www.mlab.com). The free account gives you 500 MB of space for databases. For comparison, the total size of my most-used application is only 2.7 MB. I think you’ll have enough space. The important thing to get, once you have a database set up, is called the URI. If you create a database, there is a box at the top of the page that gives you information that looks like this: mongodb://:@dsXXXXXXX.mlab.com:PORT/DATABASENAME which you will need in the next step.
I learned the Webfaction specific steps from reading this page, though you won’t need to do the Mongo steps if you are using mLab as I am. On the Webfaction server, you must install node. You can do this by following the steps here. You must also create a custom WebSockets application. This will give you a port number that you will need in the step below where local variables are set.
Again, this is a Webfaction specific instruction, but you need to attach the application to a domain/URL where your application will be accessed. Save this URL
Once you have created the WebSockets app, upload the .tar file (from step 4) to the /webapps/web-sockets-application directory through ftp and unpack with tar -xzf my-app.tar.gz
Using the mLab information from step 5, the port number from step 6, and the location of the node application from step 6, you’ll need to fill in the appropriate parts of the commands below:

export MONGO_URL="mongodb://:@dsXXXXXXX.mlab.com:PORT/DATABASENAME?autoReconnect=true" # 2
export MAIL_URL='email-address-for-sending-mail-from-your-app'
export PORT="PORT-NUMBER-FROM-STEP-6"
export ROOT_URL="DOMAIN-FOR-APPLICATION-FROM-STEP-7"
export PATH=~/webapps/node/bin/:$PATH
Almost there, folks. Inside the unpacked .tar directory (which will be called /bundle), enter the /bundle/programs/server/packages directory and run npm install
Go back to the /bundle directory and run nohup node main.js . This terminal command will run a command continuously on the shell, even if you close the terminal.
If you’ve made it this far, you might just have your Meteor app running on your own server.

I hope this helps you, but if you run into trouble, throw a comment below and I’ll see if I can help.

Standards Based Grading & Streamlining Assessments

I give quizzes at the beginning of most of my classes. These quizzes are usually on a single standard for the course, and are predictably on whatever we worked on two classes before. I also give unit exams as ways to assess student mastery of the standards all together. Giving grades after exams usually consists of me looking at a single student’s exam, going standard by standard through the entire paper, and then adjusting their standards grades accordingly. There’s nothing groundbreaking happening here.

The two downsides to this process are that it is (a) tedious and (b) is subject to my discretion at a given time. I’m not confident that I’m consistent between students. While I do go back and check myself when I’m not sure, I decided to try a better way. If you’re a frequent reader of my blog, you know that either a spreadsheet or programming is involved. This time, it’s the former.

One sheet contains what I’m calling a standards map, and you can see this above. This relates a given question to the different standards on an exam. You can see above that question 1 is on only standard 1, while question 4 spans both standards 2 and 3.

The other sheet contains test results, and looks a lot like what I used to do when I was grading on percentages, with one key difference. You can see this below:

Rather than writing in the number of points for each question, I simply rate a student’s performance on that question as a 1, 2, or 3. The columns S1 through S5 then tally up those performance levels according to the standards that are associated with each question, and then scale those values to be a value from zero to one.

This information was really useful when going through the last exam with my ninth graders. The spreadsheet does the association between questions and standards through the standards map, so I can focus my time going through each exam and deciding how well a student completed a given question rather than remembering which standard I’m considering. I also found it much easier to make decisions on what to do with a student’s standard level. Student 2 is an 8 on standard 1 before the exam, so it was easy to justify raising her to a 10 after the exam. Student 12 was a 7 on standard 4, and I left him right where he was.

I realize that there’s a subtlety here that needs to be mentioned – some questions that are based on two or three standards might not communicate effectively a student’s level with a single 1, 2, or 3. If a question is on solving systems graphically, a student might graph the lines correctly, but completely forget to identify the intersection. This situation is easy to address though – questions like this can be broken down into multiple entries on the standards map. I could give a student a 3 on the entry for this question on the standard for graphing lines, and a 1 for the entry related to solving systems. Not a big deal.

I spend a lot of time thinking about what information I need in order to justify raising a student’s mastery level. Having the sort of information that is generated in this spreadsheet makes it much clearer what my next steps might be.

You can check out the live spreadsheet here:

Standards Assessment – Unit 5 Exam

Boat Race, Revisited

A couple of years ago, I was impressed with Dan Meyer and Dave Major’s creation of Boat Race, an activity that involved navigating around buoys with some knowledge of bearings. I hoped to use his creation for my ninth graders two years ago, but Boat Race in its original form was zapped from the interwebs. At the time, I did an analog version, which you can find here in PDF form:

07 – CW – Boat Race

This year, when looking at my materials in the revamped Math 9 course, I felt compelled to take a crack at my own digitization of this activity. Here’s the result:

You can also visit the live site here and try it out yourself.

Boat Race

The moving circle moves painfully slow by design. Students will (hopefully) be compelled to do a good job of calculating distances and angles accurately. I plan to give them the analog version on paper for planning purposes. Shortest time by the end of the class wins fame and glory.

#Teachers Coding – Bingo Cards

When I attended a Calculus AB workshop back in 2003, one of the nice takeaways was a huge binder of materials that could be used immediately with students. I ended up scanning much of those materials and taking the digital versions with me when I moved overseas.

One of these activities was called derivative bingo. This was a set of two sheets, one with a list of expressions, and another a 5 x 5 bingo card with the derivatives of those expressions. It was perfect to use after introducing derivative rules such as the product and quotient rules to develop proficiency.

It also wasn’t as fun of an activity for two reasons. The first was that I only had one bingo card provided as part of the activity. Since everyone had the same card, everyone would really obtain five in a row after doing the same set of problems. Yes, I could have made different ones at some point in the past twelve years to resolve this problem, but I never thought about it with enough advance time to do so. The other reason was that the order of the list of derivatives was carefully designed so that you only obtained five in a row after doing most of the problems provided. Good for the purposes of getting students to do more practice, but definitely an attribute that hacks the entertainment value even more.

As you might expect, I wrote a computer tool to manage this. You can visit this site and see a sample card. Reload the page, and you’ll generate a new one.

This turned into a nice little competition between groups of students, and I kept a tally of how many total rows had been matched by each group as they developed. The different cards led to some great conversations between students about their results:

I use the KaTEX rendering library to make the mathematical expressions look good. If you would like to edit the files for use with your own class, you can go to the GitHub repository here and download a zip file with all of the files. You’ll find instructions there for changing the code to fit your needs. If those instructions don’t make sense to you, let me know.

If you would just like a set of cards for the derivative practice activity that is ready for use with a class, that PDF is here: derivative-bingo-class-files

Another WeinbergCloud Update

I decided a full overview of my online WeinbergCloud application was in order, so I recorded a screencast of me going through how it currently works. It’s kind of neat that this has been a project under development for nearly two years. I’ve learned a lot about HTML, Javascript, the Meteor framework, and programming in general in the process, and it has been a lot of fun.

Stay for as long as you like, and then let me know your thoughts in the comments.

« Prev 1 2 3 4 … 8 Next »