Sunday, December 30, 2018

Why I teach

I use Flipboard to consolidate news stories that I am interested in.  Of course, education and technology are two of the topics that are checked.  A couple of days ago, a story from the Wall Street Journal showed up in my feed: Teachers Quit Jobs at Highest Rate on Record.  The economy was one of the reasons listed -- teachers are receiving small or no raises and are finding better paying jobs outside of education.  And the story ended by quoting someone who felt that the American society does not value education and students -- and by extension those who work in education teaching students.

I certainly cannot fault a teacher for wanting a bigger pay check, and realize that there are many fields where teaching degrees and skills can be put to good use outside of education.  Working in the field for my fifth year, I am grateful for the skilled, energetic, and joyful teachers that work at my school.  Each of those educators has a unique reason for teaching and staying in the profession.  I have also been saddened to see some excellent educators leave the field.  There truly is a need for good educators!  As a result I want to add my thoughts about why I teach.

There are many well-written articles and blog posts about the reasons that people teach, and I am adding my perspective as someone teaching technology and teaching as a second career.  Over the summer I completed my training for a CTE endorsement and as a final activity, we completed a three sentence reflection activity on why I teach.  This is an expanded version of that reflection.

I teach technology because the future is now

When I was a senior in high school (1982-83) I took the very first BASIC programming class taught at my high school.  I was hooked!  That lead to a college degree in CS and Mathematics and a 26-year career at IBM.  Over that career, I programmed, trained, consulted, and ended in technical sales,
Placing that hook!
and along the way had the opportunity to live and work in Rochester, Minnesota; Guadalajara, Jalisco; and Denver, Colorado.  It was a long, wonderful career and I also had the opportunity to do some volunteer work with at-risk youth.  That volunteer work gave me the interest to move into teaching.

When I transitioned to teaching from IBM, I got my secondary teaching license in mathematics -- thinking that high schools would need multiple math teachers and few if any computer teachers.  I was pleasantly surprised to learn that teaching CS in high school is needed and in many cases with positions left unfilled.  Over the past several years I have gradually moved from math to computer science and have been delighted with the move.  Now I have the distinct privilege to introduce students to computer programming and hopefully hook a few more students to a career that I so enjoyed.

The CS field continues to grow, and so many other fields rely on or have connections to technology and coding.  I find myself excited about available careers in full stack web development, machine learning and artificial intelligence, cyber security, as well as the ongoing needs of operating system, middle ware, and business application development.  There are so many directions my current students can head, and I am envious of the future that they are headed into!

I teach high school because youth are our future

At times I am asked, do I miss IBM -- I worked with great people so of course.  Other times I am asked, wouldn't I rather teach at a community college or university -- there are definite perks to that.  However, teaching at the high school level is something that I am enjoying immensely.

In the Exploring Computer Science class, most students are placed in the class as a freshman or sophomore elective.  The students are very honest about whether or not they "like computers" and if they think that computer science is "too hard".  I do my best to show these students that technology in general and coding in particular can be enjoyable and something that is very doable for them.  Others feel that there is very little for them to learn in a CS class since they are already experts using their phones, getting around firewalls, and persisting with whatever the latest game is.

I walk the line between providing enough scaffolding so students thinking CS is too hard can feel comfortable finding some of those little used keys like (), {}. [ ], < >, &&, ||, etc., and keeping my advanced students challenged and extended enough to keep going and learning new things.  But at the end of the day, these students are going to be the ones designing websites, writing software, and running systems that keep society going when I am out of the working world and enjoying retirement.  I want this world to be running smoothly with all of the technological wonders continuing to flow in the future run by these students.

I teach with joy because attitudes are contagious

Honestly, this last reason for teaching is more aspirational than a statement that I can support on a daily basis.  I fully recognize that attitudes are contagious.  When I look at my coworkers I see the ones that are filled with joy every day.  Their energy is something that I want to be around and also something that I project -- on my best days.  Admittedly, I too often get frustrated with lessons that have gone wrong, students that aren't as interested as I hoped, and either the students or the teacher just having a bad day.

On the positive side, I feel that as a second career teacher, I can look at education with a wider perspective.  I know first hand the opportunities and the challenges that will face my students going into the CS field.  I also don't have the worries or the ambitions that teachers beginning a career in education have.  As the article I linked at the beginning of this post stated, there are many reasons that teachers leave the profession, and happily none of those apply to me.  I am happy with this field and the students I meet every day.  And that's a good thing, indeed.

* Images from pexels.com

Sunday, December 16, 2018

Web Design Reflections and Subgoal Labeling (Arrays)

We just finished the last week of classes at The Pinnacle and are headed towards finals week for semester 1.  My Exporting Computer Science students have turned in their final projects for the web design unit.  And my AP Computer Science students took their last set of notes on Arrays using subgoal labeling.  If you are mainly interest in subgoal labeling, skip to the end.

Web Design Reflections


This is the second year of teaching a 9-week unit on web design to the Exploring Computer Science class.  I was so impressed with the 3-4 page websites that my students produced.  Some students have a good eye for color and building a website with complementary colors that look good on a page.  They mastered building a set of web pages with a cascading style sheet.  The pages used a common grid layout and navigation bar to move between pages.  All of the students selected topics for their sites that were of interest to them.  Topics ranged from music to anime to sports, and as with all student projects they were of varying quality.

Here are some examples of their work:








Last year I was primarily focused on getting through the material (and honestly, making sure I fully understood how to use HTML and CSS).  This year I added additional opportunities to practice a skill before having students create a project.  As I look back at the end of the unit I am seeing places that need improving for next year.

Keyboarding

Many of the students taking this class do not have a great deal of keyboarding experience, and even those that do are not familiar with the keys needed for HTML and CSS.  So the first area that I want to add and improve on for next year is to have a section on finding some of those keys that are not often used in normal typing but come up frequently in HTML and CSS:

  • angle brackets for all of the HTML tags < >
  • slashes  used in ending tags / (and distinguishing them from back slash)
  • braces used in CSS files { }
  • semicolons used in CSS files for the end of each attribute ;
I was talking with one of our ESL teachers and she gave a great suggestion -- why not make a simple Google assignment where students type in the tags along with all of the special characters 3-5 times so they get accustomed to finding these little used keys in a separate activity.  Thanks Taniuska Worsham (if you are interested in learning about what she does teaching English as a second language as a second gig with VIP Kids check out this link and use referral code TANUI0001)!

Colors

I gave students a Do Now activity to look at the w3schools.com which has a great section on colors, color schemes and how to use the RGB values in a website.  Most of the students recorded a color scheme in their journals, but this Do Now was early in the unit and at that time they didn't have a good idea on how all of the different colors would be used in a website.  My thought is that students do need to have a lesson dedicated to selecting colors and that it should be near the end of the unit.  I think it will be a nice light lesson to put in between setting up a grid layout and before setting up a navigation bar.

Citations

