2021 Summer Reading List

This summer’s reading was a balance of school-related and personal books.

Deep Work: Rules for Focused Success in a Distracted World by Cal Newport

Cal Newport’s writing were recommended to me by a friend. After reading some of his blog posts, this seemed like a good book with which to start. It was a quick read and mostly reinforced my understanding of the importance of “deep work”. Last year, when we had block scheduling during, and I was isolated during these blocks, I found that I got a ton of stuff done. While it will be more challenging this school year, I’m hoping to continue to find the time and environment at school to achieve this deep work. I haven’t yet, but I have some ideas!

Crucial Conversations: Tools for Talking When Stakes Are High by Kerry Patterson, Joseph Grenny, Ron McMillan, Al Switzler, Stephen R. Covey

One of the mentors has shared tips from Crucial Conversations over the past couple of years and highly recommended that I read this book. It is excellent and my favorite book from this summer. While I read it in the context of my role as a mentor and head coach of our FIRST Robotics team, it is applicable to every aspect of my life. I took extensive notes, which I expect that I will review frequently to prepare for the various crucial conversations that I will have.

The Rise and Fall of D.O.D.O. by Neal Stephenson and Nicole Galland

I rode the Southwest Chief from Naperville, Illinois to Raton, New Mexico this summer on my way to the Philmont Scout Ranch with my son and our troop. I have ridden this train twice before to New Mexico and, each time, read a Stephenson novel. So, it seemed fitting to choose another for this trip. Compared to his other novels, this was a lighter and easier read, which made it great for the train. I planned to read half of it on the way to New Mexico and the remainder on the return trip, but I found myself unable to stop and finish the book before reaching Philmont.

Crucial Accountability: Tools for Resolving Violated Expectations, Broken Commitments, and Bad Behavior

by Kerry Patterson, Joseph Grenny, Ron McMillan, Al Switzler

Since I found Crucial Conversation so incredibly helpful, I decided to read the “sequel” Crucial Accountability as well. It was, by design, a bit repetitive after having just read Crucial Conversations. It was still very useful. And, like with Crucial Conversations, I took many notes and will refer to them frequently. While I again expect to apply these ideas the most on the robotics team, I plan to share some of the key ideas in this book with my Software Engineering students to help them have the skills needed to hold each other accountable on their project teams. I think that a series of workshops and learning, for administrators and teachers, focused on crucial conversations and accountability would have the greatest potential to dramatically transform our school district.

Fall or, Dodge in Hell by Neal Stephenson

On long road trips, I like to check out a Stephenson novel on CD from the library and play it in the car. We took an abbreviated road trip this summer; so, we didn’t quite finish the novel in the car, much to the disappointment of my son. I’m currently reading the rest of the book. This is kind of a sequel to REAMDE in that there are many shared characters but having read the previous novel isn’t critical before reading this one. Like so many of Stephenson’s novels, the science fiction that he presents frighteningly mirrors current events. As a result I found this book, especially the first part, concurrently fascinating and terrifying. I do love that Enoch Root has made yet another appearance!

Tetris Lab for APCSA

For the past two years, our AP Computer Science A (APCSA) students have completed the Tetris Lab at the end of the Object Oriented Design (OOD) unit. The initial idea and structure for the lab was forked from Stanford Tetris Project from Stanford’s CS108 by Nick Parlante, which I found as it was a SIGCSE 2001 Nifty assignment. We made significant changes during the first implementation of the lab and before the second. The current version of the Tetris Lab is a great fit for the goals that we have for our students at the point in the semester when they complete it. Your students may need something different or at a different time. Regardless, I hope you find something to adapt to your class.

To provide some context, for our APCSA classes, the OOD unit is the second to last unit before the AP exam. The last unit focuses on recursion along with sorting and searching algorithms. Our OOD unit still includes interfaces even though that is no longer part of the AP curriculum. Students also implement basic Swing-based graphical user interfaces. At the end of this unit, we want students to demonstrate their understanding of the OOD concepts as well as practice the design and implementation of more advanced algorithms in preparation for the AP exam. We have designed all of our summative programming labs to be scored based on the defined requirements but also to have various extensions that students can pursue based on their interest and time available. We also provide opportunities for students to personalize their summative programming labs. Honestly, that is a weakness of the Tetris Lab as personalization is primarily presented through extensions and not requirements and, therefore, not incorporated by all students.

