Category Archives: technology

HyperDoc Folder Cloner Script

Leave a reply

I’m teaching a new class this year in which students complete a lot of activities. Each activity has an associated Google document that provides scaffolding. Students need to reference these activity documents throughout the unit as well as use them as a resource for summative performance evaluations at the end of the unit. My approach this semester is to create a Canvas assignment for each activity and use the GoogleDocs external tool as the submission mechanism. This helps students in that a copy of the Google document is automatically created when they view the assignment, and they just have to click the submit button in Canvas when they finish the activity.

Throughout the semester, I’ve noticed some opportunities for improvement. From a student perspective, while it is helpful that the Google documents are automatically copied and placed in a Google Drive folder for the course, every document from every unit is in that folder. When students need to reference an activity that they have completed, they either have to find the associated Canvas assignment, open it, and then open the associated document; or, they have to browse through all the files in their Google Drive folder for the class and find the document. Modules in Canvas do help somewhat. From my perspective, students submit a ton of assignments to Canvas, at times late (which is fine), and it takes me considerable time to review them. My priority is that students are keeping up on the activities and completing them reasonably accurately such that they can serve as a reference later. I don’t need to score every activity and enter every activity score in the grade book, which is not integrated with Canvas.

For next semester, I wanted to move to more of an electronic lab notebook approach. Each student would still have all of the activity documents, but they would be organized by unit in some manner that provides context and links to each activity document. In the past, I’ve used Google Sites as lab portfolios and was planning on something similar. I would check each student’s lab notebook each weekend and follow up with students individually as needed. I sat down this morning to search for another teacher having already done this, but, surprisingly, came up empty handed. I then assumed that I could write a Google Apps Script that would duplicate a Google Site, copy associated Google documents, and update all the links. I was surprised to find that the new Google sites are not scriptable. With Google Sites no longer an option, I decided to go with a Google Drive folder containing all of the activity documents for a unit and a unit overview hyperDoc with links to all the activity documents. I have almost no experience with Apps Script but was able to piece together a script that does the following:

  • copies all files (but not subfolders) in the specified template folder into a new folder for each specified student
  • makes that student an editor for that folder
  • updates all of the links in the specified hyperDoc to link to the newly copied files; this is done by matching the text in the specified hyperDoc to the file name of the copied files

The script is embedded in a Google sheet that is used to specify this information.

Hyperdoc Folder Cloner

I believe that if you make a copy of this sheet, you will also get a copy of the script which is accessed through the Tools -> Script editor menu item.

I hope others find this helpful. If you run into issues, please let me know. I’ve only done basic testing and won’t use this for real for a couple of weeks when we start the spring semester.

Programming Options while Remote Learning (Updated)

Leave a reply

Barring an unforeseen issue, we will enabling Linux on the chromebooks of students in AP Computer Science A and Software Engineering. APCSA students will use BlueJ and Software Engineering students will use VS Code. The rest of this post is an updated version of the original post which reflects that Chrome OS 81 and later installs Debian 10 (Buster), which resolves many of the issues previously identified.

Given the uncertainty of the structure of high school this fall, I’ve been exploring various options my students in AP Computer Science A if they are learning outside of the classroom without access to our desktops. In the classroom, APCSA students use BlueJ and GitHub throughout the year and leverage Swing and third-party frameworks (i.e., media computation). All students have chromebooks and our district works with families if they don’t have wifi at home. During eLearning and Remote Learning during this past spring semester, we used repl.it as our programming environment. This sufficed given the programming activities and labs at that point in the semester, but it wasn’t ideal. It remains an option for the fall, and I’ll expand upon it later. The options that I explored may not be a good fit for your students, but I hope others find this information helpful.

Linux and Java

Installation

  • My chromebook:
    • Acer Chromebook is x86_64 architecture
    • Version 84.0.4147.127 (Official Build) (64-bit)
  • enable Linux (Beta) via Chromebook Settings app
    • specify username
    • Disk size: 7.9 GB (can change later)
  • install OpenJDK and JFX
    • sudo apt update
    • sudo apt upgrade
    • sudo apt-get install openjdk-11-jdk
    • sudo apt-get install libopenjfx-java
    • sudo apt-get install openjfx

VS Code

Most of my Software Engineering students use VS Code. I was able to get it running on our chromebooks (Acer Chromebook with x86_64 architecture).

Installation

  • enable Linux via Chromebook Settings app
  • download VS Code
  • in the Chrome OS Files app, drag VS Code from the Downloads folder to the “Linux Files” folder.
  • Install VS Code from the Linux VM by running:
    • sudo apt install ./code_1.48.1-1597857616.deb
  • VS Code will now be available from the App Launcher
  • install Java Extension Pack in VS Code
  • configure GitHub
    • install GitHub Pull Request and Issues VS Code extension
    • set user name and email address from terminal
      • git config --global user.name “<name>"
      • git config --global user.email <email>
    • resolve issues authenticating
      • sudo apt install gnome-keyring
      • specify a password for the keychain
    • clone a repository

Configuration

  • With BlueJ, jar files are automatically included in a project if they reside in a “+libs” folder. VS Code has a similar feature if the jar files are in a “lib” folder.
  • With BlueJ, one can directly run any static method in any class. VS Code expects a standard main method to be defined.

Issues

  • initial authorization of VS Code to use GitHub fails
    • second authorization of VS Code to use GitHub works if you copy and paste the authentication URL back into VS Code

Tradeoffs

Pros

  • GitHub accessible
  • debugger

