 | This article needs additional citations for verification .(September 2011) |
The ProgramByDesign (formerly 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.
Matthias Felleisen and 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 which was a version of the language Scheme, which is a dialect of Lisp.
The group raised funds from several private foundations, the United States Department of Education, and the National Science Foundation to create:
Over ten years, it ran several dozen one-week training 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 from PLT Scheme to Racket , and DrScheme to DrRacket. A little later it renamed TeachScheme! to ProgramByDesign.
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:
(require2htdp/universe)(require2htdp/image);; create an image from the current time(define(create-imaget)(place-imageAPPLE50(*1/10tt)SPACE));; names for basic images(defineAPPLE(circle3"solid""red"))(defineSPACE(empty-scene100100))(animatecreate-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 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.
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:
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. [1] A third edition is being prepared. [2]
The name TeachScheme! appears to imply that this design recipe requires Scheme (now 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, Java, ML, 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:
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.
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. 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."
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. [3] [4] 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.
In computer science, functional programming is a programming paradigm where programs are constructed by applying and composing functions. It is a declarative programming paradigm in which function definitions are trees of expressions that map values to other values, rather than a sequence of imperative statements which update the running state of the program.
In computer programming, a macro is a rule or pattern that specifies how a certain input should be mapped to a replacement output. Applying a macro to an input is known as macro expansion. The input and output may be a sequence of lexical tokens or characters, or a syntax tree. Character macros are supported in software applications to make it easy to invoke common command sequences. Token and tree macros are supported in some programming languages to enable code reuse or to extend the language, sometimes for domain-specific languages.
A computer algebra system (CAS) or symbolic algebra system (SAS) is any mathematical software with the ability to manipulate mathematical expressions in a way similar to the traditional manual computations of mathematicians and scientists. The development of the computer algebra systems in the second half of the 20th century is part of the discipline of "computer algebra" or "symbolic computation", which has spurred work in algorithms over mathematical objects such as polynomials.
Operational semantics is a category of formal programming language semantics in which certain desired properties of a program, such as correctness, safety or security, are verified by constructing proofs from logical statements about its execution and procedures, rather than by attaching mathematical meanings to its terms. Operational semantics are classified in two categories: structural operational semantics formally describe how the individual steps of a computation take place in a computer-based system; by opposition natural semantics describe how the overall results of the executions are obtained. Other approaches to providing a formal semantics of programming languages include axiomatic semantics and denotational semantics.
A graphing calculator is a handheld computer that is capable of plotting graphs, solving simultaneous equations, and performing other tasks with variables. Most popular graphing calculators are programmable calculators, allowing the user to create customized programs, typically for scientific, engineering or education applications. They have large screens that display several lines of text and calculations.
The Centre for Education in Mathematics and Computing (CEMC) is Canada's largest and most recognized outreach organization for promoting and creating activities and materials in mathematics and computer science housed within the Faculty of Mathematics at the University of Waterloo. It was founded in 1995 with origins dating back to the 1960s. Its mission is to increase interest, enjoyment, confidence, and ability in mathematics and computer science among learners and educators in Canada and internationally.
How to Design Programs (HtDP) is a textbook by Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, and Shriram Krishnamurthi on the systematic design of computer programs. MIT Press published the first edition in 2001, and the second edition in 2018, which is freely available online and in print. The book introduces the concept of a design recipe, a six-step process for creating programs from a problem statement. While the book was originally used along with the education project TeachScheme!, it has been adopted at many colleges and universities for teaching program design principles.
Matthias Felleisen is a German-American computer science professor and author. He grew up in Germany and immigrated to the US when he was 21 years old. He received his PhD from Indiana University under the direction of Daniel P. Friedman.
Racket is a general-purpose, multi-paradigm programming language and a multi-platform distribution that includes the Racket language, compiler, large standard library, IDE, development tools, and a set of additional languages including Typed Racket, Swindle, FrTime, Lazy Racket, R5RS & R6RS Scheme, Scribble, Datalog, Racklog, Algol 60 and several teaching languages.
Core-Plus Mathematics is a high school mathematics program consisting of a four-year series of print and digital student textbooks and supporting materials for teachers, developed by the Core-Plus Mathematics Project (CPMP) at Western Michigan University, with funding from the National Science Foundation. Development of the program started in 1992. The first edition, entitled Contemporary Mathematics in Context: A Unified Approach, was completed in 1995. The third edition, entitled Core-Plus Mathematics: Contemporary Mathematics in Context, was published by McGraw-Hill Education in 2015.
QuickCheck is a software library, specifically a combinator library, originally written in the programming language Haskell, designed to assist in software testing by generating test cases for test suites.
Matthew Flatt is an American computer scientist and professor at the University of Utah School of Computing in Salt Lake City. He is also a member of the core development team for the Racket programming language.
The expression problem is a challenge problem in programming languages that concerns the extensibility and modularity of statically typed data abstractions. The goal is to define a data abstraction that is extensible both in its representations and its behaviors, where one can add new representations and new behaviors to the data abstraction, without recompiling existing code, and while retaining static type safety . It exposed deficiencies in programming paradigms and programming languages, and it is still not definitively solved, although there are many proposed solutions.
Statistics education is the practice of teaching and learning of statistics, along with the associated scholarly research.
Racket has been under active development as a vehicle for programming language research since the mid-1990s, and has accumulated many features over the years. This article describes and demonstrates some of these features. Note that one of Racket's main design goals is to accommodate creating new languages, both domain-specific languages and completely new languages. Therefore, some of the following examples are in different languages, but they are all implemented in Racket. Please refer to the main article for more information.
Robert Bruce Findler, colloquially known as "Robby", is an American computer scientist, currently, a professor of computer science at Northwestern University. He is also a member of the PLT group and, as such, responsible for the creation and maintenance of DrRacket. In addition to DrRacket, Findler has contributed numerous components to Racket and supervises its Web-based software library, called PLaneT. Findler is also a leading team member of the ProgramByDesign project.
Bootstrap is based at Brown University (USA), and builds on the research and development done there. Bootstrap curriculum consists of 4 research-based curricular computer science modules for grades 6-12. The 4 modules are Bootstrap:Algebra, Bootstrap:Reactive, Bootstrap:Data Science, and Bootstrap:Physics. Bootstrap materials reinforce core concepts from mainstream subjects like Math, Physics and more, enabling non-CS teachers to adopt the introductory materials while delivering rigorous and engaging computing content drawn from Computer Science classes at universities like Brown, WPI, and Northeastern.
This glossary of computer science is a list of definitions of terms and concepts used in computer science, its sub-disciplines, and related fields, including terms relevant to software, data science, and computer programming.
