Emphasize "Why Haskell?" on haskell.org landing page

21

This. Let’s face it: We’re not coding Haskell because a strictly rational decision made us choose it, but because it touches our mathematical sense of beauty, deep inside.
Which still can become a rational reason to pick Haskell in your business, because the devs you hire will be more engaged and more happy.

6 Likes
23

Oh that’s funny, I also changed our messaging platform to an event sourced architecture while keeping everything running :sweat_smile: (We had more like 40-50k LoC, but still)

And this was 6 years ago when I’d only been programming for like 3-4 years (with no formal CS background :upside_down_face: )

2 Likes
24

Please comment on the specific proposals.

I think it’s incredibly hard to keep a holistic view on syntax and judge readability and asthetics.

This is one of the reasons I keep mentioning language specifications: they force us to think about the language holistically. Which is even moreso important when it comes to syntax.

GHCXXXX is more of a popularity indicator of extensions. There’s no design involved.

3 Likes
25

I like the initiative and agree with the other commenters that the concrete wording of the pitch would benefit from additional work. Thank you for taking this on.

How would I formulate it? I think the best way to do the pitch is to identify the sort of people you want to reach. I’m going to first braindump a bit. Personally, Haskell is my favourite general-purpose programming language:

  • Functional programming is a great way to describe solutions to problems, and I can drop to imperative-looking programming when necessary;
  • It hits a sweet spot of providing both “good strong type system” and “good library support” that I think is pretty close to a unique selling point;
  • It is garbage-collected and doesn’t force me to manually manage memory or rearrange all my code to satisfy a borrow checker;
  • The strong type system gives me so much more confidence that the programs I write are correct; and
  • I love being close to the research community, so I can apply advanced techniques to real problems.

So, who do we want to reach? I agree with @LaurentRDC that we should identify and reach out to several groups, and tailor the pitch for each:

  • Beginners. Haskell is a decent language to learn to program in. I’ve seen it used effectively with first-year uni students, but there are some shortcomings around libraries, an overly polymorphic Prelude, and error messages. The plus sides are an easy evaluation model to teach, a type checker that stops you from making many errors, and a clear distinction between pure and IO-using code that makes it harder to develop certain bad habits;
  • Experienced programmers who are curious about Haskell, because they want to see what this “FP” thing is all about, or have heard a “Beating the Averages”-style argument about how programmers in advanced languages can be radically more effective. The idea that learning a radically different language like Haskell or Lisp makes you a better programmer remains true, IMHO;
  • Individual developers who want to get things done, and want good tools for this. Haskell’s maintainability and “fearless refactoring” are good selling points, but Haskell is also good for starting projects! I remember a conference talk (couldn’t say which or where, sorry) where the speaker said Haskell let him write quick hacky code faster and better than other languages. This is a great advantage. It’s also really useful to sketch systems by their types, which suggests a lot more about software design than class diagrams or header files. (We’ve done this several times at work, and it’s been very useful for greenfield work.) There’s also a broad base of libraries for common tasks (particularly in the web space) without the high level of ecosystem churn in libraries (JS) or packaging systems (Python).
  • Developers working on larger projects as a team, or preparing a pitch to management to trial Haskell at their jobs. Standout features to me here are smaller code volumes (in part because the type system lets you get more from free via the typeclass sytem), maintainability (fearless refactoring, lower TCO, ability to evolve software design more easily, clearer contracts between modules/packages, etc…), decent library base.
  • Language enthusiasts. Haskell’s one of the best vehicles to do cool PLT things and get them into the hands of people who will use those things to solve real problems. I’d put the grad students that @LaurentRDC flagged in his post here.

I think the interactions between the final three groups could make a good engine to help the Haskell community thrive. A strong research community is part of and helps seed the final group (Language Enthusiasts, which also contains researchers and skilled amateurs (in the best sense of the word)). This group makes the language such a powerful lever for the individual developers who need long levers to build their ideas with, and the presence of a strong cohort of practical individual enthusiasts makes the language attractive for teams (including startups and businesses, who can then maintain open-source libraries). At least, that’s one theory, but if you believe it, it means it’s worth having a strong pitch for all three.

I think once you have successfully pitched people, only then do you help them get started. This means not talking in detail about tools during the pitch, but making the “getting started” page an opinionated on-ramp. This lets them begin start experiencing Haskell without getting fatigued looking at decisions they don’t know how to make. To that end, I would point people (only) to GHCup and Cabal. I like Nix, other people like Stack; let’s put that all aside and make the on-ramp as simple as possible.

