Great Wall of DEP

[Michael Manfre]

From DEP 001:

"Once you've written a DEP and submitted the pull request, post a message about it to the django-developers mailing list. At that point, Django developers will make sure it's technically feasible, not spam, etc., assign it a DEP number and commit it to the repository as "Active." This doesn't mean the feature will be implemented; it merely means the proposal is officially a DEP."

There are two DEP pull requests that seem to have sat for two weeks waiting to be merged in as "Active" with numbers assigned. They are both clearly not spam and are technically feasible. I'm curious why they have not been moved along in the process.

I think the DEP concept has a lot of potential, but it's already starting to have the feel of a bureaucratic barrier that will probably discourage people from contributing.

Regards,

Michael Manfre

[James Bennett]

It's worth noting that during that two-week time period the core team has been a bit preoccupied with doing a security release and followup bugfix release :)

If no-one else has looked at and commented on those two DEPs within the next day or two, I will have time to do so, and will do so (and feel free to poke me if I haven't).

[Carl van Tonder]

Hi all,

> If no-one else has looked at and commented on those two DEPs within
> the next day or two, I will have time to do so, and will do so (and
> feel free to poke me if I haven't).

Just noticed this message, and the DEP PRs are still open a week later.

Can someone shuffle this along, please?

C

[Florian Apolloner]

Hi,

On Thursday, May 8, 2014 2:13:52 PM UTC+2, Carl wrote:

Just noticed this message, and the DEP PRs are still open a week later.  

Can someone shuffle this along, please?

We are in the final stages of 1.7, I personally would rather focus on that first.

[Łukasz Rekucki]

Hi folks,

Discussing DEPs on Github inside Pull Request comments seems like a
really bad idea, because it excludes a whole bunch of people that are
subscribed to this list (I always thought this was the sole purpose of
this list).

The best thing about PEPs is that they always get posted to python-dev
in *full text* and the discussion happens there. The email thread then
gets recorded inside the PEP so that 10 years later you can easily
read the whole discussion. Github comments don't have this feature,
really.

Throwing in my 2 cents,
Łukasz

> --
> You received this message because you are subscribed to the Google Groups
> "Django developers" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to django-develop...@googlegroups.com.
> To post to this group, send email to django-d...@googlegroups.com.
> Visit this group at http://groups.google.com/group/django-developers.
> To view this discussion on the web visit
> https://groups.google.com/d/msgid/django-developers/1d33bd04-a509-4c34-8bfe-2e4df31a3add%40googlegroups.com.
>
> For more options, visit https://groups.google.com/d/optout.



--
Łukasz Rekucki

[Thomas Leo]

Their is some value in commenting directly on a pull-request, for example you can comment on specific lines of code, and the interface is very friendly. 

With that being said, having a link to related google group pages (or another mail-archive site) in the pull-request message would be a great convention to get into.

[Cal Leeming [Simplicity Media Ltd]]

I have to agree that the decentralized nature of the mailing list would probably stand the test of time a bit better, plus the ability to in-line reply makes larger discussions easier on the eyes.

In reference to OPs original comments;
Enhancement proposals are a great idea, but ultimately they will suffer with the exact same problem as other PRs, waiting on core devs. Unless a core dev has a particular interest in that specific EP, then you're pretty much waiting on a core dev to have "spare time" where they haven't got anything else they'd rather be doing, as well as not being paid to do it. That's not a dig at the core devs in any way, it's just a well established behaviour of open source contributors. 

Other projects have got around this issue by getting sponsorship and having an experienced full time person(s) keeping on top of things, leaving the rest of the core team to focus on getting the code done. Another alternative is to set a threshold on proposals, meaning that it has to be either accepted or rejected after a certain number of days since the last edit (by means of a vote count or key person decision).  Really it comes down to two things.. keeping it simple enough for users to contribute easily, whilst enforcing a certain level of quality assurance, which can only be done by a trusted (and hopefully experienced) person. Personally I don't think Django has found the sweet spot for this yet.

Cal

To view this discussion on the web visit https://groups.google.com/d/msgid/django-developers/CAEZs-EL_x6PB9jYe_OWDfQUYvV%3DH5jA52EBCeFM50xcY%2BLRMTA%40mail.gmail.com.

[Michael Manfre]

It's been almost a month and the next step in the process for the first two DEPs is to merge the PRs and assign numbers to make them "active". The discussion for each of them can take place over the coming months. I hate to sound so cynical, but if none of the 30+ current core developers are able to find 10-15 minutes of available time over the span of a month to merge and assign a number to a DEP, I think it's safe to say that the DEP process is not going to work in its current form.

I realize that most of the core developers are not paid to work on Django, are very busy with polishing 1.7, or busy with non-Django things, but there are clearly some questions that need to be discussed (some probably just among the core devs) to figure out how to improve the current situation and avoid repeating it. The current situation is not really that bad, but I would be surprised if I was the only person that thinks any feature proposal that would require a DEP is probably not worth doing at this point in time. 

This discussion is more involved than activating a DEP and should probably be postponed until 1.7 is out of the way.

1) The DEP process was quickly brainstormed and put in to practice. Did this move too quickly? Should this sort of process change be more conscientious of the Django release cycle and not take place after the feature freeze?

2) The core devs know their "territory" in the code, but did enough of them agree to take on /django/deps before it was put in to practice?

