Resigning from the Haskell Platform

https://mail.haskell.org/pipermail/ghc-devs/2015-October/010068.html

by enigmo • 11 years ago

86 76 11 years ago

mail.haskell.org

ptype• 11 years ago

Would anyone be able to give more background on the controversy?

jewbacca• 11 years ago

Withholding a tl;dr until I've read enough to understand it myself, here is where I'll be looking to generate a quick impression:

https://www.reddit.com/r/haskell/search?q=foldable+traversab...

https://wiki.haskell.org/Foldable_Traversable_In_Prelude

jkarni• 11 years ago

A more complete description is available here [0], but the essence of it is that the type of many functions that used to be specifically about lists has become more general, but also arguably harder to understand.

[0] https://wiki.haskell.org/Foldable_Traversable_In_Prelude

psibi• 11 years ago

FTP (The Foldable/Traversable proposal in prelude) is a change done to the core library of GHC 7.10. It brings the Foldable and Traversable typeclass to Prelude and makes the existing function of Prelude more polymorphic. Like the type signature of the function "and" changes from [Bool] -> Bool to Foldable t => t Bool -> Bool. People in the Haskell community have divided opinions about this. You can see more details here[0].

[0] https://wiki.haskell.org/Foldable_Traversable_In_Prelude

dagw2• 11 years ago

I understand what is changing, but not the controversy. As a very casual Haskell user it all seems reasonable enough. What are the strong arguments against? What happened in 7.9-7.10 that made Haskell 'worse' in this persons opinion.

devnonymous• 11 years ago

