Monthly Archives: October 2015

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.

Playing with Transformers & Building an AC to DC Converter

My one remaining IB Physics HL student was alone in class today, so I made a quick switch on plans to do one of the required activities in the syllabus: building a full-wave rectifier circuit. This was also an opportunity to play with transformers (no, not that kind of transformer) which I presented last class as a really useful application of electromagnetic induction:
IMG_1607

IMG_1602

I did almost nothing during the whole class period, aside from giving instructions and asking questions. With wires, resistors, and other circuit parts all over the place, this was not a well organized lab, but that doesn't matter. Here's what we did:

  • Measure the AC voltage and frequency coming out of the supply
  • Connect the supply to one of the transformer coils, and place the other coil inside. Measure the voltage and frequency on the secondary coil. Comment on the number of coils on the primary and secondary. Observe the effect of inserting an iron core into the transformer.
  • Predict what would happen if the two coils were switched, then measure to compare with prediction.
  • Build a half-wave rectifier circuit with a diode and resistor using the secondary coil as a supply. Measure the voltage wave form.
  • Build a full-wave rectifier circuit, and measure the voltage signal across a resistor. Check this out:
    IMG_1603

    This yielded a nice ripply DC signal:
    IMG_1604

  • Connect a capacitor in parallel with the resistor.
    IMG_1606

    As we had hoped, the ripples are almost gone!:

    IMG_1605

In the final step, I connected a 5V regulator to the output and showed that this would be a way to make a cell phone charger if we had the right USB connector.

This is quite possibly the most satisfying and successful 'let's build something' lab I've done with students. It fit neatly within a class period, including the clean up time. Granted, things would be different if there were multiple groups going through the process, but I'll just ignore that fact because it's a Friday.

Crutches and Exponents

Math teachers frequently discuss how students forget what the exponent rules actually mean when they make mistakes applying them. The layer of abstraction that these rules lay over the numbers and operations is at fault, of course. The reason we teach the rules is that they show structure that goes beyond the operations. They simplify our work in calculating expressions.

I was really glad that a student used this approach today when she forgot the rules:
Screen Shot 2015-10-29 at 9.38.07 AM

I would much rather a student move back to a method they know rather than blindly apply the rules they don't. This method, or crutch, is less efficient, but holds more meaning for the student. We dissuade students from crutches like counting on their fingers because they should be able to do the arithmetic in other ways. Building meaning is important, however, and the better approach would be to show how learning the mathematical ideas and structures can simplify the process. In speaking with this student afterwards, it was clear that going back to this method that we used to motivate the rule helped her understand what it meant.

I continued with this approach in reviewing zero and negative exponents today. Of the students that said they knew the rule already, only a couple of them actually applied it correctly before we did this activity. I primed the class with this:
Screen Shot 2015-10-29 at 9.41.32 AM

Students worked in groups to apply the rules and rewrite them, and I nudged them gently with using what they saw as motivation for rules about zero and negative exponents. From this, I introduced a new crutch as a way to show what negative exponents mean:

Screen Shot 2015-10-29 at 9.43.48 AM

Just as the student wrote out the factors and then divided them out in the problem above, I don't mind if a student does this as a reminder of what the rule means. I find this much more productive than a simple rule that states that fractions to a negative power simply 'flip'. Hopefully I'll see the benefits of this approach moving forward.

On Randomness & Teaching

I really enjoyed this article from Fast Company on the value of randomness in art and design.

As I read, I found many points resonated with what I feel about certain aspects of my teaching practice:

RANDOM VALUES CAN FILL IN THE UNIMPORTANT BLANKS

...The key here is an intelligent decision about what is ordered and configured versus what is appropriately random. In this kind of situation, a random function directly generates some aspect of the work, but that that aspect is usually not the focus.

I write often about the power of using programming and computation to take care of tedious tasks. This article reminded my that I also use computation to introduce randomness in situations where I don't care about the specifics. I often use a random group generator to make groups for classes. When the size of the groups matters to me on a given day, I use the generator. When the composition matters though, I might arrange them by hand because I don't have a tool to manage group composition automatically.

