Thanks for posting this, it finally cleared up a few postings by Thiago from just after the event.

I wrestled my way through this whole thing, trying to get through the self-referential nature of all the acronyms. Somewhere in the middle I finally found what a QUIP is supposed to be. However, nowhere did I find an explanation of what problem it is supposed to solve, why it solves it, or how it integrates with the current work flow. So far, it seems to me like a solution from some management sphere without a problem to solve.

So, could you please explain, preferably without relying on all the acronyms, what problems this bureaucratization effort is trying to resolve, and how it fits the rest of our work flow (like making feature requests in Jira)?



Op 20/09/2016 om 00:45 schreef Louai Al-Khanji:
Hi all,

Here are my notes from the QUIPs session. Thank you for your patience. :-)

QUIPs are a proposed design process for Qt, modeled after Python’s PEPs.

QUIP 1 introduces the general concept:


QUIP 2 details the Qt governance model, it’s simply the current wiki page
converted into a QUIP:


QUIP 3 is an informational QUIP containing the session notes, which are
repeated below:


The heroku domain is obviously a placeholder.

I have also attached the source files for proposed QUIPs 1, 2, and 3 to this 

One item left open was licensing of the QUIPs themselves. For these I propose
Creative Commons CC0.

Any and all feedback welcome.


---------------- BEGIN NOTES ----------------

At the Qt Contributors' Summit 2016 in Berlin a session was held to discuss the
idea of introducing QUIPs as a new process for Qt governance.

The general idea was introduced by looking at QUIPs 1 and 2, and by looking at
some Python PEPs. The general feedback was positive. An attempt was made to
identify the minimum set of work required to bootstrap QUIP, which was the main
theme of the session.

The overall discussion is summarized below, in roughly chronological order.

- Discussed background of QUIP, the process and the documents. Referred to
   Python and looked at QUIP 1 and QUIP 2 which had been prepared prior to the

   - The idea is to have a new git repository with the QUIP text files

   - Managed through Qt's normal work flow, currently gerrit code review

   - The maintainer of the quips repository takes on required editorial duties
- Agreed that the text documents should be limited to 80 character lines.

- Agreed that care must be taken to ensure that QUIPs are written in "proper"
   English so as to be clear, understandable and concise.

- Talked about how a new QUIP is introduced. The most important thing is to
   reserve a number, which is the identifier of any one QUIP. The title can
   change, and is expected to do so from time to time.

- New QUIP documents will go through a review process like any other patch to
   Qt. The author of the QUIP is responsible for logging this discussion in the
   evolving QUIP itself.

- The important thing is to bootstrap the process. Once it is bootstrapped, it
   is possible to fine-tune the QUIP process through QUIPs. It is expected that
   this will happen.

- The question of what goes into a QUIP was discussed. QUIP 1 gives a rough
   overview of the different kinds of possible QUIPs. It is expected that the
   content be further specified in revisions of QUIP 1 or in follow-up QUIPs.

- Like any other part of Qt, QUIPs are living documents. They can be updated,
   amended or entirely superseded by later ones.

- QUIP licensing was discussed. Python's PEPs are required to be either placed
   in the public domain or licensed under the Open Publication License. The
   former is not possible in all jurisdictions and the latter has apparently
   been superseded by the Creative Commons licenses the CC0 license was

- The minimum QUIP boostrapping process was discussed:

   1. Post QUIP 1 to qt-development mailing list for discussion.

   2. Arrange for hosting of HTML generated from QUIPs (ed. note: quips.qt.io
      has since been made available)

   3. Create new git repository to hold QUIPs

- The initial QUIP process was discussed:

   1. Author of QUIP reserves new number in QUIP 0 (the index QUIP) through

   2. The author gives notice of new QUIP by sending it to qt-development,
      either inline or as a text attachment (things like this can be refined
      later through QUIPs)

   3. Concurrently the author pushes the draft to gerrit where further
      discussion can take place. This discussion must be described in the QUIP.

   4. Decisions are achieved through the same lazy consensus mechanism that
      is in place today. In that respect nothing changes.

   5. A final +2 from the QUIP maintainer(s) is required. This differs slightly
      from other parts of Qt as only the maintainer(s) can +2 changes to this

- Louai naively volunteered to convert existing material on the wiki into a
   series of QUIPs.

- There was a question whether community guidelines could be described in a
   QUIP. The answer is a resounding yes.

- The QUIP lifecycle was discussed. The following two items were explored:

   1. Superseding QUIPs. These are QUIPs that both change some mechanism
      described in an earlier QUIP and change the content of that QUIP
      substantially. For small changes existing QUIPs can be updated.

   2. Retroactive QUIPs are possible. That is to say, QUIPs can be written
      to describe a change that occured in the past. For instance, an
      Implementation Track QUIP can be written after something has been added.

Development mailing list

Development mailing list

Reply via email to