3) Django lists over 30 current core developers. Does Django have enough *active* core developers for its current user base and existing processes? Is there a process in place for moving an inactive core developer from "Current Developers" to "Developers Emeritus"?

Regards,

Michael Manfre

PS The DEP experience so far has been reminding me of a few specific examples of "government bureaucracy" that I've banged my head against many times over the years. My motivation for pressing the DEP issue is for the sake of everyone's sanity by avoiding it devolving to that level of frustration.

--

You received this message because you are subscribed to the Google Groups "Django developers" group.
To unsubscribe from this group and stop receiving emails from it, send an email to django-develop...@googlegroups.com.
To post to this group, send email to django-d...@googlegroups.com.
Visit this group at http://groups.google.com/group/django-developers.

[Aymeric Augustin]

On 8 mai 2014, at 16:26, Michael Manfre <mma...@gmail.com> wrote:

> It's been almost a month and the next step in the process for the first two DEPs is to merge the PRs and assign numbers to make them "active". The discussion for each of them can take place over the coming months. I hate to sound so cynical, but if none of the 30+ current core developers are able to find 10-15 minutes of available time over the span of a month to merge and assign a number to a DEP, I think it's safe to say that the DEP process is not going to work in its current form.

If you consider core devs who made a non-trivial commit in the last three months, the baseline isn’t 30+ people, it’s just a handful. If you further reduce this set to the people who were at PyCon when the idea of DEPs was discussed, you probably arrive at zero. Core devs who aren’t active anymore often get excited at conferences but that doesn’t give them free time to execute afterwards.

Besides the 10-15 minutes could easily turn into becoming the contact person for these PEPs :-)

> 1) The DEP process was quickly brainstormed and put in to practice. Did this move too quickly? Should this sort of process change be more conscientious of the Django release cycle and not take place after the feature freeze?

I think we’re mostly missing someone to bootstrap the process. Since no one in the core team appears to be interested, if someone else wants to take the matter into his/her own hands, I’m happy to advocate for partial committer status (https://docs.djangoproject.com/en/dev/internals/contributing/committing-code/#commit-access). Contact me privately if you wish to discuss this.

> 2) The core devs know their "territory" in the code, but did enough of them agree to take on /django/deps before it was put in to practice?

Undoubtedly.

> 3) Django lists over 30 current core developers. Does Django have enough *active* core developers for its current user base and existing processes? Is there a process in place for moving an inactive core developer from "Current Developers" to "Developers Emeritus”?

Classifying core devs wouldn’t achieve much. Removing core devs has no practical benefit, on the contrary. Our availability comes and goes. That’s life! However, we all know that there’s no such thing as too many core devs and that we would benefit from a larger core team.

--
Aymeric.

[Jannis Leidel]

Michael,

