Re: GDM API Change Request


I think it'd be nice to come up with infrastructure that you talk
about for marking certain modules or portions of modules as being
subject to API/ABI freeze (or parts of it such as not allowing changes
while allowing additions at any time).  But it's really not something
that we have at this time, so those modules that do make more
guarantees than what is required of the release set (e.g. how gtk+
required documentation for API even before we recently added that
rule, gstreamer requiring testcases for plugins, libwnck not changing
API/ABI after freeze) are up to the maintainers to police.

Currently the GDM "README" defines the configuration file as being
Stable, and I do try to police this by keeping the configuration
from breaking, and by not accepting API changes after the API freeze
date.  So, I think, this "maintainer policing" is currently being done
with GDM as with the other modules you mention.

What additional infrastructure would be required to allow API such
as GDM configuration to be covered by the API freeze?

I think this would require expanding the definition of the API freeze
so that non-platform interfaces could be included, expanding the
process a bit to explain how non-platform library interfaces go
about proposing their inclusion, and some additional work required
by the release team reviewing API change requests as they happen.

Expanding the API freeze like this would mean that it would no longer be
possible to just say "GNOME Stable interfaces is the same as Platform
library interfaces", so it would probably be necessary for the release
team to maintain an enumerated list of what specific interfaces outside
of the Platform libraries are covered by the API freeze.

It doesn't seem like it would require too much extra infrastructure
to do this.  But this would be a benefit to GNOME users because it would
help ensure extra attention is given to important interfaces.

Technically, this isn't all that different from the requirements
imposed by the release set as we have to rely heavily on maintainers
to do the checking for us--we've missed things lots of times when
maintainers haven't been watching for us, including hard code freeze
I would really like there to be an easier way for us to detect freeze
breakages (like the string people have), and also even help provide
oversight in extra cases where it is wanted such as in your case, I'm
just not sure how to do so at this time.  Anyone else have any great
ideas (or code or infrastructure) for this?  Maybe federico or J5

Perhaps it would be a good requirement if a module must check its ABI
when you run "make check" for it to be considered a Stable interface,
much like glib and GTK+ currently do.  It might not be reasonable to
require this of modules that are already a part of the Platform but
do not support "make check" in this way, but it would seem to be a
reasonable requirement for any new additions that might be proposed.
I think this would help to detect and prevent freeze breakages.

GDM doesn't currently have this sort of "make check" verification, but
it would be good to add.  If the process recommended it, that would
certainly give me more motivation to add such checking.


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]