Category Archives: programming activities

Tetris Lab for APCSA

For the past two years, our AP Computer Science A (APCSA) students have completed the Tetris Lab at the end of the Object Oriented Design (OOD) unit. The initial idea and structure for the lab was forked from Stanford Tetris Project from Stanford’s CS108 by Nick Parlante, which I found as it was a SIGCSE 2001 Nifty assignment. We made significant changes during the first implementation of the lab and before the second. The current version of the Tetris Lab is a great fit for the goals that we have for our students at the point in the semester when they complete it. Your students may need something different or at a different time. Regardless, I hope you find something to adapt to your class.

To provide some context, for our APCSA classes, the OOD unit is the second to last unit before the AP exam. The last unit focuses on recursion along with sorting and searching algorithms. Our OOD unit still includes interfaces even though that is no longer part of the AP curriculum. Students also implement basic Swing-based graphical user interfaces. At the end of this unit, we want students to demonstrate their understanding of the OOD concepts as well as practice the design and implementation of more advanced algorithms in preparation for the AP exam. We have designed all of our summative programming labs to be scored based on the defined requirements but also to have various extensions that students can pursue based on their interest and time available. We also provide opportunities for students to personalize their summative programming labs. Honestly, that is a weakness of the Tetris Lab as personalization is primarily presented through extensions and not requirements and, therefore, not incorporated by all students.

The lab is split into two parts. The first part focuses on the model for a Tetris piece and students work with their pair-programming partner to complete this part. This part emphasizes the design and implementation of various algorithms related to Tetris pieces. We found that students working in pairs help each other especially with the design of these algorithms. The Piece class with declared methods and instance variables is provided in the starter code. Pairs implement the following methods:

  • Piece constructor in which they have to design and implement an algorithm to:
    • copy an Array of references to Point objects and copy the Point objects (they really struggle with this and it is a great opportunity to review one of the most challenging concepts in the course, Java references);
    • determine the width and height of the piece
    • determine the skirt of the piece (this is the most challenging algorithm in the constructor and pseudocode is provided so that student can focus on implementing the algorithm)
  • toString (used when debugging)
  • the rotation algorithm in the pieceRow method; the starter code defines three steps to rotate a piece to decompose this algorithm and make it more accessible for students to implement:
    • step 1: reflect across the line y = x
    • step 2: reflect across y axis
    • step 3: translate right

In other summative programming labs, students write their own unit tests. In this lab, the test code is provided and students run the tests to verify that their have completed each milestone. The first part of this lab consists of two milestones:

  • Milestone 1: JPieceTest Initial Pieces
  • Milestone 2: JPieceTest with Rotations

Students run the JPieceTest class and visual verify that the output matches the expected output in the lab document.

After completing these two milestones, which comprise the first part of the lab, the TetrisViewer class can be executed to play the game of Tetris. The Board, JTetris, and TetrisViewer classes are fully implemented in the starter code. (This is the most significant departure from the original lab as students do not implement the Board class. The first year we did this lab, I expected students to implement the algorithms in the Board class and, after witnessing how they were challenged with the algorithms in the Piece class, changed course and provided them with a fully-implemented Board class.)

The second part of the lab focuses on enhancing the game of Tetris such that the code can play the game autonomously. In this part students demonstrate their understanding of defining a subclass, overriding methods, and interfaces.

Milestone 3 focuses on the extension of the GUI defined in the JTetris class by the JBrainTetris class which adds a combobox used to select which “brain” is active and a button to enable/disable the brain. Students implement the JBrainTetris class from scratch to demonstrate their understanding of creating a subclass and overriding methods. While students have used the JButton class previously, they have learn how to incorporate the JComboBox class into the code. In addition to the components and their associated listeners, students also implement the createBrains method in the BrainFactory class. This is straightforward but a good opportunity for students to see the factory pattern and appreciate the strengths of polymorphism.

Milestone 4 focuses on overriding the JTetris methods pickNextPiece and tick to support the “brains” playing Tetris. These are challenging methods to override and students needs to understand the provided JTetris code in order to do so successfully. Understanding and then leveraging provided code is an authentic feature of many of our summative programming labs.

Milestone 5 is an additional test that shouldn’t require any additional implementation. However, students often have undetected bugs that need to be addressed.

Completing the 5 milestones meets the requirements for the lab. There are, however, several opportunities to “add more awesome” through extensions:

  • new pieces (define additional pieces with more or less than four blocks; this is a great opportunity to appreciate the benefit of abstraction as only the Piece class has to be modified)
  • adversary (add a feature where the code uses a brain to select the most challenging next piece; this is a great example of how decomposition can lead to code reuse)
  • BigBrain (implement a new brain that is smarter than the provided SimpleBrain class; students can take this extension as far as they want and spend significant time tuning their algorithm either by hand or with the assistance of a genetic algorithm)

The latest starter code is available on GitHub.

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.

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.