Cons

  • more sophisticated an IDE than desired for APCSA students
  • requires enabling Linux on chromebook

BlueJ

APCSA students have always used BlueJ as their IDE. It was a good balance of features and simplicity as it is designed for educational settings.

Installation

  • download BlueJ
  • install BlueJ
    • sudo dpkg -i BlueJ-linux-422.deb
  • BlueJ will now be available from the App Launcher

Issues

  • nonresponsive on first launch
    • killed, relaunched, worked

Tradeoffs

Pros

  • IDE designed for education
  • debugger
  • GitHub support (integration via Team feature expects a one-to-one mapping between BlueJ projects and repositories, which is different than our model, but doable)

Cons

  • requires enabling Linux on chromebook

repl.it

Students who have taken Computer Programming 1 and 2 before APCSA are familiar with repl.it as it is used extensively in those classes. As mentioned above, APCSA students used repl.it last spring during Remote Learning. However, I wanted a better experience if we use repl.it again this fall.

The GitHub and repl.it integration works best when the repository contains a single project. Historically, we have created a repository for each unit and that repository contains multiple practice programming projects and a summative lab. Forcing our repository model into repl.it requires some additional configuration.

Configuration

  • GitHub Classroom now supports online IDEs (e.g., repl.it)
    • however, Classroom doesn’t support Java Swing at the moment
    • so, create the .replit file explicitly and add to the repo
    • still select repl.it as the online IDE when creating the Classroom assignment but don’t specify a language or a run command
  • example .replit file
    • language = "java_swing"
    • run = "javac -classpath ./TurtleDemo:./TurtleDemo/+libs/* ./TurtleDemo/TurtleDemo.java; java -classpath ./TurtleDemo:./TurtleDemo/+libs/* TurtleDemo"
    • # specify additional run commands for each project but have them commented out
    • # run = "javac -classpath ./ClassNotes ./ClassNotes/SyntaxErrors.java; java -classpath ./ClassNotes SyntaxErrors"
    • [...]
    • # run = "javac -classpath ./TurtleLab:./TurtleLab/+libs/* ./TurtleLab/TurtleLab.java; java -classpath ./TurtleLab:./TurtleLab/+libs/* TurtleLab"

Tradeoffs

Pros

  • GitHub support

Cons

  • students have to edit .replit file when switching between activities
  • no debugger

While exploring these options, I realized that there is an opportunity here even if students are in class with our desktops. While the programming activities and labs are designed so that everyone can complete them during class, some students, for a variety of reasons, need time outside of class. Enabling one or more of these options would provide all students the flexibility to program on their chromebook instead of relying on a Windows/macOS/Linux computer at home or working in the classroom before school.

Streaming and Recording Online Lessons

Leave a reply

The audience for this post is a bit more specialized than usual. This post is for teachers who will be engaged in remote learning, use macOS, and have similar requirements for streaming and recording online lessons as I.

[Updated 12aug2020: I decided to purchase Loopback. It made the audio configuration so much easier. I’ve updated these instructions to tag Loopback and Soundflower-specific information.]

Here are my requirements:

  • online lessons are useful both synchronously and asynchronously, as not every student will be able to attend lessons in real-time
  • online lessons are recorded with high quality and later uploaded to my YouTube channel
  • online lessons are streamed via Google Meet and Zoom (not sure which we will use this fall)
  • during online lessons my audio is only heard via AirPods so as not to disturb my partner who is also working from home
  • multiple video sources; specifically, the FaceTime camera on my MacBook, a screen being shared (to show slides and code), and my iPhone as an external camera to capture demonstrations and drawing on paper or a whiteboard; these can be combined (for example, when displaying my screen also display a small image of me in the corner)
  • multiple audio sources; specifically, the audio from the playing videos and the audio from my mic
  • all of this works on macOS Mojave 10.14.6 (it may or may not work on Catalina)

While this solution focuses on the hardware that I already have, various substitutions should work fine. For example, any earbud/mic device could be used instead of AirPods and an external web camera could be used instead of the iPhone. You could also do all of this on Windows, except for the iPhone hardwired as a video source. From what the kids tell me, the audio configuration is a lot easier and an alternate virtual camera is available.

At the heart of the solution for these requirements is the streaming software OBS. I first learned of OBS when students on our FIRST Robotics team used it when streaming the FIRST LEGO League Qualifying Tournament that we host.

