Well-Typed, a Haskell consultancy, publishes technical posts on GHC, Cabal, testing, and Haskell libraries and patterns.
Commenters link its posts on parametricity, a minimal servant, and integrated shrinking; one finds the company's team page intimidating.
The main problem is the difficulty to hire Haskell programmers. Recruiting is crucial to a startup's success.
"We were pleased to get a total of 42 applications, of which 19 merited serious consideration, and we eventually settled on a shortlist of 7 to interview. " [0]
Then there's the entire ecosystem surrounding Haskell, which is still old and antiquated (looking at you Cabal) and moving very slowly (interfacing to NoSQL or AWS, etc...).
> looking at you cabal
See this link for a solution: https://news.ycombinator.com/item?id=9766943
> interfacing to NoSQL
I recently used the Haskell riak[3] binding in my day job for an application. The mongoDB[4] package was uploaded "Tue Jan 19 06:04:06 UTC 2010"[5]
> AWS
There has been an AWS binding since 2011[1][2].
> etc
cassandra[6][7][8]
couchdb[9]
> Finally, the very high bar to just learn how to correctly program in Haskell puts it out of reach of 99% of the developer community.
A 10 year old can do it[9], so I'm sure more than 5% of the developer community can as well!
I wouldn't say I'm a spectacular programmer and I have both learned Haskell and used it in the real world easily enough. I will admit in the past there was a learning issue, but actions to make Haskell easier to learn have (and continue) to happen.[11][12][13][14]
I'm looking forward to any rebuttals you may have to these! :)
0: http://www.well-typed.com/blog/2010/08/on-hiring-haskell-people/
1: http://hackage.haskell.org/package/aws-0.0.1
2:…
No special hardware is required — it's all in the runtime. Quoting from Parallel Haskell Digest[1]:
"""You may have heard of sparks and threads in the same sentence. What's the difference?
A Haskell thread is a thread of execution for IO code. Multiple Haskell threads can execute IO code concurrently and they can communicate using shared mutable variables and channels.
Sparks are specific to parallel Haskell. Abstractly, a spark is a pure computation which may be evaluated in parallel. Sparks are introduced with the par combinator; the expression (x par y) "sparks off" x, telling the runtime that it may evaluate the value of x in parallel to other work. Whether or not a spark is evaluated in parallel with other computations, or other Haskell IO threads, depends on what your hardware supports and on how your program is written. Sparks are put in a work queue and when a CPU core is idle, it can execute a spark by taking one from the work queue and evaluating it.
On a multi-core machine, both threads and sparks can be used to achieve parallelism. Threads give you concurrent, non-deterministic parallelism, while sparks give you pure deterministic parallelism.
Haskell threads are ideal for applications like network servers where you need to do lots of I/O and using concurrency fits the nature of the problem. Sparks are ideal for speeding up pure calculations where adding non-deterministic concurrency would just make things more complicated."""
[1]:…
Haskell is getting row polymorphism[1] for records (going under the name OverloadedRecordFields) in the next release. The new language extension will also play well with lenses, making records even more versatile.
However, we're still not getting special syntax for field access, so it'll be function application (g f) instead of a dot (f.g). This isn't a major drawback, but it means that a field g has to be in scope for this to work at all.
Fundamentally, it seems exactly the same approach could be used to give Haskell polymorphic variants. They're not part of this extension, but I wouldn't be surprised to see them in the near future.
Haskell is also getting a much better (ie not crippled) module system soon, in the form of Backpack[2]. However, I'm not sure when this is actually going to be released—I don't think it's in the upcoming version.
[1]: http://www.well-typed.com/blog/84/
[2]: http://plv.mpi-sws.org/backpack/
Yeah, it really depends on the language and build artifact characteristics, but I'm mostly speaking about my experience with haskell and C. Natively compiled languages tend to have more problems with this because the libraries themselves hold linker references to each other. Versioning isolation alone isn't enough to solve these cases, because you can end up needing multiple copies of the same version of a library to satisfy the needs of all installed packages (because of versioning incompatibilities of transitive dependencies in different libraries). There's an article series about fixing this (and other problems) with haskell's cabal, but the solution basically involves nix style sandboxing [1] [2].
[1]: https://www.well-typed.com/blog/2014/09/how-we-might-abolish-cabal-hell-part-1/
[2]: https://www.well-typed.com/blog/2015/01/how-we-might-abolish-cabal-hell-part-2/
As sibling says, Jane Street has employed people who have worked on implementing unboxed types[1] and stack allocation[2] in the OCaml compiler.
For Haskell, Well-Typed,[3] Tweag,[4] and Serokell[5] have employed people who have worked on GHC. For example, when Richard Eisenberg was at Tweag, he was working on implementing dependent types in Haskell which has led to new published research.[6] The work on dependent types is continued by other paid contributors.
[1] https://www.janestreet.com/tech-talks/unboxed-types-for-ocaml/
[2] https://blog.janestreet.com/oxidizing-ocaml-locality/
[3] https://well-typed.com/blog/tags/ghc-activities-report/
[4] https://www.tweag.io/blog/tags/ghc
[5] https://serokell.io/blog/ghc
[6] https://www.youtube.com/watch?v=TXDivoj1v6w
> “secret weapon” and do not advertise it
Both Standard Chartered and Barclays loudly advertise that they use Haskell.
A quick web search turns up their job offers on Reddit, and both also send people to conferences such as Haskell eXchange, to talk about their team tasks, structure, and size. Example: [1]
Their code bases were discussed on HN before, e.g. [2].
Standard Chartered also funded the development of GHCs low-latency, non-stop-the-world, incremental GC, for 2 years until it was recently released [3].
[1] https://skillsmatter.com/skillscasts/9098-haskell-in-the-large-the-day-to-day-practice-of-using-haskell-to-write-large-systems
[2] https://news.ycombinator.com/item?id=13073605
[3] https://www.well-typed.com/blog/2019/10/nonmoving-gc-merge/