The FTP fiasco

Isn't it hilarious? But the real question is, why are Haskallers so stupid? seriously, it's almost like they want to shit all over what took them decades to build...

Anyways, >>1, please listen to me. That it's really related to this thread. I've been in the haskell community, you know. Well anyways there was an insane number of people there, and I couldn't get in. Oh, the stupidity. Those idiots.

you have high-t low manhood brogrammer types with something to prove like bitemyapp (he wrote monohaskell site) who spends 90% of his time scaring people away from the haskell community with nastyness and smug belittling (and off of other sites where he "challenges" people to prove him wrong about how haskell is faster than YOUR shit language) and the other 10% "teaching" to buy himself a permanent position embedded in the community. Any time his bullying is called out people jump to his defend with "b-b-but he is such a good teacher!", irrelevant. It's exactly the same pattern as with dibblego (although nobody is ever going to best him at his own game).

Secondly you have suit/drone types like edwardk with greased hair that smoothly climb the social ladder up to the top - doing "consulting" and other smile-and-shake-hands with the right people jobs - while stomping on top of anyone a bit unusual. Geeks/Nerds/Outsiders with lower social skills were who really mattered in early haskell. And do you really think running through an entire book of collected results of category theory and typing them into haskell files is an achievement? I want to interrogate you for roughly an hour, do you really believe that we were missing out on higher order zip zap chrono denisty morphisms?

Anyways, I was about to start programming, and then the 1GB GHC bastard of a compiler goes "type error." so I turn off the monomorphism restriction and its still not working. Everything has changed, it's impossible to build a monad transformer stack like normal and get good error messages. they changed it to a whole ridiculous typeclass system that both can't give good error messages anymore and .. all in the name of making it easier for beginners (that is: people who can't be bothered learning how to actually do it, even though it's very easy if you just read a tutorial). Who in the world can't build a monad transformer stack nowadays, you morons?

Pure hindley milner type inference with 98' typeclasses. That's the vets way of hacking. Every valid program can have its typed fully inferred with no signatures, this is the key. And then, it's delicious. This is unbeatable. However if you stick to this it's a double edged sword: you can't use a lot of system-F's advanced features which do have their place. I can't recommend it to amateurs.

http://www.northjersey.com/community-news/borough-s-bravest-find-friend-in-lemonade-stand-proprietor-1.1353131


Haskell boy raises $170 for Wanaque Fire Dept. by selling lemonade

>>2
hah you know the haskell community pretty well, would you mind if I ask you what's your opinion on haskell's (just as a language) direction over the last, say, six years?

HASKELL IS GOIN TO SHIT IM MOVING TO AGDA BOYS

FTP stuff should be written in something webscale like Go or node.js. It wouldn't have taken them decades if they picked the right tool for the job.

Why the fuck would you write ftp server in haskel?

What is "the FTP fiasco"?

Miranda is where it's at, SKI combinators all the way down..

I think this is the right time for me to exit:

The truth is, I still can't bring myself to use a version of Haskell post
the Foldable-Traversable-aPocalypse, let alone some future Haskell after
the changes now in the works. My personal machines are all still 7.8. My
personal projects are all pre-FTP. The Haskell I love to code in, the
Haskell I'm passionate about, the Haskell I've advocated for real world
use, and the Haskell I like to teach, is 7.8, pre-FTP.

It's not that I'm dead set against change and evolution in a language, or
even breaking changes. But FTP and beyond are changes that have lost the
balance that Haskell had between abstraction and clarity, between elaborate
and practical engineering. I don't see any restraint going forward, so I'm
getting off the train.

This puts me in an odd position with respect to Haskell Platform: I find
myself building the Platform for a version of Haskell that I don't use.
This isn't healthy for either the Platform or me. Hence, I'm resigning as
release manager.

I am sad because I believed that Haskell's path to much wider adoption was
within reach. Now, especially with the ramping up of the Haskell Prime
committee, which seems preordained to codify FTP and beyond into standard,
we are approaching our Algol 68 moment: Building a major language revision
with less opportunity than it's predecessor.

I'll still see you 'round at meet-ups and conferences. I'll just be coding
with an older accent.

- Mark "mzero" Lentczner

I want Haskell to live and even thrive as a language just as long as it is isolated and contained and doesn't spread it's shit influence and keeps Haskell types there and out of the workforce, academia etc.

Haskell ghetto.

what the fuck is Foldable-Traversable-aPocalypse?

>>12
I think that basically haskell implicitly imports this "Prelude" file with some basic stuff like list data types in it.

