We agreed upon the following areas to prioritize for funding. These were identified as critical shared needs by both the Jupyter Community as well as the Member organizations.
Grow the contributor capacity of Jupyter¶
A consistent challenge within Jupyter’s community is the lack of resources and time to maintain and develop its technology and community. At the same time, Foundation Member organizations have many people who are interested in contributing, but face barriers to doing so.
By using Foundation funding to grow the contributor capacity in the Jupyter ecosystem, we can alleviate a key burden on Jupyter’s existing maintainers and provide an easier way for Member organizations to participate and contribute.
Key outcomes¶
These are likely not exhaustive, but are included to help us understand the kind of impact each goal should have.
- Grow the number of contributors. It is easier for any contributor, regardless of their organizational affiliation, to contribute to Jupyter and sustain their participation. We’ll measure success by recording the contributions (PRs, issue participation, etc.) that come from non-maintainers, as well as the growth in self-identified contributors over time.
- Improve the efficiency of our contributors. It takes less effort to maintain and develop technology in the Jupyter ecosystem. This includes reducing toil, automating common actions, defining processes and responsibility that helps us execute more reliably and effectively, etc.
- Facilitate learning across the Jupyter subprojects. Currently many subprojects act as independent and self-contained teams. They do not have a reliable way for learning from others in the Jupyter ecosystem, sharing resources, and sharing skills. Creating mechanisms for connecting these separate parts of the Jupyter ecosystem will result in more coherent and efficient actions across its community.
Examples of how to grow contributor capacity¶
- Hold events that grow Jupyter’s visibility and presence.
- Hold events that give newcomers an opportunity to collaborate with maintainers in real-time to gain comfort with participating in the project.
- Improve the documentation for navigating the Jupyter project as a whole (e.g., helping newcomers understand the project’s subprojects, skills needed to contribute to each, etc)
- Improve the documentation across each of Jupyter’s subprojects, with an emphasis on documentation for contributors.
- Fund maintainer time to organize community meetings and coordinate their efforts, with an emphasis on making them accessible and useful to non-maintainers. (for example, a “Developer Experience” or “Community Manager” role)
- Fund regular, low-effort events that give others an opportunity to pair with maintainers in common maintainer actions like PR review, issue triage, etc.
- Fund maintainer time to steward contributions from external contributors and provide them feedback with the goal of increasing their comfort with contributing.
- Fund development work on maintainer infrastructure that reduces toil and grows efficiency (e.g., improving the Jupyter Releaser technology and documentation)
Improve the reliability, security, and consistency of Jupyter’s software¶
Many of Jupyter’s repositories lack the capacity needed to be considered reliable, safe, and consistent. This is due to a combination of bandwidth constraints, tooling, training, and coordination. As a result, Jupyter’s subprojects often accrue technical debt that burns out their maintainers, and that increases the variability of their outputs. Member organizations have a desire for Jupyter’s technology to be reliable, safe, and consistent. This allows them to confidently build their own technical dependencies on Jupyter technology and use them in production contexts.
By using Foundation funding to improve the reliability, security, and consistency of Jupyter’s software and team practices, we can help Jupyter community members more sustainably manage their technical and team debt, release more reliable software, and reduce the burden on user organizations that deploy this software internally.
Key outcomes¶
These are likely not exhaustive, but are included to help us understand the kind of impact each goal should have.
- Increase contributor perception of the software quality. Jupyter’s community members are valid assessors of Jupyter’s software quality, since many are professional software engineers and because their perception influences their engagement with Jupyter. We will measure their perception of Jupyter’s software quality through community outreach efforts, such as a semi-annual survey.
- Increase testing code coverage. Software testing is a fundamental aspect of ensuring a base level of software quality. We will identify a set of key repositories based on usage and dependencies and track the amount of source code covered by tests at all levels.
- Increase the frequency and transparency of minor releases. “Release early, release often”, with an emphasis on minor releases providing bug fixes, security patches, non-disruptive performance improvements, and similarly non-disruptive new features. Ensure that releases always make it clear what has changed and what it means for a user. Minor releases with these characteristics are easier for Jupyter users and operators to deploy. This pattern also keeps the contributors familiar with the release process.
- Increase the speed of security fixes. Security vulnerabilities are a strong concern for organizations that deploy Jupyter technology as part of shared services. Improvements to Jupyter’s overall software quality should result in faster, more efficient processes for identifying, resolving, and releasing security errors.
Examples of how to improve Jupyter software reliability, security, and consistency¶
- Hold events that allow subprojects to meet and co-work to solve their most pressing problems.
- Fund contributor time to focus on security, testing coverage, etc.
- Fund contributor time to create more consistent releases with higher-quality release notes across the project.
- Fund development efforts to build common infrastructure for releases, documentation, and testing across the Jupyter ecosystem.
- Fund contributor time to focus on stewarding pull-requests, with a focus on maintenance and bug fixes.
- Fund contributor time for stewarding JEPs and encouraging productive and efficient cross-community conversation.
Ensure that Jupyter has a reliable source of funding by developing the Jupyter Foundation¶
The funding mechanisms we define will only be effective if we can reliably engage and grow the members of the Jupyter Foundation. Doing so will require dedicated capacity to ensure that the Foundation is delivering value to its members and to engage prospective members to grow the foundation.
By using Foundation funding to develop the Foundation membership and ensure it delivers value to them, we will increase the likelihood that the Foundation’s members are engaged and satisfied with their participation. This will reduce churn and increase our chances of increasing financial resources for the project.
Key outcomes¶
These are likely not exhaustive, but are included to help us understand the kind of impact each goal should have.
- Jupyter Foundation members find value in their membership. The primary goal of this group is to ensure that the members of the Jupyter Foundation are engaged, see their interests represented, and generally see value in their membership with the Jupyter Foundation.
- The Jupyter Foundation has the resources it needs to accomplish its goals. In order to ensure that the Foundation can meet its goals, the Foundation needs financial resources from its paying members. This committee also aims to grow the Foundation to a level that allows it to accomplish its goals.
Examples of how to develop the Foundation¶
- Identify the necessary roles to sustain the Foundation operations (e.g., Treasurer, Executive Director)
- Create feedback loops between the Jupyter community, the Jupyter Executive Council, Member Organizations, and the Foundation (both synchronous and asynchronous)
- Develop mechanisms for reporting progress and outcomes to Members to sustain/grow funding commitments
- Develop mechanisms to enable Member Organizations to shape funding priorities and balance this input with the needs of the Jupyter community
- Give Jupyter subprojects visibility into the Foundation’s activities and opportunities for input