Terse

TERSE is what happens when one working assembly-language programmer decides that forty years of mnemonics were a mistake, spends a year building the alternative, and then spends the next thirty years selling it on a floppy disk.

It is a machine-level language for the Intel x86, and only for the Intel x86. It gives up nothing to the assembler: you still choose the registers, you still choose the instructions, you still know exactly which bytes come out. What it takes away is the notation. Where MASM makes you write Mov eax,ebx, TERSE lets you write what you were thinking anyway:

eax = ebx;      \ Mov  eax,ebx
bx  + dog;      \ Add  bx,dog
cat - 14;       \ Sub  cat,14
cx  & 0Fh;      \ And  cx,0Fh
dx  - 123?      \ Cmp  dx,123

That last line is the whole design in miniature. An arithmetic comparison is a subtraction whose result is discarded, so TERSE writes it as a subtraction — and swaps the terminating semicolon for a question mark to say “I only wanted the flags.” Its author calls ? the “just asking” operator.

Where it came from

Jim Neil had been writing assembly language for a living since 1972 when he first sat down with an Intel 8086, in October 1978, and found he disliked it intensely. The 8086 assembler, he wrote later, “was much more like a compiler than an assembler”: it had data typing, long symbol names, procedure definitions, data structures, a segmented address space and a plethora of special-purpose registers. His first response was reactionary — he wrote his own 8086 assembler modelled on the 8080’s, used it for about a year, decided it had made his bug rate worse, admitted the mistake and went back to Intel’s syntax.

The second response was the interesting one. Facing a large assembly project on machines with 64 KB of memory and 160 KB single-sided floppy drives — too tight for any high-level language — he designed a language instead. His account puts the idea in 1986 and the working compiler in 1987, though the sources do not quite line up on when: the 1995 article places the second project “a few months later” than the year he spent on his own assembler, which would mean around 1980, while the site’s “Joy of Hex” page dates the finished compiler to “some seventeen years” after his first programming class in the late 1960s. The article’s own “Copyright © 1987-1995” line and every version of the site since favour the mid-1980s reading. He says the compiler was itself written in x86 assembly, with fully table-driven lexical and syntax analysis and heavy use of Xlat and Lodsb. He describes it as “the last x86 assembly language program I ever wrote.”

Everything before 1996 rests on that account alone. What is externally verifiable is the launch: in 1996 the manual appeared under Neil’s own imprint, terse.com went up, and Raymond Moon’s x86 Assembly Language FAQ — the reference document for the newsgroup at the time — gained a section reading “Jim Neil has just announced his TERSE Programming Language.” Catalogue entries that date the language to 1993 have nothing behind them; neither the author’s story nor the public record has anything to say about that year.

What the language actually is

TERSE is horizontal. Neil’s central complaint about assembly language is that it is vertical — one statement per line, column-oriented — which wastes the screen of a full-screen editor and hides the shape of a routine. TERSE is free-format with multiple statements per line, and the intended style packs a thought per statement and several statements per line, with a comment column on the right.

Flow control is structural rather than label-based. Braces delimit blocks; the operator after the closing brace says what kind of block it was:

eax - 10 ? =={ eax = 1; },{ eax = 0; };   \ if eax == 10 then 1 else 0
dx = 1000; { dx-; }<>;                    \ while dx != 0: dx--

Read the second one as: initialise dx, then decrement it and loop back while the result is non-zero — a Mov, a Dec and a Jnz, and no invented label. Neil’s pitch for this is not abstraction but hygiene: “there is never the need to invert another conditional or invent yet another meaningful label. Copy and paste all day long and never have a label conflict!”

Chained and compound statements collapse the assembler’s redundancy:

es = ax = 0A000h;   \ Mov ax,0A000h;  Mov es,ax
ax + bx - cx & dx;  \ Add ax,bx;  Sub ax,cx;  And ax,dx
=ax =bx =cx;        \ Push ax;  Push bx;  Push cx
ax= bx= cx=;        \ Pop  cx;  Pop  bx;  Pop  ax

