From: on

the-o/-/annabee wrote:
> Randy (obviously) said:
> "You've written a very low-end assembler, only slightly above the level
> of the toys that several hackers have set out to create when they
> decided they were going to write an assembler. You *have* put a lot of
> effort (seven years!) into ancillary products such as editors,
> debuggers, disassemblers, and the like. But your assembler is pretty
> weak as far as assemblers go."
> RosAsm is even "strong" compared to the most in use HLLs, like C++/C#
> and such.

I would say that if you compare RosAsm's assembler capabilities against
most HLLs, like C++/C#, then you would have a point. RosAsm is a *much*
better assembler than those HLLs. But that's not saying much as those
products are not assemblers.

> It is the most efficent to install,

Define "most efficient to install."
And then tell us why this means anything.
Perhaps RosAsm is breaking quite a bit and you have to reinstall it all
the time, and this is why installation efficiency is so important?

> the most efficient to
> use,

Compared to what? You've still not answered that question. This is an
empty statement. It's like Rene claiming that RosAsm is the fastest of
all actual assemblers because it compiles itself in a few seconds on
his machine. The statement is meaningless.

> and the most efficent way of creating efficient programs.

Define efficiency.
What is an efficient way of creating programs?
For whom?
And I'd bet dollars to doughnuts that if you are the beginning assembly
programmer you claim to be, that a decent C++ compiler generates better
code than you do. Though a human being *can* outperform a compiler,
this activity is *hardly* automatic, it's not all that easy, and it's
rare that a beginning assembly programmer can consistently do it.

So tell us, how much C++ code have you written and compared against
your assembly code to be able to make such a sweeping generalization?

> For instance, the RosAsm way of declearing data is superior to anything
> I have seen.

No doubt. It's obvious you've not seen very much in your short

> It sources organisation is the best ever seen,

Nor have you use many other browsers, editors, or IDEs.

> its syntax
> the most intuitive ever seen,

Ah, yes.
If it is so intuitive, how come you're still a beginner after two years
working at it?
If it is so intuitive, why does the phrase "line noise" get used around
here when describing RosAsm syntax?
If it is so intuitive, how come data declarations and equates look
almost the same? (that's hardly intuitive, btw.)

> and the run time debugger is very good,

How many other debuggers have you used in order to make such a claim.
Just for your edification, there is nothing special about the RosAsm
debugger. It's very similar to the CodeView product that Microsoft has
been shipping since, well, forever. Depending on what you want to do,
debuggers like the Visual Studio debugger are *much* nicer. Others,
like SoftIce, are far more capable.

> and many times a huge time saver.

And how many other assemblers/compilers/etc have you used to gain the
experience to make such a sweeping statement?

Again, I'll point out to you -- a statistical sample of one is

> HLA cannot even be in the competition.

Thank God!
I wouldn't want HLA trying to compete with RosAsm. That's like entering
a Formula-1 car (HLA) into a go-kart (RosAsm) race.

> HLA is slow,

HLA v1.x is, yes, one of the slower assemblers around (not the slowest,
but certainly slow). Still, it compiles most users' programs within a
couple of seconds. So except for some *really* large projects, nobody
really cares. And for large projects, of course, HLA supports separate
compilation and linking, so it still only takes a couple of seconds to
compile a few changes into a large project and produce an executable.

It is certainly *possible* to write some killer macros in HLA that
consume a lot of CPU time during compilation, but claiming that RosAsm
is better because it is faster, when RosAsm wouldn't allow you to
create such macros in the first place is just plain stupid. Eliminate
the macros, and do everything manually as you would have to do with
RosAsm, and HLA's compiling the same thing in a few seconds again.
Sure, RosAsm may be doing it ten times faster, but so few people really
care. I mean, how often do you recompile your code? It's not that
often that a few seconds per iteration is going to make any difference.

> have a very wierd
> syntax,

All assemblers have a weird syntax. And the weirdest syntaxes of all
belong to RosAsm, Gas, and, yes, HLA. You're not in a position to
discuss how weird HLA's syntax is when you're a RosAsm user.

> and is an 8 years PROTOTYPE. :)))

And your point?

> Plus it is written as an
> educational tool only.

Whatever gave you that idea?
It was certainly written as an educational tool, and that *is* its
primary purpose. But that is not its only purpose. The intent was (and
is) to provide a *very* powerful tool that programmers could grow into
as their skills increased. Someday, you're going to run up against
RosAsm's limitations, and then you'll understand what I'm talking

> Last time I read some propaganda regarding what
> a "prototype" was, (from the education department) the reason for it
> was that it was something that was done to quickly have some working
> "proof of concept". :)))

That is not an unreasonable definition.
In the case of HLA, the reason for having a prototype is to allow rapid
changes to the code to test out modifications to the *language*. The
prototype has served quite well in that regard. There have been *many*
changes to the HLA language over the years, and while the use of Flex
and Bison have not made those changes as easy as I would have liked, it
is still the case that the task was *much* easier than had I been
foolish and attempted to write the prototype in assembly language in
the first place.

BTW, this notion of "prototyping" is certain related to another
long-running complaint of the RosAsm crowd -- the use of
MASM/TASM/FASM/Gas as a back end. By using these existing products as a
back-end to the system, I was able to get the result up faster than had
I coded the stuff directly myself. I am also able to make language
changes, and see their results in the emitted code, much more rapidly
and easily by using this approach. I was also able to port HLA to Linux
in a matter of weeks because I took this approach (and if I really
wanted, I could do the same with BSD and similar OSes).

And, btw, it's been longer than eight years. The work on HLA began in
1996. We're talking better than nine years now.

So why isn't a "non-prototype version available?" Well, very simple.
HLA v1.x works fairly well. There are no "show-stopper" problems that
make it unsuitable for its target (teaching beginners assembly language
programming). And advanced programmers are using it without too many
problems. No question, it could be a bit more robust and it wouldn't
hurt if it were faster. But, literally, millions of lines of code have
been written with HLA (e.g., I've written approximately a quarter of a
million lines of code myself) and that just wouldn't have happened if
HLA were not a usable product. Quick and dirty prototype or otherwise.

> Imo, an excuse for using VB?

Yes, VB and Delphi are often used for creating prototypes. Your point?

> Randall just bashed me saying two years is long time, but 8 years is
> short time for prototyping a textconverter? :)

During those same nine years I've also written *four* books, worked
full-time, taught (in addition to the full-time job, as I was employed
outside the University while teaching), written several "partial" books
(like "Windows Programming in Assembly"), published various articles,
and, oh, actually had a life outside computers. And don't forget that
during this time I've also managed to write about 100,000 lines of code
for HLA v2.0. I think that most people would agree that this is fairly
productive for nine years.

> I am starting getting pretty bored from answering to your repeated lies

Then go away and shut up. Do us all a favor!

> and swindelings, Randall. But with people like you some reply is
> unavoidable.

Of course, you say the same nonsense over and over again. Too bad you
can't think of anything new to say.

> Because the state of the world seem to show that when
> little people does not answer to lies, a huge part of people are
> allowing themself to get ignorant. Ignorant masses will ask for
> ignorant solutions. And we all hurt from this.

So what lies have you answered to today?

> When I first saw RosAsm, it was an eyeopener to me.

I'm sure it was.

> I was previously a
> Delphi/Pascal programmer. 10 years at least.

Yes, we've heard that story before. And after those 10 years, you still
couldn't do list processing properly in Delphi. You were amazed at how
to create a list data structure in assembly as I recall. Generally,
when people have been working in a language like Object Pascal for 10
years, they figure out how to do things like create linked lists in
Pascal. Given your experience with Delphi, I suspect that in about
eight more years you'll probably figure out that having real
structs/records in an assembler is a good thing :-)

And we *all* got a big laugh out of your claims that you had rewritten
the Delphi VCL. Even funnier was Rene telling everyone about how you
were porting the VCL to RosAsm. It is amusing that Rene knows so little
about this subject that he holds *you* up as the expert on these
matters. :-)

> RosAsm was the answer to
> my dreams for what a programming tool could ever become.

I'm sure it was.

> And what
> amazed me the most was how incredibly easy it was to make the
> transition.

Yet, after two years, you're still a "beginner". Then again, after 10
years with Delphi you still couldn't do linked lists in Object Pascal.
So maybe I shouldn't be surprised.

> The reason is that there are very few incoherent solutions
> provided by RosAsm.

And very few coherent ones, too :-)

> The solutions offered are their own explaination in
> many cases, which leaves few unanswered questions.

Somehow, I don't think you quite translated your thoughts into English
properly here.

> This is actuallly
> very hard to accomplish.

Correctly, yes.

> Just try it.

Been there, done that.
And the fact that AoA is one of the most popular references on x86
assembly language programming around attests to that achievement.

> HLA on the other hand, need tons
> of explanations.

Yes. It is a *big* language. If you want to learn it all, you're in for
some serious reading. That's related to my earlier comments about
having a language you can grow into when you cease being a beginner and
become an intermediate or advanced programmer.

