First things aren’t always first

November 2, 2010 at 1:19 pm 13 comments

When I was a graduate student at the University of Michigan, I worked with Pat Baggett and Bob Kozma in the School of Education. Both of whom were interested in the human ability to make sense of knowledge presented, even when it wasn’t in the right order. Pat would give study participants instructions on assembling a complicated gadget, and she had to really struggle to juggle the instructions such that participants couldn’t assemble the gadget easily. Bob had explored teaching mathematics lessons “out of order,” and students still figured it out. People are really good at filling in gaps and remembering things to be completed later. It may slow them down, but the self-integrated knowledge is likely to be learned well — it will transfer.

So that’s why I think that some of the “But first we have to…” statements I’ve been hearing lately don’t give students the credit they deserve.

“To program, students have to use the computer well. So FIRST, we should teach them applications and keyboarding skills.”

I hear this a lot from high school teachers who are moving from being Business teachers (e.g., Office applications, databases) to becoming Computer Science teachers. They argue that students won’t be able to program until they are facile with the keyboard and basic copy-paste functionality. That’s why it makes sense to teach students applications first — which is what they are the most comfortable with teaching.

Sure, programmers are good with computers, but the order of events is backwards from what the teachers expect. Programmers BECOME good with computer basics, like keyboarding and applications. No programmer I know went out to learn Word and Excel first, in order to be a better programmer.

“To do Media Computation well, students need to learn Python. So FIRST, we should teach them five weeks of Python basics, then start into media manipulation.”

I hear this one from CS1 teachers who want to try Media Computation (or really, any other contextualized approach), but want to do it as an add-on. Sure, it’ll work that way, but it’s not necessary. The whole point of the context is to explain a purpose for learning variables, expressions, conditionals, and iteration structures. It’s not the only purpose. But it is a purpose, and there are several studies showing that that’s the problem that students face when meeting introductory computing. It’s so hard and complicated — so why do it? Doing five weeks of Python, and then starting Media Computation, is holding out the carrot — but so far out of reach that it’s irrelevant.

The part that’s challenging for teachers to recognize is that students can learn the details while learning the context. These things can happen in parallel. It isn’t necessary to have perfect knowledge of variables first. It’s okay to know something, and then pitch in and get started. The rest comes as it’s needed. Sometimes, the first things don’t have to come first.

Entry filed under: Uncategorized. Tags: .

Making Software: TDD doesn’t work; Architecting is mixed; scripting is great Slow change in CS1 Culture: China and Gates

