Well-Typed Blog

http://www.well-typed.com/who_we_are = very intimidating. I'd love to be paid to write Haskell but I've been programming in it less than a year.

It sounds like you need to learn about parametricity. https://www.well-typed.com/blog/2015/05/parametricity/

Parallel computing can still produce deterministic outcomes, if you are careful. Having said that, most people are not careful, and most languages make it very hard to be careful. The keyword is 'deterministic parallelism', if you want to look into the research. See eg https://www.well-typed.com/blog/2012/12/deterministic-parallel-program…

A lazy, immutable rose tree This article shows some really cool stuff you can do with it https://www.well-typed.com/blog/2019/05/integrated-shrinking/

Is the stuff about GHC's garbage collector still valid? (I have no idea, but I found this https://www.well-typed.com/blog/2019/10/nonmoving-gc-merge/ "Low-latency garbage collector merged for GHC 8.10", which is more recent than the OP blog post) Is the “backwards compatibility at all costs” point about Go still valid? https://blog.golang.org/using-go-modules ...it seems like you can specify versioned deps now

> “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… [2] https://news.ycombinator.com/item?id=13073605 [3] https://www.well-typed.com/blog/2019/10/nonmoving-gc-merge/

In terms of GHC's evolution, this looks really promising to me: http://www.well-typed.com/blog/2019/10/nonmoving-gc-merge/

There's also some work pushing Haskell to perform better (more like Elixir) in networking/concurrency applications: http://www.well-typed.com/blog/2019/10/nonmoving-gc-merge/

What is "the library approach"? Library approaches have failed. See http://www.well-typed.com/blog/2016/09/sharing-conduit/

Would this also benefit non-top-level thunks? We had a ridiculous space-leak at DFINITY just last month where the workaround I found involved turning off full-laziness [1] as well as using a variant of `Control.Monad.forever` defined in terms of `(>>=)` rather than `(* >)` - which is how `Control.Monad` does it, which interacted badly with how Conduit implements `(>>=)` and `(* >)`. We never got to the bottom of exactly why it leaked but I'll be sure to try it out again with GHC 8.6. However it's not clear that long-lived CAF data would have been the problem in our case. [1] https://www.well-typed.com/blog/2016/09/sharing-conduit/

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-hel… [2]: https://www.well-typed.com/blog/2015/01/how-we-might-abolish-cabal-hel…

It's well defined, but there's no good solution to this problem yet! See: http://www.well-typed.com/blog/2014/09/how-we-might-abolish-cabal-hell… It's true for every language out there, not just Haskell.

Edward Z Yang[0] is doing a GSoC project (I think) on expanding Backpack[1][2]. He's a GHC contributor, so it's relatively big. And here's overloaded record syntax: http://www.well-typed.com/blog/84/ [0]http://ezyang.com/ [1]http://plv.mpi-sws.org/backpack/ [2]http://blog.ezyang.com/2014/07/type-classes-confluence-coherence-globa…

Here's a recent blog post of a very elegant k-means implementation in cloud haskell. It's part of the effort to bring an erlang-like, CSP style, DSL-based message passing to haskell. http://www.well-typed.com/blog/74

And a more recent summary: The New Cloud Haskell, http://www.well-typed.com/blog/70 Compared to the previous prototype: * it is much faster; * it can run on multiple kinds of network; * has backends to support different environments (like cluster or cloud); * has a new system for dealing with node disconnect and reconnect; * has a more precisely defined semantics; * supports composable, polymorphic serialisable closures; * and internally the code is better structured and easier to work with.

Well-Typed, a Haskell consultancy, seems to do quite a bit of work exclusively in Haskell. For instance, they have developed an air traffic analysis tool for NATS[1] which they briefly blogged[2] about. [1] http://www.nats.co.uk/ [2] http://www.well-typed.com/blog/39

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:…

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/

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]:…

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