Re: Another Route to Grade Inflation.

Said  [EMAIL PROTECTED] (Herman Rubin) :

 
>This is a misinterpretation, at best.  Learning to read
>does not require memorization of many words.  Learning
>the properties of the integers does not require skill
>in carrying out the computations; what does the ability
>to do base 10 arithmetic have to do with understanding?
>Why not base 2 or base 16 or base 60?

Because, Herman, we have 5 digits on each hand, not 1, 8 or 30. 

The way we write numbers is decimal because people used hands: One
hand, two hands, three hands, plus four fingers, that's 34. It took a
little bit of lateral thinking to realize that, well, we can give a
number for 10 hands, and for 10 of those, and so on, and the concept
of recursion was born. 

The fact that we can count in base 2, or base 16, is crystal clear to
a musician, for example, but not to many other people: because there's
no solid, intuitive prop like one's hands to recourse to. 

And then, using base 2 or 16 or 60 adds no understanding whatsoever to
the basic issue that arithmetic is about counting - and screw the
base. It's not that 12 + 15 = 27, it's that twelve plus fifteen equals
twenty-seven, and here we have a fundamental truth: ARITHMETIC IS
INDEPENDENT OF THE CONVENTIONS WE USE TO WRITE OUR NUMBERS. So, I find
it a mistake to teach arithmetic based on number bases, because number
bases help us WRITING numbers, but they don't really help us handling
the CONCEPT of addition or multiplication. Number bases are thus well
downstream, and I think it would be a mistake to burden beginners
with that kind of thing. 
  
>One of the posters here claimed to have no problem
>in learning to use variables for numbers, but got
>thrown when they were used for functions.  It is 
>true that this was first done by Euler, about 150
>years after Viete had come up with the essentially
>modern use for arbitrarily many numbers.  But they
>can be used for anything, and we need to use them 
>in "ordinary" language.

You see, any senior computer programmer does that as a matter of fact,
and many of us can't even handle high school math. Point being,
there's got to be an upstream layer that's been ignored when many of
us teach mathematics, and that layer is not conceptual but intuitive.

If you look at a computer program, a function is way more than just a
rule: very few functions we deal with are as simply stated as those we
bump into in your typical mathematics book. Our functions require a
language to be stated, they have conditionals, loops, quantifiers,
complex binding rules, scoping, recursion, typing, and what not - and
yet most programmers can handle it, even those who don't know any
math. Some functions are stated in terms of tables, and it's not that
hard to grok that, down below, any function does nothing but to create
the elements of that table, and the choice then is merely whether we
write the table at compile time or whether we let it be computed
dynamically at run time: and any programmer who deserves his stripes
knows how an array, a structure and a function basically end up being
the same thing. 

Moreover, the way we program today, there's no such thing as a
function f, there's rather a function o.f, where o is an object or a
hierarchy of namespaces, and f is no longer called a "function" but a
"method", and it exists not by itself, but inside a hierarchy of
namespaces. Also, merely stating "function f", or even "function o.f"
is not enough because of polymorphism: we may have function f(x) and
it'll be different from f(x,y): two functions, not one. Also, f(int x)
is not the same function as f(char x), neither is "int f(int x)" the
same as "boolean f(int x)": it's no longer enough to identify
functions by names or even by hierarchy of names, we MUST take their
domain and range well into consideration: to a computer man, a
function is always a triple: a domain, a method and a range. The
method may collapse to zero if we know the pairs upfront and are able
to substitute an array or a structure for the triple (domain, method,
range), and that leaves us with the traditional concept that a
function is a set of pairs. 

None of that is taught in our K12 mathematics courses, yet programmers
handle it naturally and many don't know any of the underlying math.
The conclusion is obvious: there's go to be something out of focus in
the way we teach the stuff in our K12 classes. 


Alberto.