Governance

The following Document is adapted from the Cooperative Software Development Guidelines Governance document version 1.0.0. The original copy is in the JoinJabber Collective repository

JoinJabber is a collective, that aims to:

  • Improve XMPP by making it:
    • Safer.
    • Easier to access and sign up.
    • Advocate for the people that use XMPP.
  • Follow and advocate for consent and Permacomputing principles.
  • Promote the autonomy and privacy of people using XMPP.
  • Encourage inclusivity, diversity, multiculturalism, and language diversity both in JoinJabber and in the XMPP network.
  • Encourage and promote participatory/cooperative run servers and XMPP implementations.
  • Encourage cross-network/cross-communities organizing and collaboration.

To achieve those aims, JoinJabber:

  • Performs On-boarding, Education, and mutual aid for people new to XMPP.
  • Collect and advocate for ideas to improve the XMPP ecosystem from the perspective of people already using it.
  • Support and organize mutual aid to Server Operators around common guidelines and values.
  • Encourage participation and give platform to marginalized groups, for more diversity, equity, and inclusivity in JoinJabber, the XMPP network and XMPP implementation development.
  • Develop and standardize aspects of XMPP.
  • Advocate and support sustainability in the XMPP ecosystem as described below.
  • Support development of XMPP (through specifications, funding, repositories, infrastructure, sprints, or other means).
  • Organizes and perform XMPP outreach and cross-network/cross-communities collaborations.
  • Promotes interoperability between Jabber/XMPP and other standardized and federated/distributed networks; we stand up to the Internet giants by fostering communication between communities (such as IRC, Matrix, Fediverse…).

Our Code of Conduct lists more of our principles. Instead of duplicating the Code of Conduct here, readers can refer to the Code of Conduct for more values of JoinJabber.

No separation between the "organization/collective" and the community that does the work. We take care of each other's mental health and material needs. We shape the collective together and contribute to common goals.

We are sharing the resources we have (income (if any), funds, infrastructure, etc.) and decide how to distribute it.

We encourage other communities to adopt this model and for collectives and projects to adopt mutual aid and share resources (e.g. any contributors, funding, or any other form of organizing).

A harmful culture is prevalent in FOSS/FLOSS/OSS. The lone developer/BDFL model. This is where programmers/developers/hackers have complete control which results in:

  • Burn-outs for developers, since everything is on their shoulders.
  • Deep divisions between programmers and non-programmers (reflected in the term "users", in the mentality of "patches"/"volunteers" and partially in the mentality of "tech bros").
  • Abusive relationships like (opt-out) data-collection, ignoring accessibility or other problems that arise from limited participation of people who can't contribute to the code directly.
  • Worse interfaces, worse developer experience and worse ways to contribute.
  • Gatekeeping of improvements to the software in ways of "it's a gift" and "I can do whatever I want".
  • No insight into how things are being worked on that results in unrealistic timelines and demands.

JoinJabber aims to use, promote, and help adopt governance in projects with the aim of being participatory, cooperative and egalitarian, based on equity. Implementations are developed jointly by the community that contributes in any way, and the people that use it. We seek to lower or eliminate the barriers between developers and so-called "users" into a community that develops the software.

We (JoinJabber and all XMPP projects/collectives participating or promoted) recognize as our responsibility to listen to feedback and requests from the community in our spaces and circles. This applies to people who don't code or don't open an issue. It also applies to people not in the rooms and chat.

While this is our responsibility as people that have knowledge in a specific area and have time to get involved, it doesn't mean:

  • We can't do our own thing.
  • We have to listen to all feedback.
  • We have to start working on feedback as soon as possible.

It does mean though that the mentality of "patches or nothing happens" or "we are all volunteers and work on what we want" is not what we want to see in our spaces.

The earth and the environment has limits. JoinJabber follows the principles of "care for the earth" and "care for people" as the axiom for all choices.

Software is "by" and "for" the people. Computing is a means to improve human lives and abilities where it makes sense, not an end in and of itself.

We advocate for a radical rethink of computing as a whole (both hardware and software), across all aspects of production, usage, and architecture/design.