First, I would appreciate if you'd give feedback in a less passive
aggressive style. I hope it's just a matter of language barrier but your
mail came over as far too demanding for just a "curious" question.

As far as I can see there has been activity in the pull requests
(including from core devs) but simply no one spent the time doing the
necessary steps to mark a DEP as active. Next to personal reasons like
recuperating from PyCon I think the fact that it's a new effort means
also some hiccups and awkward waiting. Please bare with us and in doubt
lean toward the side where you see us as humans and not machines
implementing a process.

Thanks!
Jannis

> --
> You received this message because you are subscribed to the Google
> Groups "Django developers" group.
> To unsubscribe from this group and stop receiving emails from it, send
> an email to django-develop...@googlegroups.com

> <mailto:django-develop...@googlegroups.com>.

> To post to this group, send email to django-d...@googlegroups.com

> <mailto:django-d...@googlegroups.com>.

> Visit this group at http://groups.google.com/group/django-developers.
> To view this discussion on the web visit

> https://groups.google.com/d/msgid/django-developers/CAGdCwBttQ2c_3zraenR4brpLxACzXQS6EQ56Ns65mgomKRDTKQ%40mail.gmail.com
> <https://groups.google.com/d/msgid/django-developers/CAGdCwBttQ2c_3zraenR4brpLxACzXQS6EQ56Ns65mgomKRDTKQ%40mail.gmail.com?utm_medium=email&utm_source=footer>.

[Jannis Leidel]

Aymeric,

On 08.05.14 19:23, Aymeric Augustin wrote:
> On 8 mai 2014, at 16:26, Michael Manfre <mma...@gmail.com> wrote:
>
>> It's been almost a month and the next step in the process for the first two DEPs is to merge the PRs and assign numbers to make them "active". The discussion for each of them can take place over the coming months. I hate to sound so cynical, but if none of the 30+ current core developers are able to find 10-15 minutes of available time over the span of a month to merge and assign a number to a DEP, I think it's safe to say that the DEP process is not going to work in its current form.
>
> If you consider core devs who made a non-trivial commit in the last three months, the baseline isn't 30+ people, it's just a handful. If you further reduce this set to the people who were at PyCon when the idea of DEPs was discussed, you probably arrive at zero. Core devs who aren't active anymore often get excited at conferences but that doesn't give them free time to execute afterwards.

DEPs have been discussed for years and only recently been picked up
again to handle new feature proposals and bigger changes in a more
favorable format to the massive amount of mailing list threads that
we've used up until now. I thought you'd be the first to welcome such a
change :)

> Besides the 10-15 minutes could easily turn into becoming the contact person for these PEPs :-)
>
>> 1) The DEP process was quickly brainstormed and put in to practice. Did this move too quickly? Should this sort of process change be more conscientious of the Django release cycle and not take place after the feature freeze?
>
> I think we're mostly missing someone to bootstrap the process. Since no one in the core team appears to be interested, if someone else wants to take the matter into his/her own hands, I'm happy to advocate for partial committer status (https://docs.djangoproject.com/en/dev/internals/contributing/committing-code/#commit-access). Contact me privately if you wish to discuss this.

It wasn't quickly brainstormed, in fact it goes way back:
https://groups.google.com/d/msg/django-developers/QguOVc3ymmQ/c1D0aFf3-w8J

As I wrote to Micheal in a different mail already, at least Adrian and
me were interested in the process to the fact that we sat down and did
it. We also didn't decide that in a corner alone but during the Django
core lunch with a lot of core devs attending, I would guess with around
20 core devs. I'm sorry that you see the little activity of a month as
an indication of missing interest. Adrian offered to be the contact
person but left it open to the rest of the core developers to mark a DEP
as active. Since at least two core devs have given feedback in the pull
requests it's up to them to make a DEP "active", after it has been
written I should note. "active" means "implementation" AFAIU.

>> 2) The core devs know their "territory" in the code, but did enough of them agree to take on /django/deps before it was put in to practice?
>
> Undoubtedly.

Yes, around 20 (does anyone remember the exact count?) during the PyCon
core dev lunch.