Another situation is where I need a nicely factorable quadratic expression - the values don't matter, but it must be factorable over the rational numbers. The randomness fills in where the details are unimportant here. I can make up a pair of binomials and multiply it out mentally, but I'd rather put in the time to make a generator do this for me. This is where my Khan Academy powered reassessment problem generator has been serving me exceptionally well:

generating-problems

Randomness also helps identify what matters to me and what doesn't. Sometimes I'll start generating random problems and realize that I want negative coefficients, or a pair of irrational zeroes. Making decisions and recognizing the patterns is what I want to be spending my time doing, and the computer inserting randomness helps me focus on these tasks.

Here's more from the article:

RANDOMNESS CAN BE USED TO EMPHASIZE THE ALGORITHM OVER THE RESULTS

Sometimes, the contribution of an artist or designer consist of the rules, logics and coded relationships rather than the output of that process. Repeatedly running the algorithm with random input values can productively undermine results relative to process.

It is an interesting challenge to design generators of questions that nurture specific types of thinking in students. Sometimes that thinking involves deliberate practice of a skill. Other times it involves figuring out a pattern. If students observe after solving a few equations that the form is the same or that the distributive property always seems to be useful after step three, they are identifying and making use of structure as CCSS.MP7 wishes they would.

animated

Having students notice what is the same about sets of different problems requires that you have a set of problems for them to look at. Textbooks always have these sets, but they are already neatly organized into rows and types. Being able to generate these problems easily and have students do the organization is a great way to get them to do the pattern finding themselves.

Student Feedback on Class Notebooks

There have been a lot of great moments since I started using a OneNote class notebook as my main repository for class notes. I wrote previously about what I was doing differently, and a lot has happened since then. The blog post in which I detail those developments is coming, I promise.

To tide you over, I'll share this great note that a student wrote in a portfolio reflection before the first quarter reports about our use of OneNote. I think it pretty much sums up why it has totally been worth making a fundamental change to the normal structure of class notes in my classroom. Here's the student:

For this quarter, Mr.Weinberg made us a cool thing called OneNote. We were able to record the class notes and upload the practice problems for every section online, and share freely. As we got to make our own reviews and share with the whole class, I had more opportunities to go over again with all the tiny details to find any mistakes since I did not want my classmates to learn something incorrect because of me. Therefore, not only my friends could get better understanding, but I could have a more thorough review and have better understanding too. Last time I worked for it, I was working as a group with _______. She organized the information that we learned in class, and I did the practice questions. I used to skip many steps in between the calculation and solving process, but this time I did all the question step by step, even for the questions that looked obvious to me, just to help out my friends’ understanding.

I did feel the need to correct the record with this student that I didn't actually create OneNote. Aside from that, this is the kind of perfect validation that I'll take from students any day of the week.

Credit Expiration & Standards Based Grading

For the background on my reassessment system, check out this previous post.

Here's the run down of my progression in using standards based grading over the past couple of years:

  • When students could reassess whenever they wanted, they often did so without preparation. They also rushed to do as many reassessments as possible at the end of a quarter or semester. I also needed a system to know who had signed up for a reassessment, for which standard they were assessing, and when they were coming in.
    Solution: Students needed to complete a reassessment sign-up form through Google Forms that included reflection on work that was done to review a standard. In general though, the reflection on these forms wasn't strong. I needed more, but didn't get around to clearly defining what I meant by strong reflection.
  • The difficulty of scanning through a form and getting the information I needed prompted me to create an online site using the Meteor programming framework that lets students sign up for reassessments. In real-time, this sorts the reassessments for a given day and helps me stay organized. The problem was that I still wasn't satisfied with what students needed to do to reassess. They needed to review their mistakes, talk to me, practice and get feedback, and then sign up. Having a way to manage that process was essential.
    Solution: The introduction of credits. Students earned credits for working after school, showing me practice problems, and doing other work to support the deliberate practice and learning needed to get closer to mastery.
  • Many students hoarded their credits until the end of the semester. This prevented the cycle of feedback about learning from continuing, and caused the end of the semester to still be a mad rush to reassess whichever standards are lowest in the grade-book using a machine gun approach.

This brings me to what I wrote about in my year-end reflection about SBG at the end of last year. Hoarding credits and saving them until they want to use them causes less reassessment, and that's not right. I want to nudge students to reassess more often and know that they should take opportunities as often as possible to show what they know. I've threatened to make credit expiration happen since August, and students have been asking when it would start.

