Computing happened in three main waves: the big iron wave, the minicomputer wave and the microcomputer wave.

Each wave made computers cheaper and more affordable, but also, initially, substantially less powerful. At each wave, operating systems, languages and other software from the previous wave was not able to make the jump over. For instance, Multics didn't make it onto minicomputers, but some fellows who had worked with Multics created something scaled down to fit called, jokingly, Unix.

Each wave opened up computing to more people, and most of those people were forever ignorant of the software that could only run on machines of the past, or institutional machines they couldn't personally afford.

Lisp, being one of the oldest languages, belonged squarely to the first wave. It started small, but grew along with institutional hardware. By the time microcomputers came around, modern Lisp wouldn't fit. It took at least 15 years from the time computers became available and affordable to ordinary consumers to the time a fully featured Lisp would run on a computer affordable to the ordinary consumer.

A whole generation of hackers had no experience with Lisp at all. Senior programmers who are now in their 50's might have started coding as kids on 8 bit micros, using BASIC (which was useless for non-toy applications and games) and assembler. Anyone younger than those people would be likewise Lisp ignorant. The result is that we have entire organizations, from very senior people on down, who don't know anything about any Lisp.

There was some Lisp action on micros, but attempts to fit Lisp into those environments only harmed LIsp's reputation more than anything: the whole "interpreted, memory-hungry and slow" stereotype.

One language which made the jump from minicomputers to micros was C. In the middle 1980s, micros were becoming about as powerful as 1970's minis, which played out very well for a language designed for efficiently programming 1970's minis. C had to make only a one-generation jump.

There were companies selling Lisp machines in the 1980's, but these were expensive minicomputers. In this intervening time, minicomputers had become a lot more powerful, and so were able to run Lisp well. But the world had long moved on to microcomputers being the hot thing. Programmers were licking their lips at the prospects of making money in a large, consumer market. That included some Lisp programmers. Some of them hit a stark reality: they had to rewrite their code in something else, like C, to get it to run well on micros. A good case-in-point is the CLIPS system (https://en.wikipedia.org/wiki/CLIPS). CLIPS is essentially a C clone of an earlier system called OPS5, that was written in Lisp. That is why CLIPS uses he Lisp-based surface syntax. That OPS5 was also rewritten away from Lisp, using Bliss.

Lisp showed a resurgence in the 1990's, and one factor we have to thank for that is that consumer machines finally started showing memories measured in double digit megabytes and clock rates pushing past 100 MHz.

Now, note how all the modern languages that borrow from Lisp are incredibly memory hungry. Javascript, Python, you name it; those things could not have ran on anything affordable in 1990. Not in their current form and the way they are used.

In summary, there has been a recurring history in computing in several waves, each one representing a big regression in hardware capabilities, accompanied by a big jump in affordability. Each wave produced its own systems and languages due to the influx of new people not familiar with the older systems, and due to the older systems having specifications that would not fit. In each wave, there were some developments similar to what had occurred in the previous wave, but in new forms.