A CS1 Course on Media Computation
Working Document Version 3

Mark Guzdial

CS1321 Introduction to Computing is a course that seems most successful aimed at computing professionals: Students who have chosen to major in a computing-related field and who want an intensive introduction to computer science. However, many students on campus want an introduction to computing that prepares them to be professionals in an increasingly technological society. The focus for these latter students is on applications of the computing, with computer science concepts appearing as tools for enabling the applications.

This working document proposes and describes a course that we're currently referring to as CS1315 An Introduction to Media Computation. The focus for this course is on the computer as a tool for communication, through manipulation of digital media. Teaching the skill of programming is an explicit, high-priority goal for the course, and it is taught in the context of creation, transformation, and manipulation of digital media.

CS1315 will be offered as a three credit hour course: 3 hour lecture, and 1 hour required recitation.

The design in this document is based on a review of CS1321, discussions with many, the COE 1361 curriculum1, the ``Imperative-first'' model of a CS1 (introduction to Computing) course as defined by the ACM/IEEE Computing Curriculum 20012, and research literature on CS1 and novice programming. This document is meant to be a living document, frequently being updated in response to more discussions and more elaborated requirements and objectives for this course. This version is based on discussions with many faculty in various units, as well as student feedback via on-line surveys3.


1  Description of the Course
    1.1  Contrasting CS1315 with CS1321
    1.2  Goals for the Course
        1.2.1  Demographic Goals
        1.2.2  Learning Goals
    1.3  Assignments of the Course
    1.4  Language for the Course
    1.5  Teaching Assistants
    1.6  Tour of a Sample Course
        1.6.1  Stage One: First two to three weeks
        1.6.2  Stage Two: Up to Week Nine or Ten
        1.6.3  Stage Three: Up to Week Thirteen
        1.6.4  Stage Four: Last couple weeks
    1.7  Comparison to Other Approaches
2  Implementation Issues
    2.1  Time Frame

1  Description of the Course

CS 1315-An Introduction to Media Computation is an introduction to programming in the context of computer as a media creator and transformer.

The core ideas of the course are:

Students in this course will write programs to do media transformations, creations, and manipulations. We will also talk about digital media and what it means for media to be digital. Some of the content of the course will necessarily be on the media itself, e.g. that a video can be thought of as a collection of frames that are two-dimensional arrays of pixels, that sound can be thought of as a composition of sine waves, etc. Algebra and trigonometry will be necessary pre-requisites to this course.

1.1  Contrasting CS1315 with CS1321

A description of a sample offering of CS1315 appears later in this document. A contrast with CS13214 is useful.

The core idea of CS1315 is to focus on creating concrete artifacts that motivate the learning of abstractions, which come later in the semester. We will cover much of the same programming and computer literacy content as CS1321, plus content on how media are constructed plus some limited Computer Science content. For example:

Overall, we want to go at a slower pace with a concrete, multimedia content focus and a strong focus on really learning to write real programs that the students understand.

The goal is NOT to replace CS1321! With its greater emphasis on abstract, complex algorithms, and advanced data structures, CS1321 has a role with our own majors and with majors from other units that desire a greater emphasis on computer science. CS1315 is more appropriate for students who plan to use computers, but want to understand what they're using and how Computer Science may inform their work in their own discipline.

That said, I would like to see this course be an entrance into Computer Science for students who might not have thought about CS as a career. In general, I want CS1315 to be an attractive class. It may also serve to make Computer Science attractive, too. There are several options here:

This course would integrate well with the various content production courses in LCC's New Media Center. I would very much like to have them (and others) involved in setting up the content goals for the course.

1.2  Goals for the Course

The course is designed to be an introduction to computation for non-majors and to provide an alternative entrance into computer science for students who may find the current courses impossible. The point of the below goals are to be met eventually, and to design the course in order to achieve them, but not to expect them to be met in the first instantiation of the course.

1.2.1  Demographic Goals

I want to define some hard, quantitative goals for the course, along these lines:

1.2.2  Learning Goals

Some of the learning goals for the course will include:

1.3  Assignments of the Course

The idea for the assignments are to take less time than the CS1321 assignments, but while still going in-depth into how software works, giving students ample time to learn to program, providing good assessment opportunities, and providing time to work together. Here are some of my thoughts along these lines:

Here is the current plan:

1.4  Language for the Course

We are currently planning to use the programming language Jython for the course. Jython8 is a variation of the Python9 programming language which has been designed to be easily used by novices and to be a non-technical course. It's used extensively for Web programming, database programming, and ``scripting'' applications. Jython is a variation of Python written in Java-anything written in Java can be integrated with Jython, and Jython can be used for virtually anything for which Java can be used.

