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:
- When they finally had lower case, and
- when assemblers started to be case-insensitive.
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.
- On a mainframe side, using upper-case remained supported by (optional but default) automatic conversion. (*2)
- People continued with upper-case this out of habit, but also as
- Upper case was considered 'proper'.
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:
- Default code sets were capable of upper and lower case.
- The landscape was rather non-homogeneous, that is all lower terminals, all upper and dual case were used at the same time.
- There was no fine chiselled OS-I/O structure unifying input.
- There was no room for large intermediate layers.
- Software development was decentralized and quite fast or ad hoc.
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.
- Apple saved on character generator; lower case could only be added as hack. (*4)
- Tandy saved as well, but sold a lower case mod soon.
- Commodore could be switched into lower case mode, but would lose its graphics abilities in turn.
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
- Label names longer than 8 characters,
- Heck, at some point even variable length and even worse
- Introduction of (optional) case sensitivity
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.