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 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.

Sunday, October 12, 2014

Unit 0 - Creativity

We began the year with a short introduction to design process and norming feedback.  As freshman students use a simplified design process: plan, build, test, and reflect.   We began the year with the same process.  We are structuring the course by dedicating a unit to each of the 7 big ideas in the CSP curriculum framework.  We will iterate on each of the units twice: once in the first semester once in the second.  Each semester culminates in a performance task.

In our second iteration of the creativity unit in the second semester we are going to expand the design process to include ideation  as we prepare to develop original programs that address an overarching theme.  The learning goal for a design process is problems are solved using an iterative process.  In sophomore CSP we started with a design challenge around what can be made with computers.  We normed giving feedback to student projects from last year.  Feedback should be specific, relevant and actionable.

Monday, September 1, 2014

Overview of SY14-15 AFSE CSP

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.