The trick, which HLA succeeds at, is to use language "restrictability"
that allows people to write meaning programs using a subset of the
language. The fact that beginners *never* touch the advanced stuff in
HLA (i.e, it's not required for doing introductory types of projects)
is proof that this concept works in HLA.

> This is because his every dessision raises TONS of
> questions. Why?

Amazing. People have been reading AoA for years. Certain people have
asked questions from time to time, but nothing like you're suggesting.
I would like to know where you get your data from. You'd think as the
author that I would be seeing all these tons of questions; but I don't.
Where are these questions going to that we don't see them around here,
for example?

> Why parantesis?

Why brackets in NASM/FASM?
Why square brackets around data declarations and equates in RosAsm?
Actually, the only people who would ask such a question are those
coming to HLA *FROM SOME OTHER ASSEMBLER*. Someone coming to assembly
for the first time wouldn't ask such a question.

To answer your question in a very simple manner -- parentheses are very
natural to someone coming to assembly language from a language like
Pascal, C/C++/C#, Java, Ada, Lisp, etc. And that's the audience for
HLA. The lack of parentheses might work well for people coming from
BASIC. I figure that all the other assemblers can have the BASIC
programmers, if those programmers are unable to adapt to the use of

> Why change an established syntax for no
> reason.

What made you think it was done for no reason?

Most of the questions you raise are answered here:
or here

>Why do I need an illegal download of MASM in order to run HLA.

You don't.
You may either legally download MASM, or use a different assembler if
you like.

> (or legal FASM theese days) Why do I need a real assembler to use HLA?

Why do you need a linker? Why do you need an editor? Why do you need a
..... ?

> If HLA is an assembler, why the need for another assembler?

Maybe because that other assembler doesn't compile HLA programs?

> Why is
> there a whole chapter dedicated to installing HLA in one of the PDFs at
> Randys site.

I thought it was two. Oh well, maybe I'm wrong :-)

When a product has a few users as RosAsm, when the product installs in
a fixed way on a single OS, and the product is designed in such a way
as to ensure that *very few* beginners will ever use it, you can get
away with just a simple installation program. When the program can be
installed on multiple OSes, when it provides several different
installation options (e.g., multiple IDEs, multiple back ends), and so
on, and when that product is being installed by *beginners* all the
time, you want a little more help available; especially for those who
would like to customize their installation.

> Why does the author need 1000++ pages to explain his
> product.

Well, as has been said *many* times here already, HLA is a *much* more
complex product than toys such as RosAsm. So it makes sense that the
documentation should be a bit more hefty. Now the last time I did a
page count, the HLA documentation, itself, was about 250 pages. The HLA
Standard Library (nothing comparable in RosAsm) was about the same
length, AoA was about 1,200-1,300 pages, WPA was several hundred pages,
and various other documents and books on Webster probably total another
500-1,000 pages. No question about it, HLA and programming in HLA are
well documented.

OTOH, if someone already knows x86 assembly language and they just want
to pick up the gist of HLA in as few pages as possible, there is the
"HLA Quick Guide" at
which covers a fair part of the language in about 40 pages.

> Why why why ?

Because HLA is not a toy.
It is a professional-level language and such languages generally
include a bit more documentation than hacked-out toy products.

> Why Randy uses C++, Bison and such tools for his
> own work, while pretending to speak for the benfits of asm?

Because Randy is not so foolish to think that assembly is the best tool
for *everything*. It is not, for example, a good prototyping tool.
Indeed, it's not even a particularly good tool for writing compilers
with. Indeed, the only reason I'm using HLA to write HLA v2.0 with is
because I want to allow HLA users to play with the sources to HLA v2.0
without having to know another language or have other tools available.
Otherwise, I'd probably have used C for the project. The bottom line is
that to achieve the *real* benefits of assembly (fast and compact) you
have to write your code in a way that is generally unmaintainable and
unreadable. One of the principal goals of HLA v2.0 is to create a
maintainable product that can be enhanced for at least another decade
or two before another complete rewrite is necessary.

> Why is the
> author so defensive when speaking of HLA.

Why are the author and users of RosAsm constantly attacking HLA?

> Why he has 5 millon hits at
> webster, and exactly one users?

Where do you get your numbers from?
First of all, Webster past the six million mark a few months ago. And,
of course, this is just the number of hits since 1/1/2000. It probably
had another 1,000,000 hits or so in the four years leading up to the
point I reset the counter.

Second, you *do* understand what a "hit" is, right?
And what "one user" are you talking about?
You're as bad as Rene with your wishful thinking. "I wish RosAsm were
more popular than HLA, so I'll just start claiming that HLA has one
user to make myself feel better." Sonny, this is a sign of mental
illness. You should seek some professional help.

> Why he belive in things that does not
> exist?

You mean, like HLA has "one user."?
Seek some help.

> RosAsm on the other hand makes asm as easy as HLL.

There are an amazingly large number of HLL programmers who disagree
with you. And given how *few* people even *know* about RosAsm, that's
pretty sad.

> How can this be
> possible?

It's not.

> It is simply because asm _IS_ easy,

Yet after two years, you are still a beginner at it. If it were so
easy, I'd have expected better progress from you.

Take it from me, someone who has had thousands of students go through
my courses, most people don't find assembly to be particularly easy.

> but we have had traditionally some
> VERY awkward tools to do asm in.

Now you're discovering why HLA has parenthesis, the HLA stdlib, the
HLL-like control structures, and so on.

> It is those tools that have created
> the impression that asm is hard,and using such tools certainly make asm
> seem allmost impossible to a beginner, at first look.

Yep. And HLA has gone a *long* ways towards shaking that impression
from a lot of beginner's minds. Exactly how many beginners (besides
yourself, of course) have discovered how *easy* assembly is with
RosAsm? Given the pathetic size of the RosAsm user base, you ought to
be able to list them all in your next post.

> For instance,
> when reading the manuals for TASM, I was overwhelmend with the allmost
> insane amount of DIRECTIVES that was listed there.

Mistake #1: thinking you can learn how to program with an assembler by
reading a *reference manual*. But thank you for your comment. You've
proven that Herbert's (or was it Wolfgang's) assertion that all anyone
needs are the processor manuals is completely false.

> Using RosAsm I need
> NO directives.

You're just a beginner. Wait. Someday you'll start missing them :-)

> Just start and run, select file/new/PE with menus, and
> you are ready to go.

Gee, sounds like VB. Wait, weren't you criticizing that earlier?

