Monday, February 13, 2017

Second CaptainTeach Assignment

My first assignment with CaptainTeach was well received by students. They like getting that much feedback and were able to indicate the benefit of reviewing work to familiarize themselves with the instructor's expectations.  The negatives they mentioned were only superficial: CaptainTeach isn't the pretty, commercial software that they are accustomed to. They were able to distinguish between early release software and buggy software; the consensus being that, while not pretty, CaptainTeach works.

This week we are going to use CaptainTeach to have students review tests that they write for a problem statement. Students have a series of problems that they need to solve by the end of the week. The problems are divided into three levels. Today all students are to write series of tests for each of the first group of problems and submit a file with the ten problem statements and their accompanying tests.

My .yaml file for the Captain Teach assignment is below. I am asking students to provide in-line feedback for their classmates' tests, then rate the work on completeness and thoroughness.

name: Function Design Lab Tests
id: tests-1
description: Students review tests for simple functions.  
steps:
  - id: Submit-Tests
    instructions: Submit a Pyret file that contains only problem statements and at least three tests per problem. The file extension should be .arr. Your file should not contain your name. An example file name would be function_design_practice.arr. Problems should be labeled from 1 to 10. Problem statements are comments. Tests should be inside of check blocks.
    reviews:
      - student-submission:
          id: Review-Tests
          amount: 3
          rubric:
            - instruction: Review the tests submitted by your classmates. Add at least one inline comment for each test to provide feedback. Your feedback should first attempt to identify one test per problem that your classmate has completed successfully. Next your feedback should suggest possible parts of the domain that should also be tested. Suggest specific values that should be tested.
            - likert: 
                id: completeness
                text: Indicate the number of problems for which the classmate has submitted at least 3 tests.
                min-label: None
                max-label: All
                granularity: 10
            - likert: 
                id: thoroughness
                text: How thoroughly do the tests attempt to tests different values in the domain?
                min-label: Minimal testing
                max-label: Extensive testing
                granularity: 10

Sunday, February 5, 2017

First CaptainTeach Assignment

I assigned a reading from a computer science text book to my 10th grade CS Principles class. They started the summary in class on Friday and had to submit the first two sections of the chapter by the end of the period. The remaining three sections are due before school Monday morning.

I didn't get the quality that I wanted from the first sections submitted on Friday and I thought this might be a good time to start using CaptainTeach. Students will submit the first section of their summary to CaptainTeach and those submissions will be distributed to classmates for review. I've decided to combine the students who will be piloting, so students may receive feedback from a students who are not in their class section.

Here is my first CaptainTeach assignment. Assignments in CaptainTeach are written in a "data serialization format" called YAML. The most important thing to learn was that indentation matters. The assignment asks students to review their classmates summaries using two likert scale questions: (1) does the summary include all important information, (2) is the summary text-based. Finally students are asked to provide any missing information to the student as feedback.

name: PaPl Chapter 3 Summary
id: papl-3
description: Students read chapter 3 of Programming and Programming Languagues and develop a summary of each of the five sections.
steps:
  - id: section-1
    instructions: Submit your summary of section 1. Separate your summary of section 1 from the other sections and submit it separately.
    reviews:
      - student-submission:
          id: section-reviews
          amount: 3
          rubric:
            - instruction: Read your classmates summary and provide feedback.
            - likert: 
                id: completeness
                text: Does the summary include all of the elements found in the example?
                min-label: Incomplete
                max-label: Complete
                granularity: 5
            - likert: 
                id: text-based
                text: Is the summary rooted in the text without making inferences or including outside information?
                min-label: Not Text-Based
                max-label: Text-Based
                granularity: 5
            - free-form:
                id: missing-information
                text: If applicable, provide any missing detail to the student that should have been included in their summary.

I was think about having them submit all five sections from the chapter but I think it will be too much and this is really a first test to get the workflow figured out. The first challenge for students will be that they are used to working in Google Docs and have their chapter summary in a single document. They will have to move the first paragraph into a new document, download as a text file and upload to CaptainTeach. I'll need to see how they break down the workflow before planning a larger assignment.





       

Thursday, January 19, 2017

Captain-teach Day 1

I'm beginning to use the captain-teach system, developed at Brown University, to facilitate peer review while an assignment is in progress. I'm going to pilot using this system on two of my 10th grade sections currently enrolled in AP CS Principles. I have a third section that is struggling with engagement and behavior that I am not going to try a new system with in the middle of the year.

AP CS Principles requires students to write about a computing innovation and about an original programming as part of the final course assessment. However, during the administration of these two tasks (8 hours for one, 12 hours for the other) I am not permitted to give students feedback on their work. At the same time they are encouraged to collaborate with each other.

Captain-teach accepts student submissions and distributes them to classmates for peer review. Reviewers can add in-line comments and provide feedback on likert scale determined by the teacher. The system is agnostic about the medium in which students are working, so I can use the same system for developing programs as for developing the documentation and written responses.

