It’s an odd dichotomy; on Mondays, I’ve been doing very drill-and-practice style work with my students, and on Thursdays we’re doing extremely constructive and creative projects.
This evening was the third meeting of the intro to Java I’m teaching as part of the IT Cert at Kent. Unlike last term, I have a new tool to work with in the classroom: a series of tutorials I’ve developed that are embedded in the BlueJ programming environment. What has made these tutorials particularly useful is that they allow my students to wrestle with new concepts in a constrained space: constructs in the language are exposed to them individually, one-at-a-time. When they read their course text, I think they tend to get information overload (having never programmed before), and typically don’t associate terms and concepts effectively with the grammar and syntax of the Java programming language.
I have 12 tutorials right now that drill students on creating an empty class, adding fields (one at a time), adding accessors and mutators for each field, and adding one or more constructors. Because I wrote a tutorial generator for this kind of drill-and-practice tutorial, I can easily create more, and (over time) extend the tutorials to include additional, fundamental concepts.
While the term drill-and-practice carries many negative associations for me, it can be a very effective instructional method. In the context of introductory programming, I think the drill-and-practice work
- Familiarizes students with the parts of a class
- Acquaints them with common syntax errors
- Builds confidence and familiarity with the IDE
- Provides a conceptual base that I can work from
- Reduces my in-class workload
In particular, having a tutorial system that can actually inspect the student’s code, as well as offer immediate and positive feedback is an essential part of the equation.
Because the students are asked to write fields individually (for example), they clearly see what a field is in separation from all the other parts of a class. Likewise, each part of a class (accessor/mutator methods and constructors) is added piecewise. When given the TicketMachine code from the second chapter of Objects First, they were easily able to recognize these parts of a class in the code given.
They are also learning the simplest of syntax errors, and most importantly, those errors are constrained to one or two lines of code. That is, the tutorials never ask them to write more than a few lines of code at a time (often only one or two). This means that syntax errors are “constrained” to the most recent thing they did, and therefore they aren’t wandering lost in 50 or more lines of code. The edit-compile cycle also encourages a certain familiarity with the BlueJ IDE, which isn’t a bad thing at this stage.
In terms of a common conceptual base, these tutorials provide something I can refer to time and again. For example, we wrestled with accessors and mutators this evening (”setters” and “getters”). What makes them “easy” is that they both follow a very clear formula; if you know the name of the field you’re working with, you can learn to write setters and getters by wrote. Given the field
private String lastName;
we can write the getter
public String getLastName() {
return lastName;
}
Having written around a dozen of these in the first half of class, we were able to start dissecting this without it being horribly abstract. For example, when I showed them the accessor “pattern,” it didn’t really surprise them:
public type getfield-name() {
return field-name;
}
And lastly, my workload in class is significantly reduced if I let the students spend the majority of the 3 hours of class having them work through a tutorial instead of me lecturing. Instead of trying to illustrate concepts with four colors of dry erase marker and a crap little whiteboard, I can instead spend my time going station-to-station looking over the students’ shoulders. When it’s clear they’re wandering, I can provide contextual help that is timely and tailored to the individual. Or, I can pull back and do a quick “mini-lecture” that is topical to a problem they all seem to be having. My advance prep gives me the ability to spend more class-time in 1-on-1 interactions–and the best part is, that advanced prep is reusable from term-to-term and is easily shared on the WWW.
If I’m going on-and-on, it’s because this has, for the last two weeks, been entirely too easy. I feel like the students are making very good progress, considering how fast this 8 week course is intended to go.
I need to spend a little bit of time getting the website up and running for distributing these tutorials; once that is tweaked, we’ll go live and let BlueJ users everywhere grab them. And then I’ll have support issues… ![]()
of the dangers of eVoting.
The technology 