Meeting these requirements was significantly harder than expected. After much iteration, here are the condensed steps to configure a system that meets my requirements:

  • download and install OBS
  • download and install obs-mac-virtualcam
    • In order to stream via Google Meet or Zoom the composite video produced via OBS, you need to configure the video source in Meet or Zoom as the output from OBS instead of any actual camera. The obs-mac-virtualcam creates a virtual camera that displays the output from OBS.
  • [Soundflower] download and install Soundflower
    • By default, OBS cannot record the audio when playing a YouTube video in a browser, music from iTunes, or a video in QuickTime Player. This is a common challenge for those who use OBS to stream themselves playing video games and want to stream the audio from the game.
    • I’ve had Soundflower installed for a while. I don’t remember why anymore. It solves the above challenge in that it allows you to route audio from one application to another. I’ll show below how to use it.
    • Another option is Loopback from Rouge Amoeba. It looks much more powerful and Rogue Amoeba has awesome support. It is $99. If I have audio issues this fall, I’ll probably invest in Loopback.
    • create a new Multi-Output Device
      • The Audio MIDI Setup application is in the Utilities folder.
      • Click on the “+” icon and select “Create Multi-Output Device”.
      • Configure the new Multi-Output Device to use Soundflower (2ch) and AirPods.
      • Configure AirPods as the Master Device for the new Multi-Output Device.

      Multi-Output Device Configuration

      • This multi-output device routes the audio from macOS (from video, music, etc.) to the AirPods and Soundflower. We will use this multi-output device shortly.
    • configure an Aggregate Device in Audio MIDI Setup
      • Click on the “+” icon and select “Create Aggregate Device”.
      • Configure the new Aggregate Device to use AirPods (the input one) and Soundflower (2ch).
      • Configure AirPods as the Master Device for the new Aggregate Device.

      Aggregate Device Configuration

      • This aggregate device combines the audio from the mic on the AirPods (i.e., me speaking) and the audio from Soundflower (to which we routed the macOS audio from videos). We will use this Aggregate Device shortly.
    • Configure the Sound Output and Input in the Sound System Preference
      • Select the Multi-Output Device as the Output device. At this point, the macOS audio (e.g., from videos) will be sent to the AirPods and Soundflower.

      Sound Output Configuration

      • Select the AirPods as the Input device.

      Sound Input Configuration

  • [Loopback] install Loopback
    • create a Loopback virtual device
    • add Safari, iTunes, and AirPods as input devices
    • add AirPods as a monitor
  • configure the audio and video devices in Google Meet or Zoom
    • [Soundflower] select the Aggregate Device as the microphone
      • This results in the macOS audio (e.g., from videos) and the audio from the AirPod mic to be combined and streamed.
    • [Loopback] select the Loopback device as the microphone
      • This results in the macOS audio (e.g., from videos) and the audio from the AirPod mic to be combined and streamed.
    • select the AirPods as the speaker
      • This allows me to hear the macOS audio as well as the audio from others in the Google Meet or Zoom meeting.

      Google Meet Audio Configuration

    • select the OBS Virtual Camera as the video camera
      • increase the send resolution to 720p to make it easier to read code
      • your video will look mirrored, but it won’t be for others in the meeting

      Meet Video Configuration

  • configure an iPhone as an external video camera
    • I bought this handy Square Jellyfish Metal Spring Tripod Mount to hold my phone and attach to a mini tripod that I already had.
    • Connect the iPhone to the MacBook via a lightening-USB cable. The iPhone is now a video source in all applications in that whatever is on the iPhone screen is the output sent to the Mac. The quality and latency are both excellent when hardwired.
    • The hardest part here was finding an iOS app that supported landscape orientation and didn’t have any controls on the screen. I finally found True Visage, which works great.
  • configure the audio settings in OBS
    • [Soundflower]
      • select Soundflower (2ch) as the Desktop Audio
      • select AirPods as Mic/Auxiliary Audio
      • This combination of audio sources is what is used when recording in OBS. Please note that it is not the same as what is being streamed via Google Meet, which is the Aggregate Device. Selecting the Aggregate Device as the only audio source in OBS doesn’t appear to work, which was a surprise.

      OBS Audio Configuration

  • [Loopback] select Loopback as Mic/Auxiliary Audio
    Loopback OBS configuration
  • configure the video settings in OBS
    • I specified 1920×1080 as both the Base (Canvas) Resolution and the Output (Scaled) Resolution. This resolution has a 16:9 aspect ratio and looks good in Meet and Zoom. I first tried a 16:10 aspect ratio that matched that of my display, but Meet and Zoom both cropped the video output.

    OBS Video Configuration

  • create Scenes and configure Sources in OBS
    • refer to the OBS documentation for details
    • I created four scenes:
      • present: my laptop display (to show code, slides, videos, etc.) with my face from the FaceTime camera in the lower-right corner
      • whiteboard: my iPhone connected as a video source
      • practice: a black screen with the text “time to practice” for when I don’t need or want to stream any video
      • just me: me fullscreen from the FaceTime camera

    OBS Scene

  • A couple points of clarification, I record from OBS by clicking on the “Start Recording” button. I stream via Google Meet or Zoom, not from OBS. I haven’t configured streaming via OBS and won’t click on the “Start Streaming” button.
  • I configured a few hotkeys in OBS Settings to make it easy for me to switch scenes. I’ll probably configure a bunch more once I determine what I need in practice.
  • Whew; that’s it!

I tested the audio and video quality when streaming using Google Meet and it was reasonable. The audio and video quality of the recorded video from OBS is excellent. I plan to use this setup for the upcoming semester and will update this document as I learn more and improve. If you are planning or have done something similar, please share. Best wishes to everyone this fall!

Programming Options while Remote Learning

2 Replies

Given the uncertainty of the structure of high school this fall, I’ve been exploring various options my students in AP Computer Science A if they are learning outside of the classroom without access to our desktops. In the classroom, APCSA students use BlueJ and GitHub throughout the year and leverage Swing and third-party frameworks (i.e., media computation). All students have chromebooks and our district works with families if they don’t have wifi at home. During eLearning and Remote Learning during this past spring semester, we used repl.it as our programming environment. This sufficed given the programming activities and labs at that point in the semester, but it wasn’t ideal. It remains an option for the fall, and I’ll expand upon it later. The options that I explored may not be a good fit for your students, but I hope others find this information helpful.

VS Code

Most of my Software Engineering students use VS Code. I was able to get it running on our chromebooks (Acer Chromebook with x86_64 architecture).

