Tag Archives: compsci

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](https://pedagoguepadawan.net/216/greatest-benefit-of-canvas/).

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!

AP Computer Science Reflections and Plans for Next Year

I’ve been collecting my thoughts on this past year throughout the summer. Since I’m about to start a new school year, now is a good time to review these reflections and share my thoughts and plans for the upcoming year.

Last year was the first time that I taught AP Computer Science. Based on my experience teaching Physics, I appreciated the significant difference between content knowledge and pedagogical content knowledge. I spent the year building my pedagogical content knowledge and trying various types of activities to determine which would be most effective. I expanded my network of computer science teachers throughout the year and attended a couple of great workshops this summer: the [AP Annual Conference](https://pedagoguepadawan.net/260/ap-computer-science-preconference-workshop/) and the [Tapestry Workshop](http://www.cs.virginia.edu/tapestry/).

One aspect of the class that did not work well was the textbook. The textbook was old (it didn’t cover Java 5 features) and didn’t align with my personal teaching preferences (I’m a strong object-oriented proponent and start objects first). We stopped using the textbook after the first couple chapters. My department chair was super supportive and I was able to purchase [Cay Horstmann’s Java Concepts](http://bcs.wiley.com/he-bcs/Books?action=index&bcsId=7875&itemId=111843112X) book for the upcoming year. I spent a lot of time this summer creating units, choosing questions, and selecting programming activities based on the new text, but it will be well worth it.

Students spent most of class time working on programming activities. These activities were small in scope, focused on a specific concept, and not graded. They were formative assessments. I spent most of class time visiting students, asking questions, and providing direction without being too helpful. Perhaps my favorite part of this class was that I had the opportunity almost every day to talk individually with every student and directly observe their work. This upcoming year, I hope to spend even more time on these programming assignments. I hope that with the better textbook, I can minimize lecture and notes and just focus on highlighting key aspects the assigned reading and discussing questions that the students have after having read the chapter.

One part of class that worked out very well, was providing [choice in the programming activities](https://pedagoguepadawan.net/212/differentiation-and-choice-in-programming-activities/). My students were fairly diverse in both interest and background knowledge. Providing them with a variety of programming assignments, all focused on the same concept, but of varying degrees of difficulty and application, allowed each student to challenge themselves and yet be successful. I stumbled upon this by accident when I was unable to decide which of three programming activities would be the best. I decided to offer all three and was surprised at increased level of interest as students chose their favorite. While I’m changing most of the programming assignments this upcoming year, I consciously defined sets of programming assignments to provide students with choice.

Related to these topics of choice and diversity, I quickly realized last year that some students would complete a programming assignment in 10 minutes while others would need an entire class period. Again, by accident or intuition, when I first encountered this diversity, I spontaneously created an extension of the programming activity to challenge student who finished quickly. After that, I made an effort to define extensions to most of the programming activities. I also encouraged students to explore their own extensions. I will offer some of these to this year’s class. Throughout the year, these extensions were generalized into the idea of “add more awesome.” As students finished the base assignment, they would start to “add more awesome” without direction.

While I’m changing most of the programming assignments, many of the summative programming labs will remain the same. The programming labs are submitted for scoring and involve significant effort compared to the programming assignments. We will continue to do the [Game of Life](https://pedagoguepadawan.net/202/the-game-of-life-and-grid-world/) lab, [Media Computation](https://pedagoguepadawan.net/279/media-computation-collages/), [Fractal Trees](https://pedagoguepadawan.net/241/fractal-tree-lab/), and [Capstone projects](https://pedagoguepadawan.net/281/computer-science-capstones/). A few labs will be new. For example, we will try a [Word Search](https://sites.google.com/a/stuycs.org/home/courses/ml1x/zamansky/work/hw-20-duetbd) lab from Stuyvesant High School.

There are a couple of new ideas that I found lacking last year that we will try this year. I want students to have more experience with [Test Driven Development](http://en.wikipedia.org/wiki/Test-driven_development) and unit testing with [JUnit](https://github.com/junit-team/junit/wiki). I also want students to present their work to their peers; specifically, their capstone projects. While there was plenty of interaction among pairs of students last year, I didn’t provide an opportunity for students to present to all their peers.

My final focus for the upcoming year is applying some of what I learned at the Tapestry Workshop to increase the number of female students and under-represented minorities in computer science. Some of these efforts will be outside of class focused on administrators and counselors, but others will be in the classroom. Everything from my choice of programming activities to the decor of the lab can reduce stereotype threats. I hope to see a change in enrollment of the coming years!

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](http://coweb.cc.gatech.edu/mediaComp-teach) book [Introduction to Computing & Programming with Java: A Multimedia Approach](http://www.amazon.com/Introduction-Computing-Programming-Java-Multimedia/dp/0131496980). 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](https://pedagoguepadawan.net/263/ap-annual-conference-a-first-look-at-the-labs-for-ap-computer-science-a/), 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

AP Annual Conference: A First Look at the Labs for AP Computer Science A

**A First Look at the Labs for AP Computer Science A**

*Renee Ciezki*

*I attended this session since the AP Computer Science Case Study, Grid World, will be retied after the 2013-2014 school year. It is being “replaced” by a set of example labs, none of which will be accessed directly but present concepts that will be assessed. The case study is one of my favorite aspects of AP Computer Science A because I find it extremely authentic that students are presented with a large body of well designed and well written code that they have to understand and extend. That said, these new labs look really good and will be a fantastic resource for teachers.*

* real-world context will increase interest
* exam questions will focus on essential concepts
* [Draft lab materials](http://www.tymann.us/apcs_labs/) (*site is currently down*)
* teacher guide, student guide, code
* updated course description (topic outline remains the same) and lab materials available February 2014
* new audit should not be required; maybe just a form in which you promise to have good labs that meet the hands-on time requirement and cover the necessary concepts
* there will also be new practice exams to reflect this change
* use of these labs are not required
* [session slides](http://tinyurl.com/LabsAPAC2013)


* Natural Language Processing (NLP)
* String class
* Conditionals and iteration, arrays optional
* a chatbot
* created by Laurie White, Mercer University, Macon, GA
* 4-8 hours of activities? (presenter did it one 75 minute class period?)
* use it as a first lab to introduce the IDE? (better than Hello World)

**Picture Lab**

* Manipulating digital pictures (Media Computation)
* Two-dimensional arrays
* created by Barbara Ericson, Georgia Tech, Atlanta, GA
* 6.5 – 15 hours
* Stenganography and chroma key in the teacher guide as extensions


* Solitaire game, GUI supplied
* Object-oriented design and programming
* Michael Clancy, University of California at Berkeley
* Judith Hromcik, School for the Talented and Gifted, Dallas, TX
* Robert Glen Martin, School for the Talented and Gifted, Dallas, TX
* 11 (+5 optional) hours

AP Annual Conference: Learning with Exploring Computer Science

**Learning with Exploring Computer Science (ECS): Connections to AP CS**

*I attended this session to get an overview of Exploring Computer Science and AP Computer Science Principles, determine how these courses may apply to my school’s computer science sequence, and learn how these efforts are able to increase enrollment of underrepresented groups.*

**Exploring Computer Science (ECS)**

* [exploringcs.org](http://exploringcs.org/)
* Goal: increase student enrollment, especially with females and underrepresented minorities.
* ECS is a year-long course that includes six curricular units and daily lesson plans. Grew out of the book [Stuck in the Shallow End](http://www.amazon.com/Stuck-Shallow-End-Education-Computing/dp/0262514044). Funded by the NSF.
* ECS computer science concepts
* human-computer interaction
* problem solving
* web design
* introduction to programming
* computing and data analysis
* robotics
* ECS computational practices
* analyze effects of computing
* design creative solutions and artifacts
* apply abstractions and models
* analyze computational work and work of others
* communication computational thought processes
* collaborate with peers on computing activities
* In the Los Angeles School District, ~2000 students are enrolled in ECS per year; 45% are girls; underrepresented minority enrollment mirrors (or exceeds) enrollment in the district.
* ECS is also in Chicago Public Schools as well; data forthcoming.

**AP Computer Science Principles**

* [csprinciples.org](http://csprinciples.org/)

**Jody Paul**

* involved in APCS, AP Computer Science Principles, and ECS
* The context within which we teach Computer Science …
* extreme variation in prior exposure and experience of students
* misconception: computer science equals writing programs
* cognitive shifts are associated with acquiring new thinking skills
* require the passage of time (as well as mentored exercise) to acquire and internalize
* limited set of skills successful in other domains not sufficient
* frustration, confusion, bewilderment
* Success in Computer Science is associated with being adept at:
* discovery learning & inquiry-based learning
* understanding when and how to seek assistance from peers, mentors, and references
* working collaboratively
* applying creative practices
* appreciating larger context within which computation exists
* accepting and working well with the juxtaposition of vagueness and precision
* problems must be precisely specified
* there are many correct ways to solve a problem
* solutions must be creatively developed
* a solution must be precisely and unambiguously specified
* Three programs jointly facilitate success
* leveling influences to accommodate diverse backgrounds
* establishing meaningful context
* correcting misconceptions and inappropriate stereotypes
* initiating mental development processes that facilitate the cognitive shifts necessary for successful study in CS
* preparing students for progressively increasing rigor and challenge in CS study
* acquisition of key skills: inquiry, collaboration, algorithmic thinking, …


* AP CS Principles is intended for all 21st Century Students. It is a computer science course; not a programming course.
* Only 10 states count computer science as a math or science course. Some states have no certification for computer science.
* ECS, AP CS Principles, and AP Computer Science A are not intended to be a course sequence. All three courses are potential entry points into computer science. The panel seemed to concur that the audience for AP Computer Science A is quite different, and smaller, than the audience for the other two courses. There was a bit of confusion about how ECS and AP Computer Science Principles differ. With my limited exposure, they seem very similar in principle. I wouldn’t envision a high school offering both. The fact that one is AP and one is not may lead a high school toward one over the other. In addition, since ECS is an entire course package (e.g., includes daily lesson plans) while AP CS Principles is a curriculum framework, may lead a high school towards one over the other. I don’t see either replacing our current Programming 1/2 courses, but I could see offering one or the other as an additional course targeted at a much wider audience.

AP Computer Science Preconference Workshop

I attended the AP Computer Science workshop led by [Leon Tabak](http://eonsahead.com/) from Cornell College at the AP Annual Conference. The workshop was a good mix of discussion among the participants and sharing of information by Leon. This post captures the litany of resources, pedagogical ideas, and insights from the workshop.


* Java Style Guide. Leon recommended [The Elements of Java Style](http://www.amazon.com/Elements-Java-Style-Reference-Library/dp/0521777682). I currently use Litvin and Litvin’s [The 17 Bits of Style](http://www.skylit.com/javamethods/JM-Appendix-A.pdf) which is Appendix A in their book Java Methods. I also reference Sun’s [Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html). I’ll have to pick up a copy of the Java Style Guide.
* Leon makes great use of [Javadoc](http://www.oracle.com/technetwork/java/javase/documentation/index-jsp-135444.html) in his code. I learned that you can embed any HTML in the Javadoc comments. This includes image tags referencing UML diagrams, links to articles on algorithms, or even LaTex markup through the inclusion of [MathJax](http://www.mathjax.org)!
* Speaking of LaTex, Leon introduced me to the [Listings package](http://en.wikibooks.org/wiki/LaTeX/Source_Code_Listings) which supports Java and very nicely formats both inline code and code snippets in LaTex documents.
* Leon’s site: [Eons Ahead](http://eonsahead.com/)
* [ICE](http://ice.cc.gatech.edu/apexam_final/) at Georgia Tech has AP practice questions
* [Dia](https://wiki.gnome.org/Dia) is a UML diagramming tool that was recommended


* Leon led us through a series of exercises to introduce recursion. His exercises help students to understand the value of recursion rather than just understand the concept. He highlights an analysis of effective and efficient methods implemented recursively and iteratively. He starts with the classic example of implementing a factorial method recursively. While this recursive implementation is easier to understand conceptually, it is no more efficient (actually less efficient) than an iterative solution. The next exercise implements a powers of 2 method recursively and illustrates that the recursive solution is more efficient than an iterative solution by applying the algorithm 2^n = (2^{\frac{n}{2}})^2 . Additional exercises build on these ideas. A recursive method that raises a number to a power can introduce log n vs. n efficiency. Similarly, [Euclid’s Algorithm](https://en.wikipedia.org/wiki/Euclidean_algorithm) for calculating the greatest common divisor is another good example.
* While talking about recursion, one of the participants shared an exercise that she uses with her students. She gives them index cards with a number written on them and references to other cards. A student with a card reads the number and then asks the person with the referenced card to do the same. In the end, the school’s telephone number is spoken. She then has them ask the person with the referenced card for their number before speaking the number on the card. The result is the school’s telephone number backwards. This nicely illustrates the difference between tail and head recursion. Reflecting on this activity, I think I would put letters on the cards instead of numbers such that the series of cards would spell one word with tail recursion and a different word with head recursion. I’m definitely going to try this concrete example of recursion next year.
* In the midsts of a discussion of whether students should type in code by hand in order to discover common syntax mistakes that they will inevitably make and how to debug them, an alternative activity was shared. The activity is to provide students with working sample code and a list of errors to introduce one at a time. Students introduce the error, observe the result, and then better understand the how common mistakes are manifested.
* Another discussion focused on engaging students through pop culture examples. One that sounded intriguing was exploring class hierarchies using Angry Birds.
* Leon shared the importance of having students present and explain their code to their peers. I’m going to try and incorporate this next year. Perhaps in conjunction with their capstone project.


* Students that have a computer science class before AP Computer Science are much more successful. This is not surprising, but I was surprised by how many participants teach AP Computer Science as students’ first course. At my school, we are fortunate that we have Programming 1/2, each one semester, that is required (except for exceptional situations), before enrolling in AP Computer Science. I would be unable to expose students to many of the topics that I think are important (UML, unit testing, Javadoc, graphics) if AP Computer Science was their first course.

Differentiation and Choice in Programming Activities

I just finished teaching my first semester of AP Computer Science. I had no concerns with the content (I have a BS and MS in Computer Engineering, worked as a software engineer for a decade, and can recite Stroustrup’s *Design and Evolution of C++*). But, as I shared with students on the first day of class, I have experience teaching college graduates advanced software engineering techniques, not high school students how to understand programming. What I was lacking (and continue to lack) is pedagogical content knowledge (PCK). I hope to make it to an AP conference next summer or another workshop, but many of them seem to target the very important audience of “I just found out I’m teaching AP Computer Science and I’ve never programmed before.” What I’m looking for is a [Modeling Instruction](http://http://modelinginstruction.org/) workshop for Computer Science. If you have any suggestions for workshops that focus specifically on PCK, please [let me know](http://twitter.com/gcschmit). Despite my lack of PCK, I did stumble upon a couple of effective techniques that I wanted to share.


I have a very diverse collection of students in my AP Computer Science classes. I have students struggling in algebra 2 sitting next to students who are taking multi-variable calculus. I have students who debug race conditions on our FIRST Robotics programming team and students who are still struggling to distinguish types from variables. I welcome this diversity. I don’t think there should be a math prerequisite. Managing this diversity wasn’t nearly as challenging as I expected. In fact, I find it easier to differentiate in my computer science classes than I do in my physics classes. I do this is a couple of ways.

First, we spend most of our time in class programming. If a student isn’t working on their own program, they are most likely helping someone else with their program. Most of the programming activities that we do are learning activities and, therefore, not graded. I welcome and encourage their collaborative efforts. That’s how software is created in the real world. As a result, the students who need a lot of extra assistance get significant one-on-one time with me and students who need a little assistance get help from other students. This works quite well.

Second, I (and sometimes the students) create challenges for each programming lab. There is a certain base level of functionality everyone will achieve, but that will take some students two days and others twenty minutes. While the students that finish in twenty minutes can help others, I want to provide them a challenge that makes them stretch. I’ll illustrate with a couple of examples.

One activity was to write a palindrome tester. The challenge was to only examine letters and ignore punctuation. Students who met the challenge found some really long palindromes to test.

Another assignment was to use arrays to implement a stack of integers and then use that stack to implement a base-ten integer to binary converter. I defined a couple of challenges: implement a peek method and optimize memory usage by shrinking the array when it is way too big. However, the most popular challenge was found by a couple of students; they extended the program to support converting decimals from base-ten to base-two!


When practicing looping structures, I provided three different programming activities. One was mathematical: the program calculated multiples of a specified number and the challenge was to write another program that calculated square roots using Newton’s method. The second was printing based: the program printed a triangle of asterisks and the challenge was to print a diamond instead. The third was graphical: the program printed various sized boxes and the challenge was to make the graphics look like a Mondrian painting.

While providing students these challenges is good and helps keep all of the students challenged and engaged, the choice of how to apply looping structures in different contexts seems even more powerful and important. I’ve been reading a bit about the disproportionate representation of women and minority groups in computer science classes and these types of choices seem to align with some of the suggestions of how to interest everyone in computer science.

I spent the past couple of days skimming [Guzdial and Ericson’s *Introduction to Computing & Programming: A Multimedia Approach*](http://coweb.cc.gatech.edu/mediaComp-teach). Their approach is fantastic; I’m going to start next semester by applying our new knowledge of arrays to image and sound processing.

Looking forward to next year, I plan to interweave various application strands (multimedia, computational modeling, numerical methods, graphics, databases) as we learn the various concepts. I hope to expose students a bit to all these strands while permitting them to spend additional time and effort on those that appeal most to them. I may field test some of these ideas next semester with capstone projects if time permits.

The Game of Life and GridWorld

I love [GridWorld](http://apcentral.collegeboard.com/apc/public/courses/teachers_corner/151155.html), the case study for AP Computer Science. I think it makes the course much more authentic in that students experience developing software in a large (compared to what they are accustomed to) and unfamiliar code base.

One of the first labs that we did was the ActorBox lab published as part of the [A+ Computer Science](http://www.apluscompsci.com) curriculum materials. The students knew almost nothing about GridWorld and nothing about object-oriented programming, but they managed to figure out how to add Actors the the World. I introduced this lab as their first day on the job: “welcome to your new software job, here’s a large code base that you didn’t write and you don’t yet understand, figure out how to …”

Since then we have been learning the basics of Java, and now that we understand conditionals and loops, we can finally write interesting software. For the summative lab, I wanted to revisit GridWorld, emphasize the various phases of software development, and have them write a program that would be memorable. Implementing [Conway’s Game of Life](http://en.wikipedia.org/wiki/Conway’s_Game_of_Life) in GridWorld seemed to be the perfect fit.

I introduced Conway’s Game of Life last week and presented them with some initial requirements. However, I left a lot of the requirements unspecified. Students enumerated their own requirements on Friday and discussed them with me. I wanted them to realize that they needed to specify such requirements as the grid size, how to represent alive and dead cells, when the program finishes, and the time between generations. Students came up with a variety of ways of specifying these requirements with various levels of user specification. Students then started working on their design (flow charts or pseudocode; we haven’t touched on UML yet). This weekend, the were to enumerate their test cases and they will start implementation this week.

Through all of this, I continuously stressed that their requirements and design should be treated as living artifacts and will evolve as they progress through this lab. (I’m a huge proponent of Agile Software Development Methodologies, but that is a subject for another post.)

Since, at this point in the semester, my students are not that familiar with object oriented design, their solutions will be a functional approach and, most likely, inefficient and implemented with brute force. They will get to apply their newly acquired conditional and loop structures. I also think they will better appreciate the upcoming units related to object-oriented design as a result of this experience. In fact, I’m planning on a future lab to be going back and refactoring their Game of Life program.

Here’s the assignment that I posted:

Download (PDF, 46KB)

I think this may be my first computer science, related post… cool.