And having written all that, I realised that I’ve completely forgotten a few important things, that should appear somewhere as concrete data points:

  • Types help, but it’s not obvious how until your type system becomes powerful. Type classes, completeness checking, type holes, servant, etc., all apply here. I think you need to put the tool in people’s hands to help them really see the possibilities;
  • Laziness is so much more powerful than it first appears, and it’s not obvious when coming from a strict language background; and
  • Haskell solutions to things can have an incredible elegance to them. Off the top of my head, there’s the examples in Hughes’ Why Functional Programming Matters, the case studies in Algebra-Driven Design, and Justin Le’s Advent of Code examples (of which this one involving Free Groups and Group Homomorphisms is a standout).
  • And who could forget combinator-based solutions to all sorts of problems? Parser combinators are the prime example, but generally you solve a problem for your atomic elements, lift it through data structures using something like traverse, and suddenly it becomes and incredibly flexible and general toolkit.
9 Likes
26

Even if some people want to make Haskell hard to read, there is still its lambda calculus core, which nobody can take away from you.

27

Hey folks, this thread is great. I’ve already seen a lot of good proposals.

Putting my project manager hat on, I challenge you to find one impactful, non-controversial change out of the ideas already suggested, make a PR to GitHub - haskell-infra/www.haskell.org: www.haskell.org site source, and get it deployed in the next week. Do you think it is possible?

We need more people who feel comfortable actually making changes to Haskell websites. I’ve seen too many good threads peter out from perfectionism and lack of operational experience. I give you permission[1]! Go for it!

(And maybe start doing bugfixes to the site while you’re there…)

  1. Note there is actually a Haskell.org committee, I think, so my “permission” is a spiritual thing rather than a legalistic thing :stuck_out_tongue: ↩︎

11 Likes
28

Thanks for the encouragement. My impression is that governance, i.e. who has final authority to accept changes is a bit unclear; at least i didn’t. This is something valuable to include in regular call to actions as you did just now to speed things up.

I’ll start with the subheadline Focus on Haskell benefits in main (sub)headline by malteneuss · Pull Request #337 · haskell-infra/www.haskell.org · GitHub, which we can probably get through the fastest.

2 Likes
29

If you look at the Community contributions section of the README, you see a link to “the PR policy of this repository” which should explain how acceptance of changes is determined. Perhaps it’s not clear what “the committee” is? But that’s the repo of the Haskell.org committee, so that’s the committee in question, details of which can be found at Haskell.org Committee.

Perhaps this is not as clear as it could be. Can you suggest an improvement?

30

A second PR focusing on the content: Add "Why Haskell?" benefits section to main page by malteneuss · Pull Request #338 · haskell-infra/www.haskell.org · GitHub

I’ve toned the sales pitch down a notch, and added many ideas and formulations from several users in this thread (thanks for the suggestions).

3 Likes
31

Yes:

32

Thanks

I’m not sure what “that page” and “main langing page” refer to. (Maybe www.haskell.org for the latter?).

Committee members already get GitHub notifications for PRs and issues, so I think this would be redundant.

1 Like
33

seems great! There are some things I would rephrase to sound more idiomatic - is it ok if I make comments on the PR, or is here better?

34

Ideally on the PR, because it’s easier to reference the precise location and encourages specific formulations.

35

Oh I see. “Haskell.org, Inc.” is the name of the non-profit. Maybe we should change “Haskell.org” to “Haskell.org, Inc.”?

1 Like
36

This is all true, and it’s a brilliant argument: “total lifetime cost” is a cost saving argument, and those are the way into any decision-maker/entrepreneur/investor’s heart.

I’m not so sure I agree on the “somewhat true of any statically-typed language” claim though. When trying to make sense of a large extraneous code base, seeing pure functions is a blessing. If I’m trying to follow the thread on some specific behavior I can safely disregard any pure functions that don’t affect it directly, eliminating possibly tons of branches of code to analyze. That isn’t true in any other language, statically-typed or otherwise, as any function might possibly mutate the thing I’m tracking.

As an (over)user of STM (and FRP, but that’s out of the scope) I couldn’t agree more! And I would dare go even further, making the entirely-subjective-and-non-scientifically-proven claim that the lack of anything remotely similar in other languages gave birth to the awful microservices architecture, that relies on offloading the burden to some external message broker, but adds a lot of new headaches.

5 Likes
37