Twitter Mapping Lab


For the past four years, we’ve done a Game of Life lab as part of the Decisions and Loops unit in AP Computer Science. I love that lab for many reasons. However, after four years and not using GridWorld anywhere else in the curriculum, I’ve decided it was time for a change. I’ve wanted to incorporate data analytics and visualization into a lab. After some research and ideas from a couple of labs developed by others, I’m excited to try a new lab this year: Twitter Mapping.


From what I provide students:

Your application will allow the user to search Twitter for a particular word or phrase in tweets located in each of the 50 US states and then display on a map of the US the degree of positive or negative sentiment associated with that search term in each state. For example, if the search term is coding, the following map may be displayed.

Twitter Data Visualization

  • This lab has several goals beyond the immediate concepts of decisions, loops, and unit tests in this unit:

  • Exposure to data analytics. In this lab you will search a large data set (tweets on Twitter) and analyze that data to derive a new understanding (the sentiment of tweets containing a given keyword in each of the 50 US states).

  • Experience using an API (Application Programming Interface) within the context of an unfamiliar software application. In this lab, you will use the Twitter4J API to access Twitter and write code within the partially implemented Twitter Mapping Lab application.

  • Exposure to data visualization. In this lab you will visually represent the average sentiment in a map of the 50 US states.


Feel free to read the entire lab document and check out the GitHub repository with the starter code. If you would like a sample solution, please contact me.


AP Computer Science Summative Labs

I have selected the summative labs for next year’s AP Computer Science course. Students complete a huge number of practice programming activities as a whole class, through pair programming, or on their own. The purpose of these practice activities is to focus on learning and receive and provide feedback. At the end of each unit, students complete a summative lab. I kept the most successful labs from last year pretty much unchanged, revised some, and incorporated some new ones. An important element of each summative lab are the extensions. None of the extensions are required, but most students try to implement some of them or create their own extension. I have students with a diverse set of programming experience and knowledge, and the extensions provide the opportunity for each student to be challenged.

