November 24, 2003

Teaching Computation as an Expressive Medium

by Michael Mateas · , 12:40 pm

I haven’t been blogging much the last couple of months; this semester has been overwhelming. As the semester winds down and I begin blogging again, I thought it would be interesting to reflect on my experiences teaching Computation as an Expressive Medium.

As I described before, this class is a graduate introduction to programming for students coming from arts and humanities backgrounds. It contains a mixture of students in LCC’s Information Design and Technology program, as well as students in the HCI master’s program (many of the HCI students come from non-programming backgrounds). For the theoretical component of the class, I’m using Nick and Noah’s New Media Reader.

The initial syllabus was far too ambitious, both in terms of programming projects and readings. We ended up doing only the first four projects, not six, and reading about half the readings. Class presentation of the programming material took longer than I had initially planned.

It was challenging coordinating the readings with the projects. I tried to coordinate the readings with the conceptual backgrounds of the assignments. For example, while working on Project 3, the “build your own image manipulation tool” project, we read:


For Project 3, the idea was to explore the idea of the tool, how tools create new ways of relating to machines, how tools contain the dreams and biases of the designer and thus constrain as well as enable, and what it means to make your own custom tools. I wanted to denaturalize the notion of the GUI tool. But, even with a conceptual link between readings and projects, I think the urgency and anxiety some students felt about learning to program made it difficult to focus on or think about the readings. If alot of mental energy is going into understanding the difference between Swing component containment (subcomponents) vs. parent-child relationships in the Swing class hierarchy, it’s difficult to think about the historical origins of the graphical user interface and its relationship to cybernetic discourse while connecting this back to the nitty-gritty details of writing code. I still need to find ways to tie the theoretical big picture and the nitty-gritty of code together – I’d love to hear any ideas.

A related difficulty was leading interesting class discussions with the more technical readings. It’s great that the New Media Reader situates so many seminal technical articles within the historical and theoretical framework of new media. But the rhetoric of technical articles, a rhetoric of univocal clarity, makes it difficult to dig below the surface. It’s too easy to read an article such as Man-Computer Symbiosis or Augmenting Human Intellect and say “Yup, it’s amazing how well they predicated the future”, and “Wow, what we have today is still only a portion of their vision”, and “Yeah, he’s a visionary”, and “Oh, I think so too” and so forth. Not exactly a scintillating discussion. Of course what you really want to do is a deep read of the articles, moving below the simple rhetorics of progress to the deeper biases and assumptions being built into hardware and software. But doing this requires bringing in additional historical and critical knowledge (and readings). For example, the discussion of cyborg discourse in the first part of Kate Hayles How we Became Post-Human would nicely situate many of the technical readings. In any event, I need to work harder the next time I teach this class to help students dig below the surface of the technical readings. It’s interesting that one of the best class discussions we had was discussing The Cyborg Manifesto. For many in the class, this was the first time they’d encountered the language of cultural theory. Thus, for some of them, on first read the article was completely incoherent. And this sense of incoherence forced deeper thinking and opened up more avenues into the reading.

I wish there were articles in the New Media Reader about the process of coding itself, about what code is, about the distinction between a program as static writing and a program as dynamic machine, about coding as craft, about the experiential aspect of programming, about debugging as a fundamental part of programming (it’s not a bad, avoidable thing, but a necessary, good thing), about reading code (several levels of the word “reading”). The next time I teach this, I’ll sniff around for readings from the emerging fields of software studies and the theoretical discourse building up around software art. Does anyone have some interesting readings to recommend?

The increment from Project 1 (write a program that reads from and writes to the console) to Project 2 (write a screensaver) was too large. To do Project 1 students had to learn about control flow, working with Strings, and basic text I/O, but didn’t have to necessarily learn about objects, classes and methods. It was possible to write Project 1 entirely within the static main() method of a single class. But Project 2, since it involved using Swing classes, required understanding the Swing class hierarchy (to some degree), creating your own child classes of existing classes, and method overriding. Much of the schedule delay relative to the syllabus came between Project 1 and Project 2 as I struggled to teach all of these concepts. The idea behind the ordering of the projects was:

