Explaining why we reinvent software

June 15, 2010 at 7:08 am 7 comments

Why do we teach students to build the same software that many other people have built before?  Why do we have students build yet another payroll program, or “Hello World!,” or ray-tracing implementation, or fractal tree?  Mostly, these are questions that students have for us about authenticity, but we ask these kinds of questions about ourselves and our own practice too.  There is an on-going debate among data structures teachers about whether it really makes sense to teach students how to build yet another linked list or tree implementation, when almost no one implements their own data structures anymore, and the existing libraries are so good.  I have heard Systems Researchers complain that it doesn’t make sense for academic researchers to build their own operating systems and even compilers anymore, because nobody is going to use anything except Windows, MacOS, and *nix anymore and it’s too hard to compete with the existing offerings.

I heard two answers to these kinds of questions this last weekend.

The first was at the final meeting of our second cohort of Disciplinary Commons for Computing Educators (DCCE) teachers.  I was invited to the meeting last Saturday to hear the teachers (high school and undergraduate) talk about their course portfolios — their reflections on their own practice, assessment, philosophies, successes, weaknesses, and plans for the future.

I hope to post more about the DCCE later, because it was fascinating, but one quote from one teacher particularly struck me.  It was from Bruce Joyce, a teacher educator.

We need to reinvent the wheel every once in a while, not because we need a lot of wheels, but because we need a lot of inventors.

Thus, the point isn’t to build another linked list or tree implementation.  The point is to create people who know how to do those things.  The point of the exercise is to change the student, not create the product.

The second answer came from listening to Bob Edwards Weekend radio show while I cleaned and packed on Sunday. (Got back from Hawaii Thursday, and I’m teaching in Amherst, MA yesterday and today.  Still working on getting to sleep before midnight.)  His guest was Mark Frauenfelder who has just written a book Made by hand: Searching for meaning in a throwaway world. Frauenfelder talks about the complexity of today’s technology discourages people from exploring how to build things themselves, though programming reminds people that “the physical world is also hackable.”  Frauenfelder’s examples of people “making” range from chicken coops to gardens.

He emphasizes the importance of making as a way of changing our relationship with the things in our lives.  Bob Edwards pushed him, and Frauenfelder agreed that making things yourself was more expensive, slower, and resulted in a lower quality product than having an expert make something for you or buying it yourself.

Then why do it?  He had several reasons.  He argued, for example, that something made for yourself can be customized to your needs, and can work exactly the way you want it to.  I didn’t buy that argument.  Not only is it harder to build something ourselves, but I’m less likely to get the specialized parts to work just the way I want.  And how many of us have special needs for our chicken coops or gardens, anyway?  His stronger argument was that we make things in order to change how we think about them.  You don’t appreciate something that you buy to throw away.  You appreciate something differently that you have to work for, that you studied and built by hand.

That argument works for software and students, too.  I can see it with the teachers that I’m working with this week here in Amherst.  Yesterday, I had a teacher who repeatedly found paths to image files on her disk, by invoking the pickAFile() function in Python.  pickAFile() returns a string which is a path to a file.  She kept asking me, “Why isn’t the picture opening?”  I explained that she needed to create the picture from the filename (using makePicture()).  She had a hard time getting the idea of invoking a different function on the file path string, of creating an object, and mostly, of having to do something for herself that her software had always done for her.  By creating the process herself, she was making explicit a process that she had never even noticed before.

For any student in any discipline, most of what one is doing is learning what others have already learned.  Some of the process is re-doing what others have done — not to create something that we don’t already have, or to do something better.  It’s about creating the student, changing the way that the student sees the world.  No, it’s not “authentic” (in the Shaffer and Resnick sense), but it is sometimes necessary to create the kinds of inventors we need in the world, who can build on the shoulders of giants to make the truly new things we need.

Entry filed under: Uncategorized. Tags: , , .

Fred Brooks says that we should pay teachers more Studying Engineering before they can spell it

