is a machine specific
programming language designed for the complete family of Intel x86
microprocessors (8086 through the Pentium 4 and beyond).
programmers maintain
complete control over the processor (just like in assembly language)
without the monotony and bookkeeping hassles faced by their assembly
language peers. A high-level language syntax makes this possible, but you
don't relinquish control of the generated code. The x86 family's CISC
instruction set makes
versatile and extremely powerful.
is extraordinarily easy to learn and use.
I programmed the Intel 8086 for the first time in October 1978. I was bewildered by the differences between 8086 assembly language and the other assembly languages I had used previously. This assembler was much more like a compiler than an assembler. The 8086 assembler actually supported data typing! I had been accustomed to specifying operand types as part of the mnemonic, not having the assembler derive them by examining the operands. I was further confused by the support of long symbol names, procedure definitions, and data structures. Add to this, the special purpose registers, the plethora of instructions, and the segmented architecture! WOW! I was overwhelmed and disoriented. My early days programming these Intel machines were no fun at all.
Faced with a seemingly hopeless situation, I devised a traditional assembly language for the 8086 fashioned after the familiar 8080 assembly language. I wrote an assembler and used it for a year or so. Programming the 8086 in traditional assembly language turned out to be even more painful. The increased attention-to-detail burden placed upon the programmer was creating bugs. After this negative experience, I understood Intel's prudence in migrating from the traditional assembler model. Admitting my mistake, I rejected this concept and returned to standard 8086 assembly language.
Sometime later, I was faced with an enormous assembly language project.
The apprehension created by the thought of writing massive amounts of 8086
assembly language was causing me great anxiety, and I couldn't even think of
using high-level language because of space and speed constraints (i.e., 64K
8088 machines with 160K single sided floppy drives). I needed
something to increase my productivity, but what? After many restless
nights, the inspiration for hit me like a bolt of lighting.
The idea was simple: a structured symbolic low level language that would
leverage programmer productivity. A big problem with
assembly language is that it is a vertical language; its format being column
and single statement per line oriented. , on the other hand, is a free format, horizontal,
multiple statement per line, language. This means you can see a substantial
portion of your program on the screen at one time, nice when programming
with a full screen editor (I haven't used a listing in years). Flow control
statements in assembler are primitive at best. Who likes reading
spaghetti code or constantly inventing meaningful labels? The
conditional and looping structure in
is intuitive, making the code extremely readable.
When properly indented, you are able to get a feel for the flow of a program
with only a cursory examination of the source.
Operator rich, employs
prefix, postfix, and infix notation. It is context sensitive, just like natural
spoken language. A considerable amount of attention was given to the
selection of the operators. I insisted on having a reason for the choice
of each operator, none was arbitrarily assigned. The manual explains the
reason for each selection. These reasons help you to make
the necessary mental connection needed to remember the individual
operators. Commonly used operators are intuitive to programmers.
is as simple as 2=1+1.
No matter whose assembler, compilers, and linker you are presently using,
probably works
with them. Because
generates assembly language as its output, and uses
your assembler as a common code generator, you are guaranteed
compatibility with any object file format. The implementation of the
compiler is extremely fast. This was a prerequisite since the output
must be assembled and it would have been untenable to incur the double
overhead of waiting on the compiler and the assembler.
compiles
thousands of statements per second!
is tiny, weighing in at a mere 23,917
bytes.
Another feature of the compiler is the provision for intermixing standard
assembler statements right along with statements, allowing you to be as
as you like. You may use as much or
as little
as you wish,
facilitating your transition from assembler. There is also a program
(
asm2t
) for converting your existing assembler programs to
compatible assembler
so you may begin maintaining your existing software in
immediately! This ability to intermix
standard assembly language statements guarantees your
access to new instructions in future incarnations of the processor
without the need to upgrade your compiler. If your assembler supports it, so
does
.
Some assembly language programming could surely improve
most non-trivial programming projects. Fast execution is essential in
real-time programming situations like device drivers, interrupt routines, highly
repetitive tasks, bit manipulation, graphics, games, just to name a few. Also,
access to machine dependent and other special functions, not directly
accessible through a high-level language, is often required. Whole new
classes of problems are opened up to software solutions utilizing low-level
software control with modern high speed processors. Below are just a
few examples of applications that could benefit from .
Often, after a system is written, several core routines are down coded into
assembler to optimize them for speed. Sometimes critical routines are
designed and implemented in assembler from the outset. In either case,
today's programmers tend to design in a structured, high-level way.
allows you to cull
every cycle from your routines without changing the way you think.
You continue to program in the high-level style you are familiar with while
maintaining complete control over the generated code! If you write
100 or 100,000 lines of assembly code this year,
will benefit you now! If you
have never written any assembly language before,
can make learning* easy. Best of all, programming in
is just plain FUN!
Since 1988, has been
used in medical, military, industrial and commercial applications. Proven in
the real world, this is a fully tested language and compiler. Most
programmers shy away from learning anything new. Let's face it, learning
can be painful. I know of no programmer who has regretted learning
. Some have learned it
because they wanted to, while others have learned it because their job
required it. In each case, they have enthusiastically commented on the
benefits derived from
.
Most are able to read
without even looking at the manual. So why wait? Learn
today and begin exploiting the benefits
of the only real improvement in low-level programming since the
invention of the assembler.
* Learning to program at the machine level requires an intimate knowledge of the internal operating characteristics of the processor. Although the manual is written assuming a previous knowledge of assembler, using it along side a suitable text on the art of assembly language programming should take much of the drudgery out of your learning experience. [return to text]
Copyright
© . All Rights
Reserved.
The word OPTOMIZED, the name TERSE, and the logo are Trademarks of
.