You do not have permission to edit this page, for the following reasons:

This IP address has been blocked from editing Wikipedia.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

The IP address or range 44.197.0.0/16 has been blocked (disabled) by ‪Blablubbs‬ for the following reason(s):

The IP address that you are currently using has been blocked because it is believed to be a web host provider or colocation provider. To prevent abuse, web hosts and colocation providers may be blocked from editing Wikipedia.
You will not be able to edit Wikipedia using a web host or colocation provider because it hides your IP address, much like a proxy or VPN.
We recommend that you attempt to use another connection to edit. For example, if you use a proxy or VPN to connect to the internet, turn it off when editing Wikipedia. If you edit using a mobile connection, try using a Wi-Fi connection, and vice versa. If you are using a corporate internet connection, switch to a different Wi-Fi network. If you have a Wikipedia account, please log in.
If you do not have any other way to edit Wikipedia, you will need to request an IP block exemption.

How to appeal if you are confident that your connection does not use a colocation provider's IP address:
If you are confident that you are not using a web host, you may appeal this block by adding the following text on your talk page: ((unblock|reason=Caught by a colocation web host block but this host or IP is not a web host. My IP address is _______. Place any further information here. ~~~~)). You must fill in the blank with your IP address for this block to be investigated. Your IP address can be determined here. Alternatively, if you wish to keep your IP address private you can use the unblock ticket request system. There are several reasons you might be editing using the IP address of a web host or colocation provider (such as if you are using VPN software or a business network); please use this method of appeal only if you think your IP address is in fact not a web host or colocation provider.

Administrators: The IP block exemption user right should only be applied to allow users to edit using web host in exceptional circumstances, and requests should usually be directed to the functionaries team via email. If you intend to give the IPBE user right, a CheckUser needs to take a look at the account. This can be requested most easily at SPI Quick Checkuser Requests. Unblocking an IP or IP range with this template is highly discouraged without at least contacting the blocking administrator.

This block will expire on 10:52, 20 August 2024.

Even when blocked, you will usually still be able to edit your user talk page, as well as email administrators and other editors.

For information on how to proceed, please read the FAQ for blocked users and the guideline on block appeals. The guide to appealing blocks may also be helpful.

Other useful links: Blocking policy · Help:I have been blocked
Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis. The block was made by ‪AntiCompositeNumber‬. The reason given is Open proxy/Webhost: Visit the FAQ if you are affected .
- Start of block: 13:55, 18 August 2022
- Expiry of block: 13:55, 18 November 2024
Your current IP address is 44.197.119.13. The blocked range is 44.197.0.0/16. Please include all above details in any queries you make. If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy. Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

You can view and copy the source of this page:

((refimprove|date=September 2011))
The '''ProgramByDesign''' (formerly '''TeachScheme!''') project is an outreach effort of the [[Racket (programming language)|PLT]] research group. The goal is to train college faculty, high school [[teacher]]s, and possibly even middle school teachers, in [[Computer programming|programming]] and [[computing]].

==History==
[[Matthias Felleisen]] and [[Racket (programming language)|PLT]] began the effort in January 1995, one day after the ''[[Symposium on Principles of Programming Languages]]'' (POPL), in response to Felleisen's observations of his [[Rice University]] freshmen students and the algebra [[curriculum]] of local public schools. His objective was to use [[functional programming]] to make [[mathematics]] come alive and help inject design knowledge into the introductory [[computer science]] curriculum.

The effort began using a [[programming language]] named PLT Scheme <!-- Renamed, see below. --> which was a version of the language [[Scheme (programming language)|Scheme]], which is a [[Dialect (computing)|dialect]] of [[Lisp (programming language)|Lisp]].

The group raised funds from several private [[Foundation (nonprofit)|foundations]], the [[United States Department of Education]], and the [[National Science Foundation]] to create:
* Software appropriate for novices in functional programming
* Courseware: curricula, lecture notes, exercises, mini-projects
* Teacher training camps

