"Avoiding success at all cost" is the informal motto behind Haskell, coined by Simon Peyton Jones. In his 2017 talk Escape from the Ivory Tower, he puts up this slide with a knowing grin, and the audience laughs, because the ambiguity is the point.
It can be read two ways: "Avoiding (success at all cost)", don't pursue popularity if it means compromising on what matters. Or "(Avoiding success) at all cost", stay niche, deliberately, so the research stays free.
The punchline is that both readings are true, and they reinforce each other. Haskell stayed pure because it stayed small, and it stayed small because it stayed pure. That feedback loop, that willingness to trade adoption for integrity, is what made Haskell, Haskell.
The success vs. cost of language design
There are always tradeoffs in any software design, and programming language design has no exception.
Every language design decision that made a language "successful" (popular and widely used in industry or education) comes with its own "cost": being unsafe, limited in expressiveness, or having poor performance.
Whether the "cost" is actually a problem depends on the scenario and the goal. Python and JavaScript are both expressive and beginner-friendly by being dynamically typed, sacrificing type safety and performance. Java, in contrast, uses a much safer, optimization-friendly type system but is far less expressive. A similar tradeoff shows up in memory management: "managed" languages (whether by ARC or garbage collector) are easier and safer for most programmers, but are considered slower than languages "closer to the metal."
None of these costs really prevent a language from becoming immortally popular. Most languages find a sweet spot, accept the tradeoff, and move on.
Haskell refused that deal.
Being research-oriented means the goal is to pursue some "ultimate" things: the ultimate simplicity of intermediate representation, a type system where safety and expressiveness coexist, the ultimate compilation speed and runtime performance, the ultimate concise and elegant syntax... It has to be something very difficult, probably endless and impossible, to fully achieve.
This made every language decision in Haskell very hard and very slow, because almost nothing can be sacrificed. That's why Haskell insisted on laziness to "guard" purity regardless of the problems of call-by-need. That's why a decent IO mechanism was missing for the first four years after the project started, until Philip Wadler found Monads. That's why Type Classes, first proposed in Wadler's 1989 paper, took years to implement and popularize.
It doesn't mean there is no compromise in Haskell at all. It's just minimized as much as possible. When an audience member asked why both Haskell and OCaml, which look quite similar at a high level, have survived, SPJ replied:
There's just a different set of compromises.
The success vs. cost of language design process
Another common but extremely controversial topic of programming language design is about its design process: Would you prefer dictatorship or a committee (in other words, a dictatorship of many)? Would you prefer being proprietary or standardized? In which form would you write the standards: natural language, pseudo code, or formal semantics? How many and how frequently breaking changes dare you make? Would you let the open source community get involved?
I think there is no single answer for all those questions. The majority of popular programming languages came about, and are still going, on very different paths.
Python, whose creator Guido van Rossum is known as the "Benevolent Dictator For Life" (BDFL), still played the central role (until July 2018) in Python's development after the language got popular and adopted an open source, community-based development model. This directly contributed to the fact that Python 3, a breaking (not completely backward-compatible and not easy to port) but good (in terms of language design and consistency) revision, could still be landed despite significant community pressure. Many languages (Ruby, Perl, Elm) also chose to follow this route.
JavaScript, widely known as being created by Brendan Eich in 10 days, in comparison quickly evolved into a committee-governed (TC39) and standardized (ECMAScript) language due to both the open nature of the Web and its own rapid adoption. But Brendan, as the creator, wasn't even powerful enough to push the committee into landing ES4, which was also a breaking but much better revision. Instead we got ES5 (Harmony), a backward-compatible yet much less ambitious version, due to many political fights between different parties (Mozilla, Microsoft, Yahoo, etc.), and history wasn't changed. Even the recent rise and yearly release of "modern" JavaScript (ES6/ES2015, 2016, 2017...) is mainly driven by the new generation of committee parties (plus Google, Facebook, Airbnb, etc.) and still in a very open and standardized way.
Even the history and progress of two rather similar languages can be so different, not to mention more proprietary languages such as Java from Sun/Oracle, C# from Microsoft, OC/Swift from Apple (though the latter was open sourced), or more academic and standardized languages like SML and Scheme, which both have standards written in formal semantics.
So it's not surprising that Haskell also chose its own unique process to suit its unique goal. Although it's rooted in academia, it chose a rather practical, less formal approach to define the language: the compiler implementation over standardization (plus many "formal" fragments among papers), which is more like C++/OCaml from this point of view. It has a committee, but instead of being very open and conservative, it's more dictatorial (from the perspective of average users) and super aggressive in terms of making breaking changes. As a result, it trained a group of very change-tolerant people in its community. All of these quirks combined work very well and help Haskell avoid "becoming too successful too quickly."
The irony
Here's what makes the motto so delicious: Haskell "avoided success," but its ideas didn't. They just showed up wearing other people's clothes.
Monads became Promises and async/await. Type classes became Rust's traits. Algebraic data types became TypeScript's discriminated unions. Pattern matching is now shipping in Python, C#, and Java. Immutability as a default went mainstream through React and Elm. Even the Maybe/Option type, Haskell's answer to null, is now in Swift, Rust, Kotlin, and arguably every modern language designed after 2010.
Haskell didn't mass-adopt. It mass-pollinated. The ivory tower turned out to be a lighthouse.
I see echoes of this in my own world. React was mocked when JSX was first shown at JSConf 2013. Hooks were dismissed as black magic. Concurrent Mode broke backwards compatibility in the name of correctness. These choices made React harder to adopt, but they were the right ones.
End thoughts
SPJ titled his talk "Escape from the Ivory Tower." But I think the real escape was never about Haskell becoming an industry language. It was about Haskell's ideas escaping, into languages, frameworks, and mental models used by millions of programmers who may never write a line of Haskell.
That might be the most successful way to avoid success.