Contents - Cultural View
Contents - Cultural View Contents - Cultural View
TeachScheme! 294 TeachScheme! The 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. History 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 • 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 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. The name for DrScheme, the IDE, was changed to DrRacket. Functional Programming, Computing and Algebra The starting point of TeachScheme! is the observation that students are 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:
TeachScheme! 295 • 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; and • 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 TeachScheme! 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 TeachScheme! 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. Functional Programming, Computing and Design in Programming 101 For the introductory curriculum on programming, the TeachScheme! 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 TeachScheme! 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: • problem analysis with the goal of describing the classes of data that go into the program and come out; • the reformulation of the problem statement as a concise purpose statement; • the creation of examples that illustrate the purpose statement and that serve as criteria for success; • the organization of givens, also called a template or inventory; • coding; • and the creation of a test suite from examples to ensure the program works properly on small inputs. 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
- Page 247 and 248: OpenJDK 243 [12] "Open JDK is here!
- Page 249 and 250: PHP/Java Bridge 245 References [1]
- Page 251 and 252: Java package 247 External links jav
- Page 253 and 254: Parboiled (Java) 249 } } return seq
- Page 255 and 256: Plain Old Java Object 251 POJO gene
- Page 257 and 258: Pluggable look and feel 253 Pluggab
- Page 259 and 260: Primitive wrapper class 255 Primiti
- Page 261 and 262: Quark Framework 257 Quark Framework
- Page 263 and 264: Quark Framework 259 has proven to p
- Page 265 and 266: Quark Framework 261 //illustrates p
- Page 267 and 268: Quark Framework 263 As well as LECC
- Page 269 and 270: Quark Framework 265 `catch` (\ex ->
- Page 271 and 272: REPLAY (software) 267 Qualities REP
- Page 273 and 274: Real time Java 269 References [1] J
- Page 275 and 276: Restlet 271 Connectors The list of
- Page 277 and 278: SLAMD 273 SLAMD The SLAMD Distribut
- Page 279 and 280: SLAMD Server 275 SLAMD Server A SLA
- Page 281 and 282: Bruno Souza 277 Bruno Souza Born Na
- Page 283 and 284: Static import 279 References [1] Ja
- Page 285 and 286: strictfp 281 Behaviors and restrict
- Page 287 and 288: Sun Web Developer Pack 283 Sun Web
- Page 289 and 290: Swing (Java) 285 The Swing Architec
- Page 291 and 292: Swing (Java) 287 Relationship to AW
- Page 293 and 294: Swing (Java) 289 } window } See als
- Page 295 and 296: SwingLabs 291 • JDNC [7] : Contai
- Page 297: Synth Look and Feel 293 Supposing t
- Page 301 and 302: TeachScheme! 297 TeachScheme! and B
- Page 303 and 304: Unified Expression Language 299 Imp
- Page 305 and 306: Java Virtual Machine 301 Bytecode v
- Page 307 and 308: Java Virtual Machine 303 Heap The J
- Page 309 and 310: Xerlin 305 • Steinbrenner, Eugen
- Page 311 and 312: XStream 307 } and add some of these
- Page 313 and 314: Article Sources and Contributors 30
- Page 315 and 316: Article Sources and Contributors 31
- Page 317 and 318: Image Sources, Licenses and Contrib
TeachScheme! 294<br />
TeachScheme!<br />
The TeachScheme! project is an outreach effort of the PLT research group. The goal is to train college faculty, high<br />
school teachers and possibly even middle school teachers in programming and computing.<br />
History<br />
Matthias Felleisen and PLT started the effort in 1995 (January, one day after the POPL symposium) in response to<br />
observations of his Rice freshmen students and the algebra curriculum of local public schools. His objective was to<br />
use functional programming to bring mathematics alive and to help inject design knowledge into the introductory<br />
computer science curriculum.<br />
The group raised funds from several private foundations, the US Department of Education, and the National Science<br />
Foundation to create<br />
• software appropriate for novices in functional programming<br />
• courseware (curricula, lecture notes, exercises, mini-projects)<br />
• teacher training camps.<br />
Over ten years, it ran several dozen one-week workshops for some 550 teachers. In 2005, the TeachScheme! project<br />
ran an Anniversary workshop where two dozen teachers presented their work with students.<br />
In 2010, PLT renamed its major programming language Racket. The name for DrScheme, the IDE, was changed to<br />
DrRacket.<br />
Functional Programming, Computing and Algebra<br />
The starting point of TeachScheme! is the observation that students are computers in grade school courses on<br />
arithmetic and middle/high school courses on pre/algebra. Teachers program them with rules and run specific<br />
problems via exercises. The key is that students execute purely functional programs.<br />
If we can turn students into teachers that create functional programs and run them on computers, we can reinforce<br />
this content and show students how writing down mathematics and how writing down functional programs creates<br />
lively animated scenes and even computer games.<br />
Here is an example:<br />
(require 2htdp/universe)<br />
(require 2htdp/image)<br />
;; create an image from the current time<br />
(define (create-image t)<br />
(place-image APPLE 50 (* 1/10 t t) SPACE))<br />
;; names for basic images<br />
(define APPLE (circle 3 "solid" "red"))<br />
(define SPACE (empty-scene 100 100))<br />
(animate create-image)<br />
This short program simulates an apple falling from the top to the bottom of a small white canvas. It consists of three<br />
parts:
Change language