7 Comments Add your own

  • […] This post was mentioned on Twitter by Alfred Thompson, Doug Peterson. Doug Peterson said: RT @alfredtwo: Best job of Explaining why we reinvent software in school EVER – http://bit.ly/b2vhR1 blog post by @guzdial […]

    Reply
  • 2. James Howison  |  June 15, 2010 at 12:08 pm

    Fascinating topic. I encounter this a lot as I look at scientists programming (e.g. in Physics collaborations or bio-informatics labs). Many of them come to program only as grad students with one programming class (“go learn C++”) thrown into their studies, if they are lucky. Many, I suspect, go on to reinvent wheels and fail to benefit from previous work in the collaboration.

    I’m starting to see how the “start with a blank sheet” method of teaching programming interacts with characteristics of a) the students and b) their work environment, to produce multiple re-implementations. (I don’t, however, think that’s necessarily always a bad thing since its one way of demonstrating correctness).

    By the students I mean understandable tendencies to want to work independently. Seeking others code means interacting with others. Hacking from scratch on one’s own late at night is just easier for introverts. Asking questions in public creates vulnerability that figuring it out on one’s own does not. Knowing something from “first principles” is also a core value in the sciences (and math). Re-using code requires the student to trust others work, always hard when they have to defend the correctness of the analysis to their advisors and beyond.

    Perhaps more importantly the work environment means that reusing code means dealing with issues which are really policy questions above their pay grade, like “do we want to bind our collaboration to this other project/lab?”

    Clearly we want inventors, the innovators, “the crazy ones” 😉 but we also want re-users, software plumbers and team players. And I’d say that the ratio is something like 10:90.

    We also need prose authors, but we don’t teach writing before reading and comprehension … So why teach someone to write code before they can read it?

    Re-implementing underlying things should definitely be an option: but it should be an advanced one, not an introductory one.

    Reply
  • 3. Alfred Thompson  |  June 15, 2010 at 4:00 pm

    Honestly I would like to see more re-inventing of operating systems. Right now it is had to jutufy commercially because of the established base of Windows and UNIX-based operating systems. Linux and MacOX are really basically both UNIX with different windows shells these days. We have some shell experimentation especially for Linux and that is great. But personally I miss the days when I would work on 3 to 4 very different operating systems in the same day depending on the problems I was trying to solve. But when one OS is entrenched and the other is free its hard to get people to look at new directions. There are research projects out there (Microsoft has several and I believe the old Bell Labs people have some) but that’s not really enough. The OS innovation seems to be in haand held devices but even there I’m not sure (I have too little insights into their designs) I worry that we are not straying enough trom the established systems. (Note that I am stating my own opinions and not those of my employer – just for the record – they may well disagree with me.)

    There is innoation going on in programming languages and I think there is a lot of excitment among some students taking compiler courses. And that is great.

    Could “reinventing ” data structures implimentations spark some new ideas? I do hope so and I do see it as possible. It’s hard to know what rules to break if you don’t know the rules though. So seeing the way it is done now may well be a necessary step to opening innovation.

    Reply
    • 4. Erik Engbrecht  |  June 15, 2010 at 11:10 pm

      I think the change is subtler…

      Prior to Linux, the BSDs, and the open sourcing of Solaris; it was hard to try new special OS concepts (I think), because you needed the whole infrastructure. Or you needed to emulate them on a host OS, which isn’t nearly the same as having them run on bare metal.

      Today, if there’s some component you want to swap out with your own you can just do it. Companies do it to optimize for their own products. Hobbyists and researchers do it for their projects. I dare say it’s never been easier to do specialize OS research (I dare b/c I don’t really know, I’m not an OS researcher) because you can just plug your new component it and compare its behavior to the old or a whole host of options.

      But that’s subsystems…lets say you wanted to change the architecture…well..that’s another matter.

      What we have is a situation that rewards local optimization. It could take years…maybe over a decade to build up a real user base on an entire new OS. It can takes months or less for a replacement Linux module.

      So detailed design work gets rewarded while architectural work is…well…not as well rewarded.

      Reply
  • 5. Alan Kay  |  June 16, 2010 at 6:01 pm

    There seem to a few fundamental confusions here. One is between the essential natures of engineering, mathematics, and science. Another is how are they best learned?

    On the side, I think operating systems as they exist now, and have existed since the 60s are a very bad idea. We managed to get rid of them at PARC, but apparently we used the wrong wood for the stake to the vampire’s heart, and they came back from the dead in the 80s (in generally worse and more dangerous form than ever). There’s a Hollywood movie here somewhere ….

    Reply
  • 6. Mike Lutz  |  June 17, 2010 at 3:44 pm

    Feynman wrote of his time at Cornell when a student in psychology (I believe) was chatting with him about her work extending an experiment. She asked him how to proceed, and he told her to redo the original experiment so that she would (a) increase her skills and (b) understand what the experiment’s underlying assumptions more completely – as a prelude to doing her own work. She went back to her advisor, who told her the experiment had been done once; to do it again was to waste time. Feynman was outraged that the psych. professor had so little understanding of science. So there’s one reason for doing the old stuff again.

    A second reason, perhaps, is that this is (was?) the tried-and-true method by which artists and artisans were trained – imitate those who came before you to really learn your craft.

    A third reason: if you want someone to be competent in a new endeavor, you want them to have proven their skills in doing simpler, well-known problems. I assume chemistry departments still have students doing qualitative and quantitative analysis, even though the compounds they work with are purposefully simple.

    Finally, as Mark notes, doing it yourself gives you insight into what’s involved, even if you don’t arrive at the optimal solution. You end up able to truly appreciate what a master is able to do.

    In particular, I’d hate to think of students using hashes, lists, queues, stacks, etc. without a clue as to how the underlying “machine” really works. Without this, how can we expect them work on systems (like those in the cloud) employing very sophisticated data structures and algorithms for replication, reliability, and performance?

    Reply
  • 7. Interesting Links 21 June 2010  |  June 21, 2010 at 5:47 am

    […] Explaining why we reinvent software is a blog post by Mark Guzdial that is the single best job of explaining why we have students write code to solve problems that have been solved and for which libraries exist. IF a student has ever asked “why are you making us write sorts when there are functions to do that already?” this post will help you prepare your answer. Don’t miss it. […]

    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 )

Google photo

You are commenting using your Google 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 9,004 other followers

Feeds

Recent Posts

Blog Stats

  • 1,876,333 hits
June 2010
M T W T F S S
 123456
78910111213
14151617181920
21222324252627
282930  

CS Teaching Tips


%d bloggers like this: