Chrome OS created a whole slew of buzz around the Web finally being an OS. There are many other examples of this of course. On the desktop we have had the likes of moblin and Jolicloud for quite some time. On the phone we have webOS.

The Web as a virtual machine

In many ways, it seems obvious that this will happen. When I look at my desktop, I often find it looking like this:

which looks surprisingly similar to this:

Wait a minute. Can’t you look at the browser as being a virtual machine for the Web? A hugely successful one that has been ported to almost every platform known to man. It is a viral virtual machine that has become so successful due to its simple yet powerful constructs that allowed the platforms to do the porting (oh and it was friggin made to be free! Take that gopher!). As a virtual machine it grew so fast that it is quickly usurping the hosts themselves. The traditional operating systems. Applications are being written for the VM rather than the OS. This is very different to the diagram that has Windows running inside a VM on the Mac. In that case you are running applications written for Windows on the Mac. The virtualization crew have done wonders to make that emulation possible. With the Web you didn’t quite need those tricks, and instead thanks to Web standards, you just had to write a browser.

Going inside out

Normally, we have seen systems built natively and then we virtualize them. In the case of the Web, the “Web platform” is the host environment and the VM. As this environment has become stronger and stronger, there is bound to be the time to ask “do we need our host anymore?” We are on the fringe of that time right now where a huge bulk of the applications that people use are Web based.

I just ran an experiment in this area myself. The hard drive in my Macbook Pro died and while the kind folks at the local Apple store replaced it I had to pick up a random machine for use. What would life be like if I had to work on a random machine? I purposely didn’t restore from my own backup, and ended up with a week seeing how much of this cloud thing I use.

It turned out that all of the apps that weren’t somehow cloud based were now a pain in the arse. Obviously I could get my email with Gmail and the other Web apps were there. However it went further than that. I could download Tweetie and be instantly up and running where I left off (thanks to the fact that Twitter is just a Web service). I got to see which IM servers did a good job keeping my server based contacts, and what a pain it is when you make changes on the local client to tell you that flubber65 is Frank and suddenly you have no idea who anyone is without that (NOTE: if you build a service, for gods sake save everything up there!).

It even made me happy for Bespin, as I was able to get to a bunch of my code. That has incentivized me to help make Bespin great :)

So, I learned that Web based services won. I was productive on a random machine in minutes, and cursed the situations where this wasn’t the case (mainly around development).

If the entire OS was Web based, with a rich cloud infrastructure, then I could literally login to any machine and be ready to roll. X Windows productivity will be back! :) This will greatly change the role of devices too. Seamless upgrades. Multiple devices sharing data. Fun times.

So, Web OS it is. Hopefully the Web platform will be complete enough, and where it isn’t this kind of force behind it will push it even faster (this is why I am excited to see the space heat up, and also wanting to keep a watchful eye to see how things get standardized with crazy timelines behind them).

What do we lose?

But, wait a minute. We have seen that virtual machines are actually pretty awesome. Having an entire system in a single file that I can suspend, backup, and run multiple off? Cool. I am running multiple “Web OS’s” every day (Firefox, Safari, Chrome). I can update them whenever I want, and they can compete.

We also see fantastic features where we can watch over all of the connections from the virtual machine to the host. Tweak how ethernet works, set limits on various usage, etc. Just as we are getting amazing things out of virtual machines…. maybe we don’t need the Web platform to move from there just yet.

User-Agent

Chris Beard (Chief Innovation Officer at Mozilla) is often talking about what it means for the browser to be the “users agent”. There is so much that the s/browser/virtual-web-machine/g can be doing for us, and we have only just begun.

We need to be wary of losing out on any of these thoughts if the Web becomes the OS on the computer (whatever that means, of course!).

As we think about Jetpack and granting enhanced functionality from Web apps to browser-chrome I am often thinking about a morphing browser. When I am on Gmail, I don’t need the URL bar and all of that jazz. Instead, add new Gmail specific UI for me to use, and let me tie into the local system for contacts etc.

In that vein, it has been nice to see a step in that direction when listening to Alexander Limi speak about UX in Firefox last week. He and the UX team showed some concept mockups for future versions of Firefox such as this:

By the “home” tab you can imagine other tabs that are for applications. Thin tabs that just have an icon (e.g. an email notification icon showing new message counts). These “app tabs” can be slightly magical. The user has to bless them, and at that time can grant special powers to access local services such as a File API, or a Webcam, or Geo location, or [insert cool thing that native apps can do]. This feels like a small step for the browser, but one that can open up a lot.

In conclusion, I am bullish about the Web being called the ‘OS’ on certain computing devices. I am most excited about seeing this driving innovation into the Web platform as a whole, and also exploring the great side of having a platform run as a virtual machine on your hardware. Gotta love the Web :)

The web’s advantages are its low barrier to entry for content production, and its version-free always up-to-date distribution model. The web’s downside is the general inadequacy of its technology and its deep reliance on networking availability.

As the downsides get fixed, it’s going to displace solutions without the advantages. This to me is inevitable, unless the other platforms manage to solve the distribution and production problems. So I do think the odds are in the web’s favor that it’s going to make operating systems irrelevant in many cases, reducing them to a role similar to kernels and drivers.

I agree with Dion and Joeri – I think the cards are strongly stacked in favor of web-based OS’s taking over.

It’s interesting how things go in cycles – you used to have the ‘mainframe + dummy terminal’ model, which was replaced by the PC model of computers that did their own processing and ran independently (but could be networked), which in turn will be replaced by a ‘web + cloud’ model that looks a lot more like the ‘mainframe + dummy terminal’ model (cloud = mainframe, and web OS = dummy terminal).

I think Web OS is a misleading title for what it is. Certainly Web Applications will become more common, but those who call it a Web OS forget what an Operating System really is: hardware abstraction and memory management. The line might be blurred a little bit in the future, but I don’t see the whole operating system being on the web since a) that would require much more collaboration between services than there is right now and b) the browser and web standards in general would have to become much more powerful than they are now seeing as you have extremely limited contact with hardware and filesystem resources right unless you use something like Flash or an Applet as a medium to do that. Javascript also needs to become much faster and probably will need direct video access in the future to compete with desktop applications as well. It will also need threading and such to do anything worth doing rather than hacky delayed callback functions. The web has a long way to go before it’s an actual operating system and everything operates on it.

I write code in Delphi and in Javascript/PHP. I’m roughly as productive in both environments, and I write the same types of applications. Delphi talks directly with the OS, Javascript only with the browser. The difference for me (writing forms-based business apps) is minimal. I deal mostly with the database anyway, not with local files.

The change is going to come in classes of applications. As the web toolchain matures, more and more classes of applications will make sense to move to the web. Right now, for traditional business forms apps, it’s starting to become a no-brainer. For simple games, it’s also starting to make a lot of sense (you see the success of a lot of simple web games these days). With google docs and microsoft office for web, we’re also seeing office productivity slowly get to the point where it “prefers” being web-based. It’s all a matter of time, and the driving force behind it all is the central hosting model, which IT admins love.

Terminals failed because they couldn’t match PC’s in capability and because the networks of then weren’t good enough. The situation is different now. The networks are fast and ubiquitous, and the browser is not a terminal, it can do more (it can even go offline).

Like Sun before, Google is now fueling that confusion about what an OS is. No browser can run without an OS under it (even Chrome). Thus, a browser is not an OS.
What a browser is is an execution environment. It may emulate some aspects of an OS but it really isn’t. It’s much closer to the .NET or Java runtimes.
Has anyone ever claimed that Java was an OS?

@Dion: I hope this isn’t a revolutionary concept to you :) These thoughts have been bandied about by many of us for a long time. That aside, I think you’re right, this is where we’re headed.

@WillPeavy: I noted the same cycle in my first book a couple of years ago… especially if, like me, you’ve spent some (thankfully fairly minimal!) time in the mainframe world, you can see the cycle even more clearly.

@kjordan2001: I totally agree that JavaScript needs to get faster, but that’s happening naturally already. We’re also getting multithreading without plugins soon (already here in some browsers? haven’t checked recently), so that’s being taken care of too. Your other concerns, file access, memory management, etc., are answered by thinking of things differently. It sounds like you have some familiarity with OS architecture, which is good… think of all the parts of a typical OS… now think about what it would mean if that code ran remotely… you can still have memory management, but it’s managing memory essentially living elsewhere… the file system, well, it’s a file system in the cloud. In fact, theoretically, you could simply write a new HAL and build your OS on top of it, assuming the APIs were clean. Now, I’m not suggesting anyone literally should do that… as you point out, the asynchronous nature of the web would make this not feasible (or, at best, horribly bad performing). That’s kind of what is being done here though. As an FYI, I spent a few months working on my own web-based OS, part of which involved developing a relation database-based file system… but, the programming API that an application was coded against looked suspiciously like any FS API you’ve ever seen in a real OS :) In fact, I wrote a Java-based command line shell that looked just like any shell you’ve ever seen, but the commands you executed were running on a remote server against data stored in a database.

@BertrandLeRoy: I disagree that no browser can run without an OS underneath it… that may be true of current browsers as you know them, but imagine a browser that, essentially, has a Linux kernel bolted to it. The boot loader loads this “browser”, complete with kernel, and that *IS* your OS. This isn’t new, it’s been done before (laziness is keeping me from going to Google to state a reference), and I think this is exactly what Google’s Chrome-based OS will basically be. Without all the “cruft” of an OS in between the browser and the metal, we may find that performance of a web-based application in that environment (one that is a “sovereign webapp”, with its data hosted in the cloud I suspect) runs pretty much like any native app you know and love.

I’m only posting because, like I mentioned, I’ve done some work in this space and it’s a topic I’m extremely interested in because, like Dion, I do see it as our future… just a question of how long it takes to get there and what the final form is. It’s not a new concept to be sure, but it’s one who’s time I think is almost here (I suspect five years is about the right timeframe for when we finally see a true, complete, “Web OS”, not some proof-of-concept or early prototype, but something we recognize as an OS and are willing to use and even pay for).

In the cases of both JavaOS and ChromeOS, what you really have is an OS that is restricted to one runtime. Let’s not kid ourselves, that does not make Java or the browser an OS, it bolts an OS onto Java or the browser.
I don’t really see what benefit there is in an OS that can only run one application.
Especially as there are fully capable, free OS out there. What can possibly be the real intent here? mmmh. I wonder… :)

@BertrandLeRoy: That’s the case if you view the browser as JUST an application… surely that’s true when you have Windows of Linux or OSX underneath… but if you incorporate into the browser the bare minimum code needed to deal with the hardware directly, and then load that browser when the computer starts up… almost as if it were the operating system… hmm… :)

What constitutes an operating system after all? Certainly, some sort of abstraction layer above the hardware for one… memory and task management… communications stack(s)… an API that applications can be written against to gain access to services offered by the OS (and by extension, the hardware)… a storage system, usually in the form of a file system… those are probably the key areas.

Now, let’s look at a browser… say Chrome more specifically… doesn’t have the hardware abstraction… DOES have memory and task management… DOES have a communications stack (granted, it’s sitting on top of the OS’s stack)… DOES offer an API that applications can be written against… DOES offer storage (HTML5 database, even cookies)…

Seems to me, if it had the hardware part you could make a pretty compelling argument that it’s an operating system. I’d bet you could take a Linux kernel, with just a little more around it, marry it to Chrome…

…hmm, someone should go tell Google ;)

If you go along with all that, then it becomes quite easy to see how any webapp looks exactly like a native app on Windows or Linux or OSX does today. In fact, you don’t even have to be abstract about all of this: go take a look at Palm’s webOS. It’s pretty much EXACTLY what I just described. It’s a Linux core with a web browser engine (WebKit) above it that all applications run in.. note the differentiation between this and the web browser application that the end user uses… the later is actually itself a webapp running inside the runtime provided by the core WebKit engine that really constitutes what you could probably term “user space” in the operating system … granted, Palm has some currently private ways to talk directly to the hardware that most of us can’t play with in our webOS applications, but that’s kind of like the Windows shell as compared to, say, Firefox: the shell probably is using some things that Firefox and most other applications can’t (at least, I wouldn’t be shocked to find that was the case).

Bottom line: in the case of webOS, the browser engine + the Linux core *IS* the operating system. They have been, effectively, fused together to form a single operating system, which is, as I understand, what Google is doing with ChromeOS, or whatever it winds up being called. Once you get the idea that a browser (engine) plus a little more can be an operating system, it starts to become pretty obvious what we’re talking about.

