Tag Archives: chromebooks

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.

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

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

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

Unfortunately, InfuseLearning closed their doors in April. In preparation for sharing resources with teachers this summer before we deploy 1:1 Chromebooks for all high school students this fall, I surveyed the current tools available with a focus specifically on Peer Instruction that supports drawing and peer-critique of written responses.

I evaluated the following features.

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

Socrative

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

The Answer Pad

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

Formative

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

Pear Deck

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

NearPod

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

Conclusions

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

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

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

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

Chromebook Toolchain for AP Physics

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

  • Canvas. Everything starts and ends with this learning-management system.

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

  • LabQuest 2. Vernier’s LabQuest 2 can create its own ad-hoc network or connect to the school’s wireless network. The LabQuest 2 hosts its own web page as part of their Connected Science System. Students can then access the device, the data, and graphs via Chrome. Data and graphs can be exported to the Chromebook via the web page.

The next tool depends upon the lab. For some labs, the data and graphs produced on the LabQuest 2 are sufficient. Students will import these into their Google Document and create whatever is required for their lab report. If additional analysis is required and the data sets are relatively small:

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

  • Plot.ly. Plot.ly seemed to explode onto the education scene this summer, or maybe I was just paying more attention. Data exported from the LabQuest 2 can easily be imported into Plot.ly. Like Desmos, graphs can be shared via a link and an image can be embedded in the Google document. Plot.ly can also embed its graphs in an iframe, but I couldn’t find a way to embed that in a Google document as opposed to a web page. Fran Poodry from Vernier made a great screencast demonstrating the integration of the LabQuest 2 and Ploy.ly.

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

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

  • Glowscript. Glowscript is the up-and-coming platform for computational models with the advantage that it runs in a browser that supports WebGL. I’m not a huge fan of JavaScript syntax for novice programmers; so, we will be using CoffeeScript instead. I didn’t write as many starting models over the summer as I had hoped, but I did at least verify that complicated models can be ported.

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

  • InfuseLearning. There are a number of web apps in this space, but I selected InfuseLearing because it allows the creation of spontaneous questions, supports a variety of answer methods including drawing and sort-in-order. Pear Deck looks promising, but I don’t want to be forced to create my set of questions ahead of time.

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

  • Evernote. I love Evernote and use it all the time for all sorts of stuff.

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

  • Crocodoc. The free personal version allows students to upload a PDF, annotate it, and export their annotated version. Other tools I explored are Notable PDF. This requires paid licenses to be useful. We may try this out if we find Crocodoc lacking.

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

  • Doctopus. I think Canvas assignments and SpeedGrader cover everything that I personally would do with this app.

  • 81Dash. Private back-channeling app.

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