Nice, I’m glad to see you’ve made the next steps!

I worry that you may not have chosen the least controversial place to start. :see_no_evil_monkey: So don’t get discouraged if that particular “small” change gets bogged down. Lots of people will have strong opinions about the first words that a site visitor will read.

I’m still hopeful, of course. But if that particular change stalls out, there are lots of other things that could be improved. Getting other changes through would help improve the level of trust the committee has in your work, which would make it easier to get consensus in the future.

I also have strong opinions. :smiley: My own suggestion for a better tag line would be “A radically different paradigm for fun and maintainable software”. It hints at the fact that Haskell is truly different, and hits the two main benefits that appeal to me about the language. I’d want to follow up with facts about its “seriousness” to offset the danger of being mistaken for a toy, but I’d definitely want to start with a pure expression (lol) of why Haskell is valuable.

For inspiration, I think https://sass-lang.com/ is especially good. It quickly paints a picture of what Sass provides, and follows up cleanly with features of the language and community. Unsurprisingly, it looks good, too.

For comparison, here’s a bunch of language website tag lines:

  • Rust: “A language empowering everyone to build reliable and efficient software.”
  • Python : “Python is a programming language that lets you work quickly and integrate systems more effectively.”
  • Ruby : “A dynamic, open source programming language with a focus on simplicity and productivity.”
  • Scala: “A programming language that scales with you: from small scripts to large multiplatform applications.”
  • Go: “Build simple, secure, scalable systems with Go”
  • PHP: “A popular general-purpose scripting language that is especially suited to web development.”
  • Fortran: “High-performance parallel programming language”
  • C#: “The modern, innovative, open-source programming language for building all your apps.”
  • Swift: “Swift is a general-purpose programming language that’s approachable for newcomers and powerful for experts.”
  • Java: “Oracle Java is the [number one] programming language and development platform. It reduces costs, shortens development timeframes, drives innovation, and improves application services. Java continues to be the development platform of choice for enterprises and developers.”
  • TypeScript: “TypeScript is JavaScript with syntax for types. TypeScript is a strongly typed programming language that builds on JavaScript, giving you better tooling at any scale.”
  • Matlab: “Math. Graphics. Programming. MATLAB is a programming and numeric computing platform used by millions of engineers and scientists to analyze data, develop algorithms, and create models.”
  • Sass: “CSS with superpowers. Sass is the most mature, stable, and powerful professional grade CSS extension language in the world.”
  • Octave: “Scientific Programming Language”

I find them to be a mix of outcomes, features of the language, and benefits of using the language.

9 Likes
38

I beg to differ.

I think what’s more important for the regular entrepreneur is:

  • time to market (quick prototyping)
  • commercial support (solutions, integrations and consulting companies)
  • hiring market (access to cheap labor as well as strong talent)

“total lifetime cost” is something very hard to grasp. We’re assuming entrepreneurs think and care about things like “technical debt”, while the reality is that they’re more worried to show something to survive the next fundraising.

Quick prototyping is true for Haskell, to an extent. But I’d say there are languages that allow faster prototyping. Haskell does have a bit more “up-front” cost than, say, Python. The main difference is, that you almost always want to throw away your python prototype, since it’s impossible to refactor it. Then we could go ahead and say “refactoring is amazing in Haskell”, but refactoring in its own has no immediate business value and will not excite most entrepreneurs.

So in a way we have “better than average” prototyping and a huge edge in terms of “turn your prototype into something production ready”. That’s a bit against the idea of prototyping (you should throw it away and start from scratch), but I think it’s true and there are companies that could provide evidence of such lifecycles. This is Haskell’s real strength.

11 Likes
39

I actually agree with what you say, but you surely want to attract the juicy-decade-overarching-mindset enterprise and not just the funding-desperate-quarterly-thinking startup :slightly_smiling_face:

I like your “conversion” argument a lot (turning Haskell prototypes into products) and reading it just after all those taglines from the message above gave me an idea :light_bulb:

Haskell: “the language that grows with you”

12 Likes
40

This is a pretty cool slogan, imo… because we can interpret it in different ways:

  • business growth: going from prototype to production in no time
  • engineers growth: there’s always something new to learn (frp, lens, effects systems, …)
  • academics growth: contribute latest functional programming research to a first-class compiler (linear types, DH, …)

And it implicitly also relates to the “stability vs research” tension that I think is unique to Haskell.

Maybe we can extend it:

“Haskell: where stability meets research. A language the grows with you.”

7 Likes