No time like the present.

After working on this for a couple of days, I've activated a feature on my reassessment management app that allows credits to expire.

Screen Shot 2015-10-15 at 8.45.55 AM

Right now, I will be expiring credits manually. I need to see how students respond to this change before the system does this automatically. I get a visual indication that a given credit has expired and click the 'fire' button to expire the credit. I can also restore the credit if I change my mind. The asterisk button lets me apply the credit lifetime in the input box to a specific credit and change the expiration.

For old credits, I applied a much longer lifetime, but as students learn to adjust their behavior, I'm starting with a ten day expiration lifetime. That seems to be just the right amount of time to get students assessing within a reasonable amount of time of doing work related to a standard. I don't think this changes the time pressure to learn something within a given amount of time, which is one of the benefits of SBG. It does change the pressure to assess within a given amount of time, which I do want to happen.

I'm also adjusting some of my policies that cause the hoarding in the first place. Some of this tendency was a consequence of my system - I haven't let students go from a 5 to a 10 (on a ten point scale) with one assessment session. Mastery is demonstrated over time. I typically had students go from a 5 to an 8 on a perfect first assessment, and then left it there until the unit exam, when students can demonstrate mastery of standards in the context of many other problems.

I'm planning to loosen this progression in light of the credit expiration changes here. If a student is able to demonstrate the ability to answer questions related to a standard, no matter what I throw at them, that's a pretty good hint on their mastery level. It's up to me to give reassessment questions that measure what I'm looking for though. That's where the art of good assessment and experience comes in. I reserve the right to not raise the mastery level if I'm not convinced of a student's level - students know that taking a reassessment does not automatically mean their level will be raised. As long as that understanding continues, I think these changes will lead to better learning.

As always, I'll keep you all updated with how well this works in practice. I can always turn this feature off if it's a disaster.

#TeachersCoding: Improving Report Writing with CommentHelper

Whenever I start the process of report card comments, I always think of how I might make things more efficient. Text-expander? A comment bank nearby for cutting and pasting common phrases? In the end, however, I end up writing them all from scratch anyway, usually in a spreadsheet. Storing comments that way means that over the course of a year, I can see the progression of my comments for a given student. I like being able to do that, but using a spreadsheet as a writing interface is lousy.

I started thinking about my comments workflow a bit earlier than usual, so there was time to think about using code to redesign the process. I write a lot of the same things over and over again in the process of writing comments. Might it be possible to use code to make this more efficient?

The first thing I thought to do was some word analysis to figure out what phrases to use. I picked up a nifty book: Web Scraping with Python which has a chapter on language processing. There I learned about the n-gram library in Python, which has the ability to parse text for phrases of a given length. I took the text of my comments from last year and ran them through a script to create a list of three, four, and five word phrases that appeared multiple times. I then took this list and embedded it in a file that used the jQueryUI Autocomplete function to make those common phrases available.

Here was what I ended up with:

Screen Shot 2015-10-09 at 8.01.18 AM

The common text area is where I put the blurb about the course that is common to each class of students. Clicking the 'Add Common' button adds that text to the text box below. I type the student specific text into the horizontal box below that button, and hitting the right arrow key dumps that text into the comment box below and clears out the text input. As I type into the middle text box, common phrases pop up, and I can select them with the arrow keys.

How well did this work? Well, the autocomplete thing didn't end up being that useful. The phrases that my script picked up certainly showed up frequently in the words that I typed, but it didn't feel like using them saved much time. The autocomplete function I put in only matches the complete text in that box, so I would have had to know in advance that I wanted a common phrase, hit the arrow key, and then start typing that phrase afterwards. Not really a time saver. I suppose curating those phrases a bit more carefully would have made for a better use of that function.

What was interesting, however, was that it was easier for me to focus when I was constantly writing in the text box, and then appending that text to the comment when I knew the text was the way I wanted it. Clearing out the text each time made it easier to say exactly what I wanted to say without having to read the entire sentence before. I occasionally moved down to the comment box to patch up the wording directly, but most of the text input was through that middle box. I wonder if clearing the box also cleared my head to let me think what I wanted to say next.