Our next unit is analyzing data. Students will need to be able to formulate questions that are answerable with a given data set. Captain-teach should provide a great way for students to give each other feedback on those questions.



Wednesday, November 12, 2014

Impact Lesson #3 - Introduction to Grace Hopper

Of course we want our students to know about Grace Hopper and in future years I hope to be able to able to offer a longer and more intimate introduction to students.  We began our introduction with a dive into an excerpt from the History of Computing website.  During the Impact unit students are annotating articles.  From their annotations they are either writing to prompts from the performance task or submitting into our class' computing innovations catalog.  We read and discussed Grace Hopper's contributions to computing with the enjoyment of sharing the "first computer science bug" anecdote and every student receiving a "nanosecond".  We watched Grace on Letterman and hoped that there's a new Google Doodle this year.  After our discussion we researched innovations that Grace contributed to directly: compilers and COBOL.  Students submitted catalog entries for their Grace Hopper related technology innovations.

Saturday, November 8, 2014

Unit 3 - Impact

After two months leading up the Create Mini Task we leave programming until the 2nd semester to prepare for the Explore Task.  We will prepare for the task in three units: Impact, Internet, and Data.  For this first iteration of Data we will focus on personal data and the implications on privacy and security when large amounts of data can be analyzed by sophisticated algorithms by powerful computers.

We are in the middle of the first of the three units leading up to Explore.  Using the task rubric as a guide we are researching computing innovations and practicing our analysis of them.  On our course website we have a google form set to collect information on computing innovations.  Each time a student submits a form for a computing innovation they are adding to the class catalog of potential research topics that students could use for the administration of the Explore task.  Since the CS Principles Performance Tasks must be administered without the assistance of the teacher, it is important to build up a class set of resources and structures that students can access during the administration of the task.

Each class period we practice one of the paragraphs of the written report.  In our last class for example we worked on the paragraph analyzing the long and short term benefits and harms of a computing innovation.  We read and annotated an article on the use of flying drone technology for criminal purposes and discussed the implications.  Students wrote a paragraph addressing the prompt with the homework assignment to pick one of the computing innovations from our class catalog and to write a paragraph on the short and long term benefits of that innovation.

I also want to use this unit to expose students to the trajectory of the computer science community as it has grown into a global phenomenon, and to familiarize students with people like Grace Hopper and to expose them to the evolution of computer science.  In future iterations I would like to build curriculum where we can use Ms. Hopper as a tour guide through computing innovations throughout the 21st century.  At the very least we will be passing out "nanoseconds".




Sunday, October 19, 2014

Unit 01 - Programming and Unit 02 - Abstraction

My CS Principles course use the 7 big ideas from the CSP curriculum framework as unit themes.  My in-progress curriculum map can be found here.  There are many concepts that overlap such as abstraction and algorithms as essentially parts of programming, or at least students program to demonstrate mastery.  However, structuring the course around the big ideas themes facilitates wrapping my mind around a dense curriculum (there are 305 knowledge objectives!).

My goal is to design a CS Principle that follows the How to Design Programs pedagogy in collaboration with Bootstrap curriculum.  The goal is to cover the first 10 sections (or 11 if your in the 2nd edition of HTDP) up through list of structs.  This should give students enough options to produce a unique artifact for the Create Performance Task.

Unit 01 - Programming introduced students to the Racket programming language.  Using the flag project idea from Brown's CSCI 0190, students develop expressions to display flags using composition of image producing functions.  Students get are introduced to abstraction by writing an arithmetic expression to control the dimensions of the flag.  For example if a rectangle is 300 x 200, students would write (* 3 100) (* 2 100).

In the Unit 02 - Abstraction students add abstraction to their flag programs by defining variables and functions.  They learn to identify the parameters of expression by looking at the arithmetic expressions they wrote in the previous unit.  The Abstraction unit culminates in a second iteration of the flag project that mirrors the Create Performance Task.  Students are required to produce a program to display a flag of their choice.  The project includes documenting the process and program.  Prompts are aligned to the Create Task.

Tuesday, October 14, 2014

Gradescope

gradescope.com is changing my relationship to assessment.  Subjectively graded student work is scanned in and then broken up into individual questions.  You grade work one question at a time using a rubric that you build up from student errors.

There is no difference in the grading itself; you still have to look at every question and award or take away a certain number of points.  The difference is in the speed and in the way students are receiving the feedback.  Keyboard shortcuts really speed up the grading process and I'm grading questions without identifying the student for the first time.

After grading is complete students receive an email with a link to their assessment.  They click through each question reading feedback.  Combined with a test corrections assignment this is the most reflective I've ever seen students be after receiving back a test.

When writing the rubric for each error I use formative assessment techniques that I'm learning from David Wees in his Math for America workshop.  Instead of right or wrong feedback I give students a question that they have to answer in their test corrections.  A test corrections document is shared via Doctopus and the students split their screens with the exam on one side and the corrections document on the other.