Originally we planned to use Scheme, but we've been conducting on-line surveys of students (e.g., ) which suggest that non-majors perceive Scheme to be about ``serious CS'' and not about things that are important to them. Our original reasons for Scheme were the following.

Jython has many of these advantages, and a couple more.

We are also considering other languages, but find them less convincing:

1.5  Teaching Assistants

With the TA structures now implemented in CS1321 (after the review of the CS1321 Task Force), we plan to use a very similar structure in CS1315.

Teaching Assistants (TAs) will be hosting the recitation sections of CS1315, which will involve teaching new material-specifically, the application tools portion of the curriculum. We will want to cap the size of the recitations at 30, with a goal of 25:1 student:TA ratio. In addition, TAs will be responsible for grading, and more senior TAs will be involved in writing assignments, assignment solutions, and supervising/training TAs.

Because the goal of CS1315 will be to serve non-CS-majors, it's going to be important to have non-CS TA's involved:

For all these reasons, we will aim to have 25% or more of our TAs be from outside the College of Computing. However, we will still want the majority of our TAs to be College of Computing students to provide a CS perspective.

As mentioned, we hope that CS1315 and CS1321 can share TA training, hiring, and organizational structure. Our standards (e.g., GPA standards, never been found guilty of academic misconduct, etc.) for TAs will be the same as CS1321.

1.6  Tour of a Sample Course

An elaborated syllabus is beyond the scope of this document, but a tour of what the class might look like would be helpful in explicating the story. I am currently thinking about the class as consisting of four stages.

1.6.1  Stage One: First two to three weeks

The goal of this first stage is to get students programming things that they consider interesting and useful. The argument I'd like to make is based on their use of tools like Photoshop. I might show a before-and-after of an image processed by a Photoshop-like filter. Students could do this with Photoshop, but the application is expensive, you have to learn it, and you still don't really understand what happened, so if you want something more sophisticated or slightly different, you're out of luck. Or you can write these two lines of code (seen below). Of course, you have to know how to write these two lines of code, but once you do, you have a formidable tool in communicating what you want to communicate in the way that you want to communicate. You are not limited to what Adobe or Microsoft says you can say in the way that they want you to say it.

From the very beginning, lectures consist of demonstration to a great extent: 50-75% of class time is spent in the programming environment. Programming is a cognitive skill, and apprenticeship is an excellent way to teach cognitive skills [Collins et al., 1989].

In the first stage of the course, the core language constructs are introduced: defining variables and procedures (only a single user-defined procedure for all examples in these first weeks), function composition, simple conditionals, and iteration as manipulation of a set. The language is introduced from the very beginning in the context of manipulating media.

For example, students might record themselves (using provided audio recording software), then play their sound back with . Variables might be introduced to hold some of those pieces: my_sound = sound(``my-sound.aiff'') play(my_sound)

To continue function composition, we might play the sound at different frequencies, e.g. . The first example of iteration might be exploring the kinds of manipulations that a sampling keyboard does: for freq in [110 220 440 880]: play_at_freq(my_sound, freq)

Another example might use image manipulation. Students might load in a picture with . Once students are told that a picture consists of pixels, pixel values might be changed by defining filters, not unlike Adobe Photoshop, with code like: for p in pixels(my_pic): sethue(p, 2 * hue(p))

Note that we're explicitly making a choice here to focus on a function composition model of programming (e.g., ) as opposed to an object composition model (e.g., ). Jython is flexible in supporting both models. The plan is to start with function composition because it can be used with any programming language, from Visual Basic to Java and MATLAB. Later in the class, we can offer the object notation (common in Java) as a way of doing the same kind of activity but in an object-oriented notation.

Recitations during this initial period will go over the critical infrastructure of the class: How to use email, how to use the Web, how to use the programming environment. In recitations, TA's will use the tools in live, projected displays to demonstrate the tools.

Student assignments in this period will mostly involve editing existing code. We want students to develop the skills of reading code, and modifying someone else's anything is always easier than starting from scratch. Pre-quizzes and quizzes will test student knowledge of their programs. For example, in the last example above, trace out the pixel hue values for a given set of sample data.

1.6.2  Stage Two: Up to Week Nine or Ten

The heart of the course is applying these basic skills in a variety of domains with only a handful of new programming concepts. We want students to feel that they are programmers, that they can do interesting things by combining concepts that they know well. We also want to demonstrate different mathematical concepts that may be useful in other disciplines in the context of programming. Some lecture time will need to be spent on media concepts (e.g., that a sound has a sampling rate, that a pixel has color values), but these are meant to be motivating and interesting.