Although we discussed citations in class, I can see from the final products that most of the students did not use royalty free pictures and did not provide citations to where they got their material from.  Similar to colors I have a note that I need to make this a full lesson as well.  Again, I think this will be a lighter lesson that can be inserted between some of the heavier HTML heavy lessons.

Grid Layouts


The section that caused the greatest amount of difficulty for students was setting up a grid layout.  For practice I had students add the text of a grid section to the HTML document and then practice adding a new section to the CSS file, changing the layout, and then adding in the text for the section to an HTML document.  The completion rate on this assignment was not 100% and it did show in some of the final products.  This lesson needs to be improved and I have added a note that I need to have a second set of practice exercises for this lesson.

Subgoal labeling (Arrays)

First, thank you to Alfred Thompson for giving me a plug in his very popular blog!  I was wondering why the readership of this little blog suddenly spiked.

My learning about subgoal labeling continues.  In the set of notes for Arrays, I continued to use the major labels at the top of the notes and then provide the subgoals in each section.  For this set of notes I repeated the subgoals for the second section and had students complete this section after following the steps with me the first time.

The students gave positive feedback that they liked the idea of having a practice on your own section before they were set loose on the practice on the labs.  The full set of completed notes are at this link.  As usual I give my students the file with most of the code removed and we write it together.

I continue to fine tune this, but feel that I have a pretty good format now.  Thanks again to the original CS ED Research conducted by Margulieux, Guzdial and Catrambone on Subgoal Labeling and Worked Examples.

Sunday, December 9, 2018

Subgoal Labeling (Part 3) and CS Ed Week

It was another busy week at The Pinnacle as we wind down the first semester.  Congrats to our Timberwolves cheerleaders who won the Colorado State 3A Cheer Championship!  The TSA (Technology Student Association) students learned about careers in Security from Aaron Goldstein of Tanium.  Then they competed in the second round of Cyber Patriots.

Subgoal Labeling

First, thanks much to the valuable input from Lauren Margulieux and Mark Guzdial, I am learning more and more about subgoal labeling as a means of teaching CS concepts.  Briefly, the things that I have learned:
  • subgoals are different than the high level goals of a lesson
  • subgoals should be very granular - associated with one or only a few lines of code
  • subgoals should be short and memorable
  • subgoals should be repeated
I am tackling the first two points in my next lesson on using the Scanner class to read files.

High level labels and subgoal labels

The first thing I have learned is that what I was thinking of as subgoal labels are more appropriately the high level goals or CS Concepts.  Subgoal labels should be thought of as the individual steps or lines of code to implement a CS Concept.  Subgoal labels can often be attached to a single line of code.  

This week my students were introduced to using the Scanner class to read files.  I continue to teach a lesson using a starter file with comments and as we discuss concepts we write the code together.  Here are the high level goals for the lesson:
/**
  * Using the Scanner class to read and parse Files
  *
  * In the past we used the Scanner class to read and parse input from the keyboard and Strings.
  * Now we will use the Scanner class to read and parse input from a File.
  *
  * 1. Review reading input from a String with a Scanner
  * 2. Read a File with a header
  * 3. Read a File without a header
  * 4. Read a File with lines of text to be parsed
  *
 **/

Subgoal labels -- the finer points

The lesson had three main goals.  Introducing students to
1) Read a file with a header such as the number of lines of data contained in the file. 
2) Read a file without a header record, meaning the code should check if there is more data, before reading a record. 
3) Finally reading a file that has multiple lines and each of the lines should be processed using a Scanner with a String as noted in the previous lesson.

Each of the goals contains multiple subgoals and these subgoals are typically one or only a few lines of code.   As an example the goal of reading a file with a header record begins with a subgoal of creating a File object to represent the name and location of the file.  Because my students split between using Notepad++ and compiling their code at the command prompt and using the Eclipse IDE some of the notes reference both of these.

// 2. Read a File with a header record

// 2a. Create a File object represent the name and location of the file
//     You do not need to specify the directory if the file is in the
//     same location as the Java class if you are using Notepad++
//     or current working directory if you are using Eclipse.
File fileName = new File("for.txt");

// 2b. Create a Scanner with the File object
Scanner file = new Scanner(fileName);

// 2c. Read the header record
int numLines = file.nextInt();


// 2d. Create a for loop from 1 up to the record header
int total = 0;
for (int i = 1; i <= numLines; i++)
{
// 2e. Read the other records in the for loop using one of the next___() methods
number = file.nextInt();

// 2f. Perform any processing needed
total = total + number;
}
System.out.println(total);

Things that still need to be improved

Some other things that were pointed out that I still need to work on.  First, is that the subgoals should be short and memorable.  I think this needs to be improved.  By nature I use many words to describe something and realize that to be memorable the subgoal should be brief.

Next I need to provide an additional example or two that uses the same subgoal labels so students can see multiple examples.  This sounds like a summer project to me!

For the complete set of code for this lesson click here.

CS Ed Week


CS Education Week came too quickly, and I didn't have time to get much done.  For me the first week of December is inconvenient.  Most of my classes are finishing off one last unit before preparing for semester exams, and taking some time out to do an extra task doesn't fit in well.  I would much prefer doing something in February for our eighth grade students as they are about to start signing up for their first high school classes.  And I think I may ask our Middle School if we can come back for day at that time.

Using Unity to add tiles to construct
a game.

Let's Play!


As a result, the Pinnacle had a small showing for CS Ed Week.  The students in Game Design were finishing off their 2D Platformer games using the Unity 2D Game Kit, so I had the students show off the Unity Game Engine to a group of our sixth grade students.  Then the students got to play those games.  It was a fairly small effort that didn't impact many students, but we did leave the sixth grade class with some ooh's and ahh's and a couple of students asked what class they should sign up for in high school if they wanted to design games, so I called it a success.

Sunday, December 2, 2018

Subgoal Labeling - Revisited

Assorted Clothing Tags
Labeling Christmas gifts and steps for using the Scanner class.

The first week back after fall break is always a scary thing.  How many students have used the one week off to purge their mind of almost everything they have learned?  I decided to start the first day back with a review day for most of my classes and was very happy I did.  That refresher is helpful for everyone!

As I start to buy Christmas presents and attach the name cards, I am reminded of how important labels are to sort out Christmas gifts and also to label steps in learning a new CS concept.  So I am returning to what I am doing with subgoal labeling in my AP CSA class.  At its most basic the way I implement subgoal labeling is by creating a numerical list of the steps to teach or implement a new concept in Java.  It seems very simple, but it makes for a good way to go through a lesson.

Subgoal Labeling


I blogged about subgoal labeling and worked examples a few months ago.  The concept seemed very basic but it was not something I was doing in my course.  I dabbled with it a couple of times, but now have started using it consistently for my notes.

The way I have students "take notes" for my AP CSA class is by coding together.  I provide students with a skeleton file with comments that describe what we will be doing.  To implement subgoal labeling, the notes are now numbered.  To demonstrate how I subgoal label, let me give you the three steps that I follow for my notes with subgoal labeling.

1. The notes begin with two statements:  "In the past we...." and "Now we will...".  These statements tie the concept that we are learning to things that the students have already learned.

2. Then the notes have the list of steps that we will follow for the day.  The notes begin with a step or two that are review and then move into the new concept.  As an example here is the block comment at the beginning of the notes from last week's lesson on using the Scanner class with Strings.

/**
  * Using the Scanner class to read and parse Strings
  *
  * In the past we used the Scanner class to read and parse input from the keyboard.
  * Now we will use the Scanner class to read and parse input from a String.
  *
  * 1. Review reading input from the keyboard with a Scanner
  * 2. Review reading a line of input from the keyboard with a Scanner
  * 3. Create a Scanner instance with a String
  * 4. Parse integers using the Scanner class
  * 5. Use a delimiter other than space to separate tokens
  *
 **/

3. What follows in the notes is an expanded version of each of the steps along with code.  I typically provide all of the code for the review steps and leave blanks for the steps that are new for the lesson.  In the example above steps 1 and 2 were review and the code was provided.  Steps 3-5 were new material and the comments were in place but the code was not and we wrote the code together.

4. As a final step I typically go back to the beginning and review the steps.  The comments range from "Yes, we're done!" to "Oh, that's it?".  This method seems to me to be one of the basics of presentation -- tell them what you are going to say; say it; tell them what you said.

I will be taking a survey at the end of the semester, but so far, I feel that this is a good way to teach concepts and it provides students with a set of notes to go back to.  They can quickly review the top set of steps and look at the details if needed.

I would welcome input on whether or not I am getting this correct as far as the intentions for subgoal labeling and worked examples.

Completed Example


At the end of the lecture, here is the code that students will have in place.  If there is a day when I can't be there I can provide the worked example of notes.

Here is the completed set of notes for using the Scanner class with Strings:

import java.util.Scanner;

/**
  * Using the Scanner class to read and parse Strings
  *
  * In the past we used the Scanner class to read and parse input from the keyboard.
  * Now we will use the Scanner class to read and parse input from a String.
  *
  * 1. Review reading input from the keyboard with a Scanner
  * 2. Review reading a line of input from the keyboard with a Scanner
  * 3. Create a Scanner instance with a String
  * 4. Parse strings using the Scanner class
  * 5. Use a delimiter other than space to separate tokens
  *
 **/
public class Unit12Notes
{
public static void main(String args[])
{
// 1. Create an instance of a Scanner and read input from the keyboard
Scanner keyboard = new Scanner(System.in);
System.out.print("Enter an integer: ");
int number = keyboard.nextInt();
System.out.print("Enter a word: ");
String word = keyboard.next();
System.out.println("The number is " + number + " and the word is " + word);

// 2. You can also read a line of input from the keyboard up to and including the newline
keyboard = new Scanner(System.in);
System.out.print("Enter a line of input: ");
String line = keyboard.nextLine();
System.out.println(line);
System.out.println("word");

// 3. A Scanner can also be created with a String.
//    Instead of reading input from the keyboard, the program 
//    reads the input from the String
Scanner chop = new Scanner("12 5678");
number = chop.nextInt();
System.out.println(number);
number = chop.nextInt();
System.out.println(number);

// But Java throws an exceptions if there is no input
// uncomment the following line of code and run the program to see the exception
//
// number = chop.nextInt();

// 4. With the keyboard the input was limitless, 
//    but udinh a String means there is a limit to the input.
//    This means we need to check if there is more input using the hasNext() methods
//
//    This is a good way to "chop" up or parse input,
//    we can loop by first checking if there is more input
//    as long as there is more input, keep reading in the next integer.
chop = new Scanner("12 13 14");
while (chop.hasNextInt())
{
number = chop.nextInt();
System.out.println(number);
}

// 5. A space is what separates the numbers above
//    We can use a separator or delimiter other than space using the method useDelimiter()
//
//    We can use this to read in integers, doubles, and even Strings within a String
chop = new Scanner("Washington,Adams,Jefferson,Madison,Monroe");
chop.useDelimiter(",");
while (chop.hasNext())
{
word = chop.next();
System.out.println(word);
}
}
}

Sunday, November 25, 2018

Teaching the teacher - Humble Bundle, Meetup

One of the wonderful things about teaching has to be the periodic breaks.  Pinnacle Charter School is coming to the end of a full week of Fall Break (what I would have called Thanksgiving Break when I went to school).  It was a week to rest, catch up with friends, eat too much turkey, and even to start learning a bit about some new technology -- a little do-it-yourself professional development.

Next year I will be expanding on the nine weeks of Web Design in the Exploring Computer Science class to a full semester of Web Design  class including JavaScript.  Since I have not used JavaScript before it means that I get to learn something new.  My goal is to get a decent understanding of the language, find a set of tools that my students can use, and find places where I and my students can do more.  I am picking up this new technology by going through a book I picked up on Humble Bundle earlier this year; and I am getting hands on experience by learning from others at a JavaScript Meetup which was a new experience.

Humble Bundle

I learned about Humble Bundle last year listening to a podcast, Programming Throwdown (https://www.programmingthrowdown.com/).  It's a monthly (sometimes more sometimes less) podcast that covers a wide range of programming languages, tools, and personalities.  One of the podcasters mentioned getting the bundle each month.

Humble Bundle (https://www.humblebundle.com/) is a website that offers games, books, tools, etc.  They come out with a group of related materials and bundle them together for incredibly low prices -- as low as $1 USD for the first bundle.  They offer additive bundles on the topic for increasing (but still very low) prices.  Earlier this year I purchased a group of books from the Head First series.  I had a paper copy of Head First Java and bought the full bundle of O'Reilly Media books which included one on JavaScript.

I started reading the Head First JavaScript book at the beginning of break and decided that this was going to be a good reference and way for me to learn about the important parts of the language and try some simple projects.  But it didn't answer my question of tools and other ways to get experience, so I wanted to find another way to do this which led me to a Meetup.

Meetup

Grab some coffee and your laptop -- JavaScript Meetup
I don't recall where I first learned about Meetups but had looked at computer science Meetups in the Denver area.  I found one on Python which looked interesting and also one on JavaScript which was exactly what I was looking for.  It advertised itself as "Bootcampers Collective presents our new weekly JavaScript meetup in Denver. We'll be meeting weekly on Tuesdays to work on various projects, kata/whiteboarding, code challenges, and more."  I thought that a bootcamp was just what I needed.  However, to me meetups felt like a millenial kind of thing and going to a strange part of the city to meet with people I didn't know was not exactly in my comfort zone.  Nevertheless, I went and was pleasantly surprised.

The people at the meetup ranged from current IT professionals that wanted to expand their knowledge and learn JavaScript to beginners currently in other fields that were looking to move into IT as a career change.  After introductions, we sat down to work on a problem together.  Someone chose FizzBuzz which was great for me.  It was something I had done as an assignment for my AP CSA students during the lesson on loops, so I felt comfortable with how to solve the problem.  That left learning how to code it in JavaScript.  As an added bonus, we needed to put the results in a array.  I was able to contribute which felt good and learn something new at the same time -- Hey!  I think there might be something good for my students in that statement.

While working the problem I asked alot of questions about favorite tools to code JavaScript -- Visual Studio Code (https://code.visualstudio.com/); a good place for JavaScript reference material -- Mozilla's Developer Network for Java Script (https://developer.mozilla.org/en-US/docs/Web/JavaScript); and a good learn on my own website -- Free Code Camp (https://learn.freecodecamp.org).  Now I feel armed to learn some more on my own. 

Well, that's my excusion into do-it-yourself Professional Development!

Image from pexels.com

Sunday, November 18, 2018

Reflecting

It is the beginning of Fall Break for Pinnacle Charter School.  In the USA we are approaching Thanksgiving Day, and some schools give the whole week off as a fall break.  This week off is a great time to take a step back from the classroom, rest, relax and pause for some reflection before entering the final month of the first semester.
Reflections over Thanksgiving Break

When I was taking classes for my teaching license, I learned about many of the early education researchers.  John Dewey was one of those early thinkers, and among his contributions was the encouragement to engage in reflective thinking.  I tend to put my reflections into three categories:  short-term reflection on things I want to change now, putting last year's reflections into actions, and long-term reflection on my teaching practice.

Short-term Reflection


Most of my short-term reflection centers on the new classes that I am teaching this year.  AP Computer Science A is a new class for me.  The student engagement in the class is not what I hoped it would be, and I think about the changes I want to make at the semester break.  About half of the class is very engaged in the material and actively working hard to learn the concepts and practice them by working on the programming assignments.  However the other half is not as engaged, but complete assignments with the help of others but don't do as well on the tests.  For this class I am divided.  On the one hand I feel that I am being driven by the scope and pacing needed in order to get through all of the AP material.  In order to get more students engaged I consider changing my grading percentages for the second semester to weight more heavily towards tests since the AP test is the culmination of the class, and this would pressure students to put more effort into the class.  On the other hand, I want students to be engaged with the material and think that the pace is preventing that and feel I should slow down and possibly not have time to have a multi-week review before the AP test, but hopefully end up with more students that would be interested enough in computer science to pursue it in college.  I am seeing a discussion on this topic going on in the Facebook group for AP CSA, and others thinking about this same idea seem to fall on the side of taking more time.  And that is the direction I will take my class during the second semester.  I am still reflecting on this topic and have not quite landed on a decision that I am completely comfortable with.

The Game Design class is also new this year, it has had a slow start this year because we did not have the Unity software installed on the machines.  Due to circumstances, we did not get the software installed for the first 12 weeks of school.  Very frustrating, so I stalled by spending about eight weeks teaching the students programming concepts in Python and ending up by creating a text based dungeon crawl game using loops and conditionals.  In the end I think the time was well spent although it was not as smooth as I would like.  For the last month of the semester we will be working in Unity, building our first 2D platformer game and move into the second semester where students will be able to create a 2D roguelike game and then design and develop their own game.  I feel better about this class as I will plan to take it in the direction that I hoped to at the beginning of the year -- we are just getting a late start.  This one is not so much a matter of reflective thinking as it is simply acknowledging a slow start and needing to pick up at the beginning a bit later in the year.

Last Year's Reflections -- This Year's Actions


My end of lesson/unit reflection typically looks like yellow sticky notes that are attached to the unit test on what went well and what needs to change next year.  These either get handled over the summer or during the next school year.  This year I am teaching Exploring Computer Science for the second time, so the number of yellow sticky notes is quite high!  Last year I felt that students did not have enough practice with each of the skills in the web design unit, so this year I have created explicit practice exercises where students practice each skill before applying skills to a larger project.  After 2-3 skills are learned students create a web page of their own design and topic.  I am seeing much better results this year and am happy with the change.  Score one for reflective thinking!

Long Term Reflection


My long term reflection involves looking at the areas where I need to improve in my teaching practice and then looking at the larger view of teaching computer science today and in the future.  As a fifth year teacher the area that I still feel least comfortable is classroom management.  As a student, I was one of those compliant kids that enjoyed learning and when I didn't enjoy it, would still get the work done because that was what I needed to do.  Teaching and working with students who prefer the more social aspects of school, aren't as motivated to do school work, or simply don't see the value in an elective class in computer science is a challenge for me.  I still find myself getting frustrated when students aren't engaged as I would like.  I find that things go best when I acknowledge the students in front of me as individuals with their own unique perspectives, but hold them to the expectations of the class.  Now I just need to do that on a consistent basis! 

I had two great opportunities to reflect on computer science as a whole over the last two weeks.  First, I had my advisory committee for our CTE program over to the school a week ago.  Talking with people in industry about the direction of the program and the industry as a whole is refreshing.  I still have work to do on the input I received and will write about that another time.  The second opportunity was with the Colorado CSTA (Computer Science Teachers Association) meeting this past week.  Talking with other teachers after the session about the directions they are taking their programs is encouraging and exciting.  We are all looking ahead to things like Machine Learning, Maker Spaces, and Cyber Security.  The great thing about this profession is that the reflections look forward as well as backward.  More topics for future blog posts!

Image from pexels.com.

Sunday, November 11, 2018

CS Course Pathway

Another full week at the Pinnacle.  We took a day for our juniors to take a practice SAT test which was eye-opening for many of them to see that they need to remember all of the math and language arts that they learned as freshmen and sophomores.  Several came back exclaiming that they had forgotten much of their geometry -- a good reminder for us all, that all those things we learned long ago may come back.
A thin layer of snow looks pretty, what about
a thin layer of CS courses?

On Friday I met with the Advisory Committee for the software engineering CTE program at the Pinnacle.  Once again I am so grateful for the commitment of these men and women to provide input, guidance, and a willingness to jump in and help.  As a teacher busy with the day-to-day activities of the classroom, it is good to step back and take a longer look at the program.  We spent an hour and a half discussing our five year plan and looking at the courses that are being offered.

Today I woke up to the first snow of the year in the Denver area.  While I walked the dogs, I thought about how the light snow made for slick sidewalks, and it gave me pause to think about the classes I have setup and wonder if too thin a layer of Computer Science classes (trying to do too much) can make for a slippery path for students taking CS in high school.

Pinnacle:  CS Course Pathway

Pinnacle:  Computer Science classes
The pathway of courses will be completely rolled out with the next school year and is shown in the diagram on the left.  It begins with Exploring Computer Science (ECS) which has no prerequisites and is laid out with four units of nine-weeks each:  
  • What is a PC (computer hardware)
  • Web Design (HTML and CSS)
  • Programming (Python)
  • Robotics (Python with libraries)
It is designed to be a survey course that exposes students to many different parts of computer science.  Once completed students can explore areas that are of interest to them.

Students that want to learn more about the hardware and networking aspects of computer science can take a series of Independent Study classes which are offered online through TestOut (www.testout.com/).  These online classes prepare students to take the CompTIA A+, Networking+ and Security+ tests and allow students to get industry recognized certificates.  Because the classes are offered online, I can teach all three courses concurrently and have students checking in through review quizzes and hands-on opportunities that I set up.  This is a great way to offer a three course path in hardware and networking and only use a single class period out of my day.

Students that enjoyed the programming unit can jump to a full year Game Design class that is built around the Unity Game Engine (unity3d.com).  The course is mostly about how to use the Unity tool to build scenes, sprites, etc.  The programming in the course is done with C#, so students are exposed to another language.  This course was added based on student interest and demand.  The prerequisite for the course is ECS.

Students that enjoyed web design and programming can take an every other year course call Web Design / Intro to Programming.  The class is one full semester on Web Design which quickly reviews the HTML and CSS from ECS and then moves into JavaScript and adding a new programming language which can allow the addition of things like games to a web site, but can also be used to added data access and storage.  The second semester is an introduction to programming with the Java programming language.  This is an addition in order to help my students be more successful with the AP CSA course.  It will be a new class next year and I hope to teach students the basics of programming using an environment like Greenfoot and then transition to Java.  The pre-requisite for the course is ECS.

AP Computer Science A is the final stop for students that are interested in programming.  It is a full year course that will be offered every other year, alternating between Web Design / Intro to Programming and AP CSA.  As with most Advanced Placement classes, students can receive college credit based on the score they receive on the test at the end of the year.

Taking A Step Back

One of the great things about being the CS teacher at a small charter school is that pretty much any course that I offer to teach gets accepted.  As a result, I have proposed many new courses that I am interested in teaching and that I think will put students interested in computer science in a good place to discover many different areas in the field.

My biggest fears with the course pathway, that will be complete with the next school year, is that we are trying to do too much and that there won't be enough student interest.  As a small school there is a limited set of electives,  I am trying to offer students a variety of classes that they can take but fear there will be too many options and make it confusing for students.  The other fear and perhaps the larger one is that in a small school, there won't be enough student interest.  With the 42 students that I have enrolled in two sections of Exploring Computer Science, I only see a handful of students that I think may be interested in taking follow-on courses in CS.

I hope to partially remedy the situation by making sure that our middle school students know about the options available in high school and can actively request to be involved in intro CS class so that they will have the ability to take all of the classes that interest them.  That means starting an advertising campaign with our middle school in January.  We will see where this leads, but I am hopeful!

Images are my own.

Sunday, November 4, 2018

CS lesson planning: The blank screen

It was a good week for Computer Science at the Pinnacle.  One of my students attended the Rocky Mountain Celebration of Women in Computing (@rmcwic), and she met some interesting professionals and graduates students in the IT field.  I am grateful to the ACM for putting on a conference like this in the Denver area and taking the initiative to invite high school girls to one evening of the event.  It reminds me of the need to put an increased focus on getting more girls in my upper level classes.  The fractions for my classes this year are not good.  1/2 of the students in Exploring Computer Science are girls (freshman elective that students are placed in); 1/4 of the students in my Game Design class are girls; and only 1/7 of the 14 students in AP Computer Science A are girls.

We also competed in the first round of Cyber Patriots (@CyberPatriot).  Our school still has two teams competing and both teams did better than last year, so we are starting out well!  When I looked at the score board at the end of Friday evening, we were right in the middle of the pack for the 80+ teams that were competing from Colorado.


CS Lesson Planning

I have been teaching CS for four years and am now teaching three computer science classes:  Exploring Computer Science, Game Design, and AP Computer Science A.  I have built these classes and the lessons with them in three ways:  from scratch, starting with a blank screen each week; using a course guide or curriculum structure that provides a skeleton to build on; and using a fully completed curriculum with all lessons, labs, quizzes, and tests included -- easy street.

Grey and Black Laptop Beside White and Teal Coffee CupFrom Scratch:  The blank screen


When I started teaching my first beginning Java programming class four years ago, I looked around for text books with teachers' editions, similar to what I knew in mathematics -- I didn't find any.  Being a new teacher at a small charter school without district backing I didn't know where to go for resources or who to ask.  But I did have a long career in IT to draw on and so I built the class from the ground up pulling from various resources.  I sat down at my laptop each weekend and looked at that blank screen.  Some weekends things came together quickly, others not so much.

Occasionally, I go back and look at what I had put together from a mix of resources and building up the class in an order that made sense to me (https://sites.google.com/site/scholtenjava/).  In the end I was fairly happy with what I put together.  It took me three years before I had a set of lessons that I felt good about and would only make a tweak or two for each unit. 

Spoiler Alert:  Not until I saw a fully developed curriculum from APlus (https://www.apluscompsci.com/) did I see how many short comings my curriculum had.

Course Guide:  The skeleton


The second class I started teaching was Exploring Computer Science (http://www.exploringcs.org/).  What a difference and how much easier!  Before teaching the class I attended a one week training where I was taught by experienced teachers of the curriculum and worked with other new teachers to build out complete a complete lesson from each unit.  At the course, I received a course guide with unit plans and outlines and idea starters for each of the lessons.  Throughout the year we met online and via conference call four other times.

The course guide provided so much material that lesson planning became a matter of reading the material and then deciding how I wanted to teach each section and then building a set of Google Slides to teach the lessons and then designing the activities to support the lesson.  However, the course guide provided lots of materials and ideas to support this.
Selective Focus Photography of Skeleton

Using this curriculum skeleton gave me the structure and a good deal of material and lesson planning was cut in half.  If you can find a course guide with lots of ideas, your life is much easier.

This year I am teaching Game Design and found a similar course guide put out by Unity (https://create.unity3d.com/unity-educator-toolkit-whitepaper).  Course guides although only a skeleton provide the start and make the lesson planning process much easier.

Fully Developed Curriculum:  Easy Street


This year I moved from teaching my Java class to teaching AP Computer Science A.  Thanks to CTE funding, my school was able to spend the money to buy me the APlus curriculum.  This is a fully developed curriculum that provides Powerpoints for each lesson; worksheets to review concepts; 10+ labs for each topic so students can practice coding; quizzes to review the topic; a unit test that covers multiple choice and free response questions similar to what students see on the AP test.

Each unit I can do planning in the way that I learned in my education classes.  I start out by looking at the unit test to see what the final goal is for the students and can do my backwards planning.  I review the lesson and may choose to add or eliminate a few pages.  Then I select the learning activities for my students based on how much practice I think they will need on the topic.  I build up a review using the quizzes and create a practice free response question for the students.

While I realize that this isn't always going to be the case, I definitely know that whenever possible I want to find my way to easy street and use a fully developed curriculum!

Sunday, October 28, 2018

Grants and Funding

It was a good week for Pinnacle High School.  Our football team broke a long losing streak -- Go Timeberwolves! 

1 Us Dollar Bill
The challenge of funding a high school CS program
I am anxiously looking forward to the arrival of some new laptops that were purchased with our CTE Perkins Funding.  And with the help of our grants person, we have put in a request with the state department of education so that I can attend some professional development over the summer.  A good week indeed!  Although this does give me pause to think about the challenges that a high school computer science program has in getting funding.  It is so much more challenging than what I saw in industry.

CTE Funding for CS

Before talking about the Career and Technical Education (CTE) funding, I want to point out the challenges that we have trying to support a Computer Science program at a small school with limited funding.

Last year our school had two teams competing in security competition called Cyber Patriots (https://setanothergoal.blogspot.com/2018/08/cyberpatriot.html), but we had a considerable amount of difficulty competing because we were using 8 year old laptops.  The students competed and did quite well, making it to the National Semifinal round.  But the technology issues definitely held them back from competing at their peak.  There was no good solution at the time, so we made the best of it.

This year I am teaching a Game Design class and had planned to use the Unity engine which requires a 64-bit operating system.  Unfortunately, the computers in my classroom are quite old and our IT department was not able to get a new image pushed out to the PCs.  We spent the first nine weeks doing game design on paper and learning a bit about Python to learn the programming concepts that we will eventually use with Unity.  One of the students got very creative and downloaded a version of Unity that was several years old but did run on a 32-bit version of Windows.  So now we are working with Unity, and completing our second tutorial.  But some things don't seem to work and we get to be creative and problem solve each one that is encountered.

Entering our first full year with a Career and Technical Education (CTE) program in place for Software Engineering also comes with funding which is greatly appreciated.  We are spending part of our funds on a new set of laptops.  The students in our Cyber Patriots competition will soon be competing on nice new laptops that won't slow them down.  The students in the Game Design class will be able to load and run the latest version of Unity.  Life is good!  I highly encourage any CS teacher in the USA to investigate getting a CTE program in place (https://www.acteonline.org/).

Department of Education Grants


With the CTE funding covering some of the physical needs of the program at our school, I am looking forward to areas that I want to expand.  Cyber Security, Data Science, Computer Aided Design, and Web Design and Programming are areas that I want to learn more about but have not worked with during my career.  The Colorado Department of Education offers grants for funding professional development for computer science education (https://www.cde.state.co.us/computerscience).  With the help of our school's grants person (who also manages our assessments and other things), we have applied for a grant so that I can spend a couple weeks this summer getting some education on JavaScript programming, Cyber Security, and Computer Aided Design.  This particular grant needs to be completed in only two days, so this is most likely not something others can apply for, but check out what your state offers.

Now I realize that not every teacher wants to spend two weeks of summer vacation in PD.  But as a computer science teacher and someone who enjoys learning new things, this PD is exciting and something that I am looking forward to.  As a side note, it is also one way to attract and keep computer science teachers -- offering these people ways to keep technical skills up-to-date through professional development.  There is of course the concern that if teachers are educated in the latest CS skills they may leave, but the alternative is that CS teachers are not offered PD and then stick around and teach our students outdated skills.

Grants and Funding -- Stepping Back


While I am delighted about the new laptops and the opportunity for additional PD (if the grant is approved), I also wonder about the need for this.  Having spent 26 years in industry there was no need to look for funding or apply for grants.  When I needed a new laptop, I would let my manager know.  For the most part, I didn't even need to ask for a new system, instead it would be replaced on a regular refresh schedule.  When I needed training on something new, there was funding for me to get education either internally or externally.

I become frustrated that there is a need to search for funding, fill out paper work, hope for the best and then if it is approved the need to report on how the funding was spent and the results from it.  I look forward to the day when secondary education can receive the same type of funding that we see in industry.

I do wonder if there can some day be an expansion of the CTE program that will have our high school students begin working with industry while still in high school and have that funding flow directly from industry to schools.

Image taken from: pexels.com

Sunday, October 21, 2018

Web Design with Exploring Computer Science

Another busy week!  Our school held a fund raiser on Friday night.  Based on the idea and a whole lot of hard work from one of our teachers, and pitching in from the rest of us, we turned our school into a Haunted High School.  It was a big success!  Saturday was our final home game in football.  A tough loss but perfect weather for a game.

One student's work with a scrolling marquee
Next week I will take my Exploring Computer Science class from working with web pages in .HTML to using Cascading Style Sheets (CSS).  However, they completed their first project -- a single web page using a basic set of HTML tags, inline style, and sizing images using GIMP 2.  I was so impressed with the results of what the students have put together.  I awarded extra credit for students who researched an included a tag that we did not cover in class, and I had students use marquees for scrolling text and others that included background music that played.

Teaching Web Design

I have broken down the web design class in the order suggested by the Exploring Computer Science (http://www.exploringcs.org/) curriculum:
  • introducing a basic set of HTML tags (paragraphs, headings, breaks, lines, bold, italics)
  • working with images (using GIMP 2 to resize images and using the <img> tag)
  • adding inline style and an internal style sheet
  • adding tables, ordered lists, and unordered lists
  • cascading style sheets
  • setting up grid layouts
  • creating a navigation bar
A student's web page that added image borders.
Unfortunately, the background image was not available.
The format I teach from follows a basic approach of "we do-guided practice-you do".   First, I provide students with an HTML file with the tags in place that we will be using.  We modify together the HTML file and create a second example of the tags together.  They are typing along with me.  I am using LAN School to project my screen image as a window on student screens, so they can set up with a side-by-side pair of windows and type in the HTML along with me.

Next, students have an assignment which is 4-5 exercises where they add to an existing HTML file with an example in place, add to an HTML file with the setup for the new tags, and then finally create an HTML file using their first exercises as a template to create something new.

After completing two or three lessons students create a larger project on their own which is something of their own choosing.  After the first three lessons, the students have created some very impressive web pages.

Good Questions and Student Thought


Teaching this unit is fun!  I find that students often ask questions that lead them into the next lesson. 
Another student's web page who worked on changing
jpg images to png.
As some of the students were creating their web pages, they were asking how they could create sections to their web pages, and I let them know that it was coming soon.  Others asked if they would need to duplicate their internal style sheets on each web page they create.  What a perfect introduction to CSS files!

The other impressive thing is seeing students investigate new things for their web pages.  Some students like the idea of an image as a background but then wondered how to make smaller images pop from that background.  They learned about creating a border around an image.

Some students wanted to add some life to their web pages (we won't get to JavaScript with this class), and they found the marquee tag to add that life with scrolling text.

Finally some ambitious students wanted to add background music and learned about embedding WAV files to add that music.  We did have a discussion that some viewers of a web page may not be impressed if music comes blaring out of their speakers, but the investigation, learning and accomplishment was wonderful to see.

Sunday, October 14, 2018

Task Cards -

I woke up to the first snowfall of the year.  It was enough to cover the grass, but the ground temperature was warm enough that the sidewalks and driveways didn't freeze up or accumulate any snow.  Now, that's the best kind of snow of all.  Looks nice without the negative side effects.  Earlier this year I used task cards to reinforce the lesson on creating classes.  My hope is that the use of task cards is similar -- a fun learning activity without the negative side effects of just writing a set of programs.

Task Cards

Task Cards for Java Programming - 1
Example set of task cards - part 1
When I teach students to create classes in Java I typically step through creating a step in the class and then a corresponding step in the runner for the class to test methods.  The order that I typically step through follows:
  1. Create the class and the private instance variables
  2. Create a constructor for the class that has a parameter for each of the instance variables
  3. Create a runner with a main() method; read in values from the use for each of the instance variables; and then create an object of type of the class.
  4. Add access methods (getters/setters) for each of the instance variables
  5. Use the getter methods in the runner to display the current values; read in new values from the user; and then update the instance variables with the setter methods.
  6. Add an additional method or two that does some sort of calculation with the instance variables of the class
  7. Update the runner to use these new methods
  8. Add a toString() method to the class
  9. Use the toString method in the runner to display the current values of the class after it is initially created and again after the instance variables are updated with the setters
  10. Add an equals() method to sensibly check for equality of two instances of the class
  11. Task Cards for Java Programming - 2
    Example set of task cards - part 2
  12. Update the runner to create a second instance of the class and check if the two instances are equal using the equals() method.
It's a long set of steps and students typically find creating classes to be long and tedious.  We typically create one class and runner together and then instead of having students create others on their own, I use task cards to change things up a bit.


Task Cards - Benefits


I like using task cards for this lesson for several reasons.  First, since this activity has so many steps it seemed like a natural to put each of these steps on a task card and students complete a task and then move on to the next task.  Because the students are compiling or compiling and running at almost every step there is lots of feed back for students.

Second, I like the change of pace and the students seem to like the change of pace as well.  I also do this activity with paired programming, so a student works on one task and then switches roles and then watches as the other partner types in the next task.  I let the students self select and this provides for some good differentiation in the practice.

Third, this one was unexpected, but my students turned this into a sort of competition.  The activity becomes one of calling out, "We are on step 5!"  Students actively watch their partners to make sure they are typing things in correctly and compiling the code mentally -- catching each others' mistakes and fixing them without needing to compile.  I have the cards setup at the front of the room and have students come up and take one card at a time.  Eventually, it becomes a race to run up and get the next card.

Task Cards - Things I wonder about


I have two things that I wonder about and think may be concerns down the road.  The first is a concern about the use of task cards themselves.  When there is simply a set of steps, whether they come in a list or a set of cards, I wonder if students are making the connections to be able to think critically and independently and know why they are doing these steps and when some of these steps may not be needed for a particular class.

I also wonder about the speed aspect.  When the students turn this into a race, I become concerned about how deeply they are learning the topic.  Does it stick or is it just a fun activity?  The testing at the end of this unit tells me that they actually are learning it well, so I am hopeful.  I am also hopeful that this snow will be short lived and melt into a return to some nice fall weather!

Sunday, October 7, 2018

The Long View: CTE 5-year Plan and Advisory Committee


Red Leaf Trees Near the Road
While driving down the fall roads of my classes,
it's good to take a step back and see where you are headed
Earlier this fall, I took a day and drove up into the mountains to look at some fall colors.  It was a day well spent and an enjoyable drive down some back roads with beautiful fall colors.  This week, Parent Teacher Conferences were held and are now over and we are in for the five-week stretch before Thanksgiving break.  It's a great time to make some real progress in the classroom.  It's also a good time to take a step back and make sure your classes are heading in the right direction as well as taking a some time to take the long view and look at where your school's program is going.  And that view is my CTE 5-year plan. 

Sunday, September 30, 2018

My Favorite Bug

A beautiful bug!  
I have a couple of butterfly bushes in my backyard, but sadly this year saw only one Monarch Butterfly come through.  There were lots of bees and hornets that enjoyed the flowers, though -- those bugs however are not my favorites!  This is just an aside, and it does give me an excuse to put a nice image into a blog post with lots of boring text.  It also provides a nice introduction to discussing bugs in coding (and teaching).

Sunday, September 23, 2018

Bare Walls Theory -- not so much!

This is my fifth year teaching, and I spent the first two years of my teaching career on a cart as a travelling teacher, so I was very happy about getting my own room two years ago.  At that time, I decided that I did not want to follow a "bare walls" strategy that I saw in many high school classrooms, but I also did not want to go overboard with decorating and make the room a big distraction to the students.  The general rule that I followed was that each of the posters and decorations in the room would be there to emphasize a key concept from the units in the classes I taught and that they should be student generated whenever possible.

Sunday, September 16, 2018

CS Teaching Strategies - Subgoal Labeled Worked Examples

I finished week five of the 2018-19 school year,  ran chains at our Homecoming football game which was a tough loss but is now behind us, and chaperoned the Homecoming dance last night -- I'm tired!  So I put in for a day off next week to rest and regenerate a bit.  The rub, my AP CSA class is a week behind where I hoped we would be, so the students need to make progress on the day I am gone.

CS Teaching Strategies -- I wish there
was only one piece missing!
As a relatively new CS teacher and a brand new AP CSA teacher, I am still learning about and trying new methods and strategies in my classroom.  I pick up ideas on blogs, other CS related websites and attending meetings of our local CSTA (Computer Science Teachers Association) chapter.  During one of my Google explorations I came across the image here.  Too often I feel like instead of one missing puzzle piece I have far too many pieces missing and need to fill in lots of gaps.  However, rather than just approaching this with a hit and miss strategy, I have started reading some research studies on teaching computer science and have come across a whole set of studies done at the University of Georgia Learning Technologies Division (https://scholarworks.gsu.edu/ltd_facpub/).

Sunday, September 9, 2018

Blogging with High School Students

I had my Exploring Computer Science students start out their web design unit by creating a blog.  The idea for this came from a Google training that I attended last year and a session from Chris Moore.  I used it with my ECS students and enjoyed it so much that I am including it again in the web design unit.  For web design we focus on two areas.  First, students will learn the hard skills of HTML and CSS, and this year I am hoping that we will have enough time to get started with a little JavaScript as well.  Second, I have students work on developing soft skills such as branding, audience and voice by working on a blog.

Branding


I begin by having students make a list of 3 things/people/hobbies that interest them most.  Then they take that list of three and select the one thing that they feel they can make a list of ten ideas, sentence starters, or topics.

I cut short the time on coming up with the list so that students only have a few ideas generated.  We pause and talk about branding and how certain companies have a brand name that is associated with a particular product line such as soft drinks, shoes, or cars, while other companies have a brand based on a concept such as low prices or home delivery for a variety of products.  We have a short discussion on how having a unifying theme for their blog and also for their website can help them develop a brand.   Students can make the connection so that their blog can help them become known for the concerts they have attended or the fashion they are interested in, or the books they have read.

After the discussion on branding students complete their list and seem much more interested in generating that list around the theme of their choice.  Students are given the choice of blogging privately so only other students can read it or blogging publicly so that anyone can read it.  Last year only a few students chose to make their blogs public, but at the end of the semester several other students expressed that they wished they had made their blogs public.

Audience


As we blog I require that students read and comment on the blogs from other students in class as well as read and comment on blogs that are on a topic similar to theirs.  We do this to help develop a sense of audience -- being an audience for others and creating an audience for our blogs.

With the statistics functions students see the number of views that their blog has received and where those viewers are located in the world, the operating system of the system their audience views from, and the browser that is used.  However, very quickly students move from wanting views to wanting comments.  This moves to a discussion on the idea that in order to have an audience we need to be an audience; and in order to have comments on our blog it is good if we comment on others' blogs.

On a practical front I show the students how to turn on moderated comments, meaning that they need to approve every comment that shows up for their blog.  We discuss that yes there are people out there who may have positive comments for us that we want to display; others have negative comments that we want to display because they will help improve the blog; and others have negative and demeaning comments that we simply don't want to display.  Moderating those comments shows us who our audience is, but also allows us to control what is displayed and helping us further develop our brand.

Voice


Finally, as we blog, I have students focus on developing their own voice.  On a practical side I have students think if they want their blog to follow a pattern for each blog entry.  From the ideas generated last year and this year common blog topics are reviews or opinions related to a common set of topics:  music genres and groups/performers, basketball shoes I own or want; books I read or want to read; etc.  For each of these I ask students to develop a pattern for each entry that might include basic information, a star rating of some sort, and then a written review.  Or else see if they want their blog to follow various forms for each entry.

To further develop their voice I have students read their blogs aloud.  Listening to a blog entry is very different from simply typing it up and proof reading it.  Finally I have students work with a partner and before each entry is posted, they must have their partner proof read the entry as well as discuss it with their partner.  This helps eliminate mechanical errors such as spelling, capitalization and punctuation as well as helping the student recognize if this blog entry "sounds" much different from other entries.

As I read through this blog entry I am again grateful for the Google session I attended last fall.  This was one of several very valuable sessions that has had a long lasting impact on my teaching and my class.  Not only that, I find it enjoyable to think about my classes and write about them!

Sunday, September 2, 2018

First Time Teaching - Objects Early

We completed the third week of school and I have introduced objects to the Advanced Placement Computer Science A (AP CSA) class.  Together we have coded a class representing a geometric shape and a Runner class that contains a main() method which creates instances of the geometric shape.  My first impressions are that I am going to like this.

Previous Years - Objects Late

During the last three years I taught a Java programming class (not AP CSA).  This was a class that I had built on my own and did not follow a set curriculum so I taught in an order that made sense to me -- and without doing any research on the debate of when to introduce objects.  The order that I taught language concepts follows:
  • Java program skeleton
  • screen output, variables and data types, basic math
  • keyboard input, the Math class, and Random
  • selection statements (if and switch) 
  • loops (for, while, do while)
  • file input and output
  • classes, methods, inheritance and OO Programming
  • arrays and ArrayLists
  • GUI and Swing
Classes, methods, inheritance and Object Oriented Programming were introduced only after students had learned a majority of the Java language constructs and a good number of supporting classes.  Each year, I would introduce the topic and let students know that they had been using classes and methods from the beginning when they created their first String and now they would be creating their own classes, each with multiple methods.  Each year students took a long time to get comfortable with this topic and we needed to do many, many examples -- together, in pairs and individually.  This was always the unit that would need to be extended with a lecture review,  new examples, or an extra project.

For the last two years I found my best success with teaching classes by following a cookbook approach and having students follow a set of task cards to create a class and tester for the class by going through one task card (one step) at a time -- create the class; add instance variables; create a constructor; create a tester that constructs objects; and so on.  I picked up this technique from a professional development I took over the summer at Colorado School of Mines (@CSatMines).  Students would go through one step at a time, it seemed to cement in their minds the steps needed to create objects.  However I was unsure if they were mastering OO concepts or simply mastering the steps in the recipe.  This further became apparent, when we started looking at inheritance, some students were able to take the next step while others showed that they did not fully grasp the concept of a class and had difficulty with inheritance.

This Year - Objects Early - and Hopes

This year I am teaching AP CSA following the order setup in A+ Computer Science (https://www.apluscompsci.com/).  We have covered the Java program skeleton, screen output, variables and data types and keyboard input during our first two and a half weeks covering Unit 0.  On Friday we started Unit 1 and built our first class Dog which has only the default constructor, no instance variables and a couple of methods that only produce screen output.  This seems like a good first step to start learning the ideas of a class and an object without jumping into the details of instance variables, constructors, access methods, etc.

We will do some more practice with these basic classes containing methods with only println() statements and then go into adding instance variables, constructors and other methods.  My plan is still to spend a good deal of time on this unit with several program together examples, followed by paired programming with task cards and then a project.  Then after that I will introduce inheritance and the importance of abstraction.

With this early foundation in objects, I am hoping that we can as a set of learners have a good foundation in object oriented programming and be able to go further in the content so that concepts such as sorting, searching, and recursion can be covered along with a thorough review for the AP CSA test in May.  From this early look, I am pleased with what I am seeing.

My Look at the Research

Once you are programming in Java and using objects as part of a day to day job, the question of when you learned the OO concepts seems a moot point.  Most programmers from my era learned Java as a fourth or fifth or later programming language and it was a case of one more language and in most cases object oriented concepts were first used with C++.  However, now that I am in the education world, the topic of how you teach programming and object oriented concepts in the same course, the order does become important.

The debate ranges from objects early to objects late to objects never.  With AP CSA the latter is eliminated as it looks like students will be tested on objects.  So that leaves objects early and objects late.  I started looking into this when I attended the AP Summer Institute in July.  I had been following Alfred Thompson's blog and read what he had to say which concluded with use early and create late (https://blogs.msdn.microsoft.com/alfredth/2006/11/16/objects-early-objects-late-objects-never/).  I have to admit that this is what I was most comfortable with, but I also knew that my students had been struggling with this.

I read the 2009 study from Albrecht Ehlert and Carsten Schulte (http://home.cc.gatech.edu/csed/uploads/2/ehlert2009.pdf) which concluded that there were no learning gains to be found from one method over the other.  I also read the 2012 research from Murat Pasa Uysal (http://file.scirp.org/Html/23962.html) which concluded that there was a statistically significant difference in learning outcomes for object first being better than objects late.  This study was done with graduate students using the BlueJ environment which isn't my student population or the tool I am using in class (Eclipse).

The research does not seem to point definitively one way or the other which leaves teachers to select the method that works best.  Personally I find that with each year I collect new methods and strategies for teaching CS concepts and in the end hope to come up with a good set of tools for my students.  As for the debate, it looks like a spirited one with people falling on all sides of the issue, and I am making my own small experiment by moving from objects late to objects early, so stay tuned and I look forward to finding my own conclusions.