Google Code Blog

(I don't know why I keep wandering into this thread; I don't even like Dart, but here goes...)

We agree that the browser market of 1995 is not one we want to replicate, but the rest of this is revisionist to a fault. The development of the open web itself has consistently been a messy business. There's a reason that the single-champion model has been adopted by several groups, including TC39: it works really well, and a lot of good standards have come out of it, whether on purpose (many recent specs) or not (many of the features we can thank old IE for). Even when things have been going great, people try to use committee maneuvering to torpedo things, or patent claims come out of the blue and suddenly you're turning to a different champion for your touch events.

Pretending that we now have a one true way of developing the open web is silly, because it's not even a little true.

> The Canvas spec is a complete steaming pile of nonsense that again, has only been iteratively improved into a more useful state by the tireless efforts of the whatwg (and whoever was maintaining it before them, I don't remember). Canvas delivers miserable performance and a crippled, arbitrary feature set that was clearly designed for the specific purpose of solving whatever problems Apple had at the time. Compare Canvas with WebGL, if you like: WebGL was developed in the open, based on an established, proven API that had been used to solve problems for decades, and it is quickly gaining on Canvas…

I'd rather have Google say "in order for GAE to stay alive, we've had to raise pricing on our current metrics to X", I can understand that, I can justify that, I can compare it and decide how to deal with it/optimize for it, but instead we got, "based on user popular feedback we're radically changing the way we measure usage, then charging some significant multiplier to whatever everybody is already paying so that it no longer makes sense to operate on our platform and you can't even really compare it in such a way as to make sense of the change, then we'll systematically not address anybody who asks us about this in forums or via other communications but we're going to do all this in the most frustratingly passive aggressive way possible" [1][2] Can anybody really believe that popular feedback to Google was "we're not being gouged nearly enough, Google, charge us 2000% more!"

[1]http://googlecode.blogspot.com/2011/05/google-app-engine-new-version-and.html

"Over the last three years, we’ve collected great feedback from our customers and now believe that the biggest thing we can do to help our customers is to graduate App Engine from preview status. "

"Adding business features will help App Engine meet a broader set of needs and the new, more transparent pricing model will help customers better align their App Engine investment with their business goals."

[2]http://googleappengine.blogspot.com/2011/05/year-ahead-for-google-app-engine.html

"App Engine graduating from…

The idea is by no means new. localStorage is old. So is the AppCache specifications that actually allows an application to go 'offline'. Gmail did this as early as 2009: http://googlecode.blogspot.sg/2009/04/gmail-for-mobile-html5-series-using.html

Unfortunately it's not as easy as it looks. I found that out when doing research for a weekend project. Here's an excellent A List Apart article detailing all the gotchas you can face while working with it: http://www.alistapart.com/articles/application-cache-is-a-douchebag/. The Financial Times Labs have an interesting article talking about an approach to deploying an offline app that uses the AppCache as little as possible: http://labs.ft.com/2012/08/basic-offline-html5-web-app/

And of course you can find information about it in places like Dive into HTML5 and MDN, by simply searching for them

"What's the best language" is a sure fire way to not get any useful answers(because you'll get all possible answers) from a crowd of programmers, IMO.

What's "best" for what? Does the safety critical system need to be fast and respond to real time events in real time? Or is it safety critical but is allowed to be slow? What kind of hardware is it running on?

Depending on your hardware, the only safety critical language may be assembler, so you can check every single instruction and make sure it's precise.

Having said all that, Apollo 11's code was written in a meta-language, then compiled to assembly instructions, then hand-compiled into computer code. You don't get any more safety critical than taking the first men to the moon.

http://googlecode.blogspot.com.br/2009/07/apollo-11-missions-40th-anniversary-one.html

Your claim that it was ever meant to stay "an x86 sandbox" is contradicted by a lot of things, including the actual launch announcement for NACL:

http://googlecode.blogspot.com/2011/08/native-client-brings-sandboxed-native.html

"
The next milestone for Native Client is architecture independence: Portable Native Client (PNaCl) will achieve this by using LLVM bitcode as the basis for the distribution format for Native Client content, translating it to the actual target instruction set before running. "

I actually dislike PNaCL for a different set of reasons, but claiming it was built as an x86 sandbox, and meant to stay that way, is just revisionist history.
If you believed otherwise, it was, in fact, your misunderstanding.

http://www.chromium.org/spdy/spdy-whitepaper has data on improvements in lab tests.
http://googlecode.blogspot.com/2012/01/making-web-speedier-and-safer-with-spdy.html has a blurb where Google announces that they've made search (already highly optimized) faster with SPDY. This is a fascinating result, because this result was obtained after Google Search switched to using HTTPS, which typically makes websites slower, but in Google's case, made it faster because of SPDY.
Note that Twitter and Facebook have also adopted SPDY. I'd be rather skeptical that Google, Twitter, and Facebook would all switch to SPDY if there weren't real world benefits.