The ProgramByDesign project, formerly known as TeachScheme! project, is an outreach effort of the PLT research group. The goal is to train college faculty, high school teachers and possibly even middle school teachers in programming and computing.
Contents |
Matthias Felleisen and PLT started the effort in 1995 (January, one day after the POPL symposium) in response to observations of his Rice freshmen students and the algebra curriculum of local public schools. His objective was to use functional programming to bring mathematics alive and to help inject design knowledge into the introductory computer science curriculum.
The group raised funds from several private foundations, the US Department of Education, and the National Science Foundation to create
Over ten years, it ran several dozen one-week workshops for some 550 teachers. In 2005, the TeachScheme! project ran an Anniversary workshop where two dozen teachers presented their work with students.
In 2010, PLT renamed its major programming language Racket. At the same time, the group renamed DrScheme to DrRacket and a little later TeachScheme! to ProgramByDesign.
The starting point of ProgramByDesign is the observation that students act as computers in grade school courses on arithmetic and middle/high school courses on pre/algebra. Teachers program them with rules and run specific problems via exercises. The key is that students execute purely functional programs.
If we can turn students into teachers that create functional programs and run them on computers, we can reinforce this content and show students how writing down mathematics and how writing down functional programs creates lively animated scenes and even computer games.
Here is an example:
(require 2htdp/universe) (require 2htdp/image) ;; create an image from the current time (define (create-image t) (place-image APPLE 50 (* 1/10 t t) SPACE)) ;; names for basic images (define APPLE (circle 3 "solid" "red")) (define SPACE (empty-scene 100 100)) (animate create-image)
This short program simulates an apple falling from the top to the bottom of a small white canvas. It consists of three parts:
A teacher can explain create-image as easily as any ordinary function in an algebra course. For example, one can first draw a table with two rows and n columns where each column contains t at the top and an appropriate image at the bottom. That is, if the numbers increase from left to right, then on each image the red dot is a little bit lower.
Finally the animate line applies the given function, create-image, at the rate of 28 ticks per second to 0, 1, 2, 3, and so on. The resulting images are displayed on the computer monitor at the same pace. That's how movies are made.
The background needed for such an example is little more than knowledge about making movies, about the algebra of pictures in DrRacket (which is like the one for numbers), and minimal pre-algebra. The ProgramByDesign project claims, however, that children would have more fun with such "live" functions than with algebraic expressions that count the number of garden tiles [see Prentice Hall books for grades 8-9].
The ProgramByDesign project proposes that both traditional mathematics as well as science courses could benefit from an integration of this form of programming. In contrast to the traditional Basic or Visual Basic blocks in such books, a Racket program consists of as many lines as the mathematics. Moving between the mathematics and the program is thus straightforward. Better still, the meaning of the two are the same. DrRacket's algebraic stepper can illustrate how Racket evaluates the program as if it were a sixth or seventh grade student, step by step, using plain algebra.
For the introductory curriculum on programming, the ProgramByDesign project emphasizes that courses should focus on the role of systematic design. Even if students never program again, they should see how helpful a systematic approach to problem solving is. This should help them whether they become programmers or doctors or journalists or photographers. Thus, an introductory course in programming would not be perceived as a place where students learn about the syntax of the currently fashionable (and soon-to-be-obsolete) programming languages, but a place where they can learn something widely applicable.
The key design element of the ProgramByDesign curriculum is the design recipe. It has two dimensions: the process dimension and the data dimension.
Along the process dimension students learn that there are six steps to designing a (simple) program, before they can run it and others can use it:
Note that, as in test-driven development, test cases are written before coding, as part of requirements analysis, rather than afterward as part of testing.
Almost any human endeavour can benefit from clearly understanding the problem, defining criteria for success, analyzing the available resources/givens, developing a proposed solution, and checking it against the criteria, in that order. A journalist, for example, benefits from a similar process: figuring out the major concepts in a story; coining a headline; lining up examples and specific data; organizing the article about the story around the givens and how the story unfolded; writing; and fact checking.
The data dimension can be summarized by the maxim the shape of the data determines the shape of the code and tests. For example, if the input or output data type has three variants, a test suite should have at least one test case from each variant, and program code will probably contain a three-way conditional (whether explicit or hidden in a polymorphic dispatch). If the input or output data type has three fields, a test suite will have to specify values for those three fields, and program code will have to refer to those three fields. If the input or output data type has a simple base case and one or more self-referential variants, the test suite should include a base case and one or more non-base cases, and the program code will probably have a base case and one or more self-referential cases, isomorphic to the data type. The technique of recursion, rather than being scary and mysterious, is simply the application of already-learned techniques to a self-referential data type.
Organizing the givens is the task of translating the descriptions of data into a program skeleton. Each form of description determines a specific form of program organization. The transformation is nearly mechanical and helps the students focus on the creative part of the task.
How to Design Programs is the text book authored by the core of the ProgramByDesign group.
The name TeachScheme! appears to imply that this design recipe requires Scheme (now Racket) and is only teachable with Scheme. Neither conclusion is true, however. Members of PLT and their trainees have successfully applied the design recipe in Assembly, C, Java, ML, Python, and other programming languages, not to speak of poetry, geometry, and biology courses. The fundamental idea of ProgramByDesign is to stress programming as a design activity. This misconception is one of the reasons for the renaming actions taken in 2010.
To get started the ProgramByDesign project has produced three essential elements:
Their choice of Racket reflects their belief that Racket is a good language for a small team with little funding (in comparison to Java) to validate their conjectures. The PLT group has always tried to ensure, however, that the ideas remain portable to other contexts.
Over the past few years, the team has also created a second part of the curriculum. It demonstrates how the same design recipe ideas apply to a complex object-oriented programming language, such as Java. This phase of the curriculum applies the same design recipe to Java, initially in a functional paradigm, then introducing object-oriented concepts such as polymorphism and inheritance, and then introducing the imperative techniques that are idiomatic in mainstream Java.
A part of the team has a grant from the National Science Foundation for conducting field tests in colleges and high schools. Professional-development workshops took place in the summer of 2007, 2008, 2009, and 2010. This part of the project is dubbed ReachJava; the accompanying book is tentatively titled "How to Design Classes."
In 2006 PLT at Northeastern University and Citizen Schools from Boston made joint efforts to reach out to inner city students with after-school programs. Citizen Schools is a nation-wide organization that matches volunteers with after-school program sites and gets them started with scripted curricula. The goal of the effort is to translate the material into a sixth-grade curriculum. The first few tests were a great success in Boston. [1][2] The effect on the mathematics courses of this program has encouraged Microsoft and Google to fund a national scale-up effort, developing materials for training teachers and creating sites in Texas, California, and other volunteer cities.