Understand and sort official/unofficial Haskell related organizations

Show and Tell
#1

Hi.

I am trying to get my head around Haskell related organizations on GitHub and GitLab. I want to reduce the barrier for people to start help improve the Haskell ecosystem. What I found so far:

GitLab organizations:

  • ghc: GHC development.

GitHub organizations:

My question is more related to the GitHub organizations. Is there a clear notion of what these organizations do? Who is leading them? Where is this information?

I suggest summarizing all official organizations (and semi-official ones if such a category exists) on haskell.org, and make clear where ideas and such in form of Requests For Comments should go. To be honest, I prefer fewer well-maintained organizations over a proliferation of organizations with unclear purposes.

I also suggest stating that all other organizations are unofficial in that they are maintained by individuals, and not managed by a committee associated to Haskell/GHC/TheHaskellFoundation (What is actually the top official instance of Haskell?).

I suggest doing this on the https://www.haskell.org/community/ website, or probably even on a separate tab.

Please let me know what you think!

EDIT: I just found Haskell.org Committee, which might also be relevant to the discussion!

4 Likes
#2

I don’t understand how sorting the organizations would reduce a barrier for improvements to the ecosystem. If there is a thing somebody wishes to improve, they find the repository for it, and that repository has maintainers. The fact that different repositories are under different organizations is somewhat orthogonal – it is the maintainers of that specific repository that matter.

That said:

Haskell foundation is the org associated to the haskell foundation nonprofit organization: https://haskell.foundation/
Haskell org is associated to the Haskell.org committee: Haskell.org Committee
Haskell-infra is associated to the haskell infrastructure team: GitHub - haskell-infra/haskell-admins: Information and resources regarding Haskell infrastructure admin team

As you note, the main haskell organization is sort of shared between various teams – ghc, core-libraries, cabal etc. exact ownership is not fully specified: GitHub - haskell/meta: A place for discussing & documenting the github.com/haskell organization

Haskell-numerics is just an organization a group of people made. You will note of course that anybody can create a github org with any name, so anyone can create a github org with “haskell” in the name :slight_smile:

#3

I don’t understand how sorting the organizations would reduce a barrier for improvements to the ecosystem.

I do.

Unless you’ve spent 10 years in the haskell community and know all the bazillion committees, processes and interactions between the groups, it’s not easy to drive improvement except for patches to repositories.

Either we sort these properly or make clear that the Haskell Foundation is the ultimate entrypoint, which will then defer certain topics and discussions to the right governing groups.

7 Likes
#4

That is exactly my point. In my opinion it should be made clear which organizations are official and what are their respective assignments.

#5

I highly relate to the organizational overhead imposed on the Haskell community by the number of various independent groups 🫂

Committees, Task Forces, Work Groups and whatnot.

In the past, I wanted to document all of the existing structures but the number of different groups and their bureaucracy overheads made it an almost impossible challenge.

I’d like to add a few more groups to your list:

  • ghc-proposals: A committee for evaluating GHC proposals.
    • :warning: This is not the same as GHC developers! But some overlap may exist.
  • Core Libraries Committee: A committee for evaluating proposals to the Haskell standard libraries. It’s an important entity but it’s also just a repository inside the haskell GitHub org.
  • cabal and stack developers are also two completely different separate groups.
  • I believe, ghcup is also maintained separately from everything else and there’s no separate committee that tells GHCup maintainers what to do.
  • haskell-hvr: A bunch of important Haskell packages maintained previously by HVR but now also maintained by other people as well.
  • haskellari: A bunch of important Haskell packages maintained by Phadej but now also maintained by other people as well.
  • Kowainik: A bunch of important Haskell packages maintained by the Kowainik organization.
  • Haskell Weekly: It’s a separate newsletter but it’s the most important Haskell newsletter and it’s been around for years.
  • haskell-crypto: A GitHub org affiliated with Haskell Foundation.
  • haskellfoundation/stability: The Haskell Stability group.

Also, don’t get me started on why we have two completely different organizations named exactly the same:

I’m also not going to mention the fact that some parts of these organizations are on GitHub but others are on GitLab (e.g. the Haskell standard library is on GitLab but the committee uses GitHub).

I might forget something, this is just from the top of my head.

The notion of Official vs Unofficial is also not clear. Some of the groups are really important to the Haskell ecosystem but they are not affiliated with Haskell Foundation.

All of this makes contributing to the Haskell ecosystem significantly more difficult and immensely frustrating. It’s almost impossible to figure out where and how to start.

7 Likes
#6

In fact… only base, not other core libraries. For those you either have to utilize the haskell libraries mailing list or actually ping all the individual maintainers (that’s what I ended up doing… the libraries ML didn’t serve any purpose for me).

So, if you have proposals that cross multiple core libraries, you’ll be talking to a lot of people with no clear process.

1 Like
#7

B…b…but official according to who? There is no “big org” that can say which others are “official” in what sense? These groups all co-ordinate, but they do not report to one another – they have independent responsibility.

I do think a PR to the community page to enumerate some of the missing stuff, and maybe elaborate a bit further is a good idea.

I want to agree with @hasufell that the issue of “responsibility proliferation” with various groups and needing to co-ordinate is real. However, I want to also emphasize that the different “github organizations” are not the same of as the groups that need to be co-ordinated with. If you want to do something affecting a package in the haskell github organization, what matters is the maintainers and people responsible for that package, not the anything about the haskell github organization per se.

