Carter's words touched me. Ever neither smart nor silent, I am going to be a little loud once more. Being an outside spectator of this venue, a beneficiary _(one of innumerably many)_ of the work being inconspicuously done by the persons present, and a skilled developer that potentially may shoulder some of the burden, I would really like to understand better the structure of power and the philosophy behind the CLC enterprise — it is not observable, therefore I cannot decide who to be thankful to and whether my participation is reasonably warranted. I know there are people that do a huge amount of work continuously fixing a vaguely defined cloud of _«core»_ packages — but I also know these people have no idea that I exist, from which it follows that my needs and wishes are respected only accidentally. I am voicing this thought for these reasons: * I am a small scale commercial Haskell user — on its face it classifies me as the target audience. I am invested into Haskell but not a luminary like those others present here — rather an ordinary person, an average. In some way this makes me a representative example. * I am somewhat altruistic. I contribute open source code, answer questions about Haskell and even help people privately without mercantile aims. This suggests that I should want to participate in an effort that is beneficial to many — being an altruist, I may as well be an effective one. If there is a person that should be caught in the wave, that is me here. But it is very evident that I am not. The story is that I asked `\x → (x, x)` to be given a place in standard libraries — hard to find a more innocent proposition. As some know, it did not go well. _(This is not an only example but the most striking.)_ There are several possible explanations. 1. This is meritocracy at work. Haskell collects some of the most gifted programmers of the world. A mere mortal cannot possibly suggest any beneficial change to `base` or `containers` or `vector` or `cabal-install` — in all likelihood it was already considered by the wise council. 2. The philosophy is unclear and undisputed. For example, it was suggested to me in private correspondence that the reason the standard libraries are not being extended more often is because exporting more names is wrong. This is of course as valid a principle as any — but I do not see it being spelled out and considered on the basis of evidence. Perhaps the wizards of code are not that good at other things, like being clear about their design goals. 3. The power structure is set up in favour of a specific invisible group that sets the tune. Recall the story about Stack and Cabal. It had been shown clearly that the interests of the community at large are not represented in the group of maintainers of Cabal. It is hard to triangulate from the distance what exactly went wrong, but on the basis of the meager evidence that I can have, the theory is plausible, and evidence keeps adding up. There is also a question of who selects the libraries to be called _«core»_. For example, Stack _(and, consequently, half the user base of Haskell)_ depends on `rio`, and `typed-process` is a superiour replacement for `process`. Should the _«core»_ include packages vital to half the user base? Should it include a superiour replacement of a morally obsolete package? Or is it a place where leviathans of the past come to die? What does it entail for a package to be considered _«core»_? Does it get included in the standard distribution? What sort of packages should we like to distribute? Finally, there is a question of high principles. Haskell can be a pragmatic tool of the trade or a paragon of elegance, rock-solid or bleeding edge… maybe even all of it at once, but what does the _management_ want it to be? What do you folks dream of? What is your ideal? I cannot see any — I only see reactive efforts to fend off the inevitably approaching future. No one would be inspired by that. I suspect there are a few people that get paid to contribute to Haskell. Maybe that should be the main motive instead? Maybe it is time to say that Haskell is a commercial language maintained by corporate employees? I would not like to be one but at least expectations would be aligned. Haskell has not only made me a programmer — it defined me as a person. There is no other language and no other community like this one. I have reverence. Is it the same for anyone else here? Or should I, rather, grow up and move on?