A new element of next year’s class, which affects all the labs, is the use of [GitHub]( I want students to be exposed to and gain familiarity with some of the best practices of software engineering. Last year, students leveraged JUnit to write unit tests. This year, they will use GitHub for source control management. I created a repository for each unit which contains some practice projects and at least an empty project for the summative lab (maybe more, depending on the lab). Students will fork these repositories into their own accounts and commit changes as they work on the practice programming activities and summative lab throughout the unit. When they complete the summative lab, they will create a pull request. In response, I will offer feedback and assess their summative lab. At the end of the course, students will have a collection of repositories in their own GitHub account that captures all of their coding.

Here are the summative labs with links to the associated unit’s GitHub repository:

[Turtle Lab](

*This is a new summative lab. I’m de-emphasizing (but not eliminating) GridWorld. The first lab used to involve placing GridWorld actors in a world. Instead, students will do something similar with turtles. This lab leverages the [Media Computation classes from Georgia Tech]( This lab nicely frames the first unit as students create a turtle world program on their very first day of class.*

### Purpose

The goal of this lab for you to experience what your first assignment as a software developer at a software company may be like. You will be working with a large body of code (Turtle and TurtleWorld) with which you are unfamiliar. You don’t understand all of the intricacies of the existing code base and you aren’t yet familiar with many of the Java language features that you will use. However, through experimentation and browsing the documentation, you will be able to complete this assignment and most likely go beyond the requirements!

### Requirements

* Sync the TurtleLab directory from GitHub.
* Draw a pattern using at least two Turtle objects.
* Invoke multiple methods on the turtle objects to change their attributes.
* Follow our Java style guidelines.

### Extensions

* Make a more sophisticated pattern.
* Make a pattern that involves multiple colors.
* Change the picture for the turtle to something else.
* Add more awesome.
* Something else? Be creative and share!

### Submission

* Submit a pull request in GitHub and submit a link to the request with this assignment.

[Cityscape Lab](

*This lab was new last year and was created by my counterpart at our sister high school. I’ve left it as is other than incorporating the design class diagram into the lab description. (I drew the DCD on the whiteboard last year in response to student questions.)*

### Introduction

The goal of this lab is for you to demonstrate that you can define classes, create objects, and display graphics via a Java application.

### Requirements

* Create a Java graphical application (with a Viewer class, Component class) that displays a cityscape.
* Design at least three classes for elements of the cityscape (e.g., building, window, sun, moon, car, tree)
* demonstrate good class design (encapsulation)
* provide configurability through constructors and instance variables (size, color, etc.)
* Create multiple instances of a class with different properties and display in the cityscape.
* Document the class using JavaDoc comments as demonstrated in our code template.
* Peer review another student’s lab and provide comments in the rubric hosted in Canvas.

Here is a design class diagram to illustrate the relationship among the classes in this project:


### Extensions

* Define additional classes for additional elements of the cityscape.
* Animate your cityscape (e.g., day and night, lights in windows, moving cars)
* Randomize your cityscape (a different cityscape every time)
* Add more awesome.

### Submission

* Submit a pull request in GitHub and submit a link to the request with this assignment.

[Game of Life Lab](

*This was the [first lab]( that I created on my own and have used it the past two years. It is a perennial favorite of the students. Last year, I tried to incorporate unit testing into this lab and it was a bit rocky. This year, I’m providing more scaffolding to help students implement their unit tests.*

### Introduction

The goal of this lab is to apply your understanding of decision and loop structures to implement a complex algorithm within the context of an unfamiliar and significant software framework (GridWorld). In addition, you will implement a unit test for your program using the JUnit framework and create documentation for your program using JavaDoc.

### Requirements

Write a program that plays [Conway’s Game of Life][1]. Conway’s Game of Life is a cellular automaton. From Wikipedia:

_The universe of the Game of Life is an infinite two-dimensional orthogonal grid of square cells, each of which is in one of two possible states, alive or dead. Every cell interacts with its eight neighbours, which are the cells that are horizontally, vertically, or diagonally adjacent. At each step in time, the following transitions occur:_

* _Any live cell with fewer than two live neighbours dies, as if caused by underpopulation._
* _Any live cell with two or three live neighbours lives on to the next generation._
* _Any live cell with more than three live neighbours dies, as if by overcrowding._
* _Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction._
* _The initial pattern constitutes the seed of the system. The first generation is created by applying the above rules simultaneously to every cell in the seed—births and deaths occur simultaneously, and the discrete moment at which this happens is sometimes called a tick (in other words, each generation is a pure function of the preceding one). The rules continue to be applied repeatedly to create further generations._

### Nonfunctional Requirements:

* the program must be implemented in Java and utilize the GridWorld platform
* I recommend not use GridWorld’s execution engine to produce subsequent generations. It will be easier to implement the unit test if you directly produce and display subsequent generations.

### Artifacts to Produce:

* Requirements Document: Many functional and nonfunctional requirements needs to be defined. You must define additional requirements that are reasonable and document them in a requirements document. I must review your requirements document before you start the design document or test plan. You may change the requirements document throughout development.
* Design Document: You must do some design activity before starting implementation. This may consist of a flow cart, pseudocode, or other design artifact. I must review your design document before you start implementing code. You may change your design document throughout development.
* Test Plan: You must create a test plan with specific test cases (at least two) before starting implementation. I must review your test plan before you start implementing your test class. You may change your test plan throughout development. The provided code in GitHub is an example of implementing an initial test case.
* `GameOfLifeTest `Test Class: JUnit-compatible test class that implements the test plan.
* `GameOfLife` class: You must produce a working class the meets the requirements and is verified and validated by your test plan.
* Reflection Document: This is a significant and challenging lab. Please reflect on this experience and share your feedback with me. What did you like or dislike and why? What was surprising or unexpected? What did you learn? What questions do you still have? What advice would you offer next year’s students?

### Extensions:

* Add custom icons for alive or dead cells.
* Implement more sophisticated seed patterns.
* Add more awesome.

### Submission:

* Ensure the following artifacts have been committed to GitHub in addition to your code:
* requirements document
* design document (pseudocode, flow charts, etc.)
* test plan (with specific test cases)
* HTML documentation generated by JavaDoc
* reflection document
* Submit a pull request in GitHub and submit a link to the request with this assignment.

### Rubric:

The implementation will be evaluated according to the Computer Science Grading Rubric in Canvas. The other artifacts will be evaluated independently.

[Signals in Noise Lab](

*This is a new lab. It is inspired by the post “[Detecting Signals and Noise](” on the DataGenetics blog. I was looking for a new lab for arrays and array lists. I also wanted a lab that more directly represented an authentic application of computer science. This technique to detect a signal in the presence of noise is conceptually very similar to that used in particle physics experiments (e.g., dark matter candidates hitting multiple CCD pixels or tracks reconstructed within a particle collider). I wrote the code for the case of a stationary target as an example. Students will tackle the more challenging case of a moving target. I’m really looking forward to seeing how students engage with this lab.*

### Introduction

The goal of this lab is to apply your understanding of 2D arrays to implement a complex algorithm. In addition, you will implement a unit test for your program using the JUnit framework and create documentation for your program using JavaDoc.

One common application of computing is signal analysis. In real-world applications, the data that is processed is a combination of something of interest (the signal) and garbage that obscures the signal (noise). Computational techniques for signal analysis are prevalent in a wide variety of scientific and financial applications. This lab provides a simplified context in which to explore signal analysis. Conceptually, the techniques you will use in this lab are similar to those used in particle physics experiments.

### Requirements

* Write a Monster Early Warning program that finds a moving monster based on the data from your noisy radar system. This is described in DataGenetics blog post, “[Detecting Signals in Noise][2].” The sample code in GitHub implements the case of a stationary monster. You may leverage this code to implement the case of a moving monster, which is more complicated.
* Design your program such that the initial position and velocity (dx and dy) of the monster can be specified interactively (e.g., from a user) or as parameters (e.g., for your unit test).
* Implement a unit test for your program that tests multiple cases.
* Document your code with standard JavaDoc comments.

### Extensions:
* Add support for detecting multiple monsters.
* Develop a different detection algorithm.
* Add support for straight-line constant acceleration motion.
* Add more awesome.

### Submission:

* Submit a pull request in GitHub and submit a link to the request with this assignment.

[Collage Lab](

*This lab is from the [Media Computation materials from Georgia Tech]( Students create [incredibly creative collages]( This is the first lab of the spring semester and is a good review of the fall semester after winter break. This lab is very similar to the new [AP Picture Lab]( I’m going to have students complete most of the activities in the AP Picture Lab as practice programming activities.*

### Introduction

The goal of this lab is for you to apply creatively the filters and transformations that you have developed throughout this unit.

### Requirements

* collage contains at least 4 copies of the image
* the 4 copies includes the original image and at least 3 modifications of the original image
* modifications must include one or more filters (changing colors) and one or more transformations (scaling, cropping, mirroring)
* the collage must run on its own (don’t invoke FileChooser.pickAFile())
* * instead copy the source image file into the same folder as your Java source files and just specify the file name to the Picture constructor
* For example: Picture sourcePic = new Picture(“beach.jpg”);
* the collage must be saved as an image file, the path needs to be absolute and specific to where you have your bookClasses folder stored. I recommend copying and pasting the path from an Explorer window to your code and then escaping the backslashes. For example:
* * finalPic.write(“H:\2014\AP Computer Science\Media Computation\bookClasses\MyCollage.jpg”);

### Extensions

* Add more copies.
* Add more filters
* sepia:
* convert to grayscale
* if red < 60 then reduce all three components to 90% of their original value
* else if red < 190 then reduce just blue to 80% of its original value
* else reduce just blue to 90% of its original value
* posterize
* set all color component values in a range to one value (the midpoint of the range)
* try with four ranges for each color (0-63, 64-127, 128-191, 192-255)
* pixelate
* Add more transformations (e.g., rotation)
* Add more awesome.

### Submission

* Commit the generated collage image file to GitHub.
* Submit a pull request in GitHub and submit a link to the request with this assignment.

[Elevens Lab](

*This is one of the new [AP Computer Science labs]( I wanted to try a new object-oriented design lab and this looks like it may be a good fit.*

### Introduction

The goal of this lab is for you to apply object-oriented design principles to implement the card game Elevens.

### Requirements

* complete Activities 1-9 of the AP Elevens Lab.
* peer review another student’s lab and provide comments in Canvas.

### Extensions

* complete Activities 10-11 of the AP Elevens Lab.
* Add more awesome.

### Submission

* Submit a pull request in GitHub and submit a link to the request with this assignment.

[Fractal Tree Lab](

*The [original version of this lab]( was inspired by George Peck from Lynbrook High School. The end product of this lab has remained the same over the past two years, but last year it was more effective since I provided much less scaffolding. That change was a result of feedback from students who let me know that the original version of the lab was too easy. I’m keeping it unchanged for next year.*

### Introduction

The goal of this lab is to create a recursive algorithm to draw a tree.

Imagine you were describing how to draw a tree. You might say:

1. Draw a vertical line
2. At the top of the line, draw two smaller lines (“branches”) in a v shape
3. At the ends of each of those two branches, draw two even smaller branches
4. Keep repeating the process, drawing smaller and smaller branches until the branches are too small to draw

This process of repeating the same design at a continually decreasing scale is an example of a _Fractal_. Using fractals to draw trees can give some [interesting and beautiful patterns.][3] In this assignment we will use a recursive branching function to create a fractal tree.

### Requirements

* Use the Koch Snowflake program as a starting point for an TreeViewer class and a TreeComponent class.
* The trunk of the tree needs four values: the X and Y of the starting point and the X and Y of the end point. We will also have three member variables that will control:
* how much smaller the branches are
* how small the branches will get
* the angle between the branches.

### Extensions:

* Add controls (e.g., scrollbars) to allow the user to change member variables that affect the construction of the tree.
* Some fantastic trees can be produced by modify algorithm to add asymmetry, adjust angles,
 adjust thickness, or adjust color.
* Add more awesome.

### Submission:

* Submit a pull request in GitHub and submit a link to the request with this assignment.


A Different Kind of Computer Science Literacy: Reading, Writing, Debate

I want my AP Computer Science course to be more than a programming class. I want my students to read, think, write, and debate issues at the intersection of technology, society, and ethics. I suppose this aligns with the AP Computer Science course goal of “understand the ethical and social implications of computer use,” and “Computing in Context” topics (“An awareness of the ethical and social implications of computing systems is necessary for the study of computer science. These topics need not be covered in detail, but should be considered throughout the course.”). I’ve never seen a question related to these topics on the AP Exam, and I wonder how much these topics are addressed in classes throughout the world. Regardless, students should explore these topics. In addition, practicing reading, writing, analyzing, and debating these topics incorporates various Common Core literacy standards.

The first standard for my course is: “Standard 1 – Analyze, evaluate, and debate examples combining technology, society, and ethics.” Last year, students completed five discussion assignments associated with this standard; three the first semester and two the second. In preparation for next year, I revised these assignments. I kept the ones that resulted in the most engagement and discussion relatively unchanged. I combined a couple into a richer collection of articles in hopes of generating a stronger discussion. I created a couple of new assignments to expose students to topics I felt were important. Next year, I plan to have students complete three discussion assignments in the fall semester and three in the spring.

In hopes that other computer science educators will find these assignments useful in their classrooms, I’ve copied the six from [Canvas]( into this blog post.

What is Computer Science? Who should learn it? When should they start?

In the past couple of years, there have been efforts to promote computer science to the public and primary and secondary students in particular. Last December, [][1] hosted the [Hour of Code][2]. On January 1, 2012, [Codeacedemy][3] declared that 2012 would be “Code Year.” Audrey Waters wrote [an article][4] about “Code Year,” the press it generated, and if it is a good idea. The controversy erupted when Jeff Atwood, co-founder of Stack Overflow, published his response: “[Please Don’t Learn to Code][5].” In the Association of Computing Machinery journal, Esther Shein wrote an [excellent article][6] on the subject. In February, National Public Radio [did a piece][7] on these efforts. What complicates all of these efforts is the general lack of agreement about what is computer science. Jonah Kagan raises this point in his article “[Computer science isn’t a science and it isn’t about computers][8]”.


* Read all five articles (Waters, Atwood, Shein, NPR, Kagan) and any others related to the topic that you find interesting.
* Post a response to these articles. Your response must:
* Provide a brief overview of each of the four articles.
* Answer multiple prompts (potential, not exclusive, prompts are enumerated below) in detail.
* Cite specifics from each of the four articles to support your response and demonstrate that you carefully read and analyzed each article.
* Connect the articles to your personal experience (past, present, or future).
* Comment in a civil and respectful manner on other’s responses or comments. (You must post before you can see others’ responses or comments.)

Some potential (but not exclusive) prompts:

* Do you strongly agree with one side or the other in the everyone should learn to code debate? Why?
* Does your decision to take AP Computer Science support or refute any of these claims?
* What is the most important thing to learn in AP Computer Science? Java? Writing programs? What?
* How is Kagan’s description of computer science consistent or inconsistent with your understanding of computer science?
* How does this Kagan’s essay support (or doesn’t support) your expectations for this computer science course?
* Do you agree that society in general and even technically sophisticated people are unsure exactly what computer science is? Does this matter?
* Is this class a math class, a business class, a science class, an engineering class, or something else? Why?


Net Neutrality

Vi Hart’s video [Net Neutrality in the US: Now What?][9] is the best explanation of what Net Neutrality is and the history of the issue. In Forbes, Joshua Steimle, wrote a piece about his opposition to Net Neutrality: [Am I The Only Techie Against Net Neutrality?][10].


* Watch Vi Hart’s video, read Steimle’s article, and watch or read at least two other videos or articles linked in the description of the video.
* Post a response to these videos and articles. Your response must:
* Provide a brief overview of each of the four videos/articles (clearly state which other two videos or articles you watched or read).
* Answer multiple prompts (potential, not exclusive, prompts are enumerated below) in detail.
* Cite specifics from each of the four articles to support your response and demonstrate that you carefully read and analyzed each article.
* Connect the articles to your personal experience (past, present, or future).
* Comment in a civil and respectful manner on other’s responses or comments. (You must post before you can see others’ responses or comments.)

Some potential (but not exclusive) prompts:

* Do you support Net Neutrality? Why or why not? Defend your position with evidence.
* Will the FCC ruling on this topic actually affect you in any significant way?
* What, if anything, do you plan to do after analyzing this issue as a result of this assignment?


Diversity in Computer Science

As a group, Computer Science students are one of the least diverse. What needs to be done to increase the participation of women and underrepresented minorities? In [this interview][101], Dr. Maria Klawe, president of of Harvey Mudd College in California, addresses this question on PBS Newshour. In her article, [Want More Women in Tech? Fix Misperceptions of Computer Science][102], Shuchi Grover focuses on the image problem of computer science. The last two sections of Tasneem Raja’s recent article [Is Coding the New Literacy?][103] summarizes the challenges and various efforts underway. Philip Guo writes about his [Silent Technical Privilege][104] as an Asian male.


* Read or watch all four pieces (Klawe, Grover, Raja, Guo) and any others related to the topic that you find interesting.
* Post a response to these articles. Your response must:
* Provide a brief overview of each of the four articles.
* Answer multiple prompts (potential, not exclusive, prompts are enumerated below) in detail.
* Cite specifics from each of the four articles to support your response and demonstrate that you carefully read and analyzed each article.
* Connect the articles to your personal experience (past, present, or future).
* Comment in a civil and respectful manner on other’s responses or comments. (You must post before you can see others’ responses or comments.)

Some potential (but not exclusive) prompts:

* Is it feasible to address the gender and underrepresented minority gap in computer science in high school?
* Do you agree that the lack of diversity is due to a misperception of computer science?
* What can high school students do to address this gender gap? What about teachers (computer science and others)? What about the school as a whole? What about parents? What about society?
* Do you have a personal experience that either encouraged or discouraged you to take this or previous computer science courses?



“Three years after it was discovered, Stuxnet, the first publicly disclosed cyberweapon, continues to baffle military strategists, computer security experts, political decision-makers, and the general public. A comfortable narrative has formed around the weapon: how it attacked the Iranian nuclear facility at Natanz, how it was designed to be undiscoverable, how it escaped from Natanz against its creators’ wishes. Major elements of that story are either incorrect or incomplete.”


* Read [this article][201] about Stuxnet and the cyberattack on Iran’s centrifuges. Also browse this [detailed report][202] for more information.
* Post a response to these articles. Your response must:
* Provide a brief overview of the two variants of the virus. Compare and contrast them to each other .
* Answer multiple prompts (potential, not exclusive, prompts are enumerated below) in detail.
* Cite specifics from the article and report to support your response and demonstrate that you carefully read and analyzed the article and report.
* Connect the articles to your personal experience (past, present, or future).
* Comment in a civil and respectful manner on other’s responses or comments. (You must post before you can see others’ responses or comments.)

Some potential (but not exclusive) prompts:

* What security vulnerabilities were exposed?
* Did the attack work as designed?
* What does this attack on Iran’s centrifuges mean for the security of critical technologies within the United States?
* What types of defenses would be effective? What types of defenses are not?


Data, Privacy, and the Future of Ed-Tech


* Read the following excerpt. Choose two or more of the questions presented to explore further, either by following the links or doing additional research.
* Post a response to these articles. Your response must:
* Provide a brief overview of the articles related to the two questions that you chose to explore.
* Cite specifics from each of the articles related to the two questions that you chose to explore to support your response and demonstrate that you carefully read and analyzed each article.
* Connect the articles to your personal experience (past, present, or future). For example:
* How do the issues of data and privacy affect you personally?
* What personal behaviors are influenced by your understanding of data and privacy?
* Will you change your behavior after researching this topic?
* Comment in a civil and respectful manner on other’s responses or comments. (You must post before you can see others’ responses or comments.)

## Data, Privacy, and the Future of Ed-Tech

Facebook CEO Mark Zuckerberg famously [declared privacy “dead” back in 2010][301]. This year, incidentally, he bought the four houses adjacent to his after hearing that a developer had plans to market a neighboring property as being “[next door to Mark Zuckerberg][302].”

Nevertheless, you hear it a lot in technology circles – “privacy is dead” – often uttered by those with a stake in our handing over increasing amounts of personal data without question.

To see privacy as something will inevitably “die,” to view it as a monolithic notion is [quite ahistorical][303]. To do so ignores the varied cultural and social expectations we have about privacy today. It ignores how power relations have always shaped who has rights and access to autonomy, self-determination, solitude. It ignores the ongoing resistance (by [teens][304], for example, by [activists][305], and by [librarians][306]) to surveillance.

Nonetheless, as the adoption of ed-tech continues (and with it, the increasing amount of data created – intentionally or unintentionally, as content or as “[exhaust][307]”), there are incredibly important discussions to be had about data and privacy:

* What role will [predictive modeling][308] and predictive policing have in education? Who will be marked as “deviant”? [Why][309]? Against whom will data [discriminate][310]?
* What role does privacy play – or phrase differently: what role does a respite from surveillance play – in a child’s development?
* How can we foster agency and experimentation in a world of algorithms?
* What assumptions go into our algorithms and models? Who builds them? Are they transparent? (After all, [data is not objective][311].)
* [What can we _really_ learn from big data in education][312]? [Bill Gates says][313] big data will “save American schools.” [Really][314]? Save from what? For whom? Or is all this data hype just [bullshit][315]?
* Who owns education data?
* [What happens to our democracy][316] if we give up our privacy and surrender our data to tech companies and to the federal government? What role will education play in resisting or acquiescing to these institutions’ demands?

_The above is a portion of the article [Top Ed-Tech Trends of 2013: Data vs Privacy][317] by Audrey Waters who blogs at [Hack Education][318]._


Aaron Swartz

From Wikipedia: [Aaron Swartz][401] (November 8, 1986 – January 11, 2013) was an American computer programmer, writer, political organizer and Internet [Hacktivist][402].

Swartz was involved in the development of the [web feed][403] format [RSS][404],[[3]][405] the organization [Creative Commons][406],[[4]][407] the website framework[[5]][408] and the social news site, [Reddit][409], in which he became a partner after its merger with his company, Infogami.[[i]][410]

Swartz’s work also focused on sociology, civic awareness and activism.[[6]][411][[7]][412] He helped launch the [Progressive Change Campaign Committee][413] in 2009 to learn more about effective online activism. In 2010 he became a research fellow at [Harvard University][414]’s Safra Research Lab on Institutional Corruption, directed by [Lawrence Lessig][415].[[8]][416][[9]][417] He founded the online group [Demand Progress][418], known for its campaign against the [Stop Online Piracy Act][419].

On January 6, 2011, Swartz was arrested by [MIT police][420] on state breaking-and-entering charges, after systematically downloading [academic journal][421] articles from [JSTOR][422].[[10]][423][[11]][424]Federal prosecutors later charged him with two counts of [wire fraud][425] and 11 violations of the [Computer Fraud and Abuse Act][426],[[12]][427] carrying a cumulative maximum penalty of $1 million in fines, 35 years in prison, [asset forfeiture][428], [restitution][429] and [supervised release][430].[[13]][431]

Swartz declined a [plea bargain][432] under which he would serve six months in federal prison. Two days after the prosecution rejected a counter-offer by Swartz, he was found dead in his [Brooklyn][433], [New York][434] apartment, where he had hanged himself.[[14]][435][[15]][436]

In June 2013, Swartz was posthumously inducted into the [Internet Hall of Fame][437].[[16]][438][[17]][439]

Boston Magazine published an article titled, “[Losing Aaron, Bob Swartz on MIT’s Role in His Son’s Death][440]”.

In January 2013, [Aaron’s Law][441] was authored in Congress. The Electronic Frontier Foundation has been [leading efforts][442] to reform CFAA and pass Aaron’s Law and similar initiatives.

Lawrence Lessig used the occasion of his Chair Lecture at Harvard to speak about Aaron Swartz: “[Aaron’s Laws: Law and Justice in a Digital Age][443]”.


* Read the articles from [Boston Magazine][440], [WIRED][441], and [EFF][442]. (Watch Lessig’s

[443], if interested; it is excellent.)
* Post a response to these articles. Your response must:
* Provide a brief overview of Aaron Swartz, CFAA, and Aaron’s Law.
* Answer multiple prompts (potential, not exclusive, prompts are enumerated below) in detail.
* Cite specifics from each of the three articles to support your response and demonstrate that you carefully read and analyzed each article.
* Connect the articles to your personal experience (past, present, or future).
* Comment in a civil and respectful manner on other’s responses or comments. (You must post before you can see others’ responses or comments.)

Some potential (but not exclusive) prompts:

* Is it accurate to compare Aaron’s actions to that of civil disobedience?
* Did Aaron’s downloading of JSTOR archive cause harm?
* What role and responsibility does MIT have in this case?
* What reforms, if any, are needed? Does Aaron’s Law go far enough?
* What can you do? What should you do?

[402]: “Hacktivism”
[403]: “Web feed”
[404]: “RSS”
[406]: “Creative Commons”
[409]: “Reddit”
[413]: “Progressive Change Campaign Committee”
[414]: “Harvard University”
[415]: “Lawrence Lessig”
[418]: “Demand Progress”
[419]: “Stop Online Piracy Act”
[420]: “Massachusetts Institute of Technology Police Department”
[421]: “Academic journal”
[422]: “JSTOR”
[425]: “Mail and wire fraud”
[426]: “Computer Fraud and Abuse Act”
[428]: “Asset forfeiture”
[429]: “Restitution”
[430]: “United States federal probation and supervised release”
[432]: “Plea bargain”
[433]: “Brooklyn”
[434]: “New York”
[437]: “Internet Hall of Fame”

AP Computer Science End-of-Year Survey Results

I recently reviewed the end-of-year feedback from my AP Computer Science students. This year we moved to a new textbook. Last summer, I focused on selecting new practice activities from the textbook and improving the summative labs that students complete at the end of each unit. I made the decision to invest most of my time in the development of the summative labs rather than the practice activities. My focus (and lack of focus) is evident in the feedback. In the following charts, a “1” represents strongly agree and a “5” represents strongly disagree.

I see practice activities as the aspect of the class most in need of improvement. While the feedback was largely positive, it was as positive as I would like. I believe the feedback on peer programming was a result of how I introduced, structured, and facilitated peer programming rather than a poor reflection on the methodology itself.

Screen Shot 2014 06 22 at 1 33 52 PM

The feedback on summative labs was much more positive, which is good because I put forth a lot of effort to improve those! I plan to retire the ActorBox lab which was an early introduction to GridWorld. I may do a turtle lab instead. I also need to re-evaluate the Word Search lab. The lack of popularity may be somewhat due to timing rather than the lab itself. I may look for a different lab for arrays and ArrayList. I would love to create something with more social relevance. The DrawingEditor was fairly well liked but was too much of a challenge for too many students. I may consider replacing it with the new AP Elevens lab.

Screen Shot 2014 06 22 at 1 34 23 PM

Screen Shot 2014 06 22 at 1 34 38 PM

The chart is a shout out to Canvas’s Speed Grader. I sung its praises in [an earlier post](

Screen Shot 2014 06 22 at 1 34 32 PM

I was surprised how many of my students were planning to major or minor in a computer-related field. I would expect about three-quarters of them would major in a STEM-related field, not solely computing related.

Screen Shot 2014 06 22 at 1 34 45 PM

I had a very simple standards-based assessment and reporting system for this class. Summative assessments were scored on a 1-5 scale. Each unit that consisted of one exam and one lab. I almost never had a conversation with students about scores or grades. Lots of conversations about computer science instead.

Screen Shot 2014 06 22 at 1 34 55 PM

My focus for this summer is to improve the practice activities by selecting fewer and selecting those that students will find more relevant. In addition, with the practice activities, I want to achieve a balance between instructor-led examples, individual development, and peer programming. I specifically want to improve my facilitation of peer programming. I also plan on developing my own slide decks instead of using those that are included with the textbook. Finally, we will be using GitHub next year and I want to move the summative labs into GitHub to provide necessary scaffolding for the students. Looking forward to next year!

Computer Science Capstones

During the spring semester, before we started reviewing for the AP Computer Science exam, we spent a week working on capstone projects. These capstone projects were inspired by and modeled after the [capstone projects]( I did earlier with my AP Physics B class. I introduced the capstone project as follows:

Our final project for the year is a capstone. Capstones must do the following:

* Show synthesis of multiple concepts in unfamiliar situations. A capstone requires you to use more than one idea to solve a problem, and it isn’t just a rehashing of work you’ve already done.
* Show initiative. A capstone isn’t just your teacher telling you what to do. It is you unleashing your curiosity to discover what you want to do.
* Are open ended. Capstones don’t have ends. You should always feel like you could dig deeper and discover more if you had more time.
* Are public. Capstones are not private projects you share only with your teacher. They are public endeavors that you share with the class and the world at large. Successful capstones require you to collaborate with classmates.
* Involve significant revision. No one gets it right the first time, no first draft is perfect, and you must plan accordingly. A capstone will not be eligible for grading by me until it has undergone at least one revision.

Ideas that may generate a spark:

* GUI applications
* numerical methods
* simulations
* games
* data analysis
* databases
* multi-threaded programing
* network programming
* AI algorithms
* audio/video processing
* 3D graphics

I used the following scoring rubric:

Download (PDF, 37KB)

Students pursued a wide variety of capstones. The links display their portfolio where they have described their capstones in more detail and have a link to download the source. Here are some:

* [JavaChess]( by Nathan L: a GridWorld-based, two-person chess game
* [Super Tic-Tac-Toe]( by Matthew W: a Java implementation of Super Tic-Tac-Toe
* [Doge Defender]( by Max B: a sophisticated arcade-style game with multiple levels and sound
* [Cat Fountain]( by Jessica H: an app that displays cats spewing from a fountain; strange and surpringly addicting to watch

I only planned for a week to complete these capstones, which really wasn’t enough. As a result, students didn’t have the opportunity for significant revision. This coming year, I’m going to plan for two weeks. The other change I’ll make is that I’m going to have students present their capstone to their peers in class. My class this past year was definitely lacking in terms of opportunities for students to present to others. Despite these shortcomings, students were very engaged and created some fantastic software.

Media Computation Collages

One of my, and my students’, favorite projects this past year was a series of activities based on [Mark Guzdial and Barabara Ericson’s]( book [Introduction to Computing & Programming with Java: A Multimedia Approach]( I read their book over winter break and decided that it would be a great way to get back into the swing of things after break (no pun intended). Before winter break, we made it through arrays and the media computation project was a great review when we came back in January. While the book covers pictures, sound, and movies, we just focused on pictures.

We worked through several activities, focusing on filters and transformations. The students enjoyed seeing that they could write programs that performed some of the same features as Photoshop. The unit concluded with a collage project in which students combined several of their filters and transformations into a final and unique image.

I was extremely pleased to see that [one of the new AP Computer Science labs](, Picture Lab, was developed by Barbara Ericson and is based on her book. I think this new lab will bring an authentic and engaging series of activities to a wider audience.

Here are some of the collages that my students created last year.


Li raymond late 2784455 25010819 collage

Lindquist nathan 2773682 25010244 collage

Truong brian late 1367561 25010797 nairb s nyan cat thingy

Wang larry 2782126 25010473 NoctisFinalPicture

Zhou tony late 2762744 25051039 collage3