>> 3) Django lists over 30 current core developers. Does Django have enough *active* core developers for its current user base and existing processes? Is there a process in place for moving an inactive core developer from "Current Developers" to "Developers Emeritus"?
>
>
> Classifying core devs wouldn't achieve much. Removing core devs has no practical benefit, on the contrary. Our availability comes and goes. That's life! However, we all know that there's no such thing as too many core devs and that we would benefit from a larger core team.
>

I'm not sure how this is connected to the DEPs, it seems to me as if
Michael is trying to force a discussion on core committer policy without
actual offering proposal that we can weigh. I would like to ask to open
a separate thread about this.

Thanks,
Jannis

[Michael Manfre]

Hi Jannis,

On Fri, May 9, 2014 at 3:11 AM, Jannis Leidel <lei...@gmail.com> wrote:

Michael,

First, I would appreciate if you'd give feedback in a less passive
aggressive style. I hope it's just a matter of language barrier but your
mail came over as far too demanding for just a "curious" question.

I apologize if my email came across as passive aggressive. Probably an artifact of the dozens of revisions I made while composing it. My usual nature is overly direct and I put a great deal of time and effort revising my emails to make sure that my directness cannot be interpreted as aggressive. I will continue to extensively revise my emails to the list before clicking send because I think it is better to be interpreted as passive aggressive instead of outright aggressive. When directing emails to you, I'll try to be more direct so please assume that anything I write is not meant to be offensive or an attack.

If you or anyone else thinks I'm being too direct or not direct enough, feel free to call me out on it or ask me to clarify anything I've rewritten and I'd be happy to do so.

 

but simply no one spent the time doing the necessary steps to mark a DEP as active.

That is the entire point of my various DEP related emails. The process is new and not well understood, especially by those of us in the community that are left wondering and waiting.

 

Next to personal reasons like recuperating from PyCon I think the fact that it's a new effort means
also some hiccups and awkward waiting. Please bare with us and in doubt
lean toward the side where you see us as humans and not machines
implementing a process.

My biggest gripe about the process so far is the lack of communication. Just like the devs, the community members are humans and largely comprised of volunteers. If we were machines, there would be no complaints as we block waiting for an unknown amount of time for something to happen. If I hadn't written my emails, how many weeks/months do you think it would have been before the next steps took place or anything was communicated about what the community can expect? There will always be a conference or personal reason. I understand that and our personal lives are clearly more important than Django. This is also the reason why I asked questions about if there are enough active core developers. This is a new process that demands more time of the core team.

Regards,

Michael Manfre

[Trey Hunner]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Adding my two cents below regarding DEPs.

On 05/08/2014 05:49 AM, Łukasz Rekucki wrote:
> Discussing DEPs on Github inside Pull Request comments seems like a
> really bad idea, because it excludes a whole bunch of people that are
> subscribed to this list (I always thought this was the sole purpose of
> this list).

I just submitted a DEP and I actually preferred the pull request method
over an email thread.

I like the pull request method because I am more likely to open a pull
request or comment on a pull request than to send an email to this
mailing list. Sending an email seems like a big deal because it's set
in stone and making a correction to it requires sending at least one
follow up email.

I also like that a pull request is available for reading and feedback
without being buried by mailing list threads. My DEP hasn't been
updated in 4 days because I've been busy, but others can still easily
find it by scanning the pull requests page on the DEPs repository.

> The best thing about PEPs is that they always get posted to python-dev
> in *full text* and the discussion happens there. The email thread then
> gets recorded inside the PEP so that 10 years later you can easily
> read the whole discussion. Github comments don't have this feature,
> really.

Maybe this system should be setup as a two stage process:

1. Create a DEP and make small revisions on the pull request based on
feedback and new insights

2. Post to the mailing list after milestone changes, possibly copying
the full DEP text or by just referencing the URL and overview of the DEP

That way both the mailing list and deps repository watchers would stay
informed, but the mailing list would only hear about larger changes.

- --
Trey Hunner
http://treyhunner.com
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1
Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/

iQEcBAEBAgAGBQJTbQWvAAoJEOpnfp/NreonUtIH/02Cqj8FTK+OD4wd3QZrCIgb
llvz3pgUmCAurZ/zJAbK9AykA5JwtlCRampGrU/JzxcKB0LmstCVrUEE5WHavup9
gWfqCtoF/QBnY3wqLWnkBi8/fposfoyhLCLzGx9K0SP/Hsrr+N4ZnvaTprVWQTtQ
HYj5SQx8be53KAFF7nbgCl06Rg8Pah9wxMAxbt/wx1VeD9MIIyDsX0Iiv9Sms5Ru
ZPpefsmjXbBjWWGizZ5kYLH/092GhrFM3pG1udCDVlcgBa5s0pDI3ch+TfL6eLuQ
XsxVKUHP+n67f72EvNxpFRwZvwNqYXivuxojf8PYeivlv014v9cbXMbaWHhm5hA=
=2QVT
-----END PGP SIGNATURE-----

[Trey Hunner]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

On 04/29/2014 08:58 PM, Michael Manfre wrote:
> From DEP 001:
>
> "Once you've written a DEP and submitted the pull request, post a
> message about it to the django-developers mailing list. At that point,
> Django developers will make sure it's technically feasible, not spam,
> etc., assign it a DEP number and commit it to the repository as
> "Active." This doesn't mean the feature will be implemented; it merely
> means the proposal is officially a DEP."
>
> There are two DEP pull requests that seem to have sat for two weeks
> waiting to be merged in as "Active" with numbers assigned. They are both
> clearly not spam and are technically feasible. I'm curious why they have
> not been moved along in the process.

I'm not convinced that the open pull requests are a problem. I don't
see any comments on any of the pull requests stating that a DEP seems
ready to be merged.

Maybe the problem here is an unclear/absent process for merging? I
would think merging should purposely be delayed because once the DEP is
merged it is no longer active unless a new pull request is made to
modify it.

The current process assigns a number only after the pull request has
been merged. I'm not sure those two steps should be related.
Assignment of a DEP number could happen *before* the pull request is merged.

How does the PEP process handle this? Are threads ever declared "done"
and if so is that finalization separate from the assignment of a PEP number?

- --
Trey Hunner
http://treyhunner.com
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1
Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/

iQEcBAEBAgAGBQJTbQZ7AAoJEOpnfp/NreonXkwH/jRsO7gcc6HX5b1kdZmGpoOO
92sX9gtjYiX8NwkEwjQaTAOGGCLhxZXnvwN1IMdjMR4ogE7rs9vg0Uc4hML0UYYL
1zijA8sxJF4ZeuIgAk/hFIRfOHVfAkJUaSdkAtVijH3VPX8wvd/NqAr5zlGn/e9b
0DsvA5OczZea6VvqllZfqQVJ6KJA7lfDWjf6PRKGnWl+Daxi9ygkhUV7E0pyt/qZ
wqV6jSBqvNkoT/QPdpXnXvKd8ZkG8KtOw+VYuJJb3cf2guUXdwy9tHX6Lmlm2IMR
AhCnRHJPAqqVRDhswocFJCJ1tIUjObnb2rVsxgwh11PrcNhLz7z/MS7rN3M+lcQ=
=TmrW
-----END PGP SIGNATURE-----

[Jorge C. Leitão]

In my opinion, it may be too soon to make an evaluation of DEP.

Most importantly, it has to be put in context to what happened/is
happening:
- there was a security release
- there was a fix to the security release
- there is a version of Django to be released with *considerable* new
features, that naturally have release blockers to be fixed.

I believe this waiting time has nothing to do with being a DEP, a PEP, or a
simple feature request; it is just that DEP was formally announced before the start
of the new cycle - 1.8 - to be used on it, and the current priority is to
close the current cycle, which is demanding a considerable commitment,
specially from the core devs, as some already expressed here.

It may be worth performing an evaluation of the DEP procedure;

however, my suggestion is to postpone it to after the
release of 1.8, since at that time we have a full release cycle where DEP
was used and tested. In my opinion, this will allow a more pragmatic evaluation

that matches more closely the expectations and ideas behind the DEP.

Regards,
Jorge