The Academy for Software Engineering is entering its third year and the computer science department is starting to blog the courses that we are iterating on this year. I am a pilot teacher for the new CS Principles. CSP will be a live advanced placement course in the 2016-2017 school year. I'll be blogging this year to document the development of the course in our second pilot year.
Last year I drew heavily from the BJC curriculum from UC Berkeley and used the Snap! programming environment. Snap! extends the Scratch language with things like script variables and higher order functions. At the end of last year EarSketch was just releasing its cloud IDE for Python music programming, so we tried that too. Students really responded to EarSketch; nothing is more immediate than music and even the most disengaged students perked up to hear work from their peers being shared out in class.
While I loved BJC and Snap! I missed teaching the systematic approach to function design presented in the Bootstrap curriculum and How to Design Programs using Racket. I'm told that Snap! is really a Scheme implementation under the hood and that the professors that teach it at Berkeley are Racketeers at heart. So since my students have already had a year of Scratch and Python I'm going to jump right into text languages with Racket and Python and only return to the Snap! environment for demonstrating advanced concepts that I don't expect students to use in their performance tasks.
The CSP Curriculum framework is so extensive (304 individual content standard!) that I built a spreadsheet that I could use to organize the curriculum. Last year I relied on pre-built curricula that are good, but I didn't cover much of the curriculum framework. This year I want a plan that lays out how I could cover the entire curriculum and know that I'm doing it. We'll have to make choices along the way but at least we had a plan.
At AFSE we build pretty extensive curriculum maps. I built my spreadsheet to be able to organize the elements of the College Board's CSP curriculum framework into units and lesson plans. I decided to try using the "Big Ideas" (creativity, abstraction, algorithms, data, programming, internet, and global impact) as the titles of my units and to cycle through them twice in the year.
This year we are identifying mastery skills and content for each unit. Mastery skills are elements of my curriculum that I expect all students to be able to do. In one sense these skills are the minimum that a student can do to pass, but in another they are the most important skills that you need to have gotten the essence of the course, not necessarily the easiest skills to master.
CS Principles students need to be prepared for a analysis based objectively graded exam as well as two major artifact based performance tasks. The first semester focuses and prepares students for the Explore Performance Task, which involves research into the impact of computing on a population of society. The second semester focuses and prepares students for the Create Performance Task, which requires the original ideation and implementation of a computational artifact. The Create Task entails both individual and pair programming and documentation.
The tension between preparing students for a test and preparing for a portfolio evaluation suggests certain pedagogical techniques. We'll present programming topics using conceptual themes but also structure the course to present certain types of programs that students can draw from to create their original products. Running through the seven big ideas twice will allow us to spiral concepts in preparation for the exam, while focusing each semester on the elements that prepare students for the performance tasks.