> Installing RosAsm is a matter of unpacking the
> zip, and doubleclick the icon.

So. Installing MASM32 is a matter of downloading and running the
program. Installing HLA is a matter of downloading the installer and
running it. Installing FASM is a matter of downloading the installer
and running it. What's your point?

> And having ready to run tutorials and
> template apps you can tinker with, is a huge advantage to learning.

And most of those tutorials were translated from MASM tutorials. And
many of those same tutorials have been translated to every other
assembler out there. Plus, of course, all those other assemblers have
their own set of unique tutorials. So what makes RosAsm so special

> Imo, the best way to learn, is to interact with some allready running
> template app.

What does this have to do with RosAsm? Whatever truth there is to this
statement is true for all assemblers, HLA included. And in terms of
tutorial apps, there are a *few* more of them available for HLA than
for RosAsm (remember those 1,000++ pages of documentation? Think it's
all English text?)

> Rosasm wins because the tool itself is not an obstruction
> to the work beeing done with it.

In your opinion. Others feel differently.

> HLA is without any chance, because it
> complicates everything, including the writing of the code itself.

How is that?
Randy Hyde

From: on

the-o/-/annabee wrote:
> About structs? René wrote the best programming environment in the
> world, I know of, without them.

Regardless of your claims about the quality of the RosAsm environment,
no one *ever* said that it is impossible to write code unless you have
true structs/records. They certainly make the code more readable and
maintainable, but they are not a necessary feature for writing code. I
mean, look at the equates stuff that you are doing. It will *work*. It
just won't as readable or maintainable when you're done as had you used
true structs/records/classes/unions.

> When I compare the user experience of HLA to RosAsm,

How can you compare the two when you've never really used HLA?

> it is for sure, no
> obvious reason to belive you over him.

Yep. It's easy to believe Rene, who gets caught in his lies over and
over again in this newsgroup. That makes you a very gullible person.
The fact that he has convinced you that equates are just as good as
true structs/records pretty much proves the point.

> Before I learned to program in
> asm with RosAsm, I had actually only a vage understanding of
> structures.

And you still don't know much about them, apparently.

> Once seen their true nature, and understood the job they
> really do, and beeing able to replace them using equates, I feel
> empowered (in my understanding).

Great. Now start using real structures and enjoy their software
engineering benefts, all the while understanding how they are
implemented at the machine level. It's *good* to understand completely
how structs/records work. And if implementing them by equates is what
leads you to that path, more power to you. But now that you know, why
force yourself to suffer with such an arcane mechanism?

> Your structures are, if not the worst
> things, a tool for alienation of people.

How many times have I heard you say that in this thread?
Randy Hyde

From: Betov on
"randyhyde(a)" <randyhyde(a)> ?crivait

> In every way but macros, GoAsm is better than RosAsm.


Thanks for Jeremy.


< >

From: on

Betov wrote:
> "randyhyde(a)" <randyhyde(a)> écrivait
> news:1132584721.018201.129250(a)
> > RosAsm is a
> > complete failure.
> :)))))
> Maybe...

No maybe, a fact.

? but, as opposed to you, i never claimed having
> any success story. All the contrary:
> I am rather proud when counting how many interresting
> Applications and Demos have been written with this
> Assembly PEs Producers, while having a so small number
> of users.

And what does that prove? What is there to be proud of? Heck, *I've*
written more lines of HLA code than you and all your users (put
together) have written lines of RosAsm code. If the productivity of
your entire user base cannot match one person, what's there to be proud

From: on

the-o/-/annabee wrote:
> "
> >From the guy whose only "knowledge" of structures comes from RosAsm :-)
> Yes, you're proving your point quite strongly here.
> Cheers,
> Randy Hyde"
> My knowledge of the USE of structs comes from Delphi. My full
> undestanding of structs comes from RosAsm.

And you've still got a ways to go. Perhaps you ought to consider
another language now?
Randy Hyde