The new computer science concepts to be introduced are:

Lecture will cover a variety of media types, with new primitives introduced to make simple the manipulation of each media type. Research on novice programmers has found that students really don't have a problem with handling a variety of basic functions and figuring out which ones are needed (e.g., [Perkins et al., 1986][Spohrer and Soloway, 1985][Spohrer, 1989]). The problem is helping the students to understand how to use them in combination.

This actually becomes a human-computer interface problem, and there are solutions for such problems. By choosing primitives that are well-suited for students' tasks, we make it more like for the students to figure out what to use when [Pane et al., 2001].

There are lots of possible media examples to use in this part of the class. Some of the media examples we're considering are described below. The actual ones to be used in a given offering of CS1315 can certainly be dependent on instructor interest and student feedback. I would like for the course materials to include lecture and support materials (e.g., examples worked out, assignment suggestions) for many media types, so that a given instructor could easily pick the media types that interest her.

Student assignments in this section of the course can actually be quite creative and open-ended. The specification of the assignment can define the media types and transformations to be applied, and students can define the details. Some examples:

Recitations in this section will focus on use of applications and on use of the development environment for the assignments. Students will be taught to use Microsoft Word, Microsoft PowerPoint, and Microsoft Excel (for both calculation and graphing). Additional tools might be introduced, and ties will be made between the programming in the class and the relevant media manipulations in the tools (e.g., ``moving to back/front'' in PowerPoint has a lot to do with the ordering of the graphics drawing primitives, which can be a useful example of statement ordering). TAs will also answer questions with example use in the development environment.

1.6.3  Stage Three: Up to Week Thirteen

Now that the students have done a good bit of (interesting) programming, we begin to introduce more advanced Computer Science concepts as a way of making programming easier and more robust. The question to students is how to handle lots of cases without writing code for each one, how to write code in fewer lines so that it takes less time, and how to write code that others can read and understand what you're doing (or you read others' code) so that they can use the same thing. We'll use the exact same media examples, and perhaps a few more sophisticated ones, to explicate the CS concepts introduced in this stage.

Student assignments will involve using these new concepts to manipulate media as previously. There will be an emphasis on creating the same functionality as in the Stage Two assignments, but using these new concepts.

Recitation will emphasize re-iterating the lecture concepts in a small group setting with plenty of examples and time for questions. These are highly abstract concepts. Students will need a lot of time to grok these ideas.

1.6.4  Stage Four: Last couple weeks

Some of our students may actually work in Jython - it is a serious programming language with commercial viability. However, some will want to work in languages like Java. We want the course concepts to transfer out into new contexts [Bruer, 1993]. In Stage Four, we explicitly aim at that transfer into useful contexts.

In lecture, we will introduce Java. Direct comparison will be made between the core programming concepts introduced in Jython (e.g., variables, procedures, function composition, structures, arrays, iteration and conditional constructs, recursion, objects) in the new language, which is made easy since Jython is close to Java in core concepts already. The goal here is not to introduce language constructs specific to Java (e.g., object references or constructors in Java). Rather, we want students to be able to do the exact same kind of programming that they were doing in Jython in this new, more common, but harder language.

Student assignments will involve doing similar kinds of programming as what they were doing previously, but in Java.

Recitation will focus on use of Java. In particular, installation, debugging skills, and practical issues will be the focus.

1.7  Comparison to Other Approaches

The approach that is closest to the one described here is the Exploring the Digital Domain text and course by Abernethy and Allen [Abernethy and Allen, 1998]. The multimedia content of CS1315 is very similar to the Digital Domain course, but the Digital Domain course is without programming.

Most other non-major or Scheme-based approaches to CS1 emphasize computer science concepts without a more concrete focus. The Great Ideas in Computer Science text and course by Biermann [Biermann, 1998] does introduce programming (in small pieces), but doesn't expect the students to program much. The Berkeley non-majors course is in Scheme [Harvey and Wright, 2001] and does offer some fun projects (like tic-tac-toe and Eliza-style pattern matching/interaction), but is mostly about CS abstractions. For example, the course talks a lot about meta-functions like and which are quite complex. The text currently used in CS1321 [Felleisen et al., 2001] emphasizes the design of programs, which could be useful for Engineering students. However, the content of the CS1321 text is clearly Computer Science abstracts: It's not clear how to connect the design of programs to any other kind of design.