Chained assignments run right to left, computations left to right. The es = ax = 0A000h idiom is the language’s favourite example, because the x86 cannot load a segment register with an immediate and every assembly programmer therefore writes the same two-instruction dance; TERSE writes the single thought as a single statement and calls ax a work register. Elsewhere there is built-in pointer advancement (al=[bx+];), postfix + and - for increment and decrement, !21h for Int 21h, and, in comparisons, >> for unsigned above against > for signed greater than — chosen, Neil explains, because unsigned operands are potentially larger numbers, so they get the physically larger operator. The same doubling rule runs through the operator set in other contexts, where it means “a bit more work”: outside comparisons > and < are shifts while >> and << are rotates, * is a signed multiply and ** an unsigned one, and ++ is add-with-carry rather than plain addition. Comments run to end of line after a \, picked as a lowercase character that was “pleasing to the eye and not requisite for the specification of any processor operation”.

The operator choices are not incidental to the product. The manual’s selling point is that it explains the reasoning behind every operator, on the theory that a remembered reason is a remembered operator. The site’s slogan for this is that TERSE is “as simple as 2 = 1 + 1”.

The compiler that refuses to be a compiler

The design decision that makes TERSE unusual among assembly-syntax projects is that it does not generate object code at all. It generates .ASM text, and hands it to whatever assembler the customer already owns.

Neil’s reasoning is stated plainly in the 1995 article: object file formats are numerous and getting them all right is hard, so don’t. Use the assembler as a “common code generator”. The consequence is that TERSE is compatible with any object format, any linker, any librarian, any debugger and any high-level language toolchain the customer already has, and that it inherits the assembler’s directives, macros, conditional assembly, structures and equates for free. Anything the compiler does not recognise as a TERSE statement is passed through untouched — which means standard assembly can be mixed line-by-line with TERSE, and any instruction Intel adds in future becomes available the moment the assembler supports it, with no compiler upgrade. A companion program, asm2t.com, converts existing assembly source to the pass-through-compatible form so that an existing codebase can be migrated a routine at a time.

The cost is a second pass over the source, and Neil’s answer to that was to make the compiler extremely fast — written, he says, as if it were a real-time program, with fully table-driven lexical and syntax analysis, jump tables, huge I/O buffers and heavy use of Xlat and Lodsb.

The speed claim itself should be read as advertising rather than as a benchmark. The site says TERSE “compiles thousands of statements per second”; the 1995 article puts the same claim as “compilation times are measured in thousands of lines per second”. Both figures are the vendor’s own, they are not stated consistently, and neither comes with a processor, a clock speed, a source corpus or a baseline to compare against. No independent measurement of a TERSE compile has ever been published. The 23,917-byte executable size, by contrast, is a specific figure the vendor has quoted unchanged for thirty years.

The product

TERSE was never free, never downloadable and never open. Per the order page, $49 plus $9 shipping ($19 outside the US) bought a bound manual the site advertises as 220 pages — the Library of Congress record collates it as “xvii, 197 p.”, so the round number is presumably the physical extent rather than the numbered pages — with a tear-out “Memory Jogger” reference card, the complete language BNF, assembly-to-TERSE and TERSE-to-assembly lookup tables, and a 1.44 MB 3.5-inch diskette containing terse.com, asm2t.com, batch files for driving the compiler, assembler, linker and exe2bin, a reusable .com skeleton and six sample programs. The licence permits one copy on one machine, forbids networking it, and forbids copying the manual. Neil offered a 30-day money-back guarantee and shipped US orders by Express Mail.

The stated system requirements are the clearest single fact about how the language aged: an 8088 or better, 256 KB of memory, a 1.44 MB diskette drive, DOS 2.0 “or equivalent (e.g., Windows)”, any assembler using Intel mnemonics — MASM, TASM and NASM are the three named — and any editor that writes plain ASCII. That list has not changed on the site in a quarter of a century. Whatever “clearly it has been ported to other OSes” meant to observers in 2003, the vendor has never documented a build for anything but DOS.