Well, yeah, what you get when you combine a browser with the essential parts of an OS does contain the essential parts of an OS and could be called an OS as a whole. Duh. Doesn’t make the browser part an OS.
But while it makes sense to do that on a pocket device such as Palm’s (although the iPhone shows it’s not even necessary any more (although it was the initial programming model (and it sucked))), you have got to question the motivation to do the same thing on a full-blown computer, because doing so, you are *restricting* the user’s options for no good reason that I can see (at least no reason that is good for the consumer).

@BertrandLeRoy: I don’t agree, and with all due respect, I think you’re not quite getting it. Let me try it another way…

The browser, on its own, is not an OS. I would agree with you on that point. What the browser is though is analogous to, say, the Win32 API. You would agree that Win32 is in fact part of the Windows operating system, would you not?

Assuming so, just extend the thought: below Win32 is more “stuff”, the more traditional “core” parts of the OS, but all of it taken together form the operating system.

What we’re talking about is no different than if you swapped out Win32 for a browser. You’d simply be coding your apps to a different API (an entirely different *kind* of API I admit, but the idea still holds).

I don’t at all agree that this is restricting user’s options in any way, shape or form. Windows apps are written using Win32 (although not necessarily directly: MFC and .Net are, essentially, abstractions above Win32). This hasn’t proven to be a limitation… except perhaps when it comes to games, where more bare metal approaches are often required. Even there, with ever-increasing hardware power, the needs continues to decrease.

If you instead mean restricting in terms of what is possible in a browser versus a native app, that’s certainly fair… there’s no question web technologies aren’t quite on-par with what you can do with a native app. I think that delta is shrinking day by day though and it’s not far-fetched to say there will come a time when the difference is virtually nonexistent.

I think it’ll be telling whether Palm’s webOS winds up a success or not. That will, I think, indicate whether the idea is viable or not (assuming Palm doesn’t simply screw the pooch in some way). Obviously, Google thinks the idea has merit, that’s why they’re going in the same general direction. Not that Google is infallible, but you have to give credence to anything they think is a good idea. Ultimately, as I said earlier, time will tell… there’s a bit of a mental shift that has to accompany this, especially the part about cloud-based computing, which is perhaps the larger part of this discussion that we’ve both kind of side-stepped :)

The salient feature of web browsers has always been that they were (supposed to be) sandboxes by design. What happens in the browser stays in the browser — it stays outside of my OS and away from my files. Browsing the web has no side effects except when I explicitly upload/download a file. When that line is blurred, people will start demanding sandboxes inside browsers.

Browser vendors are beginning to realize that fusing the web with the OS and fusing web content with browser chrome is not necessarily a good thing. It was browser vendors who killed <bb>.

@randomrandom
We already have a mixed model. You go to websites, click a link, and install an application that can do anything to your system. We know that the application and the web site are very different things, but many users see only the blurriest of distinctions (they have to click one icon instead of another). Applications like Adobe Air make the whole thing even blurrier, making local apps out of web sites. (Incidentally, Air has a fatal flaw in that it no longer uses the web site as a central metaphor, which negates many of the benefits of the web stack.)

I do not think the browser-only OS (like palm’s webos) is going to replace windows, os x and so on for general computing any time soon. There’s too much existing software to be replaced. It is however going to become the standard API to program to, across all OS’s.

I think what you should be looking at is what type of model a browser based OS would bring, as opposed to the traditional OS.
Is it only going to be another thin-client concept or something else? If so, there’s nothing new on the table. We’ve had that back when IE4 came out, starting with intranets and kiosks.
Is it only going to be a rich, sandboxed, web-driven app? If so, we’ve tried it numerous times in the past, with Microsoft’s HTA, Java’s WebStart, Mozilla’s XULRunner and now Adobe’s AIR. The critical misstep is getting buy-in and offering enough bang to counteract native apps.
It’s not like iPhone apps which went from zero to a million, because they have a good platform, a good audience, and most importantly, a good monetization model to get everyone doped up.
Does the browser bring another set of concepts and conventions that users would not be familiar with?
For example, websites are not grey looking rectangular boxes, nor are they built with a consistent and well-defined set of widgets. It’s going to take a whole lot of JavaScript whizbang to mimic the native scroll table component without eating all your RAM and the closest participant, ExtJS, still has a lot of steps to climb. If we’re going to play the web app game, then we’re going to need a paradigm shift to get people to get used to the web app philosophy. And I don’t mean just getting participation, I mean trust as in treating web apps on equal footing to native apps.
What is the difference between a website with offline persistence (using Gears) and a “hide the navigation bar” appearance (using Prism), compared with a native app with online sync support?
Answer: one is controlled by Microsoft and one isn’t.

