In nearly all the assembly source files and published listings I read up to the early 1980s, the labels, mnemonics, and operands were written in all uppercase. Just a few years later, I noticed 80x86 code was mostly in all lowercase, as well as later code for other CPUs. By that time, all uppercase code seemed to have disappeared.
When did the switch to all lowercase assembly happen? Were there any specific CPUs or platforms that introduced or popularized this style?
It changed when people learned that a) they HAD lowercase, b) typing in uppercase is a pain in the neck, c) that it doesn't matter what case it's in.
It's just the natural progression as capabilities expanded.
Simply someone started and said "What the heck am I doing this for?".
The earliest published example I could find (through a non-exhaustive search) was for a Z80 routine published in Dr. Dobbs in Oct of 1981.
That said, I'm pretty sure when I was doing assembly back in the early 80s, I, too, used uppercase "because assembly".
But, yea, typing in upper case is a pain in the neck, frankly. Especially since I haven't had a CAPSLOCK key in 15 years.
I guess there is no straight answer, as it's a fuzzy move spread across a long time, many machines, OSes and applications. Also, with each generation, systems usually start out with only one case. If restricted to a single case, western (Latin) cultures used to fall back to Roman times by using upper case only (*1).
When did Assembly code begin being written in lowercase?
I guess the most important point has already been touched by Will's answer:
Both of this depends on hard-/software development, including the adoption of codes providing lower case at all and OS input routines no longer uppercasing everything entered by default. Development varied on machines, thus there is no specific point in time.
But there are maybe a few additions more to habit and psychology.
Then there came along a generation of programmers that first used the lowest cost devices possible - teletypes - and thus got used to the look - except to the computer, everything typed was upper case.
This generation of systems, nowadays mostly summarized as 'Minis', 'felt' several issues:
As a result, input files came in whatever case typed. Without central conversion in file upload or storage, programmers added internal case conversion to their Assemblers (*3). As a result, files not only stayed the way they were created, but also all output showed the verbatim input, not converted to upper-case like before.
Overall it was a process repeated with each new field computers reached, as early Micros showed the same limitations that mainframes and Minis had when being introduced: only caps. Just take the 'big three': TRS-80, Apple II and Commodore PET. They all started out in upper case.
It wasn't until the mid 80s that lower case was really hassle-free on all common platforms - and the overwhelming number of them being Micros, running on software ported from, or at least inspired by, Minis (*5).
In some way it marks a generation shift, as everyone after that could use a case-insensitive Assembler without any pressure to use upper case; they simply did it, never learned different and the world moved on.
In fact, the mid/late 80s also mark the moment in time when this development in turn influenced the 'old' world of mainframes. It was around that time that mainframe assemblers started to allow bells and whistles unheard of before ... like
Well, the new generation got its will, even on old iron :))
*1 - Lower case letters were added rather late, starting around the 4th century and only in handwriting. It wasn't until the 8th century that "Minuscules" looked mostly like we know them today.
*2 - That means, any input was turned into upper case processed and outputted as such, so all seen was upper case, regardless how it was inputted.
*3 - A mode nowadays called case-insensitive :=)
*4 - A seriously odd hack. Input-wise it involved connecting the shift keys to one of the game inputs, while output was handled by using Inverse characters as upper case and regular ones as lower - all still using upper case glyphs. Sounds weird, is weird, but after some time one gets used to it and it feels fine. That is until using a different computer again. :))
*5 - By then the percentage of programmers of mainframes or even minis started to become invisible compared to the all present desktop micro.
PRINT CHR$(97) would output a lowercase a?
It depends on the local culture. If you look at man pages from 1st or 2nd edition Unix, then it appears they always did use lower case. On the other hand, in DEC we tended to write in upper case.
There are two drivers for this as far as I can see: (1) the I/O devices you have available, and (2) the code you've been exposed to. I wrote MACRO-11 in upper case because all the MACRO-11 I read was written in upper case. I don't even recall whether the DEC assemblers were case-insensitive; probably they were.
In short - I dispute the notion that there was 'a time' when this happened.
P.S. Come to think of it, I also wrote BLISS in upper case (the compiler didn't care), simply because all the BLISS code I read was in upper case. You can perhaps regard this as adhering to convention for the sake of readability: today, I use Java conventions for Java, Python conventions for Python, etc.
Just guessing here, but the answer might be related to whether the typical input method (punch cards, teletype, video terminal, typing code using the built-in keyboard and character generator) for editing or entering assembly language code into a system defaults to UPPERCASE, or is even limited only to such representation of text. Ditto for printers used for printing out the program code listings.
For instance, the Commodore PET boots up in a mode which only allows uppercase characters. Granted, you can switch to an alternate character set which allows mixed case but at the expense of losing access to many block graphics characters (see PETSCII). On such a system, programming in uppercase is the natural default.
Conversely, programming would be awkward on a system which defaults to lowercase (mixed case) if the assembler or machine code monitor only accepted uppercase mnemonics — that is, if the programmer were required to constantly hold down the Shift key or keep the Shift Lock or Caps Lock function enabled while editing the code. On such a system, programming in lowercase is the natural default.
Computers started out as programmable number-crunching, code-breaking, data processing, simulation, and automation devices. For such purposes, all-caps text is sufficient. The glorified typewriter thing (word processing) only came later, and was perhaps the first application that actually required implementing lowercase?
The uppercase/lowercase usage in program code listings likely reflects these developments.
RT-11 Realtime PDP-11 Operating System:
All code was written in MACRO-11. A short experiment of writing some of the utilities in C freaked out the attorneys and was stopped.
As of 1979, all source editing was done on VT100s or better, which readily handled cased input and display. Printers were capable of displaying both cases. Some still did compressed descenders to save a couple of pins in the print heads. (Incidentally, compressed descenders have reappeared in my Jeep's instrument and Sirius-XM radio displays – UGH!)
As RT-11 architect (in the 1980s and early 90s), I introduced a concept I called semper shiftus. The maximum MACRO-11 symbol was 6 characters long. It was case insensitive because it was converted to rad50 (don't ask), which was stored as uppercase. However, the visual representation of a symbol could have 6 bits of information added by using camelcase. The cases of individual letters could give more clues about the meaning of the name.
For instance, PMTBLK, when displayed as pMTblk, could more easily be understood as "pointer to empty block".
This concept was not accepted with universal joy.
Back in the 1970s, most line printers only did upper case. Some had lower case, but the longer print chain slowed them down considerably. So you couldn't rely on all printers having lower case, so you only used it occasionally.
Moreover, until the late 1970s you'd be lucky to have an input device that did lower case. Punched cards were upper-case only. So were teletypes. I typed (and edited, and printed out) my PhD thesis in 1975 using a paper-tape device called a Flexowriter, but they were expensive and scarce (I used them at night when the queues were shorter).
Lower-case started to become widely available around 1980, with the advent of VDUs and dot-matrix printers. It probably affected assembly programming rather later than most things because when you're dealing with short instruction names like ADD and SUB the readability benefit from lower-case is rather marginal. Certainly I was programming in assembler from 1977-1982 and it never occurred to us to use lower-case, even if it was becoming possible.
Incidentally some of my colleagues who wrote assembler were quite slow to move off punched cards. They found that inserting and removing cards from a deck was an intuitive way of editing an assembly-language program. Probably says something about the quality or performance of the interactive editors available at the time.
From personal experience, I started programming in assembler on a BBC micro in 1982. The documentation at the time used upper case, probably for historical reasons but perhaps to make it easy to identify code vs English text, so I did the same until I found out by accident that lower case was also valid. I tended to use upper case though because my teletype couldn’t print lower case characters as upper case even though it had an 8-bit paper tape punch. In later years, using lower case by default allowed the regression to camel-case, once the programming community had got used to using variable names of more than one character.
The PDP-1 computer from DEC built in 1960, used lower case for Assembler. I seem to recall that upper case was used for some special purpose, like referencing a macro parameter.
You can see some PDP-1 assembler for the Spacewar program here
There was, once, a compelling reason for all programs to be written in all-caps: not all computers have always supported lowercase. This convention stuck longer for the languages that were typically used on those machines. In particular, Intel 8086/8088 assembly code was designed to be similar to 8080 assembly code, and some of the original microcomputers with an 8080 or Z80 CPU, such as the original TRS-80, did not have lowercase. You also see it with languages that were originally used on mainframes, such as Fortran and COBOL.
The shift seems to parallel the transition, circa 1980, from uppercase keywords in languages such as Fortran and Algol to lowercase keywords. Most older languages that started out with keywords like BEGIN and END also accepted begin, rather than reject programs where the intent was obvious. Then, newer languages made those the default, or even mandatory. C, designed on minicomputers of the early 1970s without already-obsolete mainframes or early 8-bit microcomputers in mind, was one of the first major languages to only accept lowercase keywords.
I have the impression that this became a stylistic choice. lowercase was the newfangled way to program, ALLCAPS the old-fashioned way, and only someone with a dinky little computer would need it. But it was probably mostly a matter of convenience. Once programmers switched from card punches to keyboards, lowercase was easier to type.
In the late 60s when I learned assembly (first for a Honeywell 200, an IBM 1401 clone more-or-less, and then the GE 635) we submitted our programs on punch cards, which had only uppercase. Not too long after Dartmouth Time Sharing went live on the 635, a fellow student wrote a macro assembler which ran (and stored our code!) on the time sharing system, letting us get rid of the punch cards.
Nevertheless, our terminals were model 33 and 35 teletypes. Again, only uppercase. And, of course, the line printer also had only uppercase.
As I remember, and I could be wrong, even the early CRT terminals I first encountered in grad school on Decsystem 10 circa 1972 were upper case only. But we did have a primitive WYSIWYG editor, written by one of our professors. Night and day in terms of productivity, but still not particularly pretty.
I wish I could remember when I first saw a terminal with lower case, but I can't.
It may be worth noting that in the early days of computing, many documents consisting entirely of human-language text which was intended to be read solely by humans were reproduced in all caps. Photocopying machines were uncommon, and while typing a document on a mimeograph stencil would be more convenient than typing it onto a stack of cards, there was no convenient way to copy a mimeograph stencil into a form that could be distributed and allow multiple recipient to independently run off their own copies. If a supplier of computer equipment or software for it wanted to distribute documentation to customers who had printers, including the documentation in a form that could be reproduced easily using computer equipment could be cheaper and more useful than having to produce the document using a mimeograph, Linotype, or other such means.
If the documentation for how a language works is going to be printed in all caps, any language examples will need to be likewise, regardless of whether the language designer would have favored the use of all caps over lower case or mixed case.
I remember that in the early 1970s the Math Faculty at my university had a Honeywell GECOS system with a dual-case printer.
Most input was via IBM 2741 selectric typewriter, which allowed me to submit assignments for most of my essay courses on computer printout, rather than having to use a typewriter to directly type them on paper as most other students did. (Minor corrections were trivial, as opposed to having to retype the entire page.)
Input from punched cards (EBCDIC or BCD) was also possible, but those characters were by default all lower-case when sent to the printer (much easier to read than all upper-case).
The oldest personal code I could find in my archives is from 1976:
$ ls -l ap2c.txt
-r--r--r-- 1 ray ray 1245 Feb 19 1976 ap2c.txt
$ more ap2c.txt
.titl FAST];INTERRUPT HANDLER and DIO RTC INTERRUPTS.
.nrel
.ent INTER
.extd TOP,STACK,CLOCK
.extn XOUTC,XOUTT,XINT,XINC
INTER: inta 2];Interrupt Routine.
skpdz DIO
]jmp XDIO
]skpdz RTC
]jmp XRTC
]skpdz TTI
]jmp @.INC
]skpdz TTI1
]jmp @.INT
]skpdz TTO
]jmp @.OUTC
]skpdz TTO1
]jmp @.OUTT
]sta 3, DIO3];clear garbage interrupt.
]lda 3,CLEAR
]add 2,3
]sta 3,.+1
]0
]lda 2,FALSE];Stack false interrupt message.
]jmp STORE
XDIO: sta 3,DIO3];DIO Interrupt.
DLOOP: dias 3,DIO];restart device.
]lda 2,CALARM
]movl 3,3,snc];select CRT or TTY.
]lda 2,TALARM
STORE: lda 3,TOP];get stack pointer.
]inc 3,3
]addl# 3,3,szc];check for wrap around.
]lda 3,STACK
]sta 3,TOP
sta 2,@TOP];store AC2 on stack.
]skpdz DIO
]jmp DLOOP]];loop if DIO has interrupted again.
]skpbz TTO1
]jmp DIOX]];if stack was empty, send a null
]sub 2,2 ]];character to CRT and TTY to cause interrupts.
]doas 2,TTO1
]doas 2,TTO
DIOX: lda 3,DIO3
]inten
]jmp @0
XRTC: nios RTC];RTC interrupt.
]isz CLOCK
]inten
]jmp @0
DIO3: 0
CALARM: 101461
TALARM: 130403
FALSE: 134070
CLEAR: nioc 0
.OUTC: XOUTC
.OUTT: XOUTT
.INT: XINT
.INC: XINC
.end
I believe that was for a "real time lab" course, where we wrote programs that monitored and controlled an electric train using a mini computer.
I managed to save one mail message from the professor for that course:
From: mamalcolm
Date: Fri Mar 12 1976 17:21
Subject: realtime train labTHE NOVA IS AVAILABLE NOW. IT RUNS FAIRLY WELL, BUT ABOUT EVERY 30 OR 60 MINUTES IT CRAPS OUT. SYMPTOMS ARE THAT IT HALTS ON NON HALT STATEMENTS. THE REMEDY IS TO WACK THE NOVA CABINET ON THE SIDE WITH YOUR HAND AND TRY AGAIN. IF THAT DOESN'T WORK, TURN THE POWER OFF AND THEN BACK ON AND TRY AGAIN. IF THAT DOESN'T WORK, SEND ME MAIL. GOOD LUCK.
Given that he could type the subject in lowercase, I've no idea why the body is in TUC.