I’m not sure how to deal with the large increment between projects 1 and 2. One way would be to provide a more developed infrastructure for the students to use for project 2, so the project consists more of small modifications to existing code. But, if I took this route, at some point I’d like them to understand the scaffold and be able to modify it more deeply. When should this occur? Also, the issue of providing framework code is tangled up with another issue; how targeted or open should the projects be?

One of the motivations for teaching programming from an art and design perspective is to motivate programming concepts by teaching them in the context of expressive projects. And, in order to be maximally motivating, the students should define and develop the projects themselves (within some conceptual framework provided by the assignment). But, to the degree the assignment is open, then it is difficult to teach the programming material students need to finish their projects (because there is a such a wide range of skills needed across the range of projects), difficult to ensure that all the students cover some minimal core of concepts, and difficult to provide framework code for all the students to build upon. To the degree that the assignments are highly targeted, one can provide code that everyone is able to modify to accomplish the assignment. But, one of the goals of my course is to introduce students to the dialectical relationship between the craft of programming and developing art and design concepts. Targeted assignments don’t give students enough conceptual room to develop this connection. At the 4S Conference a month or so ago I had a nice lunch conversation with Phoebe Sengers and Warren Sack about teaching programming for artists, at which we discussed this exact issue. Warren said he’s tried both approaches (more targeted and more open assignments) and is still searching for a happy medium. In my class I provided example pieces of code for “typical” things that students might want to do with assignments. Most students built on one or more of these examples, while needing to learn some additional stuff on their own (e.g. how to use some class) to complete their specific assignment. But I still don’t feel like I’ve really found a way to balance these two extremes.

Many students found the Java API documents difficult to understand and navigate. Given the huge wealth of classes provided by the Java runtime, learning to navigate these documents is essential. As I told my class, the trick is not to have to write reams of your own code, but rather to build cleverly on existing code. I tried to model using the docs by doing some programming in front of the class, talking out loud as I moved through the API docs to look up classes and methods, and encouraging the class to interrupt me with frequent questions. I’ve tried to use this model of writing code in front of the class alot, to demystify programming, to show that I need to debug too and to talk through and model how I debug, and to demonstrate that you can get interesting effects in relatively few lines of code. This approach worked for some students but not for everyone. I wasn’t expecting reading the API documents themselves to be such a difficulty – I’m still searching for good ways to teach how to read documentation and code. To help with teaching how to read code, I’ve tried providing heavily documented (i.e. 2-3 lines of documentation for each line of code) code full of my own explanations for how things work. For students who engaged the projects early (spent time just learning the code, playing with it) I think this was useful. I tried to encourage a playful attitude towards the code (like any craft practice, you just have to spend time fooling around well before the project is due), but this didn’t work for everyone. For some students I think more targeted assignments would have been useful (i.e. take this code and change it to do x), but this relates back to the whole tension between targeted and open assignments.

I’d love to hear comments and ideas from anyone who has taught programming for artists and designers.

