[Haskell-beginners] coming to grips with hackage

[tam at hiddenrock.com]

> > How does this handle the situation where I want both package A and package B
> > installed, but they each want a different version of package C?
> 
> How would your distro handle it if those packages were written in C?

I'd say the C-leaning factions of the open-source community have largely
accepted the convention that ABI/API changes that cause incompatibilities are
accompanied by bumps in the major version number.  There are, of course,
exceptions, but my feeling is they are rare, generally well-publicized, and
quickly fixed.  To be honest, I don't even know if hackage authors tend to
follow this convention because...

> With Haskell it seems worse because everything has conservative dependencies
> in a *.cabal file and Cabal will refuse to build the thing unless they're
> met.

... Haskell seems worse to me in that if package foo is updated, every other
package depending on foo (recursely) must then be rebuilt, even if they didn't
change and even if the interface presented by foo didn't change.  C programs
do not suffer similarly and my limited experience with ``cabal hell'' would
have been a non-event if this recompilation process wasn't necessary.  I don't
know what technical issues necessitate it and I don't know whether the
conventions required to make it feasible are already in place, which is
partially what I'm trying to learn here. =)

Additionally, it seems that the hackage ecosystem is far more intertwined than
that of third-party Python packages (I have no experience with Ruby).  That
is, many things in hackage depend on other things in hackage whereas far more
Python packages depend only on the libraries included in the base install.
This is not a knock against Haskell by any means; it is, in fact, a testament
to the powerful abstractions it supplies and enables.  It does, however,
weaken the ``other languages have this problem, too'' argument.

Perhaps the solution is a more rigorous effort to keep the Haskell Platform up
to date, especially with well-regarded ``building block'' libraries (eg,
lens), and possibly even on a fixed schedule.  Then hackage authors can be
encouraged to make their stuff compatible with particular releases of the
Haskell Platform and ``normal'' users would only need to worry about upgrades
whenever the Platform is updated.  But then we're really edging out on the
slippery slope to Haskell becoming a distro unto itself.

pete