I was really wondering how bad Google is making the a feeling that things have got changed so rapidly. At the user end we’re not really feeling anything. Mozilla has changed their version from 3.6 to 4.0 with such a big changes from the previous version. If they would have changed the version as Chrome did, it would have reach some 10 at least. Still Google Chrome can’t meet the basic things like Hardware acceleration support for HTML5. Even recently I reported minor issues to Google Chrome[http://code.google.com/p/chromium/issues/detail?id=82525], which shows that how they’re greedy about showing the users that they’re doing something instead of making the product stable.
Fred Wilson’s story about deployment at Etsy was a great inspiration for me, though they, like Google, are deploying to their own servers:
I too was fascinated with the way Chrome was updated. I was always checking up on the latest iteration of Firefox/Chrome/Opera, but these are always just small changes so most of it is nothing to shake a stick at.
I have to agree, it would be nice to have an auto-update while the browser is open. Especially when I’m developing a site and got like ten tabs open.
There’s only one problem with web app auto-updates: app integrity. There’s no way I want my web server to be able to grab a zip, unpack it, and scribble all over its own code. If someone exploits the server to log in as apache, the document root should be read-only. If someone poisons the DNS, the server should not automatically install the attacker’s alleged update.
OTOH, I realize that there are operational difficulties with solving those problems: there are web hosts out there who chmod 777 everything you upload so they don’t have to support you when it’s broken. There are cheap web hosts that don’t provide shell access to have an out-of-band mechanism available for upgrades. There is no standard out-of-band “DO UPGRADE” command for the webapp to call out to. There are webapps which have plugin-like functionality that essentially consists of executing an XML file of patch instructions, meaning an upgrade would destroy your customizations. There is software which won’t install without having its directories world-writable, even though group-writable is sufficient and provided. People don’t (usually) get PGP keys out-of-band, and the server may not have the tools installed to verify the signature anyway.
It’s an ugly mess of problems.
Sounds like you want something like Ksplice, which updates a Linux kernel without needing to reboot: http://www.ksplice.com/
- Oli
I wish Flash and Java would switch to infinite versions. What misery it is to put up with their rude updating!
I don’t think Jeff wants an infinite version, he wants version singularity. I don’t like the idea. Hypothetical: the next build of whatever software you use gets released and it turns out to be absolute crap (unstable, insecure, design changes that you may not like), there would be nothing that you can do to prevent it from being installed. Of course he sees version singularity to be a strength because he’s a developer, but the enduser has lost all the power.
@OssoBucco I think the concern you have as an app consumer is relevant but not related to this subject. What you’ve described is poor support for a previous requirement in new versions. This problem might be a exacerbated by auto-update but certainly isn’t a cause of it. This is an issue with the vendor of the software that became crap not with the approach described here.
To make this clear if the software did not support auto update you would be able to stay on version 3 and not upgrade to version 4 which has become crap at fulfilling your requirements. However since all future security updates will be targeted at the current release you end up in just as crappy a situation as if you updated.
Bottom line is that this infinite version model will only work for apps that are very slow to deprecate features, and have a very good understanding of their requirements. Then it feels seamless to the user. It’s worth noting that even google isn’t there yet. I’ve spent the last week trying to figure out what is wrong with my chrome logo, and didn’t realize that it was an official change until I read this blog.
Murphy’s Law tells us that:
-
Your spreadsheet will come up with a redesigned interface just as you’re about to miss an important deadline.
-
Your operating system will refuse to boot after an automatic update just when your backups are most stale.
-
Your blog will be upgraded just when you’re handling a spike in traffic.
Ubuntu’s constant updates and difficulty in installing them- “oh no, you can’t upgrade to the latest ___ because your only one-year-old version of Ubuntu doesn’t support it”- pretty much turned me off Linux forever to Windows, which, AFAIK, still receives support for even the 10-year-old XP.
Arch, with it’s “just update the packages” philosophy, is the only distro I really like to work with. I’ve always wondered why most distros prefer versioned releases (which often go obsolete rather quickly resulting in you having to choose between out-of-date software or tedious update procedures) when they have a package manager capable of producing much easier rolling updates. Probably a marketing thing.
The wordress comparison is a bit off when calling it a “webapp upgrade”, because in that scenario you’re using yourself, a server administrator, to mean “the customer.” In that scenario, you’re installing software onto your computer so it is exactly like a fat app.
If you look from the perspective of your readers (also wordpress “customers”) they received the wordpress update without doing any work or restarting anything. Their experience could be like that of Google Docs.
And yet I still much prefer Opera in every single way because of the control it affords me without hiding it.
The one thing I hate about Chrome most of all is not being able to determine the install location. My stuff is organised and that breaks it.
I really think we should start hiding version numbers though. They aren’t important to the end user. Updates, no matter how small should be intelligently pushed to the user immediately. Give them an option to disable auto-updates and you’re done.
I think the reason live updating doesn’t work is likely a Windows “issue” (possibly even safety measure). I don’t know how Chrome functions specifically, but the only way I could think of doing it would be to create a new component (creates a small overhead) and choosing to now load those while the program is running and then next time the browser is started, replace the old ones with the new ones. Pretty expensive though and I’m not even sure if it can work as I’ve never even thought about it.
P.S.: Word filters are dumb.
Since Google Chrome’s tabs are all separate processes, barring the inherent difficulty of doing so, why don’t they do it like this:
- User opens Chrome and uses it.
- Google pushes update to user.
- Download finishes, user continues working unknowingly.
- User opens a new tab, Chrome uses the new version on that tab, keeping the old version running for remaining tabs.
- As the user closes tabs, the old version has less and less impact.
- Eventually, either all the old tabs are closed or the browser itself is shut down. At this point, the older engine can be removed.
Seems like you could use this to auto-update everything but the UI without a restart.
Even though Chrome must restart to apply the changes, it is still the quickest restart ever. I don’t really know what people are complaining about. Chrome even restores your session.
@Dwighthouse
This may not be possible if we need to update a statically linked library. Even if it has changed slightly, any tab that is open will explode when trying to access it.
People are never happy…
I’ve always been impressed with Chrome’s update mechanism. Most people don’t care to be bothered with update notifications. Some developers might complain, but if the whole update thing can happen silently (like in Chrome) it’s so much nicer for the average user.
In fact, Silverlight enables functionality that is very similar. Back when Silverlight 3 came out I was delighted to learn the details of its out-of-browser install/update mechanism. You’re free to code this however you’d like of course. But I chose to copy the Chrome way of doing things. My Silverlight app silently checks to see if there is an update when it first starts. If there is an update, the update is downloaded. When the app is restarted, the update is installed. It was an incredibly easy thing to code and like Chrome, it’s extremely fast & dependable.
As long as Google keeps making the right decision with each change they make to Chrome, people will love Chrome’s infinite upgrades. However, if Google gets things wrong, an infinite-upgrade system could become Chrome’s undoing. Few companies consistently make the right product-design decisions.
What if Windows Update had infinitely-upgraded the whole OS during the past 10 years? Imagine the horror of watching your beloved Windows XP machine as it slowly disfigured itself into Windows Vista. I bet the same power users (like me) who protested the phasing-out of XP would have fought to disable Windows Update (or considered Windows alternatives) in this alternate history. Instead, we were able to keep XP, wait out Vista, and give Microsoft a chance to get it right (or at least better) with Windows 7. Microsoft might not have had a second chance in an infinite-upgrade alternate timeline.
Infinite, mandatory upgrades reduce consumers’ available choices. It’d probably be best for a company to compete against its products’ old versions (and itself) than to make old versions unavailable and force annoyed customers to reconsider competitors’ alternatives. There are good reasons why sites such as OldVersion.com exist. ( http://www.oldversion.com/about.php )
As an independent desktop-software developer, I plan on making my programs’ old versions available for download indefinitely (with appropriate disclaimers and warnings for significant bugs). If I ever implement an infinite-upgrade system, I plan to make it easy for users to disable it on their own if desired. (I’d also give them the option of notifying me of this change, to help me become aware of their discontent and of missteps I may need to correct.)
Silent updates work for some type of programs and some type of updates. They cannot be a catch-all solution to software upgrading.
When Jeff says “To achieve the infinite version, we software engineers have to go a lot deeper” my only thought is to advise caution. You really don’t want to go there. You’ll quick understand that when you pretend to alter the program existing functionality or interface and smack that on the face of unsuspecting users. May even work for a browser (if you don’t care for the 30% that will be annoyed because they actually don’t like your changes but can’t go back). Where it definitely won’t work is for most productivity tools; like office suits, where your precious silent update can in fact disrupt users work.
Manual and automatic upgrades will remain a necessity. It’s not evil. It’s in fact beneficial and desirable for many types of software.
@Rebecca Putinski
No no! I love Chrome! I’m not complaining, I just didn’t know what was involved or if it was possible.
At least chrome is still better than IE ^^ http://boxhacker.com/blog/
Oh the irony: while reading this article a giant Firefox 5.0 Beta update requester popped up covering the screen.