Unlike Google forms which I used previously, I can use the full power of MathJaX & XyJax to display mathematical content and vectorize diagrams in my questions. Because these apps are provisioned in the tamu.edu domain, it has also enabled me to personalize data to each student using the Google IDP for OAuth-based authentication. It allows me to display the student's attendance record, their relative standing in the class, my feedback for them etc., while being mindful of privacy. If you are interested in improving that bit of software, I'd be happy to bundle it in a form that may be usable by others.

To make this process more automated, I wrote an XSLT style sheet that generates inline styling information for documents written in XML. I generate HTML pages from XML using Python's lxml module, that I then paste into Canvas. You can find the style-sheet and the Python driver here. If you try it, let me know what changes make it run more smoothly for you. You may need to change a few things here and there, but you'll get an idea of where I'm going with it. The set of web pages that you're viewing have been built using the stylesheet.

<article>
<section title="Week 1">
CSCE 313: Introduction to Computer Systems
<subsection title="Lecture 1">
Class policy. Introduction.
</subsection>

<subsection title="Lecture 2">
<ul>
  <li> Git Overview during labs. </li>
  <li> x86-64 ISA overview. </li>
  <li> Linux environment setup. Watch this video by <a
    href="https://www.youtube.com/playlist?list=PLIZzM4eefg8Cg3P4Mpfj77FUA4ZNlxJF8">Prof. Houngninou</a>.</li>
</ul>
</subsection>
</section>

<section title="Week 2">
This week we'll cover the following topics.
<ul>
  <li> Assembly Language Programming on the x86-64.</li>

  <li> <a href="https://canvas.tamu.edu/files/58847845/download?download_frd=1">CSCE313_0101.pdf</a> (8/29).
  This is about 70 slides out of the 250 slides that cover x86-64 assembly language programming in
  Profs. Bryant &amp; Hallaron's class at CMU. </li>

  <li> x86-64 ISA. <a href="https://cs61.seas.harvard.edu/site/2022/Asm/#gsc.tab=0">Prof. Eddie Kohler's Assembly Page</a></li>
</ul>
</section>
</article>

<article>
Show that if <m>A, B, C</m> are sets, then
<dm>\overline{A \cap B \cap C} = \overline{A} \cup \overline{B} \cup \overline{C}</dm>
using a membership table.

<p> What can you say about the sets <m>A</m> and <m>B</m> if we know that</p>
<ol>
  <li> <m>A \cup C = B \cup C</m></li>
  <li> <m>A \cap B = A</m></li>
  <li> <m>A - B = A</m></li>
  <li> <m>A \cap B = B \cap A</m></li>
  <li> <m>A - B = B - A</m></li>
</ol>
</article>

class MathExtension(etree.XSLTExtension):
    def execute(self, context, self_node, input_node, output_parent):
        eqn = input_node.text
        e = quote(quote(eqn))
        out = f"""<img class="equation_image" src="/equation_images/{e}?scale=.9"/>"""
        output_parent.append(etree.fromstring(out))


class DisplayMathExtension(etree.XSLTExtension):
    def execute(self, context, self_node, input_node, output_parent):
        eqn = input_node.text
        e = quote(quote(eqn))
        out = f"""<p style="display:block;text-align:center;margin: 8px 0 5px 0;"><img class="equation_image" src="/equation_images/{e}?scale=1"/></p>"""
        output_parent.append(etree.fromstring(out))

Let's say that students are tasked with writing a Java program that converts fahrenheit to celsius.