There have been other multimedia-focused CS1 courses, mostly for non-majors (e.g., [Marks et al., 2001] [Zimmerman and Eber, 2001]). There was little emphasis on programming in those courses. Probably the closest approach to the one proposed here was the ACSE environment and class in the late 80's [Miller et al., 1994], where undergraduate students learned programming in the context of manipulating multimedia simulations in order to learn about science and programming. (A similar focus was used in Emile [Guzdial, 1995], but with high school students.) While the literature on ACSE says that students ``built'' a lot, we don't really know much about learning in this environment, either about programming or science.

This course will be unique. There are virtually no courses aimed at non-majors, with a focus on concrete applications, that also attempt to teach programming. If successful, it will be an important accomplishment for our students and for CS education.

2  Implementation Issues

This section describes the time frame and costs of this course.

2.1  Time Frame

I am planning this course to take on a serious number of students from the first offerings.

Here is the implementation time frame that I'm thinking about:


[AAUW, 2000]
AAUW (2000). Tech-Savvy: Educating Girls in the New Computer Age. American Association of University Women Education Foundation, New York.

[Abernethy and Allen, 1998]
Abernethy, K. and Allen, T. (1998). Exploring the Digital Domain: An Introduction to Computing with Multimedia and Networking. PWS Publishing, Boston.

[Barker et al., 2002]
Barker, L. J., Garvin-Doxas, K., and Jackson, M. (2002). Defensive climate in the computer science education. In Knox, D., editor, The Proceedings of the Thirty-third SIGCSE Technical Symposium on Computer Science Education, 2002, pages 43-47. ACM, New York.

[Biermann, 1998]
Biermann, A. W. (1998). Great Ideas in Computer Science: A Gentle Introduction. MIT Press, Cambridge, MA.

[Blumenfeld et al., 1991]
Blumenfeld, P. C., Soloway, E., Marx, R. W., Krajcik, J. S., Guzdial, M., and Palincsar, A. (1991). Motivating project-based learning: Sustaining the doing, supporting the learning. Educational Psychologist, 26(3 & 4):369-398.

[Bruer, 1993]
Bruer, J. T. (1993). Schools for Thought: A Science of Learning in the Classroom. MIT Press, Cambridge, MA.

[Collins et al., 1989]
Collins, A., Brown, J. S., and Newman, S. E. (1989). Cognitive apprenticeship: Teaching the craft of reading, writing, and mathematics. In Resnick, L. B., editor, Knowing, Learning, and Instruction: Essays in Honor of Robert Glaser, pages 453-494. Lawrence Erlbaum and Associates, Hillsdale, NJ.

[Felleisen et al., 2001]
Felleisen, M., Findler, R. B., Flatt, M., and Krishnamurthi, S. (2001). How to Design Programs: An Introduction to Programming and Computing. MIT Press, Cambridge, MA.

[Green, 1977]
Green, T. R. G. (1977). Conditional program statements and comprehensibility to professional programmers. Journal of Occupational Psychology, 50:93-109.

[Guzdial, 1995]
Guzdial, M. (1995). Software-realized scaffolding to facilitate programming for science learning. Interactive Learning Environments, 4(1):1-44.

[Guzdial, 2001]
Guzdial, M. (2001). Use of collaborative multimedia in computer science classes. In Proceedings of the 2001 Integrating Technology into Computer Science Education Conference. ACM, Canterbury, UK.

[Harvey and Wright, 2001]
Harvey, B. and Wright, M. (2001). Simply Scheme, Second Edition. MIT Press, Cambridge, MA.

[Margolis and Fisher, 2002]
Margolis, J. and Fisher, A. (2002). Unlocking the Clubhouse: Women in Computing. MIT Press, Cambridge, MA.

[Marks et al., 2001]
Marks, J., Freeman, W., and Leitner, H. (2001). Teaching applied computing without programming: A case-based introductory course for general education. In McCauley, R. and Gersting, J., editors, The Proceedings of the Thirty-second SIGCSE Technical Symposium on Computer Science Education, pages 80-84. ACM Press, New York.

[McCracken et al., 2001]
McCracken, M., Almstrum, V., Diaz, D., Guzdial, M., Hagan, D., Kolikant, Y. B.-D., Laxer, C., Thomas, L., Utting, I., and Wilusz, T. (2001). A multi-national, multi-institutional study of assessment of programming skills of first-year cs students. ACM SIGCSE Bulletin, 33(4):125-140.

[McDowell et al., 2002]
McDowell, C., Bullock, H., Fernald, J., and Werner, L. (2002). The effects of pair-programming on performance in an introductory programming course. In Knox, D., editor, The Proceedings of the Thirty-third SIGCSE Technical Symposium on Computer Science Education, 2002, pages 38-42. ACM, New York. Pair-programming (social) reduces attrition rates.

