Re: What's the best language to start with? [was: Re: Should I learn C or Pascal?]

["Tim Behrendsen" <tim@airshields.com>]

Peter Seebach <seebs@solutions.solon.com> wrote in article
<4ud8oo$61t@solutions.solon.com>...
> In article <01bb8536$892ee260$87ee6fce@timpent.airshields.com>,
> Tim Behrendsen <tim@airshields.com> wrote:
> >My point is someone who has "vaguely" learned five algorithms has
> >simply memorized them, and learned nothing about the general
> >principles of how algorithms are created.
> 
> Which is exactly what will happen if they code them in assembly; they
> can't possibly be learning how algorithms are created if they start with
> implementing them in a low level language.  Algorithms are generally
written
> in natural languages, and written on napkins.

What? I guess before HLLs nobody "possibly" learned anything.

I don't know about you, but I think about algorithms in terms of
data flow and manipulation.  HLLs or Assembly don't enter into
either.


> The details of which bytes move where are *not* part of the algorithm
itself.

What What?  That's what algorithms *are*!  What are algorithms
if they aren't black boxes that describe a particular output for
a particular input?  I don't know about your I/O, but mine are
in bytes.

> >Truly understanding two algorithms is better than memorizing five
> >algorithms, because that is what *gives" the fundamental
> >understanding.
> 
> But experimenting with the five algorithms, and comparing them, is a
better
> way to truly understand them than implementing them in a difficult
language.

I agree that I would rather have the student experiment with
*anything* rather than just crank out homework assignments with
no thought involved.

We disagree however on the difficulty of assembly.  I think it
is *much* easier, albeit more tedious, than a HLL.

> Sure.  Implementing I/O routines and stacks, *in any language*, is a good
way
> to learn about I/O routines and stacks.  It's a crappy way to learn about
> sorting.
> 
> Further, learning about stacks is bad way to learn about computing;
stacks are
> not a universal implementation of computers.  Students who learn about
stacks
> early on may start assuming that that's somehow a basic truth of
computing.
> They may do things like assert that the addresses of local variables in
one
> function are always lower than the addresses of local variables in a
function
> "above" it on the stack.  Or maybe that should be higher; both kinds
exist.

But that contradicts the C standard.  You're saying that total
ignorance is better than partial ignorance, and I might
even agree with that.  But I don't think it's reasonable to
argue that total ignorance is better than adequate knowledge.

In fact, I might even argue it's better to expose those
mistakes early on, rather than graduate them completely innocent
of these issues, and then when they need to do some assembly,
they pick up the bad habits.

-- Tim Behrendsen (tim@airshields.com)