[Paper Review] File Managing and Program Execution in Web Operating Systems

Mario Bravetti|arXiv (Cornell University)|May 27, 2010

Service-Oriented Architecture and Web Services3 references3 citations

TL;DR

This paper proposes a middleware architecture for Web Operating Systems that extends traditional file and program management to use URLs instead of local paths, enabling client-side and server-side execution via a process algebraic model. The key contribution is a formal semantics using session-based communication and URL-based resource resolution, supporting secure, stateful program execution and workflow composition across distributed web resources.

ABSTRACT

Web Operating Systems can be seen as an extension of traditional Operating Systems where the addresses used to manage files and execute programs (via the basic load/execution mechanism) are extended from local filesystem path-names to URLs. A first consequence is that, similarly as in traditional web technologies, executing a program at a given URL, can be done in two modalities: either the execution is performed client-side at the invoking machine (and relative URL addressing in the executed program set to refer to the invoked URL) or it is performed server-side at the machine addressed by the invoked URL (as, e.g., for a web service). Moreover in this context, user identification for access to programs and files and workflow-based composition of service programs is naturally based on token/session-like mechanisms. We propose a middleware based on client-server protocols and on a set primitives, for managing files/resources and executing programs (in the form of client-side/server-side components/services) in Web Operating Systems. We formally define the semantics of such middleware via a process algebraic approach.

Motivation & Objective

• To address the growing need for persistent, device-agnostic application execution by shifting from local filesystems to URL-based resource management.
• To enable seamless execution of programs both client-side and server-side using unified URL-based addressing and session mechanisms.
• To formalize a secure, composable middleware for Web OS using process algebra, supporting dynamic workflows and access control.
• To overcome limitations of HTML-centric web technologies by promoting virtual-machine-based UIs for richer, OS-like application experiences.
• To integrate RESTful services, Comet-style real-time communication, and data binding for scalable, responsive Web OS applications.

Proposed method

• Designs a client-server protocol stack where programs and files are accessed via URLs, with execution modes determined by URL resolution and session context.
• Introduces a process algebra with constructs for remote execution ({\bf rexec}), local execution ({\bf lexec}), and session management using labeled communication.
• Employs a formal semantics with structural operational rules (Tables 1–6) that model state transitions for file access, program execution, and session creation/termination.
• Uses path matching and substitution mechanisms (e.g., $\theta_1, \theta_2$) to resolve relative URLs and bind execution contexts dynamically.
• Applies session typing and scope management (e.g., $\nu l\backslash{\bf session}\backslash{\cal S}$) to ensure type safety and prevent resource leaks.
• Implements a Java-based prototype supporting interface-based and RESTful web services, with Comet-based real-time communication and multiple data binding techniques.

Experimental results

Research questions

• RQ1 How can traditional operating system concepts of file management and program execution be generalized to use URLs instead of local paths?
• RQ2 What formal model can capture the semantics of client-side and server-side program execution in a Web OS environment?
• RQ3 How can session-based access control and secure resource sharing be integrated into a URL-based execution model?
• RQ4 What are the performance characteristics of different data binding and real-time communication patterns in such a Web OS middleware?
• RQ5 How can rich, standalone-like GUIs be supported without relying on HTML or browser-specific execution models?

Key findings

• The proposed middleware enables transparent execution of programs both client-side and server-side using a single URL-based addressing scheme, with relative paths resolved relative to the deployment context.
• The formal process algebra model supports secure, composable workflows through session typing and scope management, preventing unauthorized access and ensuring correct resource lifecycle.
• The implementation demonstrates feasibility of integrating RESTful services, Comet-style event streaming, and long-polling techniques for real-time application interaction.
• Performance evaluation shows that data binding methods vary in efficiency, with implications for choosing optimal binding strategies in Web OS applications.
• The architecture successfully decouples user interface rendering from execution logic, enabling high-fidelity, VM-based GUIs independent of browser limitations.
• The system supports dynamic, stateful execution with persistent sessions and secure access control through token-like mechanisms, enabling complex application workflows across distributed services.