And after like 20 years of everything being ok they decided to completely change the prelude and break loads of old code so that everyone is forced to use these weird new typeclasses that Lens has (the shittest snakeoil library ever written).

Another option would have been just making a library that people can import but they have dominated the haskell world and taken control of it and want everyone to know that so they forced it upon everyone that uses GHC instead of making it a choice.

People are afraid to say that they are unhappy about this because there's a very small number of people that you have to stay buddy-buddy with who manage 90% of haskell jobs.. and you don't want to have to write java instead do you?

>>13
I don' think it broke anything. Many Prelude functions that used to only work on lists now work on Foldable. Now List is an instance of Foldable, so those same functions still work when applied to lists, in addition to anything else implementing Foldable.

The only downside is less discoverability for those particular functions. Not that discoverability wasn't a problem before - many libraries I have tried to use have data structures that implement about fourteen thousand interfaces, which causes the same "so what the fuck can I actually do with this?" problem as inheritance in OOP, but an order of magnitude worse.

>>14
Discoverability also doesn't matter actually. The case is SPJew wants to make FOLDABLE^tm and TRAVERSABLE^tm into fundamental type classes and forces everyone to learn their interfaces, so that it's in turn possible to force absolutely everything to implement them. ``Everything is a FOLDABLE<sup>tm</sup>! Everything is a TRAVERSABLE<sup>tm</sup>!''. A new ``paradigm'' right here shoven deep into the old Haskal dogs' throats.
That fucking jew. I knew he would betray me for the LENS^tm fuckers' shekels since day ONE.

>>15
Isn't everything in Haskell a monad anyway?

>>15
spj has no part in this

Lenses have ruined Haskell completely. Why didn't Kmett stick to C++?

>>17

spj has no part in this

Except he was the one who initiated this shitfest in the first place^[1]:

Below is a tentative list of such changes. This is offered as
the beginning of a discussion rather than a final proposal per
se. As part of the proposal, we should solicit feedback from
the community at large (not just on this list) as well as the
haskell' committee in order to ensure that we do as much as we
can to clean things up. In particular, it'd be good to assemble
the list of complaints/proposals prior to trying to resolve the
details of any particular one, similar to the haskell' process
I suppose.

* Applicative => Monad.
* Unify pure/return. Depends on Applicative => Monad.

* Add join method to Monad, with default definitions for
* join/(>>=).

* Remove fail from Monad (add Monad => MonadFail, if desired).

* Make the (<$) method of Functor more official. When starting up
ghci-7.6.1, it only gives (<$) qualified as (GHC.Base.<$)

* Replace Enum by type classes which do not require partial
* functions. (I have a more concrete proposal for this one, which I'll put on
Hackage in the next week or so.) This isn't a hot topic like the others, but
it's part of the general concern about having partial functions as
standard/required parts of the language.

* Remove from the Prelude things which are not required for resolving circularity. This is highly controversial, but I think it would help minimize future issues. If desired, in order to reduce imports, we could have an Interlude which serves the kitchen-sink role of the current Prelude but which requires an explicit import rather than being implicit like the Prelude is.

* Remove the list-monomorphic versions of Foldable/Traversable functions. And/or export them from a separate PegagogicalHaskell module for learners to use, such that they do not materially affect intermediate/advanced Haskellers.

* This is a bit off-proposal, but: do not have every Control.Monad.* module re-export Control.Monad. Modules like Control.Monad.Foo should only export Foo-specific things; if people want the general tools they can import Control.Monad itself. This is related to the pain of standardizing on Foldable/Traversable.

* Clean up the Monoid class, add a Semigroup superclass, etc. There was a lot of discussion about this a while back. We came up with a fair solution, but it'd be nice to revisit the discussion and tighten things up while we're at it.

_______________________
^[1]: http://osdir.com/ml/libraries@haskell.org/2013-05/msg00280.html

>>19
ok I was wrong, thanks for correcting me

>>2
Man, Haskal was better in 2003.

Oh yay, they fixed the prelude?
Did they fix the dumb text/bytestring/whatever thing too? It's so cute that Haskell still cannot disambiguate between functions with the same name in the year of our Lisp 31.

What happened with fmap?

