Monthly Archives: January 2012

Rethinking the Office Hours app

It’s Winter Semester at BYU, and I’m again the TA for Phil Windley’s Distributed System Design class (CS 462). This time, we roped Reed into being a TA as well. We really liked the idea of the Office Hours app from last year, but we have a few different requirements this year:

  • There are two of us now, instead of just one, so the Google Calendar holding the hours got more complicated.
  • Since Reed and I both work in a research lab, we want to be available to the students without having to sit down in the TA cubicles all day. We created “on-call” office hours, during which we are available to help students but we won’t be physically present until someone actually shows up.

Those two things increased the complexity of the problem fourfold. We used the same basic model as before (texting via Twilio) but chose a more distributed design:

Here is how this works in terms of events:

  1. The SMS is received by Twilio, raising a twilio:sms event to the dispatch ruleset.
  2. The dispatch ruleset checks the Google Calendar to see if anyone is on the schedule. If so, it raises a schedule_inquiry event to the rulesets handling hours for each TA. If not, it raises an absent event.
  3. The dispatch ruleset responds to the absent event by sending a text to the student that no TAs are on the schedule now. It also includes the date and time of the next office hours.
  4. The individual TA rulesets respond to the schedule_inquiry event by checking the calendar to see whether that TA is on the schedule right now. There are two possibilities: in office and on call. The former raises a present event; the latter raises an on_call_request event. The default behavior is to respond this way:
    • present: Text the student that {Steve|Reed} should be in the cubicle already.
    • on_call_request: Text {Steve|Reed} to get downstairs and reply to the student that he’s on his way.

Separating the TA rulesets allows me and Reed to have the application behave differently for each of us. I prefer texting (or XMPP if I ever figure out a good way to do it), but Reed would prefer email, since his AT&T iPhone gets bad reception in our lab. All I have to do is add another rule to respond to the on_call_request event and make it do whatever I want.

Here is what my version of the TA ruleset looks like:

To read your speech or to speak

Seth Godin wrote a great post today: “Your voice will give you away“. If you give a presentation by reading a speech you wrote beforehand, your voice betrays it. If you’re speaking naturally, your listeners will notice.

The BYU devotional this week was an excellent example of this. President and Sister Samuelson gave a joint speech. They scripted everything and decided who would talk when. But the occasional awkward transition and canned, corny joke betrayed a lack of rehearsal.

At the very end of the speech, Sister Samuelson read her testimony from the script and concluded. Then President Samuelson spoke again and bore his testimony. This time, he had a different tone. He stammered a bit. His words were softer. It was obvious to me that he was speaking from his heart this time, not reading the script. His testimony at the very end of that speech was the most powerful part of the entire hour, because I knew it was real.

The stilted tone made me tune out much of the speech. But when President Samuelson spoke from his heart, I was compelled to listen, and I relished it.


When I give presentations or speeches, I usually write them out beforehand and rehearse them. But I write with the same tone I use when I speak. I use the same expressions; I try to use big words only if I might actually say them. I make it as conversational as the setting permits. Once I have it written out, I practice it again and again until I can speak it without having to read my script.

That method gives a very genuine feel to my talks. The audience thinks I’m just talking, not reading. I work hard to get that tone. Seth is absolutely right.