Over ten years, it ran several dozen one-week [[training workshop]]s 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 from ''PLT Scheme'' to ''[[Racket (programming language)|Racket]]'', and ''DrScheme'' to ''DrRacket''. A little later it renamed ''TeachScheme!'' to ''ProgramByDesign''.

==Functional programming, computing, and algebra==
The starting point of ProgramByDesign is the observation that students act as computers in [[primary school]] courses on arithmetic, and in [[middle school]] and [[secondary school]] courses on [[pre-algebra]] and [[algebra]]. Teachers program them with rules and run specific problems via exercises. The key is that students execute purely functional programs.

If students can be turned into teachers that create functional programs and run them on computers, this content can be reinforced and show students how writing down mathematics, and functional programs, creates lively animated scenes and even computer games.

Here is an example:
<syntaxhighlight lang="racket">
(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)
</syntaxhighlight>
This short program simulates an apple falling from the top to the bottom of a small white canvas. It consists of three parts:
* A function definition for create-image, which is a one-line function in mathematics, assuming an algebra of images with place-image, circle, and empty-scene have been introduced
* Two abbreviations, where names are equated with some value, just as in "let x be 5" in an algebra text
* One line for running the program

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 and science courses could benefit from integrating 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.

==Functional Programming, Computing and Design in Programming 101==
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:
# Analysing problems with the goal of describing the classes of data that go into the program and come out;
# Reformulating the problem statement as a concise purpose statement
# Creating examples that illustrate the purpose statement and that serve as criteria for success;
# Organizing givens, also called a template or inventory
# Coding
# Creating a test suite from examples to ensure the program works properly on small inputs.

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 and givens, developing a proposed solution, and checking it against the criteria, in that order.

