My Journey with Meteor as a Teacher-Coder

Many of you may know about my love for Meteor, the Javascript framework that I’ve used for a number of projects in and around the classroom. I received an email this morning alerting me (and the many other users) that the free hosting service they have generously offered since inception would be shutting down over the next month.

To be honest, I’m cool with this decision. I think it’s important to explain why and express my appreciation for having access to the tool for as long as I have.

I started writing programs to use in my classroom in earnest in 2012. Most of these tended to be pretty hacky – a simple group generator and a program to randomly generate practice questions on geometric transformations were among these early ones. The real power I saw for these was the ability to collect, store, and filter information that would be useful for teaching so that I could focus my time on using that information to decide on the next steps for my students. I took a Udacity course on programming self-driving cars and on web applications and loved what I learned. I learned to use some Python to take some of the programs I had written early on and run them within web pages. I built some nifty online activities inspired by the style of Dan Meyer and put them out for others across the world to try out. (Links for these Half-Full and Shapes tasks are below.) It was astounding how powerful I felt being able to take something I created and get it out into the internet wilderness for others to see.

It was also astounding how much time it took. I learned Javascript to manage the interactivity in the web page, and then once that was working, I switched to Python on the server to manage the data coming from users. For those that have never done this sort of switching, it involves a lot of misplaced semicolons, tabs, and error messages. I accepted that this was the way the web worked – Javascript in front, and Python (or PHP, Rails, Perl, etc.) on the back end. That extra work was what kept someone like me from starting a project on a whim and putting it together. That cost, in the midst of continuing to do my actual job of teaching and assessing students five days a week, was too great.

This was right around the summer of 2013 when a programmer named Dave Major introduced me to Meteor. I did not know the lingo of reactivity or isomorphic Javascript – I just saw the demonstration video on YouTube and thought it was cool. It made the connection between the web page and the server seamless, eliminating the headaches I mentioned earlier. Dave planned to put together some videos and tutorials to help teachers code tools for the classroom using Meteor, and I was obviously on board. Unfortunately, things got in the way, and the video series didn’t end up happening. Still, with Dave’s help, I learned a bit about Meteor and was able to see how easy it was to go from an idea to a working application. I was also incredibly impressed that Meteor made it easy to get an application online with one line: meteor deploy (application-name here) . No FTP, no hostname settings – one line of code in the terminal, and I could share with anybody.

With that server configuration friction eliminated, I had the time to focus on learning to build truly useful tools for myself. I created my standard based grading system called WeinbergCloud that lets students sign up for reassessments, earn credit for the homework and practice they did outside of class, and see the different learning objectives for my course. I created a system for my colleagues to use to award house points for the great things that students did during the school day. I made a registration and timing system for our school’s annual charity 5K run that reduced the paperwork and time required of our all volunteer staff to manage the hundreds of registrants. I spoke at a Meteor DevShop about this a year and a half ago and have continued to learn more since then.

Most importantly to me, it gave me knowledge to share with a class of web programming students, who have learned to create their own apps. One student from last year’s class learned about our library media specialist’s plan to hold a read-a-thon, and asked if he could create an interactive website to show the progress of each class using, you guessed it, Meteor. Here’s a screenshot of the site he created in his spare time:
Screen Shot 2016-03-11 at 10.34.26 AM

And yes, all of these apps have been hosted on the free deploy server at *, and yes, I will have to do the work of moving these sites to a new place. The public stance from Meteor has been that the free site should not really be used for production apps, something I’ve clearly been doing for over two years now. I re-read that line on the documentation website back in January and asked myself what I would do if I no longer had access to that site. The result: I did what I am paid to do as a master learner, and learned to host a site on my personal server. That learning was not easy. The process definitely had me scratching my head. But it also meant that I had a better understanding of the value that the free site had given me over my time using it.

The reality is that Meteor has clearly and publicly shifted away from being just being that framework that has a free one line deployment. The framework has so much going for it, and the ability to create interesting apps is not going away. The shift toward doing what one does best requires hard choices, and the free site clearly was something that did not serve that purpose. It means that those of us that value the free deploy as a teaching tool can seek other options for making it as easy to get others in the game as it was for us.

Meteor has helped me be better at my job, and I appreciate their work.

As promised, here are those learning task sites I mentioned before:

Choosing the Next Question

If a student can solve $latex 3x – 1 = 5 $ for x, how convinced are we of that student’s ability to solve two step equations?

If that same student can also solve $latex 14 = 3x + 2 $ , how does our assessment of their ability change, if at all?

What about $latex -2-3x= 5$ ?

Ideally, our class activities push students toward ever increasing levels of generalization and robustness. If a student’s method for solving a problem is so algorithmic that it fails when a slight change is made to the original problem, that method is clearly not robust enough. We need sufficiently different problems for assessing students so that we know their method works in all cases we might through their way.

