Historically, interpreters and compilers have limited the length of identifiers. For example, FORTRAN I and II considered only six characters to be significant, and LISP 1.5 forbid symbol names to exceed thirty characters (although the infrastructure for storing the names would have allowed for arbitrary lengths).
What was the first system, i.e., an implementation of a programming language*, not to place such limitations? The only factor constraining identifier length should be the available memory on the computer, modulo overhead for the compiler's coding, the run-time environment, and so on. All characters in an identifier must be significant.
According to a note by Arthur Sale in the sixth Pascal Newsletter (on page 46), the Pascal compiler for the Burroughs B6700 was one such system by 1976:
Another [issue in program portability], not so obvious, is the practice of allowing any-length identifiers, but permitting only the first few n characters to be significant ignoring the tail. If a program is compiled on a computer with true any-length identifiers (e.g. B6700), then it is quite on the cards that it will be compiled incorrectly by some other computer without warning, as if the names are
TEMPATTOPOFFLUE. No, identifiers must be true any-length, or fixed up to a length n with at the very least a mandatory warning or better an error thereafter.
* Language specifications often leave details about identifier length up to the implementation. For example, Pascal requires at least eight characters to be significant (case-insensitively). Algol says nothing, giving only the production rule for
<identifier>, which of course generates an infinite number of strings.
C has complicated rules regarding identifiers, where the nature of a declaration can determine the minimum number of significant characters. Because of the desire to maintain compatibility with existing systems on which C must run, C89 retained the obnoxious old FORTRAN-like rule that only six characters are significant in “external names”. The C standard rationale says
The decision to extend significance to 31 characters for internal names was made with little opposition, but the decision to retain the old six-character case-insensitive restriction on significance of external names was most painful. While strong sentiment was expressed for making C “right” by requiring longer names everywhere, the Committee recognized that the language must, for years to come, coexist with other languages and with older assemblers and linkers. Rather than undermine support for the Standard, the severe restrictions have been retained.
In contrast, the Common Lisp standard implicitly requires identifiers to be unconstrained. Identifiers are effectively first-class entities in Lisp (known as symbols); one attribute of a symbol is its name, which can be any string. Equivalence of symbol names is determined by a typical comparison of strings. (For historical reasons, case conversion is applied by default, although this can be changed.) See Chapter 2, “Syntax”, for details. I would not be surprised if a Lisp implementation is the answer to this question, given that symbols were often used for strings in older dialects of the language; e.g., you might see
(PRINT '|PROCESS ENDED|) or
(PRINT 'PROCESS/ ENDED) in Maclisp.