The lab is split into two parts. The first part focuses on the model for a Tetris piece and students work with their pair-programming partner to complete this part. This part emphasizes the design and implementation of various algorithms related to Tetris pieces. We found that students working in pairs help each other especially with the design of these algorithms. The Piece class with declared methods and instance variables is provided in the starter code. Pairs implement the following methods:

  • Piece constructor in which they have to design and implement an algorithm to:
    • copy an Array of references to Point objects and copy the Point objects (they really struggle with this and it is a great opportunity to review one of the most challenging concepts in the course, Java references);
    • determine the width and height of the piece
    • determine the skirt of the piece (this is the most challenging algorithm in the constructor and pseudocode is provided so that student can focus on implementing the algorithm)
  • toString (used when debugging)
  • the rotation algorithm in the pieceRow method; the starter code defines three steps to rotate a piece to decompose this algorithm and make it more accessible for students to implement:
    • step 1: reflect across the line y = x
    • step 2: reflect across y axis
    • step 3: translate right

In other summative programming labs, students write their own unit tests. In this lab, the test code is provided and students run the tests to verify that their have completed each milestone. The first part of this lab consists of two milestones:

  • Milestone 1: JPieceTest Initial Pieces
  • Milestone 2: JPieceTest with Rotations

Students run the JPieceTest class and visual verify that the output matches the expected output in the lab document.

After completing these two milestones, which comprise the first part of the lab, the TetrisViewer class can be executed to play the game of Tetris. The Board, JTetris, and TetrisViewer classes are fully implemented in the starter code. (This is the most significant departure from the original lab as students do not implement the Board class. The first year we did this lab, I expected students to implement the algorithms in the Board class and, after witnessing how they were challenged with the algorithms in the Piece class, changed course and provided them with a fully-implemented Board class.)

The second part of the lab focuses on enhancing the game of Tetris such that the code can play the game autonomously. In this part students demonstrate their understanding of defining a subclass, overriding methods, and interfaces.

Milestone 3 focuses on the extension of the GUI defined in the JTetris class by the JBrainTetris class which adds a combobox used to select which “brain” is active and a button to enable/disable the brain. Students implement the JBrainTetris class from scratch to demonstrate their understanding of creating a subclass and overriding methods. While students have used the JButton class previously, they have learn how to incorporate the JComboBox class into the code. In addition to the components and their associated listeners, students also implement the createBrains method in the BrainFactory class. This is straightforward but a good opportunity for students to see the factory pattern and appreciate the strengths of polymorphism.

Milestone 4 focuses on overriding the JTetris methods pickNextPiece and tick to support the “brains” playing Tetris. These are challenging methods to override and students needs to understand the provided JTetris code in order to do so successfully. Understanding and then leveraging provided code is an authentic feature of many of our summative programming labs.

Milestone 5 is an additional test that shouldn’t require any additional implementation. However, students often have undetected bugs that need to be addressed.

Completing the 5 milestones meets the requirements for the lab. There are, however, several opportunities to “add more awesome” through extensions:

  • new pieces (define additional pieces with more or less than four blocks; this is a great opportunity to appreciate the benefit of abstraction as only the Piece class has to be modified)
  • adversary (add a feature where the code uses a brain to select the most challenging next piece; this is a great example of how decomposition can lead to code reuse)
  • BigBrain (implement a new brain that is smarter than the provided SimpleBrain class; students can take this extension as far as they want and spend significant time tuning their algorithm either by hand or with the assistance of a genetic algorithm)

The latest starter code is available on GitHub.

HyperDoc Folder Cloner Script

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)

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


  • 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).


  • 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


  • 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.


  • 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



  • GitHub accessible
  • debugger


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


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.


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


  • nonresponsive on first launch
    • killed, relaunched, worked



  • 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)


  • requires enabling Linux on chromebook


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.


  • 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"



  • GitHub support


  • 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.

Software Engineering Book Clubs and Panel Discussion