>>19
What a shame. Some of these things are actually very good (I've been waiting for Functor/Applicative/Monad for ages), and then he goes full lens.

Haskell is functional Java now.

>>24
No it isn't. Java has humility.

>>25
The authors of overengineered garbage don't, but I guess you are right about the language's authors.

I think Foldable-Traversable is a good thing. Moving fail to a MonadFail class is also good.

The type class hierarchy needs an overhaul. Num should be split up into a class for non-negative numbers which would include Natural.

Haskell 1.4's type class hierarchy was better. map used to work on any functor. (++) was part of MonadPlus. List comprehensions were generalized to any monad.

>>22
There's the ClassyPrelude. Some might think it's too ``enterprise'' but I like it.

FPTP is still how we vote.

>>29
babies would die if we changed vote system

http://ichef-1.bbci.co.uk/news/304/media/images/51400000/jpg/_51400389_avbabypic304.jpg
https://i.guim.co.uk/img/static/sys-images/Admin/BkFill/Default_image_group/2011/2/25/1298628970292/no-to-av-baby-campaign-005.jpg?w=1200&q=85&auto=format&sharp=10&s=f4e05b87ae771216d0bd1bb8bb91faab

>>30
That's fine, I'm feeling rather peckish anyway.

>>31
a modest proposal

>>31
are you a woodpecker?

Why would they spend 250 million pounds for this? Looks like someone can't manage the money properly.

>>34
They would havo to teach the electorate how to count up to five.

>>24
Unlike his fellow ABSTRACT CANCERS FACTORY excretor Poeterring, Kmett is actually a very brilliant guy. Too bad he's also the kind that would for the sake of mental masturbation utilize all of the brilliant part of his mind to shit out functional JAVABEANS.

>>36
this is a common misconception, he's actually a jerk and not 'brilliant'

>>37
Yeah. All he does is rewrite well known category theory theorems in Haskell and add inline directives. Even my 5 year old can write a program to do that.

>>38
Sounds like a brilliant kid and doesn't make Kermit any less brilliant.

40 cm

fuck the police

>>13,15
Foldable is just ToList, Traversable is just ToListApplicative. For a language that is so crazy about linked lists, the adoption of those classes into Prelude is only logical. It would make sense for Lisp, too, but Lisp just cannot into typeclasses.

>>42
It's also an examplar abstraction creep.
See, a class for fold sure does help a lot: pretty much every agelbraic type can be folded and you can even mechamically derive fold for them too, but why the hell does Foldable have fucking length in it?

>>43
fold has a very different type for each algebraic type though.. it's not something you can abstract over with a class

>>43
because length = foldl (const . (+1)) 0

>>45
Well I mean why just let List keep length and call the Foldable equivalent total or something? Because the name length implies some sort of sequential linear structure, while a Tree can be Foldable too.
>>44

it's not something you can abstract over with a class

You can if you restricted it to type constructors with kind *->*, and Foldable does just this.
class Foldable f where foldr::(a->b->b)->b->f a->b

Doesn't stop Foldable from being a convoluted OVER-ENGINEERED piece of shitware.

>>43
Because Foldable is ToList. If a data structure is coercible to a list, then there obviously is a way to define length for it.

>>46
Being a member of Foldable already implies some sort of sequential linear structure, whether it's a tree or not is irrelevant. If it's listable, there is length of it.

>>48
No it doesn't you monkey, it just says there is a structure-preserving map from some initial algebra to some other algebra. It implies nothing of there being a measure that corresponds to the length.

data Expression = Number Int
| Add Expression Expression
| Minus Expression
| Mult Expression Expression
| Divide Expression Expression

>>46
that's not a proper fold though, as 47 its a shittly listlike structure. Don't let them use 'advanced' names like Fold trick to you into thinking there's anything clever going on here. It's java level unprincipled bad design.

>>49
don't conflate category theory ideas like inital alegebras and folds with the cappy 'likelist' typeclass they've come up with and happened to call fold.

exercise:
(1) Define a foldable instance on your Expression a type (change it so Number Int is Number a).
(2) Remember how in category theory the identity function is an example of a fold? Define that using foldr :: (a->b->b)->b->f a->b

1 is possible of course but 2 is not, because it's not a real fold.

fuck what these people are doing to destroy this once beautiful language. Seriously? Am I the only one seeing this happening? They keep moving further and further away from mathematically justified things.

>>49
You're converting a datastructure to a finite list. All finite lists have lengths. Which fucking part don't you understand, caveman?

>>51

mathematically justified things.

Yeah, like Num. All of my category theory books say that numbers must have functions for negation and conversion to strings.

>>53
I agree Num is and has always been shit. I don't think that invalidates my other point though.

real fold

you mena CATAMORPHISM

Haskell is deprecated.
Install Rust today!

fold my anus

CATAMORPH MY ANUSMORPHISM

>>58
I prefer Ana^_lmorphisms.

it's just a trick to invalidate the old books and sell new books