From a cursory glance (I'm not part of the large haskell community), there doesn't appear to be any controversy.

This just appears to be a decision of an individual to stick to what they think is the best platform/version for them. Since the individual was also the Release manager, seems like stepping aside was the logical thing to do if they do not prefer the latest version of the language.

moomin3• 11 years ago

Let's describe this in a way that makes sense to me, a C# programmer. In C#, there's a function called Sum. It takes an IEnumerable<int>. There's an overload for IEnumerable<double>. There's no way to express "is a number" in C#, so it's just special cased. In Haskell, however, there is:

sum :: (Num a) => [a] -> a

Which means: for any a which is a number, sum can be used to add up a list of as.

However, going back to the C# example, you'll note we said IEnumerable<T>, not List<T>. In C#, the container is general, but in Haskell it's specific. And since IEnumerable is an interface, this actually means "any type that is enumerable". Haskell has an analogue of IEnumerable called Foldable.

So, what we _really_ wanted sum to say was "sum is a function that, for any container f that is foldable, for any type a that is a number, takes an f of a and gives you an a".

sum :: (Foldable f, Num a) => f a -> a

This is the AMP style version of sum. Some people hate it, I love it.

However, there's another piece of background to this that the email doesn't mention: the Haskell Platform is under attack itself. There's a new solution called stack which is, to my mind, easier to use and less likely to bite you with version conflicts. And whether HP should continue to be the "default" recommended way of starting with Haskell is, at best, controversial.

In short: there's plenty of people who won't miss his work on Haskell Platform, but losing Mark himself is a loss.

tinco2• 11 years ago

Another hint of intuition for C#'ers out there. Foldable is like IEnumerable, and Traversable is a bit like ICollection. Some are a bit unhappy with the names too, even though they really make sense from the category theory sense.

A thing about Foldable is that you can fold over it (obviously) but you can't necessarily map over it because in Haskell the general map (fmap of the Functor typeclass) has the law that `map (f1.f2) enum == ((map f1) . (map f2)) enum` but for example for Set this law won't hold because the intermediate set might drop elements identical elements that would not have been identical would the f1.f2 been applied in direct succession. See [0] for an example. Why fmap has this law I don't know, but Functor is super fundamental in Haskell's types so you can bet it's there for a good reason.

Note that this Foldable-Traversable-Functor introduction into Prelude is not complete yet. For example the map in prelude is: `map :: (a -> b) -> [a] -> [b]`. If this movement continues it will possibly be `map :: (Functor f) => (a -> b) -> f a -> f b`. People are super scared of the name Functor, so I think that's why it's not been adopted yet. It should possibly be renamed to Container or Mappable to be more in line with what general developers expect.

Would prelude's map be made equal to fmap however, it would make prelude super powerful. It would suddenly work on any Functor type, not just List.

[0] https://www.fpcomplete.com/user/chad/snippets/random-code-sn...

p.s.: if you don't grok typeclass, call it classclass instead, i.e. class of classes. And then think about how C#'s Interface also defines a class of classes.

FrankenPC3• 11 years ago

Hmmm... Is F# a good alternative? I already have a ton of experience with .NET and C#. I'm thinking about doing a deep dive into functional programming and don't want to waste my time with something that has a major fundamental flaw.

spuz2• 11 years ago

That's quite a rash conclusion to jump to. Every language has its controversies and quirks. I would recommend deep diving both into F# and Haskell - you certainly won't be wasting your time either way.

glogla• 11 years ago

How is F# on unix? I can imagine F# being nice on Windows, but can people with Linux or Mac OS use it? How dependent on visual studio it is?

I would guess that Ocaml might be better in unixy environment while sharing similar features to F#?

FrankenPC3• 11 years ago

It's not a conclusion. I have no idea what's going on with FP. So, it's a genuine question.

cammil• 11 years ago

Dont forget that journalism by its very nature is sensationalist. I doubt very much that this is a "major fundamental flaw".

Besides, you would also be asserting that F# does not have that flaw. I don't believe you have that evidence either.

kolektiv• 11 years ago

It doesn't have that flaw! But that's probably partly because it doesn't have typeclasses, so Foldable/Traversable aren't possible in the same way...

sitharus2• 11 years ago

I wouldn't say it's an alternative any more than Haskell is an alternative to Java. It's a different language and ecosystem.

That said, F# is pretty nice. It's opt-in laziness for .NET compatibility but laziness is pervasive. There's no forced purity though. On the plus side it's easy to interact with anything that has .NET bindings.

drewm1980• 11 years ago

Yeah, I'm not really a haskeller, but this is not a flaw at all. Some standard functions that used to operate specifically on lists now operate on anything that is "Foldable"... including lists. It makes the learning curve a bit steeper, but tutorials already often have you re-implement toy versions of standard library functions for learning anyway. The benefit, if I understand correctly, is that you can use the standard library functions on more things that are not lists.

masklinn• 11 years ago

don't want to waste my time with something that has a major fundamental flaw.

It's not a fundamental flaw it's a change. Basically in the early days of Haskell they decided to make much of the prelude (the builtins) work on the concrete type "list" rather than on more abstract types for beginner simplicity, with more abstract "interfaces" like Foldable not shown upfront, with the attendant duplication as each function of the prelude now has a more abstract duplicate somewhere else.

The FTP change reverses this and alters the prelude to operate on abstract types rather than concrete ones, this somewhat increases the initial learning experience[0] but it doesn't really change the language itself.

For C# equivalence, imagine if all the most easily accessible functions operated on the concrete `List` to avoid having to introduce interfaces and all had duplicates taking an IEnumerable instead (that doesn't quite work as C# uses methods but there you are).

And surely if that's a "fundamental flaw" of Haskell, you've wasted your time with C# and its fundamental flaw of non-generic System.Collections

[0] for complete beginners with no concept of abstract types I guess? For Haskell beginners coming from other languages it doesn't seem like a big issue, just a matter of how abstract types which is already an issue between languages anyway e.g. where Haskell has Foldable C# has IEnumerable, Ruby has Enumerable, Java and Python have Iterable, ...

FrankenPC3• 11 years ago

For C# equivalence, imagine if all the most easily accessible functions operated on the concrete `List` to avoid having to introduce interfaces and all had duplicates taking an IEnumerable instead (that doesn't quite work as C# uses methods but there you are).

Thanks! Considering 'List' is one of the few structures of FP I understand, that makes actual sense.

paulsutter4• 11 years ago

Hey, Haskell wouldn't be cool if /everybody/ used it. Some guys are totally down with bringing "the Foldable and Traversable typeclass to Prelude" and making "the existing function of Prelude more polymorphic", while others feel that just synergizes the wrong paradigm.

If you, like me, have no idea what this is about, just go back to coding in one of those subtheoretical languages for feeble minded norms, like me.

I'm sure these guys are doing some REALLY IMPORTANT WORK with a language as obscure as that. Way over my head, I'm sure.

EDIT: Scrollaway, thanks for asking. I don't really have a beef with Haskell itself, I just think its tragic that so many smart people are drawn to something that has .. well.. let's just say, I'd love to hear the practical aspects of Haskell.

csvan• 11 years ago

Judging from how shallow your reasoning appears to be, it is way over your head indeed.

scrollaway• 11 years ago

Got some inferiority complex showing here? What exactly is your problem with Haskell?

ehvatum• 11 years ago

There is beauty in decrying the inapplicability of a purely functional thing:

Even if you wanted more function, you couldn't have it, because there isn't. And yet, you find that it has no function. None!

    Water, water, every where,
    And all the boards did shrink;
    Water, water, every where,
    Nor any drop to drink.

retrogradeorbit• 11 years ago

I can't read Spanish. That's because I don't know Spanish. But does that mean that Spanish is a bad language? Or does it mean that Spanish speakers are somehow superior for writing this language I can't read? No. The Spaniards seem to be doing fine with it.

tempodox2• 11 years ago

As I see it, the practical aspect of Haskell is to build things that are completely specified and need only be implemented. I can't imagine using it for anything remotely experimental, but if your job is implementing a completed spec, Haskell might well be worth the learning curve.

pwm• 11 years ago

This same line of reasoning is sometimes used against theoretical math. History keeps proving it wrong though.

chriswarbo2• 11 years ago

You mean those "subtheoretical languages" with "practical aspects" like deciding whether to use an abstract base class, which allows implementation inheritance for friends but violates encapsulation; or putting static final methods in an interface and using reflection to dynamically dispatch via a meta-object protocol to the contra-variant constructors of a private inner class?

All languages and paradigms can be obscure to outsiders. Just take a look at http://programmers.stackexchange.com/questions/tagged/object...

paulsutter4• 11 years ago

Can I ask a question about Haskell? I see a lot of excitement about it, but, honestly it seems a bit over my head and I'd love to understand.

Deep learning, for example, has opened the door to some pretty incredible advances, I'm astonished monthly at least by what people are accomplishing. Stuff that's getting close to the uncanny valley.

I see equally smart people enraptured with Haskell. And, maybe it's just over my head, but so far no practical advance is apparent. To me at least. So, for the sake of the nonbelievers, it would be grand to share some of the hopes that merit the great energies that go into languages like Haskell.

(ps. thanks to Scrollaway for asking, below)

moomin3• 11 years ago

Haskell is, frankly, hard to learn. But the interesting thing about learning Haskell is that you feel like you're actually learning more about coding and computation, whereas most languages just feel like you're learning a new syntax for doing the same thing.

In general terms, Haskell has an unparalleled ability to be both precise and flexible at the same time. At least, that's why I like it.

paulsutter4• 11 years ago

I like that description, it conveys a sense for what can be appealing about it.

But, if I look at Deep Learning, I see a freight train to the future. If I look at Haskell, I see a lot of... well, debating about... things.. well I just don't see where it's going. I get the sense that it's a gleeful little clever club that exists as an alternative to doing actual work.

And, where's the counterexample, Haskell is a freight train to where? What's the future that Haskell brings?

This is really a sincere question. I've been programming long enough to feel the limitations of existing tools. But, will humans even be coding in 30 years?

nikanj• 11 years ago

To me, it was mostly about new ways to force the compiler consider a number a number. You have one integer from monad a, another from monad b and want to use them as parameters for a function in monad c.

I mean, I understand /why/, but sometimes I really longed for a blunt instrument.

tempodox2• 11 years ago

Opportunities multiply as they are seized. The more computational models you get under your belt the broader your horizon will be. And since the computational model of Haskell is quite unique, you will almost certainly learn more than just new syntax. The same would be true for (e.g.) Prolog, whose computational model is non-mainstream as well. That difference means, you can't understand this new thing in terms of what you knew before, but you need to grok new concepts (not just syntax). As the adage says: “If you know exactly what you're doing, you're not learning anything”.

rhaps0dy• 11 years ago

I'm not sure how much of it has been proven, but this language helps a lot with correctness in software engineering. The compiler and type system conspire to make the software correct when it compiles more often than not. Maintenance work on projects is easy because you never have some global state to worry about, instead, everything you need to understand a function and modify it is in that function's definition.

And nice libraries. But other languages have them bigger and of similar quality.

exDM69• 11 years ago

Haskell is a programming language, it's just a tool - just like you don't expect some profound practical advantages from, say Python, C# or Rust, you should not expect Haskell to be magically better than others.

That being said, Haskell has been at the forefront of programming language research since its inception in the 1980s. It may be more academic kind of advances but things have trickled down to mainstream languages, e.g. F# and C# have had influences from Haskell (particularly because Simon Peyton-Jones is employed by Microsoft Research). Scala and other languages have had some influence too. Things such as Parser combinators have emerged from the Haskell world and have been adopted to many programming languages since.

Haskell is exciting because it takes a no-compromises approach to the paradigm it is based on. It's purely functional and lazy, something not taken to such extremes in any prior languages. Whether this is the right(tm) approach to take is open to debate.

If I had to summarize in one sentence: Haskell is a research language that is practical - learning it will make you a better programmer even if you never get the opportunity to use it in your day job.

fho3• 11 years ago

Just another Haskell-influence on mainstream languages: Pythons list-comprehensions are verbatim copied from Haskell. This is even acknowledged here: https://wiki.python.org/moin/PythonVsHaskell

crdoconnor3• 11 years ago

I see equally smart people enraptured with Haskell. And, maybe it's just over my head, but so far no practical advance is apparent.

The advantages appear to be limited to highly complex functional code (i.e. big black boxes of code without side effects). IIRC facebook has a spam filter written using it.

Since most of the industry involves code where the functional aspect isn't all that complex and the side effects are, the practical advances aren't all that relevant for a lot of people.

Except, perhaps, for the impact Haskell is having on other more mainstream languages' design.

thoughtpolice3• 11 years ago

Haskell does not eliminate side effects. It allows you to control them.

You do realize that system you described - Facebook's Sigma - is a real-time, massively concurrent online spam-fighting system, that automatically and implicitly makes your code concurrent for all operations, can optimize it, and has automated caching/batching request mechanisms in place to talk to external systems (Graph databases, SQL, cache servers) in an optimal way while reducing things like round tripping, with naive code? (e.g. it can automagically parallelize and optimize the "N+1 Query Problem" into an efficient query that minimizes duplicated requests and round trips, with no intervention, and the single 'query' can operate over multiple data sources like mentioned previously.) In other words: it does side effects all the time, and makes them manageable in ways you could only dream of in other languages. Did I mention all of that was done in a library? :)

I mean, we definitely have a sales problem, don't get me wrong. We could spit these stories better or clean up the presentation. I can list off a dozen things Haskell is poor at, or probably an infinite number given the time. But you sort of chose literally the worst example in the world to make your point.

I would suggest you actually spend some time with the language in anger. It is not easy. But I've been writing 'real world' software in Haskell for years, and it's no more difficult or 'magical' than any other part of being a software developer. It's just more rewarding because my code works far more often. And working code seems to be something that's rare in the software world these days ;)