One of the units during the fall semester in my Software Engineering class focuses on technology, society, and ethics. The big idea is that “Students will research, analyze, discuss, and present contemporary issues at the intersection of technology, society, and ethics”. The guiding question is “How does technology affect change from the critical context of privacy, social justice, economics, education, politics, culture, security, or warfare?”. The rationale for this unit is that technology is having a dramatic impact on every aspect of today’s society. The scope of the impact ranges from the personal to international relations. Today’s students will be tomorrow’s digital citizens who will be designing, applying, and using technological products that will affect change. We achieve these standards through book clubs in which small groups of students (3-5) read, analyze, and discuss a text. Students participate in a panel discussion as the summative assessment for this unit.

The past couple of years, students read one of the following books:

  • Algorithms to Live By: The Computer Science of Human Decisions by Brian Christian
  • Blown to Bits: Your Life, Liberty, and Happiness After the Digital Explosion by Hal Abelson, Ken Ledeen, Harry Lewis
  • The Hacked World Order: How Nations Fight, Trade, Maneuver, and Manipulate in the Digital Age by Adam Segal
  • The Monsters of Education Technology by Audrey Watters
  • The Second Machine Age: Work, Progress, and Prosperity in a Time of Brilliant Technologies by Erik Brynjolfsson and Andrew McAfee
  • Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy by Cathy O’Neil

I present each of the books to the class and then have them force rank their choices. I then form the groups to reflect student preferences while balancing the size of groups. This year, I’ll use my genetic algorithm.

The book groups meet weekly for six weeks in the middle of our data structures unit. This serves as a refreshing change of pace as the data structures unit is fairly intense. In the past, we’ve met in the Learning Commons for book groups which is a great space for this activity.

