Assembly language runs fast. Assembly language produces small programs. But Assembly language takes nearly forever to write. That’s because you pretty much have to do everything from scratch.

Unlike higher-level programming languages — even the C language — Assembly has no libraries. There are some routines you can access in the computer’s ROM or in the operating system, but beyond that you have to code everything. That includes input, output, math — you name it. It’s a lot of work.

The payoff, of course, is that the code runs super fast, especially when compared with the typical BASIC program of the era.

As an example, here is code I wrote in 1988 that displays a message on the screen:

        DOSSEG
        .MODEL small
        .STACK 100h
        .DATA
message db      "This is an .EXE file.$"

        .CODE
start:  mov ax,DGROUP
        mov ds,ax
        mov ah,9
        mov dx,offset message
        int 21h

        mov ah,4Ch              ;leave
        mov al,0                ;zero code
        int 21h

        END     start

The resulting executable file is only 244 bytes long. That size cannot be equalled by any other programming language. Granted, it’s entirely unreadable. Even if I wrote all the necessary comments, few non-Assembly programmers would understand the code itself. But as you can see from my comments above, I probably felt comfortable enough with what I was doing not to write comments.

Generally speaking, most programs do more than display a single line of text. And yet, in Assembly, every little bit of the program must be coded.

Below is a snipped from code I wrote. It takes a string of text stored in memory and converts that text into a value. The value is stored in one of the processor’s registers:

;---------------------------------------;
;  Calculate string si==> into bx       ;
;---------------------------------------;
DECBIN  proc near
        mov bx,0                        ;zero out initial value
Dget_next:
        mov al,byte ptr [si]            ;read value
        sub al,30h                      ;make binary
        cbw                             ;make into a word
        add bx,bx                       ;multiply bx by 10
        push bx                         ;save *2
        add bx,bx                       ;*4
        add bx,bx                       ;*8
        pop dx                          ;get back *2
        add bx,dx                       ;*8 + *2 = *10
        add bx,ax                       ;add new value
        inc si                          ;bump pointer
        cmp byte ptr [si],'0'           ;end of string?
        jl Dleave                       ;go if so
        cmp byte ptr [si],'9'           ;other possible end
        jle Dget_next                   ;if not, continue
Dleave:
        ret
DECBIN  endp

This code snippet is basically what you would call a function in any higher-level language. In Assembly, it’s a procedure. In the C language, you would probably use the atoi() function to accomplish the same thing. In Assembly, you have to write your own code, similar to what’s shown above.

This snippet isn’t the only procedure you’d have to code. For each and every program you wrote in Assembly, you’ve have to write procedures for everything. Eventually you do develop your own procedure library, which you can use over and over. That includes tasks such as converting a string to a value, but also math fucntions, trigonometry, graphics — you name it. That takes time, and it’s a pain.

And I loved it!

After a while, however, I realized how awkward it was to write things in Assembly. I’ve kept all my Assembly code that I wrote on my PCs. The dates range from 1984 through about 1988. That was when I began to code in C, primarily because the development time was so much faster. But I still remember Assembly language. Those were the days.