Confusion• 11 years ago

Erik Meijer has been railing against this change on twitter, saying he won't use this version of Haskell for future sessions of the FP101X EdX MOOC. It seems to me that a change that is so divisive among experts is not likely to be a good idea. Disagreement is one thing, but this seems more than just disagreement...

skimpycompiler• 11 years ago

The irony is that this change has nothing to do with expertise. It is entirely subjective.

Scala has awful types. GHC 7.10.2 change is still elegant.

grp2• 11 years ago

I think it's sad to resigning like that but the newcomer argument is misused in this controversy.

I started learning haskell 3 years ago with no background in CS nor in mathematical expertise. So I feel like I'm still a noob toying with ghc until late.

But I welcome that change with a big smile! In my opinion it resolves the list problem (who can be a jail sometimes). As a newcomer I always started with lists which often ended as a bad choice but I learned it that way...

Like: "Oh, wait.. those lists were cools but... WHAT? I need to change everything because just now there are too limited? Fffuuuhh..."

codeisawesome• 11 years ago

Cool, genesis of a fork.

rkrzr• 11 years ago

Is there going to be a backwards-compatible version of Prelude then? Maybe called something like SimplePrelude which could be imported to keep all old code working without any changes (it could also be used for teaching purposes then, because the old Prelude really is much easier to understand for beginners, I think). Or does this change break something fundamentally that makes this impossible?

kolme• 11 years ago

I don't know anything about Haskell other than the basics. I've played around with it, but the most "complicated" things I made with it was Fibonacci and factorial functions.

I'm pretty curious, can someone summarize for me, what was the deal with FTP? What are the pros and cons, and why are people upset about it? That'd be really nice, thanks.

_Codemonkeyism• 11 years ago

The arguments look a little bit like the CanBuildFrom in Scala, which makes container methods really nice (return same container type that you gave it) but method signatures harder to read, with the argument that it makes Java developers go away.

Resigning from the Haskell Platform

Related Stories