Installation

  • enable Linux via Chromebook Settings app
  • download VS Code
  • in the Chrome OS Files app, drag VS Code from the Downloads folder to the “Linux Files” folder.
  • Install VS Code from the Linux VM by running:
    • sudo apt install ./code_1.45.1-1589445302_amd64.deb
  • VS Code will now be available from the App Launcher
  • install Java Extension Pack in VS Code
    • disable IntelliSense support
    • disable Maven support
  • use JDK 11
    • add the following to /etc/apt/sources.list:
      • deb http://deb.debian.org/debian stretch-backports main
    • sudo apt update
    • sudo apt install openjdk-11-jdk
  • configure GitHub
    • install GitHub Pull Request and Issues VS Code extension
    • set user name and email address from terminal
      • git config --global user.name “<name>"
      • git config --global user.email <email>
    • clone a repository
    • resolve issues authenticating
      • sudo apt install gnome-keyring
      • specify a password for the keychain

Configuration

  • With BlueJ, jar files are automatically included in a project if they reside in a “+libs” folder. VS Code has a similar feature if the jar files are in a “lib” folder.
  • With BlueJ, one can directly run any static method in any class. VS Code expects a standard main method to be defined.

Issues

  • initial authorization of VS Code to use GitHub fails
    • second authorization of VS Code to use GitHub works if you copy and paste the authentication URL back into VS Code
  • key chain didn’t work on a clean install, but did after a clean restart

Tradeoffs

Pros

  • GitHub accessible
  • debugger

Cons

  • more sophisticated an IDE than desired for APCSA students
  • requires enabling Linux on chromebook

BlueJ

APCSA students have always used BlueJ as their IDE. It was a good balance of features and simplicity as it is designed for educational settings.

Installation

  • enable Linux via Chromebook Settings app
  • install BlueJ
    • note that this is not the latest version of BlueJ as that requires Buster which is not running on our chromebooks
  • install OpenJDK and JFX
    • sudo apt-get install openjdk-8-jdk
    • sudo apt-get install libopenjfx-java
  • install BlueJ
    • sudo dpkg -i BlueJ-linux-414.deb
  • BlueJ will now be available from the App Launcher

Issues (updated 16jul2020)

  • windows are often opened in a default position such that its upper-left corner is positioned at the center of the screen which is annoying
  • windows are often a single pixel which makes BlueJ unusable
    • workaround from BlueJ folks:
      • sudo apt-get install xdotool
      • xdotool search —class “BlueJ” windowsize %@ 800 600
      • incorporate the use of xdotool into a daemon that constantly monitors new BlueJ windows and resizes them

Tradeoffs (updated 16jul2020)

Pros

  • IDE designed for education
  • debugger
  • GitHub support (integration via Team feature expects a one-to-one mapping between BlueJ projects and repositories, which is different than our model, but doable)

Cons

  • requires enabling Linux on chromebook

repl.it

Students who have taken Computer Programming 1 and 2 before APCSA are familiar with repl.it as it is used extensively in those classes. As mentioned above, APCSA students used repl.it last spring during Remote Learning. However, I wanted a better experience if we use repl.it again this fall.

The GitHub and repl.it integration works best when the repository contains a single project. Historically, we have created a repository for each unit and that repository contains multiple practice programming projects and a summative lab. Forcing our repository model into repl.it requires some additional configuration.

Configuration

  • GitHub Classroom now supports online IDEs (e.g., repl.it)
    • however, Classroom doesn’t support Java Swing at the moment
    • so, create the .replit file explicitly and add to the repo
    • still select repl.it as the online IDE when creating the Classroom assignment but don’t specify a language or a run command
  • example .replit file
    • language = "java_swing"
    • run = "javac -classpath ./TurtleDemo:./TurtleDemo/+libs/* ./TurtleDemo/TurtleDemo.java; java -classpath ./TurtleDemo:./TurtleDemo/+libs/* TurtleDemo"
    • # specify additional run commands for each project but have them commented out
    • # run = "javac -classpath ./ClassNotes ./ClassNotes/SyntaxErrors.java; java -classpath ./ClassNotes SyntaxErrors"
    • [...]
    • # run = "javac -classpath ./TurtleLab:./TurtleLab/+libs/* ./TurtleLab/TurtleLab.java; java -classpath ./TurtleLab:./TurtleLab/+libs/* TurtleLab"

Tradeoffs

Pros

  • GitHub support

Cons

  • students have to edit .replit file when switching between activities
  • no debugger

Which option will we pursue if we end up in a remote learning scenario? I’m not entirely sure. If I can convince our IT department to enable Linux on the chromebooks of those students enrolled in APCSA (quite likely as they are incredibly supportive), I think we will use BlueJ for APCSA and VS Code for Software Engineering. I need to further test the viability of a daemon that handles the BlueJ window size issue. (updated 16jul2020)

While exploring these options, I realized that there is an opportunity here even if students are in class with our desktops. While the programming activities and labs are designed so that everyone can complete them during class, some students, for a variety of reasons, need time outside of class. Enabling one or more of these options would provide all students the flexibility to program on their chromebook instead of relying on a Windows/macOS/Linux computer at home or working in the classroom before school.

Contextual Feedback Using GitHub Pull Requests

3 Replies

After reading @dondi’s workflow for using pull requests to provide feedback to students, I wanted to try it this semester. I wasn’t exactly sure what steps were involved, but I found a workflow that worked for me and I wanted to share it. I decided that a screencast would be an easier way to illustrate the steps rather than trying to type every step.

In general, the key is to edit one of the student’s files (the edit is simply to provide an opportunity to comment in the pull request) so a branch and pull request can be created. At this point, comments can be left where each change was made.

