@malteneuss is this merged ?!!
In my experience, you’re not over-claiming; that’s all exactly right[*]. And for marketing this is gold:
In Haskell, it’s possible to do truly major heart-lung-transplant refactors on a 200k-loc code base that is 30 years old. (I know, because I do that to GHC.) That is a major value proposition. Instead of having a 5-year lifetime, your investment has a multi-decade lifetime.
What @hasufell said about converting prototypes to production software is an extension of this maintainability superpower, and also worth emphasising I think.
[*] Ok, here’s the caveat. Critics reading “multi-decade lifetime” will say, “that’s all very well for your code as a platonic construct, but what about constant churn in GHC, library APIs, Cabal ? Why do we almost always have problems building any non-trivial Haskell project more than a year old ?” This may be a different issue but one we should have answers for.
2 Likes
I really like this. I forgot to mention it before, but so many of Haskell’s features and idioms make it much less likely that you feel you’re bumping your head on an expressivity ceiling. When you have a function like (<>) :: Semigroup m => m -> m -> m, no matter how many times you use it, you’re still working with ms, you don’t have to work with mBatch or some other construct. This is also true of things like parser combinators and the examples in Algebra-Driven Design.
1 Like
I would try to avoid the term “research” at all cost. It is neither actually true, nor can I imagine that decision makers are happy to read that their basic infrastructure still needs research.
Something like “actively developed” or “healthy evolution” seems more reasonable, but it is also not something I would say to sell Haskell; I feel like development of Java has been more active in the past couple of years. (Of course they have a lot to catch up on.)
8 Likes
Why? Haskell started as a research language and continues to add latest research to its repertoire (DH, linear types,…).
It seems odd to me that we’re scared to be open about this fact/our origin. Isn’t it one of the main reasons it is popular today?
Sure, we’re also trying to be more industry focused etc., which is why “stability” is mentioned as well.
The way Haskell evolves is rather controlled. We have two committees involved in that!
I think “evolution” could actually work.
1 Like
I also instinctively reacted negatively to seeing the word “research” in a slogan; not sure why, perhaps because of connotations like being hard to understand, “just a research prototype, not battle-tested in production” or “researchy (2.)”.
Perhaps “cutting-edge” is an alternative? OTOH “the latest research” sounds better than just “research” to me 
1 Like
“cutting-edge” feels a bit empty to me.
Let’s see:
“Haskell: where stability meets evolution. A language that grows with you.”
I think this is actually a bit sharper, because “evolution” relates to the second sentence.
It’s fairly vague, but I haven’t seen any other language front page word it this way. It’s a good way to stand out. We’d probably have to explain somewhere what we mean by this, e.g. in the “Why Haskell?” section:
Stability meets Evolution
Build powerful abstractions via latest functional programming principles. While Haskell’s core is rock stable, the language is constantly evolving, but does so through rigorous processes. Learn new tricks and features as you go, while relying on a solid foundation.
8 Likes
Haskell started as a research language for lazy evaluation. I think it has proved what is and isn’t possible when building a system based on that paradigm. And it is far more possible than would I dared dream about if there was no Haskell to prove it! GHC is amazing, and that’s the reason why I got involved with Haskell in the first place.
Many inventions of the language were a direct result of Haskell being lazy, such as type classes for abstracting over different monads to track side-effects. For a long time, Haskell was the main language featuring type classes and monads, so all research revolving around that was implemented in Haskell.
But neither dependent types nor linear types are active research areas. DTs have been around for half a decade, linear types at least for 25 years (lower bound).
Adding dependent types or linear types to Haskell is not research, it is the application of well-known research ideas, and mostly an incredible amount of engineering. There are a lot of technical questions to answer in this process, and finding mutually compatible answers without introducing too many backwards incompatibilities is an engineering task that can result in a very well-received research publication at some academic conferences.
But this is not the same as saying “Oh, there are these researchers who are constantly trying out new ideas, and some of them work and some of them don’t. Subtext: Your developers will be very eager to try out these ideas and make your code base unmaintainable”. I think GHC Haskell is waaaaay past that stage, for at least 5 years.
Likewise, many researchers are using Haskell to implement their systems. This does not make Haskell a research language. It just shows that Haskell is good at expressing research ideas concisely; it’s the same reason why Haskell is better-than-average at prototyping. I would even say it’s best in class when your domain involves tree-structured data (e.g., ASTs), because many traversals are completely natural to formulate or derive.
Because Haskell is the result of research and good design decisions, Haskell feels more concise and principled than other languages. That’s why I enjoy using it.
“Haskell: where stability meets evolution. A language that grows with you.”
I love it 
14 Likes
Just wanted to add my support for this. I think it’s a fantastic tag line and strongly grasps my experience with Haskell.
4 Likes
Hmm: “stability meets evolution” - yes, there is something about that…wait a moment:
…there it is: “stability without stagnation” !
So what’s the difference?
2 Likes
Or an alternative: “Stability meets innovation”? “Evolution” sounds good too, but slightly odd as a contrast to stability for me, though not sure I can articulate why. In either case, seems like a great tagline, and maybe a good focal point for how to organize the “Why Haskell” section?
2 Likes
One reason I like “Stability meets evolution” is that it should apply not only to the Haskell ecosystem (somewhat aspirationally – we’re still working on stability) but also to code you write using Haskell. If it works, it will keep working when you make small adjustments (stability) but it also allows you to keep it working when making big adjustments (new features, architectures, global refactors) (evolution).
4 Likes
I actually prefer “stability meets evolution”, because it is a more positive way of making the same point.
1 Like
An alternative would be: “A language that lets your code grow with you”.
That’s admittedly a little more verbose and less catchy, but it focuses on the aspect that is probably more important for the readers.
What? 
I don’t want my code to grow (as in: get bigger and/or more complicated). 
If at all, I just want it to grow (as in: get better and/or more capable).
I think applied to “language”, “growth” is more indisputably good than when applied to “code”. (Unless someone thinks of language [definition / grammar] size. Despite the plethora optional language extensions, Haskell isn’t (and shouldn’t grow into) a “big” unwieldy language. It’s certainly not as small as Lambda Calculus (even though it mostly is just that with some syntactic sugar, but that sugar also adds up) or as some Lisps, but Haskell is still orders of magnitude smaller than, say, SQL with its hundrets of keywords.)
Interesting. If you’d ask me which language that is, I’d pick C (not C++) or Fortran (since 90, not the fixed format up to 77).
With Haskell I’d associate something like “pure and elegant”.
1 Like
And some more, also relevant:
OCaml: “An industrial-strength functional programming language with an emphasis on expressiveness and safety”
Gleam: " Gleam is a friendly language for building type-safe systems that scale !"
Roc: “A fast, friendly, functional language.”
Unison: “Unison is a friendly programming language from the future: statically-typed, functional, and a lot of fun 
”
Flix: “A powerful effect-oriented programming language”
And the worst so far:
Clojure: “Clojure is a robust, practical, and fast programming language with a set of useful features that together form a simple, coherent, and powerful tool.”
Elm: “A delightful language for reliable web applications.”
PureScript: “A strongly-typed functional programming language that compiles to JavaScript”
ReScript: “Fast, Simple, Fully Typed JavaScript from the Future”
Cobol: “Run mission-critical processes on the modern mainframe with this business-oriented language that enterprises and developers continue to rely on.”
Common Lisp: “Extensible from the Inside-Out”
C: “The lingua franca of programming”
Edith added
Chapel: “Productive parallel computing at every scale.”
Uiua: “is a general purpose array-oriented programming language with a focus on simplicity, beauty, and tacit code.”
1 Like
Another good bit for marketing.
Or the full quote, as a testimonial:
Should haskell.org show a few testimonials, randomised from a huge collection, on the home page ?
3 Likes
Good data. There’s more in this vein at the recent https://news.ycombinator.com/item?id=44018922. My attempt at a six-word tag line for general audience was
Haskell → High-assurance applications and prototyping/research
Well, Fortran and dynamically typed. Although “implicit integer” is some kind of “dynamic”, I guess