Initial Thoughts

Time for a few pictures...
Roughly speaking, the concept separates the act of development into two part, the OS developer and the App developer. The OS developer would provide the services and the stage and the App developer much of the functionality.

The diagram above highlights what a Web OS may look like. The platform would boot on all devices via the web browser then proceed to load apps based on the users preferences from a store. The Web OS would have a stable API, such that App developers could build reliably for it and it would likely incorporate technologies such as jquery to help with browser abstraction. 

From the perspective of a large company all of these developers may work within the same organisation, but be distributed across multiple continents. This approach allows everybody to work independently on features without impacting each other. Apps can be built to communicate with each other via the Kernel, such that if one is not installed, the platform is tolerant and does not fail. It also does away with large build processes as the Web OS does not need to be aware of the Apps at build time. Everything is only available at runtime. 

Visually ( and taking a slightly Windows Phone view ) the Web OS would run something like this. The actual Web OS would be mostly invisible, providing limited UI features such as basic navigation ( think opening an App and closing an App ). The App would open full screen and would provide its own navigation inside, such as back, forward etc.

Whilst mulling this over some interesting enhancements to the original concept are Web Workers, where the App runs in a thread and therefore has no access to the Web OS memory or the DOM. This provides massive security benefits and performance benefits ( in that sloppy App programming would not hang whole thing and the Web OS can do some basic managing of Apps ). This does create a headache for creating a nice API for the App developer, so that working with the DOM is not cumbersome.

OS as a Design Pattern

For a while now, I have been thinking and tinkering with the concept of using operating system principals in a browser framework. The purpose and motivation behind this are: -

• Scalability for the software: Many we applications are built as a single solution with lots of developer changing code before a build process pulls it all together. This makes large scale deployment hard and large scale development even harder, as it is very easy to trip over each other. 
• Reduction in boiler plate code: Web Apps require a certain amount of boiler plate code to enable them work, which is then repeated over and over again. Frameworks can help but these tend to be more focused on the UI.  
• Improved integration: Web Apps deployed within an organisation struggle to communicate with each other and end up relying on adhoc solutions that are susceptible to breaking. 
• Security: Web Apps hosted in a portal style can easily scrape information from each other, especially if the developer has used global namespace to store information. 
• 3rd party integration: It is very difficult / impossible for a developer to create a small "app" for integration into a larger product. 

The vision would be something similar to FaceBook / the now defunct iGoogle, which allow 3rd parties to develop secure Apps to be hosted in a larger suite. Obviously the afore mentioned products are large, complex and unavailable for businesses to buy, but would it be possible to develop a similar solution, to allow business to run a platform that can then be customised for/by each individual via an web app market?

Over the next few months I plan to investigate this concept, in design and code, to make a working example and provide the source code open source. I welcome any thoughts and feedback you may have.