Monthly Archives: July 2020

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


  • 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 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 “<name>"
      • git config --global <email>
    • clone a repository
    • resolve issues authenticating
      • sudo apt install gnome-keyring
      • specify a password for the keychain


  • 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
  • key chain didn’t work on a clean install, but did after a clean restart



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


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


  • 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 as it is used extensively in those classes. As mentioned above, APCSA students used last spring during Remote Learning. However, I wanted a better experience if we use again this fall.

The GitHub and 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 requires some additional configuration.


  • GitHub Classroom now supports online IDEs (e.g.,
    • however, Classroom doesn’t support Java Swing at the moment
    • so, create the .replit file explicitly and add to the repo
    • still select 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/; java -classpath ./TurtleDemo:./TurtleDemo/+libs/* TurtleDemo"
    • # specify additional run commands for each project but have them commented out
    • # run = "javac -classpath ./ClassNotes ./ClassNotes/; java -classpath ./ClassNotes SyntaxErrors"
    • [...]
    • # run = "javac -classpath ./TurtleLab:./TurtleLab/+libs/* ./TurtleLab/; java -classpath ./TurtleLab:./TurtleLab/+libs/* TurtleLab"



  • GitHub support


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