How will this impact Web Development?

This largely depends on what kind of web development you do. In most
cases you and your enterprise won’t be affected in the slightest.
Chrome has a very fast and robust rendering and JavaScript engine, and
much like any newly released browser (remember Firefox 1.0?) loads up
in no time flat. The rule of thumb is that if you’re already supporting
Safari, you can safely assume you’re supporting Chrome.

Why is this? What you may not know is that the underlying  engine that Safari runs on is a package called WebKit,
which is the same engine which powers Google Chrome. There are some
revision based incompatibilities (Since Safari’s already a few versions
ahead), but practically speaking they’re identical. The downside of
this is that if your agency is one of the rare islands left that only
support the “Two Major Browsers” (Firefox and Internet Explorer), you
no longer have an excuse to not support them.

If you’re doing Rich Internet Application development, you’ve just
been presented with a very interesting way of taking your application
to the desktop. You might not have heard of Google Gears
before now, or might not have considered it to be a viable option.
Gears is a browser extension framework that allows desktop-application
like interaction between your RIA and the client’s computer. Sounds
neat, right? It is, and it’s directly integrated into Chrome and is
available as a plugin for both IE and Firefox. Unfortunately, the major
restriction of Gears up to this point was that you were still
restricted to the browser’s UI, but as I point out later in this
article this is no longer entirely the case.

What about Mobile?

If you’re doing Mobile Web Development, you may be able to target
WebKit directly from this point forward. See, Safari is the exclusive
browser on the iPhone, and with the upcoming release of the T-Mobile HTC Dream,
you can bet that Chrome will be the default browser for Android. What
this means is that WebKit will become the de-facto web development
standard for mobile devices. While mobile UI patterns and application
frameworks will shake themselves out over the next few years, the
writing’s on the wall: If you want to take RIA’s to mobile devices
without bothering with a native application, WebKit is the platform to
build for.

So What’s The Big Deal™?

At this point you’re probably asking yourself: "What’s the big
deal"? If Chrome behaves much like the other major browsers out there,
why is there so much buzz about it? Is this just Google Hype?

Without going into a lot of gritty detail  about it (The Comic Book
published by Google does that really well), the major big deal is that
Chrome is not just a Browser: Chrome is an Application Platform.

Much like AIR, Chrome attempts to blur the lines between the desktop
and the web by creating a wrapper for previously developed content.
They even do it in very similar ways: AIR allows the execution of
JavaScript RIA’s in an integrated WebKit Browser running within the
ActionScript Virtual Machine, while Chrome allows the execution of
Flash RIA’s running in the Flash Player. The difference is simply the
technology stack used- Chrome is based around JavaScript and HTML,
while AIR is based on ActionScript and MXML.

The Google Engineers are quite explicit about this. The Comic Book
talks about it, and one of the primary features is "Create Application
Shortcut". While functionally this really just creates a direct link to
a specific website, the integration of Google Gears allows some
websites to move almost entirely to your desktop. It even goes so far
as to use the favicon for your application icon, giving you a Desktop
Application experience for any website you choose (try it with Google
Calendar or Gmail).

So what’s the Big Deal? It’s a concept change, a different way of
looking at the Web. It’s not particularly new- Microsoft tried to do
this with the close Windows/Internet Explorer integration in the late
90′s and .chm/.hta applications, but it is the first time that the
browser’s been turned into a (soon to be) platform agnostic application
wrapper.

A Future Vision

Not to be a crazy futurist or anything, but consider the following
possibility: Both Google and Adobe have now firmly cast their lot in
with an ECMAScript/DOM-like technology stack, and we already know that
there is a close relationship between the two companies both from
YouTube and from the indexable headless player. Personally, I think
it’d be pretty interesting if the future held a technological
convergence of all ECMAScript languages. Compiling HTML to a desktop
application? Converging JavaScript and ActionScript into a single
ECMAScript language? It’s all possible.