The New York State goals for K-12 math, science, and technology education are here.
Scheme, like most programming languages, provides Boolean values and the operations "and" and "or". Unlike most programming languages, Scheme makes it very easy to experiment with these interactively. If you write down a complex sentence that you expected to come out "true", and the computer says it's "false", you can step through the evaluation to see where your understanding differs from the computer's.
Unlike most programming languages, Scheme supports integers of unlimited size, fractions (automatically converted to lowest terms, either mixed or improper), and "inexact" approximations of real numbers. Students can observe the results of arithmetic on each of these types of numbers; the "inexact" numbers also provide an opportunity to discuss approximation and error.
In my college-freshman classes, I still get students who can't apply order of operations or evaluate a complex expression. Scheme has no order of operations -- everything is fully parenthesized -- so you can avoid that issue while concentrating on others if you wish. Alternatively, you can use the process of translating back and forth between Scheme notation and traditional algebraic notation as a laboratory for studying and practicing order of operations. In either case, DrScheme allows students to step through the evaluation of an expression. The same single-stepping technique can also be used on expressions containing variables, thus illustrating vividly the concept of "variable".
"Develop an understanding of and use the composition of functions and
transformations."
"Combine functions, using the basic operations and the composition
of two functions."
Scheme makes it extremely easy to experiment interactively with functions, composing them in various combinations, and provides a "single-stepping" feature that allows students to observe the steps of substitution along the way.
Scheme also distinguishes between operations on numbers and operations on Booleans (among other data types), so you can illustrate why "(3 < 4) and (5 + 6)" makes no sense. Indeed, identifying and distinguishing data types (e.g. numbers, Booleans, symbols, functions) is central to the TeachScheme design recipes.
Scheme, unlike most programming languages, can operate on symbols (typically words or names) as easily as on numbers or Booleans; students can thus represent non-numeric problems (e.g. the wolf-goat-cabbage problem) as naturally as numeric problems. Scheme also makes it easy to create and manipulate variable-length lists and other compound data types like Cartesian pairs.
More generally, any program is a mathematical model of some portion of reality; its designer must make decisions on which aspects of reality to model and which to ignore (or "abstract away").
"Use graphing utilities to create and explore geometric and algebraic models."
The Scheme implementation we use provides a simple, platform-independent graphics package that allows students to plot points, lines, circles, rectangles, polygons, etc. either directly or under program control. This provides good opportunities to illustrate the geometric meaning of Cartesian coordinates and trigonometric functions.
In the TeachScheme curriculum, every function definition is developed from a word problem using a step-by-step "design recipe" that includes identifying inputs and outputs, giving examples of the function with known correct results, defining the function formally, and testing the formal definition against the known cases to detect errors in its formalization. This design recipe, once learned, applies equally well to the process of converting a word problem to a mathematical representation.
As mentioned above, the TeachScheme design recipes emphasize choosing good test cases with known correct answers, and then testing the function definition to confirm that it produces those correct answers. Testing individual functions is much easier in Scheme than in most programming languages.
Scheme, like most programming languages, provides a random-number generator. Since it's so easy to create new functions in Scheme, students can quickly and easily write simulations of, e.g. rolling a die a specified number of times, or (more fun) a graphical depiction of a random walk. And see above about "exact" vs. "inexact" numbers.
A function can be viewed as a generalization or abstraction of an infinite collection of expressions with similar structure. Scheme makes it extremely easy to define new functions and to experiment interactively with expressions involving them -- indeed, almost everything we do in Scheme consists of defining new functions. Composition of functions can be illustrated directly by using the single-step feature in DrScheme.
Since Scheme is a full-fledged programming language, not just a graphing calculator, it can define functions not only with a single formula but piecewise, by cases (e.g. bank interest, which is typically at different rates depending on balance).
Scheme, unlike most programming languages, allows functions to manipulate other functions as easily as they can manipulate numbers: for example, one could easily write a function that iterates another function (provided as a parameter) a specified number of times, or a function that graphs another function (provided as a parameter) on a specified domain.