We follow, and advocate for the Permacomputing Principles from the Permacomputing collective.

JoinJabber promotes privacy as a fundamental human right, and as a pillar of popular power and autonomy. We take part in evaluating the privacy of the ecosystem, and proposing recommendations for implementers, for server operators, and for people using XMPP/Jabber.

We push back against data harvesting practices of any kind.

JoinJabber advocates accessibility for everything, regardless of physiology (disabilities), neurodiversity and resource limitations (slow Internet access, low-end hardware, or lack of money).

We do the work to bring accessibility to the XMPP/Jabber network, the implementations, and advocate for accessibility beyond XMPP when collaborating with other networks/communities.

We do not do anything that is against our values or questionable, to justify the result we will get later. We do every action and step toward our goals according to our values, and following our ethics.

As described in the Cooperative Principles section, JoinJabber aims to build healthy, inclusive and diverse projects based on equity. We are advocating for communities that build software together to fit their needs (not just programmers). We do not want to have Free as in Free Time Software (whoever has the privilege to have free time gets a voice in FOSS/FLOSS). We want to actively work to give platform to less privileged people that can't take part due to money or any other constraints and to work with existing contributors/communities and projects to make them sustainable in a self-organizing way.

JoinJabber aims to do collective work and XMPP development sustainable. This includes (among others):

  • Taking steps to protect the mental health of volunteers.
  • Giving adequate time and space for collective/project work and for non-work.
  • Encouraging more people to share the same responsibility so that volunteers don't have to shoulder everything alone.
  • Provide tools and infrastructure to make the work of volunteers easy and focus on their comfort.
  • Depending on the monetary ability of JoinJabber at the time, compensate volunteers for working on JoinJabber projects/goals that were previously agreed with the community.
  • For XMPP implementations specifically:
    • Organizing and managing funding.
    • Encourage and help set-up inclusive, diverse, sustainable communities according to JoinJabber values (e.g. Cooperative and Sustainability principles)
    • Fund XMPP standards to make implementation of XMPP easier.
    • Take care of the stressful aspects for XMPP software projects (example: hosting of rooms, finding volunteers, outreach etc.)
    • Encourage ways to ensure long term sustainability (eg. monetary income (through donations or other means) or infrastructure) and community ownership of the project (eliminating/reducing single point of failures and burn-outs).
    • Help build a culture of inclusivity towards less priviledged people and encourage participation of non-programmers in the project.

We give consideration to people who are not here. We don't:

  • Expect everybody to code.
  • Believe that licenses are a substitute for social interaction/consent between people/projects.
  • Believe that if we can "see" something (text, code, picture, etc.) we can do whatever we want with it.

We are humans first, state legal stuff are just a necessity. We contact and ask for permission from the person/project that created said thing (software, documentation, etc.) for permission if we are doing something that may not be okay. If we are not sure then we ask.

In JoinJabber we have a culture of talking openly about both good and bad things.

We think it's important to offer compliments and praise people often because what keeps us going is appreciation for our work. We are not alone but a community that acknowledge and appreciate one another.

Sharing problems or complaints is also important. Problems should be voiced early so that we have a chance to talk before feelings of resentment start settling in. We focus on restorative justice and non-violent communication as frameworks to talk to one another and solve conflicts. Some resources are given below as suggested reading.

Disclaimer: While we try to practice non-violent communication we do support free expression and we encourage people to express themselves with all the range of emotions they have. We will never try to "tone-police" a person when they try to be heard.

Suggested reading:

JoinJabber works actively with the XMPP/Jabber community at large and aims to serve as a meeting point, organizer, and federation for any communities or projects that want to collaborate in any way in the XMPP/Jabber network or not.

This means that besides individuals who can join as JoinJabber members, communities/organizations can also join by:

  • Participating in an existing circle. One delegate per each non-JoinJabber entity.
  • A proposal for the formation of a JCC (JoinJabber Community Circle) as an independent circle to advance the interests of the group. For a guide how to create it refer to the JoinJabber Community Circles document (TBD.).

Communication between circles within the JoinJabber collective is in English, and we encourage speakers of other languages to express their concerns via translations and/or delegates of their choice. A copy of the original text is also sent together with the translation.

