12Daisy
commented
1 year ago @arliss-NF
Closed 12Daisy closed 1 year ago
12Daisy
commented
1 year ago @arliss-NF
12Daisy
commented
1 year ago cc @arliss-NF
12Daisy
commented
1 year ago cc @arliss-NF
arliss-NF
commented
1 year ago @12Daisy - so sorry for the delay - this is an excellent first contribution. Very thorough and concise. Well-organized and the content is at the level we are looking for. Moving on to your second contribution. Please make sure to submit a final application. Thank you.
12Daisy
commented
1 year ago Thank you ma’am for reviewing my workSent from my iPhoneOn Apr 3, 2023, at 4:04 PM, arliss-NF @.***> wrote: @12Daisy - so sorry for the delay - this is an excellent first contribution. Very thorough and concise. Well-organized and the content is at the level we are looking for. Moving on to your second contribution. Please make sure to submit a final application. Thank you.
—Reply to this email directly, view it on GitHub, or unsubscribe.You are receiving this because you were mentioned.Message ID: @.***>
Name: Emile-Daisy Project: The Django open-source project Governance model: https://www.djangoproject.com/weblog/2020/mar/12/governance/
Django is an open-source web framework for Python that follows a community-driven development model. The Django project has a governance model that outlines how decisions are made and who has authority in the project. Here are the key elements of the Django governance model:
Django Technical Board: The Django Technical Board (DTB) is responsible for overseeing the technical direction of the project. The DTB consists of five members who are elected by the Django core team for a term of two years.
Django Core Team: The Django Core Team is responsible for maintaining the Django codebase and reviewing contributions from the community. The Core Team consists of approximately 20 members who are selected based on their contributions to the project.
Decision Making: Major decisions in the Django project are made through a consensus-based approach. The Core Team and the DTB discuss and debate proposals, and decisions are made based on the opinions of the majority. In cases where a consensus cannot be reached, the DTB has the final say.
Contribution Guidelines: The Django project has detailed guidelines for contributing to the project. These guidelines cover code style, documentation, testing, and other aspects of contributing to the project.
Code Review: All code contributions to Django are reviewed by the Core Team. The Core Team provides feedback on the code, and contributors are expected to address the feedback before their code is merged into the codebase.
Release Cycle: The Django project has a regular release cycle, with new versions of Django released approximately every eight months. The release cycle includes alpha and beta releases, as well as a release candidate.
The Django governance model is designed to ensure that the project remains open and community-driven while also maintaining a high level of quality and consistency in the codebase.
The decision making process for the Django open source project typically involves the following steps:
Discussion: When a new feature or change is proposed, it is first discussed on the Django Developers mailing list or on the project's issue tracker. The proposal is presented with supporting evidence or use cases, and the community is invited to provide feedback and raise any concerns or alternative solutions.
Decision-making body: Once a proposal has been discussed, a decision-making body is responsible for making the final decision. For Django, this body is the Django Technical Board (DTB). The DTB is made up of a group of developers who are responsible for the overall technical direction of the project.
Decision criteria: The DTB considers a range of criteria when making decisions, including the impact on the community, the maintainability of the code, and the overall direction of the project. They also consider the opinions of the wider community and aim to reach a consensus where possible.
Voting: In some cases, the DTB may hold a vote to make a decision. Each member of the board has one vote, and a decision is made based on a simple majority.
Implementation: Once a decision has been made, the implementation of the change or feature is typically done by a volunteer contributor from the community. The code is reviewed by other members of the community, and any issues or bugs are addressed before the code is merged into the main codebase. The decision making process for the Django open source project is transparent, community-driven, and focused on the long-term goals of the project. The process is designed to ensure that decisions are made in the best interests of the community and the project as a whole.
Finding information about the governance model for Django is relatively easy, as the project's website includes a section dedicated to governance, which can be accessed from the main navigation menu. This section provides detailed information on how the project is run and how decisions are made. Understanding the governance model, however, may require some familiarity with open source development and community-driven projects. The Django governance model is based on the principles of open governance, with a core team of developers overseeing the project's development and decision-making processes. The model is structured around a set of governance documents, including a code of conduct, a roadmap, and a technical board that oversees development and manages conflicts. Overall, while understanding the details of the Django governance model may require some prior knowledge of open source development, the information is easily accessible and well-documented for those interested in learning more.