A user account is required in order to edit this wiki, but we've had to disable public user registrations due to spam.

To request an account, ask an autoconfirmed user on IRC (such as one of these permanent autoconfirmed members).

Difference between revisions of "FAQ"

From WHATWG Wiki
Jump to: navigation, search
(move to https://github.com/whatwg/html/blob/master/FAQ.md)
(move to https://whatwg.org/faq)
Line 1: Line 1:
{{moved|the [https://github.com/whatwg/html/blob/master/FAQ.md HTML Standard FAQ]. What remains is in the process of being moved.}}
{{moved|the [https://whatwg.org/faq WHATWG FAQ] and the [https://github.com/whatwg/html/blob/master/FAQ.md HTML Standard FAQ]}}
== The WHATWG ==
=== What is the WHATWG? ===
The Web Hypertext Application Technology Working Group (WHATWG) is a growing community of people interested in evolving the Web. It focuses primarily on the development of HTML and APIs needed for Web applications.
The WHATWG was founded by individuals of Apple, the Mozilla Foundation, and Opera Software in 2004, after a W3C workshop. Apple, Mozilla and Opera were becoming increasingly concerned about the W3C’s direction with XHTML, lack of interest in HTML and apparent disregard for the needs of real-world authors. So, in response, these organisations set out with a mission to address these concerns and the Web Hypertext Application Technology Working Group was born.
=== How do you spell and pronounce WHATWG? ===
It is spelled WHATWG, all uppercase, no spaces. It has various pronunciations: what-wee-gee, what-wig, what-double-you-gee.
=== What is the WHATWG working on? ===
The WHATWG's main focus is Web standards, specifically:
* [https://html.spec.whatwg.org/multipage/ HTML], which also includes Web Workers, Web Storage, the Web Sockets API, Server-Sent Events, Microdata, and the 2D Canvas.
* [https://fetch.spec.whatwg.org/ Fetch], including the <code>fetch()</code> API
* [https://dom.spec.whatwg.org/ DOM], including DOM Events, DOM range, and mutation observers
* [https://url.spec.whatwg.org/ URLs], including an API for URLs
...and [https://spec.whatwg.org/ a number of other specs].
=== How can I get involved? ===
There are lots of ways you can get involved, take a look and see ''[[What you can do]]''!
[https://www.youtube.com/watch?v=hneN6aW-d9w This video from Domenic Denicola] is a good introduction to working with standards bodies.
=== Is participation free? ===
Yes, everyone can contribute. There are no memberships fees involved, it's an open process. You may easily [https://github.com/whatwg participate on GitHub] or subscribe to the [https://whatwg.org/mailing-list WHATWG mailing lists]. There are no meetings, since meetings prevent people with limited time or money from participating.
=== Is there a Code of Conduct? ===
Yes, see [https://whatwg.org/code-of-conduct Code of Conduct]. Please read it and respect it.
== The WHATWG Process ==
=== How does the WHATWG work? ===
People [https://github.com/whatwg collaborate on GitHub] or send email to [https://whatwg.org/mailing-list#specs the mailing list].
Each standard has one or more editors, who are responsible for dealing with feedback for that document. Those editors read all the feedback, and, taking it into account along with research, studies, and feedback from many other sources (blogs, forums, IRC, etc.) make language design decisions intended to address everyone's needs as well as possible while keeping the languages and APIs consistent.
This continues, with people sending more feedback, until nobody is able to convince the relevant editor to change the spec any more (e.g., because two people want opposite things, and the editor has considered all the information available and decided that one of the two proposals is the better one).
For new features, or significant changes to the processing models, the relevant editor will typically describe the intended changes in the relevant bug or mailing list thread to give people a chance to point out problems with it before the spec is updated. Implementors, especially, are urged to indicate on such threads whether they approve of the suggested changes or new feature, so that we can avoid the spec containing material which implementors are later found to disagree with.
This is not a consensus-based approach — there's no guarantee that everyone will be happy! There is also no voting. There is a small oversight committee (known historically as the "WHATWG members", from the name that the original [https://whatwg.org/charter charter] used, though that terminology is misleading) who have the authority to override or replace editors if they start making bad decisions, but so far that has never happened in over ten years. This committee has a private mailing list, but it receives very few messages, usually going years with no emails at all. Discussions on that list are summarized and described on the public list, to make sure everyone is kept up to date.
=== What happens with WHATWG mailing list/GitHub issue discussions? ===
On the WHATWG list and in WHATWG issues on GitHub, the burden is on the spec editors to evaluate the various positions that have been put forward in a discussion, and figure out which one is strongest (or find another position that strikes a better balance between all of them).
The purpose of debate at the WHATWG therefore isn't to convince everyone; it is to put forward the arguments that exist, so that the
relevant editor can make a well-informed decision. As a corollary: If some points are made, rebutted, and not further defended, then maybe the person making the arguments is hoping that the relevant editor will consider the rebuttals weak, or thinks that the argument they have presented is strong despite the rebuttals. If you find someone is not making good arguments, or is ignoring your arguments, your best bet is to stop responding. Repeating previously-stated arguments doesn't help, since the editors will see all the arguments when they look at the thread. Similarly, as soon as threads start being meta-threads about people's argumentation behaviour, we stop making any kind of
useful progress, since that isn't input that can help the decision-making process later.
=== How should tool developers, screen reader developers, browser vendors, search engine vendors, and other implementors interact with the WHATWG? ===
File an issue on the [https://spec.whatwg.org/ relevant standard] as indicated at the top of that standard. All feedback is supposed to be addressed in due course. You are also welcome to take a stab at addressing the problem yourself through a GitHub pull request.
'''If you want feedback to be dealt with faster than "eventually", e.g., because you are about to work on that feature and need the spec to be updated to take into account all previous feedback, let the editors know''' by either emailing them, or contacting them on [[IRC]]. Requests for priority feedback handling are handled confidentially if desired so other implementers won't know that you are working on that feature.
=== {{anchor|Is_there_a_process_for_removing_bad_idesa_from_the_spec.3F}}Is there a process for removing bad ideas from a specification? ===
There are several processes by which we trim weeds from the specifications.
* Occasionally, we go through every section and mark areas as being considered for removal. This happened early in 2008 with the data templates, repetition blocks, and DFN-element cross references, for example. If no feedback is received to give us strong reasons to keep such features, then they eventually are removed altogether.
* Anyone can ask for a feature to be removed; such feedback is considered like all other feedback and is based on the merits of the arguments put forward. If it's been a few years and there's no implementation, and no vendor is showing any interest in eventually implementing that section; or if it's a section that browsers previously implemented but where the momentum shows that browsers are actually removing support, then it is highly likely that the request to remove the section will be honoured. (Sometimes, a warning is first placed in the spec, as with [https://html.spec.whatwg.org/multipage/webappapis.html#dialogs-implemented-using-separate-documents showModalDialog()].)
* If browsers don't widely implement a feature, or if authors don't use a feature, or if the uses of the feature are inconsequential or fundamentally wrong or damaging, then, after due consideration, features will be removed.
Removing features is a critical part of spec development.
=== {{anchor|Is_there_a_process_for_adding_new_features_to_the_spec.3F}}Is there a process for adding new features to a specification? ===
The process is rather informal, but basically boils down to this:
# Forget about the particular solution you have in mind! Solution time is later!
# Write down a description of the underlying problem you're trying to solve. What are the use cases? A use case is an actual user wanting to do something. Then list requirements for each use case. For a good example of how to do this, see [http://lists.w3.org/Archives/Public/public-webapps/2012JulSep/0835.html this email].
# Get more people involved. Open a new issue in [https://github.com/whatwg/html/issues whatwg/html on GitHub] that describes the use cases and their requirements. Ask fellow Web developers about their opinions (but remind them of step 1 above). Adjust the list of use cases and requirements as appropriate. Say which use cases are important and which are just nice to have.
# Optionally, your work is done at this point. If you have done a good job of the above steps and convinced other people that your use case is an important one to solve, they can do the remaining steps. (On the flip side, if nobody else cares about the use case, chances are solutions for it will not succeed despite being awesome.)
# Research existing solutions. Come up with new solutions. Try to keep the solutions as simple as possible, maybe only addressing the important use cases and leaving the nice to have use cases for later (when there's implementation experience). Send this list of solutions, old and new, as a comment on the feature's issue. Ask browser vendors for feedback. Maybe some particular solutions don't fit with the browser's architecture, optimizations, etc., and just are not going to be implemented no matter how much you like them. Strike those solutions and don't grieve about the loss!
# Evaluate how well each of the remaining solutions address each use case and how well they meet the requirements. This step should show which solution is the technically best fit (might turn out to be someone else's solution).
# Ask the spec's editor to put that solution in the spec, or create a pull request on GitHub yourself. Possibly your text won't be taken verbatim but will be written in a style that is more suitable for implementors or better hooks in to the rest of the spec, etc.
# Ask browser vendors to implement the newly specified solution, even if it's just an experimental implementation. This implementation experience usually means that new problems are found with the solution that need to be addressed, or that a different solution is actually better.
# Write a test suite for the feature to see if the implementations match the spec. This usually highlights bugs in the implementations and also bugs in the spec.
# Participate in subsequent design discussions. When there are two or more mature implementations, it may be time to extend the feature to address the nice to have use cases (but this whole process should be repeated even for such extensions).
If the idea survives the above design process, the spec will be eventually updated to reflect the new design. Implementations will then be updated to reflect the new design (if they aren't, that indicates the new design is not good, and it will be reworked or removed). The spec will be updated to fix the many problems discovered by authors and implementors, over a period of several years, as more authors and implementors are exposed to the design. Eventually, a number of provably interoperable implementations are deployed. At this point development of the feature is somewhat frozen.
Writing a comprehensive test suite is also an important step, which can even start before implementations start being written to the spec. Cross-browser tests for HTML are maintained in [https://github.com/w3c/web-platform-tests/tree/master/html w3c/web-platform-tests/html on GitHub].
=== Should I send new proposed text when I have a suggestion? ===
Please do not suggest new text, instead, say what is wrong with the current text. Just proposing new text makes it impossible for the editor to determine if the problem is endemic (requiring more changes than you realise), or whether what the editor thinks of as mistakes in the new proposed text are intentional or not (and should be fixed or not), or whether stylistic differences are intentional or not, etc.
=== What does "Living Standard" mean? ===
The WHATWG specifications are described as Living Standards. This means that they are standards that are continuously updated as they receive feedback, either from Web designers, browser vendors, tool vendors, or indeed any other interested party. It also means that new features get added to them over time, at a rate intended to keep the specifications a little ahead of the implementations but not so far ahead that the implementations give up.
Despite the continuous maintenance, or maybe we should say ''as part'' of the continuing maintenance, a significant effort is placed on getting the specifications and the implementations to converge — the parts of the specification that are mature and stable are not changed willy nilly. Maintenance means that the days where the specifications are brought down from the mountain and remain forever locked, even if it turns out that all the browsers do something else, or even if it turns out that the specification left some detail out and the browsers all disagree on how to implement it, are gone. Instead, we now make sure to update the specifications to be detailed enough that all the implementations (not just browsers, of course) can do the same thing. Instead of ignoring what the browsers do, we fix the spec to match what the browsers do. Instead of leaving the specification ambiguous, we fix the the specification to define how things work.
=== Does that mean the specifications can change at any time? ===
The specifications do not change arbitrarily: we are extremely careful! As parts of a specification mature, and implementations ship, the spec cannot be changed in backwards-incompatible ways (because the implementors would never agree to break compatibility unless for security reasons). The specifications are never complete, since the Web is continuously evolving. The last time HTML was described as "complete" was after HTML4, when development stopped for several years, leading to stagnation. (If the Web is replaced by something better and dies, the HTML spec will die with it.)
For references to stable copies of the specifications, some WHATWG specifications follows a process by which each change to the specification (embodied in a commit) triggers the publication of a frozen snapshot of the said specification.
These snapshots are published as historical references. The WHATWG intends to keep these frozen snapshots available at their published URL permanently.
=== What's the patent story for WHATWG standards? ===
The WHATWG operates as a W3C Community Group and thus uses the W3C Community Group patent policies.
So far we have published one FSA with [http://www.w3.org/community/whatwg/spec/82/commitments patent commitments] from Google, Mozilla, and others covering the URL standard.
[https://blog.whatwg.org/make-patent-commitments You can make patent commitments too!]
Some of our specifications have also been forked and republished by the W3C with patent commitments from certain companies.
=== What is the process for translating WHATWG standards? ===
Many WHATWG standards have been translated into other languages by the WHATWG community. This is great, and highly encouraged!
In general, if you translate a WHATWG Standard, please communicate with the maintainers of the standard (e.g. via a GitHub issue) letting them know about your work. In general this will lead to adding a link to your translation to the top of the original specification, to allow interested readers to view it. You can see examples of this in many WHATWG standards, e.g. https://streams.spec.whatwg.org/.
Such translations are not normative (i.e., implementations should be sure to consult the original). Due to the nature of living standards, which can change often, it's possible for translations to become out of date compared to the original standard. If the translation shows signs of no longer being maintained, or has other quality problems, community members are encouraged to provide feedback to the maintainers of the standard, so that any links to the translation can be removed in order to avoid confusing readers.
Note that WHATWG specifications are always licensed under liberal licenses that allow the creation of derivative works like translations.
== Mailing List ==
== Mailing List ==

Revision as of 13:25, 11 August 2017

This page has moved to the WHATWG FAQ and the HTML Standard FAQ

Mailing List


Please note that content-free agreement (such as +1s) have no effect on the WHATWG list and are therefore discouraged. Editors of specs discussed in the WHATWG only consider the quality of the arguments presented, and not the volume of agreement.

You should therefore only post to the list if you have a substantive new point to make, for example if you have seen a flaw in an argument presented so far, or have a new idea to contribute, or have some information that has not yet been brought to the table.

Making Outlook quote email messages properly

If you use Outlook or Outlook Express, you can use either Outlook-QuoteFix or OE-QuoteFix. These plugins fix several of Outlook's problems with sending properly formatted emails.

Should I top-post or reply inline?

Please reply inline or make the reply self-contained, and trim extraneous quotes from previous emails in your replies.

Basically, please remove anything after the last line you have written, so that people don't have to scroll down to find out what else you wrote, and make sure that your email makes sense on its own, as it will probably be read out of context years later.

That is, you should reply like this:

Ian wrote:
> What do you want? 

I want cats!

> When do you want it?


You should definitely not reply like this (because this requires people to read your email backwards):


Ian wrote:
> Is this a good example of how to post emails?

You should also not reply like this (because this leaves people to wonder if there is any text lower down that you have written):

This is a bad way to write email.

Ian wrote:
> Is this a good way to write email?
> Lorem ipsum foo bar baz.
> Unrelated other bits that aren't replied to.
> Yet more text

You should also not reply like this (with no context at all), because the reader will not know what you are referring to:

No, I think that's a bad idea. It wouldn't be good for the readers, for instance.

Quote enough original text or provide an introduction yourself.