On May 12, 5:29 pm, Frank Kotler <fbkot...@xxxxxxxxxxx> wrote:
Now, at a pedagogic point of view, time will tell if they are worthy
or not, but it would be a big surprise to me, if, in "more than two
weeks of install problems", your "Munawwar" could not have learned
more than with the HLA shits in two years. In fact, they are written
as "twelve hours" lessons, and a problem that i am utterly unable to
evaluate, is how long it could really take to a pure beginner to make
these bases clear in his mind.
So you need a test newbie. Preferably a flock of test newbies. You know
what they say about honey vs vinegar...
When he does this, he's going to discover real quick the problems with
his approach. I briefly looked at lesson 1 a while back and almost
died laughing. The problem with these tutorials is that they look good
*to someone who already knows assembly language*. I'm glad you've
posted the first tutorial, I'll help Rene out a little bit by
annotating the tutorial and what's wrong with it.
First of all, let's talk about the audience for this tutorial:
1) Is it someone who already knows another assembly language and wants
to learn RosAsm?
answer: probably not. Rene has claimed it is for "beginners" and
someone who already knows another assembler wouldn't really qualify as
2) Is it someone who has already learned how to program in a HLL and
now wants to learn assembly?
answer: again, probably not. Rene tells us that learning assembly
language is easier than learning a HLL, and that people shouldn't
bother with HLLs.
That leaves us with...
3) Is it someone who has never programmed before and wants to learn
programming using assembly language?
answer: this would be the audience that Rene's past posts would
I could *really* rail on this tutorial if it was truly targeted at
group (3). However, the tutorial is a complete non-starter as an
introduction to programming, so I'll assume that the target audience
is group (2), that is, people who already know how to program in some
HLL and now want to learn assembly language programming.
* Run the Assembler and [Open] this file to read its Source.
* Then, compile and execute it, by depressing [F6]
Fuck, this refuses to copy/paste! Must not like the CRs (Unix is
brain-dead that way... dos'll tolerate *not* having 'em. Lemme strip
that... That's better... Still some "funny" characters in there...
Right off the bat we're messed up here.
Most people think that EXEs are *executable* files, not source files.
Strike one for RosAsm's proprietary source format that they cannot
open with any editor and isn't immediately recognizable to a normal PC
user as a source file.
It would also help if, prior to this point, there was *some*
explanation of how to use the editor, the menus, stuff like that. A
*pure text* explanation of the system would be most helpful here.
Lesson 1: The Generic Syntax of the Tutorials.
; (This is a Mono-Line Comment).
(This is a Multi-Line Comment).
Notice there is no explanation of how this multi-line comment ends.
The above "Main" is the "Entry Point" of the Executable.
What makes "Main" so special?
It *some* HLLs, this might make sense to someone (e.g., C/C++), but in
others this seems a bit abitrary.
When the OS "gives control" to this Executable, this is
the Address where the execution starts. No PE can exist
without an Entry Point.
What is a PE? Why would a programming in group (2) know what this term
means? And as much as Rene grips about AoA being pedantic, the above
is a classic example of pedantism. Why not simply say "this is where
program execution begins" and leave it at that?
Notice that any Label, here, is ending with a Colon (":").
What is a label? What it is used for? In particular (not even
mentioned here), what is a statement label. Keep in mind that many
programmers in group (2) have never before used statement labels. What
is their purpose? And, of course, what is their syntax?
Some Assemblers do NOT require them for the Data Declaration.
Why is "Data Declaration" brought up at this point? The label above
has nothing to do with data declarations. This sentence would be
completely confusing to someone who didn't already know assembly
What a Label is: Nothing but a Location in Memory.
Another term ("memory") brought up out of the blue with no
explanation. What's a "location"? What's "memory"?
words: An Address.
What's an "Address"?
The Assembler takes care of translating
each Label Name into its Numerical Address counterpart.
What relationship is there with Labels, Numerical Addresses, and
Memory Locations? This would be incredibly confusing to a beginner.
Therefore the name of any such Assembler: A "Symbolic
Yet a new term gets thrown out without explanation: "Symbolic".
Nowhere was the term "symbol" or "symbolic" used prior to this point.
It's a bit of a stretch to expect a beginner to realize that a "label"
is the same thing as a "symbol" and that a "symbolic assembler" is one
that uses labels. And why is using labels important? What's the
alternative? Nowhere was this explained.
Now, hit [F6] (compile & execute in Debugger mode) and then
read the downward Block of Comments. See you soon. :)
It sure would have been nice to inform the beginner that this ";;"
ended the block of comments.
Okay, this is the *first* time the beginner has played around with
assembly language. They're going to know what the above statement
means? Once again, this is an example of "this is a tutorial for
people who already know assembly language programming, not a tutorial
for beginners." For all the beginner knows, this is a statement that
invokes some telephony code to make a phone call.
Absolutely no explanation of the above statement. Brilliant. Beginners
are supposed to figure out what this is doing?
; The Dialog you see now, aside, is the integrated Sources
; level Debugger.
nop ; Here, hit [F8] ---> Stepping mode...
What is a "nop"? What is a "stepping mode?" What should they expect
to see? Why are they doing this?
What does the above mean? What is its purpose in the source file?
'int3' just halts the Application, so that you could follow
its execution step by step [F7] and/or [F8], with the help
of the Debugger.
Why wasn't this put up above with the int3 instruction?
'nop' is an Instruction doing nothing at all.
What is an "instruction"? Why wasn't this put *before* the NOP. Why
don't you explain the mnemonic ("no-operation") so that it makes
It is there
to allow you the time of setting the Debugger window at a
position where you could read this Tutorial.
Is that the only purpose for NOPs?
For doing so
in a comfortable manner, redefine also the main window
position, by using [Tools]/[Configuration]/[Pos]. Select,
first, the most appropriate Font... Done?
Where did you explain what text like "[Tools]/[Configuration]/[Pos]"
Now, hit [F8]: This will tell the Debugger to execute the
File down to the next Instruction, as you have hit [F6]
previously, for running in Debugger Mode.
The above is not an Assembly Instruction, but an indication
forcing the Assembler to execute a Pre-Parser assuming
alternative Syntaxes besides the default one, which default
What the *hell* is a "Pre-Parser"? Understand one thing, Rene, this is
a made-up term. It doesn't make any sense to anyone. What is an
"alternate syntax"? What is a "default syntax"? Why should the user
mov eax D$MyData ; Hit [F8]. Look at the Debug-View.
What the heck does this do? You've thrown out yet another machine
instruction with absolutely no explanation of what it does. What does
all that syntactical crap mean, anyway?
What is EAX? Oh, you've forgotten to mention things like registers.
You've also forgotten to discuss things like bytes, words, and dwords,
which is necessary to understand what the statement above is doing.
And, of course, you're using a memory variable without explaining how
to declare them, what they are, how to access them, etc.
; Try to find by yourself why the value of EAX is now 01F8.
What is 01F8? It seems that you've forgotten that most beginners don't
know what hexadecimal representation is. And even the few that do
would likely expect a different syntax than you've provided.
; With above Pre-Parser command, we can also write as well:
mov ebx D[MyData]
mov ecx DWORD[MyData]
mov edx DWORD PTR[MyData]
Why would someone care at this point? What is the purpose of all the
above? And is EAX the same thing as EBX, ECX, and EDX? According to
what you've written, they could be. Once again, you're presenting a
lot of heavy material without any explanation at all.
; In these Tutorials, we will use a very Generic Syntax,
; that will be:
mov eax, DWORD[MyData]
Why? What makes this syntax "generic" versus the other syntaxes? Why
are these syntaxes even considered different? Why even bring this up?
That's all for generic Code.
So, IOW, you've introduced a lot of confusion and then skipped out on
explaining all this stuff you've presented. Beginners will *love*
this. You've basically wasted their time with the above. Just give
them one syntax and ignore all the other stuff.
Let us see, now, the other components of a Source. First,
the Data Declarations.
What is "data" and what is a "declaration"?
You will find different forms in different Assemblers, and,
of course you will have to learn the one you will need for
your finaly chosen Assembler. This is not a big deal, but
notice that this is not the default of RosAsm. Here is the
actual form for these Tutorials:
[MyData: DD 01F8]
What dos this mean?
Again, what is 01F8?
What is "DD"?
For that matter, what is "MyData:"? For all the beginner knows, this
is syntax you have to use to begin a "data declaration". Nowhere have
you explained that this is a user-defined label, or what a label is
(syntactically), and so on.
; Whereas the usual RosAsm default would be the unified:
[MyData_2: D$ 01F8]
Why would they care?
If you're going to "sell" RosAsm, just stick to the RosAsm syntax. All
you do with this syntax-switching is create confusion for the
Now, the Equates:
What is an "Equate"?
When developing, it might really increase
a lot the readability, by adding a couple of User-Equates.
That doesn't tell the beginner *anything*. It might make sense as a
software engineering statement once the user knows what an equate is,
but it certainly isn't a definition of an equate.
[DONE = 1]
mov eax, DONE
What does this do? And why doesn't this "mov" statement (whatever
'mov' does, the beginner doesn't know because you haven't defined it
yet) do differently from the one with the DWORD and brackets?
; Notice that the usual RosAsm Form would be:
mov eax, NOT_DONE
Again, why do you insist on confusing the beginner by throwing around
multiple syntaxes? If you want to SELL RosAsm, stick to RosAsm
Notice also that RosAsm includes, for free, more than 63,000
Win32 Equates, that can be invoked, at any time, without any
previous declaration, in the form of:
mov eax, &TRUE ; Right-Click upon "&TRUE"...
Why would they want to do this? Why does the "&" have to appear here?
What's the difference between the "&", the "$", and the lack of
either? How is the beginner supposed to figure this out?
With the other Assemblers, you will have to define some
"Include" headers Files before having this enabled.
You make this sound so bad... :-) Keep in mind that most of the
beginners coming from group (2) are already going to understand what
an include file is all about. A statement like this is going to make
them question the quality of this tutorial.
The Macros: This is the point where all Assemblers differ
the most from each others. So, we are going to avoid them
as long as wishable, here, in order to focus on the
Assembly Language itself.
So why even mention them, then?
Again, you're tossing out extra information that serves no purpose
other than to create information overload in the beginner's mind.
Nevertheless, let us create a couple of very small and very
usual ones, that will make the reading easier:
Whoa! You just said we weren't going to use them and then turn around
and use them anyway. Way to go. You've just made the tutorial
irrelevant to a lot of people.
[push | push #1 | #+1] ; Multi-pushes.
What is a push? Why would use use it?
What is a macro? What does the above mean? Why would you want "multi-
pushes"? What the heck is "#+1"?
[call | push #L>2 | call #1] ; HLL-like forms of calls.
The above looks sufficiently like "line noise" that you'd have a hard
time justifying it in a tutorial for advanced assembly language
programmers. Putting this in a tutorial for beginners is insane.
Especially as you offer no explanation for what it means.
What does the "push 0" mean? Why does this call instruction look
different from all the others in this tutorial? What does a call do?
(You still haven't explained that.)
After execution of the above call, as you have seen, the
Debugger is closed.
Do not type [F8] anymore, because it would draw a Separation-
Line inside this Source. If you do... hit [Ctrl][Z] as many
times as needed:
Why does [F8] do different things in the program?
Now, re-read it all, down to the end, and make sure you have
understood all the explanations.
Except that there is little in the way of "explanations".
Don't refrain from playing
the fool with this Tutorial: Even in case you would succeed
to destroy it completely, you still have the zip, don't
Exactly what is it you expect them to do? At this point, they probably
feel like a "fool" because they don't have a *clue* what just happened
in this program.
; With the above Macro, we could have written, as well:
call 'KERNEL32.ExitProcess', 0
Why is this?
; Double-Click upon 'call', and select [Unfold]...
This 'ExitProcess' is a Function of the OS (in 'KERNEL32.DLL,
exactly), whose job is to terminate the Program's Execution
(Process End, Handles closure...).
Finally, an explanation of what that call does. This should have
appeared *before* the actual call instruction. Generally, it's a good
idea to define terms before their use. The few valid explanations that
appear in this example violate that principle.
What is this and what connection does it have with the rest of the
program? In particular, you never did explain what the "call RunMe"
The RosAsm Sources Editor includes a Right-Click feature,
whose Functionalities depend on what you have chosen to
click upon. Go to the Top of this Source and Right Click
upon 'RunMe:': See you soon, again... :)
Perhaps it would help a little bit if you explained what they should
expect to see. Beginners are a bit insecure about "clicking on things"
without knowing what to expect.
If you are here after right clicking upon "RunMe", right
click again in a Blank area of the Source, and the Editor
will get back to its initial position.
What's a "Blank area"?
The next Code verifies that the Tutorial is executed in
Debugger mode, and not 'Stand Alone', as long as it does
not do anything special, and would hang, of course, because
of the wild "int3", not being under the Debugger control.
What is a "wild int3"?
So, we have to tell the user what to do, in that case:
; 'GetCommandLine' returns a pointer to the Command line in EAX.
What is a "pointer"? Whta is a "command line"? What is "EAX"? What is
; We now scan this Command line, down to the end:
L0: inc eax
cmp BYTE[eax], 0
What the heck does all that mean? This is a lot of sophisticated code,
well beyond what a beginner going through the first tutorial would
even begin to understand? Let's see, beyond not explaining what the
three instructions (inc, cmp, jne) mean, you've failed to discuss:
1) local symbols in RosAsm and why they are different from standard
labels (not that you've explained standard labels, mind you).
2) What is the "BYTE" thing? They've seen DWORD before, but BYTE is
3) No discussion of flags, which is absolutely necessary to understand
what this code does.
4) What does [EAX] mean and how is it different from [MyData]?
; <---- You can set a Dynamic Break-Point (Margin Clicks).
cmp DWORD[eax-3], 'Run'
Whoa! What does all of that syntax mean? Things like "[eax-3]" came
right out of the blue. And 'Run' isn't going to make *any* sense to a
beginner. And you've yet to describe what the heck something like
; I use the Macro form, here, for my own comfort:
call 'USER32.MessageBoxA' &NULL,
; Right click upon each
What does all of that mean?
I could keep going on and on, but it would be a waste of time.
The bottom line is that this "tutorial" could be read by someone who
already knows x86 assembly language and is wanting to play around with
RosAsm. It is nearly useless for people who've never seen assembly
Rene, you make lots of comments about beginner's questions with
respect to HLA. Trust me on this point -- you *won't* get too many
questions about your tutorials. Beginners will spend a few minutes
with it, decide it doesn't make sense at all, and then move on
elsewhere for their assembly language knowledge. That's really too
bad. It would be fun to see people start asking *you* these questions.
Then you'd know just how well-refined AoA really has become over the
- Prev by Date: Re: URGENT
- Next by Date: Re: writing a compilers
- Previous by thread: Re: URGENT
- Next by thread: Re: URGENT