Re: Rene can't handle AoA's Success

On Jun 18, 12:27 am, Betov <b...@xxxxxxx> wrote:
"r...@xxxxxxxxxx" <r...@xxxxxxxxxx> écrivait news:1182127640.206645.46000
@a26g2000pre.googlegroups.com:

Over in CLAX, Rene wrote:

:))

Why on earth, did not you answered in CLAX, clown?

a. I don't have a whole lot of respect for Chuck Crayne these day.
b. Why pollute CLAX with more of your propaganda?
c. Over in CLAX, if you start going crazy you get moderated and your
posts don't appear. Over here, people get to see exactly how crazy you
are, and that immediately diminishes any respect readers might have
for you.


Have you lost your capacity at duping people with your
politicaly correct and pedantic insanities?

You seem to be the one doing that.


Right, clown: That's the point. Now, if you had thought about
this so evident point, before writing your HLA ***, you would
have saved your victims from having to read tons of dummy Pdfs
for simply understanding what is what. Fact is that, with an HLL
making a clear difference in between what is Assembly and what
is not Assembly, by the grace of some

Asm {

}

... your victims would have _seen_ what is Assembly and what is
not Assembly, at first sight.

You mean, like << call "somekernelroutine", parm1, parm2, parm3 >> ?
Hmmmm...

The problem here, Rene, is that you have demonstrated *over and over
again* your inability to differentiate between and idea and the
implementation of that idea. For example, you cannot tell the
difference between a language and the implementation of a language.
Now, you're demonstrating that you don't understand the difference
between a pedagogy and a tool that a particular pedagogy uses. For
example, there is absolutely *nothing* about HLA that prevents someone
from teaching assembly language in exactly the manner you propose. All
the "high-level" stuff you discuss can be just as easily avoided in
HLA as one could avoid all the macros and "high-level calling"
sequences present in a typical RosAsm program.

What you are really complaining about is the pedagogical method that
the "Art of Assembly Language" uses. For some reason you cannot seem
to comprehend the difference between AoA and HLA in your own mind.
Allow me to clue you in -- should you ever come up with some "12 steps
tutorials" that actually work, it would be *trivial* to convert the
same thing to HLA. Using the same instructions. Using the same "Bottom-
Up" (a complete misuse of that term, BTW) approach. HLA is just an
assembler. It wouldn't prevent the user from doing anything in the
tutorial that could be done with RosAsm.

Now there is no question that there are other pedagogical approaches
to teaching assembly language beyond the one that AoA uses. However,
this "bottom-up" approach you're suggesting is nothing new. It is, in
fact, probably the most traditional way of teaching assembly language:
first one teaches the students some basic machine architecture, then
you teach them about registers, then you teach them about memory and
addressing modes, then you teach them several common instructions,
then you teach them how to put those instructions together to do
simple operations, then you teach them how to create functions with
those instructions and pass data between the functions, then..., then
you teach them how to write applications.

Look at the majority of textbooks on assembly language programming.
They pretty much *all* work this way. Now look at the majority of
programmers in the world who've been through a course taught in this
manner; they:

1. Think assembly is difficult to learn.
2. Think assembly is difficult to use.
3. Think assembly is useless for all but the tiniest of problems.
4. Think people are nuts for using assembly for anything.

If your "bottom-up" approach is so good, why is it that the majority
of the world's programmers who've been exposed to assembly language in
this way think so little of assembly?

I was asking these same questions in 1995/6, while teaching assembly
language programming using a pedagogy not unlike this "bottom-up"
thing you keep talking about. The students hated the approach.
Spending two weeks (4-6 lectures) describing the semantics of the
commonly-used instructions never went over well. At the end of the two
weeks, a student could tell me exactly what a MOV or an AND
instruction did, but they could not tell me how to *use* those
instructions to do anything useful. Students *resented* being spoon-
fed instruction sequences to accomplish things when they couldn't
generate those same sequences by themselves (or even understand how
someone could generate such a sequence of instructions). They
especially disliked the fact that none of their previous programming
experience was helpful when trying to learn assembly language in this
manner. This is the failure of the "bottom-up" approach you're trying
to claim is better. These issues are what led to to develop a new
pedagogical approach, including the design of the HLA language, to
improve the educational process. There is little you've suggested
that I haven't tried in a classroom setting, and seen *fail*.




You're assuming that the beginner is incapable of determining what is
and what is not assembly unless there is an "asm{...}" syntax?

No, clown, i am assuming nothing at all. I am saying that your HLA
*** is evidently not the proper Tool for learning Assembly because
it does not even make any difference in between what is Assembly
and what is not.

Once again, you are confusing the pedagogical approach used by AoA
with the HLA language. Ignoring the fact that when AoA uses a high-
level control construct it prefaces the discussion with "this isn't
true assembly", the fact that AoA leverages the reader's existing HLL
knowledge to help them learn assembly language faster is simply one
approach. If someone, such as yourself, feels that this is the wrong
approach, well, you could use a different approach *and still use
HLA*. You do not have to teach the students about the HLL-like control
constructs in HLA anymore than one has to teach a beginner about the
PREPARSE statement in RosAsm. You could teach all this "low-level
assembly" you're talking about using HLA and sticking to the machine
instructions. Again, you're confusing HLA with the pedagogical methods
AoA uses. Now you're welcome to your opinion that using the
traditional methods for teaching assembly are better, but in my
experience, the approach that HLA uses is much more efficient. At the
end of the course the students are writing more sophisticated
projects, they're using more machine instructions, and they understand
the concepts a whole lot better than students did using the
traditional approach. In my case, I've actually got classroom data to
back up my theories on what is the best way to teach assembly
language. You've got nothing to back up your opinions. Indeed, it
really seems that your opinions are directed more at attacking HLA and
selling your own product rather than trying to have an intelligent
discussion about how assembly language ought to be taught.





Now, i have no doubt that, WITH ENOUGH EFFORTS, a beginner could,
- after having read tons of useless Pdfs -, finaly understand what
is Assembly and what is not Assembly, with your HLL.

In practice, of course, the beginners are finding that it takes *less
effort* to learn assembly language using the pedagogy I've provided.
If it were a whole lot harder than traditional methods, as you seem to
be implying, why would anyone read my stuff? Why would it be so
popular? It's not like there is a shortage of assembly language
programming books -- there are literally dozens of them.

Of course, you've not actually *taught* a classroom full of students
assembly language programming and you certainly haven't tried teaching
students assembly language using several different approaches. I have.
So you'll forgive me if I don't give you a whole lot of respect for
your theories about how assembly language ought to be taught. Go teach
a class full of students sometime. Then you might have enough
experience to be able to make some suggestions about what does and
does not work for beginners.



What i am
saying is that it would have been TIMES easier and faster to achieve
a way better result, with an HLL making visible the difference, in
the notation, in between what is Asm and what is not.

That would make no difference at all. Your puny arguments about
asm{...} are pure nonsense.
hLater,
Randy Hyde


.