A History of Being 'Obsolete'
To understand Lisp’s survival, you first have to understand the many times it was supposed to have vanished. Lisp, whose origins trace back to 1958, was the language of choice for artificial intelligence research for decades. When the “AI Winter” of the late
80s and early 90s hit, funding dried up, and many of the specialized hardware and companies built around Lisp collapsed. Around the same time, languages like C++, and later Java and Python, rose to dominate university curricula and corporate IT departments. They were seen as more practical, modern, and accessible. By all conventional measures, Lisp should have been relegated to the history books, a quirky footnote like so many other languages of its era.
The Secret Weapon: Unmatched Malleability
The first part of the answer lies in a feature that sounds esoteric but is profoundly powerful: macros. Unlike in many other languages, macros in Common Lisp are not simple text replacements. They are code that writes code. This allows developers to reshape the language itself, creating new syntax and abstractions that are perfectly tailored to the problem they are trying to solve. In essence, instead of just solving a problem in Lisp, developers can evolve Lisp into the perfect language for the problem. This makes it extraordinarily expressive for tackling highly complex, domain-specific challenges where off-the-shelf languages feel clumsy and restrictive. This is why you see it used for things like advanced query optimizers, where the rules of the problem are themselves complex and evolving.
An Interactive and Evolving Workflow
Another core reason for its longevity is its development environment. Common Lisp is designed for interactive, incremental development. A developer works with a running Lisp system, modifying functions, redefining classes, and inspecting data on the fly, without the constant stop-and-recompile cycle that defines many other workflows. This tight feedback loop is incredibly productive, especially for exploratory programming and solving problems that aren't fully understood at the outset. When an error occurs, the system doesn't just crash; it enters a debugger where the developer can inspect the entire state of the program, fix the code, and continue from the point of error. This makes building and maintaining large, long-lived, and complex systems more manageable.
Finding Its Forever Homes in High-Value Niches
Lisp didn’t survive by competing with Python for web scripting jobs. It survived by becoming indispensable in specific, high-value domains where its unique strengths gave it an unbeatable edge. The most famous modern example is ITA Software, the company that developed the revolutionary airfare search engine QPX. This incredibly complex scheduling and pricing problem was a perfect fit for Lisp's strengths. The company was so successful that it was acquired by Google, and its Lisp codebase still powers Google Flights today. Reportedly, even Google found the system too complex and well-engineered to rewrite in one of its standard languages. Other examples include a scheduling system for the London Underground and backend services for the grammar-checking tool Grammarly. These aren't trendy startups; they are mission-critical systems where correctness and power trump popularity.
Stability as a Feature, Not a Flaw
Finally, Common Lisp survived because it is a stable, standardized language. The ANSI standard was published in 1994, and it has remained largely unchanged since. In an industry obsessed with constant updates, new frameworks, and breaking changes, this stability is a feature. A program written in Common Lisp a decade ago is very likely to run, unmodified, on a modern implementation. This makes it a reliable choice for long-term projects where maintenance and longevity are critical. Developers aren't chasing a constantly moving target. Instead, they are using a finished, powerful tool to build robust applications designed to last for decades, not just a few years.
