Announcing the RosAsm Library Project

[rhyde at cs.ucr.edu]

On Oct 4, 6:36 pm, Evenbit <nbaker2... at charter.net> wrote:
>
> This is extremely easy to answer.  The average RosAsm coder tends to
> only make use of the libraries documented here:
>
> http://msdn2.microsoft.com/en-us/library/aa383749.aspx

Which is a bit limiting, wouldn't you agree?

>
> If you wish to revue the source code, then bring that issue up with
> Microsoft.  Please let us know of any positive results.  ;)

Actually, at one time I *had* the NT sources on my machine (research
at UCR in the OS research time). Let's just say that at 35 million
lines of code (at the time, this was NT 4.0) it may as well have been
closed source. :-)


>
> If a programmer feels that a project requires him to use a large
> amount of pre-written "library" code and advanced programming features/
> tools, then he must seriously question why he is using assembly
> language (rather than a High-Level Language) in the first place.

Why is that?
You do realize that with every OS API call you're making, you're doing
exactly this -- making use of a large amount of pre-written "library"
code.


> After a programmer has made the choice to code at the ASM level, he
> has already -- by default/definition -- decided to avoid the trappings
> of the HLL world.

What makes you think this?  You do realize, don't you, that the *vast*
majority of people who write assembly code are actually writing
functions to be called from HLLs, right?

And what "trappings" of the HLL world are you talking about?
I've seen *very* little code posted to this group or to any assembly
language site that couldn't be done in almost exactly the same way in
a HLL.

>
> You are indeed one pecular person.  On the one hand [http://www.artofasm.com
> ], you have taught, written a book, built an advanced assembler, and
> generally answer many questions about assembly language.  However, on
> the other hand, you spend a great deal of time here in alt.lang.asm
> denigrating assembler tools and "bashing" those who write assembly
> language.

Well, I wonder why that is?

>
> So, the question is [this goes also for all those regular a.l.a
> trolls]:  Are you here to _support_ the *assembly language*
> community?  



> Or, are you here to encourage everyone to "give up" on ASM
> and adopt an easy HLL instead?

I'm all for people using the appropriate tools for a given task. If an
"easy HLL" is more appropriate than assembly language for the task,
I'm all for having them adopt an "easy HLL" instead.

The argument that all applications should be written in assembly
language was lost over a decade and a half ago, I'm afraid. Although I
feel that far more code should be written in assembly language than we
see today, only a fool would claim that all code should be written in
assembly language. Today, the main reason for learning assembly
language is *not* so you can write all your code in assembly, but so
that you can understand what HLL compilers are doing with your source
code when they translate it into machine  code. This allows you to
write much better HLL source code.

What's funny, despite Rene's constant dream about an "assembly
rebirth" is that today people are viewing languages like C (and even C+
+) the same way assembly language was viewed 15 years ago. I suspect
that in another 10 years, you'll hear the old time C programmers
arguing about how programs ought to be written in C rather than in the
latest gee-whiz interpreted scripting language.

As much as I would like to see things turn out otherwise, the bottom
line is that assembly language is really dying off. Anyone who doesn't
see this just isn't paying attention. Oh sure, we had a big burst of
activity when the Iczelion Tutorials were first announced, and lately
there *have* been a couple of new books appear, but how many people
are *truly* developing assembly language code (of any kind --
libraries, OSes, system tooks, apps, whatever)?

In one resect, Rene is right. Where are all the assembly apps? And I
add "written with any assembler?" Or sure, a few crackpots (myself
included) still do it, but everyone in this newsgroup is out on the
fringe.

Though *writing* assembly language code isn't so bad, the real problem
with most people is the issues of testing, debugging, and maintenance.
I don't care what debugger you use, one simple fact is that debugging
assembly language code is a heck of a lot more work than debugging HLL
code. The reason is pretty simple -- you can't do things like screw up
the stack in most HLLs; you generally get *some* sort of type checking
in those HLLs that is missing from assembly (including HLA, I might
add). Having just developed a test suite for the HLA stdlib, I can
tell you that it's a heck of a lot more work to test and debug
assembly code that it is to debug the equivalent C code.

Then, on top of that, code has to be maintained. Very few projects in
this world are like HLA/HLA stdlib where a single person works on the
code for 10 years. In  most environments, you have some senior
engineers who develop something, get it working reasonably well, and
then they dump the result on someone else for maintenance and
enhancement. Now matter how good *you* are at assembly language, the
sad fact is that most people, to whom the code is going to be dumped
on later, don't know assembly language or, at best, have a passing
knowledge of it. That, alone, is probably the major reason why
assembly language *has died out*.

Yes, there are still some *very* good reasons for learning assembly
language. And for certain projects there are some good reasons why one
should use assembly language. But assembly language really has become
a "niche within a niche".

The reasons for using assembly language today have little to do with
"avoiding the trappings of a HLL." Indeed, the main reason HLLs have
caught on is to avoid the trappings of assembly language.  Today,
there are only a few valid reasons for using assembly language on a
real project. I'm kind of a special case, I use assembly language (for
example, I'm writing a terminal emulator for General Atomics right now
in assembly language) for a couple of reasons that have little to do
with the project:

1) I enjoy working in assembly language
2) I get to further test the HLA compiler and stdlib by using it on
work-related projects

and then, of course, the biggie:

3) Job Security! :-)

(the last is a joke, if you didn't catch on to that.)

Soon, I expect to be working on a rewrite of the Triga Mark II digital
console software (currently written in C under QNX4) to Linux. I'm
contemplating doing this project in assembly language because it will
force me to write a lot of assembly code under Linux and really shake
out the HLA system under Linux. I'm currently weighing the benefits of
that against the "unprofessionalism" of delivering an application
written in assembly language to the next person who comes along and
works on the project.

Bottom line is that you want to always advocate using the right tool
for the job. Some times, the right tool *is* assembly language; most
of the time it is not (opinions in this newsgroup not withstanding).
Yes, facilities like the HLA standard library make it possible to use
assembly language where it absolutely did not make sense before, but
by and large, assembly's day has passed.

Now as to "denigrating tools around here", well, some tools (e.g.,
RosAsm) are pure crap and they do even more harm to assembly's
reputation and a practical development tool.  Such crap definitely
deserves appropriate comments; especially when it's being pushed as a
"solution" to perceived problems.

One of those perceived problems, and hence this satrical thread, is
this crazy notion that assembly language libraries are bad. This is
absolutely insane. The only reason Rene would even make such a claim
is because he's never gotten around to providing such a library for
RosAsm users. If he doesn't have something, his reaction is to attack
those who do.

hLater,
Randy Hyde