Reception

The reception was not kind, and the record of it is unusually candid because most of it happened in one thread.

On 11 December 2003 Bryan Parkoff asked comp.lang.asm.x86 what people thought of terse.com. Michael Brown replied that it “definately doesn’t replace assembler”: it performs no instruction reordering, so peak performance still requires hand-written or inline assembly; there is no support for SIMD instructions except through pass-through assembly; and it was probably good “back in the pre-pentium days, where you only had to worry about cycle counting” but out of date for out-of-order CPUs. Toby Thain said the site’s “thicket of marketing speak and overheated boosterism was utterly impenetrable” — a fair reading of pages headed The Joy of Hex, Extreme Programming, He Laughed When I Told Him I Had Invented A New Language and I’m Not A Programmer, What Can TERSE Do For Me?, the last of which asks consumers to demand the TOP logo on the software they buy.

The most striking post is Randall Hyde’s. Hyde — himself the author of a high-level assembly syntax, HLA — wrote that he was “not at all sure” the language had been substantially updated since the days of DOS, that, as he recalled it, several people in the assembly community turned on Neil over the $50 price, that Neil had spent that period patiently answering beginners’ questions in the newsgroup, and that after sustained personal and professional attacks and after “someone decided to ‘ruin’ the product by releasing their own free version of Terse, we never heard from Jim again. What a real shame.” Ed Beroset, replying, thought it was the evangelism rather than the price that had done it, and cautioned that neither recollection might be correct. The free-software world’s own summary, in the Linux Assembly HOWTO, splits the difference: the most compact assembler syntax for the x86 family — “however, it is evil proprietary software” — with a note that the free clone was abandoned “after worthless pretenses that the syntax would be owned by the original author”, and an open invitation to build a TERSE-syntax front end for NASM. Nobody took it up.

Where it stands

terse.com is still there. Fetch it today and you get the same pages, the same claims, the same Melbourne, Florida phone number and the same offer: send $58 and a diskette will arrive. Nothing on it has been revised in roughly twenty-five years — the newest fact on the site is the Pentium 4 — and there is no download, no repository, no forum, no mailing list, no successor and no version 2. For a language whose entire distribution channel is a physical 3.5-inch floppy for DOS, “dormant” is generous.

What survives in public is thin: one PDF article, one 176-byte 99 Bottles of Beer program, a paragraph in an assembler FAQ, a paragraph in a Linux HOWTO, and a seven-message argument from 2003. The manual is scarce enough that library catalogues carry a single record for it, with the title misspelled.

Why it matters

TERSE is worth remembering for two reasons, and neither is commercial success.

The first is that it is a genuinely thought-out point in a design space most people never notice exists. The space between C and assembly language has been probed repeatedly — Wirth’s PL360, Hyde’s HLA, the structured macro packages that ship with MASM and TASM, and today’s inline-assembly intrinsics — and TERSE stakes out the extreme end of it: keep all of the machine, change only the notation. Its refusal to optimise is not a limitation it apologises for but the entire premise — the compiler, in the site’s phrase, “doesn’t generate anything without being ’told to’”, and the optimising is left entirely to the programmer. That is a defensible position, and the 2003 critique — that a language which does no scheduling is worthless on out-of-order hardware — is the strongest argument against it, made by people who had thought about it just as hard.

The second is as a case study in what it costs to be a one-person commercial language in the internet era. TERSE had a real implementation, a real manual, real documentation, a real design rationale for every operator and, on the author’s account, a decade of production use before it was ever offered for sale. It had no free tier, no source, no community, no package repository and no way to try it before paying, and it met a newsgroup culture that had recently been given NASM for nothing. What it had instead was one man’s enthusiasm, expressed at a volume that convinced very few people and irritated a good many. Thirty years later the site is still up, the price is still $49, and the language survives in the reference lists mostly as a garbled entry — commonly filed as a 1993 functional research language, which is wrong in the year, wrong in the paradigm and wrong in the field.