Hmm now what would Chrome OS be?? Google is currently working hard on the Wave platform which is build upon an extension on the XMPP protocol. The original XMPP allows a server push and isn’t bound to some sort of restricted HTTP one way traffic. My guess is, that Chrome OS fully implements the wave protocol besides HTTP and will open a whole new window for event driven web application.

The cool thing is that a month ago google also published the pubsubhubbub protocol. It’s a simple observer protocol but together with wave and the desktop as a client….. It’s only just beginning :)

@fzammetti: Ah, the usual “with all due respect, you don’t get it” argument.
Win32 is a much lower level API. Actually, it’s pretty much the lowest-level available on Windows (more accurately, there are various layers in win32, but it does contain the lowest-level one). In that respect, it’s the actual first abstraction between the hardware and the applications, which is the definition of an OS. A browser (or any other programming model) necessarily has to build on win32 or on the local equivalent.
Now if you hide that first layer under, say, a browser and prevent any access to it, what you are doing is locking developers into your One True Programming Model.
It seems to be a common tendency nowadays: Apple’s iPhone EULA for example even prevents the development of alternative programming models or frameworks on top of theirs.
On Windows, Linux or MacOS, you can use the browser, gcc, Python, ObjectiveC, .NET, Java, Flash, Air and a few hundred other programming environments. It seems like all the new OS that appear nowadays have at most one or two and try to lock anything else out. That is a tendency I don’t like.
Cloud programming is just the means to a goal here.

“A browser (or any other programming model) necessarily has to build on win32 or on the local equivalent.”

That’s the statement I believe to be incorrect.

I don’t know your background, but I know mine: I did A LOT of low-level programming years ago. In fact, I actually wrote my own (very) rudimentary OS some years back. I wrote the bootstrap code, I wrote the code that knew how to talk to a file system, I wrote the code that knew how to talk to the video subsystem, and I wrote the code that was the API an application talked to that sat above all that (I didn’t do any networking code back then, nor did I do a lot of other things typical of an OS… like I said, VERY rudimentary, but you could boot a PC up with it off a floppy and run simple applications with it, no Windows, Linux or anything else involved at all).

Now, take a browser engine… what does it need? Clearly it needs network capabilities, and it needs video capabilities, and it needs some sort of storage system, probably some sort of file system (although, you could imagine it being all memory-based, but that doesn’t seem too likely). In other words, it needs, at a fundamental level, very little beyond what my little OS provided. If I were to take WebKit and add it to my OS’s code base, that’s all I’d need to create a “browser-based” operating system (not sure WebKit is *that* flexible, but I’m talking theory here, I’m not about to do this!)

I don’t necessarily have to build on top of Win32, or any other API… a browser doesn’t inherently have to be one application running within an OS, it can be the ONLY application, and it’s not a stretch to say at that point that it IS the OS because it is then the API applications are written to. Imagine if the Windows GUI shell was instead a browser. Similar conceptually.

You are correct in saying that browsers as they exist today, by and large, need an OS underneath them. I think it’s incorrect to say that they necessarily need that though.

“Now if you hide that first layer under, say, a browser and prevent any access to it, what you are doing is locking developers into your One True Programming Model.”

But that happens quite naturally as a result of abstractions.

Think about Windows 95, since it’ll be easier to illustrate with that version… you had BIOS and DOS APIs that Windows 95 was built on top of. Part of Windows 95 was Win32, an API that was an abstraction above those DOS and BIOS calls. You no longer cared, as an application developer, what was below Win32, that was the API you wrote to (the one you were “locked into”, effectively).

Now jump to Windows XP… DOS and BIOS APIs are replaced (well, DOS is at least, not sure about BIOS) with a different layer of code, but its still underneath Win32, so applications don’t (generally) care.

Now, .Net came along, an API that was an abstraction above Win32. Now when you write a .Net app, you don’t care about Win32, and you certainly don’t care about the layers beneath it. This is the very definition of abstraction and the whole point to APIs. Why is this a bad thing? It certainly isn’t new.

If your argument is that an application CAN be written to layers below the “primary” API on a general-pupose computer, then you’re talking about a matter of choice and I’d generally agree that I don’t like choice being taken away from me. But, I’d counter that this isn’t at all unusual and really has never been. It’s the way complex systems of any sort are build: layer by layer, and you stop thinking about the layers beneath the top-level layer (mostly) as you move up the abstraction ladder.

A browser above Win32 or .Net or whatever else is just another level of abstraction, another API, another layer that lets you ignore the layers below, and that’s kind of the whole point.

“It seems like all the new OS that appear nowadays have at most one or two and try to lock anything else out. That is a tendency I don’t like.”

I generally agree, and I certainly don’t like when an Apple has legal clauses in the EULA that stops you from building your own layer on top of what they provide. That seems wrong to me too, and it’s things like this that make me very much NOT a fan of Apple.

But, that’s a legal issue, not a technical one. Well, mostly… Apple tries to technologically enforce the legal, which effectively makes it a technical issue, but fundamentally I mean, it’s really not a technical issue. I know that I won’t develop for the iPhone unless these sorts of restrictions are lifted, just on principal, and I’d hope that others that agree with the basic thought here wouldn’t either. It’s why I’ve never owned a Mac and I believe never will, I’m just not onboard with things like what you point out in their EULA (I’m not much more happy with Microsoft incidentally, there’s just a certain arrogance in everything Apple does that I can’t get past… now I’m off on a tangent though!).

It also might be true that to properly address the security and technical issues involved in building a TRUE browser-based, cloud-living operating system that you have to give up some of the flexibility and multiple APIs available to us as developers… I guess we won’t know the answer to that for sure until afterwards… certainly webOS would seem to support that thought.

@fzammetti: yes, I’m talking about choice and I think we mostly agree on that. We’ll see what Google does and I’m willing to give them the benefit of the doubt, but the idea of limiting what the OS can do to running a browser seems like a step backwards for users and developers because you can only build upwards, not sideways or downwards from this abstraction level. As there are OS out there that are both free and not crippled, I don’t see where the progress is in that…

> the idea of limiting what the OS can do to running a browser seems like a step backwards for users and developers

I disagree. First, browser capabilities are getting greatly enhanced through the standards bodies and things like gears, jetpack, 3d in the browser, css animations, etc. that they can do most of what an app requires.

Second, I don’t think the *vast* majority of users would see it as a step backwards. Their only concern is having lots of apps that are easy to use, and easy to install. Look at the iPhone platform.

I think google will incorporate some model of a user in their OS, like current phone OS’s do. On your OS you have the ability to compile anything you want from source, but can you write a program that gets a line of input from a user and display it reversed on screen. How could you possibly write this incredibly simple program cross platform today? I don’t even know how I would do it on my mac, without ensuring my end user has growl installed, has quicksilver and some scripts installed, isn’t afraid of the terminal, etc.

I’d greatly prefer the constraints of having single javascript way to do this, rather than having the power to write an implementation in gtk or qt or swing or dotnet. Gears and Jetpack are making good API’s and user interfaces for these kind of common tasks, the fact that they’re simple and on a much more ubiquitous platform (with distribution built in) makes them much more powerful to me.

This is exactly why Opera has become my primary browser. My work OS is Linux, and i have use Macbook at home. But my bookmarks, and notes are all synched with Link and my work and personal emails and contacts are synched via IMAP. (I only wish it had Feed synchronization, both of subscribed feeds and read/unread entries.)

For most service-based applications, the good ones usually follow the same pattern:
1) Have a fast, responsive OS-specific UI,
2) But store data “in the cloud”,
3) And provide generous APIs for mash-ups and third-party applications (e.g. iPhone apps, Dashboard Widgets, iGoogle/Yahoo widgets, embeddable HTML-based widgets, Web-framework plugins, …),
4) And usually provide a default, basic web-based UI as well.

We use cookies and other similar technologies (Cookies) to enhance your experience and to provide you with relevant content and ads. By using our website, you are agreeing to the use of Cookies. You can change your settings at any time. Cookie Policy.