Inspired by a Cult of Pedagogy article featuring Marisa Thompson, the weekly discussion is structured around Thoughts, lingering Questions, and Epiphanies (TQEs). Each week the book club group collaboratively completes a document (week #1 template) to capture their discussion. This provides some accountability and serves as a great resource for the panel discussion.

The sample prompts change from week to week:

  • Week 1
    • author’s claims
    • personal or group response to the author’s claims
    • evidence (examples) that support the author’s claims
    • aha! (striking) moments while reading or discussing
  • Week 2
    • Has anyone’s personal response or beliefs changed while reading the first third of the book? If no, why not?
    • How does your personal response or beliefs align with those of the author? If yes, how have they changed? Why did they change?
  • Week 3
    • Notes on research on the author. What is their background? What is their education and profession? For whom do they work? Do they have a personal connection to the topic? For which, if any, publications do they write?
    • What are the potential biases of the author?
    • How does awareness of these potential biases affect your perspective of the author’s claims?
  • Week 4
    • Through which of the following critical contexts does the technology highlighted in your text most affect change? (privacy, social justice, economics, education, politics, culture, security, of warfare)
    • how does the technology highlighted in your text affect change from the critical context selected above?
  • Week 5
    • What question is most important to be asked in relationship to your book that has not been asked? That is, what is the question for the answer that you are most excited to share? Why this question is so important?
  • Week 6
    • students are on their own at this point…

After these six weeks of reading, analyzing, and discussing their books, students demonstrate their understanding through their participation in a panel discussion. Originally, I planned on having students write individual essays. One of our Learning Support Coaches recommended alternative assessments and suggested a panel discussion. While I was nervous about managing a panel discussion, it worked incredibly well as a summative assessment and is so much more engaging than a bunch of essays.

The structure of the panel discussion varies somewhat based on the number of students in the class. Overall, there are four panel discussions over two days of class. I set up tables for the panel and the observers in the Learning Commons and invite teachers and administrators to watch the panel discussion. Each panel is comprised of a student from each of the book groups. At times, there may need to be two students from the same book group. This ensures a variety of perspectives as each will address the prompt through from the perspective of their book. Students are expected to address the prompt from the perspective of their book and its author and not their personal opinion. This is important in that I want them to demonstrate that they can take one of their author’s claims, support it with evidence, and connect it to a novel prompt with their reasoning. In addition, students are expected to respond to their peers on the panel as this should be a discussion and not just a round robin of responses to a question. Students are allowed to have notes but are cautioned that use of these notes shouldn’t distract from the panel discussion. I collect their notes at the end of the panel, which serves as supplemental evidence of their understanding. Each student is assessed based on this rubric.

I prepare several prompts for the panel discussion, but one is almost always sufficient for a 15-20 minute panel discussion. Here are the prompts that I’ve used in the past:

  • According the author’s claims presented in your text, through the lens of education [could also be any of the other critical contexts], how do the topics presented in your texts affect change?
  • According the author’s claims presented in your text, how do the concepts presented in your text affect our perception of self identity, control of one’s destiny, and self value?
  • The topics presented in your texts are technologically advanced. According the author’s claims presented in your text, how do they affect everyday people?
  • Many of the topics raised in your text are fairly depressing. According the author’s claims presented in your text, what did you find in your text that was hopeful for the future?
  • According the author’s claims presented in your text, to what extent would your author agree that technology is headed in a positive direction?

Here are a couple of my extra prompts in case a panel gets stalled:

  • The authors of your texts raised several concerns. How did they advise individuals to respond to these issues? What is their call to action?
  • According the author’s claims presented in your text, to what extent would your author agree that the ethical questions raised in this text are subjective?

I’ve been really impressed with students on the panels the past three years. As I mentioned previously, a single prompt almost always lasts 15-20 minutes and is all that is needed for a panel. Students exceeded my expectations. They really took care of each other; if someone was struggling to make a connection, they would prompt them with a bridge to help them make a connection and give them an opportunity to speak. Clearly our Communication Arts teachers have helped these students develop these impressive skills.

For the upcoming school year and the fourth year of my Software Engineering class, I will leave most of this unit unchanged. The one change that I will make is to have students read one of two books and narrow the focus to the critical context of social justice. The district Learning Services department has generously agreed to purchase additional copies such that every student will read either Weapons of Math Destruction or Race after Technology: Abolitionist Tools for the New Jim Code by Ruha Benjamin. While I worry a bit that the more focused lens will limit the panel discussions, both of these books are so rich that I expect the panel discussions will be just as good, if not better, than in the past.

2020 Summer Reading List

I haven’t published my summer reading list in a few years. This summer, for some reason, I seemed to have more time for reading. Most of my reading centered on potential new books for the Technology, Society, and Ethics book study unit in my Software Engineering class where students analyze these texts through a lens that combines the technological, societal, and ethical perspectives. Small groups of students explore the question “How does technology affect change from the critical context of privacy, social justice, economics, education, politics, culture, security, or warfare?”. I did read a couple of books for my awesome biweekly Zoom book club.

Army of None: Autonomous Weapons and the Future of War by Paul Scharre

I’ve been wanting to read this book and evaluate it for class for a couple of years. It will fit well in the software engineering unit and provide an easier to read and analyze alternative to The Hacked World Order. It is very balanced and does an excellent job presenting the challenge of even defining autonomous weapons. Personally, I found it a bit repetitive and long for my students; so, I will probably suggest groups read a subset of the chapters.

Algorithms of Oppression: How Search Engines Reinforce Racism by Safiya Umoja Noble

This was a powerful read. This book had also been on my list for a couple of years. I read it hoping it could complement Weapons of Math Destruction with a more direct focus on racism. Dr. Noble strongly illustrates how algorithms perpetuate racism. While I found the book excellent, I fear that that complexity of the text and concepts may be too much for my students. As a warning to others, some students and especially parents may be uncomfortable with the language of some of the search examples. My search continued with…

Race After Technology: Abolitionist Tools for the New Jim Code by Ruha Benjamin

This was the book for which I was looking. It presented diverse examples of what Dr. Benjamin has coined “the New Jim Code”. In addition, it didn’t resign us all to technology perpetuating engineered inequity as it presents “these forms of resistance are what I think of as abolitionist tools for the New Jim Code.” I had the pleasure of watching Dr. Benjamin’s keynote at this summer’s CSTA conference. After all of this, and the events of this summer, I decided to focus the critical context for this year’s Software Engineering book clubs to social justice. My school district has already approved the purchase of enough copies of Race after Technology and additional copies of Weapons of Math Destruction such that every student will read and analyze one of these two books. We will then have a more focused panel discussion focused specifically on how technology affects change through the critical context of social justice.

Computer Science in K-12: An A-To-Z Handbook on Teaching Programming by Shuchi Grover

This was my surprise read of the summer. I noticed a lot of discussion about this book in my Twitter. Checking the table of contents, I was surprised how many of the authors were familiar. (Grover is the editor and author or co-author of several chapters.) This book should be required reading for all computer science education programs. As I shared on Twitter:

I started with Ch 14: Naive Conceptions of Novice Programmers by Juha Sorva in @shuchig’s book Computer Science in K-12. It captured and distilled misconceptions (preconceptions per #modphys) that I have been struggling to identify. I wish I had this book 8 years ago!

I truly wish I had this book eight years ago when I started teaching computer science. I hope to convince my computer science PLC to make this book part of our work this fall semester.

Braided Sweetgrass: Indigenous Wisdom, Scientific Knowledge, and the Teachings of Plants by Robin Wall Kimmerer

I’ve started reading this book before the start of summer. It was the book that I selected for our book club. It is a book best read one chapter at a time with sufficient time between chapters to savor each. Dr. Kimmerer’s words heal you as you read them. This book connected my childhood home (near where Dr. Kimmerer lives), science, spirituality, and my love and respect of nature. My mom gifted me a signed copy of this book with the inscription “for Geoffrey, in honor of our teachers, the plants”.

The Dispossessed by Ursula Le Guin

Since we didn’t take a long road trip this summer, which is when I usually get in a Stephenson audiobook, I was pleased when another member of our book club selected a science fiction book. A classic that is as relevant now as ever.

Streaming and Recording Online Lessons

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!

Start-of-Year Student Surveys

This year, perhaps more than any in the past, it will be important for me to get to know my students as quickly as possible. At the start of each year, I administer a survey to facilitate this process. Many of the questions that I ask are from start-of-year surveys shared by John Burk and Brian Frank. Each summer, I revisit the survey to add some questions and remove others. This summer, I created an additional assignment in Canvas where students submit an audio recording of themselves saying their name. My hearing isn’t the best, and I hope that having a recording to play over and over again will help me ensure that I pronounce every students’ name correctly.

I administer the survey as a Google Form, but that isn’t important. However, I think it is important that they can read my answers to the same survey questions (when relevant). I revise these answers each summer. This also facilitates the relationship building and provides students an incentive to complete the survey.

Below are the questions on the survey. For some, I’ve provided some context in italics.

  • student email addresses are automatically collected
  • What is your name?
  • In which class period are you?
    • I can look this up, but having the data in one place saves me time.
  • What do you preferred to be called? (nickname)
  • What is your GitHub user name?
    • This is only included in my software engineering class where students already have GitHub accounts.
  • What are your gender pronouns?
  • Do you have any brothers or sisters? If so, what are their names?
    • On occasion I don’t make the connection between siblings until I meet the parents at open house or conferences.
  • Are you responsible for caring for younger siblings on days when you are learning from home?
    • This is a new question this year. While I plan to have synchronous and asynchronous resources, I want to know which students have this responsibility.
  • What languages do you speak at home?
  • Did you attend another high school?
  • If so, which one?
  • Select all IT and computer science classes which you have taken.
  • Select all IT and computer science classes which you are currently taking at NNHS.
    • These two questions let me know which shared experiences we already have and will have throughout the year.
  • Select all math classes which you have taken.
  • Select all math classes which you are currently taking.
    • My computer science classes are not math heavy at all. However, I’m curious if there is a correlation between math background and success in my computer science classes.
  • I signed up for this class because…
    • A large number of choices are presented. These answers help the CTE department focus its recruiting efforts and measure their effectiveness.
  • What extracurricular school commitments do you have? (activities, athletics, clubs, etc.)
  • What commitments outside of school do you have? (activities, athletics, clubs, jobs, etc.)
  • The next several questions are answered on a Likert scale.
  • I can conveniently access a computer outside of school.
  • I can conveniently access the internet outside of school.
  • I like science, technology, engineering, or math.
  • I like stories about science, technology, engineering, or math.
  • I plan to pursue further studies in science, technology, engineering, or math. (for example, in college)
  • I plan to pursue further studies in a computing-related field. (for example, computer science, computer engineering, software engineering)
  • Which best describes you?
    • I proactively communicate with my teachers and feel comfortable in doing so. Expect to hear from me early and often.
    • I would like to proactively communicate with my teachers, but I sometimes feel uncomfortable taking the initiative to do so. I appreciate it when teachers reach out.
    • I only reach out to my teacher if things are not going well, and that suits me fine.
    • Communicating with teachers is something that can make me feel uncomfortable. I will hesitate to reach out even if things aren’t going well.
  • Explain why you picked this choice.
  • What should I know about your prior experience with computers?
  • What motivates you?
  • What are your goals for this year?
  • What can I do, as your teacher, to help you learn best?
  • If you are struggling in this class, what can I do to help you?
  • If you are struggling in this class, what will you do to help yourself?
  • What do you like most about yourself?
  • Tell me about something you’re good at UNRELATED to computers.
  • What do you think of when you hear the word computer science?
  • How do you think computer science might be useful for your future goals?
  • What’s the last idea that fascinated you?
  • Who is your favorite teacher and why?
    • The answers to this question gives me insight into what students’ value in a teacher. At times, I share these kind words with teachers that are mentioned, while keeping the student anonymous.
  • What are your hobbies?
  • What are your potential career interests?
  • Anything else I should know?
    • This is the most important question on the survey. Simply providing students an opportunity to share something else has been incredibly helpful. There is much that students are not comfortable in sharing at the start of the year, but some are.

CS Coaching Card

I’m fortunate to be a member of an excellent Professional Learning Community (PLC) focused on the computer science pathway at my school. We are given an hour each week to develop formative assessments, analyze data, reflect on our instructional practices, and improve our students’ experience in our classes.

One of the essential standards for all our computer science courses is “Collaborating around Computing”. (Our essential standards are the CS Practices from the K12 Computer Science Framework.) In our PLC, we determined that some students needed additional support when supporting their classmates. Specifically, we wanted to provide students some “tips to support your peers without stealing from them the joy of discovery”. The result was the CS Coaching Card. While creating the card, we realized it was also a useful resource for those students who didn’t want assistance at the moment but still needed some support; so, we added “… or to support yourself” to the heading.

The CS Coaching Card is organized around activities: design, code, test, debug. There are tips for each activity. The tips are coded to reinforce various pillars of computational thinking: decomposition, abstraction, pattern recognition, and algorithm design. For the most part, the tips simply capture the questions and suggestions that we teachers would offer to a student.

Here’s the CS Coaching Card for AP Computer Science A:

We tweaked it a bit for our introductory Python course:

Updated Physical Representations of Variables, Objects, and References in APCSA

I’ve been meaning to update my post from 2018 – Physical Representations of Variables, Objects, and References in APCSA with how it has evolved the past two years. The impetus to finally do so is due to attending Colleen Lewis and Hannah McDowell’s CSTA 2020 session, “AP CS A: Physical Models of Java Memory”. Colleen has a document with instructions, examples, videos, everything. What I realized during the session is that my approach was missing the concrete representation; it only had the pictorial and abstract representations. (I love the use of “remote controls” to model references!) So, I’m off to buy materials (I hope I can find stuffed animals that are turtles) and add concrete representations this year. I still want to share some updates on my pictorial models that have evolved over the past two years.

The most important change has been how invoking methods are modeled. I’ve captured this pictorial model in a set of slides (slide 22 – 34). These slides capture the following examples of invoking a method:

In the classroom, white rectangles still map to full sheets of paper (objects) and yellow rectangles still map to sticky notes (variables), as described in my original post. The new addition is the green rectangle, which maps to a green half-sheet of paper in the classroom that is presented as a form that is filled out, turned in, and returned when a method is invoked. The form models a method invocation. There are some parts of the form (arguments) that must be completed before the form is turned in (method is invoked). The field “this” must be completed (for non-static methods). When filling in the form, values are always copied from sticky notes (variables) or literals. There may be a part of the form that is “for office use only”. That is, it is not completed when initially filling out the form but will be completed when the form is returned. This models the return value of the method. When the form is returned, this value is copied from the form to a sticky note.

In class, students create these pictorial representations for various examples to develop their understanding. This additional pictorial representation coupled with improvements based on comments on the original post and feedback from students, has resulted in a model that helps students develop a strong understanding of, what I believe is the most challenging concept in APCSA, references in Java. This year, I’ll demonstrate with the concrete representation and then have students create these pictorial representations.