I am speaking of
RosAsm, that is a Good
Thing, which I enjoy
slowly and thoroughly.
Here is a little
report, consisting of two
brief pieces.
1. I have never
had a better insight into
the inside - of the
computer, the code, and
the application built with
my code. It is all there
right in front of my eyes:
The Windows-application
written in RosAsm; the
Debugger, a very fine one
with all information, very
clearly layed out, that
shows all about your
application as it is
stretched out in the
computer's memory and
registers, in all its
diverse aspects; and the
code in the Source-Editor,
highlighted at the place
in the Debugger.
Since compiling is
lightning fast, one can
intuitively directly edit
one's code and Debug it,
in virtually one process.
And just looking at it
and trying to understand
it shows and explains a
lot, implicitly and
explicitly, and does so
much better and more
completely and precisely
than any HLL could do,
about computing and the
computer and code for it
in general and in this
particular case.
This is also true if
you never were to code in
assembler. It really is an
educative experience to
see what I am describing
in RosAsm: This is the
sort of thing that must be
going on when running a
program written in any
language, documented and
displayed to the smallest
detail and the least bit,
if desired.
And mind that in the
Source-Editor of
RosAsm right-clicking on
virtually any piece of
code immediately pops up
specific help for that
piece of code, clear and
complete, and very
revealing about what the
code is meant to do.
One has the complete
explanation of everything
going on, and the reasons
and terms and parameters
for them, on the screen or
just a click away.
Everywhere there is
highly specific and
precise help for almost everything (including
incidental humorous and
deserved exclamations like
a pop-up that says "You
have to ask about that?!!
You poor fool!").
It's all very amazing,
and in its own way quite
beautiful. And also
highly explanatory: So
this is what is
really
happening, when computing,
in as much detail as one
wants, all very nicely
laid out, and
extra-ordinarily well
documented.
2. Then I have
been playing around with
making Windows-interfaces.
RosAsm has a fine
Resource-Editor for it,
reminiscent of what I know
from Delphi, and also
something a bit simpler
tool that I have been using
now, the Dialog-Editor for
Windows-interfaces.
This tool is very
cleverly put together, and
allows one to built
complete interfaces by
clicking and dragging,
plus typing of captions
and titles, and to adjust
things in very great
detail. And the beautiful
thing is that this tool
outputs the ready-made
complete assembly-code for
this interface - that one
has written by clicking,
dragging and typing a few
things - in one's
Source-Editor, where one
wants it.
So in quite a few ways
this is better than
Delphi, for it is assembly
and the previous point
applies again: compile it
and you can step through
it as precisely as you
want to, it is far more
capable (for one can use
the entire available
Windows-Api, in principle,
and not just what Borland
precoded for you) and it
is all completely open
source and completely
free, and everything is
visible, and immediately
alterable by anyone who
has the wits and the
knowledge.
Also, after the first
few minutes this
Dialog-Editor is quite
intuitive and easy to work
with - and again it is
very clearly documented.
Anyone used to making
interfaces ("Forms") in
Delphi will have no
trouble with this, and
indeed will find it more
clearly laid out.
O, this is where you
get
RosAsm. You have a free
will, and may be perverse.
I find it amazing,
beautiful and highly
instructive, also in an
enjoyable way.