The language used inside circles is up to the discretion of the circle.

The JoinJabber Collective is comprised off:

  • Its members. People that are members of a JCC and have voting rights.
  • The delegates of the communities that take part in JCCs.

Work in the JoinJabber Collective is organized within JoinJabber Community Circles. The structure, creation process, membership, and everything else is described in more detail in the Community Circles Document (TBD.).

In brief JoinJabber is a network of interconnected circles that operate fully autonomously. They hold each other accountable by sending delegates and coordinators and deciding by consensus. The Decision making document (TBD.) describes how we make decisions.

Participation to a circle's gathering places is open and anybody can voice concerns and contribute ideas to the group. Decision making happens by the members of the circle. The members make sure to take into consideration the people that are not part of the gathering places of the circle and the people that are not members but take part in discussions.

Circles may function as permanent, temporary (for a specific issue or investigation) or organizing (as a meeting point between two or more circles). Circles may also decide to send a delegate to a circle that affects them to be part of decision making.

All work in JoinJabber happens in the open and all tasks are visible to all JoinJabber members. The way used to organize tasks is up to the discretion of each circle.

The reason to make everything public is because it enables transparency and makes it easy pick up new tasks for people to do. It also makes it easy for collaboration between people and circles in addition to long term planning.

RFCs are proposals that specify a big decision or a policy(procedure/guideline). They can be inside a circle or in feedback gathering by the whole collective.

Note: People that are responsible for a specific area of the circle, can act autonomously in that area they have been trusted with. More on this in the JoinJabber Community Circles Document (TBD.).

In a circle they can be used for example:

  • Disaster recovery procedure.
  • Changing providers for the website or the hosting.
  • Making Guidelines for Event Organizing or Flyer/Poster Templates.
  • What criteria do we have for listing applications.

A JoinJabber Community Circle wants to gather feedback from the community at large:

  • Code of Conduct or Event Guidelines updates for the Mediation Circle.
  • An appeal from somebody that had their proposal repeatedly blocked.
  • Changes to any core document in the Governance folder or changes to any Circle's Document.

In case of the latter the circle collecting the feedback has the responsibility to:

  1. Gather the feedback.
  2. Distill it into objections and improvements to the current proposal.
  3. Take it into account when creating the final decision.

Note: Remove the comments before submitting the RFC.

+++
# Title includes name and the number of the RFC.
title = ""
# Format should be ISO. year-month-day
date-last-modified =

# An array of all author names, pronouns and jids (if applicable) seperated by a comma. Also the name of the circle that owns the RFC.
# See previous RFCs or the governance documents for an example.
authors []

# don't change this.
license = "CC-BY-SA-4.0"
# version starts from 1.0.0. Rules to change the version are up to each circle.
version = "1.0.0"

# This is the date the circle has agreed to look at this RFC again, to check if it is working as intended or needs changes/retraction.
# After the review the field below will change to reflect the date of the next review that was agreed.
date-of-next-review =
+++

## Problem Statement
Describe the problem that the RFC aims to solve and why the problem exists.

## Proposal
The proposal to solve the above problem.

## Who it affects
List people and groups that this proposal affects/may affect.

## Rationale
What is the impact of not doing this?

## Impact
What could go wrong when we do this? What should we be careful for?

How will the proposed change evolve with time?  What is the cost of changing the approach later?

## How do we know we succeeded
What are the visible/measurable improvements this proposal is going to make if it's implemented?

## Previous Versions
Everytime the RFC changes version write a note on what changed here. One entry per version.

## Comments from previous review sessions.
Any comments or concerns from the previous review sessions.

Propose an RFC to either:

  • The Collective repository for feedback by the whole JoinJabber collective.
  • The individual repository of a given circle for decision making inside a circle. If no individual repository exists it is added to the collective repository and tagged accordingly.

The Decision Making Document (TBD.) describes the decision making process for RFCs.

The JoinJabber collective works on implementing the RFCs, after they pass the vote, on its own discretion.

The procedure to change this document is defined in the Core Circle Document (TBD.).