The Greatest Advance
In Machine Control
In 40 Years!

What Is ?

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.

Why ?

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.

Before

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.

The Inspiration

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 Birth of

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.

is Natural

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.

is Compatible

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.

is Flexible

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 .

Who Needs ?

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 .

• BIOS and DOS Calls
• Communications
• Data Acquisition
• Data Compression
• Database Access
• Database Manipulation
• Demo Programming
• Digital Signal Processing
• Embedded Systems
• Game Programming
• Graphics Routines
• I/O Sub-Systems
• Motor Control
• Operating Systems
• Video Drivers

When to use

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!

is Proven

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.