Oh, great, the email _did_ go out on the mailing lists (what with haskell.org being down I wasn't sure it would). Don Stewart <dons@galois.com> writes:

ivan.miljenovic:

...

Thomas Bereknyei are currently re-writing fgl (just about completely from scratch) and we plan to make an initial release to get feedback on the API in the next few weeks.

However, I'm sending this email out now to warn people that I highly doubt any code that was written for the current version of fgl (http://hackage.haskell.org/package/fgl-5.4.2.2) will work with the new version.

How about you give the library a different name then -- so as not to break all those programs?

A complete rewrite with a new maintainer: fgl-awesome

We considered giving it a new name (fgl', etc.) but figured that in the long term this wouldn't be advantagous. We feel that the situation is analogous to QuickCheck: when the new version came out most people kept using the old one until slowly the momentum shifted and more people started using the new version (without checking in depth, Roel's Hackage mirror reports QC-2.x now has 153 reverse dependencies as opposed to 127 reverse dependencies for QC-1.y). If we changed the name, then the "emotional attachment" that the Haskell community has to FGL being the de-facto graph library means that people would keep using the old version. Whilst we also face the possible problems of people not liking the old version and thus automatically dismissing the new version, I think this is a much more unlikely scenario. The overall philosophy is remaining the same: we're just updating the implementation (letting people pick the Node type rather than hard-coding it to Int, letting people constrain the label types and also providing more scope for optimisations). As such, the new version is incompatible with the old one; however, if you're only _using_ FGL (as opposed to making a new instance of the graph types), then the actual changes to using the new version should be minimal (especially if you're using it internally in which case you can hard-code the various types in and not have to worry about the type family usage at all). As I said, I've directly emailed the maintainers of the packages that have open-ended dependencies on FGL and thus would have compilation problems when we release the new version[s]; 7 out of 12 of those maintainers have already responded within less than 24 hours so I don't think this is likely to be a problem unless some new package is uploaded in the near future without proper ranged dependencies. So as to give you even more of a heads up, here are some more overall plans Thomas and I have for FGL: * FGL will still focus on inductive graphs; however the two current classes are being combined since it doesn't make much sense in general to have a graph that can be decomposed using match but can't be composed using & (there might be specific cases where this is true such as considering the Cabal package dependency "graph"; however this is likely to be defined internally within some project so users should just be careful about how they use it to ensure they don't add arbitrary nodes/edges that don't make sense; note that the new Show and Read instances take advantage of this by using Contexts as the basis of this instance). * The ability to have proper Eq, Show and Read instances for graphs with pre-defined helper functions implementors can use (currently Data.Graph.Inductive.Tree has a "pretty" output for Show but no Read instance, and graphs cannot have equality due to overlapping instance problems). * Splitting the library up into the base classes + sample instances (the fgl package) and a separate fgl-algorithms package (analogous to Dan Doel's vector-algorithms; this will be comprised of what is currently in the Data.Graph.Inductive.Query.* modules as well as the Data.Graph.Analysis.Algorithms.* modules in my Graphalyze library. The Data.Graph.Inductive.Graphviz module will also be scrapped in favour of my graphviz library. * By default, fgl will ship with two default instances: the one currently in Data.Graph.Inductive.PatriciaTree and also a generic Map-based one that lets people choose their own Node type (i.e. the key type in the Map). Any other suitable instances that we can think of (e.g. Thomas has the beginnings of a vector-based one) we'll ship in separate packages (e.g. fgl-vector). If anyone has a good reason to object to any of these plans, we are willing to be persuaded out of them. This is why the 6.z series of fgl will be "technology previews" to slowly build up what FGL does and gauge the reaction of the Haskell community. -- Ivan Lazar Miljenovic Ivan.Miljenovic@gmail.com IvanMiljenovic.wordpress.com

Christian Maeder <Christian.Maeder@dfki.de> writes:

Ivan Lazar Miljenovic schrieb:

...

We considered giving it a new name (fgl', etc.) but figured that in the long term this wouldn't be advantagous. We feel that the situation is analogous to QuickCheck: when the new version came out most people kept using the old one until slowly the momentum shifted and more people started using the new version (without checking in depth, Roel's Hackage mirror reports QC-2.x now has 153 reverse dependencies as opposed to 127 reverse dependencies for QC-1.y).

If we changed the name, then the "emotional attachment" that the Haskell community has to FGL being the de-facto graph library means that people would keep using the old version. Whilst we also face the possible problems of people not liking the old version and thus automatically dismissing the new version, I think this is a much more unlikely scenario.

I'm afraid you'll destroy the "emotational attachment" to fgl by annoying incompatibilities (and possibly interfering new bugs).

Although parsec-3 can be used as an replacement for parsec-2 it would have been better, they had different names (as argued elsewhere for the haskell platform).

I'm sorry, I don't recall this discussion: care to summarise? With fgl, the actual changes aren't that big on the user side of things if they want to keep using the defaults (it's not a drop-in replacement, but the _way_ to use it remains unchanged). The big difference is when people want to make custom instances; however, as far as I know no-one has created any custom instances for FGL's classes.

Changing a dependency in a cabal file is a small problem. Those (unaware), who only mention "fgl", will fall over an incompatibility (usually at installation time!) and simple say "fgl < ..." unless they are willing to change their code then.

Those who already have "fgl < ..." need to find an advertisement of a "new and better fgl" anyway and can choose when to change their code.

But by keeping the old fgl around as a separate package, there is then no real incentive to change/upgrade. If, however, we re-use the package name then it will be more obvious that there is a new and (hopefully) improved version available. -- Ivan Lazar Miljenovic Ivan.Miljenovic@gmail.com IvanMiljenovic.wordpress.com

Christian Maeder <Christian.Maeder@dfki.de> writes:

Ivan Lazar Miljenovic schrieb:

...

...

Although parsec-3 can be used as an replacement for parsec-2 it would have been better, they had different names (as argued elsewhere for the haskell platform).

I'm sorry, I don't recall this discussion: care to summarise?

http://www.haskell.org/pipermail/libraries/2010-March/013101.html

I've read through that thread, but I remain unconvinced. First of all, I think there are a few misconceptions raised there (e.g. the gitit discussion is because John Macfarlane doesn't want to use Parsec-3 for Pandoc because it used to be slow and because it isn't available in Debian; this latter point shouldn't be a concern for most software IMHO; secondly, if the documentation of the 2.x series was better, then why not improve the documentation of the 3.y series?). Maintaining Haskell98 compatability may be a valid concern (I don't know how valid it is to most people, but I can see some people preferring it). _Why_ should a library remain fixed at a particular version (unless of course you are convinced it is perfect)? By creating a new package, people will keep using the old version which will eventually bit-rot rather than upgrading. There are also a few other differences between the situations here: * A lot more packages use parsec than fgl, such that the conversion process is more difficult (whereas for those packages on Hackage that use fgl, over half have already responded that they'll fix the dependency problem such that the version update won't be a problem). * The most common reason given for not upgrading to parsec-3 was efficiency; we're going to work hard to make sure that the speeds are comparable if not better (since for the most part the data structure is the same, it's just the overall API that differs in terms of how function names, etc.). * Many people liked parsec-2; the common opinion on #haskell, etc. seems to be that fgl is full of warts and many people (such as Cale) prefer to use one-off custom graph implementations (e.g. IntMap IntSet) rather than use fgl. A lot of the changes we're making to fgl comes from taking into account what people don't like about the current layout of fgl.

...

With fgl, the actual changes aren't that big on the user side of things if they want to keep using the defaults (it's not a drop-in replacement, but the _way_ to use it remains unchanged).

I usually don't want to make even small changes at installation time.

But this isn't an installation time change, it's a build/develop time change.

...

The big difference is when people want to make custom instances; however, as far as I know no-one has created any custom instances for FGL's classes.

Well, I've created a custom instance: http://trac.informatik.uni-bremen.de:8080/hets/browser/trunk/Common/Lib/Grap... and our hets project is not a hackageDB package.

This looks very similar to what is currently called Data.Graph.Inductive.PatriciaTree; is there any particular reason for using your own custom variant? One thing you may like from the new fgl: proper Show, Read and Eq instances being available for graphs (since I know some people are annoyed that fgl currently doesn't have any method of serialising the graph for storage/transmission; so much so that someone has even resorted to converting the graph to/from Dot format and using that for serialisation).

...

But by keeping the old fgl around as a separate package, there is then no real incentive to change/upgrade. If, however, we re-use the package name then it will be more obvious that there is a new and (hopefully) improved version available.

Your "incentive" would be a "small annoyance" for me since it would force me to change the dependency to "fgl < ..." until I find time to test our code with the newer fgl version (without possible other changes).

It's a very simple change, however (and arguably you and everyone should always use bounded dependencies anyway just in case of this kind of problem). Arguably, changing the code may involve more time to take into account the new API. However, we aim to have sufficient advantages to the new version of fgl that people would _want_ to change.

(I still haven't updated from tabular-0.1.0.2 to tabular-0.2.x, yet.)

Wow, considering that tabular-0.2.1.0 (the first in the 0.2.x series) came out over a year ago and you still haven't upgraded is a little surprising... As a compromise, we might consider not uploading the new version of fgl to hackage (or having the developmental version use a new name, similar to how darcs has darcs-beta for testing releases) and get that package deprecated and hidden once we're satisfied and make a formal release. However, I envisage having the new version fully developed and out by the end of the year (time permitting, etc.; I want to get the API right the first time so we don't have to go through this argument again next year :p). -- Ivan Lazar Miljenovic Ivan.Miljenovic@gmail.com IvanMiljenovic.wordpress.com

Ivan Lazar Miljenovic schrieb: [...] we don't need to repeat a parsec-2 vs parsec-3 discussion. There are obviously different opinions that cannot be easily changed.

...

Well, I've created a custom instance: http://trac.informatik.uni-bremen.de:8080/hets/browser/trunk/Common/Lib/Grap... and our hets project is not a hackageDB package.

This looks very similar to what is currently called Data.Graph.Inductive.PatriciaTree; is there any particular reason for using your own custom variant?

I guess, Data.Graph.Inductive.PatriciaTree wasn't available when I created my own instance. Furthermore, I'm using more efficient functions directly on the graph that are not available via the graph class methods.

It's a very simple change, however (and arguably you and everyone should always use bounded dependencies anyway just in case of this kind of problem).

Sure, I can live with either way.

Arguably, changing the code may involve more time to take into account the new API. However, we aim to have sufficient advantages to the new version of fgl that people would _want_ to change.

I'll rather wait and see how the new FGL will look like and then consider if re-writing is worthwhile.

...

(I still haven't updated from tabular-0.1.0.2 to tabular-0.2.x, yet.)

Wow, considering that tabular-0.2.1.0 (the first in the 0.2.x series) came out over a year ago and you still haven't upgraded is a little surprising...

Well, looking at our simple ascii usage, I decided to copy the used bits from the sources (one package less and its dependencies, to worry about).

As a compromise, we might consider not uploading the new version of fgl to hackage (or having the developmental version use a new name, similar to how darcs has darcs-beta for testing releases) and get that package deprecated and hidden once we're satisfied and make a formal release.

For me it's no big deal, if you make a new package fgl6 or make a new version fgl-6, because I'll stick to fgl-5.4.2.2 as long as I see fit. Others may complain, if their old sources no longer compile because they got fgl-6 instead of fgl-5 by whatever unintended circumstances.

However, I envisage having the new version fully developed and out by the end of the year (time permitting, etc.; I want to get the API right the first time so we don't have to go through this argument again next year :p).

I think, sources should go on hackageDB as soon as possible to get early feedback. Christian

Ian Lynagh <igloo@earth.li> writes:

On Mon, Jun 07, 2010 at 11:50:44AM -0700, Donald Bruce Stewart wrote:

...

A complete rewrite with a new maintainer: fgl-awesome

In 10 years time, we don't want to have fgl fgl-awesome fgl-great fgl-joe which all do the same thing, and have an unclear relationship to each other.

Definitely (though hopefully we wouldn't pick names like "fgl-awesome" anyway...).

I think the important question is: Once the new FGL is finished, will there be a good reason (other than backwards compatibility) for people to use the current FGL?

If yes, then different names should be used. Otherwise, no matter how different the API is, keeping the same name is the right thing to do.

And this is why we're going to request the community's input on our API design: to try and avoid the situation where there's a specific reason to keep using the old one. As it stands, the only real advantage that I can think of is that the new version uses extensions, the old version doesn't (and hence is more compatible).

So if there is consensus that the new design is a better fgl, I think it ought to keep the name.

Which is what we're trying to build (the consensus, that is). Don has started a wiki page with the arguments here, and I've already added my 2c: http://haskell.org/haskellwiki/Libraries/WhenToRewriteOrRename -- Ivan Lazar Miljenovic Ivan.Miljenovic@gmail.com IvanMiljenovic.wordpress.com