10 Responses to “Teaching Computation as an Expressive Medium”


  1. Matt K. Says:
    November 24th, 2003 at 4:22 pm

    Michael, I’ve looked at your class material pretty closely and was wondering if you could say something about how both the BlueJ IDE and the Thinking in Java textbook worked out for you.

    Some fiction might be a good way of getting the students to the “deep conceptual” issues you want to discuss–I’d recommend Ellen Ullman’s recent novel The Bug, which is full of programming lore and actual (well, pseudo) code.

  2. B. Rickman Says:
    November 24th, 2003 at 4:29 pm

    Two things you could borrow from eXtreme Progamming: unit testing and pair programming. You might also find some good discussion material in the XP guidebooks, they get a bit dogmatic.

    I would also argue against the desire to appeal to the more visual art students. There’s a lot of mileage to be had out of manipulating strings in a console window. I personally learned a lot of programming skills by building stuff on MOOs.

  3. Francis Hwang Says:
    November 24th, 2003 at 9:54 pm

    I think B. Rickman’s point about pair programming is probably a good one. I was just at RubyConf a few weeks ago and somebody who talked about teaching programming to testers said that pair programming made it much easier for ideas to stick since people could help each other out actively with every little idea. Also, it’s probably quite a bit less intimidating.

    Personally, the best CS class I ever had didn’t ask us to write entire programs, it only asked us to fill in small parts of really impressive programs. One program was a text based virtual reality; we had to program a dog that would walk around randomly and bark from time to time. Another program was a Lisp parser in Lisp; we only had to fill in a few functions to handle a few cases, thank goodness. Not sure if that’s relevant to your case since you’re trying to teach programming as expressive, and I’m not 100% if I know what you mean by that. I always think of programming as pursuing correctness first, and expressiveness second. (Programmers have had an okay handle on correctness for a few decades now; but we’re still working on expressiveness.)

    Programming is bloody difficult, no matter how you conceive of it. Lots of details and only our fuzzy minds to grasp onto them. Maybe that will change in 50 years and I’ll be an old fogey sitting around complaining about spoiled kids. But today I don’t know if a beginning programmer would ever be able to program image manipulation software in a semester. If you find one that can do that, please send me her resume.

    Actually, have you considered using a MOO? That might be the perfect way to learn for a class like this. It’s very social, which kind of adds to the incentive to get better; you’re always programming to impress your classmates. And although you can start out doing simple stuff in MOO code, you can get super-ambitious if you want. Years ago I programmed a Markov-chaining hallucinogen in MOO code.

    Well, it impressed me.

  4. Dennis G. Jerz Says:
    November 25th, 2003 at 12:08 am

    To build on what Francis wrote… I taught a 300-level “Writing Electronic Text” course at my previous job. In that job, I had students sample IF programming, creative web authorship, and informative web authorship. Students then chose a term project from one of those areas, and then we spent more time in each of those areas. Few students chose IF, but I wanted all students to experience IF programming, so I created a simple IF environment that asked students to fill in the blanks and replace boilerplate texual descriptions of objects “You are in a room…” with personalized content — in this case, their childhood bedroom. I then asked them to personalize an object called “Your favorite childhood toy,” and showed them where to add keywords for ‘fuzzy’ ‘brown’ ‘teddy’ ‘bear’ (and so forth). Then I had them compile what they wrote, which involved the personalized room and the personalized toy in a simple game in which a monster emerges from under the bed and grabs the toy. Very simple, but intended to demonstrate how emotionally powerful an interactive environment can be… They learned very little actual programming, but the got the benefit of understanding the power of programming, and at the very least they were more appreciative of the IF selections that we played later on, since now they understood better what actually goes into programming an game.

    I think some of the chapters from “Diamond Age” or a few scenes from “Arcadia” or “PICK UP AX” do a fine job explaining the cultural value of comptuer programming. If that’s what you want to teach them, then giving them almost-complete programs and letting them fill in key parts will free up more of your course time for the kind of advanced critical thinking you probably want to encourage.

    Obviously, moving from my IF examples into a MOO, where students can show off their accomplishments to the group, will likely accelerate the process.

    At any rate, thanks for the summary of your efforts… I’d love to have the opportunity to test my mettle in a class like that.

  5. noah Says:
    November 25th, 2003 at 11:04 pm

    I’ll probably have much more to say later, but I want to jump in now with a few quick questions for Michael.

    First, I think the use you’ve made of The New Media Reader is very interesting. Do you think it would have worked better in a more advanced class (e.g., “Computation as an Expressive Medium III”) or is the combination of that kind of reading with challenging programming assignments just not the right one?

    Second, I’m wondering what you think of the “fill in the content” assignment ideas from the comments above. I’m guessing that, for a class with your goals, they’re too targeted, and remove the space students need to start thinking of the computational structures (and not just the content they “deliver”) as means of expression. What do you think about inverting this, and having given content within a structure where important parameters of how it is presented need to be filled in by students? Or, what if the given is a set of libraries, which the students need to find a way to use creatively? The framework students would need to use the libraries might be pretty similar, while providing for an interesting range of uses. (Obviously, this just brainstorming…)

    Also, I wonder if you might say a bit more about why you chose to teach this course, rather than send students over to one of the existing Intro to CS courses. Certainly having assignments that would motivate students focused on media is part of it — but are there also different concepts to cover, or concepts to cover in a different order, than with most Intro to CS? Also, how do you imagine a course such as this should interface with the CS curriculum? Should a student who has taken Computation as an Expressive Medium skip the normal Intro to CS if they want to take further CS classes?

  6. nick Says:
    November 26th, 2003 at 10:50 pm

    Michael, thanks for your long, informative, and thoughtful post. I delayed because I had so much to say and didn’t know how to start.

    I guess I’ll start by saying that I feared your syllabus was too ambitious, and I hope the class ends up being a good (if frazzling) experience for you and your students.

    I’ve been toying recently with Squeak, a Smalltalk-80 implementation that is very capable in terms of multimedia creativity. I think if I had a course like yours to teach I might consider a programming language that is particularly suited to writing expressive (but potentially complex) programs. Java is nice for many reasons — it’s open, it’s free as in free beer, it’s pretty community-driven for a proprietary language, it’s cross-platform, it’s widely used, etc. But it isn’t made doing what you’re doing with it in class, which is why so much pain is involved in moving from the console to a screen saver. For expressive computing, Squeak and Proce55ing seem like two good candidate languages. Both are pretty widely cross-platform – the Squeak VM runs on at least a dozen platforms and Proce55ing is implemented in Java. Of course, there’s still the question of whether anyone would sign up to learn these “useless” languages which are so well-suited to the educational goal here.

    I can appreciate that the technical paper discussions were tough. One of the ways to read “Man-Computer Symbiosis” or “Augmenting Human Intellect” might involve an implementation of a concept in the article or a project inspired by the article. I think the reason these texts are important is not because they help us critically understand the effects of computerized society the way that Turkle and Haraway do, but because they are frankly visionary. One approach is to critique the masculinist assumptions of these sorts of text, and this is worthwhile, but putting forward non-masculinist alternatives would be an even more interesting way in which to develop such a critique.

    But perhaps a better way to read such a paper is to go through it the way that computer scientists read a computer science paper in a seminar, and to make sure the class understands everything about the system being described in complete detail. This would introduce your students to the way that another discipline deals with scholarship. I suppose this is compatible with the above idea of implementing some of the paper or doing something that is inspired by it.

    I wish there were articles in the New Media Reader about the process of coding itself, about what code is, about the distinction between a program as static writing and a program as dynamic machine, about coding as craft, about the experiential aspect of programming, about debugging as a fundamental part of programming (it’s not a bad, avoidable thing, but a necessary, good thing), about reading code (several levels of the word “reading”).

    It would have been good to include such – although the book is probably a bit more computer-science heavy than the advisory board suggested, as it is! (I plead guilty.) Of course, keep in mind that all of these points about the nature of code and programming are not specific to new media work. I have something on my shelf that I’ve not yet read but that relates to these topics in an unusual way; I’ll see if I can get to that and post about it before too long. But, anyway, these sorts of resources that you mention would generally be good for an introduction to programming, even if expressive computing isn’t the topic. I’ve love to find some to suggest for the intro course that I’m now teaching a section of.

    In closing, I wanted to note that extreme programming is not an educational philosophy and shouldn’t substitute for one, but people have looked into how XP practices work with software engineering education. I think having an educational philosophy is a great deal more important that picking certain techniques from a software development methodology. Pair programming, although I wasn’t able to get it working well in my section, seems compatible with my constructionist/constructivist perspective on education, but it does prevent people from directing their work completely individually in a way that they choose.

  7. michael Says:
    November 28th, 2003 at 5:41 pm

    Michael, I’ve looked at your class material pretty closely and was wondering if you could say something about how both the BlueJ IDE and the Thinking in Java textbook worked out for you.

    BlueJ worked out well as a starting IDE for students. It’s most interesting feature is that it provides a java interpreter so that students can try out lines of code right away. It also provides an object browser that lets you graphically explore an instantiated object, recursively look at the structure of any objects stored in fields, and directly invoke methods on the instantiated object. I taught these features in the first couple of weeks of class; next time I teach this I’ll return to these features halfway through the semester. At the beginning of the class, many people still didn’t understand what an object was well enough to appreciate the object browsing and debugging features. Some of the more advanced students in the class have migrated to other IDEs, either ProjectBuilder (Mac OSX), or Eclipse. Next time I’ll start with BlueJ, then migrate my own useage in class over to Eclipse. That way I’ll model using both IDEs.

    Thinking in Java didn’t work out as well as I’d like. The book assumes too much prior programming experience (though it is a great book for someone who already knows some programming and is now learning Java).

    A couple of people recommended some fiction pieces as a way to get into the culture of programming. One concern I have is that science fiction representations of programming tend to make programming mysteriously easy and glamorous. You rarely see people struggling for days to make their program work, rarely see depictions of the mixture of creative insight, the lost sense of wandering through the desert, “aha” experiences, and frustration that comprise the programming experience. I’ve read reviews of The Bug but haven’t read it myself – I’ll have to check it out. Dennis, I don’t know Arcadia or PICK UP AX, what are they about?

    There’s a lot of mileage to be had out of manipulating strings in a console window. I personally learned a lot of programming skills by building stuff on MOOs.

    Actually, have you considered using a MOO? That might be the perfect way to learn for a class like this.

    I’ve been toying recently with Squeak, a Smalltalk-80 implementation that is very capable in terms of multimedia creativity. I think if I had a course like yours to teach I might consider a programming language that is particularly suited to writing expressive (but potentially complex) programs.

    Last Summer I struggled with the choice of programming language. In 1993 I did some research at Tektronix Labs (when the Labs still existed and had a cool and active HCI research group) on building a collaborative programming space using the LambdaMOO core. My friend Scott Lewis (who went on to do multi-user space work with Electric Communities, at Intel Labs, and at his own startup) and I built an environment where programs were represented by objects within the MOO, the act of programming was represented within the MOO (as physical actions and physical object manipulations) either peripherally (multiple programmers working on objects in the same room who want to be peripherally aware of what the other programmers are up to) or in detail (for programmers in the same room who are actually working on a program together). I’m aware of the expressive power of such text-based spaces and thought hard about teaching programming within a MOO. But I decided against MOOs (and Squeak) because I wanted the students to learn a language (and environment, primarily the API) that is in wide use, that allows them to build “real” things that they can readily distribute, that has massive corporate support in terms of running on everything, that has a huge code base of existing classes to draw upon (not just the standard JDK API, but all the special free API’s made by Sun and others). That is, I want the students to be apart of a large “real world” community of practice, not a small, specialized (albeit cool) community of enthusiasts.

    At Georgia Tech, Mark Guzdial is heavily involved in the Squeak community and has editor and authored a couple of books about Squeak. He has also developed a very successful course called Media Computation that is an undergraduate media-centric introduction to computing using a Java implementation of Jython called JES. He and I have been having some interesting conversations about similarities and differences between his course and mine. We need to continue these conversations.

    Do you think it (the New Media Reader readings – ed.) would have worked better in a more advanced class (e.g., “Computation as an Expressive Medium III”) or is the combination of that kind of reading with challenging programming assignments just not the right one?

    Ideally there would be a two course sequence, one focusing more on the craft of programming, one focusing more on theoretical and historical issues. But this isn’t going to happen anytime soon. I still think the NMR can successfully be used in this course. I just need to do more work framing the readings both historically and relative to the assignments.

    Second, I’m wondering what you think of the “fill in the content” assignment ideas from the comments above. I’m guessing that, for a class with your goals, they’re too targeted, and remove the space students need to start thinking of the computational structures (and not just the content they “deliver”) as means of expression.

    Yes, you are correct. I do want the students to think about the computational structures themselves as expressive. However, some small “fill in the code” assignments might be useful between major projects as a way for students to think about specific coding issues prior to working on their projects.

    Or, what if the given is a set of libraries, which the students need to find a way to use creatively? The framework students would need to use the libraries might be pretty similar, while providing for an interesting range of uses.

    In a sense this is what I am doing, using portions of the standard Java SDK classes as the library (admittedly it’s a large library). I introduce portions of the library with small example programs that I present (and often develop) in class.

    Also, I wonder if you might say a bit more about why you chose to teach this course, rather than send students over to one of the existing Intro to CS courses.

    Most Intro to CS courses focus on teaching a collection of standard algorithms and data structures rather than starting from the perspective of the effect you want to achieve. The Media Computation course I mention above does focus on media, but doesn’t include theoretical and historical readings. It’s also a freshman class – I don’t think any of my graduate students (many of whom are returning students) would enjoy sitting in a class with a bunch of freshman (and with the necessary rather rigid structure that such classes employ). Also, I’ve had several students tell me that they wanted to learn a “real” language like Java. Finally, the CS approach tends to focus on fully understanding each new programming concept before moving on, building up an understanding slowly and methodically. The approach in my course is to throw people into the deep end; it’s the difference between learning a new (human) language through the “learn the grammar and vocabulary” approach vs. immersion. I emphasize playing around with code, focusing on the effects you want to achieve, using various code snippets as magic incantations that make sense after repeated use. It’s like the famous von Neumann quote: “In mathematics you don’t understand things. You just get used to them.” Understanding is just a kind of familiarity. Few of us “understand” our native languages in a rigorous, bookish way (as revealed when non-native speakers stump us with questions about grammar or word usage – we know what’s correct but not necessarily why), though we can still be quite proficient in expressing ourselves. This is the approach to teaching programming that I’m developing.

    I guess I’ll start by saying that I feared your syllabus was too ambitious, and I hope the class ends up being a good (if frazzling) experience for you and your students.

    Yes, it was a bit frazzling for all concerned, but, as the semester comes to an end, I’m generally satisfied with the results. There are a number of students who knew little programming before the start of this class and are now confidently building interesting programs.

    One approach is to critique the masculinist assumptions of these sorts of text, and this is worthwhile, but putting forward non-masculinist alternatives would be an even more interesting way in which to develop such a critique.

    I agree. What I’m interested in is critical technical practice, where a critical, theoretical perspective pans out in a new technical practice. It is the intuitive feeling for a new kind of programming practice that I’d ultimately like students to walk away with. Achieving this for real can’t be done in one class; it requires a whole new curriculum. I’m on committee now that is developing a curriculum for a new, joint undergraduate degree called Media Computation to be offered jointly between the College of Computing and Literature, Communication and Culture. I’m excited about what this curriculum could eventually evolve into.

  8. Dennis G. Jerz Says:
    December 1st, 2003 at 1:00 am

    Arcadia is a Tom Stoppard play that echoes Ada Lovelace in the person of an intelligent but bored 19th century woman who discovers entropy, but it’s mostly interesting as an example of how chaos theory permeated literature, using the Second Law of Thermodynamics as a comment on memory and history. I’ve never seen a production, but it’s a good read. PICK UP AX is a play by Anthony Clarvoe, set in Silicon Valley around 1980, in which the characters discuss D & D and even play an Adventure clone onstage. Here’s a link to a (spoiler-filled) review I wrote: http://jerz.setonhill.edu/if/clarvoe.htm. Note that these creative works have to be interesting to the general public in order to be artistically successful.

  9. Mark Guzdial Says:
    December 1st, 2003 at 4:38 pm

    Michael invited me to respond with more on my class, Introduction to Media Computation. The class draws from students in Architecture, Liberal Arts, Management, and Biology–no Engineers or Computer Science students.

    The focus is Licklider-ish: “Computation for Communication, not Calculation.” We have students implement Photoshop-style filters, splice and reverse sounds, create animations, and generate HTML pages, but all from code, no applications. For example, the code to decrease the red in a picture by 20% looks like this:

    
