Re: experimental proposal

On Thu, Nov 13, 2003 at 03:18:37PM +0100, Juliusz Chroboczek wrote:
| SL> Consider the OpenGL model, where loads of extension exists, and from
| SL> time to time the ARB does pull in some of the extensions to become a
| SL> standard part of the OpenGL spec, and bump the OpenGL minor version.
| 
| Why is this better than defining a profile ?  (A set of extensions.)

It depends on the policies you choose for defining and supporting
profiles, and how the extensions are accessed.

In the OpenGL world, it works roughly like this:

	Any licensee or group of licensees can define a set of
	extensions.   The ARB (Architecture Review Board, the OpenGL
	standards committee) doesn't have to be involved.  The functions
	and enumerants required to access the extensions are given
	special names to highlight that they're not part of the core
	standard.  To use them, an application has to make several
	queries to determine if the extensions are available and to
	fetch pointers to the extension functions.

	The ARB can define extensions as well.

	When there's general agreement that a set of extensions is
	stable and useful, the ARB can vote to make them "ARB"-class
	extensions.  This signals users that the functionality is likely
	to make it into the core standard in the future.  But no one is
	required to support any particular extension.  The function and
	enumerant names are changed accordingly, and some minor tweaks
	may be made to fix problems that arose in the earlier stages.
	Apps still need to query before using the extensions.

	When the ARB agrees that a set of extensions is important to the
	viability of the standard, then it "promotes" those extensions
	into the core standard.  This requires a special supermajority
	vote.  The names of the extension functions, enumerants, etc.
	are changed to reflect the new status, and the revision number
	is incremented.  Everyone who supports the latest version of
	OpenGL is required to support the functionality, so knowing the
	current revision number is enough to tell you what functionality
	is supported.

So the short answer is that there are stronger guarantees about
stability and support for functionality that makes it into the core, as
opposed to functionality that's available through extensions.

It doesn't have to be this way; you could manage the same thing with
profiles.  But you do have to reach and publish a general agreement
about whether all implementors are required to support a profile, what
assumptions the apps can make about support for each extension, etc.

Allen