[Miller, 1974]
Miller, L. A. (1974). Programming by non-programmers. International Journal of Man-Machine Studies, 6:237-260. Participants strongly preferred to use set and subset expressions to specify the operations in aggregate.

[Miller, 1981]
Miller, L. A. (1981). Natural language programming: Styles, strategies, and contrasts. IBM Systems Journal, 20(2):184-215. Languages require iteration where aggregate operations are much easier for novices.

[Miller et al., 1994]
Miller, P., Pane, J., Meter, G., and Vorthmann, S. (1994). Evolution of novice programming environments: The structure editors of carnegie-mellon university. Interactive Learning Environments, 4(2):140-158.

[Pane et al., 2001]
Pane, J. F., Ratanamahatana, C., and Myers, B. (2001). Studying the language and structure in non-programmers' solutions to programming problems. International Journal of Human-Computer Studies, 54:237-264.

[Perkins et al., 1986]
Perkins, D. N., Martin, F., and Farady, M. (1986). Loci of difficulty in learning to program. Technical report, Educational Technology Center, Harvard.

[Resnick et al., 1996]
Resnick, M., Bruckman, A., and Martin, F. (1996). Pianos not stereos: Creating computational construction kits. Interactions, 3(5):41-50.

[Roumani, 2002]
Roumani, H. (2002). Design guidelines for the lab component of objects-first cs1. In Knox, D., editor, The Proceedings of the Thirty-third SIGCSE Technical Symposium on Computer Science Education, 2002, pages 222-226. ACM, New York. WFD (Withdrawl-Failure-D) rates in CS1 in excess of 30

[Soloway et al., 1983]
Soloway, E., Bonar, J., and Ehrlich, K. (1983). Cognitive strategies and looping constructs: An empirical study. Communications of the ACM, 26(11):853-860.

[Soloway et al., 1982]
Soloway, E., Ehrlich, K., Bonar, J., and Greenspan, J. (1982). What do novices know about programming? In Badre, A. and Schneiderman, B., editors, Directions in Human-Computer Interaction, pages 87-122. Ablex Publishing, Norwood, NJ.

[Spohrer, 1989]
Spohrer, J. C. (1989). MARCEL: A Generate-Test-and-Debug (GTD) Impasse/Repair Model of Student Programmers. Ph.d., Yale University. YALEU/CSD/RR 687.

[Spohrer and Soloway, 1985]
Spohrer, J. C. and Soloway, E. (1985). Putting it all together is hard for novice programmers. In Proceedings of the IEEE International Conference on Systems, Man, and Cybernetics, volume March. Tucson, AZ.

[Spohrer and Soloway, 1986]
Spohrer, J. G. and Soloway, E. (1986). Analyzing the high frequency bugs in novice programs. In Soloway, E. and Iyengar, S., editors, Empirical Studies of Programmers Workshop, pages 230-251. Ablex, Washington D.C. Operator precedence errors were among the high frequency bugs observed in novice programs in a traditional programming language.

[Williams and Kessler, 2000]
Williams, L. A. and Kessler, R. R. (2000). The effects of 'pair-pressure' and 'pair-learning' on software engineering education. In Proceedings of the Thirteenth Conference on Software Engineering Education and Training, pages 59-65.

[Zimmerman and Eber, 2001]
Zimmerman, G. W. and Eber, D. E. (2001). When worlds collide! an interdisciplinary course in virtual-reality art. In McCauley, R. and Gersting, J., editors, The Proceedings of the Thirty-second SIGCSE Technical Symposium on Computer Science Education, pages 75-79. ACM Press, New York.




3 and


5 It's not unusual for CS1 classes to have failure rates in excess of 30% [Roumani, 2002].

6 The plan for including collaborative activities is based on research supporting 'pair-programming' effects on retention in CS1 [McDowell et al., 2002] and performance [Williams and Kessler, 2000] in CS1, and on the positive impact of social learning situations for female students in CS1 [Margolis and Fisher, 2002][Barker et al., 2002]

7 One of the problems that are being reported in CS1321 is (from students), ``I type what you did in class, but it doesn't work!'' Obviously, the students didn't, but probably because they didn't see all the detail of what the teacher typed: Non-programmers tend to gloss over quotes, commas, and case. By seeing what they write (not just copy-paste from a workspace), we can see what they are seeing-they can only write down what they see. This gives us a chance to focus on how they read programs and how they understand them.



10 A brief example: The code actually wouldn't compile, because the string 'abc' doesn't understand the message . Precedence is confusing in Squeak.

File translated from TEX by TTH, version 2.25.
On 22 May 2002, 16:26.