Computer Science Teacher
Computer Science Teacher - Thoughts and Information from Alfred Thompson

February, 2010

  • Computer Science Teacher - Thoughts and Information from Alfred Thompson



    Last week someone on the SIGCSE mailing list mentioned that they learned to program in FORTRAN, using punch cards on an IBM 1130. Well so did I and I said so. This seemed to have opened the floodgates of nostalgia (lots of us on the list seem to be old where old is defined as my age or older). I told someone that one of my friends wrote a program to have the 1403 line printer play music. It turns out that others did similar things and I read the story of one group breaking the chain while playing the Indian national anthem. Good times. Yes, we reminisce about line printers, card readers, old programming languages and much more about the “good old days” of computing. And then the interesting question came up.

    Mark Hoffman of Sciences Quinnipiac University asked “What will current students or recent graduates be sharing as nostalgic 40 years from now on the SIGCSE mailing list?

    Well what do you think? Something like “remember when you had to use a keyboard and mouse to use a computer?” Or “remember when computers sat on your lap rather than being embedded into your skin?” Or “what was that computer company named after a fruit?”

    Have any ideas? What do young people, your students perhaps, think will be long gone in 40 years?

  • Computer Science Teacher - Thoughts and Information from Alfred Thompson

    Cheating In Computer Science Classes


    This story on cheating in Computer Science classes is one of  those things that really makes you think. Years ago one of my students was so tired of students looking over his shoulder and stealing his code that he started using variable names that made absolutely no sense at all. He figured that if they were too obviously his no one would dare steal his code. This was my first awareness of student cheating in my own classroom and was a real eye opener. I kept a close eye on things but honestly I am sure I missed as much cheating as I caught. Hopefully not more but who knows?

    Defining cheating in computer science / programming courses is difficult though. After all code reuse is a goal for professional developers and team work is essential. The article above listed HONOR CODE RULES FOR STANFORD'S COMPUTER SCIENCE CLASSES and they are a lot like I tried to run things in my classroom

    • You must indicate on your submission the receipt of any assistance, such as discussion of ideas and strategies and write the actual program code on your own.
    • You must not share program code with other students.
    • You must not look at solution sets or program code from other years.
    • You must be prepared to explain any program code you submit.

    The last line became a critical part of my final project grading in my courses. I would do a one on one interview and mini code review with each student and we would go over their project together. I would prepare questions about code that seemed tricky or overly familiar to me. I would ask for explanations of names and program organization. All this to make sure that students understood what they had done. This doesn’t scale well of course. You can’t realistically do it for a 180 students. I wish we could but there is a limit to time in the day. On smaller projects during the year I would do spot interviews when I suspected something was “different” about a project. This requires knowing what each student is like and also doesn’t always scale. But you know English teachers do it with writing projects so we should be able to do it in computer science classes as well. Style is unique.

    But the article also says that cheating is much more common in computer science courses than in other courses. Why is that? Stanford’s Eric Roberts has some ideas based on his research.

    • Students are attracted to a computer science degree by its marketability and as a steppingstone to wealth and job security rather than intrinsic interest in the subject. They see stellar course work as critical to their future livelihood.
    • The material is cumulative, so students who neglect early work are completely confused by later assignments, and panic.
    • Unlike other disciplines, it is not possible to merely submit inferior work. A computer program that doesn't work is simply rejected, which creates student anxiety.
    • It"s easy to get help from others. In terminal clusters, students work near each other, so it’s tempting to ask for help, peek over a shoulder or retrieve program listings from a recycling bin. Many students accidentally leave copies of their work on the hard disk of public machines.
    • Computer science courses often reuse past assignments, because assignments, like programs, improve with time and debugging. So students seek solution sets from past course offerings.

    These resonate with me. Take the second item. How do we handle it when students fall behind? Can we do things more self-paced, especially in the early courses, to make this sort of cheating less necessary? Perhaps not at college/university but perhaps we can in high school. Helping students get a solid base for later seems like it should be a huge goal for HS CS.

    And the third item. Do we have to make projects binary – pass or fail? Or can we review code and give some partial credit for it? That is done in grading the free response questions on the APCS exam. This is a larger problem with projects/homework of course. But I tried to review even code that would not correctly compile to at least understand what the student was not understanding. If we can review projects while they are being worked on we can help with those sorts of things. Again, not easy to scale but doable in smaller courses. And lets face it, small classes are what many HS CS teachers are facing. Perhaps we can turn that into an advantage for our students.

    Clearly this is going to be an issue going forward. It means we need to talk about the ethics of “helping”, “borrowing” and other cheating methods. But we also need to emphasize that students really need to and should want to learn these things for themselves. Success in later their life will depend on what they know and not on what the student in the next chair knows.

    BTW see Mark Guzdial’s take on this at Stanford finds cheating increasing, especially among CS students and how cheating influenced Georgia Tech in how they rewrote the curriculum. Useful information and ideas.

  • Computer Science Teacher - Thoughts and Information from Alfred Thompson

    Where is the Computer Science at Education Technology Conferences?


    I’ve been attending educational technology (EdTech) conferences for years now. Some of them are really big like ISTE, TCEA and FETC. Some are smaller like the New Hampshire (NHSTE) Christa McAuliffe conference. There are a lot of great things at these events. There are large numbers of sessions on using technology in education. There are many many teachers doing innovative things and sharing what they know. The problem for me and for a lot of computer science teachers is that there just isn’t that much for them.

    There are usually some computer science sessions at the large conferences (ISTE, TCEA and FETC) but not a lot of them. ISTE and TCEA both have special interest groups who have meetings but the smaller conferences seldom have large group meetings. At TCEA last week the TA/CT SIG meeting had about 50 people which the conference as a whole had over 12,000 attendees. This seems like a small percentage to me. And there was a small group in a session I saw part of on using Dr Seuss  books in teaching java.  We had about 70 in a session we did on XNA and the XNA curriculum that we have out now. SO Computer Science is still alive at TCEA but I talk to CS teachers in Florida and CS seems dead to them at FETC. I hear talk that there will be 10 or fewer CS sessions at ISTE this year. Could that be true? Scary that this is even a remote possibility.

    But to me it is even more of a problem that small regional conferences don’t have much in the way of real CS sessions. After all most teachers do not have the funds to attend the very large conferences.

    On one hand this is all a function of technology integration becoming a much bigger thing across the curriculum. That’s clearly a positive thing in my opinion. But at the same time this should be opening more doors to teaching the science behind the technology and that isn’t happening. That is where the problem is. I think that the people who run these conferences need to do more to create some outreach to bring CS teachers back – as presenters as well as attendees. Sure you can say that CS teachers need to be more pro-active about submitting to conferences and presenting and there is some truth to that. But if they don’t feel welcome, if they don’t feel like their sessions will be accepted they are not going to submit.

    For computer science teachers there are starting to be some alternative venues for professional development and presentations. There is SIGCSE (see CSTA blog for a post on K12 day and events at SIGCSE) and there is the CS & IT Symposium which is amazing. And CSTA is developing local CSTA chapters and they are running some wonderful local events. These separate events may be the best future for professional development for computer science teachers in the near term. But I think that as a computer science education community we need to get back into the “main stream” ed tech conferences. We need to reach out to the technology integration people and help them to see that they need to find ways to bring more computer science education into the schools. I’m not sure how to make that happen but I think we as a community need to find a way. Or several ways.

    What do you think? Is creating more separate events the way or should be be worming our way back into edtech conferences? Am I overstating the problem?

Page 3 of 8 (22 items) 12345»