def decreaseRed(pict):

  for pixel in getPixels(pict):

    value = getRed(pixel)

    setRed(pixel, value * 0.8)

    We very explicitly never do “Hello, World!” (Does anyone really believe that seeing the words “Hello, World!” appear on the screen is motivating for undergraduates?) We start from showing pictures and playing sounds, then move through psychophysics (e.g., why can we break a picture into pixels and it looks okay?), and then do simple data structures, IF conditionals, FOR loops, and the rest. We deal with higher-level CS ideas (e.g., compilation vs. interpretation, abstraction, functional programming, recursion, object-oriented programming) at the end of the class, as a response to student questions, e.g., why is my code always slower than PhotoShop?

    We are working in Jython, a version of Python implemented in Java. Jython gives us Python syntax but with access to the Java media libraries. We constructed our own API on top of Java’s libraries so that our students deal with Pictures, Sounds, and Colors, not BufferedImages and all the rest of the Java classes. We built our own IDE for Jython, called JES (Jython Environment for Students).

    The choice of Python was hard. Like Michael says, students want something “real.” The faculty in these units didn’t like Java (“Is that what you use in your upper division CS classes? Then it’s not appropriate for my freshmen.”) nor Scheme (“Do you know that that’s what they use at MIT?!?”). What sold them on Python was that companies that they recognized, like Industrial Light and Magic and Google use Python.

    We don’t use pair-programming, but we do have a liberal collaboration policy and work hard to create a social setting that isn’t traditional CS. We use a CoWeb (Swiki) a lot, for questions and answers, homework postings, and exam reviews, but also for students to share their created media in Galleries.

    My research is in learning sciences and technologies, so building and evaluating this class is a big part of my research right now. In general, the development of the class is on-going at the MediaComp-plan Swiki (partial papers page). Normally, our intro CS classes have a WDF (Withdrawl or D or F grade) rate of around 28%. In the Spring, our class had an 11% WDF rate, from 211 students originally enrolled, 2/3 of whom were women. This term, we lost only 6 students out of the 309 who enrolled (obviously, no D or F data yet).

    We are hoping to create a graduate version of this course because, as Michael says, graduate students don’t want to sit in on an undergraduate course. The grad version will probably go at a faster pace and include material on building user interfaces.

  10. Michael Says:
    February 5th, 2004 at 10:29 am

    Mary Flanagan and I have been chatting by email about teaching computer science to artists. She gave me permission to post her reactions to my syllabus.

    “The projects seem so ambitious for intro students… I could only imagine the students I have now doing one of these in a semester at an introductory level. Also finding a clever way to target assignments and leave them open is the trick for all teachers but esp art teachers — they have to have room (and impetus) to subvert and push the rules. One of the most interesting classes I ever taught was called 6×1 where students did time based media but all 6 projects could only be one minute long. Formal constraints are one thing in video, audio etc because the technical stuff is relatively straightforward. In Java you would have to do quite a bit of background work to get to a point where you could deal in such formal constraints, and motivating students who are visually or kinetically oriented during that process is an issue.

    This basic stuff is what we are dealing with in the rapunsel project and what I face in teaching college level artists. How do you scaffold the environment/tasks to attract students and actually help them into the process of programming? How do you use students’ natural interests (social networking, for example, or gaming) to design perhaps a system that other instructors could use, or that users could use to teach themselves? So many times I show the stuff I work on for kids and adults humbly come up to me after the talk and ask “could I use that to learn too?” of course they could, but why not make something relevant for adults?”

Powered by WordPress