From 1999 through 2002, I taught an Introduction to Programming class using the Java programming language to 6th through 8th grade students at Berkeley's Longfellow Arts & Technology Middle School.  It was a challenge, but I also enjoyed it.

Starting in the summer of 2000, I volunteered to work with Brian Harvey, participating in the BFOIT Introduction to Computer Science program.  Brian has been researching introducing the concepts involved in serious computer programming for decades and has written many textbooks on the subject; he also spends considerable time delivering the material; he's a master at it.  I wanted to work with him to learn all I could about teaching introductory programming.

The Longfellow Java class was held on Saturday mornings, from 9:00am to 11:00am.  The age of the students and the short amount of time (2 hours) and the spacing (weekly, at best) forced me to develop a class unlike anything I could find to use.  I've managed to keep all of the students (and some parents) coming back Saturday after Saturday by keeping the class very hands-on in nature.  For each week, I pick one or more new concept to illustrate; I provide skeleton source code and the objective of each lesson is to complete the software.  In 2002, we worked on a computer-based TicTacToe program.

The BFOIT class started out as a single week, with Introduction to Programming taught every morning from 9:00 to 12:00.  The students were older and part of the criteria for selecting participants was strong backgrounds in Algebra and Geometry.  The first year we pushed the students hard; the objective was to implement the game Mastermind in Logo with help from the LCSI Microworlds Logo development environment.  We supplied pieces of the application and a few students completed the project.  But, we got a lot of feedback that we covered too much in one week.

In the summer of 2001, BFOIT was extended to two weeks.  Brian and I decided to slow the pace with a couple of days dedicated to generic programming, followed by a project: to write the game TicTacToe.  Our success rate improved.  We still had feedback that the pace was aggressive, but we also had feedback that we moved too slowly...  Success!

For the summer of 2002, I combined the Turtle Graphics commands available in Logo with the Java programming language.  The experience proved to me that the concepts of programming that are the challenges to learn/teach are independent of the programming language.  However, due to the limited time for the class, Java's complex syntax was too much to cover.  For the summer of 2003, I went back to Logo and it did prove to be better.

For the 2004 BFOIT class the web notes were expanded to cover a wider variety of computer science topics.  I used a subset of the Logo language (which I'm calling TurtleTalk).  The idea was to cover all of the basic concepts of programming in TurtleTalk.  Once the students got comfortable with this material, Java will be introduced along with object-oriented programming.

During the 2004-2005 school year, Albany High School (just north of Berkeley) used the lessons.  I was in close contact with the instructor and adjusted the contents to meet feedback.

The 2005 BFOIT summer camp went well.  I got more feedback and have continued to refine the material.  Albany High School is again using the curricula; this year without any assistance from me.  I am engaged in playing with e-learning via a CoPE Internet site.  This should be interesting. 

Meanwhile, I will continue to move the BFOIT curricula to prepare students for the Advanced Placement Computer Science class.  This is my overarching goal.

Curriculum Philosophy

The BFOIT website materials cover what I believe are the most import concepts for a student's initial exposure to computer programming and computer science.

I believe that the purpose of a high school CS1 class should be to introduce how useful computer science, programming in particular, can be as an aid to learning/understanding and in problem solving; it can help explain complex processes (via modeling and simulating); it can be used to express oneself artistically.  It needs to make computer science attractive, fun.  We need more students (and a more diverse group of students) using computer programming to enhance their learning experience.  It should prepare a student for further investigation (?the AP CS class?).  Even if the students end their study of computer science with this class, they should walk away with improved problem-solving skills.

So, what's important for a successful CS1 class?

1. It must cover the basics of computer science and programming.  The instructor must have a set of lessons that cover a decent subset of CS and be comfortable delivering the material.  She needs to know where the hard/trouble spots are (where many students have problems) and be prepared to give extra guidance/coaching in these spots.

   "20% of the people will learn whatever you do to them. It's the other 80% that you have to worry about." Elliot Soloway

   What are the most important basic concepts?

   1. program and information encoding as binary numbers (bits)
   2. the concept of process, and then,
   3. the process of decomposition of problems into understandable/manageable pieces
   4. abstraction - procedures and data
   5. control flow (iteration, conditionals)
   6. the proper use of variables
   7. debugging and verifying a program's correctness
2. It must have a good (interesting) series of projects/exercises that introduce the concepts.  The last thing I want to do is to scare students away from the field.

   The instructor should know them inside-out.  Since there is rarely a single way to do things, you must be able to see/judge merits/deficiencies in alternative solutions.  Students will do things their own way and there can be a lot learned from their approaches.

3. Simplicity.  The programming language used must be one that the instructor knows very well.  Given this, the simpler the chosen language's syntax/semantics, the better.  High school CS1 students are not going to get a job in the real world based on what they learn in a CS1 class.  The language should not get in the way of what one really is trying to teach.  Simplicity also is important in the chosen programming environment.  The less time you spend talking about the constructs of the language and how to write code in the environment, the more time you get to spend on the real problem of writing a process in source code.

What's needed to follow these lessons on your own home computer?

For the first few lessons, while the programs being written are small, all you need is a browser capable of executing a Java applet.  The TurtleTalk dialect of Logo has been written in Java such that it runs as either an applet or application.  The major advantage of the applet is it lets students try things out as they are presented.

The big problem with a Java applet is that it does not have access to the computer it's running on's storage - you can not save/load large programs.  To work on the larger programs, you must copy the applet/application to each computer.  And, each computer must have a JRE (Java Runtime Environment) on it.

I'm pretty sure that any copy of Java that's compatible with v1.1.8 (the version browsers have been supporting since the mid-90s) will run the program.  See Appendix F for more details regarding installation.

I hope you find the lessons educational, and fun!

guy
(guyhaas at pacbell dot net)