For example, a journalist benefits from a similar process: figuring out the major concepts in a story; creating a headline; lining up examples and specific data; organizing the article about the story of 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 mysterious and scary, is simply applying already-learned methods 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]] (HTDP) is the text book authored by the core of the ProgramByDesign group.<ref name="HTDP">((cite web |url=https://htdp.org/ |title=How to Design Programs |last=Felleisen |first=Matthias |author-link=Matthias Felleisen |last2=Findler |first2=Robert Bruce |author-link2=Robert Bruce Findler |last3=Flatt |first3=Matthew |author-link3=Matthew Flatt |last4=Krishnamurthi |first4=Shriram |author-link4=Shriram Krishnamurthi |date=2018-01-06 |publisher=MIT Press |access-date=2019-01-08))</ref> A third edition is being prepared.<ref name="HTDP3">((cite web |url=http://felleisen.org/matthias/HtDP3e/ |title=How to Design Programs, Third Edition |last=Felleisen |first=Matthias |author-link=Matthias Felleisen |website=Felleisen.org |access-date=2019-01-08))</ref>

==Programming language choice==
The name TeachScheme! appears to imply that this design recipe requires Scheme (now [[Racket (programming language)|Racket]]) and is teachable only with Scheme. Neither conclusion is true. Members of PLT and their trainees have successfully applied the design recipe in [[assembly language]], [[C (programming language)|C]], [[Java (programming language)|Java]], [[ML (programming language)|ML]], [[Python (programming language)|Python]], and other programming languages, and with geometry, biology, and poetry 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:
* A series of successively more powerful and permissive teaching languages, which are dialects of Racket, matched to the design recipe but with error reporting matched to the student's level (for example, many things that are legal in standard Racket, but which a beginning student doesn't need, are flagged as errors in the Beginning Student level)
* A beginner-friendly, freely-downloadable, pedagogic programming environment, an [[integrated development environment]] named DrRacket, that enforces these language levels
* A curriculum, encoded mostly in the book How to Design Programs,<ref name="HTDP" /> which third edition is in the works.<ref name="HTDP3" />

Their choice of Racket reflects their belief that Racket is a good language for a small team with little funding (relative to Java) to validate their conjectures. The PLT group has always tried to ensure that the ideas remain portable to other contexts.

==For Java==
Over the past few years, the team has also created a second part or phase of the curriculum. It demonstrates how the same design recipe ideas apply to a complex [[object-oriented programming]] language, such as [[Java (programming language)|Java]]. The recipes are applied initially in a functional paradigm, then introducing object-oriented concepts such as polymorphism and inheritance, and then introducing the imperative methods that are idiomatic in mainstream Java.

A part of the team has a grant from the National Science Foundation to conduct 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."

==Bootstrap==
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 nationwide 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.<ref>((cite news |url=http://www.boston.com/yourtown/news/dorchester/2011/05/bootstrap_program_pulls_up_rox.html |title=Bootstrap program pulls up Roxbury, Dorchester middle-schoolers |work=Boston.com |date=2011-05-03 |access-date=2011-09-29))</ref><ref>((cite web |url=http://www.cs.brown.edu/~sk/Publications/Talks/Moby-Bootstrap/ |title=The Moby Scheme Compiler for Smartphones |last=Krishnamurthi |first=Shriram |date=March 2009 |website=Brown University, Computer Science Department |access-date=2019-01-08))</ref> 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.

==References==
((Reflist))

==External links==
* ((Official website|programbydesign.org))
* [http://www.racket-lang.org/ Racket]
* [http://www.htdp.org/ ''How to Design Programs'']
* [http://www.bootstrapworld.org/ Bootstrap]

((Lisp programming language))

[[Category:Computer science education]]
[[Category:Scheme (programming language)]]
[[Category:Java (programming language)]]

Pages transcluded onto the current version of this page (help):

ProgramByDesign (edit)
Template:Ambox (view source) (template editor protected)
Template:Cite news (view source) (protected)
Template:Cite web (view source) (protected)
Template:Find sources mainspace (view source) (template editor protected)
Template:Hlist/styles.css (view source) (protected)
Template:Icon (view source) (template editor protected)
Template:Lisp programming language (edit)
Template:Main other (view source) (protected)
Template:More citations needed (view source) (template editor protected)
Template:Navbox (view source) (template editor protected)
Template:Official website (view source) (template editor protected)
Template:Refimprove (view source) (template editor protected)
Template:Reflist (view source) (protected)
Template:Reflist/styles.css (view source) (protected)
Module:Arguments (view source) (protected)
Module:Category handler (view source) (protected)
Module:Category handler/blacklist (view source) (protected)
Module:Category handler/config (view source) (protected)
Module:Category handler/data (view source) (protected)
Module:Category handler/shared (view source) (protected)
Module:Check for unknown parameters (view source) (protected)
Module:Citation/CS1 (view source) (protected)
Module:Citation/CS1/COinS (view source) (protected)
Module:Citation/CS1/Configuration (view source) (protected)
Module:Citation/CS1/Date validation (view source) (protected)
Module:Citation/CS1/Identifiers (view source) (protected)
Module:Citation/CS1/Utilities (view source) (protected)
Module:Citation/CS1/Whitelist (view source) (protected)
Module:Citation/CS1/styles.css (view source) (protected)
Module:Find sources (view source) (template editor protected)
Module:Find sources/config (view source) (template editor protected)
Module:Find sources/links (view source) (template editor protected)
Module:Find sources/templates/Find sources mainspace (view source) (template editor protected)
Module:Icon (view source) (template editor protected)
Module:Icon/data (view source) (template editor protected)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:Namespace detect/config (view source) (protected)
Module:Namespace detect/data (view source) (protected)
Module:Navbar (view source) (protected)
Module:Navbar/configuration (view source) (protected)
Module:Navbar/styles.css (view source) (protected)
Module:Navbox (view source) (template editor protected)
Module:Navbox/configuration (view source) (template editor protected)
Module:Navbox/styles.css (view source) (template editor protected)
Module:Official website (view source) (template editor protected)
Module:URL (view source) (template editor protected)
Module:Unsubst (view source) (protected)
Module:Yesno (view source) (protected)

Return to ProgramByDesign.

Retrieved from "https://en.wikipedia.org/wiki/ProgramByDesign"