In solving $latex 3x-1 = 5 $ , for example, we might suggest to a student to first add the constant to both sides, and then divide both sides by the coefficient. If the student is not sure what ‘constant’ or ‘coefficient’ mean, he or she might conclude that the constant is the number to the right of the x, and the coefficient is the number to the left. This student might do fine with $latex 10 =2x-4 $ , but would run into trouble solving $latex -2-3x = 5$ . Each additional question gives more information.

The three equations look different. The operation that is done as a first step to solving all three is the same, though the position of the constant is different in all three. Students that are able to solve all three are obviously proficient. What does it mean that a student can solve the first and last equations, but not the middle one? Or just the first two? If a student answers a given question correctly, what does that reveal about the student’s skills related to that question?

It’s the norm to consider these issues in choosing questions for an assessment. The more interesting question to me theses days is that if we’ve seen what a student does on one question, what should the next question be? Adaptive learning software tries to do this based on having a large data set that maps student abilities to right/wrong answers. I’m not sure that it succeeds yet. I still think the human mind has the advantage in this task.

Often this next step involves scanning a textbook or thinking up a new question on the spot. We often know the next question we want when we see it. The key then is having those questions readily available or easy to generate so we can get them in front of students.

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.

Screen Shot 2016-02-25 at 9.07.41 AM

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:

Screen Shot 2016-02-25 at 9.10.02 AM

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

An Easy Transformation: Right Triangle Trigonometry

From Haese and Harris MYP 9:

Screen Shot 2016-02-21 at 5.07.33 PM

I was looking for problems to give my students as applications of the right angle trigonometry from our previous class. The problem is essentially equivalent to the basic questions requiring them to find an unknown side or angle – the work is all done for them. One of my standards is all about parsing a word problem for the information needed to answer it, and this question does not require students to do any parsing.

I removed all of the measurements, and this problem became remarkably more demanding:

Screen Shot 2016-02-21 at 5.08.48 PM

This will certainly prompt more conversation than in its original form.

It’s embarrassing how easy it was to make this change – I anticipate a nice payoff in class.

My Unscientific Case Study on Helpful Explanations

I’ve been fascinated by the discussion on Dan Meyer’s blog about explanations and their role in a math class. This was prompted by this article that makes assertions about the usefulness of these explanations to indicating understanding. The question of what merits the label of explanation and how that relates to ‘showing work’ is an important one, and has been hashed around by the commenters on Dan’s blog. I decided to pitch a question to students that asked them to explain and nudge them in a discussion to get meaning out of their responses.

Here’s the question, which is from the Amsco Integrated Algebra textbook on page 115:
Screen Shot 2015-11-18 at 9.54.27 AM

I took pictures of their responses and then put them up two at a time in front of the class. I didn’t pair them up deliberately, which might have been more interesting. After putting them up, I asked students to first share their observations about what made them different. There wasn’t much of a responses, but I wrote what was shared underneath. I also asked for each pair to vote on which of the two was more helpful to understanding the answers. Here are the results:

Pair A:
Screen Shot 2015-11-18 at 10.00.07 AM

3 voted for the one on the left, 11 voted for the one on the right.

The one student that spoke up said that the one on the left makes more sense because the one on the right merely shows the pattern. I didn’t get more out of this student in terms of explanation, and other students weren’t stepping up to share.

Pair B:
Screen Shot 2015-11-18 at 10.02.03 AM

10 voted for the one on the left, 4 voted for the one on the right.

The left example is the sort of diagram that I think I’ve seen in those Facebook posts knocking Common Core. I’ve never shown them this kind of diagram though – this was 100% from the student who, knowing this student’s history, has never stepped into a CCSS classroom in the United States to be taught this explicitly. This student decided to make this diagram because she felt it best showed her understanding of the problem. On the right is a set of arithmetic problems that show precisely the same thing, and the students preferred it, but weren’t willing to share why.

Pair C:
Screen Shot 2015-11-18 at 10.02.51 AM

In a move that surely would appease the writers of the article Dan referenced in his post, 2 students voted for the left one, and 12 voted for the right.

I’m not sure what these results mean aside from the comments I’ve already shared. I think it would be easy for Garelick and Beals to point to the preferences of my students as evidence that supports their argument. I think the role of showing answers in this context are different from one of testing, which is one complication of this result. The other is that my question on answers being ‘helpful’ might be dramatically different from asking which answers best show ‘understanding’.

Certainly a more carefully designed experiment might tease out more. This might be the sort of task to use Desmos Activity Builder or PearDeck to give students a chance to share their thoughts in a less public setting.

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:


…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:


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:


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.


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.

An Easy Transformation

Screen Shot 2015-10-16 at 10.19.21 AM

Solve every problem, or maybe just the odds.

Screen Shot 2015-10-16 at 10.21.02 AM

Instructions given to students:

  • Group the problems you think belong together
  • Work with your group to write out a rule that works to simplify the expressions in each group
  • Clearly show how the rule applies to simplifying each expression.

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.

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.