• When a student submits their code (in this simple example it's just one Java file F2C.java), it's available in /autograder/submission in the Docker container.
• Gradescope eecutes the file run_autograder and expects that the output will be a json file formatted as below that lists each test case that was run, the student's score for the test and the maximum score for the test.

    {
      "tests": [
        {
          "Test Case": "Test with argument 104.8",
          "score": 10,
          "max_score": 10
        },
        {
          "Test Case": "Test with argument 98.4",
          "score": 10,
          "max_score": 10
        }
      ],
      "score": 20
    }  
    
  

• To simplify running tests and parsing the output of test cases, we use Python in this example. run_autograder is a bash script that serves as a test harnes for running various tests. It looks like the following.

    #!/usr/bin/env bash
  
    cd /autograder/source
    cp /autograder/submission/F2C.java /autograder/source
  
    cd /autograder/source
    javac F2C.java
  
    # Run the autograder code
    python3 runtest.py
    python3 genout.py
    cat /autograder/results/results.json
    
  

• runtest.py looks as follows.

    import re
    import unittest
    import subprocess
  
  
    # See https://github.com/gradescope/autograder_samples/blob/master/python/src/tests/test_simple.py
    # https://stackoverflow.com/questions/4414234/getting-pythons-unittest-results-in-a-teardown-method
    class TestF2C(unittest.TestCase):
        JAVA = "java"
  
        def setUp(self):
            pass
  
        def tearDown(self):
            pass
  
        def add_score(self, score):
            with open("result", "a") as W:
                W.write(f"{score}\n")
  
        def test_one(self):
            cmd = [TestF2C.JAVA, "F2C", "104.8"]
            data = ''
            with subprocess.Popen(cmd, stdin=None, bufsize=-1, stdout=subprocess.PIPE) as proc:
                data = proc.stdout.read()
            val = data.decode('utf-8')
            if re.search(r"^\s*40.4", val):
                self.add_score(10)
            else:
                self.add_score(0)
            #self.assertRegex(val, r"^\s*40.4", "Incorrect response to 104.8")
  
        def test_two(self):
            cmd = [TestF2C.JAVA, "F2C", "98.4"]
            data = ''
            with subprocess.Popen(cmd, stdin=None, bufsize=-1, stdout=subprocess.PIPE) as proc:
                data = proc.stdout.read()
            val = data.decode('utf-8')
            if re.search(r"^\s*36\.8", val):
                self.add_score(10)
            else:
                self.add_score(0)
            #self.assertRegex(val, r"^\s*41", "Incorrect response to 98.4")
  
  
    if __name__ == '__main__':
        unittest.main()
    
  

  runtest.py runs the tests and appends a score out of 10 for each test, one entry per line into the file results.
• After the tests have executed, we generate the json formatted output that encapsulates the test results. That code looks as follows.

    import json
  
    TESTS = {
        0: "Test with argument 104.8",
        1: "Test with argument 98.4"
    }
    total = 0
    out = {}
  
    with open("result", "r") as R:
        scores = R.readlines()
  
    for s in scores:
        total += int(s)
  
    out["score"] = total
    out["tests"] = []
    for i, s in enumerate(scores):
        out["tests"].append({
            "score": int(s),
            "max_score": 10,
            "Test Case": TESTS[i] if i in TESTS.keys() else "???"
        })
  
    with open("/autograder/results/results.json", "w") as W:
        W.write(json.dumps(out, indent=2))
    
  

  The code is quite straightforward.

Here's a basic Dockerfile that creates a container with JDK in it.

FROM ubuntu:bionic

RUN apt-get -y update
RUN apt-get -y install software-properties-common
RUN add-apt-repository ppa:openjdk-r/ppa
RUN apt-get -y install openjdk-11-jdk
RUN apt install python3
WORKDIR /autograder/submission
COPY F2C.java .
WORKDIR /autograder/source
COPY run_autograder .
COPY *.py .
WORKDIR /autograder/results
RUN touch results.json
WORKDIR /autograder/source

Students have complained that when I point to stuff on the big podium display with my hand, they can’t see it and would like me to point to things by marking them on the display. (I would have preferred a more amphitheater-like classroom where everyone looks at the podium, but the table displays have inexorably trained students over time into staring at their closest monitor!) So how can you mark text that appears in your Powershell or iterm2 window?

Enter the Epic Pen. Also talk to Ted Seidel who offered this tip. Basically, install the Epic Pen software and you can annotate any portion of the display! It's also available in the OS image deployed on the ZACH PC's.