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

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.

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.

Programming Options while Remote Learning

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.

Physical Representations of Variables, Objects, and References in APCSA

Historically, my AP Computer Science A students have struggled with the concept that the value of a variable in Java can be a reference to an object. Actually, even before I started teaching APCSA, students would find me the week of the AP exam and ask for help on this concept. Over the years, I’ve improved both my instruction and student understanding in several ways. I’ve utilized tools like BlueJ’s debugger and the Java Visualizer to help students see the relationship between these concepts. I’ve created practice programming activities that create the cognitive dissonance necessary to spur reconsideration of understanding. I’ve woven these concepts throughout the curriculum to provide students with multiple and increasing complex opportunities to explore these relationships. Finally, I’ve tried to keep my language purposeful, precise, and consistent as, too often, we refer to variables as if they are objects. Despite these actions, students still struggled with these concepts. Last year, I had a new idea, and this year I implemented it.

I decided that these abstract concepts are further abstracted by the computer, and that’s too much abstraction for students at this point. Therefore, I removed the computer, and we explored these concepts via an extended analogy in a CS Unplugged manner:

  • variables are represented by small sticky notes
  • objects are represented by full sheets of paper
  • full sheets of paper are numbered in their upper-right corner; these numbers are references

IMG 9412

Variables When a variable is declared, a new small sticky note is used and the variable’s name is written on the top of the sticky note. The value of the variable is written below the name. There isn’t a lot of room on a small sticky note. There’s only enough room for values that don’t take too much space to store such as primitive values and references to objects. You cannot write all of the properties of a Turtle object on a small sticky note! When the value of a variable changes, the previous value is crossed off, and the new value is written.

Objects When a new object is created, a new sheet of paper is used. To keep track of all the sheets of paper, they are numbered in their upper-right corners. The name of the class of the object is written at the top of the sheet. The names and values of the object’s properties are written below the class name. There is plenty of room on a full sheet of paper to write all the properties of a Turtle object. As the value of an object’s property is changed, the previous value is crossed off, and the new value is written.

References References are the numbers on the upper-right corner of the sheets of paper. They are used to find the desired sheet of paper from among all the sheets of paper. When a variable is assigned the reference to a newly created object, the value of the variable is the number on the upper-right corner of the new sheet of paper for that object.

Methods When a method is invoked on a variable that references an object, the value of the variable is used to find the desired sheet of paper. Once the sheet of paper is found, the method can operate on the object by potentially changing the object’s properties by updating a value on the sheet of paper or returning a value.

In one lesson, I modeled this extended analogy for the class in the context of a simple example involving two Turtle objects, two variables that reference Turtle objets (turtle1, turtle2), and two variables of type int (number1, number2). In the next lesson, pairs of students, with my assistance, traced through a couple of other examples using small sticky notes and sheets of paper.

Based on a short formative assessment, student understanding appears to be improved compared to previous years. I will continue to use this extended analogy as we revisit these concepts throughout the year. I may extend this analogy when students start implementing their own methods to include a paper form that represents a method invocation. Values are copied to complete the form. When the form is returned after the method returns, the returned value is copied as well.

If you have any feedback, please share!

Project-Based Learning in New Software Engineering Course

A couple years ago, I wrote about a new course that would be offered in the 2017-2018 school year, Software Engineering. Last school year, the course was a great success, although there are many refinements I’m preparing for this upcoming school year. The second semester of the course is described as “small groups of students develop a software product as they iterate through software engineering development cycles to produce a software product”. Other teachers expressed the most interest in how to facilitate teams of students managing a semester-long project and how to assess them throughout the semester. Until last semester, I had never done this as a teacher. Fortunately, I remembered that I did this every day in my previous career as a software engineer.

One of my roles in my previous career was that of a methodologist with a specific focus on Agile Methodologies. After a review of the current state of Agile Methodologies, I decided that Scrum would be a good fit for my students. None of these students have any experience with Agile Software Development, and few have worked as part of a team on a substantial project. Scrum provided sufficient structure while maintaining the lightness appropriate for small teams. The activities in each sprint provide the opportunities for everything that is needed in project-based learning: planning, review, and reflection. I attempted to fulfill the role of Scrum Master. Each team had a product owner who was external to the class.

If you are interesting in a succinct overview of Scrum, I highly recommend the book, Scrum: A Breathtakingly Brief and Agile Introduction by Chris Sims and Hillary Louise Johnson. (If you want more, their book The Elements of Scrum is also excellent if the first book leaves you wanting more.)

I scheduled the teams into four, staggered, 4-week-long sprints. While all teams started and ended their project based on the start and end of the semester, the first and last sprint for each team were of varying length such that I could facilitate the activities with each team during class.

The key activity in Scrum is the Daily Scrum or stand-up meeting. Teams would hold their Daily Scrum twice a week. Having a four-week sprint seems long, and holding a Daily Scrum twice a week seems infrequent, but these teams aren’t developing software as a full-time job; they are in class for 50 minutes a day. At the beginning of the semester, I would facilitate every Daily Scrum meeting in my role as Scrum Master. Soon students became adapt and comfortable, and teams held their Daily Scrums while I observed from afar.

We focused on four activities in each sprint: Sprint Planning, Story Time, Sprint Review, and Retrospective. For each of these, the team would assign a student responsible for facilitating the activity, capturing the work, and sharing it with the team. With a team of four students and four sprints, each student would facilitate each of the four activities throughout the semester. The student facilitating the activity was assessed based on the student’s effectiveness in facilitating the activity, their demonstrated understanding of the activity, and the quality of the submitted document.

Repeated feedback is essential for both project-based learning and software development. Teams would receive feedback from their product owner during each sprint review (and more often as needed). Teams would receive feedback from me and each other during each retrospective.

In addition to these standard Scrum activities, I added an additional activity at the end of each sprint, a personal retrospective. Each student would evaluate themselves based on their role as a Scrum Team Member, reflect on the personal goal they set in the previous sprint, and set a new personal goal for the next sprint. Based on student feedback, for the upcoming school year, I will also have students evaluate their teammates.

At the end of the semester, we hold a Demo Event attended by all the students, their product owners, and other stakeholders. Each team presents their product in a modified version of the “3-in-5” presentation format. After the Demo Event, each student completes a final retrospective reflecting on the entire semester.

This structure worked well for my students and their projects last semester, and we will use the same structure next year with some refinements.

One final note – Scrum is used for all kinds of projects; not just software projects. After my experience last semester, I would encourage teachers to consider Scrum as a tool to facilitate any project-based learning of a significant duration.

Questions? Comments? Please comment here or each out to me on Twitter.