In the past, I’ve provided feedback as comments via Canvas’ SpeedGrader. This new approach is much better in that the code on which I’m providing feedback is adjacent to the specific comment. Once students see that the assignment is marked complete in Canvas, they check the “feedback” pull request to review my comments. If they have questions or if they have answers to questions that I’ve asked, they can continue this conversation in the pull request. While this isn’t a traditional use for pull requests, it works well and it’s good for students to be familiar with participating in conversations for pull requests.

Please comment if you have any suggestions to improve this workflow or if you have any questions!

Preparing for Year 2 of GitHub Classroom

5 Replies

I’ve used GitHub with my AP Computer Science students for a couple of years, and last year I used GitHub Classroom for the first time. GitHub Classroom definitely made version control more accessible to my students. @mozzadrella wrote about my approach with my students in her Teacher Spotlight series.

As I prepare for the next school year and year 2 of GitHub Classroom, I wanted to make sure that I followed the best practices. For example, I read that there should be a one-to-one mapping between organizations and Classrooms. So, I’ve been reading the GitHub Education Community and playing around. Today, I successfully made it through preparing for the first unit of the upcoming school year. There are a series of steps:

  1. Create a new organization for the upcoming school year (NNHSAPCS201718 for my AP Computer Science class). I also created a new organization for the entire computer science department at my school (NNHSComputerScience). This organization will not be shared by students and will contain starter code repositories, old assignments, and sample solutions for teachers to reference. Previously, I was using the same organization that I used with GitHub Classroom last year.

  2. Request that the new organization be upgraded to have free unlimited private repositories. My request was approved in minutes!

  3. Create a new GitHub Classroom associated with the new organization for the upcoming school year.

  4. (Optional) Transfer the repositories from last year’s GitHub Classroom organization into the new department organization. I will use this organization indefinitely and want everything sourced from here.

  5. Make any changes to the repository on which your first Classroom assignment will be based.

  6. Push the repository from the department organization to the organization for the upcoming school year. (This also pushed the branches. Is there a way only to push the master branch?)

  7. Squash commits for the repository in the organization for the upcoming school year. In the interactive mode for rebase, leave the first commit as pick and change the rest from pick to squash. Then specify a single comment (e.g., “prepared for 2017-2018 school year”).

    git rebase --interactive --root

git push --force

  8. Create a new GitHub Classroom assignment based on the repository in the new organization for the upcoming school year.

  9. Repeat 4-8 for each repository (e.g., unit).

I am not sure if this actually follows best practices, but it seems pretty good so far and is based on the comments of others with more familiarity with GitHub and git than I.

If you have any suggested improvements or questions, please comment!

Selling Our Colleagues Short with SAMR

Leave a reply

