[nathankleyn]

The Haskell wiki has a page called "Haskell in industry" [0] which lists all the people using Haskell in the real-world.

Some notable ones include:

* Facebook Haxl, an abstraction around remote data access [1]

* Microsoft Bond, a cross-platform framework for working with schematized data [2]

* Google Ganeti, a cluster virtual server management tool [3]

* Intel Haskell research compiler, a custom Haskell compiler used internally at Intel Labs [4]

---

[0]: https://wiki.haskell.org/Haskell_in_industry

[1]: https://code.facebook.com/projects/854888367872565/haxl/

[2]: https://github.com/Microsoft/bond

[3]: https://code.google.com/p/ganeti/

[4]: http://www.leafpetersen.com/leaf/publications/hs2013/hrc-pap...

[jayvanguard]

Anytime a technology needs to publish a list of "who's actually using this in the real world" the answer is not all that many (relative to other peer technologies). Most projects in those lists fall into the following categories:

1. It is just a small team or even one person using it and they're doing it because they really want to use that technology badly.

2. The project is some side research thing or trivially small that it could have been done using any technology.

3. It is actually just a tool or sub-system of the main system that was low risk enough.

4. The project is no longer operational, if it ever made it to that stage.

[Guvante]

While your point isn't invalid it is important to keep in mind that popularity is not a valid proxy for quality.

Also he is focusing on large companies who have huge reasons they can't use Haskell, mostly related to internal resources. If you have several hundred Java engineers (for example) you literally cannot just switch to Haskell, it wouldn't work.

[jayvanguard]

Completely agreed about quality. Popularity is highly correlated to actual utility though.

Lisp falls into the same category. High quality and very interesting but it will never, ever gain widespread use. Don't believe me? A half century of proof exists. Haskell is already at a quarter century.

Both are very cool and everyone should learn them to some degree because they will make you a better programmer but neither will ever be used widely. They just aren't appropriate for most general purpose programming tasks.

[dasil003]

I would be wary of painting Haskell and Lisp with the same brush. Yes, on first glance they both appear to be "difficult" languages that are over the heads of the average programmer. However they take very different approaches.

Lisp gives the programmer maximum raw expressive power. This appeals to lone wolves and autodidacts, but it completely punts on the issues of standards, teamwork and maintainability.

Haskell on the other hand, promises a direct solution to a huge swath of problems that are experienced across the board in software development today. The pitch is essentially an extension of what Sun used to sell Java in the 90s: it makes your code safer and more maintainable. Except Java only really did that for memory management in a C-dominated world, the type system gives you barely anything in that regard, so you still have just as many NullPointerExceptions as you suffer from lack of types in languages like Ruby. Haskell type system gives you infinitely more meaningful safety, but with suitable state-of-the-art functional abstractions to minimize the pain of acquiring it.

The only catch is the learning curve is steep, but as more and more programmers scale that wall, the benefits to performance and maintainability will become apparent to the pointy hairs. Lisp never really had an equivalent value proposition, except in a few narrow fields where its expressiveness and plasticity were key.

[AnimalMuppet]

But beware lag time.

That is: Some languages aren't suitable for general use. Some aren't... and then they are. But popularity probably correlates with how suitable the language was at least two years ago, and maybe more like 10. (Call it 5 as a compromise.)

So popularity doesn't tell you that the language is unsuitable now. But I agree, there is a correlation. Programmers for the most part aren't stupid sheep, afraid to use something new.