There are a couple questions in the comments about LTS Haskell and related projects, I was thinking this might be a good summary. (tel's might be better, but I had already written this so I'll let others decide https://news.ycombinator.com/item?id=8834823)
Hackage is the core package server, comparable to RubyGems.
The Stackage (http://www.stackage.org/) project functions like a CI system for Hackage. Stackage builds and tests the group of packages that have opted in to it, ensuring that the latest versions all work together (when there's an incompatibility between packages, the authors of the packages are pinged to resolve the issue [1]).
When a build of all the packages succeeds, Stackage generates a "snapshot", a list of all the package versions used for that build (sort of like a Gemfile.lock/Podfile.lock, for the whole ecosystem). Developers can have Cabal (Haskell build tool) use the package versions from that list when installing new packages. This ensures that when you install a new package that it's compatible with the other packages you're currently using.
The issue with those snapshots (generated nightly) is that you'll want to get updates for your packages, but the snapshot generated N days from now might have packages that have made breaking API changes, making them incompatible with your application.
LTS Haskell attempts to fix that. It's based off a specific Stackage snapshot. For the duration of the LTS (currently 3 months), the major versions from that snapshot are locked down, but patches/bugfixes will continue to be released. This allows you to get bugfixes for your application while still getting the advantages of Stackage.
[1] As an example, when the language-ecmascript 0.17 package was released, the authors of the 2 packages that depended on language-ecmascript < 0.17 were pinged to update their packages: https://github.com/fpco/stackage/issues/390
I guess this is similar to Quicklisp for CL packages? A stable "world snapshot" every now and then instead of rolling releases.
I works pretty well in the CL world, I think this approach (releases) will become standard for package management in Ecosystem-package-managers (as it has been in the OS world).
Hackage - live packages get uploaded and released fast
Stackage - a rolling tested release. It promises that all packages will compile together. (There are a few flavors of this).
and now LTS Haskell. A snapshot of Stackage that doesn't roll very quickly (every 3 months). It won't do upgrades to packages at all, except for bug fix & patch releases. So your own application code can pull down the LTS today, and again tomorrow, and be relatively sure that everything will work the same.
In addition to this, the release duration is somewhat experimental.
Why such short support windows? The strawmen of three
months between releases and a one month grace period are
ridiculously short support windows. The reason I propose
them is because- like I mentioned in the design goals- we
want the smallest delta from how people work today. Right
now, there is no concept of stable versions, and we're
trying to introduce it. Starting off with a more standard
support window of something like two years would be a
radical shift in how library users and authors operate
today. Three months is very short, but it's long enough for
us to test the process. As time goes on, we should have
serious community discussions on how long a support window
we should have. (I, for one, am fully in favor of extending
it well beyond three months.)
so "1.1" is the version of the whole thing, even if most of the packages haven't changed; as opposed to the usual way of versioning each package independently?
edit yep, looks like it: "an LTS Haskell release reduces it all to a single version number for "my Haskell ecosystem""
Haskell's package repository, Hackage, changes very rapidly. The best policy that exists today for determining whether packages will work together, the Package Versioning Policy, is a bit like Semantic Versioning. This allows you some chance in hell of finding compatible packages, but it's very low information and often fails. This is exacerbated by a few things
1. Due to static typing package combination errors are detected at compile time not runtime. This means that potential mismatches in package versions are detected and punished very early and very severely. This is why Cabal compares so disfavorably to NPM. It's not that NPM is more advanced, it's that Cabal tries harder to ensure that package mismatches don't survive build.
2. There are differences in opinion on the right place to put burden of package matching—should the maintainers exhaustively test things and maintain accurate and complete information at all times? Or should people just tell them quickly when things break. Unfortunately, these two methods of handling versioning don't live together nicely and they wreck havoc for the solver.
3. Haskell as a language strongly promotes chunking off nice, trustworthy abstractions and squirreling them away into their own package. This means that there are a lot of packages all versioning against one another and the package matching problem is quite large.
So, atop this a few "curated sets" have been built which push the package managing troubles to someone else---namely a build farm where, arguably, it ought to be. These sacrifice bleeding edge availability for a bit less personal burden finding compatible package sets. The two I use are called Stackage and Nixpkgs.
Stackage is in particular supported by the company FPComplete and FPComplete sells Haskell solutions to industry. They are therefore well-interested in providing a support solution for stable sets of packages from Stackage. This may even just be a formalization of what they already do since they probably cannot justify code breakages to customers as "well, the state of the art of libraries keeps changing".
As far as I can tell these LTS package sets are stable points in the master package set which will receive bugfixes and unquestionably unbreaking feature updates alone. In terms of the PVP, they can receive minor version bumps but are protected against major ones. Stackage is a rather massive set of packages, so this is done in a pretty conservative manner and it seems reasonably experimental at the moment.
In particular, it'll come down to the willingness of library maintainers to backport bugfixes to prior major versions of their libraries. Good library maintainers have support windows they care about already, but not everyone has the resources to pull that off. LTS will feel this differential effect.
Anyway, hopefully that's a good, reasonably correct overview. Corrections welcome.
My best understanding from the posting is that it's going to be a "stable" version of the "Haskell Platform" set of packages.
Haskell has been notorious for moving (too?) fast while not maintaining decent backwards/forwards compatibility, a problem made worse by some tooling issues ("cabal hell"). Now most of the technical issues should be solved.
It does seem to be a competitor. They could use the same infra to do the HP versioning and builds. Some NIH going on?
The key here seems to be the level of automation, which is great to see.
Unfortunately, I think it's a bit of a branding thing, too. To most people's eyes the HP is something of a failure since it's so slow to release—never mind the stabilizing effect it has had on all constituent projects. Stackage thus grabbed some market- and mind-share by promising a closer-to-bleeding-edge update path at the cost of lesser stability. From this position they're peeling back a little bit, trading off newness for a bit more stability, in what appears to be the easiest-to-maintain fashion.
So from that, it's sort of culturally incompatible with HP, unfortunately. It'd be very nice if some crosscutting could be had once-and-if LTS stabilizes as a product.
Actually, the ideas for LTS Haskell came out of conversations I had with Duncan and Mark at ICFP. The original idea was to create a GPS Haskell that would encompass a "best of both worlds." LTS Haskell is a first step towards that, and I'm hoping that Haskell Platform and Hackage ultimately fold this stuff back in.
Sounds good. I had assumed you were heading in this direction. The approach was something Duncan and I wanted to try in 2007/2008 but we didn't have resources at the time. Now the infrastructure is there, automatically identifying stable sets, tagging and releasing them is a good step. If you can get to the point of computing the next HP set in the same fashion, that will be a big win for stability.
The core set of packages (e.g. those in the platform) tend to not break backwards compatibility, but you're right that there are still packages that move fast and do.
Hackage is the core package server, comparable to RubyGems.
The Stackage (http://www.stackage.org/) project functions like a CI system for Hackage. Stackage builds and tests the group of packages that have opted in to it, ensuring that the latest versions all work together (when there's an incompatibility between packages, the authors of the packages are pinged to resolve the issue [1]).
When a build of all the packages succeeds, Stackage generates a "snapshot", a list of all the package versions used for that build (sort of like a Gemfile.lock/Podfile.lock, for the whole ecosystem). Developers can have Cabal (Haskell build tool) use the package versions from that list when installing new packages. This ensures that when you install a new package that it's compatible with the other packages you're currently using.
The issue with those snapshots (generated nightly) is that you'll want to get updates for your packages, but the snapshot generated N days from now might have packages that have made breaking API changes, making them incompatible with your application.
LTS Haskell attempts to fix that. It's based off a specific Stackage snapshot. For the duration of the LTS (currently 3 months), the major versions from that snapshot are locked down, but patches/bugfixes will continue to be released. This allows you to get bugfixes for your application while still getting the advantages of Stackage.
[1] As an example, when the language-ecmascript 0.17 package was released, the authors of the 2 packages that depended on language-ecmascript < 0.17 were pinged to update their packages: https://github.com/fpco/stackage/issues/390