ProgramByDesign
| Company type | Outreach program |
|---|---|
| Industry | Education, Computer Science |
| Founded | January 1995 |
| Founder | Matthias Felleisen and PLT research team |
Area served | United States (initially), expanding nationwide |
| Products | Educational software, curricula, training workshops |
| Parent | PLT research team |
| Website | programbydesign |
The ProgramByDesign initiative, previously known as TeachScheme!, is an outreach program developed by the PLT research team. Its mission is to equip college professors, high school educators, and potentially middle school instructors with skills in programming and computing.
History
Initiated in January 1995 by Matthias Felleisen and the PLT group shortly after the Symposium on Principles of Programming Languages (POPL), the project was inspired by experiences with freshmen at Rice University and observations of local school algebra syllabi. The objective was to leverage functional programming techniques to improve mathematics instruction and incorporate design methodologies into foundational computer science education.
At its inception, the project employed PLT Scheme, a derivative of Scheme, which itself is a dialect of Lisp.
Financial backing came from private foundations, the United States Department of Education, and the National Science Foundation. This funding supported the creation of:
- Software specifically designed for beginners in functional programming
- Educational materials such as syllabi, lecture content, practice problems, and small-scale projects
- Training sessions for educators
Over more than ten years, the project organized numerous one-week training workshops, training close to 550 teachers. A special workshop in 2005 celebrated this milestone by featuring projects led by teachers and completed by their students.
In 2010, PLT updated its main programming language’s name from PLT Scheme to Racket, and changed the IDE from DrScheme to DrRacket. Correspondingly, the initiative formerly called TeachScheme! adopted the new name ProgramByDesign.
Functional programming, computing, and algebra
ProgramByDesign is founded on the concept that students act like computers when engaging with primary arithmetic and secondary algebra tasks—applying rules through exercises that resemble executing purely functional programs.
By guiding learners to develop functional programs on actual computers, the initiative strengthens mathematical understanding via interactive visualizations and game-like activities.
An example in Racket demonstrates an apple falling within a graphical window: <syntaxhighlight lang="racket"> (require 2htdp/universe) (require 2htdp/image)
- generate an image based on time t
(define (create-image t)
(place-image APPLE 50 (* 1/10 t t) SPACE))
- define basic images
(define APPLE (circle 3 "solid" "red")) (define SPACE (empty-scene 100 100))
(animate create-image) </syntaxhighlight> This snippet includes:
- A function named create-image employing an image algebra
- Two variable definitions analogous to algebraic "let" expressions
- An animation command that runs the function continuously
Instructors can describe create-image as a typical algebraic function that maps input values to images illustrating increasing quantities visually.
The animate command executes create-image at a rate of 28 frames per second, producing a sequence of images that simulate motion similar to film frames.
This method requires only fundamental algebra knowledge while introducing students to programming concepts intertwined with mathematics. ProgramByDesign contends that such engaging interactive functions capture student interest more effectively than conventional algebra worksheets.
The program promotes embedding functional programming within math and science education. Unlike traditional languages such as BASIC or Visual Basic blocks, Racket code closely parallels mathematical notation, enabling smooth transitions between mathematical expressions and code. Additionally, DrRacket’s algebraic stepper tool supports comprehension by visually breaking down program execution step-by-step using familiar algebraic reasoning.
Functional Programming, Computing, and Design in Programming 101
The ProgramByDesign initiative advocates that introductory programming education should prioritize a methodical design process over merely teaching the syntax of ephemeral programming languages. This methodology equips learners from various fields with a versatile problem-solving framework.
At the heart of the syllabus lies the design recipe, which encompasses two key aspects: process and data.
Regarding the process aspect, students adhere to six sequential steps before executing any code:
- Examine the problem to identify input and output data categories;
- Restate the problem through a concise purpose statement;
- Develop examples that demonstrate the intended purpose and define success criteria;
- Arrange known elements into a structured template or inventory;
- Implement the program code;
- Construct a test suite derived from examples to verify accuracy.
Echoing principles similar to test-driven development, test cases are formulated prior to coding, integrating them into the requirements analysis phase.
This structured methodology extends beyond software development—for instance, journalists employ analogous procedures when organizing articles, crafting headlines, collecting information, writing content, and verifying facts.
The data aspect is encapsulated by the principle the shape of the data dictates the structure of code and tests. For example, when data types consist of multiple variants or fields, corresponding test scenarios and program constructs (such as conditional statements or recursion) are designed to reflect these variations. Recursion is presented as applying familiar techniques to self-referential data structures rather than being an inherently difficult concept.
Translating givens into templates transforms data descriptions into program frameworks, simplifying coding efforts and allowing focus on inventive design elements.
The primary textbook supporting this approach is How to Design Programs (HTDP), authored by leading members of ProgramByDesign. A third edition is currently being developed.
Programming language choice
Although the title TeachScheme! implies that mastery of the design recipe requires Scheme (now Racket) exclusively, this assumption is incorrect. Members of PLT and their trainees have successfully implemented the design recipe in languages such as assembly language, C, Java, ML, Python, among others, as well as in disciplines like geometry, biology, and poetry. ProgramByDesign stresses programming as fundamentally a design endeavor—a misunderstanding that prompted renaming efforts in 2010.
ProgramByDesign provides three foundational components:
- A sequence of increasingly capable teaching languages—dialects of Racket—aligned with the design recipe, featuring error messages customized to suit learners at different proficiency levels (for example, Beginning Student level flags constructs valid in standard Racket but unnecessary for beginners)
- DrRacket, a free and user-friendly integrated development environment designed for novices that enforces these language levels
- A curriculum largely encapsulated within the book How to Design Programs, with a third edition forthcoming
Their selection of Racket stems from its appropriateness for a small development team operating with limited resources compared to Java, facilitating practical validation of their concepts. The PLT group maintains these ideas’ adaptability across various environments.
For Java
The team recently introduced a second phase of their curriculum that demonstrates how the same design principles extend to sophisticated object-oriented programming languages such as Java. This phase starts with a functional programming approach, then gradually incorporates object-oriented ideas like inheritance and polymorphism, and finally covers idiomatic imperative techniques specific to Java.
Funded by a grant from the National Science Foundation, this program has undergone field testing in both high schools and colleges. Additionally, professional development workshops were held during the summers from 2007 through 2010. Known as ReachJava, this effort is supported by a companion textbook provisionally titled How to Design Classes.
Bootstrap
In 2006, PLT at Northeastern University collaborated with Boston’s Citizen Schools to engage urban youth through after-school initiatives. Citizen Schools facilitates connections between volunteers and program sites using structured curricula. The partnership aimed to tailor the content into a curriculum suitable for sixth graders. Initial trials conducted in Boston demonstrated significant success.
Due to its effectiveness in enhancing mathematics education, the initiative secured backing from Microsoft and Google to expand nationwide. This expansion involved creating teacher training resources and establishing additional program locations in Texas, California, and other regions.