Background

jLogo Programming

Java

Appendices

Lastly

Preface

These web-based notes are the result of classes that I have been involved with over the past few years. I started putting them together simply as notes for my students.

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. I had no idea what I was getting myself into. 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.

In 2006 I decided to move the BFOIT curricula more towards preparing students for the Advanced Placement Computer Science class. This is now my overarching goal. Since the BFOIT flavor of Logo is written in Java and contains Java-like extensions (e.g., Events, println), I've renamed the language jLogo. I have started to add objects to jLogo.

In 2007, a new German friend (Florian Plank), told me he liked the material, but that it's presentation could use a lot of work. He put together an example page or two which were much, much better than my stuff. So, I have spent a lot of time rewriting the material as I cut and paste it into Florian's style. As soon as this exercise is complete, I will go back and complete adding support for objects.

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 CS0 class should be to introduce how useful programming can be as an aid to learning and understanding and in problem solving; it can help explain complex processes (via modeling and simulation); it can be used to express oneself artistically. The class must make computer science attractive, fun. We need more students (and a more diverse group of students) using 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 my class, they should walk away with improved problem-solving skills and a feeling for how they could use a computer as a tool.

For a couple of my favorite views in this area, see Computational Thinking and Changing Minds.

In her book In Code, Sarah Flannery talks about how she used programming to explore and then document her work in cryptography.

So, what do I think is important in a CS0 class?

It must have a good set of projects/exercises that give the student a feeling for how he/she can get a computer to do something of interest to him/her. 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, the instructor must be able to see/judge merits/deficiencies in alternative solutions. Students will do things their own way and there may be a lot learned from their approaches.
It should cover the basics of computer science and programming without overwhelming the student with esoteric information. The instructor needs a set of lessons that cover a subset of CS and must be comfortable introducing 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 areas.
"20% of the people will learn whatever you do to them. It's the other 80% that you have to worry about." Elliot Soloway

I've had students in my classes that just get it. I need to do very little other than point them in the right direction and they are off and running. These are not the students I hope to help with these lessons. Chances are these students will get bored unless the instructor can recruit them to help others in the class, or push their limits with extensions to the exercises here.

What are the most important basic concepts?
1. the concept of process, and then,
2. decomposition of problems into understandable/manageable pieces
3. abstraction - procedures and data
4. the proper use of variables
5. debugging and verifying a program's correctness
6. at least an introduction to the way a program and information is encoded in binary numbers (bits)
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 is also is important in the chosen programming environment. The less time you spend talking about the constructs of the language and how to develop programs in the chosen environment, the more time you get to spend on the real problem of writing out a process in source code.