890 karma · joined February 12, 2010
[ my public key: https://keybase.io/zaphoyd; my proof: https://keybase.io/zaphoyd/sigs/7AwrXTTBUkPTzTgg12WEOisWDxg1xGo8hftKyhNPImI ]
EDIT: for friendliness.
T-Mobile's IPv6 service is an IPv6-only service that uses NAT64 and DNS64 in the network to connect IPv6 mobile users with IPv4 content. We believe that the majority of the bandwidth consumed by IPv6 subscribers will be native end-to-end IPv6 without any translation required by the end of 2012 as major content providers like Google, Yahoo, Facebook, Microsoft, and many others have demonstrated during World IPv6 Day
Opportunities for growth 4% world share of Firefox 3.6 users -> webm 26% world share of IE 6-8 users -> up for grabs? iOS/Mac growth -> mostly h.264 Android growth -> both 23% loss for h.264 if/when chrome drops support
Why webm still doesn't matter yet: demographics and fallback availability. The devices that exclusively support h.264 are more valuable users for video (mobile, console, set top box) and have no fallbacks. Most of the webm support base (desktop Firefox, chrome) can fall back to flash h.264 player. Half of the webm support base presently supports h.264 natively anyways (chrome, android)
Other notes: - webm support can be trivially added to desktop safari and IE9+ by mildly tech savvy users. - h.264 tools and encoders are better and hardware encode/decode support is far better - the openness and cheapness of webm will probably improve its tool and hardware support in the long run especially if/as uncertainty about its patent status declines.
Even in cases where your WebSocket implementation exposes incomplete message fragments, the boundaries of the message are still clearly and accurately preserved.
I do see your point on the "endless streaming" section of the RFC. Stating that "(section 5.4) The primary purpose of fragmentation is to allow sending a message that is of unknown size when the message is started without having to buffer that message." implies that a web socket implementation should support this sort of operation. Indeed, if you want to support sending messages of unknown size you must expose an interface more complicated than the default message based one.
That said, a message only implementation that does not allow sending unknown sized messages is 100% compliant with both the spec and receiving such messages. The RFC probably could have made this fact more clear. I believe that endless streaming mode will not be a common use case and have not implemented it in my generic WebSocket library. I do believe, however, that fragmentation of messages provides important benefits even without unknown size sends. Once you have message fragmentation there is no additional protocol cost to allow unknown size sends.
Time and time again it has been demonstrated that we are bad at choosing a maximum allowed value for all applications and all future considerations (see: ethernet frame sizes, IP address lengths, operating system address spaces, file system block sizes/counts, etc).
In some cases (many of those previously listed) there were hardware, cost, or technical concerns that led to nailing down a number in an RFC. For WebSocket there is no clear benefit to forever encoding a specific numeric maximum message size. It is a high enough level protocol that there is no technical or cost benefit to make message sizes limited by anything other than individual application needs.
As such, the WebSocket RFC leaves maximum message size implementation defined, and specifically says that an implementation SHOULD implement a reasonable maximum message size for its purpose. A chat application that knows it will only be moving small text messages can set its maximum message threshold small to improve buffer performance and catch invalid messages sooner. An application that finds a business case for sending a large file in one large message can set itself up accordingly. Generic WebSocket parsers should expose a method of setting the maximum message size the application wishes to receive.
I definitely agree that not requiring implementations to return their maximum message size along with the "Message too big" error will make some sorts of interoperability more difficult. However, it also prevents exposing implementation security details and simplifies the core spec (the author has already complained that the spec is too complicated already). It is relatively simple for an application to negotiate a maximum message size privately if necessary and the WebSocket extension mechanism allows a method for standardizing a way of doing so if this turns out to be a serious issue in the future.
There are two components to web sockets. The WebSocket API under development by the W3C/HTML5 groups (http://dev.w3.org/html5/websockets/) which defines the javascript/browser API and the WebSocket Protocol under development by the HyBi working group at the IETF (http://datatracker.ietf.org/wg/hybi/charter/) which defines the actual wire protocol.
The WebSocket API has been relatively stable for awhile, most of the changes recently have been hashing out how to handle binary messages in javascript.
The WebSocket wire protocol has been undergoing more substantial development in the past year and is presently in the Last Call phase of IETF standardization. The final wire protocol has not been fixed yet.
Protocol version numbers were added sometime last year and each version stands for which draft version of the protocol the user agent is implementing. Not all drafts change the wire protocol so some version numbers aren't used. The purpose of the version numbers was to help folks who were writing test implementations of websocket to keep track of which implementations should work together for interoperability testing.
The draft/version number primarily indicates that the client can only talk to servers that speak the same version. Clients typically support only one draft, servers often support multiple drafts. The current draft (http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketproto...) uses protocol version 13. FireFox 6 ships with a prefixed (MozWebSocket) websocket object that implements draft 7. FireFox 7 and 8 and Chrome 14 and 15 (beta and dev channels respectively) currently implement draft 8, though this may change before they are shipped. Safari 5.0.1+ and Chrome 7-13 implement draft 0, an obsolete version from 2010.
Draft 7,8, and 13 are nearly identical, a server supporting one will likely support all three. Draft 0 is significantly different. There is a list on wikipedia of the major websocket implementations and which protocol versions they presently support (http://en.wikipedia.org/wiki/Comparison_of_WebSocket_impleme...).
The OP appears to be using a simplified version of a pre-draft 0 that Pusher implemented. I am not actually sure why it is using websocket at all since it doesn't appear to actually use the browser as the source of the connection. It just happens to be using an early draft of the websocket protocol as it's message framing mechanism.
I suspect that tunneled traffic volumes will always be low enough not to significantly affect the bottom line, as anyone willing to maintain a manually configured tunnel will move to native IPv6 transit as soon as possible and higher volume production business needs will use native/load balancers/proxy servers instead of tunnels.
edit: it looks like Safari must run dns requests both as IPv4 and IPv6 and uses whichever returns first. Refreshing a few times found the IPv6 is ready message on ipv6.google
These probably aren't completely mainstream needs (is USB3 even a mainstream need though?) but they represent things that can only be done with traditional form factor PCs now. Why buy a Mac Pro when the only thing holding you back from a compact low power mini or laptop is some port you can only get a on PCI card?
host www.v6.facebook.com www.v6.facebook.com has IPv6 address 2620:0:1cfe:face:b00c::3