Anyway, it was a fun exercise. Feel free to adapt and use for your own purposes. You can download the code from Github as a zip file. The file comment-helper.html is the file you want to open. You could clear out the phrases in the phrases.js file and use your own.

Let me know if you try this to good effect. Happy coding, and happy Friday everyone!

Perplexity and Figuring It Out

For two years in a row, I've hit a sweet spot of engagement, discussion, and really invigorating student interaction with one particular exercise in my web design course. I sit with a web browser console open, and just ask students to go through this cycle:

  • Make a prediction of what's going to appear when I hit enter.
  • See what actually appears.
  • Adjust your model and repeat.

Here was today's series:
Screen Shot 2015-10-08 at 3.56.01 PM

I say almost nothing aside from "here's another one". The amount of laughter, head slapping, and students talking through their attempts to understand is a beautiful thing to witness. The fact that no student blurts out the answer speaks to the respect my students have for each other and for this model.

This is a simple type of activity that I do from time to time, and only from time to time, because I don't want it to lose its novelty. There's no engagement from a real world context. There's no lecture beforehand about what I'm about to do, and how I want them to respond. (Ok, I do ask that they not blurt out the answer or how it works once they know, but that's about it.)

I hope to establish an unspoken agreement with my students that goes something like this:

  • There is a pattern, and I am confident that you'll be able to figure it out.
  • If you can't get it right away, that's fine. You probably aren't the only one.
  • If you are the only one, then you have a lot of people around to nudge you in the right direction.
  • If you're wrong, you'll get another chance to be right in just a minute.
  • Once you know how it works, you might not care anymore. Enjoy the journey.

Getting this agreement across takes time and trust and is really difficult to force. It's remarkably satisfying when it happens. The important part is the consistent commitment to failure: Everyone will fail at least once. Everyone will also likely be wrong at least once after they are right.

Building (Ev)anAcademy Exercises for Reassessments

I've written multiple times previously about WeinbergCloud, the system I created using the Meteor framework that lets students sign up for reassessments. Over the course of the semester, I've been developing some aspects of the system that I'm excited about, and I'll talk about them all eventually. One in particular has held my focus for the past few days, and it's probably the one feature I've been talking about for the longest: building a reassessment engine within the system.

Part of this is out of necessity. The wireless network settings on our school network have changed, so the Python reassessment engine that I've used for reassessments over the last two years no longer works when hosted on my personal laptop. I've managed reasonably well this year using problems from textbooks and handouts, but it became time to automate this using my new knowledge of Javascript and Meteor.

Whatever your feelings about Khan Academy, the reality is that the organization has put a lot of energy and resources into developing a pretty comprehensive web application built around assessment. Not only are these resources available for free for teachers and students to use, but the source code is as well. The code for anyone to be able to run their own local version of exercises has been around for a while at Github here. The Javascript libraries that go with these exercises are also pretty impressive and capable - generating random numbers with constraints, simplifying fractions and expressions, and numerous other helper functions are already written by people that code much better than I do. They also wrote a math-typesetting library called KaTEX that has some performance advantages over some other libraries...or so I hear. I'm sure much of the 'why' here is lost on me.

After two days of tinkering, I've adapted some of their code in my app for the purposes of generating questions for reassessments. Writing questions and defining variables is all done in HTML, just as in their own local application, which means it's possible to add questions without having to load in a database through FTP or some other method. The code rendering the questions onto the webpage I had to write myself, but eventually I determined some ways to make this work for me.

I can put in HTML and Javascript definitions into text areas. Here's an example of a question asking for a simplified fraction for slope:
Screen Shot 2015-10-02 at 9.14.46 PM

A preview appears below to make sure the question appears the way I want it. In the variable definitions are strings of Javascript code that calculate and define the variables using the Khan Academy utility functions. The question text is then rendered using KaTEX. The random values change on each reload of the page, but these values could potentially be fixed for an individual student's quiz.

As I create frames for questions, I get a virtually infinite supply of questions I can use for assessing students on learning. Here are a bunch that I put together for testing the interface:

Screen Shot 2015-10-02 at 9.35.43 PM

The next step is to link each question frame to a course standard and build my database of questions. I'm loving the possibilities for building on this further, and will share as they develop. Stay tuned.