Hi all,
(TL;DR: Is [0] a good idea?)
For a while now, I've been thinking about the issue of open design process,
and how we can take the design discussion forward (Dominic sent me this
excellent post[1] on the subject a while back - thanks!). I'd like to
illustrate the current problems and a possible solution.
The issues
···
----------Currently we have 3 main issues with our design process:
- Closed discussion
- Fragmented discussion
- Lack of review of design
Let me take these one-by-one. Firstly, closed discussion - of the people we
might call “core devs”, many work together in the same offices. That’s not
an
inherently bad thing, but it does lead to hallway-track discussion. One
example would be the recent surge of smart-proxy features, for example (I’ll
stress that I’m not attacking anyone here - these were good additions, it’s
simply that the way in which they arrived caused some friction).
I think we should be taking this to the next level by moving the design
discussion out into the dev community wherever possible. This is something
we’re
already getting better at, but it’s held back by the other two points (e.g.
I
frequently hear the comment - why take a design to the community if no-one
reviews it there?)
Second, fragmented discussion - we have no official place to discuss design.
Some people like to use tracker issues in Redmine. Others prefer to prepare
example code as a GitHub PR. Still others like to discuss on the mailing
list.
None of these are used coherently, and none really provide an easy way to
see,
historically, why a feature was implemented in the way it was, with all
the
discussion about pitfalls, possible alternatives, etc.
Third, lack of design reviews - this is a consequence of the fragmentation.
There’s no consistent place for interested people to look for current
proposals, and to see what designs are under consideration. Redmine and
GitHub
are too noisy with the day-to-day commits of bugfixes, small improvements,
etc,
and have too many repos to track. The mailing list is better, but it’s not a
great medium for historical data, and still gets a bit noisy at times,
leading
to design reviews getting missed.
The proposal
I’m seeing more and more projects implementing a RFC repo in their
source control. This is a very simple repo containing a README for
instructions, and a directory full of existing RFCs, and perhaps a table
listing current state of the open RFCs.
The process seems to be fairly simple - anyone can copy the template RFC to
a
new file, fill it out and submit a PR to the repo. From there a core dev
who is
familiar with that area can take on the role of mentor for the RFC, helping
it
to move forward, drive discussion, etc. Ultimately a decision will have to
be
taken about whether to accept an RFC, or reject it. It’s also acceptable to
discuss possible RFCs and implementations on the dev mailing list
beforehand.
The benefits here are:
- Open design discussion
- A single repo for interested-but-time-pressured community members to watch
- Clear historical data on why features were done a certain way
- Use cases, user stories, pitfalls can all be recorded for future info
- Some form of roadmap information for interested parties (not binding, but
at
least an indication of intent)
There is one minor downside, and that’s a slight overhead in reviewing these
RFCs - but I think the benefits to the project of a clear design system
outweighs this heavily. I expect most RFCs, initially at least, to be coming
from existing developers who will be quite capable of mentoring their own
RFCs, so that shouldn’t add much.
I’ve put together a sample RFC repo at https://github.com/GregSutcliffe/rfcs
please do take a look at the process in the README, the RFC template, and
I’ve
filled one RFC example out (the host/nic changes that went into 1.8, written
from my memory). This is based on the RFC repos from Rust[2] and EmberJS[3].
I’ll be happy to transfer ownership of this to theforeman/rfcs if the
proposal
is successful, or we can write a new one - either way, I’m sure there’ll be
changes.
I see this as being relevant for all the Foreman repos, although plugins
can,
of course, choose to opt out or set up their own RFC system. I’ve left
plugin
RFCs deliberately vague in the document for now - I can see plugins perhaps
adding RFCs to their own repo, or having a separate directory in the main
rfcs
repo. Thoughts welcome!
Thanks for reading to the end! Comments are most definitely encouraged
[0] https://github.com/GregSutcliffe/rfcs
[1] http://dtrace.org/blogs/bmc/2015/09/16/requests-for-discussion/
[2] https://github.com/rust-lang/rfcs/blob/master/README.md
[3] https://github.com/emberjs/rfcs/blob/master/README.md