In an open source ecosystem there will necessarily be many groups of people doing different things and individual contributors all of whom work together. Github organizations are just a convenience for sharing some responsibility for managing repos – they’re not going to map onto that other structure. And that other structure is inevitable, and arises naturally – all that can be done is to help direct people as well as possible.

1 Like
#8

… and maintain a map somewhere to the network of groups. Such a map would enable and empower newcomers to understand the lay of the land and figure out where they wish to contribute.

As much as I might want to streamline this all (and I do), I agree that doing so would be hard, needlessly disruptive, and might not net an improvement. Yet that doesn’t mean we can’t provide a map!

As for officialness: that’s really hard. Haskell is a diffuse idea. It is owned by no one and no corporation. Both the Haskell Foundation and the haskell.org committee are legal entities in the US. But anyone can make a legal entity with the word Haskell in its name, just as anyone can make GitHub organizations. In short: “officialness” depends on some root of a hierarchy that is official axiomatically and can bestow officialness on other groups. Haskell has no such root, and thus nothing can be “official”. (Things can be e.g. an official part of the Haskell Foundation, as that locally does have a root.)

2 Likes
#9

Thank you for this explanation @rae. I think two points have emerged in this discussion:

  1. Contributing to packages: As @hasufell pointed out, contribution is involved with base/core libraries. Personally, I do not see a difficulty when contributing to other (non base/core) packages owned by somebody (that can be nicely seen on Hackage) provided that this somebody is an active user.

  2. Contribution to the Haskell ecosystem: In my opinion, it is more difficult when one wants to contribute to the Haskell ecosystem. In think a lot of contributions are not submitted, because life is fast, time is short, contributions are small, and it is a burden to look up where to submit something, and in which form.

I am not sure how to remedy point 1 (especially the core/base part). With respect to other packages, we could ping package maintainers once in a while (e.g., once a year) and ask them “Are you still maintaining this package? If not, can we set it to unmaintained so that somebody else can take over, if they have time?” At the moment, unmaintained packages are only found by trial and error (and that can take a long time). It is also good to know if you as a library developer (or even application developer) depend on an unmaintained package.

I think we can help in improving the situation about point 2 by adding the most important organizations led by teams of individuals (probably with dedicated committees) to the haskell.org homepage, explaining what they do and how to reach out to them. (Some are already there, others are not). I think we should explicitly link to the respective websites of these organizations and also to their code bases (i.e., the respective GitHub or GitLab organizations).

I may have time to work on point 2 in the next days but I can not promise and I only do this if you appreciate this suggestion. Please let me know!

#10

Have you recently championed a proposal that affected multiple core libraries? I’d argue that this happens very rarely… not so much due to lack of ideas, but because:

  1. you can literally give up if you’re not at least involved as a primary maintainer of one of the affected packages
  2. a single unresponsive or unwilling maintainer can block your entire efforts

I can say that the recent AFPP proposal was very close to the limit of what I’m willing to invest into community projects in terms of energy. Luckily I had great backup by @Bodigrim

And yet… I can see why people would disengage from such projects when they realize how much effort and energy this takes. There’s not even proper coordination with the GHC team about boot library schedules/changes/version bumps etc. Everything happens pretty much ad-hoc and you have to make sure to talk to the right people at the right time and get their support.

Maybe you consider this the right way… forge relationships, get support, etc. But I feel this causes cliquesque centralization, where only people who know each other can really drive change.

CLC focuses on base for now, which is probably a good decision, but long term, we need more coherence.

2 Likes
#11

I see your point. No, I have never worked on a proposal affecting multiple libraries (not to speak about multiple core libraries). I agree we should also improve this situation. In contrast to my suggestions above about adding some paragraphs to haskell.org, I do not know how and where to start.

For reference, because I had to look it up: AFPP.

Just so that it doesn’t get lost, please let me know if you think it is a good start to summarize important Haskell organizations on haskell.org.

#12

I’m the executive director of the Haskell Foundation.

As others have said up-thread, there is no “owner” of Haskell who can bestow officialness onto a given organization, committee, or project. Any group can declare themselves to be the Haskell Organization for Purpose X, and then the rest of the community gets to decide whether to follow or trust them for Purpose X. Generally speaking, this happens when the people doing so are acting in a thoughtful manner, and so it all tends to work out. There are a lot of advantages to this approach: we are very resistant to wholesale capture by a special interest that would work against our community values, Haskell doesn’t rise and fall with the fortunes of any one organization, and we are able to match tasks with interests and abilities.

The end result is, however, overwhelming. It ends up being difficult for new participants to enter into Haskell governance without a mentor, it can lead to certain concerns falling through the cracks, and we can sometimes end up with long-running disagreements that nobody is in a position to resolve. Moreover, it creates a selection effect where only people with certain kinds of personalities and enough time are able to be heard.

Our goal at the HF is to find ways to enable Haskell to work better for more people, but not to seize power and start bossing people around. Basically, I try to have my eyes on the cracks that things can fall into so that I can find ways to get them addressed, and I try to find opportunities to help the existing groups work more efficiently and have more fun doing so. Right now, we have one full-time person working on these things, so posts like yours are very important input that helps me think about where to prioritize my time and efforts. Most people in your position just give up and disappear, rather than showing up and asking how to help resolve the second-order issue, so thank you very much!

I think that a map of the community organizations is a great idea. I’d encourage you not to focus on GitHub/GitLab organizations, because those are tools used by existing organizations rather than being the organization itself, though they can be one source of evidence of an organization’s existence and activity. Haskell is an old language and community, and we predate GitHub by many years.

Please let me know if I can help in some way.

10 Likes