Rethinking Operating Systems: Shifting from User-Centric to Job-Centric Models

Operating systems (OS) have long been designed with the end user in mind. Abstractions such as files, directories, GUIs, and even text editors exist to simplify human interaction with machines. However, as computational workloads grow increasingly specialized and automated—driven by AI, cloud computing, and edge devices—this user-centric paradigm feels outdated and inefficient for job-focused operations.

In this article, we explore a radical rethinking of the OS model, one where the primary unit of abstraction is not the user or their files but the job itself. By jobs, we mean computational tasks: data processing pipelines, machine learning model training, sensor data aggregation, and other operations designed for machines to execute autonomously.

Why User-Centric Abstractions Are Obsolete for Jobs

Traditional OS abstractions like files, folders, and even processes have roots in the days when the primary user of a computer was a human. These abstractions prioritize usability over efficiency, creating overhead in environments where human interaction is minimal. For instance:

• Files: The notion of files and directories is a convenience for humans, but for machines, these abstractions are cumbersome. Jobs often deal with raw streams of data, serialized objects, or other formats that don't need to adhere to a human-readable file system.
• User Spaces: User permissions, sessions, and GUIs are irrelevant in systems running tasks without human intervention. The overhead of managing these abstractions could be eliminated to streamline task execution.
• Processes and Threads: While these abstractions are foundational, they don't necessarily align with the concept of discrete jobs. Jobs often span multiple nodes in a distributed system, interacting across threads and processes in complex ways that existing OS paradigms struggle to manage seamlessly.

Toward a Job-Centric Operating System

A job-centric OS would shift the focus from users and their files to the computation itself. This rethinking involves reimagining core OS components to prioritize jobs as first-class citizens.

1. Job-Specific Abstractions

Jobs should replace processes as the fundamental unit of operation. A job would encompass all resources, states, and dependencies needed for execution, abstracting away traditional notions like files and sockets. Jobs could include:

• Input and output streams
• Task graphs representing dependencies
• Resource requirements (e.g., GPU, memory)
• State checkpoints for recovery

2. Data as Streams, Not Files

Instead of files, data would be managed as streams. A stream-first design treats all input and output as continuous flows of data, which can be pipelined, transformed, and processed in real time. This aligns well with modern workloads like AI training and IoT, where the concept of a static "file" is unnecessary.

3. Resource-Centric Scheduling

Rather than assigning resources to users or processes, the OS would schedule resources for jobs based on their requirements. The scheduler could dynamically allocate CPUs, GPUs, and memory based on job needs, supporting fine-grained resource sharing and prioritization.

4. Job-Oriented Networking

For distributed workloads, a job-centric OS would natively support seamless job migration, inter-node communication, and resource pooling. Networking would be an integral part of the OS kernel, enabling direct communication between jobs running on different nodes without middleware.

5. Event-Driven System Design

Jobs should be reactive and event-driven. The OS would operate as a large state machine, executing jobs based on events like data arrival, resource availability, or job completions. This would eliminate the need for constant polling and reduce idle resource consumption.

6. Kernel Simplification

A job-centric OS kernel could strip away much of the user-facing overhead, focusing solely on low-latency, high-throughput job execution. Features like GUIs, user authentication, and file system management could be relegated to optional, user-space components.

Challenges in Realizing a Job-Centric OS

Transitioning to a job-centric OS model is not without challenges:

1. Compatibility: Existing software stacks rely heavily on traditional OS abstractions. Bridging the gap between the two paradigms would require emulation layers or hybrid systems.
2. Complexity of Jobs: Representing jobs as unified entities could be challenging due to their heterogeneity. A machine learning job differs significantly from a data aggregation pipeline.
3. Security: Removing user-centric abstractions risks exposing jobs to potential attacks if not carefully isolated. Securing inter-job communication would be critical.
4. Adoption: Convincing the industry to adopt a fundamentally different OS paradigm would require demonstrating significant performance and usability benefits.

A Glimpse of the Future

Imagine a distributed computational cluster running a job-centric OS. A data scientist submits a training pipeline as a single job, specifying input streams, resource needs, and output requirements. The OS schedules tasks across nodes, streams training data from sensors in real-time, and dynamically adjusts resource allocation as jobs progress. There are no files, no user sessions, and no manual intervention—just pure computation optimized for machine-centric operations.

By shedding legacy abstractions and embracing a hardcore, machine-first mindset, we can unlock new levels of efficiency and scalability in computational systems. The future of operating systems isn’t about making machines easier for humans—it’s about making machines better for themselves.