I’ve been seeing more and more references to SAMR. Maybe it’s because ISTE is starting, or maybe it’s because my district is promoting it as a tool for teachers embarking on our Digital Learning Initiative (1:1 devices), or maybe its just the [Baader-Meinhof phenomenon](https://en.wikipedia.org/wiki/List_of_cognitive_biases#Frequency_illusion). Regardless, I can only tolerate so many SAMR infographics before I’m pushed over the edge, and I have to say something.

**Due to its overemphasis on technology, SAMR is the least helpful model to promote with teachers if you want to provide a resource to positively impact student learning.**

Depending on the teacher, it confuses, at best, and misleads, at worse. I’m not alone in this sentiment. Several of my colleagues both local and online have expressed similar feelings. Most eloquent are [a couple](https://learningandphysics.wordpress.com/2014/10/22/i-am-not-satisfied/) [of posts](https://learningandphysics.wordpress.com/2014/12/30/dont-keep-it-simple-stupid/) by Casey Rutherford. My favorite quote:

> On the note of lesson design, I am not satisfied with simplifying the complexities of teaching to where it falls on the SAMR scale. Teaching is nuanced, fluid, and has a ton of moving parts, and we’d be better off embracing that than cheapening it with a stamp of ‘modification.’

I’ll illustrate the problem with a couple of lessons.

Lesson #1
—-

> Embracing the “Flipped Classroom,” the teacher records and shares a demonstration of the projectile motion lab and an overview of the lab procedure. Students can watch the video for homework before coming to class. In addition to the video, the lab procedure is published to Canvas and each student can follow the procedure on their devices while performing the lab. The video (and published procedure) instructs students on how to setup the apparatus and make the necessary measurements of the path of the ball bearing that is launched after rolling down the ramp. The data is captured in a Google doc and plotted using Plotly, allowing group members to share data with each other. Based on their plot, students determine where on the floor to place the target and then the teacher observes their attempt. Points are awarded based on how close the ball bearing lands to the target. Each student creates a video that captures their attempt in which they report their percent error and list potential sources of error. The videos are posted on their public blog. Students, and the public, can comment on these videos posted on the students’ blog, but no one does.

Let’s take a look at this lesson. Hmmm. Flipped classroom, LMS, Google Docs, Plotly, video creation, student blogs. Woohoo! We are swimming in the deep end of the SAMR pool! Modification? Redefinition? Doesn’t matter, we’re above the bar!

There’s just one problem. This lesson sucks. I know, it’s based on one of my actual lessons. My class did it. They weren’t engaged; they didn’t have ownership; they didn’t have choice; they didn’t exercise their creativity. They asked me a ton of questions about the details of the procedure. From a pedagogical perspective, it is flawed. It is a traditional cookbook science lab jazzed up with a bunch of tech.

Don’t worry, I made improvements the next year. I focused on research-based pedagogy, and I integrated technology where it supported the pedagogy and content.

Lesson #2
—-

> Students are presented with a challenge: Given a fixed vertical elevation of the projectile launcher (i.e., “cannon”), determine the launch angle and time of launch to hit the toy buggy at a specific location as it “flees” . Students work in small groups to justify the selection of the kind of data needed, design a plan for collecting data, and collect data. They choose the tools with which to collect the data. Some groups use video cameras; others, motion detectors; others, photo gates; others, meter sticks; others, phones. They create a computational model using 3D physics programming language since a traditional mathematical solution is beyond most of their current capabilities (one group solves the problem algebraically using clever trig substitutions, which is fine). Using the computational model they solve for the launch angle and time of launch. Their attempt based on their calculation is recorded with a high speed video camera and [shared publicly](http://180.pedagoguepadawan.net/107/107/) to celebrate their success. Students reflect on the lab practicum with a specific focus on measurement uncertainty and capture their reflections in their electronic portfolio which they will export into an open format (HTML) and take with them to university. During the post lab discussion as a whole class, each group shares what in their evaluation is the most significant aspects of their approach as each group had a unique approach to the lab. Groups compare and contrast these techniques arriving at a set of best practices for minimizing measurement uncertainty.

Students were motivated and engaged. They were creative and collaborative. They asked each other many questions. They surprised me with their solutions. They focused on deeper science practices beyond the content of projectile motion. Some groups incorporated technology to help them meet the challenge. Some groups hardly used any technology at all.

Some may rebuke my assertion and claim that I’m oversimplifying SAMR and there is more to it than what I’m presenting. I’m missing the student-centered vs. teacher-centered aspect. Maybe there is, but you wouldn’t know it from most of the resources out there. [SAMR Coffee](https://www.google.com/search?q=samr+coffee&tbm=isch&tbo=u&source=univ&sa=X&ei=e5WQVYbAGtXaoATpr7TIBg&ved=0CB4QsAQ)? [SAMR Apps?](https://www.google.com/search?q=samr+apps&tbm=isch&tbo=u&source=univ&sa=X&ei=k5WQVYiNNo_ooASyi7CgCQ&ved=0CB4QsAQ) Really?

Some may argue that teachers new to tech need a simple model to reference. Yes, SAMR is simple. But, why promote it when there are better and more inclusive models available? Do we really think [TPACK](http://www.matt-koehler.com/tpack/what-is-tpack/) is too complex for our colleagues? Are we selling them that short?

I’m not.

Formative Assessment Tools for Peer Instruction and Peer Critque of Written Responses

Leave a reply

This past year, as my AP Physics 2 cases piloted Chromebooks, we used a couple of formative assessment tools frequently in class. For Peer Instruction, we used [InfuseLearning](http://www.infuselearning.com). InfuseLearning’s stand-out feature was their support for draw-response questions. Having students sketch graphs and draw diagrams is very valuable as a formative assessment in physics class. Throughout the year as I shared InfuseLearning with other teachers participating in the pilot, the draw-response feature was the most popular everyone, from elementary through high school.

The second formative assessment activity was focused on preparation for the new paragraph-length responses on the AP Physics 2 exam. To practice these types of responses, students responded to a prompt using [Socrative](http://www.socrative.com). Socrative allows me to share all the responses with students, and students can vote for the best one. We can then, as a class, discuss the elements of the best responses.

Unfortunately, InfuseLearning [closed their doors in April](http://www.infuselearning.com/?page_id=35). In preparation for sharing resources with teachers this summer before we deploy 1:1 Chromebooks for all high school students this fall, I surveyed the current tools available with a focus specifically on Peer Instruction that supports drawing and peer-critique of written responses.

I evaluated the following features.

* **Cost**: Is there a free version? What are the limitations of the free version? Can teachers upgrade to a paid version on an as-needed basis?
* **Account Creation**: How easy is it for students to create accounts? Can they login with their Google account?
* **Prepared Questions**: Does the tool support preparing questions in advance?
* **Spontaneous Questions**: Does the tool support creating a question on-the-fly without preparation ahead of time?
* **Supported Question Types**: What types of questions do the tool support?
* **Multiple Choice Questions**: Since Peer Instruction often uses multiple choice questions, how flexible are these questions? Can the answer choices be customized (e.g., A-D or 1-4)? Can the number of answer choices be customized?
* **Draw Response Questions**: Are draw response questions supported by the tool? How rich are the drawing tools?
* **Sharing Student Responses with Students**: Does the tool support sharing sample student responses with all students?
* **Capturing Student Responses**: Does the tool support capturing student responses for later analysis? What can and cannot be captured?
* **Reporting**: Does the tool support reporting of sessions? What is captured and reported?

[Socrative](http://socrative.com/)
—-

* **Cost**: free
* **Account Creation**: integrated with Google accounts
* **Prepared Questions**: yes
* **Spontaneous Questions**: yes
* **Supported Question Types**: multiple choice, true/false, short answer
* **Multiple Choice Questions**: limited options (exactly 5, A-E)
* **Draw Response Questions**: no
* **Sharing Student Responses with Students**: sharing short answer allows student to vote on best peer answer
* **Capturing Student Responses**: yes
* **Reporting**: for prepared questions and short answer only (not spontaneous multiple choice or true/false)

[The Answer Pad](http://theanswerpad.com)
—-

* **Cost**: free and paid; free is limited (limited templates, question types, creation of own images, capture student responses)
* **Account Creation**: students have to create accounts (doesn’t support Google accounts) if you want to track student responses
* **Prepared Questions**: yes, but not draw response
* **Spontaneous Questions**: yes
* **Supported Question Types**: multiple choice, true/false, yes/no, up/down, fill-in, Likert scale, drawing
* **Multiple Choice Questions**: limited options (exactly 4, A-D)
* **Draw Response Questions**: yes, decent drawing tools
* **Sharing Student Responses with Students**: no
* **Capturing Student Responses**: limited in free version
* **Reporting**: only for prepared questions

[Formative](http://goformative.com/)
—-

* **Cost**: free
* **Account Creation**: integrated with Google accounts
* **Prepared Questions**: yes
* **Spontaneous Questions**: no (maybe have some standard templates?)
* **Supported Question Types**: multiple choice, show your work (draw response), short answer, true/false
* **Multiple Choice Questions**: flexible response choices
* **Draw Response Questions**: yes, but limited (no colors)
* **Sharing Student Responses with Students**: no
* **Capturing Student Responses**: automatic
* **Reporting**: yes

[Pear Deck](http://www.peardeck.com/)
—-

* **Cost**: free and paid; free is limited (draw response in prepared decks, capturing, and reporting are paid features)
* **Account Creation**: integrated with Google accounts
* **Prepared Questions**: yes
* **Spontaneous Questions**: kind of (can ask a quick question in the context of an existing deck)
* **Supported Question Types**: agree/disagree, draw on grid, draw on blank, yes/no, true/false, multiple choice, long text answer, short text answer, numeric answer
* **Multiple Choice Questions**: flexible response choices
* **Draw Response Questions**: yes (quick question only for free version)
* **Sharing Student Responses with Students**: no
* **Capturing Student Responses**: paid only
* **Reporting**: paid only

[NearPod](http://nearpod.com/)
—-

* **Cost**: free and paid (free has limited storage space and reporting export options)
* **Account Creation**: integrated with Google accounts
* **Prepared Questions**: yes
* **Spontaneous Questions**: no (maybe have some standard templates?)
* **Supported Question Types**: open-ended question, poll, quiz, draw it
* **Multiple Choice Questions**: flexible response choices
* **Draw Response Questions**: yes, decent drawing tools
* **Sharing Student Responses with Students**: yes
* **Capturing Student Responses**: yes
* **Reporting**: yes (PDF only in free version)

Conclusions
—-

At our summer professional learning sessions, we will be featuring Socrative. It is easy to use and applies to a wide variety of disciplines. The significant drawback of Socrative is the lack of draw-response questions. For those teachers that need that feature, I’m recommending they use NearPod. I used to use NearPod a couple of years ago when piloting classroom iPads. At that time, NearPod was an iPad-only app. I was thrilled to discover that it now supports all major platforms.

For my physics classroom, I’m going to use NearPod for Peer Instruction because draw-response questions are so important. While I’d rather be able to create spontaneous questions, I’m also interested in capturing student answers to provide me more insight into their learning, which necessitates creating a set of questions ahead of time. I will create a few slides in each deck that can serve as general-purpose placeholders for spontaneous questions.

I’ll still use Socrative for peer-critique of written responses. The ability to share student responses with students and have students vote for the best response is very effective at developing their writing. These two classroom activities – Peer Instruction and peer-critique of written responses are done independently; so, using two different tools should not be inconvenient.

If I’ve missed a tool that would work well for either of these classroom activities, please leave a comment to let me know!

GitHub, Canvas, and Computer Science

2 Replies

There are certain software development techniques or tools that are not strictly part of the AP Computer Science curriculum that I think are valuable for students to learn about and practice in my class. Two years ago, I incorporated pair programming. Last year, I added test-driven development and JUnit. This year, I made [GitHub](http://github.com/) an integral part of the course.

I want students to be aware of and appreciate the value of source control management. GitHub was the obvious choice as they are [supportive of education](https://education.github.com) and is mostly likely the specific tool that students will encounter.

After consulting with a couple former students more familiar with GitHub than I, I decided to create a [repository for each unit in the course](https://github.com/nnhsapcs201415). At the start of each unit, students fork that unit’s repository and clone it to their desktop. They perform these operations through the GitHub web site.

Throughout the unit, I encourage students to put all of their code in their forked repository and frequently commit and sync. This provides students with all of the typical advantages of source control: they can more easily work at both school and home, and they can revert to an earlier version of code if a project goes astray.

At the end of the unit when students have completed their summative lab, they issue a pull request to submit the lab. They then submit the URL to this pull request via the [Canvas](http://www.instructure.com/k-12/) assignment that I created for the summative lab.

I created a video tutorial that captures the student workflow:

The student workflow works well except when they accidentally generate merge conflicts by not keeping home and school synced.

While exposing students to GitHub is enough of a benefit, this particular workflow is extremely efficient from the perspective of me evaluating their summative labs.

I [still use Canvas’s SpeedGrader](https://pedagoguepadawan.net/216/greatest-benefit-of-canvas/) to keep track of who has submitted the lab and to provide detailed feedback to students. In previous years, I had students submit a zip file of their entire project folder. The link to their pull request is much more efficient. My workflow for evaluating their lab is the following:

1. Click on the link in SpeedGrader to open the pull request page in another tab.
2. Click on the “Check out this branch in GitHub for Mac” icon which does exactly that.
3. Open the BlueJ project file for the summative lab, read the code, read the docs, run the project, and provide feedback via SpeedGrader.
4. Close the pull request.
5. Run the following script which switches back to the mater branch and removes all traces of the student’s pull request:


	git reset --hard
	git clean -xdf
	git checkout master

6. After evaluating all of the labs, I list all of the branches that I checked out: git branch --list
7. I then delete each of these branches: git branch -D pr/xx

While the above may seem like a lot of steps, there is very little overhead and it is much more efficient than my previous workflow.

I’m embarrassed to admit that there is another advantage of these GitHub repositories for each unit that I didn’t utilize until this past unit. While making notes to myself about where we had stopped in one class period where I was modeling how to write a certain algorithm, it struck me that I can create branches for each class period. I now create a branch for each class period and, when I demonstrate how to write some code, I commit and sync that branch with some helpful notes to myself at the end of each class period. The next day, I switch to the corresponding class’s branch, read my notes, and we start right where we stopped.

If you have any suggestions on how I can improve my students’ workflow or my workflow, please share. If you have been thinking of incorporating source control management into your computer science class, I encourage you to take the plunge. Your students will learn a very valuable skill!

Chromebook Toolchain for AP Physics

5 Replies

This fall, my AP Physics 2 classes will be using Chromebooks as part of my school district’s 1:1 pilot. Chromebooks were new to me; so, it took some time this summer to find the apps to support the workflow I want for this class. While I’m sure the toolchain will change throughout the semester, and there will be surprises (both pleasant and otherwise), here is the starting toolchain:

* [Canvas](http://www.instructure.com/k-12/). Everything starts and ends with this learning-management system.

We will do a lot of lab activities. The workflow depends on the amount of data acquired and the level of graphical analysis required. The start of the workflow is the same:

* [LabQuest 2](http://www.vernier.com/products/interfaces/labq2/?lq2-home). Vernier’s LabQuest 2 can create its own ad-hoc network or connect to the school’s wireless network. The LabQuest 2 hosts its own web page as part of their [Connected Science System](http://www.vernier.com/products/wireless-solutions/connected-science-system/). Students can then access the device, the data, and graphs via Chrome. Data and graphs can be exported to the Chromebook via the web page.

The next tool depends upon the lab. For some labs, the data and graphs produced on the LabQuest 2 are sufficient. Students will import these into their [Google Document](http://www.google.com/docs/about/) and create whatever is required for their lab report. If additional analysis is required and the data sets are relatively small:

* [Desmos](https://www.desmos.com). A fantastic graphing app. For small data sets and [applying linear fits in a meaningful manner](https://www.desmos.com/calculator/w5a3shbzy4), it is fantastic. Graphs can be shared via a link and an image can be embedded in the Google document.

If data sets are large or more sophisticated analysis is required:

* [Plot.ly](https://plot.ly). Plot.ly seemed to explode onto the education scene this summer, or maybe I was just paying more attention. Data exported from the LabQuest 2 can easily be imported into Plot.ly. Like Desmos, graphs can be shared via a link and an image can be embedded in the Google document. Plot.ly can also embed its graphs in an iframe, but I couldn’t find a way to embed that in a Google document as opposed to a web page. Fran Poodry from Vernier made a great [screencast](https://www.youtube.com/watch?v=HBH2eSQ9DqY) demonstrating the integration of the LabQuest 2 and Ploy.ly.

Regardless of the analysis performed, in the end, students create their lab report in Google docs and submit it via Canvas.

Another important aspect of class is the exploration and modification of computational models. In the past, we’ve used [VPython](http://vpython.org). I had to find an alternative that would be compatible with Chromebooks:

* [Glowscript](http://www.glowscript.org). Glowscript is the up-and-coming platform for computational models with the advantage that it runs in a browser that supports WebGL. I’m not a huge fan of JavaScript syntax for novice programmers; so, we will be using [CoffeeScript](http://coffeescript.org) instead. I didn’t write as many starting models over the summer as I had hoped, but I did at least verify that [complicated models](http://www.glowscript.org/#/user/gcschmit/folder/My_Programs/program/Maxwell-Boltzmann) can be ported.

Peer instruction is one of the most effective and popular classroom activities that we do. In the past, I’ve used handheld clickers. This year, we will use the Chromebooks:

* [InfuseLearning](http://www.infuselearning.com). There are a number of web apps in this space, but I selected InfuseLearing because it allows the creation of spontaneous questions, supports a variety of answer methods including drawing and sort-in-order. [Pear Deck](https://peardeck.com) looks promising, but I don’t want to be forced to create my set of questions ahead of time.

For notes in class, I’ll leave it up to students to use whatever tool works best for them (including paper and pencil). I’ll suggest they at least take a look at:

* [Evernote](https://evernote.com). I love Evernote and use it all the time for all sorts of stuff.

I do provide students with PDFs of my slides. I can envision that students may want to annotate these PDFs or other handouts. Surprisingly, this was the hardest tool to find:

* [Crocodoc](http://personal.crocodoc.com). The free personal version allows students to upload a PDF, annotate it, and export their annotated version. Other tools I explored are [Notable PDF](http://www.notablepdf.com). This requires paid licenses to be useful. We may try this out if we find Crocodoc lacking.

A couple of other tools that looks interesting, but I’m not sure if they fits into the toolchain for my class is:

* [Doctopus](https://chrome.google.com/webstore/detail/doctopus/ffhegaddkjpkfiemhhnphmnadfbkdhbf?hl=en). I think Canvas assignments and SpeedGrader cover everything that I personally would do with this app.

* [81Dash](http://81dash.com). Private back-channeling app.

I’m sure I will learn of new tools throughout the semester and I’ll make adjustments to the toolchain. If you are using Chromebooks, please share your favorite apps below in the comments!