13 Comments Add your own

  • 1. John "Z-Bo" Zabroski  |  November 2, 2010 at 1:42 pm

    Regarding out of order learning:

    I ocne raed a sduty taht siad hmuans can raed melpleisd snetances so lnog as the fsrit and lsat ltteers in ecah wrod are crroect.

    Nicole McNeil, a psychologist and researcher at Notre Dame, has done some fascinating stuff regarding how students learn math. She has shown that some students will incorrectly interpret the = sign as “calculate the total”, and so when they have problems such as 3 + _ = 11, they answer 14. One might argue this is a situation that demonstrates need to understand the context or else when they approach more algebraic looks at the topic, they will carry bad habits forward.

    Reply
  • 2. Gary Litvin  |  November 2, 2010 at 2:23 pm

    “The part that’s challenging for teachers to recognize is that students can learn the details while learning the context. These things can happen in parallel.”

    Computer programming is usually taught in some context. The question is whether it is better to lock the context for a considerable length of time or vary the context appropriately with the topics taught. I emphatically vote for the latter. If you lock the context, students may become distracted by it and confused as to what exactly is beign taught. Or simply bored by it.

    Gary Litvin
    http://www.skylit.com

    Reply
    • 3. Mark Guzdial  |  November 4, 2010 at 8:00 am

      Hi Gary,

      I disagree that programming is usually taught in some context. In a review of CS1 textbooks, we found that very often problems were just problems: Swap two values, sort some numbers. No purpose given.

      I have an article coming out in the next ACM Inroads on the data on context. I suppose it all depends on how long a “considerable length” means. The studies I’ve seen (like Beth Simon’s ITICSE 2010 paper) show that contextualizing the whole first course can lead to sustained retention gains a year later.

      Cheers,
      Mark

      Reply
      • 4. John "Z-Bo" Zabroski  |  November 4, 2010 at 1:47 pm

        Hi Mark,

        Do you have a link anywhere to a publication or blog entry where you review CS1 textbooks? I have had a side hobby since undergrad that was fascinated with the approaches introductory texts take to programming.

        Usually, my biggest gripe has been textbooks that conflate data abstraction techniques and confuse ADTs with objects. Also, their examples tend to be awful and don’t actually model the real-world well. For example, many books discuss what a Date class should look like, but don’t explain anything about the problem domain regarding Date’s. What should the logic look like? We aren’t told, so the implementation ends up naive and there ends up being no constraints in place to guard bad dates from being entered. In this situation, not only have I seen authors conflate ADTs with objects, but also give AWFUL examples that nothing interesting can be learned from! The authors also use language that shows they don’t know the difference between ADTs and objects. If they did, they would probably realize how bad the example is.

        Then my favorite OO example is the ATM. At least two books I have seen allow the ATM to have knowledge of accounts, which it should not have. If an ATM knows about the banking account information subsystem, then instances of an Account need to be shared between the ATM and banking subsystem. This creates versionability conflicts, and also increases complexity in the communication protocl between the two systems, because you have now distributed your objects. Finally, the poor ATM examples don’t properly use an object-oriented interface to seal the client from the implementation details such as the format of the currency. Upgrades such as transitioning to euros would require every client in the world to have its firmware updated, which in the case of EPROM chips common in embedded systems basically means manual re-installation. ATMs also these days tend to print custom advertising on the receipts customers get, and you can only do this cheaply if you properly design the system.

        Reply
        • 5. Mark Guzdial  |  November 4, 2010 at 6:50 pm

          John, I suggest looking through the SIGCSE Symposium Proceedings for analyses of textbooks. Allison Elliott Tew published some of her CS1 textbook review in last year’s proceedings.

          Reply
          • 6. John "Z-Bo" Zabroski  |  November 5, 2010 at 9:25 pm

            ACM Digital Library won’t let me log back in because I let me membership lapse and had to sign up for a new membership, so my online account and membership are not linked at the moment.

            I recall reading Tew’s paper, and as I recall she found that analyzing textbooks was NOT fruitful, and her conclusion was that the textbooks covered more material than CS1 demanded. I regarded this paper as completely annoying and pedantic. I realize you are a co-author, but I will not spare your feelings. This section of the paper simply asked the wrong questions (at least in comparison to what I want to know and think what is worth asking).

            I want to know, What technical mistakes are made in popular textbooks on programming? If a leading programming language researcher were to critique their vocabulary usage, how well would the author make out?

            Arguing stuff like “well, these textbooks are too big for CS1”, just seems boring to me. Moreover, it measures things against something that was basically set as a standard in the 70s and has not given much thought to since (IMHO). Rather than re-think the standard, professors have re-acted by trying to dumb it down in other ways, such as “let’s teach Java”. This is what happens when institutionalized bureaucracies run amok. Asking how well these bureaucracies are run — the effectiveness of textbooks for CS1 — is simply not an interesting long-term question.

            Reply
            • 7. Mark Guzdial  |  November 6, 2010 at 3:01 am

              It’s okay, John. We weren’t writing it for you. Those weren’t the questions we were answering.

              Reply
          • 8. John "Z-Bo" Zabroski  |  November 5, 2010 at 10:14 pm

            Another thing I want that “textbooks used for CS1” can’t measure is just general approaches to teaching learning outside CS1. Many programming language book authors don’t know what the heck CS1 and that’s a darn good thing, but by trying to sample CS1 books we’re basically selecting from a small pool. Since so few books are ever worth reading, limiting the sampling pool seems ridiculous.

            I want to know WAY more than what you can show by trying to systematize CS1.

            I want to know about programming language introductory books grouped by interest. For example, if I want multimedia, well, I could use your book, or I could maybe use John Brinckerhoff Clements stuff for PLT-Scheme [1]. Or I could use The Haskell School of Expression: Learning Functional Programming through Multimedia.

            Or what if I wanted something really novel and whacky for learning programming? Friedman and Felleisen’s The Little Schemer? The Seasoned Schemer? Gene Korienek and Tom Wrensch’s ObjectLand?

            I want to be able to visualize my consumer options more effectively, rather than some flat boring google search. I can’t even type such a search into Google today and get back an interesting intellectual answer, let alone a visually captivating one.

            [1] http://www.brinckerhoff.org/clements/csc123-fa10/index.html

            Reply
        • 9. Bonnie MacKellar  |  November 5, 2010 at 1:59 pm

          In many ways I agree with you – the examples in introductory textbooks tend to gloss over lots of important considerations. BUT, you have to realize that the students are struggling with the concepts. You cannot explain a design that takes versioning into account to a student who is utterly flummoxed over the idea that an ATM could be represented as a class at all.
          I have to teach Java and OO design to students who spent the first 2 semesters learning (being ruined by?) procedural, non-OO programming. The idea that one object could have knowledge of another is very difficult for them. I have to keep the examples very simple for them. Until they are able to internalize basic concepts, I cannot introduce extraneous ideas.
          Textbooks have to simplify their examples to present one major idea at a time, and that is why the examples might not be up to industrial programming norms.

          Reply
          • 10. John "Z-Bo" Zabroski  |  November 5, 2010 at 8:58 pm

            My examples were picked to illustrate how many books appear to copy-and-paste pedagogic examples, so that I could deconstruct them and show that they have severe weaknesses that could interfere with pedagogy.

            I believe many approaches to teaching can work well. However, I am utmost against cheapening the learning process. You can’t risk oversimplifying programming. For example, I don’t mind the idea of using multimedia to interest students, so long as they learn something beyond how to drop in a media player into a Java Swing app. Have you ever tried relating to your students and speaking out loud what may be going through their head? I once gave a talk on OOP to system administrators who were really interested in the hype surrounding Ruby, because they hated their past sins of using perl and acknowledged bash and the original bourne shell just didn’t cut it when it came to managing supercomputers, as well as system administration. A few months later they were all using Puppet, a centralized system configuration tool written in Ruby. I recall the turning point during the talk, when it became more interactive, and somebody mentioned that in their undergrad course on OOP (which they didn’t do well in), they got the sense from the professor that there was some “ghost in the machine”. Teasing out his comments, it occurred to me that this was “the idea that one object could have knowledge of another [being] very difficult”.

            Another thing I demonstrated was comparisons. For example, I took Pontus Johnson and Mathias Ekstedt’s example from his free book, The Grand Unified Theory of Software Engineering, “How do you write code for an N-Body Problem?” Beginning with the perspective of OOP, I demonstrated, as Pontus did, that the OOP approach leads to “artificial consistency requirements”, because the OOP approach forces us to transform an elegant representation of a problem into a representation with more consistency requirements; the system becomes over-determined. (Alan Kay’s VPRI group would probably argue that you should create an object-oriented parser that represents the differential equations and use that DSL to solve the problem, thus keeping things object-oriented but eliminating the coordination overhead demonstrated in the GUTSE.) The real point here was I was demonstrating to them what “overkill” looks like. Most students, even the 30 year olds I were talking to, don’t realize, as Butler Lampson once said, “our reach exceeds our grasp”, and that we will tend to over-engineer things. So it helps to instruct people on what over-engineering looks like, and why it pays off to keep things simple and only implement the requirements. To do this effectively, the student has to learn what is essential and what is accidental. If they don’t learn this, then they are basically paying college credits for a University of Phoenix Online degree – which is what most CS programs are content with becoming. Seth Godin wrote an excellent blog post recently about “Pushing back on mediocre professors”, where he kept the idea real simple: Does this course advocate the student grow as a problem solver, or is this course something the student could take on their own and the professor is just there to grade tests/homework? [1]

            I also gave them the object-oriented binary adder example from Bernhard Zeigler’s book Objects and Systems, but at this point they were pretty excited about what they were hearing and just wanted to know how they could apply it to system administration. I honestly wasn’t prepared for that, and so it wasn’t until Puppet came along that I discovered a great example for the problem domain of network and system administration.

            I do not have any degrees, undergrad or advanced, in education, but read 10 years of ACM SIGCSE publications my senior year of college, because I was so frustrated with the genuine lack of rigor in our curriculum (or I am just a perfectionist). It wasn’t just the course material that seemed wrong to me. When I wanted to assess the curriculum as a whole, they could not provide me accurate numbers (at least they admitted that the numbers were flawed). Since they had no statistical measures, they hadn’t even thought about how poor their stat tracking was. I don’t know if I changed that, but I was told by the Department Chair that the presentation given to the faculty was top-notch and he would act on the suggestions. Since moving away, I have not kept up.

            [1] http://sethgodin.typepad.com/seths_blog/2010/10/pushing-back-on-professors.html

            Reply
          • 11. John "Z-Bo" Zabroski  |  November 5, 2010 at 9:05 pm

            I guess my long-winded reply was intended to agree with Mark, and especially Gary Litvin:

            ***Vary the context while the student is learning the concepts.***

            You may find that trying to teach only the concepts, especially with less chaotic examples than all the ones I have mentioned, ends up making teaching the concepts more difficult.

            Reply
  • 12. Doug Holton  |  November 2, 2010 at 6:55 pm

    Yeah it’s a counter-intuitive finding from a lot of research on situated cognition, problem-based learning, learning from simulations, etc. Students learn more if you start with the messy problem or complex simulation or real-world experience first, and hold off the lectures and so forth until afterward (or as solicited by students). The simulation or design challenge may be a bit too difficult for them, or they may not understand it all, but they start to form questions, and better understand what they don’t know and what they need to know. So then when they hear a lecture or read a text about certain concepts or formulas, they are better prepared to learn from it, and see the need for it, and can attach a context to it.

    Some refs:
    * Brant, G., Hooper, E., & Sugrue, B. (1991). Which comes first: The simulation or the lecture? Journal of Educational Computing Research, 7(4), 469-481. See: http://baywood.metapress.com/link.asp?id=pwdp45l8lhl52vx7
    * Akpan (2002). Which Comes First: Computer Simulation of Dissection or a Traditional Laboratory Practical Method of Dissection. See: https://docs.google.com/viewer?url=http://wolfweb.unr.edu/homepage/crowther/ejse/akpan2.pdf
    * Schwartz & Bransford (1998). A time for telling. See: http://www.jstor.org/pss/3233709

    Reply
  • 13. There is no “First” in CS1 « Computing Education Blog  |  November 27, 2010 at 5:10 pm

    […] but neither does any other -first.  His results are really not surprising.  We already know that the sequence of topics in a curriculum doesn’t really seem to make much difference in the learning — that’s how […]

    Reply

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Trackback this post  |  Subscribe to the comments via RSS Feed


Enter your email address to follow this blog and receive notifications of new posts by email.

Join 10,184 other followers

Feeds

Recent Posts

Blog Stats

  • 2,039,339 hits
November 2010
M T W T F S S
1234567
891011121314
15161718192021
22232425262728
2930  

CS Teaching Tips


%d bloggers like this: