Re: Reverse engineering != piracy (was Re: RosAsm disassembler output vs. IDA Pro)

From: Beth (BethStone21_at_hotmail.NOSPICEDHAM.com)
Date: 02/02/04 

Date: Mon, 2 Feb 2004 08:14:06 -0000

The Half A Wannabee wrote:
> I am writing almost a Delphi style like
> application in RosAsm now. Instead of using objects, I use chucks of
data,
> each representing an object, and uses a current pointer for each
type.
> CurrentWindow, Current"ObjectName" etc. and just points them to the
correct
> chuck of data or pass them to the code. It works like firecrackers.
Want to
> see my "main" code :
>
> ********************************* code
> Main :
> call Application_Init
>
> ;Create and show the first window
> call Application_CreateWindow
> call SkinWindow_Show
>
> call Application_Run
> call Application_Done
> ********************************* /code
>
> _*None*_ of it is oop.

Actually, sorry..."OOP" is not defined by what keywords you use, it's
defined by the methods you employ...it's an unusual brand of OOP, for
sure...but you've got "persistent data" and "methods" which access
that data and even, though unusually structured, "this" pointers in
the form of those "Current..." things...

On the contrary, that quite clearly _is_ "OOP"...you don't need an
OOPL or fancy "class" keywords to be programming "OOP"...that stuff is
merely "native support" which helps to make that style of programming
easier...but it's the _style_ of programming that makes it "OOP", not
the language you use...

> But it *looks* like oop and it is just as "modular",
> when I use the verbose names, in combinations with TITLE. I access
the
> virtual memory chunks by offset. I name theese offset verbose, like
this, in
> an equate :
>
> [TSZSkinWindow_Sections 0 ;
> .....
> TSZSkinWindow_HiddenSections 8 ;
> TSZSkinWindow_DropSections 12 ;
> TSZSkinWindow_CombinedSectionRgn 16 ;
> TSZSkinWindow_WindowHandle 20 ;
> TSZSkinWindow_ClientRect 24
> TSZSkinWindow_BoundsRect 28
> ..........
> SizeOf_TSZSkinWindow 32 + X,
> ]
>
> And I access the memory chuck like this ( via edi )

So, you're using virtual method tables or something effectively
equivalent to them? Then, sorry, this _is_ "OOP"...

> Application_CreateWindow:
> ......
> ......
> call 'User32.CreateWindowExA' &NULL ClassName AppName,
> &WS_POPUP+&WS_THICKFRAME,
> 100 100 400 500,
> &NULL &NULL D$hInstance &NULL

I would just point out here that you are using a macro in the line
above; "Call" does not naturally allow parameters to be specified as a
variable-length series of operands...you are making use of one of
Rene's "helper" macros above...

> ;Save the windowhandle into the current TSZSkinWindow_ structure
> mov D$edi + TSZSkinWindow_WindowHandle, eax
> .....
> ....
> ret
>
> My code still doesnt use a single macro.....save push / pop.

Incorrect; You're using a special "HLL" macro in the "CALL" statement
above...a macro which, ironically, serves the same purpose as those in
HLA that Rene and yourself insult...

Now, Rene, what was that you were saying about "newbies" being
"deceived" by "HLLisms"? If Wannabee really thinks he's not using a
macro in the code he posted then you know what's just happened, don't
you?

He thinks - as your tool and your documentation gave him this
impression - that RosAsm's version of the "invoke" macro is a machine
instruction!!! Yes, the very thing you claim that your "precious"
philosophy preaches that it ensures never happens by being
"specific"!!

You've been busted, Rene...one of your RosAsm newbies has just
demonstrated that your "philosophy" simply doesn't work...he clearly
stated that he uses no macros, straight after posting up code that
uses your HLL "invoke" macro...he thinks "invoke" is a machine
instruction!!! The exact example you yourself have used to justify
your philosophy because it avoids this happening...well, clearly, it
doesn't, as we can see right here...sorry, Rene, you're
well-intentioned but we've now seen proof that your "philosophy"
doesn't prevent these newbie mix-ups at all...

> For thoose who have seen Delphi. It _soon_ becomes _as_ simple. I
have
> written the bottom code, and this is the _up_. Works like a charm.
My
> progress have been _faster_ than when I did this with Delphi 3.0 2
years
> ago. And I made the code smaller, faster and simpler, cause I see
clearer
> now, whats going on. And I am still _very_ fresh in assembly.
Because of the
> source code of RosAsm I can learn from, because of the demos and
startlevel
> "baseX.exe"s and simple to follow tutorials that gives short and
excellent
> coding examples to clip in an modify when I need them, access to
directX9
> headers, the works.

Yes; Your work sounds great and impressive...plus, RosAsm really does
supply some great features "out of the box" like that...understand
that none of this comes under any criticism...it's Rene's "philosophy"
nonsense that he spouts...that's the issue..

Although, he's got RosAsm's support up to DX9 now, has he? Very
interesting...

> And the multi instruction lines makes it simple too.

A feature available under HLA too, by the way...in fact, all except
the DX9 headers (which I am working on providing myself because it's
only a matter of typing them out and not some "magic" only RosAsm is
capable of ;) of the things you've used are equally possible in HLA...

No, I'm NOT telling you to use HLA by saying this...please, stick with
RosAsm, you seem to be doing a great job with it...the point, though,
is that it's incorrect to state that none of this is equally possible
in HLA...use RosAsm, enjoy using RosAsm but that does not include
spreading lies, swindles and propoganda about HLA that simply are not
true...the sole thing that would cause you difficulty to do equally
the same thing with HLA is that, yeah, the DX9 headers have not been
finished by myself yet...note, though, that you _can_ perfectly write
your own such headers - just including what you need - with HLA, no
problem...all I'm doing is trying to create a comprehensive set which
Randy can put into the package or as a download or something so that
it's just as easy to start up with that stuff in HLA too...

> It goes with what I am
> doing - having the whole procedure within a screen view. I _write_ a
chunk
> of code, as in any assembler. Then the bunch of instructions come to
a
> *logical* end. So _if_ they fit on a single line, I place them on a
single
> line, each together makes a statement. That statement becomes easy
to
> comment. And whats awsome I think, is that it makes the procedure
smaller,
> and easier to follow.

I repeat, multi-line instructions are available on HLA too...that's
what the semi-colons - ";" - at the end of the instructions are
for...they mark the end of an instruction and you're at perfect
Liberty to stick another instruction directly after that...and so on
and so forth...if you've used C or Pascal (which it sounds like you
have, as you mention Delphi :) then it works just like that...

In fact, you'll find HLA's formatting to be much more flexible because
it basically ignores whitespace and carriage returns completely while
processing a file...the semi-colons are what defines the end of the
instructions only...otherwise, break up an instruction onto multiple
lines, join together lines, etc....

And there's also one unique feature in HLA that none of the others can
do...if you like to put related, logical sequences of instructions
together, then take a look at "instruction composition" under
HLA...for example:

mov (mov(3, ebx), eax);

Which is equivalent to:

mov (3, ebx);
mov (ebx, eax);

Or, in other words, it's roughly like "a = b = 3;" under something
like C...

This, by the way, is _why_ HLA uses those brackets to support
this...these features are all also perfectly available under HLA - in
fact, HLA does more and is far more flexible - it's just that Randy
tends not to write code of this nature because it's less readable for
others when making his examples...it's not that HLA can't do it, it's
just that Randy resists writing code like that for examples other
people have to read because it's more understandable when it's
formatted out in the more traditional "one instruction per line"
way...but HLA doesn't insist on that formatting at all...it's actually
the one that permits the most freedom to write it out any which way
you like...

> They compare to Delphi routines in size. The verbose namings might
seem like
> a pain, but I am used to write verbose from delphi, and it sure
makes it
> easier to know whats going on, when your read it back later.

Yeah, it's no big deal...perhaps Rene could add some "auto completion"
feature so that it recognises what you're typing and then you press
TAB, allowing people to use the longer more meaningful names but only
having to type a few letters for each (only as many letters as it
takes to differentiate which instructions or identifier you want :)...

Actually, I remember something similar from almost twenty years ago on
the C64...as those machines had much less memory, variable names were
only two letters long...or, to be more correct, the machine only
bothered to look at the first two letters but you could type out
longer ones, if you wanted to...well, combine that with "auto
completion" and you'd have long, meaningful names but only have to
type out two or three letters for any variable name, hitting TAB to
get the editor to complete it for you...oh, well...if Rene's not
interested then I'll see if it could be put into LuxAsm instead...

Also, on the C64, there were lots of instruction "shortcuts"...like,
under the BASIC language, typing "?" for "PRINT", typing the first
letter of an instruction and then typing the second letter with the
SHIFT key pressed (which made a funny graphic character
appear)...then, when you typed "LIST" to look back on your code, all
these abbreviations were automatically expanded back out in full for
you...

This is another one of those places where things have actually gone
backwards rather than forwards...things like abbreviations and, for
those tools with standard editors, auto completion and stuff would be
great in that it would allow and encourage long meaningful identifiers
but means the programmer doesn't actually have to constantly type them
out...a variable might be called "CountOfZebrasInTheZoo" but as
there's no other variable starting with "Co..." (there is one that
starts with a "c", though, so we need two characters to distinguish
one variable from another :), the programmer types "co" and then hits
TAB...

Funny, really; I'm the one who doesn't care about speed and yet comes
up with the solution that makes things instant...and I'm the one
perfectly happy to type in really long names, who suggests a system of
"abbreviation"...you just gotta Love that irony, eh? ;)

> I am not claiming RosAsm to be better assembler,

Good...because you'd be wrong if you did...it isn't the worst but it's
equally got as much distance from best too...

> I have seen so few,

That explains a lot; I've used tools of all descriptions on all types
of machines for all different purposes...on the other hand, Randy has
probably forgotten more tools than I've learnt to use...

Don't worry; I know _exactly_ what it is...HLA _looks_ crap...dreadful
name, strange Pascal syntax thing, boring and bland command-line tool,
all that ugly stuff with using MASM or FASM along with it,
etc....yeah, HLA won't win no beauty contest for sure...well, no
_superficial_ beauty contest...even with RadAsm, it's kind of
"cheating" because it's getting a "face lift" from having some other
tool take that place (but, then again, if it _works_, does that
particularly matter? ;)...but under the uninteresting facade - which
it must be stressed is mostly a product of it being a _prototype_ in
its v1.x incarnation...you're only looking at the _experimentation
phase_, not the final thing at all - there lies a _powerhouse_...the
"don't judge a book by its cover" thing applies in full effect with
HLA...

If HLA was ever given the kind of "face lift" by putting an IDE onto
the front (a total possibility to do quite properly and well, once
v2.0 and the "portable GUI library" is completed...not only could HLA
be given that "face lift" but it could uniquely do it on Windows and
Linux (and FreeBSD and BeOS and whatever HLA gets ported to, as time
passes) at the very same time)...

> but Im
> willing to bet, you must look hard to find one so easy to learn, so
capable
> in teaching you assembly.

Easy to learn because it's "point and click", okay...but "so capable
in teaching you assembly"?? Listening to Rene's contradictory
arguments about avoiding "bloat" but insisting that you add "bloat" to
achieve that?? Randy's AoA (either and both 16-bit and 32-bit
versions) is an established text on assembly language that has had a
hundred times more people learn assembly from, than Rene will still
have by the time he puts RosAsm to rest in however many years from
now...due to the grand "levelling" power of an unmoderated newsgroup
(anyone may post anything as and when they feel like), these newsgroup
discussions are probably giving you a false idea of what's actually
going on...

Rene's an ex-builder who, in his retirement, has decided to give this
new "GUI" thing they'd invented while he was off building houses a
try, carrying on with the kind of '60s stuff he used to do before he
went into the building trade but applying it to this "new" frontier of
pointee-clickee interfaces...he's new to this kind of thing and
doesn't quite understand why people started using structures and
things like that...but he was one of the best back in the '60s, so,
sure, he's got the talent to kind of "feel his way" around these "new"
GUI things...in GUI terms, his interface is totally non-standard, a
touch awkward and a bit clunky in places...but, then, hey, you can't
expect this "GUI newbie" to instantly pick up on the lessons everyone
else learnt over the last two decades overnight...for sure, this is
impressive what he's done, considering this is his first attempt at
this kind of thing...

Randy, on the other hand, never left...he's been working with assembly
and programming in general all this time...it's not "new" at all, he
was around while this was all happening and he knows all about
it...he's taught courses and published textbooks respected and used
all over the world...while Rene likes to "feel his way" around
subjects, Randy researches them thoroughly...looking over texts and
examples and stuff from everywhere...yeah, even the boring ones
(there's, unfortunately, plenty of them ;)...he's written tools for
decades and, note, he wrote something very RosAsm-like in the _late
'70s_...because, yeah, he was "new" once too and had all the same
kinds of wild ideas Rene once had...but his knowledge and talent has
moved on from there...by quite a long way...

I may be younger than these two but I started early...grew up with
programming, basically...and I've been around since, say, mid '80s,
following on ever since...I don't find there to be anything at all in
RosAsm that I couldn't do and I'm sure I could easily improve on
it...and 5 years seems an awfully long time - for someone who claims
to work 12 hours a day on it - for what he's actually got there...the
reason why I haven't done anything similar, by the way, is simply time
and inclination...but, then again, with the LuxAsm project, there's a
team involved so that is a prospect I could sign up too...Rene seems
to me like a good assembly coder from the '60s who went away and is
now catching up with the bits "in between" he missed when he was
building houses (a worthy profession which shows he's multi-talented
and has discipline and intelligence)...Randy, on the other hand,
scares me talent-wise (but not personally because he's a nice guy
who's always helpful :)...I tend to think I'm no slouch on these
matters and like to know a little bit about everything...but Randy
makes me look completely and utterly stupid in comparison...in fact,
when Randy doesn't do so well in connecting with "newbies", it's
because of that problem of "he's forgotten far more than you've ever
learnt" kind of deal...generally, I'm impressed that Randy _is_ mostly
able to bring his conversation down to understandable levels...but,
yeah, once or twice I have noticed him perhaps use one too many jargon
words and things like that...it's in avoidance of this thing ever
happening to me in the future that I rigidly try to keep to a "no
jargon, Plain English" policy myself...plus, generally, I find that if
you can't just grab a random person and tailor your explanation so
that _anyone_ can understand it, then you don't know the subject as
well as you think you do and should revise it more...Einstein's "as
simple as possible" thing there...because to "Plain English"
something, you really, really have to _understand_ something to be
able to manipulate it into a simpler form _without_ actually being
incorrect or misleading...I consider that a challenge worth making to
myself because, as I say, if I can manage to do it well then I know
that I really have properly _understood_ a subject...it's a great
little "indicator" you can use on yourself (as, of course, inside our
own minds, we all think we completely understand and know it
all...that's actually rarely the case in reality...so, it's kind of
like looking into a mirror...throw it out and then wait for the echo
to come back...in fact, have you ever recorded your own voice and then
listened back to it? It doesn't sound quite the same as your voice
sounds inside your own head, does it? Well, something similar happens
all the time to everyone in the _way_ they speak as well as how their
voice sounds...you say something and you reckon it makes perfect sense
but everyone else is sitting around scratching their heads
confused...Rene obviously doesn't use a similar strategy to me on this
score because he did that whole "it is clearly defined" thing,
reckoning everyone was able to read his mind or something and knew
exactly what he was talking about...leading to something I still find
hilariously funny that Rene's "clearly defined" ideas were totally and
utterly vague and incomprehensible...like: "you know what I mean" /
"umm, no I don't" / "Yes, you do...because it's all clear to me so it
must be clear to you" / "nope, sorry, no idea what you're talking
about" / "But surely everyone understands this...I know I do" / "Yes,
great...we know _you_ understand this but, for Pete's sake, you
haven't even told anyone what the subject is, even" / "The subject is
clear" / "No! It isn't! What are you talking about?" / "You are
feigning ignorance" / "No, no pretence involved at all...how can I
know what you're talking about when you won't even give us a clue as
to the general topic, let alone any details about this 'clearly
defined' thing" / "How can you not know? I know perfectly well" /
"Yes, we've established that but I'm not you and can't read your mind"
/ "I am having nothing more to do with you because you are playing
games" / "No I'm not!!! Aaaaaarrrrgggghhh! [ starts pulling out hair ]
I give up! Mercy! Mercy! I can't put up with this torture any more!
You win!!" ;)...

> So for a beginner I would recommend RosAsm,
> instead of some of the other monsters.

For some beginners, RosAsm is a good place to start...for others, it
isn't...rather than trying to squeeze all beginners into the same
box - where it won't be the right box for many of them - wouldn't it
be better not to have these "feuds" but to present the case for both
and allow the beginner to try them out and see what they like?

Note, neither Randy nor myself has the slightest problem with people
using RosAsm (so long as they know what they've in for doing that
:)...it's _Rene_ who started this whole "destroy HLA!" propoganda
drive...Randy and myself are _only_ reacting to unfair criticisms,
trying to ensure that Rene's _propoganda_ doesn't get miscontrued by
too many newbies as being factual...because it ain't...

If Rene said nothing, then we'd not only say nothing, we could go back
to how it was originally when, in fact, Randy and me were actually
trying to _help_ Rene for years with suggestions about how to do
things better for RosAsm...it was Rene who pulled the "high and
mighty" act that he thought he knew everything (yet, I've made plenty
of suggestions to Randy which he's looked at and then said "yeah,
actually...that's not a bad idea"...Randy, in a sense, is the one who
has the right to be "high and mighty" but in total contrast, he's the
complete opposite...he takes suggestions and comments happily :)...and
it was Rene who started this "Holy War"...as I've said many times over
and over, my interest is, in fact, towards _ALL_ assemblers getting a
fair hearing, for everyone to work together to improve _assembly
language_ and for this "war" nonsense to end...that is what gets my
back up about Rene's remarks: He's damaging all chances of the wider
promotion of assembly and, yes, even his precious "assembly rebirth"
is being held back the most by _him_, not anyone else...

> And I would be completly safe that
> once they got used to it they would just laugh at MASM and not even
look at
> HLA.

Then they must have been brain-washed...even though I loathe Microsoft
and would urge away from MASM on "principle" grounds, I could not do
too much to attack it on technical grounds...the only real thing on
those grounds is the horrible, horrible inconsistent syntax
nightmare...but then if someone turns around and says "sure, but I'm
used to it" then there aren't any other _technical_ grounds...there's
a million "ethical" and "political" arguments, mind you, but MASM does
actually take a lot of battering that other assemblers can't handle
because they are nowhere near as robust...

And if someone - including Rene himself - is not looking at HLA then,
trust me, it is _they_ who are missing out from not doing so...AoA and
HLA combined are so comprehensive and feature-laden and
well-documented and professional that NOTHING compares to it among the
others...it's in a different ballpark on those points...

> Why would they? By then they allready know! Why waste time on HLL
like
> stuctures and stuff like that. Its not needed ! Doesnt make faster
code,
> takes more time to study it. Pointeless waste of time. Its more than
enough
> to learn what you need for the current job, and motivation is much
higher
> when you need only study whats good to get the current job done, as
oposed
> to read the whole fucking manual at once, and still not knowing if
you need
> the crap or not. AoA is bedtime reading. A 2 pund sleeping tablet
and a
> weapon against burgulars. Hey Beth, why didnt _you_ think about that
?

You just don't get it, do you? And whatever I say, you refuse to see
it...okay, fine...I'll see you in some years' time when you've moved
from "newbie" to "advanced" to understand what's really going
on...and, don't worry, I won't "I told you so" or force you to eat
humble pie because I'm not a cruel person like that...

I'm completely aware of the issues involved and I've looked into the
possibilities and I've come to my conclusions, which you already
know...I've often been accused of "thinking too much"...rarely the
other way around that I've not given something enough thought...

> As Betov states in _RosAsm_ manual, you need mostly a few, maybe 20
asm
> memonic, those working horses.

Indeed; So, he _stole_ that point from Randy, then, did he? If you
don't believe me then it would be a task to search the archives but I
guarantee you that those comments are post-dated from when Randy said
even further back...

> The Win32 API have 1000s of procedures,

Of which you don't actually need a great deal of them...but maybe Rene
hasn't mentioned this because neither Randy or myself have mentioned
it yet for him to steal his "knowledge" and pretend he thought it all
up...

For someone who talks about "specific assembly", I'm thoroughly
disappointed by Rene's actual implemenations of it...for instance, why
is he creating more than one window? It's totally unnecessary...you
create the one "top-level window" in order to get yourself a basic
surface that works within Windows...but then all "child" windows can
be coded _within_ an application, without needing to interface with
Windows at all...

You want a _real_ "specific assembly" tutorial, Wannabee? I can give
you some great advice that Rene seems not to have worked out himself
yet...because, truth is, if you're following Rene, then you're "Half a
Wannabee" handle is the _perfect_ description...Rene's a "Wannabee"
and you're "Half a Wannabee" because you're trying to work up to his
"Wannabee" level...

Regardless of how many windows or their complexity or arrangement, no
application ever needs to create more than one window class...no
application needs to create any "child windows" whatsoever...the only
GDI resource they require is a "DC" to draw things...as Windows is so
incredibly slow processing "messages" then you can vastly improve an
application by being _specific_ and dealing with all messages to child
windows in a single "window procedure"...and we've already seen how
Rene's "philosophy" helped you _bloat_ your application unnecessary by
more than a megabyte in order to save clock cycles on a "CALL / RET"
which would probably get "eaten" up, overall, on modern CPUs as "free"
due to the specific optimisations and out-of-order execution,
remembering that a megabyte breaking most level 2 caches, let alone
level 1 caches that you're bringing a series of "cache misses" onto
your head...

If you're really interested in such stuff, then completely ignore
Rene's advice and ask someone like Terje, who's a _real_ (not
"Wannabee") optimisation guru...you'll learn an awful lot more in one
post from Terje about getting your code optimal than Rene's whole
"B_U_asm" can muster...go talk to the coders who enter the Hugi
contest or wolfgang...heck, I'd even give Herbert his due credit on
that score more than Rene (Herbert just has weird opinions on some
things but even he would make a better "role model" for you :)...

> and Delphi runtime also have 1000s of functions to call. Asm in
itself is easy.
> You dont sit down tewing the hole intel/masm manual in one run, do
you?

And the thought never occurred to you that you don't do that with the
HLA manuals either? That, in fact, AoA is _specifically designed_ to
be approached in a gradual and piecemeal fashion _exactly so_ that you
don't have to read the whole thing in one go...

You think I don't understand...but I understand perfectly...you're
scared of big books and lots of text...I'm not unsympathetic to that
at all...but just like you don't read the Intel manuals from cover to
cover, like it was a Stephen King novel, you don't actually do that
with HLA and AoA either...they are, in fact, designed to be read
"piecemeal"...AoA works with a "gradual step" method and the
"reference manuals" are, as the name suggests, reference manuals so
you dip into those as and when needed to look particular details
up...just like looking up a particular instruction in the Intel
manuals...

And if you truly think that all assembly programming is, is to know a
handful of machine instructions and that's all, then you've soooo
missed the trick, it's almost painful...algorithms, cache issues, OS
interfacing (including when NOT to interface with the OS), hardware
access, etc., etc....

Did you read that "assembly thinking" thread at all? Take note, even
your "god" Rene was among the choir who was singing that there's an
awful lot more to assembly language that just knowing some
instructions...indeed, sorry, but it's _you_ who's still stuck in a
HLL mentality...because, sure, that's all you need to know in Delphi
to know Delphi well...which "jigsaw pieces" to put together
where...but if you're just doing "Delphi with MOV instructions" in
your program then you're missing the most, most important part of why
you should be using ASM in the first place: You're NOT "assembly
thinking"...

> The fact is, that even RosAsm is a monster. Its a 2 mega byte
monster, and
> the manual is also very verbose.

Well, you and I (actually me and the entire world) define "verbose"
and "concise" in different ways...I look at the _actual content_
("concise = densely packed", NOT necessarily "short"...after all, I
have the "Concise Oxford English Dictionary" by here and it's NOT in
any way a "short" book and it's jam-packed with information written in
small print...these people, one would assume from them writing
dictionaries, must know what "concise" actually means and they apply
it to their "not at all short" dictionary...on the other hand, it _is_
"densely packed", as I'm suggesting is the better definition because
it's got a large chunk of the entire English language fully defined
inside it and you can (just) hold the thing in one hand
size-wise...that very much sounds like "densely packed" to me,
considering how gigantic the English language is to be defined in such
a small space ;) while everyone else thinks a "word count" is the
measure...

> But it never *gets in the way*.

An implementation issue; If Randy converted his PDF reference manual
into a WinHelp file then that would make all the difference on this
point...I know this because, for example, Ralf Brown's Interrupt List
comes normally as one gigantic text file...it's a pain to browse
through it to look for the information you want...then I spotted that
it comes along with a little utility which automatically turns the
list into a convenient WinHelp file...takes a long time for that
utility to process things but the end result is a massive, massive
difference...you name it, I can get to the entry in the list within no
more than four or five mouse clicks...

On this point, I do believe Rene's been cleverer...a little
interactive "side-kick" reference manual is a lot more useful and
convenient whilst programming (Ralf's list, the WIN32 API reference
and the DirectX documentation are just icons that sit on my desktop,
very nice and easy to access at any time I want to check something up
:)...it also masks just how gigantic the reference might actually be
because it's _focussed_, just like a website can have thousands of
pages but because you can easily browse around with hyperlinks, this
is never intimidating at all...

An excellent invention the "hyperlink" which makes that "Sir Bill
Gates" thing all the more absurd...Sir Bill gets an honourary
knighthood but the British inventor of the world-wide web - he came up
with the idea of hyperlinking everything - got some lesser OBE or MBE
or something...talk about screwed up and getting it totally the wrong
way around...one made one of the biggest contributions to the internet
and world community _releasing to the public domain_ his whole "let's
link pages together into a kind of world-wide 'web' thingy" idea...the
other wants to destroy it all, if he can't personally own every single
inch under his proprietary ".NET" empire and already walks around
thinking he owns it: "I will personally end all spam" (have you
actually seen their suggestions? It's all publicity nonsense...things
like "block anyone who's not in your address book" is hardly
"innovative" but then Microsoft always do steal other people's ideas,
pretend they made it up and then call it "innovation"...so, Sir Bill,
care to explain how I permit legitimate posts from newsgroup
participants reach me - but who I could not know in advance to
"approve" them first - without getting a stream of breast and penis
enlargement spam? Yeah, exactly...you have no idea how to deal with
that, as much as anyone else...just kicking up a fuss in public to get
some cheap, free publicity)...

> And its
> structured so it doesnt appear to be so flooding you. THAT is what
makes
> RosAsm so good, it stays simple and managable, even if it lack
nothing in
> content. It stays clear of hokus pockus.

Yeah, there's a definite advantage to something like a "WinHelp"-style
reference manual...you know, I've always criticised Randy when it
comes to the HLA name and I've also always hated that PDF file format
too...yeah, yeah...it's great for printing things out but what about
people who don't have printers? I don't have one...couldn't print it
out, even if I did fork up a small fortune in paper and ink...and
perhaps you can buy AoA in book form but the reference manuals - to
which some kind of convenient "hyperlinked" format is _ideally
suited_ - are another thing...

In fact, Randy, what's the "source" of those PDF files? That is, could
it be possible - at least with the "HLA standard library reference"
and the "HLA reference"...AoA's slightly different and probably does
work best as a book or PDF file because you work through it in a
mostly "linear" fashion from start to finish - to knock up a utility
similar to those ones that go along with Ralf Brown's List that could
churn out one of those "HTMLHelp" files? Doing it manually is a
possibility but, of course, an automatic method would ensure it's
accurate to the original text and doesn't go "out of synch"...

Because, on this point of how easy it is to access the "reference"
material, PDF files aren't at all useful...something implicitly
"hyperlinked" would be just perfect like the WinHelp / HTMLHelp kind
of thing...you know, so that someone could open it up and be presented
with overall categories of what's in the "HLA standard library" and
could just "browse" their way around what's available to find what
they want...as it stands, in electronic form, trying to do that with
the PDF files is a total pain in the arse...I can't disagree with
Wannabee on that point because I've had to do it numerous times and
it's NOT as easy as it should be to look something up whilst
programming...the PDF files "work", so to speak, in that, yes, the
information is there and you can get at it...but they don't work so
well when it comes to being _easy_ and _convenient_ to do so...

Beth :)