Let’s get cranky, shall we?

I’m going to make strong statements, and see if there’s pushback. And, this weekend, I’ll try and turn comments back on. In the meantime, use the gmail address, and I’ll add your comments as they come in.

From Worker Bee, we see this post:

Today I taught my last class of the quarter (Friday is the final), in which I gave a lecture introducing computer science, the whole discipline, starting with NAND gates and how you’d coax electricity to behave like boolean logic, and ending up with the P=NP question and the halting problem. I don’t know whether my students cared about it, but for me it was great fun.

What if the entire lecture had been questions? “What is computer science?” Wait for a minute. Two. Wait until someone says something. Anything. Challenge it. Explore it. Ask other students in the classroom whether they agree or disagree. If they disagree, why? If they don’t, why? See what they know. See what they think. See if they know what they do not know.

In the end, who gives a shit about what another CS grad student thinks computer science is? Grad students in CS are a dime-a-dozen, and every one of us has our own slant, our own view, our own opinion on what computing is or is not. I personally think computing is about the creative process, but I doubt many people care about that. A bunch of first years certainly don’t give a flying duck about NAND gates, and they never will. (I take that back; some of them do. And those students probably didn’t need your lecture in the first place.) Who cares if they have that fragile knowledge about the computational tower—I want them to think!

I’m glad the lecturer’s imagination was captured by their own egotistical rambling, but I’m sure mine wouldn’t have been. Mercy. When will people start asking their students questions, challenging them to wake up, instead of selling them a crapload of bullshit facts?

For the record: Yes, I know I wasn’t there. Yes, I know I’m extrapolating from nothing. Consider Worker Bee’s blog post nothing more than a springboard for me to rant; I certainly don’t actually have any malice or ill-will towards Jacob. The post was nothing more than a foil. But still, why wasn’t the post about the great discussion they had in that classroom, instead of a lecture that the students may or may not have cared about? How much longer until our classrooms become conversations, not pulpits?

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…

Last night was the second session in the introduction to Java that I’m teaching as part of Kent’s IT Cert course. Most of my students had not reviewed chapter one, or continued working through any of the exercises; in an 8-week course, this isn’t ideal, but we can manage at this early stage.

I spent a good chunk of Sunday prepping for class, as well as ironing some details out on Monday. The prep was primarily composed of building a tutorial that would run within BlueJ; we’re calling these tutorials trails. This is because the tool we’re currently using to build the trails (a modified version of JFLAP–a tool designed for teaching student about automata) lets us draw out the progression of the tutorial, as well as attach conditions on the transitions from one step to the next.

From the student’s perspective, they encounter the tutorial content as a textual pane embedded in BlueJ.

What’s interesting about the tutorial is that we can interact with the environment and the student’s code at a very high level through the BlueJ Extensions API. This means we can write a tutorial that responds to

• Classes of syntax error made by the student,
• (Some) semantic errors made by the student, as well as
• The state of their interactions in BlueJ with objects on the bench.

Practically, this means we can augment or override compiler errors with messages of our own, we can inspect their code to see if they’ve carried out the correct additions or modifications (example below), or see if they understand how to interact with the classes they’ve written as objects.

For example, I wanted my students to write a very simple class:

public class Animal {

}

This is because I wanted to build up to adding fields (one at a time), a constructor (that sets default values for those fields), accessors (again, one at a time), and mutators in a very stepwise, controlled manner. This way, syntax errors would generally be constrained to one or two lines of code at a time, and the students would repetitively encounter the fundamental elements of a class. Drill-and-practice at its simplest.

Using the trail builder, we can check for all kinds of things (more on this when the tools and software are released after testing). This particular tutorial didn’t capture any syntax errors, but it would check to see that they managed the semantics of each step. For example, we could check that they had a class called Animal with no fields or methods; if they didn’t, we give them some generic feedback saying as much:

After enough attempts, we encourage them to ask a question. There are better ways of handling this, but for the moment, the intention was to get the students asking myself or each-other questions in-class, not coding checks for every possible contingency. When they get things right, something very important happens: they get positive feedback.

Off the top of my head, I don’t know of any tutorial systems for programmers that offer this kind of interaction. We can augment syntactic error messages, semantic errors (by examining their code through the BlueJ API or unit tests), we can branch to sub-trails to drill on specific problems as necessary, and most importantly, we can praise students for work well done—something that simply doesn’t happen in VB.Net (or any other development environment I’m aware of).

I think the class went very well. I was surprised at how far through the tutorial my students made it in an hour-and-a-half, considering none of them have done any programming of significance before. They saw it as a lot like HTML, but “more picky.” At the end of the evening, we were able to recap and go through the concepts and vocabulary fairly easily. I’d say that there was a lot of value last night in drilling on basic concepts from the start.

We’ll see what happens next week; I’ll be writing a “drill-and-practice” tutorial generator (so I can give them an endless stream of these kinds of problems to work on), and we’ll start digging into the TicketMachine material I’m cleaning up.

A good friend of some years dropped an email a few days about with some reflections on how he might envision his children being educated. Not that he has kids, mind you, but he was thinking ahead. His own education was fairly non-traditional, and somehow, despite being raised by wolves, turned out relatively brilliant. Except when he’s being stupid, of course.

Point being, his musings primarily concerned ways that a small community might go about organizing to provide home schooling for more than one child, utilizing the expertise of everyone in that community. In this way, his expertise in (say) Physics might be leveraged, while someone else’s expertise in Literature or Ecology would be utilized elsewhere.

I think, however, that he glossed over what probably matters most in the scenario he laid out. One of his starting assumptions was

I’m also proceeding from the standpoint of someone who will one day be a parent, and furthermore the parent of a child who … will get lots of love and attention at home.

I think that might be the single most important factor in the whole equation. Instead of worrying about expertise in Physics or Ecology, you could go a long way to having parents in a community host homework sessions for a group of students, where the parents take turns with small groups of kids asking them questions about their homework, taking interest in what they do, etc. Or, put more simply, I don’t think expertise matters in this situation, but I think the attention and respect are key.

It was an interesting email to receive as CSCS is starting up in a few days. We’ll see how many students show up this year, but the premise is daunting (yet exciting) from an instructor’s point of view: as long as we don’t do things that suck, the students will show up. Or, as long as we respect the time the students are putting in, I’ve noticed that the students respect our time as well, and participate actively. Working with things the students are interested in (little robots) helps out, so I think it’s a healthy combination of respect and motivation that play a key part.

Is my friend’s “home school collective” related to CSCS? I think so, because I think that capturing a student’s imagination is a critical first step in the learning process. And I think that this was implicitly (and somewhat explicitly) behind my friend’s preflections on his children’s future education: how can I get them to be excited about learning (because I don’t think your typical school environment manages)?